第八讲 - 元组和字典
1. 元组（不可变序列、不能重新赋值） 表现形式 tuple
什么时候用列表，什么时候用元组？
1、一般当我们希望数据不变的用元组，其余情况用列表
2、不能用索引重新赋值
'''
# 创建元组
my_tuple = ()
print(my_tuple,type(my_tuple))
'''
# 可变对象
my_tuple = (1,2,3,4,5) #创建一个空的元组
print(my_tuple[3]) # 4
# 如果元组不是空的元组，他里面至少得有一个逗号（,）
my_tuple = 10,20,30,40
a,b,c,d = my_tuple
print(my_tuple,type(my_tuple)) # (10,20,30,40) <class 'tuple'>
# 元组的解包
# 解包指的是将元组当中的每一个元素赋值给一个变量
print('a =',a)
print('b =',b)
print('c =',c)
print('d =',d)
# 在对一个元组进行解包时变量的数量要和元组中的元素保持一致
# 当变量和元组的数量不一致时，我们可以在变量前面添加一个*，这样变量将会获取元组中剩余的元素
# 不能加两个*号
# 情况1
my_tuple = 10,20,30,40
a,b,*c = my_tuple
print(a,b,c) # 10 20 [30, 40]
# 情况2
my_tuple = 10,20,30,40
a,*b,c = my_tuple
print(a,b,c) # 10 [20, 30] 40
# 情况3
my_tuple = 10,20,30,40
*a,b,c = my_tuple
print(a,b,c) # [10, 20] 30 40
print(*a,b,c) # 10, 20 30 40
# 情况4
a,b,*c = [1,2,3,4,5,6,7]
print(a,b,c) # 1 2 [3, 4, 5, 6, 7]
# 情况5
a,b,*c = 'python java'
print(a,b,c) # p y ['h', 't', 'o', 'n', ' ', 'j', 'a', 'v', 'a']
# 可变对象
# 每个对象当中保存了3个数据: id(标识) type(类型) value(值)
a = [1,2,3]
print('修改前：',a,id(a)) # [1, 2, 3] 20455472
# 通过索引来修改列表
a[0] = 10 # 修改的是对象(value值)，这个操作是通过变量修改对象里面的值，不会改变变量指向的对象
print('修改后：',a,id(a)) # [10, 2, 3] 5709872
a = [4,5,6] # 修改的是变量，这个操作给变量重新赋值，会改变变量所指向的对象
print('修改后：',a,id(a)) # [4, 5, 6] 2080120
'''
1.
'''
a = [1,2,3]
b = a
b[0] = 10
print('a:',a,id(a)) # a [10, 2, 3] 10428624
print('b:',b,id(b)) # a [10, 2, 3] 10428624
'''
2.
'''
a = [1,2,3]
b = a
b = [10,2,3]
print('a:',a,id(a)) # a [1, 2, 3] 10468728
print('b:',b,id(b)) # b [10, 2, 3] 11214896
'''
== 和 is
== ！= is is not
== != 比较的是对象的值是否相等
is 和 is not 比较的是对象的id是否相等
'''
a = [1,2,3]
b = [1,2,3]
print(a,b)
print(id(a),id(b)) # 16711632 16694648
print(a is b) # False
print(a == b) # True
2.字典
新的数据结构，称之为映射（mapping），
字典的作用就是用来存储对象的容器，
列表存储数据性能很好，但是查询数据性能很差，
字典中每个元素都有一个名字，通过这个名字可以快速查找指定的元素，
唯一的名字称之为（key），通过Key可以查找value，称为值（value），
所以字典，我们称为键值对（key-value），
每个字典可以有多个键值对，每个一个键值对我们称为一项（item）
# 创建字典
# 用{}来创建
# 语法：{key:value,key:value...}
# 在字典中键和值可以是那些内容?
# 值可以是任意对象
# 键可以是任意不可变的对象（int,str,bool,tuple）
# 字典的键是不可以重复的，如果出现重复后面是会替换前面的
d = {'name':'yxh','age':20,'gender':'男','name':'CSY'}
print(d,type(d))
print(d['name'],d['age'],d['gender']) # CSY 20 男
# 字典的使用
# 创建字典
d = dict(name = 'book',age = 10,gender = '男')
'''
双值子序列 dict()这个函数可以将一个包含有 双值子序列 转换成字典
双值序列，序列只有两个值[3,4] 或者 ('hello','name') 或者 'xy'
子序列，如果序列当中的元素也是序列，那么我们就称为这个元素为子序列 [(1,2)]
'''
d1 = dict([('name','包括'),('age',18)])
print(d,type(d))
print(d1,type(d1))
'''
in 检查当前字典是否包含指定的键
not in 检查字典当中是否不包含指定的键
'''
d = dict(name = 'book',age = 10,gender = '男')
print('name' in d) # True
# 获取字典里面的值
# 语法： d[key].
d = dict(name = 'book',age = 10,gender = '男')
n = 'name'
print(d[n]) # book
'''
get() 方法：
get(key[,default]) 根据键来获取字典当中的值，如果获取的键不存在，则返回None
也可以指定一个默认值，作为第二个参数，这样当获取不到键的时候会返回默认值
'''
d = dict(name = 'book',age = 10,gender = '男')
print(d.get('hello','没有这个值')) # 没有这个值
'''
修改字典:
d[key] = value
如果存在则覆盖，不存在则添加
'''
d = dict(name = 'book',age = 10,gender = '男')
d['name'] = 'LOL'
d['phone'] = '123126'
print(d) # {'name': 'LOL', 'age': 10, 'gender': '男'}
'''
setdefault(key[,default) 可以用来像字典当中添加key-value
如果key已经存在，则返回key的值，不会对字典做任何操作
如果key不存在，则向字典当中添加这个key，并设置value
'''
d = dict(name = 'book',age = 10,gender = '男')
res = d.setdefault('name','亚所')
res = d.setdefault('phone','56431')
print('res:',res)
print(d)
'''
update()
将其他的字典当中key-value添加到当中的字典当中
'''
d = {'a':1,'b':2,'c':3}
d2 = {'b':4,'e':5,'f':6,'a':7}
d.update(d2)
print(d) # {'a': 7, 'b': 4, 'c': 3, 'e': 5, 'f': 6}
'''
del() 删除
'''
d2 = {'b':4,'e':5,'f':6,'a':7}
del d2['a']
del d2['b']
print(d2) # {'e': 5, 'f': 6}
'''
popitem() 随机删除字典当中的一个键值对，一般情况下都会删除最后一个键值对
删除之后它会讲key-value作为返回值返回
'''
d2 = {'b':4,'e':5,'f':6,'a':7}
d2.popitem()
res = d2.popitem()
print('res =',res) # res = ('f', 6)
print(d2) # {'b': 4, 'e': 5, 'f': 6}
'''
pop(key[,default])
根据字典删除字典中键值对key-value
返回的是删除的value值
如果删除不存在的key,会抛出异常 key error
如果指定了默认值，删除不存在的key值的时候，就会返回默认值
'''
d2 = {'b':4,'e':5,'f':6,'a':7}
res = d2.pop('e')
print('res =',res) # res = 5
print(d2) # {'b': 4, 'f': 6, 'a': 7}
res = d2.pop('x','没有这个值')
print(res) # 没有这个值
'''
clear()清空字典
'''
d2.clear()
print(d2,id(d2)) # {} 17564032
3 、浅复制（浅拷贝）
只会复制字典本身，如果字典当中还有字典是不会被复制的
copy() 对于一个字典进行浅复制
# id一样
d = {'a':1,'b':2,'c':3}
d2 = d
d['b'] = 10
print('d =',d,id(d)) # d = {'a': 1, 'b': 10, 'c': 3} 19874272
print('d2 =',d2,id(d2)) # d2 = {'a': 1, 'b': 10, 'c': 3} 19874272
# id不一样 ，不影响修改
d = {'a':1,'b':2,'c':3}
d2 = d.copy()
d['a'] = 1000
print('d =',d,id(d)) # d = {'a': 1000, 'b': 2, 'c': 3} 56783232
print('d2 =',d2,id(d2)) # d2 = {'a': 1, 'b': 2, 'c': 3} 56783280
浅复制 ：如果字典里面还有字典，则不会复制，是只会复制外部，里面内层是不会产生作用的
d = {'a':{'name':'狐狸王','age':20},'b':2,'c':3}
d2 = d.copy()
d2['a']['name'] = '我德纳'
print('d =',d,id(d)) # d = {'a': {'name': '我德纳', 'age': 20}, 'b': 2, 'c': 3} 12099920
print('d2 =',d2,id(d2)) # d2 = {'a': {'name': '我德纳', 'age': 20}, 'b': 2, 'c': 3} 12099968
4、遍历字典 keys() values() items()
4.1 keys() 该方法会返回字典所有的键
d = {'name':'狐狸王','age':20,'phone':'123456'}
print(d.keys()) # dict_keys(['name', 'age', 'phone'])
for k in d.keys(): # 狐狸王
print(d[k]) # 20
# 123456
4.2 values() 返回一个序列,保存字典的值
d = {'name':'狐狸王','age':20,'phone':'123456'}
print(d.values()) # dict_items([('name', '狐狸王'), ('age', 20), ('phone', '123456')])
for v in d.values(): # ('name', '狐狸王')
print(v) # ('age', 20)
# ('phone', '123456')
4.3 items() 返回字典当中所有的项，它会返回一个序列 ，序列中包含双值子序列，双值是值字典中的key-value
d = {'name':'狐狸王','age':20,'phone':'123456'}
print(d.items()) # dict_values(['狐狸王', 20, '123456'])
for k,v in d.items(): # name = 狐狸王
print(k,'=',v) # age = 20
# phone = 123456
