Python 笔记 — 基本数据类型（五）字典类型

最新推荐文章于 2023-11-28 15:12:44 发布

永远十八的小仙女~

最新推荐文章于 2023-11-28 15:12:44 发布

阅读量365

点赞数 2

分类专栏： Python 文章标签： python 笔记

本文链接：https://blog.csdn.net/muyuhen/article/details/130601335

版权

Python 专栏收录该内容

24 篇文章 1 订阅

订阅专栏

一、定义

用于表示键值对的集合，每个键关联一个值，可以使用花括号来定义字典。

字典是一种可变的、无序的、键-值对（key-value）的数据结构。
字典中的每个元素由一个键和对应的值组成，键和值之间使用冒号（:）分隔，键值对之间使用逗号（,）分隔。
字典中的键必须是唯一的，而值可以重复。
字典中的元素是无序的，即不能通过索引访问，而是通过键来获取对应的值。

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
print(my_dict) # {'name': 'John', 'age': 30, 'city': 'New York'}

my_dict2 = dict(name='John', age=30, city='New York')
print(my_dict2) # {'name': 'John', 'age': 30, 'city': 'New York'}

二、相关操作

1、查看元素

1.1、key

通过键（key）查看对应的值，如果没有对应的 key 值会报错。

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
print(my_dict['key1']) # value1

print(my_dict['key4']) # 报错：KeyError: 'key4'

1.2、get

使用 get() 方法来查看对应的值，如果键不存在，返回指定的默认值（默认为 None）。

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
print(my_dict.get('key2')) # value2
print(my_dict.get('key4')) # None

2、修改元素

2.1、key

直接赋值修改元素。

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
my_dict['key1'] = 'new value'
print(my_dict) # {'key1': 'new value', 'key2': 'value2', 'key3': 'value3'}

2.2、update

批量修改元素。

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
new_data = {'key2': 'new value2', 'key3': 'new value3'}
my_dict.update(new_data)
print(my_dict) # {'key1': 'value1', 'key2': 'new value2', 'key3': 'new value3'}

3、增加元素

3.1、setdefault

修改元素或添加新元素。

my_dict = {'key1': 'value1', 'key2': 'value2'}
my_dict.setdefault('key3', 'value3')
my_dict.setdefault('key2', 'new value2')
print(my_dict) # {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

3.2、dict

访问不存在的键时，可以直接赋值来添加新元素。

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
my_dict['key4'] = 'value4'
print(my_dict) # {'key1': 'value1', 'key2': 'value2', 'key3': 'value3', 'key4': 'value4'}

4、删除元素

4.1、del

删除指定的元素

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
del my_dict['key2']
print(my_dict) # {'key1': 'value1', 'key3': 'value3'}

删除整个字典

my_dict = {'name':'monitor', 'sex':'f', 'address':'China'}
print(my_dict) # {'name': 'monitor', 'sex': 'f', 'address': 'China'}
del my_dict
print(my_dict) # 报错：NameError: name 'my_dict' is not defined

4.2、pop

删除指定的元素并返回其值。

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
value = my_dict.pop('key2')
print(my_dict) # {'key1': 'value1', 'key3': 'value3'}
print(value) # value2

4.3、popitem

随机删除并返回一个键值对。

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
item = my_dict.popitem()
print(my_dict) # {'key1': 'value1', 'key2': 'value2'}
print(item) # ('key3', 'value3')

4.4、clear

清空整个字典的元素。

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
my_dict.clear()
print(my_dict) # {}

5、常见操作

5.1、len

获取字典中键值对的数量（即字典的长度）。

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
print(len(my_dict)) # 3

5.2、keys

获取字典中的所有键。

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
keys = my_dict.keys()
print(keys) # dict_keys(['key1', 'key2', 'key3'])

5.3、values

获取字典中的所有值。

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
values = my_dict.values()
print(values) # dict_values(['value1', 'value2', 'value3'])

5.4、items

获取字典中的所有键值对。

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
items = my_dict.items()
print(items) # dict_items([('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3')])

5.5、fromkeys

用于创建一个新字典，其中指定的键对应于给定的默认值。

new_dict = dict.fromkeys(keys, value)

参数说明：

keys：指定要作为键的可迭代对象。
value：指定的默认值，将会赋给所有键。
返回值是一个新的字典对象，其中包含了指定的键和默认值。

keys = ['name', 'age', 'gender']
default_value = 'unknown'
person_dict = dict.fromkeys(keys, default_value)
print(person_dict) # {'name': 'unknown', 'age': 'unknown', 'gender': 'unknown'}

5.6、sorted

字典本身是无序的，无法直接对字典进行排序。

可以使用 sorted() 函数对字典的键、值或键值对进行排序，并返回一个有序的列表。

按照键进行排序：

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

for key in sorted_keys:
    print(key, my_dict[key])
# a 1
# b 2
# c 3

按照值进行排序：

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

for value in sorted_values:
    for key in my_dict:
        if my_dict[key] == value:
            print(key, value)
            break
# a 1
# b 2
# c 3

按照键值对进行排序：

my_dict = {'b': 2, 'a': 1, 'c': 3}
sorted_items = sorted(my_dict.items())
print(sorted_items) # [('a', 1), ('b', 2), ('c', 3)]

for key, value in sorted_items:
    print(key, value)
# a 1
# b 2
# c 3

三、字典嵌套

在 Python 中，字典也可以嵌套在另一个字典中，形成字典的嵌套结构。这种字典的嵌套结构允许在一个字典中存储其他字典，从而创建更复杂的数据结构。

# 字典嵌套
nested_dict = {
    'dict1': {'key1': 'value1', 'key2': 'value2'},
    'dict2': {'key3': 'value3', 'key4': 'value4'},
    'dict3': {'key5': 'value5', 'key6': 'value6'}
}
print(nested_dict) # {'dict1': {'key1': 'value1', 'key2': 'value2'}, 'dict2': {'key3': 'value3', 'key4': 'value4'}, 'dict3': {'key5': 'value5', 'key6': 'value6'}}

# 访问嵌套字典中的元素
print(nested_dict['dict1']) # {'key1': 'value1', 'key2': 'value2'}
print(nested_dict['dict2']['key3']) # value3

# 修改嵌套字典中的元素
nested_dict['dict3']['key6'] = 'updated value'
print(nested_dict) # {'dict1': {'key1': 'value1', 'key2': 'value2'}, 'dict2': {'key3': 'value3', 'key4': 'value4'}, 'dict3': {'key5': 'value5', 'key6': 'updated value'}}

# 迭代遍历嵌套字典
for key, value in nested_dict.items():
    print(key)
    for nested_key, nested_value in value.items():
        print(nested_key, nested_value)
# dict1
# key1 value1
# key2 value2
# dict2
# key3 value3
# key4 value4
# dict3
# key5 value5
# key6 value6

四、字典推导式

字典推导式（Dictionary comprehension）是一种简洁创建字典的方法。它允许我们通过对一个可迭代对象进行迭代并定义键值对的方式来快速创建字典。

基本形式：

{键的表达式: 值的表达式 for 元素 in 可迭代对象}
{键的表达式: 值的表达式 for 元素 in 可迭代对象 if 条件}

1、创建一个包含数字和它们的平方的新字典

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

2、创建一个包含偶数及其平方的新字典

numbers = [1, 2, 3, 4, 5]
even_squares_dict = {x: x**2 for x in numbers if x % 2 == 0}
print(even_squares_dict) # {2: 4, 4: 16}

3、将一个字典中的键和值进行反转

my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
reversed_dict = {value: key for key, value in my_dict.items()}
print(reversed_dict) # {1: 'apple', 2: 'banana', 3: 'cherry'}

4、将一个字典中的偶数值进行平方，并只保留值为偶数的键值对

my_dict = {'apple': 1, 'banana': 2, 'cherry': 3, 'date': 4}
modified_dict = {key: value**2 for key, value in my_dict.items() if value % 2 == 0}
print(modified_dict) # {'banana': 4, 'date': 16}

5、使用两个列表的元素来创建一个字典

keys = ['a', 'b', 'c']
values = [1, 2, 3]
combined_dict = {key: value for key, value in zip(keys, values)}
print(combined_dict) # {'a': 1, 'b': 2, 'c': 3}

6、使用嵌套的字典推导式来创建嵌套字典

keys = ['a', 'b', 'c']
values = [1, 2, 3]
nested_dict = {key: {value: value**2 for value in values} for key in keys}
print(nested_dict) # {'a': {1: 1, 2: 4, 3: 9}, 'b': {1: 1, 2: 4, 3: 9}, 'c': {1: 1, 2: 4, 3: 9}}

7、将一个字符串列表中的元素作为键，使用它们的长度作为对应的值

words = ['apple', 'banana', 'cherry']
word_length_dict = {word: len(word) for word in words}
print(word_length_dict) # {'apple': 5, 'banana': 6, 'cherry': 6}

8、合并两个字典，并根据键的出现次数创建一个新的字典

dict1 = {'apple': 2, 'banana': 3}
dict2 = {'apple': 1, 'cherry': 4}
merged_dict = {key: dict1.get(key, 0) + dict2.get(key, 0) for key in set(dict1) | set(dict2)}
print(merged_dict) # {'cherry': 4, 'banana': 3, 'apple': 3}

9、使用条件筛选来创建一个只包含奇数键的字典

numbers = {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5}
odd_dict = {key: value for key, value in numbers.items() if value % 2 != 0}
print(odd_dict) # {'one': 1, 'three': 3, 'five': 5}

10、将一个字符串列表中的元素作为键，并将它们的首字母转换为大写作为对应的值

fruits = ['apple', 'banana', 'cherry']
fruits_dict = {fruit: fruit[0].upper() for fruit in fruits}
print(fruits_dict) # {'apple': 'A', 'banana': 'B', 'cherry': 'C'}

11、使用字典推导式创建一个包含乘法表的嵌套字典

multiplication_table = {i: {j: i * j for j in range(1, 11)} for i in range(1, 11)}
for i in range(1, 11):
    print(multiplication_table[i])
# {1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10}
# {1: 2, 2: 4, 3: 6, 4: 8, 5: 10, 6: 12, 7: 14, 8: 16, 9: 18, 10: 20}
# {1: 3, 2: 6, 3: 9, 4: 12, 5: 15, 6: 18, 7: 21, 8: 24, 9: 27, 10: 30}
# {1: 4, 2: 8, 3: 12, 4: 16, 5: 20, 6: 24, 7: 28, 8: 32, 9: 36, 10: 40}
# {1: 5, 2: 10, 3: 15, 4: 20, 5: 25, 6: 30, 7: 35, 8: 40, 9: 45, 10: 50}
# {1: 6, 2: 12, 3: 18, 4: 24, 5: 30, 6: 36, 7: 42, 8: 48, 9: 54, 10: 60}
# {1: 7, 2: 14, 3: 21, 4: 28, 5: 35, 6: 42, 7: 49, 8: 56, 9: 63, 10: 70}
# {1: 8, 2: 16, 3: 24, 4: 32, 5: 40, 6: 48, 7: 56, 8: 64, 9: 72, 10: 80}
# {1: 9, 2: 18, 3: 27, 4: 36, 5: 45, 6: 54, 7: 63, 8: 72, 9: 81, 10: 90}
# {1: 10, 2: 20, 3: 30, 4: 40, 5: 50, 6: 60, 7: 70, 8: 80, 9: 90, 10: 100}

五、使用 for 循环遍历

person = {'name': 'John', 'age': 30, 'gender': 'male'}

# 遍历字典的键
for key in person:
    print(key)
# name
# age
# gender

# 遍历字典的值
for value in person.values():
    print(value)
# John
# 30
# male

# 遍历字典的键值对
for key, value in person.items():
    print(key, value)
# name John
# age 30
# gender male

六、enumerate 枚举

通过枚举函数，我们可以在遍历字典的过程中获取每个键和对应的值，并根据需要进行处理。

student_scores = {
    'Alice': 85,
    'Bob': 92,
    'Charlie': 78,
    'David': 88
}
for key, value in student_scores.items():
    print(key, value)
# Alice 85
# Bob 92
# Charlie 78
# David 88

七、使用 while 循环

person = {'name': 'John', 'age': 30, 'gender': 'male'}

# 遍历字典的键
keys = list(person.keys())
index = 0
while index < len(keys):
    key = keys[index]
    print(key)
    index += 1
# name
# age
# gender

# 遍历字典的值
values = list(person.values())
index = 0
while index < len(values):
    value = values[index]
    print(value)
    index += 1
# John
# 30
# male

# 遍历字典的键值对
items = list(person.items())
index = 0
while index < len(items):
    key, value = items[index]
    print(key, value)
    index += 1
# name John
# age 30
# gender male

八、应用

1、学生成绩统计：假设有一批学生成绩数据，每个学生对应一个字典，包含姓名和成绩。编写代码统计每个成绩段（优秀、良好、及格、不及格）的学生人数。

# 定义学生成绩字典列表
students = [
    {'name': 'Alice', 'score': 90},
    {'name': 'Bob', 'score': 85},
    {'name': 'Charlie', 'score': 70},
    {'name': 'David', 'score': 55},
    {'name': 'Eva', 'score': 80}
]

# 定义成绩段和对应的人数字典
score_counts = {'优秀': 0, '良好': 0, '及格': 0, '不及格': 0}

# 统计每个成绩段的人数
for student in students:
    score = student['score']
    if score >= 90:
        score_counts['优秀'] += 1
    elif score >= 80:
        score_counts['良好'] += 1
    elif score >= 60:
        score_counts['及格'] += 1
    else:
        score_counts['不及格'] += 1

# 打印每个成绩段的人数
for score, count in score_counts.items():
    print(score, '人数:', count)
    
# 优秀 人数: 1
# 良好 人数: 2
# 及格 人数: 1
# 不及格 人数: 1

2、单词频率统计：给定一个句子，编写代码统计每个单词在句子中出现的频率，并将结果存储在一个字典中。

sentence = "I love programming and programming is fun"
word_frequency = {}

# 统计单词频率
for word in sentence.split():
    if word in word_frequency:
        word_frequency[word] += 1
    else:
        word_frequency[word] = 1

# 打印单词频率
for word, frequency in word_frequency.items():
    print(word, '出现次数:', frequency)
    
# I 出现次数: 1
# love 出现次数: 1
# programming 出现次数: 2
# and 出现次数: 1
# is 出现次数: 1
# fun 出现次数: 1