【Python 基础篇】Python内建类型 之 dict

目录

一 定义字典

1.1 定义空字典

1.2 访问字典的值

1.3 修改字典的值

1.4 删除字典的值

1.5 获取字典的长度

1.6 字典转成列表

1.7 获取字典所有键

1.8 获取字典所有键

1.9  循环遍历字典

1.10  检查某个键是否在字典中

1.11  字典中的一个陷阱

二 字典的练习

---

今天学习一下 “字典”。字典是另一种可变容器模型，可以存储任何类型对象。学过其它脚本语言的同学，应该知道，字典不是Python 所独有的一个数据类型。我们在perl 编程中，早就接触到这个概念。

字典是由键值对组成，键和值之间由: 冒号分割，多个键值对之间由逗号分隔，最后整个字典由大括号包裹完成。例如：｛'a':1, 'b':2, 'c':3｝

注意：

字典的键是唯一的，但是值不一定是唯一的。

字典的值可以是任何数据类型，但是字典的键必须是不可变的数据结构，比如：字符串、数字、元组，但是字典和列表不可以。因为字典和列表示可变结构。

字典是一个无顺序的数据结构。

一 定义字典

1.1 定义空字典

my_dict1 = dict()  // 方式1
my_dict2 = {}  // 方式2

d = {} # 定义空字典
d = dict() # 定义空字典
d = {'a': 1, 'b': 2, 'c': 3}
d = {'a': 1, 'a': 1, 'a': 1} # { 'a': 1} key 不能重复, 取最后一个， 但不报错
d = {'a': 1, 'b': {'x': 3}} # 嵌套字典
d = {'a': [1,2,3], 'b': [4,5,6]} # 嵌套列表

# 以下均可定义如下结果
# {'name': 'Tom', 'age': 18, 'height': 180}
d = dict(name='Tom', age=18, height=180) # 返回正确字典
d = dict([('name', 'Tom'), ('age', 18), ('height', 180)]) # 将列表元组元素，转为字典
d = dict(zip(['name', 'age', 'height'], ['Tom', 18, 180])) # 将两个列表，转为字典，zip()只能接受2个参数; 先将两个列表转为元组，然后dict() 将元组转为 字典

1.2 访问字典的值

my_dict = {'name':'zhangsan','age':18, 'sex':'male'} // 定义一个字典
print (my_dict['age']) // 获取键 age 的值是多少
print (my_dict.get('age')) // 获取键 age 的值是多少

1.3 修改字典的值

my_dict = {'name':'zhangsan','age':18, 'sex':'male'} // 定义一个字典
my_dict['age'] = 28 // 修改字典中的年龄大小
my_dict['company'] = 'Intel' // 添加字典元素 键值对

1.4 删除字典的值

my_dict = {'name':'zhangsan','age':18, 'sex':'male'} // 定义一个字典
del my_dict['age']  // 删除字典中的年龄
my_dict.clear   // 清空字典
del my_dict  // 删除字典

1.5 获取字典的长度

my_dict = {'name': 'zhangsan','age': 18, 'sex': 'male'} # 定义一个字典
print (len(my_dict)) 

1.6 字典转成列表

my_dict = {'name': 'zhangsan','age': 18, 'sex': 'male'} # 定义一个字典
print (my_dict.items())  # 字典还是一个字典，只不过返回值是一个列表。每个元素部分是一个元组

##### 结果：
dict_items([('name', 'zhangsan'), ('age', 18), ('sex', 'male')])
[Finished in 156ms]

1.7 获取字典所有键

my_dict = {'name': 'zhangsan','age': 18, 'sex': 'male'} # 定义一个字典
print (my_dict.keys())  # 

1.8 获取字典所有键

my_dict = {'name': 'zhangsan','age': 18, 'sex': 'male'} # 定义一个字典
print (my_dict.values())  # 

d['name']  # 'Tom' 获取键的值
d['age'] = 20  # 将 age 的值更新为 20
d['Female'] = 'man'  # 增加属性
d.get('height', 180)  # 180

# 嵌套取值
d = {'a': {'name': 'Tom', 'age':18}, 'b': [4,5,6]}
d['b'][1] # 5
d['a']['age'] # 18

# 注意，这不是切片操作
d = {0: 10, 2: 20}
d[0]
# 10

1.9  循环遍历字典

my_dict = ｛'name':'wang', 'age':30, 'job':'python'｝// 方法1
for key in my_dict: 
    print (key)
    print (my_dict[key])   //打印体现无序性，并不是按照字典顺序打印的


for key,value in my_dict.items(): // 方法2：将字典中的每个键值对看作元组，将元组
    print (key)
    print (value)  //打印体现无序性，并不是按照字典顺序打印的

1.10  检查某个键key是否在字典中

my_dict = ｛'name':'wang', 'age':30, 'job':'python'｝//
print 'name' in my_dict  // 返回bool类型
print my_dict.has_key('age')   // 返回bool类型

1.11  字典中的一个陷阱

my_list = []
my_dict = {}

for i in range(3):
    my_dict[i] = i * i
    my_list.append(my_dict)

print my_list

#### 结果：
[{0: 0, 1: 1, 2: 4}, {0: 0, 1: 1, 2: 4}, {0: 0, 1: 1, 2: 4}]
[Finished in 249ms]

二 常用函数

d.pop('name') # 'Tom' 删除指定 key
d.popitem() # 随机删除某一项
del d['name']  # 删除键值对
d.clear()  # 清空字典

# 按类型访问，可迭代
d.keys() # 列出所有 key
d.values() # 列出所有 值
d.items() # 列出所有值对元组（k, v）

# 操作
d.setdefault('a', 3) # 插入一个键，给字默认值, 不指定为 None
d1.update(dict2) # 将字典 dict2 的键值对添加到字典 dict
# 对于键(key)存在则返回其对应值，如果键不在字典中，则返回默认值
d.get('math', 100) # 100
d2 = d.copy() # 浅拷贝

# update 更新方式
d = {}
d.update(a=1)
d.update(c=2, d=3)
d
# {'a': 1, 'c': 2, 'd': 3}

其它函数： 

d = {'a': 1, 'b': 2, 'c': 3}
max(d) # 'c' 最大的 k
min(d) # 'a' 最小的 k
len(d) # 3 字典的长度
str(d) # "{'a': 1, 'b': 2, 'c': 3}" 字符串形式
any(d) # True 只要一个键为 True
all(d) # True 所有键都为 True
sorted(d) # ['a', 'b', 'c'] 所有key当列表排序

 三 字典合并

x = {'a': 1, 'b': 2}
y = {'b': 3, 'c': 4}
z = {**x, **y}
z
# {'c': 4, 'a': 1, 'b': 3}
# {**y, **x} 试试调换位置

还可以用 | 符号来做合并操作，这个方法在 Python 3.9+ 中才可用：

x | y
# 合并后更新到 x
x |= y

四 推导式

利用推导式生成新的字典：

d = {i: i*10 for i in range(1,5)}
# {1: 10, 2: 20, 3: 30, 4: 40}

# 键值互换
d = {'name': 'Tom', 'age': 18, 'height': 180}
{v:k for k,v in d.items()}
# {'Tom': 'name', 18: 'age', 180: 'height'}

 五 逻辑分支

对于一些逻辑分支功能，字典可以做路由，免去编写if else语句：

route = {True: 'case1', False: 'case2'} # 定义路由
route[7>6] # 'case1' 传入结果为布尔的变量、表达式、函数调用

# 定义计算方法
cal = {'+': lambda x,y: x+y, '*':lambda x,y: x*y}
cal['*'](4,9) # 36 使用