这里将告诉您元组、字典、集合内置方法， 深浅拷贝,具体实现方法:
目录
元组内置方法
作用
定义方式
使用方法
有序or无序
可变or不可变
字典内置方法
作用
定义方式
使用方法
有序or无序
可变or不可变
集合内置方法
作用
定义方式
使用方法
有序or无序
可变or不可变
数据类型总结
存值个数
有序or无序
可变or不可变
深浅拷贝
可变or不可变
拷贝
浅拷贝
深拷贝对象
元组内置方法
作用
元组可以看成只可取不可修改的列表，元组一创建就被写死了
定义方式
()内用逗号隔开多个元素(可以为任意数据类型)
tup = tuple((1, 2, 3))
print(tup, type(tup))
# 如果元组只有一个元素，必须得加逗号
tup1 = (1,)
print(tup1, type(tup1))
使用方法
tup = (1,2,3,4,5,)
# 1.索引取值
print(tup[1]) # 2
# 2.切片
print(tup[1:4]) # (2, 3, 4)
# 3.for循环
for i in tup:
print(tup)
# 4.len长度
print(len(tup)) # 5
# 5.in / not in
print(0 in tup) # False
# 6.index获取索引
print(tup.index(1)) # 0
# 7.count计数
print(tup.count(1)) # 1有序or无序
元组能索引取值，是有序的
可变or不可变
算是不可变吧
字典内置方法
作用
存储多个值，对每个数据有描述意义
定义方式
{}内用逗号隔开多个键key(具有描述意义，不能为可变数据类型):值value(任意数据类型)
使用方法
dic = {'a':1, 'b':2}
# 1.按key取值
print(dic['a']) # 1
# 2.按key修改值
dic['a'] = 666
print(dic) # {'a': 666, 'b': 2}
dic['c'] = 3 # 没有就加值
print(dic) # {'a': 666, 'b': 2, 'c': 3}
# 3.for循环
for i in dic:
print(i) # 只能取到key值
# 4.in / not in
print('a' in dic) # True
# 5.len
print(len(dic)) # 3
# 6.keys/values/items
print(dic.keys()) # dict_keys(['a', 'b', 'c'])
print(dic.values()) # dict_values([666, 2, 3])
print(dic.items()) # dict_items([('a', 666), ('b', 2), ('c', 3)])
# 7.get
print(dic.get('a')) # get取值，如果没有返回None
# 8.update
dic1 = {'a': 1, 'c': 2}
dic2 = {'b': 1, 'd': 2}
dic1.update(dic2)
print(dic1) # {'a': 1, 'c': 2, 'b': 1, 'd': 2}
# 9.fromkeys 创建一个新字典，如没有value值，默认None
print(dic.fromkeys(['a','b','c'], 1)) # {'a': 1, 'b': 1, 'c': 1}
# 10.# setdefault # 字典有这个key，就不修改，没有则增加
dic.setdefault('j', 2)
dic.setdefault('a', 2)
print(dic)有序or无序
字典无序
可变or不可变
字典可变
集合内置方法
作用
进行 交集 / 并集 / 补集等运算，可以去重，但是集合内元素是乱序的
定义方式
{}内以逗号隔开多个元素(不能可为变数据类型)
s = {'a', 'a', 'a', 'a', 1, 'v', 2, 2, 'c', 3, 3, 4, 5, 6} # 对于数字而言，不会乱序；但是对于其他，就乱序
print(s)
# {1, 2, 'a', 3, 4, 5, 6, 'v', 'c'}使用方法
se1 = {'cwz', 'neo', 'woods'}
se2 = {'reese', 'chars', 'cwz'}
# 1.并集
print(se1 | se2) # {'neo', 'reese', 'cwz', 'woods', 'chars'}
# 2.交集
print(se1 & se2) # {'cwz'}
# 3. 差集
print(se1 - se2) # {'neo', 'woods'}
# 4.补集
print(se1 ^ se2) # {'reese', 'chars', 'neo', 'woods'}
# 5.add
se1.add('sad')
print(se1) # {'neo', 'sad', 'woods', 'cwz'}
# 6.remove / discard
se1.remove('neo') # 没有的，删除用remove会报错
print(se1) # {'sad', 'woods', 'cwz'}
se2.discard('chars') # 没有的，删除用discard不会报错
print(se2) # {'cwz', 'reese'}
# 7.pop
se1.pop() # 随机删除值
print(se1) # {'woods', 'cwz'}有序or无序
无序
可变or不可变
可变
数据类型总结
存值个数
存一个值：整型 / 浮点型 / 字符串
存多个值：列表 / 元组 / 字典 / 集合
有序or无序
有序：字符串 / 列表 / 元组
无序：字典 / 集合
可变or不可变
可变：列表 / 字典 / 集合
不可变：整型 / 浮点型 / 字符串 / 元组
深浅拷贝
可变or不可变
id值不可变，就是在原值基础上修改，为可变数据类型；
id值变化，就是重新申请一块内存空间放入新值，为不可变数据类型。
拷贝
如果lt2是lt1的拷贝对象，则lt1内任何数据类型的元素变化，lt2也跟着变化。
lt1 = [1,2,3,4,'a',[1,23,5]]
lt2 = lt1
print(lt1)
print('lt1_id: ', id(lt1))
lt1.append('b')
print('*'*50)
print(lt1)
print('lt1_id: ', id(lt1))
print(lt2)
print('lt2_id: ', id(lt2))
# 打印结果：
[1, 2, 3, 4, 'a', [1, 23, 5]]
lt1_id: 1990616507080
**************************************************
[1, 2, 3, 4, 'a', [1, 23, 5], 'b']
lt1_id: 1990616507080
[1, 2, 3, 4, 'a', [1, 23, 5], 'b']
lt2_id: 1990616507080浅拷贝
如果lt2是lt1的浅拷贝对象，则lt1内的不可变元素发生了变化，lt2不变；
如果lt1内的可变元素发生了改变，则lt2跟着改变
import copy
lt1 = [1, 2, 3, 4, 'a', [1, 23, 5]]
lt2 = copy.copy(lt1)
lt1.append(99)
print('lt1: ', lt1)
print('lt1_id: ', id(lt1))
print('lt2: ', lt2)
print('lt2_id: ', id(lt2))
print('*'*50)
lt1[5].append('qq')
print('lt1[5]: ', lt1)
print('lt1[5]_id: ', id(lt1))
print('lt2: ', lt2)
print('lt2_id: ', id(lt2))
# 打印结果：
lt1: [1, 2, 3, 4, 'a', [1, 23, 5], 99]
lt1_id: 2049177903816
lt2: [1, 2, 3, 4, 'a', [1, 23, 5]]
lt2_id: 2049299510728
**************************************************
lt1[5]: [1, 2, 3, 4, 'a', [1, 23, 5, 'qq'], 99]
lt1[5]_id: 2049177903816
lt2: [1, 2, 3, 4, 'a', [1, 23, 5, 'qq']]
lt2_id: 2049299510728深拷贝对象
如果lt2是lt1的深拷贝对象，则lt1内的不可变数据类型元素改变，lt2不变；
如果lt1内的可变数据类型元素改变，lt2不变
import copy
lt1 = [1, 2, 3, [4, 5, 6]]
lt2 = copy.deepcopy(lt1)
print('id(lt1)', id(lt1))
print(id(lt1[0]))
print(id(lt1[1]))
print(id(lt1[2]))
print(id(lt1[3]))
print(id(lt1[3][0]))
print(id(lt1[3][1]))
print(id(lt1[3][2]))
print('*' * 50)
print('id(lt2)', id(lt2))
print(id(lt2[0]))
print(id(lt2[1]))
print(id(lt2[2]))
print(id(lt2[3]))
print(id(lt2[3][0]))
print(id(lt2[3][1]))
print(id(lt2[3][2]))
# 打印结果：
id(lt1) 2156612313800
140728121221968
140728121222000
140728121222032
2156612313736
140728121222064
140728121222096
140728121222128
**************************************************
id(lt2) 2156760304520
140728121221968
140728121222000
140728121222032
2156642018504
140728121222064
140728121222096140728121222128元组、字典、集合内置方法， 深浅拷贝就为您介绍到这里
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
