第七讲：元组，列表

一. 元组

1. 元组介绍

• 元组是一个不可变的序列，即元组内的数据是不可变化的，不希望数据改变的时候我们就用元组，其他情况用列表

2. 元组的表达形式

• （）

tu1 = () # 但是创建一个空元组是没有意义的，因为元组是不可改变的
print(type(tu1))

# 输出
<class 'tuple'>

# 注：当只有一个元素的时候，在元素后边加上逗号才可以代表元组，不加逗号就不是元组
tu2 = 10
print(type(tu2))

# 输出
<class 'int'>

tu2 = 10,
print(type(tu2))

# 输出
<class 'tuple'>

3. 通用操作

• 取值和切片

tu3 = (1, 2, 3, 4, 5)
print(tu3[2])
print(tu3[2::])

# 输出
3
(3, 4, 5)

4. 拆包

• 操作

tu4 = (1, 2, 3)
a, b, c = tu4
print(a, b, c)

# 输出
1 2 3

# 当元组内元素的数量与拆包元素的数量不一致的时候会报错
tu4 = (1, 2, 3)
a, b = tu4
print(a, b)

# 错误
Traceback (most recent call last):
   File "D:/PyCharmproject/第7讲/第七讲.py", line 12, in <module>
     a, b = tu4
ValueError: too many values to unpack (expected 2)

• 当元组内元素与想要的元素数量不对应时，在其中一个元素前边加上*（星号），*接收参数之后，结果使用一个列表来存储

tu4 = (1, 2, 3)
a, *b = tu4
print(a, b)

# 输出
1 [2, 3]

• 拆包的时候有且只能有一个*

tu4 = (1, 2, 3, 4)
*a, *b = tu4
print(a, b)

# 错误
File "D:/PyCharmproject/第7讲/第七讲.py", line 12
    *a, *b = tu4
    ^
SyntaxError: two starred expressions in assignment

• 字符串的拆包

a = 'abcdefg'
b, *c = a
print(b, c)

# 输出
a ['b', 'c', 'd', 'e', 'f', 'g']

• 列表的拆包

li = [1, 2 ,3, 4, 5]
a, b, *c = li
print(a, b, c)

# 输出
1 2 [3, 4, 5]

二. 字典

• 字典是映射关系（mapping），key：value，一个字典中，每一个key都是唯一的，我们只需要通过key就可以查找到我们需要的数据，key-value称之为键值对，也可以称呼它为一项item

1. 字典的简介

• {}

dict1 = {}
print(type(dict1))

# 输出
<class 'dict'>

dict2 = {'name': '喜羊羊', 'sex': '男'}
print(dict2, type(dict2))

# 输出
{'name': '喜羊羊', 'sex': '男'} <class 'dict'>

• 当字典中的key有重复的时候，后边的key-value会替换掉前边的

dict2 = {'name': '喜羊羊', 'sex': '男', 'name': '懒羊羊'}
print(dict2, type(dict2))

# 输出
{'name': '懒羊羊', 'sex': '男'} <class 'dict'>

• 当键值对一行放不下的时候，可以竖着排列

dict3 = {
    'name': '沸羊羊',
    'sex': '男',
    'age': '未知'
}
print(dict3)

# 输出
{'name': '沸羊羊', 'sex': '男', 'age': '未知'}

• 获取value

dict3 = {
    'name': '沸羊羊',
    'sex': '男',
    'age': '未知'
}
print(dict3['age'])

# 输出
未知

2. 字典的使用（创建）

（1）字典的创建

• {}，如上文
• 使用dict类去创建字典（有两种方法）

# 第一种
dict4 = dict(name='喜羊羊', age=10, sex='男')
print(dict4)

# 输出
{'name': '喜羊羊', 'age': 10, 'sex': '男'}

# 第二种：是在python2中的方法
dict5 = dict([('name', '喜羊羊'), ('age', 10), ('sex', '男')])
print(dict5)

# 输出
{'name': '喜羊羊', 'age': 10, 'sex': '男'}

• python2中有有序字典和无序字典：
  需要dict（）括号里的数据是属于一种双值子序列的形式
  双值序列：[1, 2]，子序列：（‘a’），双值子序列：[(1, 2),(3, 4)]

（2）字典的增删改查

• len（）

dict6 = dict(name='喜羊羊', age=10, sex='男')
print(len(dict6))

# 输出
3

• in，not in：检测的是key，检测不出来value

dict6 = dict(name='喜羊羊', age=10, sex='男')
print('name' in dict6)
print('喜羊羊' in dict6)

# 输出
True
False

• 获取值的方式

1. 使用key获取value，dict[key]，如果key不存在会报错

dict6 = dict(name='喜羊羊', age=10, sex='男')
print(dict6['name'])

# 输出
喜羊羊

dict6 = dict(name='喜羊羊', age=10, sex='男')
print(dict6['hobby'])

# 错误
Traceback (most recent call last):
  File "D:/PyCharmproject/第7讲/第七讲.py", line 42, in <module>
    print(dict6['hobby'])
KeyError: 'hobby'

2. dict.get（key），key不存在不会报错

dict6 = dict(name='喜羊羊', age=10, sex='男')
print(dict6.get('name'))

# 输出
喜羊羊

dict6 = dict(name='喜羊羊', age=10, sex='男')
print(dict6.get('hobby'))

# 输出
None

• 修改字典：dict[key] = value

dict6 = dict(name='喜羊羊', age=10, sex='男')
dict6['name'] = '懒羊羊'
print(dict6)

# 输出
{'name': '懒羊羊', 'age': 10, 'sex': '男'}

• 向字典中添加key-value：dict.setdefault(key, [default])

只有当key不存在的时候才可以加进去

dict6 = dict(name='喜羊羊', age=10, sex='男')
dict6.setdefault('friend', '懒羊羊')
print(dict6)

# 输出
{'name': '喜羊羊', 'age': 10, 'sex': '男', 'friend': '懒羊羊'}

当key存在的时候，不会改变原来的键值对

dict6 = dict(name='喜羊羊', age=10, sex='男')
dict6.setdefault('name', '懒羊羊')
print(dict6)

# 输出
{'name': '喜羊羊', 'age': 10, 'sex': '男'}

• 把其他字典中的key-value添加到当前字典中：dict.update()

dict6 = dict(name='喜羊羊', age=10, sex='男')
dict7 = dict(hobby='思考')
dict6.update(dict7)
print(dict6)

# 输出
{'name': '喜羊羊', 'age': 10, 'sex': '男', 'hobby': '思考'}

• 删除字典中的键值对：del

dict6 = dict(name='喜羊羊', age=10, sex='男')
del dict6['name']
print(dict6)

# 输出
{'age': 10, 'sex': '男'}

• 随即删除一个键值对：dict.popitem()，一般删除最后一个，并且会有返回值，返回值是删除的那个键值对

dict6 = dict(name='喜羊羊', age=10, sex='男')
a = dict6.popitem()
print(dict6)
print(a)

# 输出
{'name': '喜羊羊', 'age': 10}
('sex', '男')

• 根据key来删除键值对：dict.pop(key, [default])，也会有返回值，返回值是删除的key对应的value，当key值不存在的时候，返回的就是default

dict6 = dict(name='喜羊羊', age=10, sex='男')
a = dict6.pop('name')
print(dict6)
print(a)

# 输出
{'age': 10, 'sex': '男'}
喜羊羊

dict6 = dict(name='喜羊羊', age=10, sex='男')
a = dict6.pop('hobby', '删除的东西不存在')
print(dict6)
print(a)

# 输出
{'name': '喜羊羊', 'age': 10, 'sex': '男'}
删除的东西不存在

• 清空字典：dict.clear()

dict6 = dict(name='喜羊羊', age=10, sex='男')
dict6.clear()
print(dict6)

# 输出
{}

拓展 浅拷贝和深拷贝，遍历字典

1. 浅拷贝和深拷贝

（1）浅拷贝

• 浅拷贝就是dict.copy()或者copy.copy(想拷贝的字典)

dict789都有自己的存储位置，所以它们的id不一样

import copy
dict7 = {'1': 1, '2': 2}
dict8 = {'1': 1, '2': 2}
dict9 = copy.copy(dict7)
print(id(dict7), id(dict8), id(dict9))

# 输出
2102541770328 2102541770400 2102541799568

dict7中的列表自己有一个储存位置，当浅拷贝的时候，只能引用这个列表，也就是说，dict9和dict7的列表都是一个存储位置，即id相同

import copy
dict7 = {'1': 1, '2': 2, 'list1': [1, 2, 3]}
dict9 = copy.copy(dict7)
print(id(dict7['list1']), id(dict9['list1']))

# 输出
1967093531080 1967093531080

（2）深拷贝

• 深拷贝就是copy.deepcopy(想拷贝的字典)

import copy
dict7 = {'1': 1, '2': 2, 'list1': [1, 2, 3]}
dict9 = copy.deepcopy(dict7)
print(id(dict7), id(dict9))
print(id(dict7['list1']), id(dict9['list1']))

# 输出
2194336472664 2194337304296
2194337788488 2194337788680

因为深拷贝之后，dict9把dict7的列表重新拷贝了出来，并且有了一个储存位置，所以两个字典的列表的id不相同

（3）总结

浅拷贝只能对第一层的数据进行拷贝，如果第一层的数据也是可变类型，那么浅拷贝不能将这个数据重新拷贝出来形成新的id，深拷贝则可以拷贝所有的数据并且会形成新的id。

2. 遍历字典

• key的遍历

dict10 = dict(name='喜羊羊', age=10, sex='男')
for k in dict10.keys():
    print(k)
    
# 输出
name
age
sex

• value的遍历

dict10 = dict(name='喜羊羊', age=10, sex='男')
for v in dict10.values():
    print(v)

# 输出
喜羊羊
10
男

• 键值对的遍历

dict10 = dict(name='喜羊羊', age=10, sex='男')
for k, v in dict10.items():
    print(k, v)

# 输出
name 喜羊羊
age 10
sex 男

三. 作业

第一个作业

a = {“name”:“123”,“data”:{“result”:[{“src”:“python1”},{“src”:“python2”},{“src”:“python3”}]}} 找到python1/python2/python3

a = {"name": "123", "data": {"result": [{"src": "python1"}, {"src": "python2"}, {"src": "python3"}]}}
one = a["data"]['result'][0]['src']
print(one)
two = a['data']['result'][1]['src']
print(two)
three = a['data']['result'][2]['src']
print(three)

# 输出
python1
python2
python3

第二个作业

有如下值集合[11,22,33,44,55,66,77,88,99,90], 将所有大于66的值保存至字典的第一个key的值中，将小于66值保存至第二个key的值中。

li = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
list1 = []
list2 = []
for i in li:
    if i > 66:
        list1 += [i]
    if i < 66:
        list2 += [i]
dict1 = {'key1': list1, 'key2': list2}
print(dict1)

# 输出
{'key1': [77, 88, 99, 90], 'key2': [11, 22, 33, 44, 55]}

li = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
list1 = []
list2 = []
for i in li:
    if i > 66:
        list1.append(i)
    if i < 66:
        list2.append(i)
dict1 = {'key1': list1, 'key2': list2}
print(dict1)

# 输出
{'key1': [77, 88, 99, 90], 'key2': [11, 22, 33, 44, 55]}