元组、字典、集合内置方法， 深浅拷贝

目录

• 元组内置方法
  • 作用
  • 定义方式
  • 使用方法
  • 有序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
140728121222096
140728121222128