元组

1.定义：只可取，不可更改的列表，()内用逗号隔开多个元素（可以为任意数据类型）

#lt=list([1,2,3])
tup=tuple((1,2,3))
print(tup,type(tup))
运行结果：
(1, 2, 3) <class 'tuple'>

2.作用：元组一创建就被写死了

如果元组只有一个元素，必须得加逗号

tup1=(1,)
print(tup1,type(tup1))
运行结果：
(1,) <class 'tuple'>

3.使用方法：

索引取值

print(tup[0])  #1

索引切片

print(tup[0:3])   #(1,2,3)

for循环

for i in tup:
    print(i)  #1 2 3

成员运算

print(0 in tup)  #false

len长度

print(len(tup))  #3

index获取元素索引

print(tup.index(1))  #0

计数

print(tup.count(2)) #1

有序or无序：有序

可变or不可变：不可变

字典

*字符串/列表/字典--》常用，他们三个就足够描述世间万物了

其他数据类型可以被替代--》列表替代元组，redis数据库替代集合

1.字典作用：存储多个数据，对每个数据具有描述

2.定义方式：{}内用逗号隔开多个键key（具有描述意义，不能为可变数据类型）：值value（任意数据类型）对#散列表（哈希表）

3.使用方法：

按key取值/按key修改值

dic={'a':1,'b':2,'c':3}
print(dic['a'])  #1
dic['b']=4
print(dic) #{'a': 1, 'b': 4, 'c': 3}

添加值，没有就添加，有就修改

dic['d']=4
print(dic) #{'a': 1, 'b': 4, 'c': 3, 'd': 4}

for 循环 （只循环key）

for i in dic:
    print(i)   #只循环key

成员运算

print('a' in dic)  #True

len 长度

print(len(dic)) #4

del/pop/popitem 删除

del dic['a']
print(f'dic.get('a'):{dic.get('a')}')   
运行结果：
dic.get('a'):None
    
dic.pop('a')
print(f"dic.pop('b'): {dic.pop('b')}")
print(f"dic.get('a'): {dic.get('a')}")
运行结果：
dic.pop('b'): 1
dic.get('a'): None
    
print(f"dic.popitem():{dic.popitem()}") #popitem()随机返回并删除字典中的一对键和值（一般删除末尾对）
运行结果：
dic.popitem():('j', 2)

keys/values/items 键/值/对

print(dic.keys())  #看成列表
print(dic.values())
print(dic.items())
for i in dic.items():
    print(i)   #循环键值对

get 获取 ，字典中没有返回None，可以给定一个默认值

print(dic.get('b',1))  #4
#print(dic.get('b')  #打印结果一样

update 更新 相当于list里的extend扩展

dic1={'a':1,'c':2}
dic2={'b':1,'d':2}
dic1.update(dic2)
print(dic1)

setdefault 字典有这个key，就不修改，没有则增加

dic.setdefault('j',2)
dic.setdefault('a',2)
print(dic)

有序or 无序：无序

可变or不可变：可变（值变id不变）

集合

交集/并集/补集/差集

1.作用：进行上述运算，去重，乱序--》基于散列表实现的

2.定义方式：{}内以逗号隔开多个元素（不能为可变数据类型）

s={}  #空字典
print(type(s)) 
s=set()  #空集合
print(type(s)) 
运行结果：
<class 'dict'>
<class 'set'>

s = {'a', 'a', 'a', 'a', 1, 'v', 2, 2, 'c', 3, 3, 4, 5, 6}  # 对于数字而言，不会乱序；但是对于其他，就乱序
print(s) 
运行结果：
{1, 2, 3, 4, 5, 6, 'v', 'c', 'a'}

3.使用方法：

s1={'jason','nick','tank','sean'}
s2={'nick','egon','kevin'}
#并集
print(s1|s2) 
#交集
print(s1&s2)
#差集
print(s1-s2) #前面的减去两者重合的
#补集
print(s1^s2)  #除了交集剩下的
#add
s1.add('ocean')
print(s1)

删除值 remove/discard/pop

s1.remove('cases') #没有此值就报错
print(s1)
s1.discard('cases') #没有此值不报错
print(s1)
s1.pop() #随意删除一个值
print(s1)

有序or 无序：无序

可变or不可变：可变（值变id不变）

深浅拷贝

可变：值变id不变

不可变：值变id变

1.拷贝（赋值）

当y为x的拷贝对象，如果x为不可变类型，x变化y不变，如果x为可变类型，则x和y都变化

x=10
y=x
x+=1
print(y)  #10

x=[1,2,3]
y=x
x+=[4]
print(y)  #[1, 2, 3, 4]

2.浅拷贝

如果l2是l1的浅拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，则l2会跟着改变

import copy

l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = copy.copy(l1)

l1.append('g')

print(l1)
print(l2)
l1[3].append('g')

print(l1)
print(l2)
运行结果：字符串不可变，列表可变
['a', 'b', 'c', ['d', 'e', 'f'], 'g']
['a', 'b', 'c', ['d', 'e', 'f']]
['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'g']
['a', 'b', 'c', ['d', 'e', 'f', 'g']]

3.深拷贝

当lt2是lt1的深拷贝对象时，lt1内部的不可变类型变化，lt2不变；lt1内部的可变类型变化，lt2不变

import copy

l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = copy.deepcopy(l1)

l1.append('g')

print(l1)
print(l2)
l1[3].append('g')

print(l1)
print(l2)
运行结果：
['a', 'b', 'c', ['d', 'e', 'f'], 'g']
['a', 'b', 'c', ['d', 'e', 'f']]
['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'g']
['a', 'b', 'c', ['d', 'e', 'f']]