在Python中,字典是一种常用的数据结构,是实现各类算法的基础。
1.创建字典
有多种方法可以创建字典,以下几种方法创建的字典均等于 {"one": 1, "two": 2, "three": 3}
python
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
除此之外还可以用字典推导式快速生成字典。
python
{k: v for k, v in lst}
例如
python
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": "北京"}
访问字典中的值
python
# 访问字典中的值
print(my_dict["name"])
修改字典中的值
python
# 修改字典中的值
my_dict["age"] = 26
添加键值对
python
# 添加键值对
my_dict["job"] = "程序员"
print(my_dict)
删除键值对
python
# 删除键值对
del my_dict["city"]
print(my_dict)
获取字典的长度
python
# 获取字典的长度
print(len(my_dict))
获取字典的所有键
python
# 获取字典的所有键
print(my_dict.keys())
获取字典的所有值
python
# 获取字典的所有值
print(my_dict.values())
获取字典的所有键值对
python
# 获取字典的所有键值对
print(my_dict.items())
遍历字典的键值对
python
# 遍历字典的键值对
for key, value in my_dict.items():
print(key, value)
合并两个字典
python
# 合并两个字典
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}
上面代码的双星号(**)字典解包:使用**可以将字典解包为关键字参数,将键值对传递给函数。
python
# 示例代码:
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
将列表转换为字典
python
# 将列表转换为字典
keys = ["name", "age", "city"]
values = ["张三", 25, "北京"]
list_to_dict = dict(zip(keys, values))
print(list_to_dict)
zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存。
我们可以使用 list() 转换来输出列表。
python
a = [1, 2, 3]
b = [4, 5, 6]
zipped = zip(a, b)
print(list(zipped))
结果: [(1, 4), (2, 5), (3, 6)]
当指定key
不存在时,将value
设置为 0
python
dct[key] = dct.get(key, 0)
让字典中的某个键对应的项"离开"字典
python
dict = {'name': 'Alice', 'age': 23, 'address': 'Hangzhou'}
dict.pop('age')
print(dict)
随机删除字典中某一键值对,并以元组的形式返回这一键值对,返回并删除字典中的最后一对键和值。
python
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
python
my_dict = {'one': 1, 'two': 2, 'three': 3}
'one' not in my_dict
False
'four' not in my_dict
True
3.进阶用法
使用字典推导式过滤字典
python
# 使用字典推导式过滤字典
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}
使用字典推导式对字典的值进行操作
python
# 使用字典推导式对字典的值进行操作
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}
使用字典推导式对字典的键和值进行操作
python
# 使用字典推导式对字典的键和值进行操作
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}
使用字典推导式将列表转换为字典,并指定默认值
python
# 使用字典推导式将列表转换为字典,并指定默认值
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': '未知'}
使用字典推导式将元组转换为字典,并指定默认值
python
# 使用字典推导式将元组转换为字典,并指定默认值
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': '北京'}
使用字典推导式对字典进行排序
python
# 使用字典推导式对字典进行排序
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}
键排序:
python
my_dict = {'b': 3, 'a': 1, 'c': 2}
sorted_keys = sorted(my_dict)
print(sorted_keys) # 输出:['a', 'b', 'c']
值排序:
python
my_dict = {'b': 3, 'a': 1, 'c': 2}
sorted_values = sorted(my_dict.values())
print(sorted_values) # 输出:[1, 2, 3]
使用字典推导式对字典进行去重(删除重复数据,一个不留)
python
# 使用字典推导式对字典进行去重
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}