1. 基础数据类型汇总
1. str int
还有诸多功能，可以自行查找，如：
1 s = ' ' 2 print(s.isspace()) #True 检查字符串是否只包含空格，最少含有一个空格，返回bool值
2. list
在循环列表时，最好不要删除元素，有时会产生错误：
在字典中也是一样
1 lis = [11,22,33,44,55] 2 for i in range(len(lis)): #这里i的范围已经确定，不会再发生变化 3 print(i) # i = 0 i = 1 i = 2 4 del lis[i] 5 print(lis) # [11,22,33,44,55] [22, 44, 55] [22, 44] 6 #在依次删除元素时，列表的索引发生变化从而导致错误
例题：
1 #lis = [11,22,33,44,55] 删掉奇数位的元素 2 #方法一：直接切片步进 3 lis = [11,22,33,44,55] 4 lis = lis[::2] 5 print(lis) 6 7 #方法二：创建新列表，将奇数位的元素添加进去 8 lis2 = [] 9 for i in lis: 10 if i % 2 == 0: 11 lis2.append(i) 12 else: 13 continue 14 print(lis2) 15 16 #方法三：从末尾删除 17 for i in range(len(lis)-1,-1,-1): 18 if i % 2 == 0: 19 del lis[i] 20 else: 21 continue 22 print(lis) 23 #输出均为[22,44]
ps: 1. 从末尾删除，不会被for循环以及列表的改变影响
2. range语句从进入循环之后，其中的一切都不会发生改变
3. dict
1 # 1. fromkeys的用法
2 dic = dict.fromkeys([1,2,3],'春哥')
3 print(dic) #{1:'春哥',2:'春哥',3:'春哥'}
4 '''dict.fromkeys(a,b)
5 a----键
6 b----值
7 '''
8
9 # 2. 关于列表方法赋值问题与数字赋值的区别
10 l1 = []
11 l2 = l1
12 l3 = l1
13 l3.append('a')
14 print(l1,l2,l3) #['a']['a']['a']
15 #这里注意，l1, l2, l3存的是内存的地址，用append方法后均会发生变化
16
17 # 3. dic = {'k1':'v1','k2':'v2','a3':'v3'} 要求删除字典中键含有k的键值对
18 #方法一：创建一个新列表，将键不含k的键值对加入进去
19 dic = {'k1':'v1','k2':'v2','a3':'v3'}
20 dic1 = {}
21 for i in dic:
22 if 'k' not in i:
23 dic1.setdefault(i,dic[i])
24 print(dic1)
25
26 #方法二：创建一个列表，将键含有k的字典中的键值对放入列表中，再将列表循环删除字典中的内容
27 l = []
28 for i in dic:
29 if 'k' in i:
30 l.append(i)
31 for i in l:
32 del dic[i]
33 print(dic)
34 #这里循环列表而不循环字典，是因为循环字典的同时删除键值对会报错
ps: 在循环字典和列表时尽量不要删除其中的元素，比较麻烦，有时会报错
4. bool
其他数据类型转化为bool值：
False---->int: 0 str: '' list: [] dict: {} tuple: () set: ()
5. tuple
元祖里面若只有一个元素且不加,逗号，则此元素是什么类型，元祖就是什么类型；否则还是元祖类型
1 tu1 = (1) 2 tu2 = (1,) 3 print(tu1,type(tu1)) #1 class<'int'> 4 print(tu2,type(tu2)) #(1,) class<'tuple'> 5 tu1 = ([1]) 6 tu2 = ([1],) 7 print(tu1,type(tu1)) #[1] class<'list'> 8 print(tu2,type(tu2)) #([1],) class<'tuple'>
2. 集合的增删查及去重
无序且不重复的
集合中的元素必须是不可改变的，即hashable
1 set1 = set({1,2,3})
2 set2 = {1,2,3,[2,3],{'name':'alex'}} # 错的
3 print(set1)
4 print(set2) #报错，列表的数据类型是unhashable
1. 增
1 set1 = {'alex','wusir','ritian','egon','barry',}
2 # 1. add 整体添加
3 set1.add('女神')
4 # 2. print(set1)
5 #update 迭代加入，即以最小元素形式逐次添加
6 set1.update('abc')
7 print(set1)
2. 删
1 set1 = {'alex','wusir','ritian','egon','barry',}
2 # 1. pop() # 随机删除
3 print(set1.pop()) # 有返回值
4 print(set1)
5
6 # 2. remove() # 按元素
7 set1.remove('alex')
8 print(set1)
9
10 # 3. clear() # 清空
11 set1.clear()
12 print(set1) # set()
13
14 # 4. del # 删除整个字典
15 del set1
16 print(set1) # 报错，字典不存在
3. 查
1 set1 = {'alex','wusir','ritian','egon','barry',}
2 for i in set1:
3 print(i)
4. 其他操作
1. 交集
& 或 intersection()
1 set1 = {1,2,3,4,5}
2 set2 = {4,5,6,7,8}
3 set3 = set1 & set2
4 print(set3) # {4, 5}
5 print(set1.intersection(set2)) # {4, 5}
2. 并集
| 或 union()
1 set1 = {1,2,3,4,5}
2 set2 = {4,5,6,7,8}
3 print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7,8}
4 print(set2.union(set1)) # {1, 2, 3, 4, 5, 6, 7}
3. 反交集，即并集减去交集
^ 或 symmetric_difference()
1 set1 = {1,2,3,4,5}
2 set2 = {4,5,6,7,8}
3 print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}
4 print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}
4. 差集
- 或 difference
1 set1 = {1,2,3,4,5}
2 set2 = {4,5,6,7,8}
3 print(set1 - set2) # {1, 2, 3}
4 # set1独有的
5 print(set1.difference(set2)) # {1, 2, 3}
5. 子集与超集
1 set1 = {1,2,3,}
2 set2 = {1,2,3,4,5,6}
3
4 print(set1 < set2)
5 print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。
6
7 print(set2 > set1)
8 print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集。
6. 去重
可以通过列表与集合的相互转化来实现
1 li = [1,2,33,33,2,1,4,5,6,6] 2 set1 = set(li) 3 print(set1) 4 li = list(set1) 5 print(li)
7. 不可变集合
集合是可变的，但可以通过 frozenset() 转变为不可变集合
1 s1 = {1,2,3}
2 print(s1,type(s1)) #{1, 2, 3} <class 'set'>
3
4 s = frozenset('barry')
5 print(s,type(s)) #frozenset({'b', 'a', 'r', 'y'}) <class 'frozenset'>
6 for i in s:
7 print(i) #可循环打印
3. 深浅copy
引入
1 # 赋值运算
2 l1 = [1,2,3]
3 l2 = l1
4 print(id(l1),id(l2)) #内存地址相同
5 l1.append('a')
6 print(l1,l2) #[1, 2, 3, 'a'] [1, 2, 3, 'a']
7
8 # copy
9 l1 = [1,2,3]
10 l2 = l1.copy()
11 print(l1,l2)
12 print(id(l1),id(l2)) #内存地址不同
13 l2.append('a')
14 print(l1,l2) #[1, 2, 3] [1, 2, 3, 'a']
1. 数据类型
不可变数据类型（hashable 可哈希）：Number ( 数字 ) String ( 字符串 ) Tuple ( 元祖 )
可变数据类型（unhashable 哈希）：List ( 列表 ) Dictionary ( 字典 ) Set ( 集合 )
2. copy 也叫浅copy
1. 对于不可变数据
浅复制仅仅是地址指向，不会开辟新空间
2. 对于可变数据类型
浅复制会开辟新的空间地址（仅仅是最顶层开辟了新的空间，里层的元素地址还是一样的），进行浅拷贝
3. 浅拷贝后
改变原始对象中为可变数据类型的元素的值，会同时影响拷贝对象；
改变原始对象中为不可变数据类型的元素的值，只有原始类型受影响。（操作拷贝对象对原始对象也是同理的）
1 l1 = [1,2,[4,5,6],3]
2 l2 = l1.copy()
3 print(l1,id(l1)) #[1, 2, [4, 5, 6], 3] 2096864515144
4 print(l2,id(l2)) #[1, 2, [4, 5, 6], 3] 2096892392904
5
6 l1.append('a')
7 print(l1,l2) #[1, 2, [4, 5, 6], 3, 'a'] [1, 2, [4, 5, 6], 3]
8
9 l1[2].append('a') #[1, 2, [4, 5, 6, 'a'], 3, 'a'] [1, 2, [4, 5, 6, 'a'], 3]
10 print(l1,l2)
11 print(id(l1[2])) #2907504857672
12 print(id(l2[2])) #2907504857672
1 import copy
2 #不可变数据类型
3 #数值 num
4 a=0
5 b=copy.copy(a)
6 print(a is b) #True #is 内容和地址都相等
7
8 #字符串 str
9 a='yyyy'
10 b=copy.copy(a)
11 print(a is b) #True
12
13 #元组 tuple
14 a=(1,2,3,[1,2])
15 b=copy.copy(a)
16 print(a is b) #True
17
18 #可变数据类型
19 #集合 set
20 a={1,2,3,4}
21 b=copy.copy(a)
22 print(a is b) #False
23
24 #字典 dict
25 a={1:2,3:4}
26 b=copy.copy(a)
27 print(a is b) #False
28
29 #列表 list
30 a={1,2,3,4}
31 b=copy.copy(a)
32 print(a is b) #False
33
34 #可变类型进行修改
35 #浅复制会开辟新的空间地址，仅仅是最顶层开辟了新的空间，里层的元素地址还是一样的，所以a[3]发生改变时，b也会
36 #跟着变化。
37 a=(1,2,3,[4,5,6])
38 b=copy.copy(a)
39 print(id(a)==id(b)) #True 修改之前
40 a[3].append(7)
41 print(id(a)==id(b)) #True 修改之后
3. deepcopy 深拷贝
1. 深拷贝
除了顶层拷贝，还对子元素也进行了拷贝（本质上递归浅拷贝）
2. 经过深拷贝后
原始对象和拷贝对象所有的元素地址都没有相同的了
1 import copy
2 #不可变数据类型
3 #数值 num
4 a=0
5 b=copy.deepcopy(a)
6 print(a is b) #True #is 内容和地址都相等
7
8 #字符串 str
9 a='yyyy'
10 b=copy.deepcopy(a)
11 print(a is b) #True
12
13 #元组 tuple
14 a=(1,2,3,[1,2])
15 b=copy.deepcopy(a)
16 print(a is b) #True
17
18 #可变数据类型
19 #集合 set
20 a={1,2,3,4}
21 b=copy.deepcopy(a)
22 print(a is b) #False
23
24 #字典 dict
25 a={1:2,3:4}
26 b=copy.deepcopy(a)
27 print(a is b) #False
28
29 #列表 list
30 a={1,2,3,4}
31 b=copy.deepcopy(a)
32 print(a is b) #False
33
34 #可变类型进行修改
35 #深拷贝，除了顶层拷贝，还对子元素也进行了拷贝（本质上递归浅拷贝）
36 a=(1,2,3,[4,5,6])
37 b=copy.deepcopy(a)
38 print（id(a)==id(b)） #False 修改之前，这里如里面列表改为不可变类型（字符串，元组），结果为True。
39 a[3].append(7)
40 print(id(a)==id(b)) #False 修改之后
总结：
因为的深拷贝对比浅拷贝，强调的是递归，强调的是资源素。对了顶层的操作，深浅拷贝无异。
所以说深拷贝与浅拷贝，最大的区别在于第二层及其之后的。