元组和字典的使用

1. 元祖知识点

1.1 元祖的创建

元祖属于不可变序列。一般情况，当希望数据不改变时，使用元祖，其余情况使用列表。

• ()可以创建一个空的元祖，数据类型tuple；

tup = (1, 2, 3, 4, 5)
print(tup, type(tup))
# 结果：
(1, 2, 3, 4, 5) <class 'tuple'>

• 可以通过下标获取相应的元素，但不可以对其进行修改；

tup = (1, 2, 3, 4, 5)
print(tup[0])
tup[0] = 10
# 结果：
1
TypeError: 'tuple' object does not support item assignment

• 如果元祖不是空的，则它里面至少得有一个英文的逗号；

tup1 = 10,
print(tup1, type(tup1))
tup2 = 'hello',
print(tup2, type(tup2))
# 结果：
(10,) <class 'tuple'>
('hello',) <class 'tuple'>

笔者也把这种方式理解为元祖的另一种创建方法，从结果看对 int 和 str 的类型都是适用的。

1.2 元祖的解包

• 解包指将元祖中每一个元素赋值给一个变量；
  首先看一个代码示例：

tup = 10, 20, 30, 40
a, b, c, d = tup
print('a = ', a)
print('b = ', b)
print('c = ', c)
print('d = ', d)
# 结果：
a =  10
b =  20
c =  30
d =  40

代码中呈现了一个有4个元素的元祖，将数据分别赋值给四个变量。

• 解包的时候，变量的数量需要和元祖中元素的数量保持一致；

tup = 10, 20, 30, 40
# 这里只给出两个变量承接元祖的元素
a, b = tup
print('a = ', a)
print('b = ', b)
# 结果：
ValueError: too many values to unpack (expected 2)

• 如果变量与元素数量无法保持一致，可以在变量前面加上*，这样变量就会获取元祖中所有剩余的元素，并以列表的形式返回。

tup = 10, 20, 30, 40
a, b, *c = tup
print('a = ', a)
print('b = ', b)
print('c = ', c)
# 结果：
a =  10
b =  20
c =  [30, 40]

从上述代码的结果看，变量a和b分别得到元祖中第一个和第二个元素的值，而剩余元素全部给了变量c，且以列表的形式返回。
* 可以放在a和b身上，理解起来就是不打 * 的变量按照顺序分配元素的值，剩余元素打包给打 * 的变量。

# * 放在b，执行结果：
a =  10
b =  [20, 30]
c =  40
# * 放在a，执行结果：
a =  [10, 20]
b =  30
c =  40

但 * 只能使用一次，使用多次会报错。

tup = 10, 20, 30, 40
# 多次使用 *
*a, *b, c = tup
print('a = ', a)
print('b = ', b)
print('c = ', c)
# 结果：
SyntaxError: two starred expressions in assignment

2. 可变对象

2.1 基本概念

• 对象当中保存了三个数据，分别是id(标识)、type(类型)、value(值)；

a = [1, 2, 3]
print('a的id: ', id(a))
print('a的类型:', type(a))
print('a = ', a)

• 可变对象指的是对象里面的value可以被用户改变；
  列表就是一个可变对象，a[0] = 10 只是修改对象里面的value，不会改变变量指向的对象。

a = [1, 2, 3]
print('修改前:', a, id(a))
# 通过变量修改对象里面的值，不会改变变量指向的对象
a[0] = 10
print('修改后:', a, id(a))
# 结果：
修改前: [1, 2, 3] 1993392014536
修改后: [10, 2, 3] 1993392014536

可以看出，a里面的值虽然改变，但是id没有变化，还是指向同一个对象。

a = [4, 5, 6] 则直接修改了a指向的对象，这种操作是在给变量重新赋值，会改变变量指向的对象。

a = [1, 2, 3]
print('修改前:', a, id(a))
# 修改变量，是在给变量重新赋值，会改变变量指向的对象
a = [4, 5, 6]
print('修改后:', a, id(a))
# 结果：
修改前: [1, 2, 3] 1964041258184
修改后: [4, 5, 6] 1964042059336

从结果看，a的id发生变化，已经指向了另一个对象。

2.2 相关示例

看如下一组代码：

a = [1, 2, 3]
b = a
b[0] = 10
print('a:', a, id(a))
print('b:', b, id(b))
# 结果：
a: [10, 2, 3] 2411208000712
b: [10, 2, 3] 2411208000712

上述代码中，修改了b的值，打印a后发现，a的值也被改变。这是因为 b=a 这步操作使得 a 和 b 指向同一个对象（ a 和 b 的id是一样的），修改了b的值等同于修改了a的值。

再看变量 b 的另一种操作：

a = [1, 2, 3]
b = a
b = [10, 2, 3]
print('a:', a, id(a))
print('b:', b, id(b))
# 结果：
a: [1, 2, 3] 1754105201864
b: [10, 2, 3] 1754106003016

b = [10, 2, 3] 这步操作是给变量 b 重新赋值，改变了 b 指向的对象，从结果看 a 和 b 的 id 不一样。

2.3 对象的比较

• == 比较的是对象的值是否相等；
• is / is not 比较的是对象的id是否相等。

a = [1, 2, 3]
b = [1, 2, 3]
print(a, id(a))
print(b, id(b))
print('a == b: ', a == b)
print('a is b: ', a is b)
# 结果：
[1, 2, 3] 2169126667464
[1, 2, 3] 2169127468616
a == b:  True
a is b:  False

从结果看，a 和 b 的值相等，但并不是同一个对象。

3. 字典知识点

3.1 基本概念

• 字典属于一种新的数据结构，称之为映射。
• 字典的作用和列表类似，都是用来存储对象的容器，属于可变对象。
• 为什么要使用字典？——列表存储数据的性能很好，但是查询数据的性能很差。而字典存储数据的性能相对较差，但是查询数据的性能很好。
• 在字典中，每一个元素都有唯一的名字，通过这个唯一的名字就可以快速查找到指定的元素。
• 在字典中，唯一的名字称为键key，通过key可以快速查询到value，所以字典又被称之为键值对(key-value)。
• 每个字典当中可以有多个键值对，每一个键值对称之为一项(item)。

3.2 字典的创建

• 语法 {key:value, key:value …}；

d = {'name': '张无忌', 'age': 20, 'sex': '男'}
print(d, type(d))
# 结果：
{'name': '张无忌', 'age': 20, 'sex': '男'} <class 'dict'>

• 字典的键最好不要重复，如果出现重复后面的会替换前面；

d = {'name': '张无忌', 'age': 20, 'sex': '男', 'name': '杨过'}
print(d, type(d))
# 结果：
{'name': '杨过', 'age': 20, 'sex': '男'} <class 'dict'>

从结果看，name键重复，其原有对应的值会被后面的值替换。

• 使用dict() 创建字典；
  dict() 使用关键字的参数传递创建字典。

d = dict(name='张无忌', age=20, sex='男')
print(d, type(d))
# 结果：
{'name': '张无忌', 'age': 20, 'sex': '男'} <class 'dict'>

• dict() 也可以将一个包含有双值子序列的序列转化为字典；
  双值序列，序列中只有两个值，例如 ‘mk’、[4, 5]、[‘a’, ‘b’]，不用管序列中元素的数据类型。
  子序列，序列中的元素也是个序列，那么我们就称这个元素为子序列，例如[(‘w’, 1), (1,2)]

d = dict([('name', '张无忌'), ('age', 10)])
print(d, type(d))
# 结果：
{'name': '张无忌', 'age': 10} <class 'dict'>

3.3 字典的使用

• 字典对象是根据键来获取值；

d = {'name': '张无忌', 'age': 20, 'sex': '男'}
print(d['name'])
print(d['age'])
print(d['sex'])
# 结果：
张无忌
20
男

通过名字就可以快速地获取对应的值。
key 值要加上引号，不加引号会被当成变量来处理。

d = {'name': '张无忌', 'age': 20, 'sex': '男'}
n = 'name' # n 是变量，值为‘name’
print(d[n]) # 此时的键值不能加引号
# 结果：
张无忌

key 可以是一个变量，但如果作为变量来查找元素的值时，不能加引号。

• 通过 get() 获取字典中元素的值；

d = {'name': '张无忌', 'age': 20, 'sex': '男'}
print(d.get('name')) # 参数传递的是key值
# 结果：
张无忌

使用 get() 的好处是如果获取的key值不存在，会返回一个None常量。

d = {'name': '张无忌', 'age': 20, 'sex': '男'}
print(d.get('name1')) # name1 这个键值不存在
# 结果：
None

default 也可以指定一个默认值，来作为第二个参数。如果获取不到key，则返回默认值。

d = {'name': '张无忌', 'age': 20, 'sex': '男'}
print(d.get('name1', '键值不存在'))
# 结果：
键值不存在

这种方式相比直接报bug，要柔和很多。

• 通过key值修改字典，d[key] = value；
  如果键存在，则修改值
  如果键不存在，是向字典中添加key-value

d = {'name': '张无忌', 'age': 20, 'sex': '男'}
d['name'] = '杨过'
d['id'] = 123456
print(d)
# 结果：
{'name': '杨过', 'age': 20, 'sex': '男', 'id': 123456}

看结果，‘name’ 的值被修改，而原本字典中不存在’id’，d[‘id’] = 123456 操作后添加了该键值对。

• d.setdefault() 方法，向字典中添加key-value；
  如果 key 已经存在于字典中，则返回key的值，不对字典做任何操作；
  如果 key 不存在于字典中，则向字典中添加key-value。

d = {'name': '张无忌', 'age': 20, 'sex': '男'}
a = d.setdefault('name', '杨过')
b = d.setdefault('id', 123456)
print(d)
print(a)
print(b)
# 结果：
{'name': '张无忌', 'age': 20, 'sex': '男', 'id': 123456}
张无忌
123456

d.setdefault() 有返回值，‘name’ 已经存在，返回其原本的值给变量a。而‘id’ 不存在，向字典中添加键值对后，又将元素的值返回给变量b。

• update() 将其他字典当中的键值对添加到当前字典中；

d = {'name': '张无忌', 'age': 20, 'sex': '男'}
d2 = {'id': 123456}
d.update(d2)
print(d)
print(d2)
# 结果：
{'name': '张无忌', 'age': 20, 'sex': '男', 'id': 123456}
{'id': 123456}

update() 是将参数中的字典添加操作字典对象中，如果有重复键值，会覆盖原有的键值对（字典特性）。

• 删除字典中的元素
  使用 del 来删除 key-value。
  popitem() 随机删除 字典中的 key-value，但一般都是最后一对。
  popitem() 有返回值，会把删除的 key-value 作为返回值返回。
  pop() 可以根据 key 删除 value，返回值是删除的value值。如果删除的key不存在，会报错，但是可以指定默认值（与 get() 一样）。

d = {'name': '张无忌', 'age': 20, 'sex': '男', 'id': 123456, '武学': '乾坤大挪移'}
del d['age']
print('删除age后: ', d)
a = d.popitem()
b = d.pop('sex')
c = d.pop('123', '键值不存在')
print('使用popitem删除元素: ', d)
print('被popitem删除的元素: ', a)
print('被pop删除的元素: ', b)
print('pop删除不存在的键值：', c)
# 结果:
删除age后:  {'name': '张无忌', 'sex': '男', 'id': 123456, '武学': '乾坤大挪移'}
使用popitem删除元素:  {'name': '张无忌', 'id': 123456}
被popitem删除的元素:  ('武学', '乾坤大挪移')
被pop删除的元素:  男
pop删除不存在的键值： 键值不存在

• clear() 用来清空字典

d.clear()
# 结果：
清空字典： {}