Published in：2024-10-24 |

字典

一、什么是字典

  • Python中的字典是另一种可变容器

  • 可以存储任意类型的数据

列表：将多个数据存储在一个有序的容器中，并且通过下标/索引形式来访问

字典：将多个数据存储在一个“无序”的容器中（Python3.5是无序的，在Python3.6中有序），并且通过“名字”来访问。

  • 什么情况下会使用字典：
1
2
3
4
5
6
7
8
9
10
11
# 存储三门课的成绩
# 语文：79  数学：80  英语：92
s1 = [79,80,92]
s2 = ['语文','数学','英语']   # 列表是 下标和值绑定

print(s2[0],s1[0])

# 产生一个 一 一对应关系（映射） -- 字典  键和值绑定
scores = {'语文':79, '数学':80, '英语':92}
# 声明了一个字典，有3个元素，每一个元素都由两部分组成，key:value 键：值
print(scores['语文'])
  • 存储一个人的信息 姓名：Mr_lee 年龄：18 性别：True
    • 列表： info = ['Mr_lee',18,True] info[0]
    • 字典：info = {'name':'Mr_lee', 'age':18, 'gender':True} info['name']

二、字典的创建

  • 直接使用{}来创建
1
2
3
4
d1 = {}  # 构造了一个空字典
print(type(d1))   # dict   -- dictionary
d2 = {'A': 1,  'C': 3, 'B': 2,}  # 存储多个键值对 Python3.6 存储的先后顺序排序
print(d2)
  • 工厂函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 1. 空字典
d = dict()  # 空字典
# 2. 使用映射构造
d = dict({'A': 1,  'C': 3, 'B': 2,} )  # l = list([1,2,3])

# 3. 使用可迭代对象构造
d = dict([1,2,3])  # 不行
# 如果使用可迭代对象作为参数构造字典，要求可迭代对象中的每一个元素由两个子元素构造
d = dict([('A',1),('B',2)])
          
d = dict(['A1','B2'])  # {'A': '1', 'B': '2'}
print(d)   

# 4. 可以使用关键字参数构造字典
d = dict(a=1,b=2,c=3)
print(d)  # {'a': 1, 'b': 2, 'c': 3}

三、字典的访问

  • 列表是通过下标索引的方式来访问它的元素的，而字典则是通过键名来获取对应的值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
info = {'id':1, 'name':'Mr_lee', 'age':18, 'age':20}  # 不允许有重复的键 不报错 会发生覆盖

print(info['name'])
print(info['Name'])   # KeyError: 'Name'  当键不存在时，访问报错   


# 解决键不存在时，访问键对应的值时，程序出错： get函数
n = info.get('Name')  # 当键不存在时，返回为None
print(n)  # None

n = info.get('NAME','Tom')  # 当键不存在时，返回第二个参数的值（默认的值）
print(n)  # Tom

n = info.get('name','Tom')
print(n)  # Mr_lee

注意：字典中的键一般都是字符串 ，键必须是不可变类型

1
2
3
4
d = {1:1,2:2,3:3}   # 可以
d = {'A': 1,  'C': 3, 'B': 2,} # 可以
d = {(1,):1,(2,):2}  # 可以 使用元组作为键，要求元组中的元素也必须不可变类型
d =  {[1,]:1,[2,]:2} # 不可以

四、修改和添加元素

1
2
3
4
5
6
7
info = {'id':1, 'name':'Mr_lee', 'age':18}

id = info.get('id')  # 作为右值
print(id)

id = info['id']   # 作为右值
print(id)
  • 修改数据
1
2
3
4
#  当键存在时，并作为左值，则是修改它的值

info['id'] = 100  # 作为左值，修改它的值    s[0] = 100 
print(info)  # {'id':100, 'name':'Mr_lee', 'age':18}
  • 添加数据
1
2
3
# 当键不存在时，作为左值，添加一个键值对
info['gender'] =  True  # {'id': 100, 'name': 'Mr_lee', 'age': 18, 'gender': True}
print(info)

五、字典常用的方法

函数 描述
d.clear() 清空字典中的所有的元素
d.pop(key) 删除指定键对应的值（kv一起被删除）
d.popitem() 随机移除并返回被移除的键值对 类型是一个元组(k,v)
d.get(key,default) 返回指定键对应的值，当键不存在时，返回为空，如果给了default则当键不存在时，返回default的值
d.items() 以列表的形式返回所有的键值对，列表中的每一个元素都是一个元组包含一个键和值 dict_items([('id', 1), ('name', 'Mr_lee'), ('age', 18)])
d.keys() 返回所有的键
d.values() 返回所有的值
d1.update(d2) 用一个字典/可迭代对象来更新另一个字典
d.copy() 拷贝一个字典
  • 删除和清空
1
2
3
4
5
6
7
8
9
info.clear()  # 清空
print(info)

v = info.pop('name') # 移除指定的键和值 返回对应的值
print(v)
print(info)  # {'id': 1, 'age': 18}

item = info.popitem()  # 随机返回一个键值对 tuple 如果字典为空，则KeyError
print(item)
  • 获取值
1
2
3
4
5
6
7
8
9
10
11
12
13
info = {'id':1, 'name':'Mr_lee', 'age':18, 'age':20}
print(info)

# print(info['Name'])  # KeyError: 'Name'

n = info.get('Name')  # 当键不存在时，返回为None
print(n)  # None

n = info.get('NAME','Tom')  # 当键不存在时，返回第二个参数的值（默认的值）
print(n)  # Tom

n = info.get('name','Tom')
print(n)  # Mr_lee
  • 返回所有的键值对
1
2
3
4
5
6
items = info.items()
print(items)         # dict_items([('id', 1), ('name', 'Mr_lee'), ('age', 18)])
print(list(items))   # [('id', 1), ('name', 'Mr_lee'), ('age', 18)]

for k,v in list(items):
    print(k,v)
  • 返回所有的键 或 返回所有的值
1
2
3
4
5
6
print(info.keys())# dict_keys(['id', 'name', 'age']) 可迭代对象 可以转为list

for key in info.keys():
    print(key)

print(info.values())
  • update函数
1
2
3
4
5
6
7
info = {'id': 1, 'name': 'Mr_lee', 'age': 18}

d = {'height': 180, 'weight': 180}

info.update(d)  # 类似于列表中的extend
info.update(['A1', 'B2'])
print(info)
  • 字典的遍历
1
2
3
4
5
6
7
8
9
10
11
12
# 3.5/3.6
info = {'id': 1, 'name': 'Mr_lee', 'age': 18}
info = {'id': 1, 'name': 'Mr_lee', 'age': 18}
for k in info:           # 默认获取的是键 key
    print(k,info.get(k)) 

for k in info.keys():
    print(k)

for k,v in info.items():  # 一次性获取所有的键值对
    print(k,v)
Prev:
Next:

    • Copyright © 2022 - 2024 16778738 | Powered by “> |