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 修改之后
总结：
因为的深拷贝对比浅拷贝，强调的是递归，强调的是资源素。对了顶层的操作，深浅拷贝无异。
所以说深拷贝与浅拷贝，最大的区别在于第二层及其之后的。