Python：元组和字典简述

1.列表的方法

列表主要有以下方法：

1. append() 向列表的最后来添加一个元素
2. insert() 参数1.插入的位置 2.插入的函数
3. extend（）使用新的序列来扩展当前的序列
4. clear() 清空序列
5. pop() 根据索引来删除，并且可以返回被删除的值
6. remove（）删除指定值的元素，remove没有返回值
7. reverse() 翻转列表
8. sort（）队列表中的元素进行排序，默认是升序，如果是降序要传入参数 reverse = True
   请参考下列代码每个方法的用法：

lst = [1,2,3,4,5]
lst.append(6)
print(lst)
lst.insert(6,7)
print(lst)
lst.extend([8,9])
print(lst)
lst.remove(2)
print(lst)
lst.pop(0)
print(lst)
lst.reverse()
print(lst)
lst.sort()
print(lst)
lst.clear()
print(lst)

下面是调用每一个方法之后的结果：
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 4, 5, 6, 7, 8, 9]
[3, 4, 5, 6, 7, 8, 9]
[9, 8, 7, 6, 5, 4, 3]
[3, 4, 5, 6, 7, 8, 9]
[]

2. for循环遍历列表

2.1 语法

for 变量 in 序列（遍历的规则）:
代码块

lst = [1,2,3,4,5,6]
for i in lst:
    print(i)

这个代码的执行结果就是：
1
2
3
4
5
6
由此可见，这里for循环就是将lst列表中的元素赋值给了i, 对每个元素分别赋值一次，通过这个方法，我们就可以把lst列表中的每个元素抓取出来。

2.2 range()函数

range（）函数的作业可以用来生成一个自然序。range()函数语法：range(start, stop, step)。其中：

• start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于 range（0， 5）
• stop: 计数到 stop 结束，但不包括 stop，和列表一样。。例如：range（0， 5） 是[0, 1, 2, 3, 4]，没有5
• step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
  range（）函数经常和for循环一起使用，可以方便我们直接拿出想要的数据。比如2.1当中的列子通过range()函数来实现，就不需要定义一个列表lst：

for i in range(1,7):
    print(i)

这个代码的执行结果和2.1中一样，也是：
1
2
3
4
5
6
由此可见，for循环和range（）函数一起使用可以使我们快速让代码执行我们需要的次数。

3. 元组

3.1 元组的基本概念

• 元组的表现形式是tuple，并且是一个不可变序列。所以当我们希望数据不改变时，我们使用元组，其他时候基本上使用列表。

3.2 元组的创建

• 元组用()小括号来创建，当元组不是控元组，至少需要有一个逗号，这时括号可以省略。例如：

a = 1,2,
print(a,type(a))

代码的执行结果是：
(1, 2) <class ‘tuple’>

3.3 元组的解包

• 元组解包指将元组当中的每一个元素都赋值给一个变量，例如：

a,b,c,d = 1,2,3,4,
print(a)
print(b)
print(c)
print(d)

代码的执行结果是：
1
2
3
4
由此可见，原本是（1,2,3,4）的元组分别赋值给了a,b,c,d四个变量

3.3.1 *号在解包中的用法

在解包的时候，在其中一个变量前加上*，代表，按照位置排序，分别赋值给其他变量后，剩余的元素用序列的方式赋值给这个带号的变量，例如：

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

代码执行结果是：
1
[2, 3]
4
由此可见，没有星号的a，和 c 先进行了赋值，按照位置分别是第一个1，和最后一个4，剩下的2,3转换为列表赋值给了b。

4.字典

4.1 字典的基本概念

• 字典属于⼀种新的数据结构称为映射(mapping)
• 字典的作⽤和列表类似，都是用来存储对象的容器，列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反
• 在字典中每⼀个元素都有唯⼀的名字，通过这个唯⼀的名字可以找到指定的
• 元素这个唯⼀的名字我们称之为key 通过key可以快速查询value 也可以称之为值
• 字典我们也称之为键值对(key-value)结构
• 每个字典中都可以有多个键值对，而每⼀个键值对我们称其为⼀项(item)
• 创建⼀个有数据的字典 语法 {key:value}
• 字典的值可以是任意对象 字典的键可以是任意的不可变对象(int str bool tuple…)
• 字典的键是不能重复的，如果出现重复的后⾯的会替换前面的
  字典键值对的特点，让我们可以对字典用键来查找值，例如：

d = {'name':'水冰月','age':18,'gender':'女','ability':'美少女变身'}
print(d['name'],d['ability'])

执行结果如下：
水冰月 美少女变身
由此可见，我们通过两个key，name和ability，查找到了他对应的值,水冰月和美少女变身。这就是字典最重要的查找功能。

4.2 字典的使用

4.2.1 字典的创建

• 字典可以用dict()来创建，也可以讲一个包含有双值子序列的序列转换为字典。
• 双值序列：就是有2个值的序列，可以是元组，可以是列表，也可以是字符串
• 子序列：序列当中包含另外一个序列，那么这个元素就是子序列
  例如：

d = dict({'name':'水兵月','ability':'美少女变身'})
a = ('name','蜘蛛侠')
b = ('ability','弹射蜘蛛网')
d1 = dict([a,b])
print(d,type(d))
print(d1,type(d1))

代码执行结果如下：
{‘name’: ‘水兵月’, ‘ability’: ‘美少女变身’} <class ‘dict’>
{‘name’: ‘蜘蛛侠’, ‘ability’: ‘弹射蜘蛛网’} <class ‘dict’>
由此可见，我们用2种方法都成功创建了字典。

4.2.2 通过Key获取值

• 直接用dict['key’]的方式来获取
• 可用调用get方法来获取
  例如：

d = dict({'name':'水兵月','ability':'美少女变身'})
result1 = d.get('ability')
result2 = d.get('age')
result3 = d.get('age','没有该键')
print(d['ability'])
print(result1)
print(result2)
print(result3)

代码执行结果如下：

美少女变身
美少女变身
None
没有该键

首先说明,如果我们用dict['key’]来取值，key不存在的话，程序会报错Key Error, 那么我们就可以知道，get方法的好处就是在key不存在的时候可以不报错，并且还可以返回一个默认值。对比result2和result3我们就可以得到此结论。

4.2.3 字典的通用方法

• in 检查一个值是否在字典中，返回一个布尔值
• not in 检查一个值是否不在字典中，返回一个布尔值
• len() 获取字典中键值对的个数
• pop() 根据key删除字典中的k-v,返回一队k,v的元组
• popitem() 随机删除字典中的一个k-v，但是一般都会删除最后一个，删除之后会将删除的k-v作为返回值返回，返回一个元组
• update() 将其他自动中的k-v添加到当前的字典中，如果有重复的key，后面的覆盖前面的。
• setdefault(key,default)可以向字典中添加key-value，如果字典中的Key已经存在，不会对字典有任何操作或者影响。
• 删除 可以用del关键字来删除字典中的k-v
• clear() 清空字典
  请参考下列代码每个方法的用法：

d = {'a':1,'b':2,'c':3}
print('a' in d)
print('a' not in d)
print(len(d))
d.popitem()
print(d)
d.update({'e':4})
print(d)
d.pop('b')
print(d)
d.setdefault('f',5)
print(d)
del d['f']
print(d)
d.clear()
print(d)

下面是调用每一个方法之后的结果：
True
False
3
{‘a’: 1, ‘b’: 2}
{‘a’: 1, ‘b’: 2, ‘e’: 4}
{‘a’: 1, ‘e’: 4}
{‘a’: 1, ‘e’: 4, ‘f’: 5}
{‘a’: 1, ‘e’: 4}
{}

4.2.4 浅复制

首先了解复制与赋值的区别，请看代码：

d = {'a':1,'b':2,'c':3}
d1 = d
d2 = d.copy()
d['b'] = 4
print('d=',d)
print('d1赋值的结果为',d1)
print('d2复制的结果为',d2)

程序执行结果为:
d= {‘a’: 1, ‘b’: 4, ‘c’: 3}
d1赋值的结果为 {‘a’: 1, ‘b’: 4, ‘c’: 3}
d2复制的结果为 {‘a’: 1, ‘b’: 2, ‘c’: 3}
由此可见，赋值的结果会随着原样本的改变而变化，复制的结果不受原样本的影响，这就是复制的特点。

接下来了解浅复制和深复制

import copy
d = {'a':{'name':'水冰月'},'b':2,'c':3}
d1 = d.copy()
d2 = copy.deepcopy(d)
d['a']['name'] = '天线宝宝'
print('d=',d)
print('d1浅复制的结果为',d1)
print('d2深复制的结果为',d2)

代码执行结果如下：
d= {‘a’: {‘name’: ‘天线宝宝’}, ‘b’: 2, ‘c’: 3}
d1浅复制的结果为 {‘a’: {‘name’: ‘天线宝宝’}, ‘b’: 2, ‘c’: 3}
d2深复制的结果为 {‘a’: {‘name’: ‘水冰月’}, ‘b’: 2, ‘c’: 3}

由此可见，当原字典样本中value为一个子字典的时候，我们用copy()这种方法，其复制特点会失效，子字典中的value会随着原字典样本的改变而改变。而我们使用copy.deepcopy这种方法的时候，子字典中的结果不会随着原字典样本的中的value改变而改变。

我们称第一种copy()的方法为浅复制，第二种copy.deepcopy的方法，为深复制。