字典

字典基本知识

字典（Dict）是可变的无序集合，同时是一种以键值对为基本元素的可以存储各种数据类型的集合，用大括号（{ }）表示字典的开始和结束，元素之间用逗号（,）分隔。
键值对，由键（Key）和值（Value）组成，中间用冒号（:）分隔。采用键值对，可以更加独立而紧密地表示两者之间的关系。从键值对可以看出，字典属于典型的一对一映射关系的数据类型。

1. 基本格式

{}                        # 空字典
dict1 = {'ajian': 18}
len(dict1)                # 字典元素个数
# 1
dict2 = {1: 'car', 2: 'bus'}
len(dict2)
# 2

2. 键、值设置要求
   （1）键的设置要求
   a. 唯一性
   一个字典对象里所有的键必须唯一。

dict3 = {1: 'car', 2: 'bus', 3: 'bus'}
len(dict3)
# 2
dict3
# {1: 'car', 2: 'bus'}

把相同键值对的元素保留最后一个。

dict4 = {1: 'car', 2: 'bus', 2: 'train'}
len(dict4)
# 2
dict4
# {1: 'car', 2: 'train'}

字典只保留了键相同的最后一个元素。
b. 不可变性
在字典使用过程中，不能对元素的键进行直接修改。修改方式之后介绍。
（2）值的设置要求
字典对象的键值对的值可以是Python语言支持的任何对象。

3. 字典的基本方法

方法名称	功能描述
clear	字典清空
copy	复制生成另一个字典
fromkeys	使用给定的键建立新的字典，每个键默认对应的值为None
get	根据指定键，返回对应值，访问键不存在时，返回None
items	以元组数组的形式返回字典中的元素
keys	以可以浏览的类似列表的形式返回字典中的键
pop	删除指定键的元素，并返回指定键对应的值
popitem	随机返回元素，并删除元素
setdefault	当字典中键不存在时，设置键值对；当存在键时，获取键对应的值
update	利用一个字典更新另外一个字典
values	以可以浏览的类似列表形式返回字典中的值

字典元素增加

1. 利用赋值给字典增加元素

dict1 = {'ajian': 18, 'atian': 20}
dict1['afei'] = 8
print(dict1)
# {'ajian': 18, 'atian': 20, 'afei': 8}

2. 利用setdefault()方法给字典增加元素
   setdefault()使用格式为D.setdefault(k[,d])。其中，D代表字典对象，k代表新增键，d代表新增键对应的值（如果不提供值，则默认值为None）。

dict1 = {'ajian': 18, 'atian': 20}
dict1.setdefault('afei': 8)
# 8
print(dict1)
# {'ajian': 18, 'atian': 20, 'afei': 8}
dict1.setdefault('axin')
print(dict1)
# {'ajian': 18, 'atian': 20, 'afei': 8, 'axin': None}

注意： setdefault()方法新增键值对时，若指定键已经存在，则显示已经存在键的值。

字典值查找

1. 字典名+[Key]查找

dict2 = {'ajian': 18, 'atian': 20, 'afei': 8}
print(dict2['atian'])
# 20

2. 利用get()方法查找
   使用格式为D.get(k[,d])。

dict2 = {'ajian': 18, 'atian': 20, 'afei': 8}
print(dict2.get('atian'))
# 20

get()方法在指定键不存在时返回空值，而不是报错。

字典值修改

1. 利用赋值修改键对应的值

dict1 = {'ajian': 18, 'atian': 20, 'afei': 8}
dict1['afei'] = 22
print(dict1)
# {'ajian': 18, 'atian': 20, 'afei': 22}

2. 利用update()方法修改键对应的值
   update()方法的使用格式为D.update(d1)。D为更新的字典，d1为提供更新内容的字典。若d1里提供的键在D里存在，则更新D里对应的键值；若d1里提供的键不在D里，则增加键值对。

dict1 = {'ajian': 18, 'atian': 20, 'afei': 8}
dict2 = {'ajian': 20, 'atian': 25}
dict1.update(dict2)
print(dict1)
# {'ajian': 20, 'atian': 25, 'afei': 8}
dict1.update({'axin': 24})
print(dict1)
# {'ajian': 20, 'atian': 25, 'afei': 8, 'axin': 24}

字典元素删除

1. 利用del函数删除

dict1 = {'ajian': 20, 'atian': 25, 'afei': 8, 'axin': 24}
del(dict1['axin'])
print(dict1)
# {'ajian': 20, 'atian': 25, 'afei': 8}

2. 利用pop()方法删除
   pop()方法的使用格式为D.pop(k[,d])。

dict1 = {'ajian': 20, 'atian': 25, 'afei': 8, 'axin': 24}
pop1 = dict1.pop('axin')
print(pop1)
# 24
print(dict1)
# {'ajian': 20, 'atian': 25, 'afei': 8}

3. 利用popitem()方法删除
   popitem()方法的使用格式为D.popitem()。D代表字典对象，随机返回一个键值对元组，并在字典里删除对应的元素。

dict1 = {'ajian': 20, 'atian': 25, 'afei': 8, 'axin': 24}
k_v = dict1.popitem()
print(k_v)
# ('axin', 24)
print(dict1)
# {'ajian': 20, 'atian': 25, 'afei': 8}

字典遍历操作

1. 遍历所有键值对
   利用items()方法遍历所有键值对。使用格式为D.items()。

dict1 = {'ajian': 20, 'atian': 25, 'afei': 8, 'axin': 24}
for k_v in dict1.items():
    print(k_v)
# ('ajian', 20)
# ('atian', 25)
# ('afei', 8)
# ('axin', 24)

print(dict1.items())
# dict_items([('ajian', 20), ('atian', 25), ('afei', 8), ('axin', 24)])

print(type(dict1.items))
# <class 'builtin_function_or_method'>

2. 遍历所有的键
   1）利用字典变量循环遍历

dict1 = {'ajian': 20, 'atian': 25, 'afei': 8, 'axin': 24}
for k in dict1:
    print(k)
# ajian
# atian
# afei
# axin 

2）利用keys() 方法获取字典键

dict1 = {'ajian': 20, 'atian': 25, 'afei': 8, 'axin': 24}
for k in dict1.keys():
    print(k)
# ajian
# atian
# afei
# axin 

3. 遍历所有的值
   1）通过键遍历值

dict1 = {'ajian': 20, 'atian': 25, 'afei': 8, 'axin': 24}
for k in dict1:
    print(dict1[k])
# 20
# 25
# 8
# 24

2）利用values()方法获取字典值

dict1 = {'ajian': 20, 'atian': 25, 'afei': 8, 'axin': 24}
for v in dict1.values():
    print(v)
# 20
# 25
# 8
# 24

其他操作方法

1. in成员操作
   字典的元素对象、键对象、值对象，其实质上构成了相应的集合，由此可以通过集合成员操作符号进行相关操作。

dict1 = {'ajian': 20, 'atian': 25, 'afei': 8, 'axin': 24}
if 'ajian' in dict1.keys():
    print('存在')
else:
    print('不存在')
#  存在

2. clear()方法

dict3 = {'aa': 'a', 'bb': 'b'}
dict3.clear()
print(dict3)
# {}

3. copy()方法
   通过copy()方法的复制，可以避免字典变量之间直接赋值指向同一个地址的问题。
   注意： 字典的copy()复制是深度复制，复制后产生的两个字典变量完全没有关系，互不影响。
4. fromkeys()方法
   使用格式为D.fromkeys(iterable)，D代表字典变量，iterable代表列表对象，用于指定字典键，生成的D的键对应的值默认是None。

dict9 = {}.fromkeys(['ajian', 'atian', 'afei'])
print(dict9)
# {'ajian': None, 'atian': None, 'afei': None}

字典嵌套

字典可以嵌套字典，也可以与列表互相嵌套。具体场景具体分析。
优点：

1. 可以很方便地体现数据之间的关系。
2. 体现了字典记录数据的灵活性。如横向的可以记录几条数据，竖向的也可以记录几条数据。