二、数据类型的常用方法

1.python中的一切皆对象

2.type查看对象的类型

3.dir（类型名）查看类中提供的所有功能

4.help（类型名）查看类中详细的功能

5.help（类型名，功能名）查看类中某功能的详细

 

类里面的方法有两种：带下划线的称为内置方法，不带下划线的称为非内置方法

 

int型常用方法：

1.返回x的绝对值
x.__abs__()《=========》abs(x)
2.两数相加
x.__add__(y)<=======>x+y的值
3.两数相与
x.__and__(y)<=========>x&y的值
4.比较两数大小
x.__cmp__(y)<========>cmp(x,y)<===========>x小于y，返回-1；x大于y，返回1，相等，返回0；
5.强制生成一个元组
x.__coerce__(y)<=======>coerce(x,y)
6.相除，得到商和余数组成的元组
x.__divmod__(y)<====>divmod(x,y)
7.相除，得到商
x.__div__(y)<======>x/y 5.0/2=2.5
8.转换为浮点类型
x.__float__()<======>float(x)
9.地板除
x.__floordiv__(y)<====>x//y 5.0//2=2.0(整型和相除一样)
10.加空格
x.__format__("10")《===》 在x的值前面加了10个空格
 

字符串常用方法：

1.字符串格式化
name = 'I am {0},age {1}' name.format('rooney',28)
name = 'I am {ss},age {dd}' name.format(ss='rooney',age='28')
 
2.字符串格式化（放入列表）
li=['ramos',32](元组同理)
name = 'I am {0},age {1}' name.format(*li) ========》将列表li的值依次放入name中
 
dic = {'ss':123,'dd':456}
name = 'I am {ss},age {dd}' name.format(**dic) ========>将字典dic的值放入name中，键值与name的占位字符相对应
 
3.返回下标，find
name = 'rooney'
>>> name.find('e')
4
>>> name.find('o',0,2)
1
>>> name.find('s')
-1
 
总结：找到则返回下标，没有找到则返回-1
 
4.返回下标,index，find没有找到返回-1，index没有找到会报错。
>>> name.index('o')
1
>>> name.index('e')
4
>>> name.index('s')
Traceback (most recent call last):
File "<pyshell#25>", line 1, in <module>
name.index('s')
ValueError: substring not found
 
5.是否是字母和数字
>>> name = "rooney123"
>>> name.isalnum()
True
>>> name = "&*%"
>>> name.isalnum()
False
6.是否是字母
isalpha
7.是否是数字
isdigit
8.是否小写
islower
9.是否是空格
isspace
10.字符串转换为标题(即首字母大写)
s.title()
11.是否是标题
istitle
12.是否全部都是大写
isupper
13.join连接
列表连接转换为字符串
>>> li
['s1', 's2', 's3', 's4', 's5']
>>> '__'.join(li)
's1__s2__s3__s4__s5'
14.center，ljust，rjust =====》分别为居中，左对齐，右对齐
 
>>> name
'python'
>>> name.center(20,'*')
'*******python*******'
>>> name.ljust(20,'=')
'python=============='
>>> name.rjust(20,'+')
'++++++++++++++python'
 
15.变小写，变大写，大小写互换
>>> name
'RaMos'
>>> name.lower()
'ramos'
>>> name.upper()
'RAMOS'
>>> name.swapcase()
'rAmOS'
 
16.lstrip,strip,rstrip =====>分别为去除左侧，左右两边，右侧空格
 
17.partition ======>分割，变成前，中，后三部分
>>> s1="helloworld"
>>> s1.partition('ll')
('he', 'll', 'oworld')
 
18.replace ======>替换
>>> s1.replace('ll','TT')
'heTToworld'
 
19.split =====>字符串指定分割符变为列表
>>> name = 'hello world'
>>> name
'hello world'
>>> name.split(' ')
['hello', 'world']
20.format ========>格式化字符串
>>> s = "I'm {},{}"
>>> s.format('jinbao',' hello,everybody')
"I'm jinbao, hello,everybody"
 

 列表与元组类型常用方法：

x = ['add','aardvark','abalone','acme','aerate']
x.sort(key=len) ======>根据字符串长度来排序
>>> x
['add', 'acme', 'aerate', 'abalone', 'aardvark']

字典类型常用方法：

dic = {'k1':1234}
添加内容
dic['k2'] = 5678
 
>>> dic = {'k1':1234}
>>> dic
{'k1': 1234}
>>> dic['k2'] = 5678
>>> dic
{'k2': 5678, 'k1': 1234}
 
字典的key值不可以是列表，可以是元组，也可以是系统的当前时间（datetime.datetime.now()）,但是千万别这样用，特别不推荐，推荐使用数字，字符串，类的实例。
 
 
判断是否是字典（列表，元组，字符串等等是一样的）：
>>> type(dic) is dict
True
 
 
方法：
1.get =====>获取value值，比较dic['k1']的区别是用get方式获取一个不存在的key键的时候不会报异常,返回的是None
 
>>> dic
{'k1': 1234}
>>> dic.get('k1')
1234
>>> dic['k1']
1234
>>> dic.get('k2')
>>> dic['k2']
Traceback (most recent call last):
File "<pyshell#59>", line 1, in <module>
dic['k2']
KeyError: 'k2'
 
>>> dic.get('k2','ok') =====》如果k2在字典里不存在，我让它返回ok，默认是None
'ok'
 
2.clear ===>清空字典
>>> dic
{'k2': 5678, 'k1': 1234}
>>> dic.clear()
>>> dic
{}
 
3.fromkeys ==========>给定一个列表和value,然后依次用列表里面的值当做key,value当做值
>>> dic.fromkeys(range(1,3),"rooney")
{1: 'rooney', 2: 'rooney', 3: 'rooney'}
 
 
 
>>> c = {}
>>> c
{}
>>> for i in range(5):c[i] = []
 
>>> c
{0: [], 1: [], 2: [], 3: [], 4: []}
>>>
 
 
 
4.items(self) ==========>把一个字典变成了列表，并且键和值分别在列表里面又组成了一个元组，这个主要是用于循环取的key和值的时候用。
>>> dic
{'name': 'rooney', 'age': 19}
>>>
>>> dic.items()
dict_items([('name', 'rooney'), ('age', 19)])
 
 
>>> for k,v in dic.items():print (k,v) ======》小数据量循环的时候可以用这种（10000条以内），大数据量循环的时候千万别用这种，因为它会先把字典转换成列表，数据量小的时候没什么影响，数据量一大，就会很慢
name rooney
age 19
 
 
 
>>> for k in dic:print (k,dic[k]) ========>数据量大的时候应该用这种，推荐无论数据量大小，都用这种
 
name rooney
age 19
 
 
5.keys（） ======》取得字典中所有的键值
>>> dic.keys()
dict_keys(['name', 'age'])
 
6.pop() ======>出栈，删除age，并且把age的值返回回来
>>> dic
{'name': 'rooney', 'age': 19}
>>> dic.pop("age")
19
>>> dic
{'name': 'rooney'}
 
 
7.popitem() ======>从开始往后删，尽量不要用
 
>>> dic
{'tel': 13874445888, 'name': 'rooney', 'age': 18}
>>> dic.popitem()
('tel', 13874445888)
>>> dic.popitem()
('name', 'rooney')
>>> dic
{'age': 18}
 
8.setdefault =======》如果这个值存在则返回，如果不存在则创建
>>> dic
{'age': 18}
>>> dic.setdefault("name","rooney")
'rooney'
>>> dic
{'name': 'rooney', 'age': 18}
>>> dic.setdefault("name","ramos")
'rooney'
>>> dic
{'name': 'rooney', 'age': 18}
 
 
9.update =======》合并两个字典，将dic2合并进dic中，如果两者都存在同样的键，那么dic2的值将覆盖dic的值
>>> dic
{'name': 'rooney', 'age': 18}
>>> dic2
{'qq': 1305858, 'country': 'china', 'tel': 13874188888}
>>> dic.update(dic2)
>>> dic
{'country': 'china', 'qq': 1305858, 'tel': 13874188888, 'name': 'rooney', 'age': 18}
 
10.values ======》查看所有的值，跟keys相对
 
11.copy ======》转到浅拷贝与深拷贝里里去详细解释

集合类型常用方法：集合是字典的一个变种，其中一个主要功能是去重:

>>> a = list(range(5,10))
>>> a
[5, 6, 7, 8, 9]
 
>>> b = list(range(7,12))
>>> b
[7, 8, 9, 10, 11]
 
set是设置集合
 
c=set(a)
>>> c = set(a)
>>> c
{8, 9, 5, 6, 7}
 
 
>>> d=set(b)
>>> d
{8, 9, 10, 11, 7}
 
取交集：
>>> c & d 《========》c.intersection(d)
{8, 9, 7}
 
取并集：
>>> c | d
{5, 6, 7, 8, 9, 10, 11}
 
反交集：
>>> c ^ d
{5, 6, 10, 11}
 
c里面有，d里面没有的：
>>> c-d
{5, 6}
d里面有，c里面没有的：
>>> d-c
{10, 11}