目录
文件读取引深... 3
1.参数... 3
2.按字节读取... 3
Str 字符串：不可变数据类型... 3
1.首字母大写capitalize. 3
2.casefold/lower全部小写upper全部大写title每个单词首字母大写... 4
3.center居中... 4
4.count计数... 4
5.encode编码转换... 4
6.以..为结尾... 5
7.以..为开头... 5
8.expandtabs制表符: 找到/t总体加上前面字符总体替换为20个字符... 5
9.find/rfind查找... 5
10．Index/rindex查找... 6
11.format字符串格式化，占位填充... 6
12.format_map字符串格式化，传字典... 6
13.isalnum:判断是否只有文字或数字，不包含其他字符（包括空格）... 6
14.isalpha 判断是否为文字，包括中文英文... 7
15.isdecimal判断是否为纯数字（多语言数字）... 7
16.isdigit判断是否为纯数字0-9（总结前面几个区别）... 8
17.isidentifier:是否是合法标识符... 8
19.isnumeric. 8
20.isupper是否是大写... 8
21.isprinttable是否只包含可打印字符... 8
23.istitle是否是首字母大写... 9
24.join:字符串拼接... 9
25ljust/rjust左右填充... 9
26.strip/lstrip/rstrip去空白... 10
27.maketrans对应翻译... 10
28patition/rpatition分割但是保留分割元素... 11
29.split分割不保留元素... 11
30.replace替换... 11
31swapcase大小写对换... 11
32.splitlines:按照\r\n分割，返回包含各行元素的列表... 11
List列表... 12
1.append:增加... 12
2.clear清空... 12
3.copy拷贝（浅拷贝）... 12
4.count计数... 12
5.extend扩展... 12
6.index查找元素所在位置... 13
7.insert插入... 13
8.pop取出并返回值... 13
9.remove删除... 13
10.reverse反转... 13
11.sort排序（欠参数）... 14
12切片（左闭右开）... 14
range. 14
Enumerate. 15
元组：tuple，不可变类型也不能被修改... 15
方法：index/count. 15
如果元组里面有可变类型，可以修改可变类型... 15
字典：dict，可变类型... 16
1.clear清空... 16
2. copy浅拷贝... 16
3.fromkey(两个参数)，第一个参数作为字典键，第二个作为值（可省略）... 16
4.get获取字典值，如果没有key就输出后面的值，如果有就输出值... 17
5.items/keys/values. 17
6.Pop删除并获取... 17
7.Popitem随机删除并获取对应键值对... 17
8setdefault如果有原值不变，没有增加... 17
9update批量增加或修改... 18
字典的说明：... 18
集合：set，不可重复的列表，可变类型... 18
1.都可以通过set变成集合... 18
2.add. 19
3. clear. 19
4. copy. 19
5.difference输出一个集合与其他集合不同的元素... 19
6.difference_update使集合变成与其他集合的差集... 19
7.discard删除元素，如果不存在不报错... 20
8.intersection交集... 20
9．idisjoint查看两个集合之间是否有交集... 20
10.issubset判断是否是子集... 20
11. issupperset判断是否是父集... 21
12.pop删除集合中任意一个元素... 21
13.remove删除... 21
14.union合集，新变量接收合集... 21
15.update合集，集合本身变成合集... 21
16. symmetric_difference两个集合差集的合集（对称差集）... 22
17 symmetric_difference_update. 22
文件读取引深
1.参数
""" Character Meaning
--------- ---------------------------------------------------------------
'r' open for reading (default)
'w' open for writing, truncating the file first打开文件会清空文件内容
'x' create a new file and open it for writing
'a' open for writing, appending to the end of the file if it exists追加模式打开
'b' binary mode二进制模式
't' text mode (default)
'+' open a disk file for updating (reading and writing)
'U' universal newline mode (deprecated)通用换行模式，该模式会吧所有换行符（\r,\n,\r\n）都替换为\n,不加‘rU’不会因为系统不同而换行不同"""
f1 = open('db','r',encoding='utf-8')#utf-8格式进行解码译码
date = f1.read()
f1.close()
print(date)
2.按字节读取
f1 = open('db','rb')
date = f1.read()
f1.close()
print(date)
输出结果：b'\xe5\x95\x8a'
以b开头的都是二进制格式的输出，只不过这里用了16进制以节省空间
Str 字符串：不可变数据类型
1.首字母大写capitalize
name = ' alex'
v = name.capitalize()
print(v)
v1 = name.title()
print(v1)
输出结果： alex
Alex
Ps：如果有空格则caipitalize不会首字母大写，而且首字母变成大写，其他会变小写。AA_vSèAa_vs
2.casefold/lower全部小写upper全部大写title每个单词首字母大写
name = " ALex"
v = name.lower()#只支持英文字母
print(v)
v1 = name.casefold()#支持其他语言大写变小写
print(v1)
3.center居中
name = 'alex'
v = name.center(20,'^')#默认用’^’填充，长度一共为20，如果后面不写，默认用空格填充
print(len(v))
print(v)
输出结果：20
^^^^^^^^alex^^^^^^^^
4.count计数
name = 'aabbssnnnwwnnss'
print(name.count('a'))#计算a出现的次数
5.encode编码转换
name = '郑思宇'
v = name.encode(encoding='gbk',errors='no')#error报错用的，如果编码失败，则爆出什么异常。error后面就是异常提示信息
v1 = name.encode(encoding='utf-8')
Print(v1)
print(v)
输出结果： b表示字节表示
b'\xd6\xa3\xcb\xbc\xd3\xee'
b'\xe9\x83\x91\xe6\x80\x9d\xe5\xae\x87'
6.以..为结尾
name = 'Alex'
v = name.endswith('x')
print(v)
输出结果：True
7.以..为开头
name = 'alex'
v=name.startswith('s')
print(v)
8.expandtabs制表符: 找到/t总体加上前面字符总体替换为20个字符
table_name = 'name\tage\ndodo\t18'
print(table_name)
print(table_name.expandtabs(20))#使制表位变成10位，如果不写，默认为8位
输出结果：
name age
dodo 18
name age
dodo 18
ps：name+\t一共二十个，只算前面的字符加上\t
9.find/rfind查找
name = 'alex'
v = name.find('a')
v1 = name.find('ss')
print(v)
print(v1)
输出结果：
0
-1
Ps：找得到返回索引位置，找不到返回-1
10．Index/rindex查找
name = 'alex'
v= name.index('l')
name.index('ss')
print(v)
ps：找的到返回索引位置，找不到抛出异常
11.format字符串格式化，占位填充
message = "name：{0},age：{1}"
p_out = message.format('dodo','18')
print(p_out)
message = "name：{name},age：{age}"
v= message.format(name='aaa',age=18)
print(v)
12.format_map字符串格式化，传字典
message = "name：{name},age：{age}"
v = message.format_map({'name':'dodo','age':17})
print(v)
13.isalnum:判断是否只有文字或数字，不包含其他字符（包括空格）
test1 = 'assd123'
test2='awq@dd12'
test3='12345567'
test = ''（空）
print(test1.isalnum())
print(test2.isalnum())
print(test3.isalnum())
print(test.isalnum())
输出结果：
True
False
True
False
14.isalpha 判断是否为文字，包括中文英文
test1 = 'assd123'
test2='awq@dd12'
test3='12345567'
test4='aasd'
test = ''
test6='s是s'
print(test1.isalpha())
print(test2.isalpha())
print(test3.isalpha())
print(test.isalpha())
print(test4.isalpha())
print(test6.isalpha())
输出结果：
False
False
False
False
True
True
15.isdecimal判断是否为纯数字（多语言数字）
test1 = 'assd123'
test2='awq@dd12'
test3='12345567'
test = ''
test4='aasd'
print(test1.isdecimal())
print(test2.isdecimal())
print(test3.isdecimal())
print(test.isdecimal())
print(test4.isdecimal())
输出结果：
False
False
True
False
False
16.isdigit判断是否为纯数字0-9（总结前面几个区别）
test5 = '二'
print(test5.isdigit())
print(test5.isdecimal())
print(test5.isalnum())
输出结果：
False
False
True
17.isidentifier:是否是合法标识符
# str = 'class'
# print(str.isidentifier())
18.islower是否是小写
19.isnumeric
num = '②'
v1 = num.isdecimal() # '123'
v2 = num.isdigit() # '123'，'②'
v3 = num.isnumeric() # '123'，'二'，'②'
print(v1,v2,v3)
输出结果:
False True True
20.isupper是否是大写
21.isprinttable是否只包含可打印字符
name = 'aaa\nbbb'
print(name.isprintable())
输出结果：包含了\n
False
22.isspace是否只包含空白字符
name=' '
name1 = ''
name2='ww'
print(name.isspace())
print(name1.isspace())
print(name2.isspace())
输出结果：
True
False
False
23.istitle是否是首字母大写
24.join:字符串拼接
name= 'alex'
v='_'.join(name)#会循环每一个元素
print(v)
输出结果;
a_l_e_x
name1 = ['alex','dodo','eric']
v1='_'.join(name1)
print(v1)
输出结果：
alex_dodo_eric
25ljust/rjust左右填充
name = 'aaa'
v=name.ljust(10)
print('\''+v+'\'')
print(len(v))
print(name.ljust(10,'^')
输出结果
'aaa '
10
'aaa^^^^^^^'
26.strip/lstrip/rstrip去空白
27.maketrans对应翻译
s = 'abcdefabghicjk'
m = str.maketrans('abc','123')#m只是一种对应关系
s1 = s.translate(m)
print(s1)
输出结果：
123def12ghi3jk
28patition/rpatition分割但是保留分割元素
29.split分割不保留元素
s = 'asdsk?jdfjk?fdkjd'
print(s.split("?"))
print(s.partition("?"))
输出结果：
['asdsk', 'jdfjk', 'fdkjd']
('asdsk', '?', 'jdfjk?fdkjd')
30.replace替换
s = 'aassccaassdd'
print(s.replace('a','A',3))# replace(self, old, new, count=None):
输出结果：
AassccAassdd
31swapcase大小写对换
name='Alex'
print(name.swapcase())
输出结果：
aLEX
32.splitlines:按照\r\n分割，返回包含各行元素的列表
name = 'alen\n\n\t'
print(name)
print(name.splitlines(keepends=False))#默认为false
print(name.splitlines(keepends=True))
输出结果：
alen
['alen', '', '\t']
['alen\n', '\n', '\t']
List列表
1.append:增加
name = ['a','b']
name.append('a')
print(name)
ps：列表是有序的，append加到最后一个
2.clear清空
name.clear()
print(name)
3.copy拷贝（浅拷贝）
v = name.copy()
print(v)
4.count计数
v=name.count('a')
print(v)
5.extend扩展
v = name.extend(name)
print(v)
name.extend(name)
print(name)
输出结果：
None
['a', 'b', 'a', 'b', 'a', 'b', 'a', 'b']
Ps：可变类型调用函数后改变的是本身
6.index查找元素所在位置
name = [1,3,5,6,7]
v=name.index(6)
print(v)
输出结果：3
7.insert插入
语法结构：insert(self, index, p_object):
name.insert(1,'w')
print(name)
输出结果：[1, 'w', 3, 5, 6, 7]
8.pop取出并返回值
语法结构：pop(self, index=None)，
Ps：如果不写索引值，默认删除最后一个
name = [1,3,5,6,7]
v = name.pop(2)
print(name)
print(v)
输出结果:
[1, 3, 6, 7]
5
9.remove删除
语法结构：remove(self, value)
name = [1,3,5,6,7,'sd']
name.remove('sd')
print(name)
10.reverse反转
name.reverse()
print(name)
输出结果：['sd', 7, 6, 5, 3, 1]
11.sort排序（欠参数）
name = [2,4,5,51,1]
print(name.sort())
print(name)
print(name.sort(reverse=True))
print(name)
输出结果：
None
[1, 2, 4, 5, 51]
None
[51, 5, 4, 2, 1]
Ps：排序改变的是本身，返回为none
12切片（左闭右开）
name = [2,4,5,51,1]
print(name[0:3])
输出结果: [2, 4, 5]
PS:左闭右开
range
num_list = []
for i in range(1,10) :#左闭右开
num_list.append(i)
print(num_list)
num_list.clear()
for i in range(1,11,2) :#两个一输出
num_list.append(i)
print(num_list)
输出结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 5, 7, 9]
# range可以循环字符串
usr_list = ['alex','eirc','dodo','meme']
for item in range(0,len(usr_list)) :
print(item,usr_list[item])
输出结果：
0 alex
1 eirc
2 dodo
3 meme
Enumerate
enumerate额外生成一个有序的数字
usr_list = ['alex','eirc','dodo','meme']
for i,v in enumerate(usr_list):#后面还可以加参数，索引，表示从哪开始
print(i,v)
输出结果：
0 alex
1 eirc
2 dodo
3 meme
元组：tuple，不可变类型也不能被修改
方法：index/count
name = ('alex','eric','dodo')
v = name.count('alex')
v1 = name.index('eric')
print(v)
输出结果：
1
1
如果元组里面有可变类型，可以修改可变类型
name = ('alex','eric','dodo',['a','b','c'])
name[3][1]='B'
v = name.count('alex')
v1 = name.index('eric')
print(name)
print(v)
输出结果
('alex', 'eric', 'dodo', ['a', 'B', 'c'])
1
name = ('alex','eric','dodo',['a','b','c'])
name[3].append('d')
print(name)
输出结果
('alex', 'eric', 'dodo', ['a', 'b', 'c', 'd'])
字典：dict，可变类型
1.clear清空
v = {'name':'elad',
'age':19,
'gender':'boy'}
print(v.clear())
输出结果：None
2. copy浅拷贝
v1 = v.copy()
或者直接输出v.copy,都对v进行了拷贝
3.fromkey(两个参数)，第一个参数作为字典键，第二个作为值（可省略）
dic = dict.fromkeys('a',122)
print(dic)
输出结果：{'a': 122}
# dic = dict.fromkeys(['k1','k2','k3'])
# print(dic)
输出结果
{'k3': None, 'k2': None, 'k1': None}
# dic = dict.fromkeys(['k1','k2','k3'],123)
# dic['k1'] = 'asdfjasldkf'
# print(dic)
输出结果：{'k2': 123, 'k3': 123, 'k1': 'asdfjasldkf'}
Ps:字典是无序的
4.get获取字典值，如果没有key就输出后面的值，如果有就输出值
dic = {'k1':'v1','k2':'v2'}
v = dic.get('k111',1111)
print(v)
输出结果：
1111
v1
ps:如果没有key就输出后面的值，如果有就输出值
5.items/keys/values
For 循环，循环items取出的是键值对，循环key去key，循环value取value
6.Pop删除并获取
v = {'name':'elad',
'age':19,
'gender':'boy'}
m = v.pop('name')
print(m)
print(v)
输出结果：
elad
{'age': 19, 'gender': 'boy'}
7.Popitem随机删除并获取对应键值对
m = v.popitem()
print(m)
输出结果：
V里面随机一对
8setdefault如果有原值不变，没有增加
m = v.setdefault('lenth',180)
print(v)
print(m)
输出结果
{'age': 19, 'lenth': 180, 'gender': 'boy', 'name': 'elad'}
180
Ps:注意m的值
m = v.setdefault('name','alex')
print(v)
print(m)
输出结果：
{'name': 'elad', 'age': 19, 'gender': 'boy'}
Elad
9update批量增加或修改
dic = {'k1':'v1','k2':'v2'}
dic.update({'k3':'v3','k1':'v24'})
print(dic)
输出结果：
{'k3': 'v3', 'k1': 'v24', 'k2': 'v2'}
字典的说明：
字典的key必须是不可变类型
字典可以嵌套
集合：set，不可重复的列表，可变类型
1.都可以通过set变成集合
name = ('alex','eric','dodo',)
name1 = ['alex','eric','dodo',]
v = set(name)
v1 = set(name1)
print(v)
print(v1)
输出结果：
{'eric', 'alex', 'dodo'}
{'eric', 'alex', 'dodo'}
2.add
# s1.add('you')
# s1.add('alex')
# print(s1)
Ps：如果重复也没关系，但是不会加进去
3. clear
# v =s1.clear()
# print(v)
输出结果：None
s1.clear()
print(s1)
输出结果：set()
4. copy
v=s1.copy()
print(v)
5.difference输出一个集合与其他集合不同的元素
s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
v= s1.difference(s2)
print(v)
print(s1)
输出结果：
{'李泉', '李泉11'}
{'eric', 'alex', '李泉', '李泉11', 'tony'}
6.difference_update使集合变成与其他集合的差集
v = s1.difference_update(s2)
print(v)
print(s1)
输出结果：
None
{'李泉11', '李泉'}
7.discard删除元素，如果不存在不报错
s1.discard('alex')
s1.discard('jjj')
print(s1)
输出结果：
{'李泉11', '李泉', 'tony', 'eric'}
8.intersection交集
v =s1.intersection(s2)
print(v)
输出结果
{'alex', 'tony', 'eric'}
Ps:s1本身不变
9intersction_update改变自身变成交集
s1 =s1.intersection(s2)
同 s1.intersection_update(s2)
输出结果
{'alex', 'tony', 'eric'}
9．idisjoint查看两个集合之间是否有交集
v = s1.isdisjoint(s2)
print(v)
输出结果：False
10.issubset判断是否是子集
s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony'}#,'刘一'
v = s2.issubset(s1)
print(v)
输出结果：True
11. issupperset判断是否是父集
12.pop删除集合中任意一个元素
v =s1.pop()
print(s1)
print(v)
输出结果：
{'alex', '李泉11', '李泉', 'tony'}
Eric
13.remove删除
s1.remove('alex')
print(s1)
输出结果：
{'李泉', '李泉11', 'eric', 'tony'}
Ps:如果不是其中的元素，报错
14.union合集，新变量接收合集
v=s1.union(s2)
print(s1)
print(v)
输出结果
{'tony', 'eric', '李泉', 'alex', '李泉11'}
{'tony', '李泉11', '刘一', 'eric', '李泉', 'aaaaa', 'alex'}
Ps:s1本身不变，合集会变成一个新的集合，需要变量接收
15.update合集，集合本身变成合集
v = s1.update(s2)
print(s1)
print(v)
输出结果
{'tony', 'eric', 'aaaaa', 'alex', '刘一', '李泉', '李泉11'}
None
16. symmetric_difference两个集合差集的合集（对称差集）
s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一','aaaaa'}#,
v = s1.symmetric_difference(s2)
print(v)
输出结果
{'李泉11', '刘一', 'aaaaa', '李泉'}
17 symmetric_difference_update
s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一','aaaaa'}#,
v = s1.symmetric_difference_update(s2)
print(v)
print(s1)
print(s2)
输出结果
None
{'刘一', '李泉', '李泉11', 'aaaaa'}
{'aaaaa', '刘一', 'eric', 'tony', 'alex'}