回顾

在上一篇《Python列表详解》，我们介绍了列表的的相关知识，简单回顾一下：

1. 创建列表：[] 和list()函数两种创建方式
2. 访问列表元素：listname[i]、listname[start : end : step]、listname[:]
3. 列表添加元素：append、extend、insert
4. 列表删除元素：del、pop、remove、clear
5. 列表查找元素：count、index
6. 列表反转：reverse
7. 列表排序：sort-不生成新列表、sorted-生成新列表

一、元组

元组（tuple）是 Python 中另一个重要的序列结构，和列表类似，元组也是由一系列按特定顺序排序的元素组成，列表和元组都是有序序列。

1.list列表和tuple元组

元组和列表（list）的不同之处在于：

◆ 列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；

◆ 而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。

元组也可以看做是不可变的列表，通常情况下，元组用于保存无需修改的内容。

2.创建元组

Python 提供了两种创建元组的方法：

1) 使用( )直接创建

通过( )创建元组后，一般使用=将它赋值给某个变量，具体格式为：

tuplename = (element1, element2, ..., elementn)，例如：

# 通过()创建元组
t1 = ("c", "c++", "java", "python", "ruby")
print(t1)  # ('c', 'c++', 'java', 'python', 'ruby')
# 获取指定索引值
print(t1[2]) # java
# 查询指定范围内是否存在指定值，存在返回索引位置，不存在报错
print(t1.index('java', 0, -1)) # 2

2) 使用tuple()函数创建元组

除了使用( )创建元组外，Python 还提供了一个内置的函数 tuple()，用来将其它数据类型转换为元组类型。例如：

# 使用tuple()函数将其他数据类型转换为元组
list_1 = [1, 3, 5, 7, 9]
t2 = tuple(list_1)  # 列表强转为元组
print(t2)  # (1, 3, 5, 7, 9)
str_1 = "hello world"
t3 = tuple(str_1)  # 字符串强转为元组
print(t3)  # ('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')
dict_1 = {"name": "chen", "age": 28, "height": "75kg"}
t4 = tuple(dict_1)  # 字典强转为元组
print(t4)  # ('name', 'age', 'height')

二、Python dict字典详解

Python 字典（dict）是 Python 中唯一的映射类型，是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储。字典中，习惯将各元素对应的索引称为键（key），各个键对应的元素称为值（value），键及其关联的值称为“键值对”。总的来说，字典类型所具有的主要特征如下 所示：

1.创建字典

1）使用 { } 创建字典

由于字典中每个元素都包含两部分，分别是键（key）和值（value），因此在创建字典时，键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }中。使用{ }创建字典的语法格式如下：dictname = {'key':'value1', 'key2':'value2', ..., 'keyn':valuen}

# 使用{}创建
dict1 = {"name": "tom", "age": 28, "phone": 15252162666}

2）通过 fromkeys() 方法创建字典

Python 中，还可以使用 dict 字典类型提供的 fromkeys() 方法创建带有默认值的字典，具体格式为：

dictname = dict.fromkeys(list，value=None)

其中，list 参数表示字典中所有键的列表（list）；value 参数表示默认值，如果不写，则为空值 None。

# 通过 fromkeys() 方法创建字典
c = ['name', 'age', 'weight']
dict5 = dict.fromkeys(c)
dict6 = dict.fromkeys(c, "0")
print(dict5)  # {'name': None, 'age': None, 'weight': None}
print(dict6)  # {'name': '0', 'age': '0', 'weight': '0'}

2）通过 dict() 映射函数创建字典

格式1：dict1 = dict(key1=value1, key2=value2, key3=value3)

格式2：demo = [('two',2), ('one',1), ('three',3)]

dict2 = dict(demo)

格式3：

keys = ['one', 'two', 'three'] # 还可以是字符串或元组

values = [1, 2, 3] # 还可以是字符串或元组

dict3 = dict( zip(keys, values) )

# 使用dict()方法创建
dict2 = dict(age=28, name="tom", city="xuzhou")  # dict(key1=value1,key2=value2)
print(dict2)  # {'age': 28, 'name': 'tom', 'city': 'xuzhou'}

info = (("name", "lucy"), ("age", 28), ("city", "nanjing"), ("number", 227))
dict3 = dict(info)  # 使用dict()方法强制转换二维元组为字典
print(dict3)  # {'name': 'lucy', 'age': 28, 'city': 'nanjing', 'number': 227}

a = [1, 2, 3, 4]
b = ["a", "b", "c", "d"]
dict4 = dict(zip(a, b))  # 使用dict()方法结合zip()方法将等长的列表转换为字典
print(dict4)  # {1: 'a', 2: 'b', 3: 'c', 4: 'd'}

2.访问字典元素

列表和元组是通过下标来访问元素的，而字典不同，它通过键来访问对应的值。

1）Python 访问字典元素的具体格式为：dictname[key]

其中，dictname 表示字典变量的名字，key 表示键名。注意，键必须是存在的，否则会抛出异常。

tup = (['one', 100], ['two', 200], ['three', 300], ['four', 400])
dict1 = dict(tup)
print(dict1['one'])  # 键存在，返回对应value
print(dict1['six'])  # 键不存在，抛出异常

运行结果如下：

2）get() 方法的语法格式为：dictname.get(key[,default])

其中，dictname 表示字典变量的名字；key 表示指定的键；default 用于指定要查询的键不存在时，此方法返回的默认值，如果不手动指定，会返回 None。

# 访问字典元素
dict7 = {'age': 28, 'name': 'tom', 'city': 'xuzhou'}
print(dict7["age"])  # 28
print(dict7.get("age"))  # 28
print(dict7.get("age", 18))  # 28，设置默认返回值，检索到key时，返回key的实际值
print(dict7.get("age111", 18))  # 18，设置默认返回值，未检索到key时，返回默认值

3.字典添加键值对

为字典添加新的键值对很简单，直接给不存在的 key 赋值即可，具体语法格式如下：dictname[key] = value

各个部分的说明：

◆ dictname 表示字典名称。

◆ key 表示新的键。

◆ value 表示新的值，只要是 Python 支持的数据类型都可以。

# 字典添加键值对
dict8 = {'age': 28, 'name': 'tom', 'city': 'xuzhou'}
dict8["number"] = 227  # 如果存在此键，则更新键值，不存在则添加新键值对
print(dict8)  # {'age': 28, 'name': 'tom', 'city': 'xuzhou', 'number': 227}

4.判断字典中是否存在指定键值对

判断字典是否包含指定键值对的键，可以使用 in 或 not in 运算符。

# 判断字典是否包含指定键值对的键
dict9 = {'age': 28, 'name': 'tom', 'city': 'xuzhou'}
assert 'name' in dict9
assert 'address' not in dict9

5.查看dict所有方法

Python 字典的数据类型为 dict，我们可使用 dir(dict) 来查看该类型包含哪些方法

>>> dir(dict)
['clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

6.keys()、values() 和 items() 方法

◆ keys() 方法用于返回字典中的所有键（key）；

◆ values() 方法用于返回字典中所有键对应的值（value）；

◆ items() 用于返回字典中所有的键值对（key-value）；

# 返回字典中的所有键
print(dict9.keys())  # dict_keys(['age', 'name', 'city'])
# 返回字典中的所有键的键值
print(dict9.values())  # dict_values([28, 'tom', 'xuzhou'])
# 返回字典中的所有键值对
print(dict9.items())  # dict_items([('age', 28), ('name', 'tom'), ('city', 'xuzhou')])

7.copy()方法-深拷贝与浅拷贝

copy() 方法返回一个字典的拷贝，也即返回一个具有相同键值对的新字典。

深拷贝与浅拷贝：

◆ 浅拷贝：若拷贝的对象是一个可变对象，如字典、列表等，拷贝的只是内存地址，只要其中一个被更改，则拷贝前和拷贝后的对象都会被更改

◆ 深拷贝：deepcopy()方法copy的对象，会新生成一个内存地址，故被拷贝对象的可变元素被更改后不会影响拷贝后的结果

# 拷贝字典
import copy
dict10 = {'age': 28, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou']}
# 浅拷贝：通过dict自带的copy方法
dict11 = dict10.copy()
# 浅拷贝：通过引入copy模块的copy()方法拷贝
dict12 = copy.copy(dict10)
# 深拷贝：通过引入copy模块的deepcopy()方法拷贝
dict13 = copy.deepcopy(dict10)
dict10["city"].remove('xuzhou')
print(dict11)  # {'age': 28, 'name': 'tom', 'city': ['suzhou', 'hangzhou']}
print(dict12)  # {'age': 28, 'name': 'tom', 'city': ['suzhou', 'hangzhou']}
print(dict13)  # {'age': 28, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou']}

8.update() 方法

update() 方法可以使用一个字典所包含的键值对来更新已有的字典。

在执行 update() 方法时，如果被更新的字典中己包含对应的键值对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的键值对，则该键值对被添加进去。

# 更新字典
dict14 = {'age': 28, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou']}
dict14.update({"age": 18})
print(dict14)  # {'age': 18, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou']}
dict14.update({"num": 227})
print(dict14)  # {'age': 18, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou'], 'num': 227}

9.pop() 和 popitem() 方法

pop() 和 popitem() 都用来删除字典中的键值对，不同的是，pop() 用来删除指定的键值对，而popitem() 用来随机删除一个键值对，语法格式如下：

◆ dictname.pop(key)

◆ dictname.popitem()

# 删除字典元素
dict15 = {'age': 18, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou'], 'num': 227}
dict15.pop('age')  # 删除指定键值对
print(dict15)  # {'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou'], 'num': 227}
pi = dict15.popitem()  # 删除最后一个键值对，返回值是被删除的键值对
print(pi)  # ('num', 227)
print(dict15)  # {'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou']}
del dict15["city"]  # 通过del删除指定键值对
print(dict15)  # {'name': 'tom'}

10.setdefault() 方法

setdefault() 方法用来返回某个 key 对应的 value，其语法格式如下：

dictname.setdefault(key, defaultvalue=None)

说明，dictname 表示字典名称，key 表示键，defaultvalue 表示默认值（可以不写，不写的话是 None）。

# 字典key设置默认值
dict16 = {'age': 18, 'name': 'tom', 'num': 227}
dict16.setdefault('name', 'lucy')  # 键存在时，不更新
print(dict16)  # {'age': 18, 'name': 'tom', 'num': 227}
dict16.setdefault('city', 'xuzhou')  # 键不存在时，更新字典
print(dict16)  # {'age': 18, 'name': 'tom', 'num': 227, 'city': 'xuzhou'}

总结

列表和元组都是有序序列，字典是无序序列；

列表和字典都是可变序列，元组是不可变序列；