【Python】Dict模块

2023-03-14 12:02:11

Dict 特征
通过键而不是通过索引来读取元素	字典类型有时也称为关联数组或者散列表（hash）。它是通过键将一系列的值联系起来的，这样就可以通过键从字典中获取指定项，但不能通过索引来获取。
字典是任意数据类型的无序集合	和列表、元组不同，通常会将索引值 0 对应的元素称为第一个元素，而字典中的元素是无序的。
字典是可变的，并且可以任意嵌套	字典可以在原处增长或者缩短（无需生成一个副本），并且它支持任意深度的嵌套，即字典存储的值也可以是列表或其它的字典。
字典中的键必须唯一	字典中，不支持同一个键出现多次，否则只会保留最后一个键值对。
字典中的键必须不可变	字典中每个键值对的键是不可变的，只能使用数字、字符串或者元组，不能使用列表。

使用 { } 创建字典

由于字典中每个元素都包含两部分，分别是键（key）和值（value），因此在创建字典时，键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }中。

使用{ }创建字典的语法格式如下：

dictname = {'key':'value1', 'key2':'value2', ..., 'keyn':valuen}

其中 dictname 表示字典变量名，keyn : valuen 表示各个元素的键值对。需要注意的是，同一字典中的各个键必须唯一，不能重复。

如下代码示范了使用花括号语法创建字典：

#使用字符串作为key
scores = {'数学': 95, '英语': 92, '语文': 84}
print(scores)
#使用元组和数字作为key
dict1 = {(20, 30): 'great', 30: [1,2,3]}
print(dict1)
#创建空元组
dict2 = {}
print(dict2)

运行结果为：

{'数学': 95, '英语': 92, '语文': 84}
{(20, 30): 'great', 30: [1, 2, 3]}
{}

可以看到，字典的键可以是整数、字符串或者元组，只要符合唯一和不可变的特性就行；字典的值可以是 Python 支持的任意数据类型。

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

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

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

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

请看下面的例子：

knowledge = ['语文', '数学', '英语']字典

scores = dict.fromkeys(knowledge, 60)
print(scores)

dict5 = dict.fromkeys("abc", 'x')
print(dict5) 

# {'a': 'x', 'b': 'x', 'c': 'x'} 

_dict5 = dict.fromkeys({1, 2, 3}) 
print(_dict5) 

# {1: None, 2: None, 3: None}

运行结果为：

{'语文': 60, '英语': 60, '数学': 60}

可以看到，knowledge 列表中的元素全部作为了 scores 字典的键，而各个键对应的值都是 60。这种创建方式通常用于初始化字典，设置 value 的默认值。

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

通过 dict() 函数创建字典的写法有多种，表 2 罗列出了常用的几种方式，它们创建的都是同一个字典 a。

创建字典
a = dict(str1=value1, str2=value2, str3=value3)	str 表示字符串类型的键，value 表示键对应的值。使用此方式创建字典时，字符串不能带引号。
#方式1 demo = [('two',2), ('one',1), ('three',3)] #方式2 demo = [['two',2], ['one',1], ['three',3]] #方式3 demo = (('two',2), ('one',1), ('three',3)) #方式4 demo = (['two',2], ['one',1], ['three',3]) a = dict(demo)	向 dict() 函数传入列表或元组，而它们中的元素又各自是包含 2 个元素的列表或元组，其中第一个元素作为键，第二个元素作为值。
keys = ['one', 'two', 'three'] #还可以是字符串或元组 values = [1, 2, 3] #还可以是字符串或元组 a = dict( zip(keys, values) )	通过应用 dict() 函数和 zip() 函数，可将前两个列表转换为对应的字典。

3) 通过推导创建字典

dict6 = {i: 2 * i for i in range(3)}
print(dict6)  # {0: 0, 1: 2, 2: 4}

注意，无论采用以上哪种方式创建字典，字典中各元素的键都只能是字符串、元组或数字，不能是列表。列表是可变的，不能作为键。

4) 创建键值一对多的字典

一般写法: 使用Python3标准库,collections模块的类：defaultdict([default_factory[, …]])

需要导入collections模块的defaultdict
接受一个工厂函数作为参数，default_factory可以是list,tuple,set等
defaultdict会根据method_factory参数不同为key设置默认值，而相同情况下普通Dict会抛出KeyError

from collections import defaultdict

dict2 = defaultdict(list)
dict2["one"].append(1)
dict2["one"].append(2)
dict2["one"].append(3)
print(dict2)  # defaultdict(<class 'list'>, {'one': [1, 2, 3]})
print(dict2["two"])  # key"two"不存在 根据参数是list返回空列表 []

6) 创建有序字典

创建有序Dict
推荐写法: 使用Python3的标准库，collections模块的类：OrderedDict([items])

OrderedDict内部维护着一个根据键插入顺序排序的双向链表，每添加一个新元素，它会被放到链表尾部
缺点：相比于普通Dict，OrderedDict会造成更多内存消耗

dict1 = OrderedDict()
dict1["one"] = 1
dict1["two"] = 2
dict1["three"] = 3
print(dict1)  # OrderedDict([('one', 1), ('two', 2), ('three', 3)])

7) 创建空字典

推荐写法: 使用{}直接创建

推荐写法: 使用Python3的标准库，dict类内置函数：dict()

empty_dict1 = {}
print(isinstance(empty_dict1, dict))  # True
print(empty_dict1)  # {}


empty_dict2 = dict()
print(isinstance(empty_dict2, dict))  # True
print(empty_dict2)  # {}

8) 创建有默认值的字典

推荐写法: 使用Python3的标准库，dict类内置函数：setdefault(key[, default])，key指定键，default是可选参数

default指定默认返回值
若key已存在，则返回其对应的值，default不生效
若key不存在，若给定default返回值，则返回该值，并把键值对(key, default)插入到当前字典中
若key不存在，若没有给定default返回值，则返回None，并把键值对(key, None)插入到当前字典中

dict1 = {"one": 1, "two": 2, "three": 3}

value = dict1.setdefault("one", 111)
print(value)  # key"one"存在 default不生效 1
print(dict1)  # {'one': 1, 'two': 2, 'three': 3}

none_value = dict1.setdefault("four")
print(none_value)  # key"four"不存在 None
print(dict1)  # 添加新元素 {'one': 1, 'two': 2, 'three': 3, 'four': None}

default_value = dict1.setdefault("five", 5)
print(default_value)  # key"five"不存在 返回default给定值 5
print(dict1)  # 添加新元素 {'one': 1, 'two': 2, 'three': 3, 'four': None, 'five': 5}

Python访问字典

列表和元组是通过下标来访问元素的，而字典不同，它通过键来访问对应的值。因为字典中的元素是无序的，每个元素的位置都不固定，所以字典也不能像列表和元组那样，采用切片的方式一次性访问多个元素。

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

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

除了上面这种方式外，Python 更推荐使用 dict 类型提供的 get() 方法来获取指定键对应的值。当指定的键不存在时，get() 方法不会抛出异常。

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

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

注意，当键不存在时，get() 返回空值 None，如果想明确地提示用户该键不存在，那么可以手动设置 get() 的第二个参数，例如：

a = dict(two=0.65, one=88, three=100, four=-59)
print( a.get('one') )
print( a.get('five', '该键不存在') )

Python删除字典

和删除列表、元组一样，手动删除字典也可以使用 del 关键字，例如：

a = dict(two=0.65, one=88, three=100, four=-59)
print(a)
del a
print(a)

Dict浅拷贝

Dict浅拷贝只会拷贝当前Dict的顶层元素，不会拷贝嵌套的子对象，即原Set和拷贝Set指向同一子对象
一般写法: 使用Python3的标准库，dict类内置函数：copy(other)，other指代另一个Dict

返回一个新Dict，与原Dict地址空间不同
若当前Dict包含子对象，则不会拷贝子对象，原Dict和拷贝Dict指向同一子对象
更新子对象会同时影响原Dict和拷贝Dict

dict1 = {"one": 1, "two": {1: 1, 2: 2}}

copy1 = dict1.copy()
print(dict1 == copy1)  # True
print(id(dict1) == id(copy1))  # False

copy1.get("two")[1] = 111
print(dict1)  # {'one': 1, 'two': {1: 111, 2: 2}}

一般写法: 使用Python3的标准库，copy模块的函数：copy(other)，other指代另一个Dict

需要导入copy模块
返回一个新Dict，与原Dict地址空间不同
若当前Dict包含子对象，则不会拷贝子对象，原Dict和拷贝Dict指向同一子对象
更新子对象会同时影响原Dict和拷贝Dict

import copy

dict1 = {"one": 1, "two": {1: 1, 2: 2}}

copy1 = copy.copy(dict1)
print(dict1 == copy1)  # True
print(id(dict1) == id(copy1))  # False

copy1.get("two")[1] = 111
print(dict1)  # {'one': 1, 'two': {1: 111, 2: 2}}

一般写法: 使用Python3的标准库，dict类内置函数：dict(other)，other指代另一个Dict

返回一个新Dict，与原Dict地址空间不同
若当前Dict包含子对象，则不会拷贝子对象，原Dict和拷贝Dict指向同一子对象
更新子对象会同时影响原Dict和拷贝Dict

dict1 = {"one": 1, "two": {1: 1, 2: 2}}

copy1 = dict(dict1)
print(dict1 == copy1)  # True
print(id(dict1) == id(copy1))  # False

copy1.get("two")[1] = 111
print(dict1)  # {'one': 1, 'two': {1: 111, 2: 2}}

一般写法: 使用运算符”=“

本质是对象的引用
返回一个新Dict，与原Dict指向同一个地址空间，相互影响

dict1 = {"one": 1, "two": {1: 1, 2: 2}}

copy1 = dict1
print(dict1 == copy1)  # True
print(id(dict1) == id(copy1))  # True

copy1.get("two")[1] = 111
print(dict1)  # {'one': 1, 'two': {1: 111, 2: 2}}

Dict深拷贝

Dict深拷贝不仅会拷贝当前Dict的顶层元素，也会拷贝嵌套的子对象，本质上是执行递归浅拷贝，原Dict和拷贝Dict完全独立，相互不影响
推荐写法: 使用Python3的标准库，copy模块的函数：deepcopy(other)，other指代另一个Dict

需要导入copy模块
返回一个新Dict，与原Dict是独立的对象，地址空间不同
若当前Dict包含子对象，也会拷贝子对象
原Dict和拷贝Dict所有元素地址都是独立的，更新元素相互不影响

import copy

dict1 = {"one": 1, "two": {1: 1, 2: 2}}

copy1 = copy.deepcopy(dict1)
print(dict1 == copy1)  # True
print(id(dict1) == id(copy1))  # False

copy1.get("two")[1] = 111
print(dict1)  # {'one': 1, 'two': {1: 1, 2: 2}}


获取Dict长度

获取字典长度
推荐写法: 使用Python3的标准库，内置函数len(s)，参数可以是序列(如字符串、字节、元组、列表或范围等)或集合(如字典和集合)，这里是Dict实例

dict1 = {"one": 1, "two": 2, "three": 3}

length = len(dict1)
print(length)  # 3

empty_dict = {}
empty_length = len(empty_dict)
print(empty_length)  # 0

Dict添加

Dict添加键值对

添加一个键值对

Dict添加单个元素；键必须是不可变对象，比如数字、字符串或元组(纯元组，没有嵌套可变对象)，否则会抛出TypeError
推荐写法: 使用方括号dict1[key]=value直接赋值，指定键和值

若key已存在，则会修改相应的值，若key不存在，则添加元素
性能比update函数高

dict1 = {"one": 1, "two": 2, "three": 3}
dict1["four"] = 4
print(dict1) # {'one': 1, 'two': 2, 'three': 3, 'four': 4}
dict1["one"] = 111
print(dict1) # {'one': 111, 'two': 2, 'three': 3, 'four': 4}

一般写法: 使用Python3的标准库，dict类内置函数：update([other])，other指代一个字典对象或一个键值对的迭代

若key已存在，则会修改相应的值，若key不存在，则添加元素
性能比直接赋值低

dict1 = {"one": 1, "two": 2, "three": 3}

# 通过关键字形式的参数添加
dict1.update(four=4)
print(dict1)  # {'one': 1, 'two': 2, 'three': 3, 'four': 4}

# 通过元组列表参数添加
dict1.update([("five", 5)])
print(dict1)  # {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5}

# 通过字典实例参数添加
dict1.update({"six": 6})
print(dict1)  # {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6}

# 可以使用以上任意方法修改已存在的键对应的值
dict1.update(one=111)
print(dict1)  # {'one': 111, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6}

添加多个键值对

Dict添加多个元素；键必须是不可变对象，比如数字、字符串或元组(纯元组，没有嵌套可变对象)，否则会抛出TypeError
一般写法: 使用Python3的标准库，dict类内置函数：update([other])，other指代一个字典对象或一个键值对的迭代

若key已存在，则会修改相应的值，若key不存在，则添加元素

dict1 = {1: 1, 2: 2, 3: 3}

# 通过关键字形式的参数添加
dict1.update(four=4, five=5)
print(dict1)  # {1: 1, 2: 2, 3: 3, 'four': 4, 'five': 5}

# 通过元组列表参数添加
dict1.update([(6, 6), (7, 7)])
print(dict1)  # {1: 1, 2: 2, 3: 3, 'four': 4, 'five': 5, 6: 6, 7: 7}

# 通过字典参数添加
dict1.update({8: 8, 9: 9})
print(dict1)  # {1: 1, 2: 2, 3: 3, 'four': 4, 'five': 5, 6: 6, 7: 7, 8: 8, 9: 9}

# 可以使用以上任意方法修改已存在的键对应的值
dict1.update({"four": 444, "five": 555})
print(dict1)  # {1: 1, 2: 2, 3: 3, 'four': 444, 'five': 555, 6: 6, 7: 7, 8: 8, 9: 9}

Dict删除

Dict删除键值对

1) 根据指定的key删除一个键值对

Dict根据指定的键删除一个键值对
推荐写法: 使用Python3的标准库，dict类内置函数：pop(key[, default])，key指定键，default是可选参数

default指定默认返回值
若key已存在，则删除相应的键值对，并返回其对应的值，default不生效
若key不存在，若给定default返回值，则返回该值，否则抛出KeyError
参数不能为空

dict1 = {"one": 1, "two": 2, "three": 3}

value1 = dict1.pop("one", 111)
print(value1)  # key"one"存在 default不生效 1
print(dict1)  # {'two': 2, 'three': 3}

value2 = dict1.pop("1", 111)
print(value2)  # key"1"不存在 返回default给定值 111
print(dict1)  # {'two': 2, 'three': 3}

dict1.pop("1")  # key"1"不存在 抛出KeyError: '1'
dict1.pop()  # 抛出TypeError: pop expected at least 1 arguments, got 0

一般写法: 使用del关键字：del dict1[key]，key指定键

若key已存在，则删除相应的键值对
若key不存在，则抛出KeyError

dict1 = {"one": 1, "two": 2, "three": 3}

del dict1["one"]
print(dict1)  # {'two': 2, 'three': 3}

del dict1["1"]  # key"1"不存在 抛出KeyError: '1'

2) 随机删除一个键值对

Dict随机删除一个键值对
推荐写法: 使用Python3的标准库，dict类内置函数：popitem()

随机删除一个键值对，并以元组的形式返回该键值对
若Dict为空，则抛出KeyError

dict1 = {"one": 1, "two": 2, "three": 3}

pop_one = dict1.popitem()
print(pop_one)  # ('three', 3)
print(dict1)  # {'one': 1, 'two': 2}

empty_dict = {}
empty_dict.popitem()  # 抛出KeyError: 'popitem(): dictionary is empty'

3) 清空Dict

删除Dict中所有元素
推荐写法: 使用Python3的标准库，dict类内置函数：clear()

修改当前集合，删除Dict中所有元素

dict1 = {"one": 1, "two": 2, "three": 3}
dict1.clear()
print(dict1)  # {}

4) 删除整个Dict

删除整个字典变量
推荐写法: 使用关键字“del”

del作用于变量而不是对象
del只是解除变量和对象的引用关系，而不是销毁对象释放占用的内存空间
python的垃圾回收机制主要采用的是引用计数的方式

dict1 = {"one": 1, "two": 2, "three": 3}
del dict1
print(dict1)  # 抛出NameError: name 'dict1' is not defined

6. Dict更新

1) 更新指定key的value

Dict更新指定key对应的value
推荐写法: 使用方括号dict1[key]=value直接更新，指定键和值

若key已存在，则会修改相应的值，若key不存在，则添加元素
性能比update函数高

dict1 = {"one": 1, "two": 2, "three": 3}

dict1["one"] = 111
print(dict1)  # {'one': 111, 'two': 2, 'three': 3}

dict1["four"] = 4
print(dict1)  # {'one': 111, 'two': 2, 'three': 3, 'four': 4}

一般写法: 使用Python3的标准库，dict类内置函数：update([other])，other指代一个字典对象或一个键值对的迭代

若key已存在，则会修改相应的值，若key不存在，则添加元素

性能比直接赋值低

dict1 = {"one": 1, "two": 2, "three": 3}

# 通过关键字形式的参数更新
dict1.update(one=111)
print(dict1)  # {'one': 111, 'two': 2, 'three': 3}

# 通过元组列表参数更新
dict1.update([("two", 222)])
print(dict1)  # {'one': 111, 'two': 222, 'three': 3}

# 通过字典参数更新
dict1.update({"three": 333})
print(dict1)  # {'one': 111, 'two': 222, 'three': 333}

# 可以使用以上任意方法添加一个键值对
dict1.update(four=4)
print(dict1)  # {'one': 111, 'two': 222, 'three': 333, 'four': 4}

7. Dict查找

1) 获取value的最大值/最小值

获取value的最大值/最小值
推荐写法: 使用Python3的标准库，内置函数：max/min(iterable, *[, key, default])和zip(*iterables)

返回value的最大值/最小值及其对应的key构成的元组

dict1 = {"a": 123, "b": 321, "c": 200}

# 获取max value及其对应的key
max_tuple = max(zip(dict1.values(), dict1.keys()))
print(max_tuple)  # (321, 'b')

# 获取min value及其对应的key
min_tuple = min(zip(dict1.values(), dict1.keys()))
print(min_tuple)  # (123, 'a')

一般写法: 使用Python3的标准库，内置函数：max/min(iterable, *[, key, default])

获取value的最大值/最小值对应的key，再根据key获取对应的value

dict1 = {"a": 123, "b": 321, "c": 200}

# 在一个字典上执行普通的数学运算，它们仅仅作用于键，而不是值
max_key = max(dict1)
print(max_key)  # 返回key的最大值 'c'

# 获取最大值对应的键
max_value_key = max(dict1, key=lambda k: dict1[k])
print(max_value_key)  # 'b'
 
# 根据键获取对应的值
max_value = dict1[max_key]
print(max_value)  # 321

2) 获取指定key的value

获取指定key的value
推荐写法: 使用Python3的标准库，dict类内置函数：get(key[, default])，key指定键，default是可选参数

default指定默认返回值
若key已存在，则返回其对应的值，default不生效
若key不存在，若给定default返回值，则返回该值，否则返回None
所以该方法永远不会引发KeyError

dict1 = {"one": 1, "two": 2, "three": 3}

value = dict1.get("one", 111)
print(value)  # key"one"存在 default不生效 1

none_value = dict1.get("four")
print(none_value)  # key"four"不存在 None

default_value = dict1.get("four", 4)
print(default_value)  # key"four"不存在 返回default给定值 4

一般写法: 使用方括号dict1[key]直接获取，指定键

若key已存在，则返回其对应的值
若key不存在，则抛出KeyError

dict1 = {"one": 1, "two": 2, "three": 3}

value = dict1["one"]
print(value)  # 1

none_value = dict1["four"]  # key"four"不存在 抛出KeyError: 'four'

3) 获取键值对列表

获取(键, 值)元组列表动态视图
推荐写法: 使用Python3的标准库，dict类内置函数：items()

返回Dict键值对的视图对象，当Dict更改时，会动态反映这些变化

dict1 = {"one": 1, "two": 2, "three": 3}

items = dict1.items()
print(items)  # dict_items([('one', 1), ('two', 2), ('three', 3)])

dict1.clear()
print(items)  # dict_items([])

4) 获取key列表

获取key列表动态视图
推荐写法: 使用Python3的标准库，dict类内置函数：keys()

返回Dict键的视图对象，当Dict更改时，会动态反映这些变化

dict1 = {"one": 1, "two": 2, "three": 3}

keys = dict1.keys()
print(keys)  # dict_keys(['one', 'two', 'three'])

dict1.clear()
print(keys)  # dict_keys([])

5) 获取value列表

获取value列表动态视图
推荐写法: 使用Python3的标准库，dict类内置函数：values()

返回Dict值的视图对象，当Dict更改时，会动态反映这些变化

dict1 = {"one": 1, "two": 2, "three": 3}

values = dict1.values()
print(values)  # dict_values([1, 2, 3])

dict1.clear()
print(values)  # dict_values([])

6) 从字典中提取符合条件的子集

从字典中过滤/映射符合条件的Dict
推荐写法: 使用推导式

prices = {
"a": 45.23,
"b": 612.78,
"c": 205.55,
"d": 37.20,
"e": 10.75
}

# ---过滤---
# 1. 获取value>200的键值对构成的字典
dict1 = {key: value for key, value in prices.items() if value > 200}
print(dict1)  # {'b': 612.78, 'c': 205.55}

# 2. 获取names中的key对应的键值对构成的字典
names = {"d", "e"}

# 以下方法1,2都可以满足要求，但运行时间测试结果显示，方法2比方法1所花费的时间更多。
# 方法1
dict2 = {key: value for key, value in prices.items() if key in names}
print(dict2)  # {'d': 37.2, 'e': 10.75}

# 方法2
dict3 = {key: prices[key] for key in prices.keys() & names}
print(dict3)  # {'d': 37.2, 'e': 10.75}

# ---映射---
# 1. 将value转换成整数
dict4 = {key: int(value) for key, value in prices.items()}
print(dict4)  # {'a': 45, 'b': 612, 'c': 205, 'd': 37, 'e': 10}

8. Dict判断

1) 判断key是否在字典中

判断key是否在字典中
推荐写法: 使用运算符“in”

对大小写敏感

if key in dict1:
    """do something"""
if key not in dict1:
    """do something"""
    
dict1 = {"one": 1, "two": 2, "three": 3}
print("one" in dict1)  # True
print("one" not in dict1)  # False
print("One" in dict1)  # False

9. Dict排序

1) 根据key对字典排序

根据key，对字典进行排序
推荐写法: 使用Python3的标准库，内置函数：sorted(iterable[, key=None[, reverse=False])，key和reverse是可选参数

返回一个排序列表
iterable用于指定一个可迭代对象，这里是一个字典实例
key用于指定排序规则，默认是None，语法是key=lambda elem:xxx
reverse用于指定排序方向，默认是升序，语法是reverse=False/True

dict1 = {"a": 3, "c": 1, "b": 2}

# item指代(键，值)元组，item[0]是键, item[1]是值
# 正序
dict_sorted = sorted(dict1.items(), key=lambda item: item[0])
print(dict_sorted)  # [('a', 3), ('b', 2), ('c', 1)]

# 逆序
dict_sorted_rev = sorted(dict1.items(), key=lambda item: item[0], reverse=True)
print(dict_sorted_rev)  # [('c', 1), ('b', 2), ('a', 3)]

# ------
# 注意：sorted(dict1)默认是对key排序，而不是对整个字典
sorted1 = sorted(dict1)
print(sorted1)  # ['a', 'b', 'c']

2) 根据key对value排序

根据字典的键，对值进行排序
推荐写法

先使用内置函数sorted，根据key对字典排序
再使用推导式，获取value列表
关于sorted函数的用法，参看章节“根据key对字典排序”

dict1 = {"a": 3, "c": 1, "b": 2}

list1 = sorted(dict1.items(), key=lambda item: item[0])
print(list1)  # 根据key对字典排序 [('a', 3), ('b', 2), ('c', 1)]

list2 = [value for key, value in list1]
print(list2)  # [3, 2, 1]

推荐写法

先使用内置函数sorted，对字典的键列表排序
再使用推导式，获取key对应的value

dict1 = {"a": 3, "c": 1, "b": 2}
keys = sorted(dict1.keys())
list1 = [dict1[k] for k in keys]
print(list1)  # [3, 2, 1]