具有的功能：
1
class long(object):
同int型
3.float型
1.返回分子分母数构成的元祖

2.将十六进制数转换为浮点数

3.将浮点数转换为十六进制数

4.判断浮点数是不是整数
1
2
3
f1 = 10.2
f2 = 10.0
print(f1.is_integer())31print(f2.is_integer())
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

二.字符串
具有的功能：

1.首字母变大写

2.内容居中

3.查询个数
1
2
3
4
5
6
7
count(self, sub, start=None, end=None)子序列个数 sub：要查询的子序列 start：开始位置 end：结束位置
例：
>>> cou = ‘asdfghjasdfgjqweryuzxcvbnm‘
>>> print (cou.count(‘as‘))
2
>>> print (cou.count(‘as‘,1,25))
1
4.编码修改
1
2
3
4
5
6
encode(self, encoding=None, errors=None）编码，针对unicode  encoding=‘解码的格式‘
例：
>>> name = ‘刘耀‘
>>> print (name.encode(‘gbk‘))
b‘\xc1\xf5\xd2\xab‘
>>>
5.endswith
1
2
3
4
5
6
7
endswith(self, suffix, start=None, end=None)是否以xxx结尾 suffix：填入结尾的字符串  start=在第几个字符开始  end=在第几个字符结束
endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
例：
>>> name=‘asdfghjklo‘
>>> print (name.endswith(‘lo‘,0,6))
False
>>>
6.expandtabs()
1
2
3
4
5
expandtabs() 方法把字符串中的 tab 符号(‘\t‘)转为空格，默认的空格数 tabsize 是 8
例：
>>> extab = ‘one\ttwo‘
>>> print (extab.expandtabs())
one     two
7.find
1
2
3
4
5
6
7
find(self, sub, start=None, end=None)寻找子序列位置，如果没找到，返回 -1
例：
>>> name = ‘yaotwosiji‘
>>> print (name.find(‘two‘,1,8))
3
>>> print (name.find(‘two‘,1,3))
-1
8.casefold
1
2
casefold(self)大写转小写 注：3.x新增方法，2.x没有
例：
9.format格式化
1
2
3
4
5
6
format(*args, **kwargs)字符串格式化
例:
>>> name = ‘liuyao‘
>>> age = ‘21‘
>>> print (‘姓名{0},年龄{1}‘.format(name,age))
姓名liuyao,年龄21
10.index
1
2
3
4
5
6
7
8
9
index(self, sub, start=None, end=None)子序列位置，如果没找到，报错
例：
>>> name = ‘asdfghjklqwertyui‘
>>> print (name.index(‘fg‘))
3
>>> print (name.index(‘fg‘,1,3))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
11.isalnum
1
2
3
4
5
6
7
8
isalnum(self)如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
例：
>>> zifu = ‘yao1995‘
>>> print (zifu.isalnum())
True
>>> zifutab = ‘yao 1995‘
>>> print (zifutab.isalnum())
False
12.isalpha
1
2
3
4
5
isalpha(self)如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
例：
>>> zifutab = ‘yao‘
>>> print (zifutab.isalpha())
True
13.isdigit
1
2
3
4
5
isdigit(self)如果字符串只包含数字则返回 True 否则返回 False
例：
>>> shuzi = ‘1995‘
>>> print (shuzi.isdigit())
True
14.islower
1
2
3
4
5
islower(self)如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
例：
>>> zifu = ‘Liuyao‘
>>> print (zifu.islower())
False
15.isspace
1
2
3
4
5
isspace(self)如果字符串中只包含空格，则返回 True，否则返回 False
例：
>>> kongge = ‘    ‘
>>> print(kongge.isspace())
True
16.istitle
1
2
3
4
5
istitle(self)如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False
例：
>>> zifu = ‘Liu Yao‘
>>> print (zifu.istitle())
True
17.isupper
1
2
3
4
5
isupper(self)如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
例：
>>> zifu = ‘LIU YAO‘
>>> print (zifu.isupper())
True
18.join
1
2
3
4
5
6
join(self, iterable)返回通过指定字符连接序列中元素后生成的新字符串
例：
>>> lj = ‘^‘
>>> name =(‘y‘,‘a‘,‘o‘)
>>> print (lj.join(name))
y^a^o
19.ljust
1
2
ljust(self, width, fillchar=None)返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串
例：
20.lower
1
2
3
4
lower(self)返回将字符串中所有大写字符转换为小写后生成的字符串
>>> name = ‘LIUYAO‘
>>> print (name.lower())
liuyao
21.lstrip
1
2
3
4
lstrip(self, chars=None)返回截掉字符串左边的空格或指定字符后生成的新字符串
>>> name = ‘liuyaoliuyaoliuyao‘
>>> print (name.lstrip(‘liu‘))
yaoliuyaoliuyao
22.partition
1
2
3
4
partition(self, sep)返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串
>>> who = ‘wo shi liuyao‘
>>> print (who.partition(‘shi‘))
(‘wo ‘, ‘shi‘, ‘ liuyao‘)
23.replace
1
2
3
4
5
6
replace(self, old, new, count=None)返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次
>>> str1 = ‘ni shi wo shi shei shi‘
>>> print (str1.replace(‘shi‘,‘ta‘))
ni ta wo ta shei ta
>>> print (str1.replace(‘shi‘,‘ta‘,1))
ni ta wo shi shei shi
24.split
1
2
3
4
5
6
split(self, sep=None, maxsplit=None)通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串
>>> str1 = ‘a1 b2 c3 d4‘
>>> print (str1.split())
[‘a1‘, ‘b2‘, ‘c3‘, ‘d4‘]
>>> print (str1.split(‘ ‘,2))
[‘a1‘, ‘b2‘, ‘c3 d4‘]
25.splitlines
1
2
3
4
5
6
7
8
9
10
11
12
13
splitlines(self, keepends=False)按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行
>>> str1 = ‘\na1b2 c3 d4‘
>>> str1 = ‘\na1b2\nc3\nd4\n‘
>>> print (str1)
    
a1b2
c3
d4
    
>>> print (str1.splitlines())
[‘‘, ‘a1b2‘, ‘c3‘, ‘d4‘]
>>> print (str1.splitlines(2))
[‘\n‘, ‘a1b2\n‘, ‘c3\n‘, ‘d4\n‘]
26.startswith
1
2
3
4
5
6
startswith(self, prefix, start=None, end=None)用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查
>>> name = ‘LIUyao‘
>>> print (name.startswith(‘LI‘))
True
>>> print (name.startswith(‘ya‘))
False
27.swapcase
1
2
3
4
swapcase(self)用于对字符串的大小写字母进行转换
>>> name = ‘LIUyao‘
>>> print (name.swapcase())
liuYAO
28.translate
1
translate(self, table, deletechars=None)根据参数table给出的表(包含 256 个字符)转换字符串的字符, 要过滤掉的字符放到 del 参数中，table -- 翻译表，翻译表是通过maketrans方法转换而来，deletechars -- 字符串中要过滤的字符列表。
29.upper
1
2
3
4
upper(self)将字符串中的小写字母转为大写字母
>>> name = ‘yaoyao‘
>>> print (name.upper())
YAOYAO
30.zfill
1
2
3
4
5
6
zfill(self, width)返回指定长度的字符串，width -- 指定字符串的长度。原字符串右对齐，前面填充0。
>>> str1 = ‘a1 b2 c3 d4‘
>>> print (str1.zfill(10))
a1 b2 c3 d4
>>> print (str1.zfill(15))
0000a1 b2 c3 d4

三.列表
具有以下方法：
1、追加
1
2
3
4
5
append(self, p_object)用于在列表末尾添加新的对象，obj -- 添加到列表末尾的对象，该方法无返回值，但是会修改原来的列表。
>>> lie =[1,2,3,4,5]
>>> lie.append(6)
>>> print (lie)
[1, 2, 3, 4, 5, 6]
2、统计
1
2
3
4
count(self, value)用于统计某个元素在列表中出现的次数，value -- 列表中统计的对象，返回元素在列表中出现的次数。
>>> lie = [1,2,3,4,5,1,2,3]
>>> print (lie.count(2))
2
3、合并

4、索引
1
2
3
4
5
index(self, value, start=None, stop=None)用于从列表中找出某个值第一个匹配项的索引位置，value -- 查找的对象，该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。
>>> list1
[1, 2, 3, 4, 5, ‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘f‘]
>>> print (list1.index(‘a‘))
5
5、指定插入

6、删除最后一个元素

7、指定删除
1
2
3
4
5
6
remove(self, value)用于移除列表中某个值的第一个匹配项，value -- 列表中要移除的对象，该方法没有返回值但是会移除两种中的某个值的第一个匹配项。
>>> list1
[1, 2, ‘6‘, 3, 4, 5, ‘a‘, ‘b‘, ‘c‘, ‘d‘]
>>> list1.remove(5)
>>> list1
[1, 2, ‘6‘, 3, 4, ‘a‘, ‘b‘, ‘c‘, ‘d‘]
8、反向存放
1
2
3
4
5
6
reverse(self)用于反向列表中元素，该方法没有返回值，但是会对列表的元素进行反向排序。
>>> list1
[1, 2, ‘6‘, 3, 4, ‘a‘, ‘b‘, ‘c‘, ‘d‘]
>>> list1.reverse()
>>> list1
[‘d‘, ‘c‘, ‘b‘, ‘a‘, 4, 3, ‘6‘, 2, 1]
9、排序

10、反序
1
sorted内建函数：对序列进行反序，并返回一个列表
四.元祖

元组的意义：
元组可以在映射中当作键使用；
元组作为很多内建函数和方法的返回值存在。
元组的元素是不能被修改，但元素的元素能可以被被修改的
具有以下方法：
1.统计
1
2
3
4
5
>>> boy=(‘kelin‘,‘yaoyao‘,‘liuyao‘,‘shabi‘)
>>> type(boy)
<class ‘tuple‘>
>>> boy.count(‘yaoyao‘)
1
2.索引
1
2
>>> boy.index(‘liuyao‘)
2
五.字典
当数据量达到上百万时，循环字典就不适合用dict.items()，因为首先会把一对对key和value转化为列表，然后在循环遍历输出，会增加内存使用。建议使用如下：
1
2
3
4
5
6
7
>>> a = {1:‘a‘,2:‘b‘}
>>> for k in aa:print(k,aa[k])
(1, ‘a‘)
(2, ‘b‘)
>>> for k in aa.keys():print(k,aa[k])
(1, ‘a‘)
(2, ‘b‘)
具有以下方法：
1、删除字典内所有元素
1
2
3
4
5
6
7
clear(self)用于删除字典内所有元素，该函数没有任何返回值。
>>> dic = {‘k1‘:‘v1‘,‘k2‘:‘v2‘}
>>> dic
{‘k2‘: ‘v2‘, ‘k1‘: ‘v1‘}
>>> dic.clear()
>>> dic
{}
2、浅复制
1
2
3
4
5
copy(self)返回一个字典的浅复制。
>>> dic = {‘k1‘:‘v1‘,‘k1‘:‘v2‘}
>>> dic.copy()
{‘k1‘: ‘v2‘}
>>>
3、get
1
2
3
4
5
get(self, k, d=None)返回指定键的值，如果值不在字典中返回默认值，key -- 字典中要查找的键，default -- 如果指定键的值不存在时，返回该默认值值。
>>> dic = {‘k1‘:‘v1‘,‘k2‘:‘v2‘}
>>> dic.get(‘k1‘)
‘v1‘
>>>
4、has_key
1
has_key(self, k)用于判断键是否存在于字典中，如果键在字典dict里返回true，否则返回false，k -- 要在字典中查找的键。注：3.x已删除该函数
5、items
1
2
3
4
items(self)以列表返回可遍历的(键, 值) 元组数组。
>>> dic={‘name‘:‘yaoyao‘,‘age‘:‘21‘,‘job‘:‘IT‘}
>>> dic.items()
dict_items([(‘age‘, ‘21‘), (‘name‘, ‘yaoyao‘), (‘job‘, ‘IT‘)])
6、iteritems
1
iteritems(self)项可迭代。注：3.x已删除该函数
7、iterkeys
1
iterkeys(self)key可迭代。注：3.x已删除该函数
8、itervalues
1
itervalues(self)value可迭代。注：3.x已删除该函数
9、keys
1
2
3
4
keys(self)以列表返回一个字典所有的键。
>>> dic={‘name‘:‘yaoyao‘,‘age‘:‘21‘,‘job‘:‘IT‘}
>>> dic.keys()
dict_keys([‘age‘, ‘name‘, ‘job‘])
10、删除键
1
2
3
4
5
6
pop(self, k, d=None)获取并在字典中移除，k -- 要在字典中查找的键。
>>> dic={‘name‘:‘yaoyao‘,‘age‘:‘21‘,‘job‘:‘IT‘}
>>> dic.pop(‘job‘)
‘IT‘
>>> dic
{‘age‘: ‘21‘, ‘name‘: ‘yaoyao‘}
11、popitem

12、setdefault
1
2
3
4
5
setdefault(self, k, d=None)如果key不存在，则创建，如果存在，则返回已存在的值且不修改
>>> dic={‘name‘:‘yaoyao‘,‘age‘:‘21‘,‘job‘:‘IT‘}
>>> dic.setdefault(‘sex‘)
>>> dic
{‘sex‘: None, ‘age‘: ‘21‘, ‘name‘: ‘yaoyao‘, ‘job‘: ‘IT‘}
13、更新

14、values
1
2
3
4
values(self)以列表返回字典中的所有值。
>>> dic={‘name‘:‘yaoyao‘,‘age‘:‘21‘,‘job‘:‘IT‘}
>>> dic.values()
dict_values([‘21‘, ‘yaoyao‘, ‘IT‘])
15、viewitems
1
viewitems(self)所有项，只是将内容保存至view对象中。注：3.x已删除该函数