在Python中，字典是一种常用的数据结构，是实现各类算法的基础。

1.创建字典

有多种方法可以创建字典，以下几种方法创建的字典均等于 {"one": 1, "two": 2, "three": 3}

a = dict(one=1, two=2, three=3)
b = {'one': 1, 'two': 2, 'three': 3}
c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
d = dict([('two', 2), ('one', 1), ('three', 3)])
e = dict({'three': 3, 'one': 1, 'two': 2})
f = dict({'one': 1, 'three': 3}, two=2)
a == b == c == d == e == f

除此之外还可以用字典推导式快速生成字典。

{k: v for k, v in lst}

例如

numbers = [1, 2, 3, 4, 5]
squares = {x: x**2 for x in numbers}
print(squares)  # 输出: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

字典键的特性

字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行，有特殊的要求，两个重要的点需要记住：

1）唯一性：不允许同一个键出现两次，创建时如果同一个键被赋值两次，后一个值会被记住。

2）不可变：键必须不可变，所以可以用数字，字符串或元组充当，所以用列表、字典等就不行。

2.字典常用操作

my_dict = {"name": "张三", "age": 25, "city": "北京"}

访问字典中的值

# 访问字典中的值
print(my_dict["name"])

修改字典中的值

# 修改字典中的值
my_dict["age"] = 26

添加键值对

# 添加键值对
my_dict["job"] = "程序员"
print(my_dict)

删除键值对

# 删除键值对
del my_dict["city"]
print(my_dict)

获取字典的长度

# 获取字典的长度
print(len(my_dict))

获取字典的所有键

# 获取字典的所有键
print(my_dict.keys())

获取字典的所有值

# 获取字典的所有值
print(my_dict.values())

获取字典的所有键值对

# 获取字典的所有键值对
print(my_dict.items())

遍历字典的键值对

# 遍历字典的键值对
for key, value in my_dict.items():print(key, value)

合并两个字典

# 合并两个字典
dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4}
merged_dict = {**dict1, **dict2}
print(merged_dict)

结果：{'a': 1, 'b': 2, 'c': 3, 'd': 4}

上面代码的双星号（**）字典解包：使用**可以将字典解包为关键字参数，将键值对传递给函数。

# 示例代码：
def print_info(name, age, city):print("Name:", name)print("Age:", age)print("City:", city)user_info = {"name": "Alice", "age": 25, "city": "New York"}
print_info(**user_info)

结果：

Name: Alice
Age: 25
City: New York

将列表转换为字典

# 将列表转换为字典
keys = ["name", "age", "city"]
values = ["张三", 25, "北京"]
list_to_dict = dict(zip(keys, values))
print(list_to_dict)

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

我们可以使用 list() 转换来输出列表。

a = [1, 2, 3]
b = [4, 5, 6]
zipped = zip(a, b)
print(list(zipped))结果： [(1, 4), (2, 5), (3, 6)]

当指定key不存在时，将value设置为 0

dct[key] = dct.get(key, 0)

让字典中的某个键对应的项“离开”字典

dict = {'name': 'Alice', 'age': 23, 'address': 'Hangzhou'}
dict.pop('age')print(dict)

随机删除字典中某一键值对，并以元组的形式返回这一键值对，返回并删除字典中的最后一对键和值。

dict = {'name': 'Alice', 'age': 23, 'address': 'Hangzhou'}
print(dict.popitem()) # ('address', 'Hangzhou')
print(dict) # {'name': 'Alice', 'age': 23}

对 popitem() 的说明 其实，说 popitem() 随机删除字典中的一个键值对是不准确的，虽然字典是一种无序的列表，但键值对在底层也是有存储顺序的，popitem() 总是弹出底层中的最后一个 key-value，这和列表的 pop() 方法类似，都实现了数据结构中“出栈”的操作。

key not in d

my_dict = {'one': 1, 'two': 2, 'three': 3}
'one' not in my_dict 
False
'four' not in my_dict 
True

3.进阶用法

使用字典推导式过滤字典

# 使用字典推导式过滤字典
my_dict={"a": 100, "b": 25, "c": 300, "d": 10}
filtered_dict = {key: value for key, value in my_dict.items() if value > 25}
print(filtered_dict)

结果：{'a': 100, 'c': 300}

使用字典推导式对字典的值进行操作

# 使用字典推导式对字典的值进行操作
my_dict={"a": 100, "b": 25, "c": 300, "d": 10}
updated_dict = {key: value*2 for key, value in my_dict.items()}
print(updated_dict)

结果：{'a': 200, 'b': 50, 'c': 600, 'd': 20}

使用字典推导式对字典的键和值进行操作

# 使用字典推导式对字典的键和值进行操作
my_dict={"a": 100, "b": 25, "c": 300, "d": 10}
transformed_dict = {key.upper(): value*2 for key, value in my_dict.items()}
print(transformed_dict)

结果：{'A': 200, 'B': 50, 'C': 600, 'D': 20}

使用字典推导式将列表转换为字典，并指定默认值

# 使用字典推导式将列表转换为字典，并指定默认值
keys = ["name", "age", "city"]
values = ["张三", 25]
list_to_dict = {key: values[i] if i < len(values) else "未知" for i, key in enumerate(keys)}
print(list_to_dict)

结果：{'name': '张三', 'age': 25, 'city': '未知'}

使用字典推导式将元组转换为字典，并指定默认值

# 使用字典推导式将元组转换为字典，并指定默认值
tuples = (("name", "张三"), ("age", 25), ("city", "北京"))
tuple_to_dict = {key: value if key in dict(tuples) else "未知" for key, value in tuples}
print(tuple_to_dict)

结果：{'name': '张三', 'age': 25, 'city': '北京'}

使用字典推导式对字典进行排序

# 使用字典推导式对字典进行排序
my_dict={"a": 100, "b": 25, "c": 300, "d": 10}
sorted_dict = {key: value for key, value in sorted(my_dict.items(), key=lambda item: item[1])}
print(sorted_dict)

结果：{'d': 10, 'b': 25, 'a': 100, 'c': 300}

键排序:

my_dict = {'b': 3, 'a': 1, 'c': 2}
sorted_keys = sorted(my_dict)print(sorted_keys)  # 输出：['a', 'b', 'c']

值排序：

my_dict = {'b': 3, 'a': 1, 'c': 2}
sorted_values = sorted(my_dict.values())print(sorted_values)  # 输出：[1, 2, 3]

使用字典推导式对字典进行去重(删除重复数据，一个不留)

# 使用字典推导式对字典进行去重
my_dict={"a": 100, "e": 100, "c": 300, "d": 10}
unique_dict = {key: value for key, value in my_dict.items() if value not in [v for k, v in my_dict.items() if k != key]}
print(unique_dict)

结果：{'c': 300, 'd': 10}