一.Python的五大数据类型之字典类型

Python中的字典是一种无序的可变容器，可以存储任意数量的键值对。接下来我们就来学习一下五大数据类型之字典类型。

在这里插入图片描述

1.1 什么是字典

字典的键必须是唯一的，而值则可以是任意类型的对象，如字符串、数字、列表、元组等。字典的键是不可变类型，如字符串、数字、元组，而列表等可变类型则不能作为键。
字典的实现是通过哈希表实现的，因此查找、插入和删除操作的时间复杂度都是O(1)。

1.2 创建字典

创建字典的方式有多种，下面是其中两种常见的方式：

1.2.1 方式1:直接创建字典

# 直接创建字典
dict1 = {'name': 'Tom', 'age': 18, 'gender': 'male'}
print(dict1)  # 输出 {'name': 'Tom', 'age': 18, 'gender': 'male'}

1.2.2 方式2:使用dict()函数创建字典

dict2 = dict(name='Jerry', age=20, gender='female')
print(dict2)  # 输出 {'name': 'Jerry', 'age': 20, 'gender': 'female'}

1.3 字典的基本操作

1.3.1 添加元素

可以通过以下方式向字典中添加元素：

# 添加一个键值对
dict1['address'] = 'Beijing'
print(dict1)  # 输出 {'name': 'Tom', 'age': 18, 'gender': 'male', 'address': 'Beijing'}

# 更新一个键的值
dict1['age'] = 19
print(dict1)  # 输出 {'name': 'Tom', 'age': 19, 'gender': 'male', 'address': 'Beijing'}

# 批量添加元素
dict1.update({'email': 'tom@example.com', 'phone': '123456789'})
print(dict1)  # 输出 {'name': 'Tom', 'age': 19, 'gender': 'male', 'address': 'Beijing', 'email': 'tom@example.com', 'phone': '123456789'}

1.3.2 删除元素

可以通过以下方式从字典中删除元素：

# 删除一个键值对
del dict1['address']
print(dict1)  # 输出 {'name': 'Tom', 'age': 19, 'gender': 'male', 'email': 'tom@example.com', 'phone': '123456789'}

# 清空字典
dict1.clear()
print(dict1)  # 输出 {}

1.3.3 访问元素

可以通过键访问字典中的值：

dict1 = {'name': 'Tom', 'age': 18, 'gender': 'male'}
print(dict1['name'])  # 输出 Tom

需要注意的是，如果使用不存在的键来访问字典中的值，将会引发KeyError异常。可以使用get()方法来避免这种情况的发生，如果键不存在，则返回None或指定的默认值：

print(dict1.get('address'))  # 输出 None
print(dict1.get('address', 'unknown'))  # 输出 unknown

1.3.4 遍历字典

可以使用for循环继续遍历字典：

dict1 = {'name': 'Tom', 'age': 18, 'gender': 'male'}
# 遍历键
for key in dict1:
    print(key)

# 遍历值
for value in dict1.values():
    print(value)

# 遍历键值对
for key, value in dict1.items():
    print(key, value)

1.4 字典的基本方法

1.4.1 keys()

keys()方法返回字典中所有键的列表：

dict1 = {'name': 'Tom', 'age': 18, 'gender': 'male'}
print(dict1.keys())  # 输出 dict_keys(['name', 'age', 'gender'])

需要注意的是，keys()方法返回的是dict_keys类型的对象，而非列表类型，但是可以像列表一样使用。

1.4.2 values()

values()方法返回字典中所有值的列表：

dict1 = {'name': 'Tom', 'age': 18, 'gender': 'male'}
print(dict1.values())  # 输出 dict_values(['Tom', 18, 'male'])

同样，values()方法返回的是dict_values类型的对象，而非列表类型，但是可以像列表一样使用。

1.4.3 items()

items()方法返回字典中所有键值对的列表，每个键值对以元组的形式呈现：

dict1 = {'name': 'Tom', 'age': 18, 'gender': 'male'}
print(dict1.items())  # 输出 dict_items([('name', 'Tom'), ('age', 18), ('gender', 'male')])

同样，items()方法返回的是dict_items类型的对象，而非列表类型，但是可以像列表一样使用。

1.4.4 pop()

pop()方法可以从字典中删除指定的键值对，并返回对应的值，如果键不存在，则返回指定的默认值：

dict1 = {'name': 'Tom', 'age': 18, 'gender': 'male'}
value = dict1.pop('age')
print(value)  # 输出 18
print(dict1)  # 输出 {'name': 'Tom', 'gender': 'male'}

1.4.5 popitem()

popitem()方法可以随机删除字典中的一个键值对，并返回对应的键和值：

dict1 = {'name': 'Tom', 'age': 18, 'gender': 'male'}
key, value = dict1.popitem()
print(key, value)  # 输出 gender male
print(dict1)  # 输出 {'name': 'Tom', 'age': 18}

1.4.6 update()

update()方法可以将一个字典中的元素添加到另一个字典中，如果有相同的键，则用新字典中的值覆盖原字典中的值：

dict1 = {'name': 'Tom', 'age': 18, 'gender': 'male'}
dict2 = {'name': 'Jerry', 'email': 'jerry@example.com'}
dict1.update(dict2)
print(dict1)  # 输出{'name': 'Jerry', 'age': 18, 'gender': 'male', 'email': 'jerry@example.com'}

1.5 实操案例代码

1.5.1 案例一：统计字符串中每个字符出现的次数

def count_char(str1):
    char_dict = {}
    for char in str1:
        if char in char_dict:
            char_dict[char] += 1
        else:
            char_dict[char] = 1
    return char_dict

str1 = 'hello, world!'
print(count_char(str1))
# 输出 {'h': 1, 'e': 1, 'l': 3, 'o': 2, ',': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1, '!': 1}

1.5.2 案例二：合并多个字典

dict1 = {'name': 'Tom', 'age': 18}
dict2 = {'gender': 'Male'}
dict3 = {'email': 'tom@example.com'}

dict4 = {}
for d in (dict1, dict2, dict3):
    dict4.update(d)

print(dict4)
# 输出 {'name': 'Tom', 'age': 18, 'gender': 'Male', 'email': 'tom@example.com'}

1.5.3 案例三：根据字典中的值对字典排序

def sort_dict(dict1):
    dict2 = {k: v for k, v in sorted(dict1.items(), key=lambda item: item[1])}
    return dict2

dict1 = {'Tom': 75, 'Jerry': 90, 'Alice': 80, 'Bob': 85}
print(sort_dict(dict1))
# 输出 {'Tom': 75, 'Alice': 80, 'Bob': 85, 'Jerry': 90}

1.5.4 将列表转换为字典

keys = ['name', 'age', 'gender']
values = ['Tom', 18, 'Male']

dict1 = dict(zip(keys, values))

print(dict1)
# 输出 {'name': 'Tom', 'age': 18, 'gender': 'Male'}

1.5.5 使用字典实现一个简单的缓存

def fibonacci(n):
    if n in cache:
        return cache[n]

    if n < 2:
        result = n
    else:
        result = fibonacci(n - 1) + fibonacci(n - 2)

    cache[n] = result
    return result

1.6 字典的排序方法，升序以及降序

对于字典的排序，可以使用内置的 sorted() 函数或 sorted() 方法来实现，也可以使用 collections.OrderedDict 类来保持排序顺序。

下面分别介绍这些方法的升序和降序排序。

1.6.1 使用内置函数 sorted() 进行排序

使用内置函数 sorted() 可以对字典进行排序。默认情况下，sorted() 按照字典中的键进行升序排序。可以使用 reverse=True 参数来实现降序排序。

# 升序排序
d = {'b': 2, 'a': 1, 'c': 3}
sorted_d = sorted(d.items())
print(sorted_d)  # [('a', 1), ('b', 2), ('c', 3)]

# 降序排序
sorted_d_desc = sorted(d.items(), reverse=True)
print(sorted_d_desc)  # [('c', 3), ('b', 2), ('a', 1)]

1.6.2 使用字典的 sorted() 方法进行排序

使用字典的 sorted() 方法可以按照字典中的键或值进行排序。与 sorted() 函数一样，该方法默认按照字典中的键进行升序排序，并且可以使用 reverse=True 参数来实现降序排序。

# 升序排序
d = {'b': 2, 'a': 1, 'c': 3}
sorted_d = sorted(d.items())
print(sorted_d)  # [('a', 1), ('b', 2), ('c', 3)]

# 按值进行排序
sorted_d_value = sorted(d.items(), key=lambda x: x[1])
print(sorted_d_value)  # [('a', 1), ('b', 2), ('c', 3)]

# 降序排序
sorted_d_desc = sorted(d.items(), key=lambda x: x[0], reverse=True)
print(sorted_d_desc)  # [('c', 3), ('b', 2), ('a', 1)]

1.6.3 使用 collections.OrderedDict 类进行排序

collections.OrderedDict 类可以保持字典中元素的插入顺序，并且支持排序功能。默认情况下，OrderedDict 按照字典中的键进行升序排序。可以使用 reverse=True 参数来实现降序排序。

from collections import OrderedDict

# 升序排序
d = {'b': 2, 'a': 1, 'c': 3}
sorted_d = OrderedDict(sorted(d.items()))
print(sorted_d)  # OrderedDict([('a', 1), ('b', 2), ('c', 3)])

# 按值进行排序
sorted_d_value = OrderedDict(sorted(d.items(), key=lambda x: x[1]))
print(sorted_d_value)  # OrderedDict([('a', 1), ('b', 2), ('c', 3)])

# 降序排序
sorted_d_desc = OrderedDict(sorted(d.items(), key=lambda x: x[0], reverse=True))
print(sorted_d_desc)  # OrderedDict([('c', 3), ('b', 2), ('a', 1)])

二.注意事项

字典的键必须是可哈希的，也就是说，键必须是不可变的类型，比如数字、字符串、元组等，而列表和字典等可变类型是不可以作为键的。
字典是无序的，如果需要有序的字典，可以使用collections模块中的OrderedDict类。
在Python3中，keys()、values()、items()等方法返回的不再是列表类型，而是dict_keys、dict_values、dict_items类型的对象，但是可以像列表一样使用。
字典的遍历顺序可能会随机变化，因此在遍历时需要注意顺序的问题。
字典的操作是原地修改，也就是说，对字典进行的任何修改都会影响原始的字典，因此在进行操作时需要注意备份的问题。

三.总结

总的来说，Python中的字典类型是一种非常有用的数据类型，可以用来存储键值对，其基本用法和列表、元组等数据类型类似，但是字典的键值对是无序的，且键必须是不可变类型。
字典类型的基本用法包括创建字典、访问字典中的元素、修改字典中的元素、删除字典中的元素等操作。另外，字典类型也提供了一些基本的方法，如keys()、values()、items()等，可以用来访问字典中的键、值、键值对等。
字典类型也有一些高级用法，如遍历字典、合并多个字典、将列表转换为字典、使用字典实现一个简单的缓存等操作，这些操作可以帮助我们更好地利用字典类型来解决实际问题。
在使用字典类型时，需要注意字典是无序的，键必须是不可变类型，同时还要注意避免使用不恰当的键或值类型、重复的键等问题。
此外，在使用字典类型时，还需要注意一些性能问题。由于字典类型使用哈希表来实现，所以在访问字典中的元素时，其速度是非常快的，但是在插入和删除元素时，由于哈希表的重新哈希和扩容等操作，可能会导致性能下降。因此，在需要频繁插入和删除元素的情况下，应该考虑使用其他数据类型来替代字典类型。
最后，需要注意的是，字典类型虽然非常灵活和方便，但是在处理大量数据时可能会导致内存占用过大的问题。因此，在需要处理大量数据时，需要谨慎使用字典类型，并尽可能地使用一些高效的算法和数据结构来减少内存占用。