python 字典的基础

最新推荐文章于 2024-07-31 14:30:10 发布

zhjx0903

最新推荐文章于 2024-07-31 14:30:10 发布

阅读量919

点赞数 11

文章标签： python 开发语言

本文链接：https://blog.csdn.net/zhjx0903/article/details/140458120

版权

简介：

在Python中，字典是一种可变容器模型，且可存储任意类型对象。字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号 , 分割，整个字典包括在花括号 {} 中。键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

在Python中，字典的键必须是唯一的，不能重复。如果尝试使用已经存在的键来添加或修改字典中的值，那么该键对应的值将会被新的值所覆盖。
例如：

my_dict = {'name': 'Alice', 'age': 25}
my_dict['name'] = 'Bob'  # 这里键 'name' 已存在，所以它的值被更新为 'Bob'
print(my_dict)  # 输出: {'name': 'Bob', 'age': 25}

如果尝试添加一个已经存在的键，Python会自动覆盖旧的键值对：

my_dict['age'] = 26  # 键 'age' 已存在，它的值被更新为 26
print(my_dict)  # 输出: {'name': 'Bob', 'age': 26}

创建字典：

在Python中创建字典非常简单，你可以使用花括号{}来定义一个字典，或者使用dict()构造函数。字典由键（key）和值（value）组成，键必须是唯一的，而值可以是任何数据类型。

以下是创建字典的几种方法：

1.使用花括号`{}`创建字典：

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

2.使用`dict()`构造函数创建字典：

my_dict = dict(name='Alice', age=25, city='New York')

3.从键值对列表创建字典：

pairs = [('name', 'Alice'), ('age', 25), ('city', 'New York')]
my_dict = dict(pairs)

4.从两个列表创建字典（一个列表包含键，另一个包含值）：

keys = ['name', 'age', 'city']
values = ['Alice', 25, 'New York']
my_dict = dict(zip(keys, values))

创建字典后，你可以通过键来访问对应的值：

print(my_dict['name'])  # 输出: Alice
print(my_dict['age'])   # 输出: 25
print(my_dict['city'])  # 输出: New York

在字典中添加

向已经存在的字典中添加一个新的键值对非常简单。

添加单个键值

方法描述：

直接通过指定键来赋值，如果键不存在，它会被添加到字典中；
如果键已经存在，它会被更新为新的值。

例子：

1.键不存在时

# 假设有一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 添加新的键值对
my_dict['d'] = 4
# my_dict['e'] = 5    # 可以同时添加多个
# 打印更新后的字典
print(my_dict)     # 输出：{'a': 1, 'b': 2, 'c': 3, 'd': 4}

执行这段代码后，my_dict将包含一个新的键值对'd': 4。

2.键存在时(不是进行添加的操作)

# 假设有一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 进行添加的操作
my_dict['c'] = 4

# 打印更新后的字典
print(my_dict)   # 输出：{'a': 1, 'b': 2, 'c': 4}

执行这段代码后，my_dict 中键'b' 原本的值被替代

添加多个：

在已经存在的字典中添加多个新的键值，仍然可以通过直接赋值的方法实现。也可以通过其他的方法实现。

方法一：直接赋值：

如果你已经知道要添加的键值对，可以直接通过赋值语句添加他们。

例子：(直接赋值)

my_dict = {'a':1,'b':2}
my_dict['c'] = 3
my_dict['d'] = 4
print(my_dict)    # 输出新的字典，{'a': 1, 'b': 2, 'c': 3, 'd': 4}

方法二：

将这些要添加的元素放在一个新的字典中，对这两个字典进行合并即可。具体方法键下面的合并字典。

[[合并字典]]：

什么是合并字典？

合并字典是指将两个或多个字典中的键值对组合到一个新的字典中，使得新字典包含了所有原始字典中的键值对。在合并过程中，如果遇到相同的键，则需要决定如何处理这些键的值。通常，如果键相同，可以决定保留第一个字典中的值，或者保留第二个字典中的值，或者将它们合并（例如，通过将值放入列表中）。

常见的方法：

1. 使用 [[`.update()`]]方法：

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict1.update(dict2)
# dict1 现在是 {'a': 1, 'b': 3, 'c': 4}

2. 使用 `**` 运算符（Python 3.5+）：

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged_dict = {**dict1, **dict2}
# merged_dict 是 {'a': 1, 'b': 3, 'c': 4}

3. 使用 `|` 运算符（Python 3.9+）：

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged_dict = dict1 | dict2
print(merged_dict)
# merged_dict 是 {'a': 1, 'b': 3, 'c': 4}

4. 使用 [[`copy()`]] 方法和 [[`.update()`]] 方法：

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged_dict = dict1.copy()
merged_dict.update(dict2)
# merged_dict 是 {'a': 1, 'b': 3, 'c': 4}

5. 使用 `dict()` 构造函数和 `**` 运算符：

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged_dict = dict(dict1, **dict2)
print(merged_dict)
# merged_dict 是 {'a': 1, 'b': 3, 'c': 4}

6. 使用循环手动合并：

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged_dict = dict1.copy()
for key, value in dict2.items():
	merged_dict[key] = value
	print(merged_dict)
   # merged_dict 是 {'a': 1, 'b': 3, 'c': 4}

在这些方法中，** 运算符和 | 运算符是最简洁和直观的，它们在Python 3.5+和Python 3.9+中引入，使得合并字典变得更加容易。如果你使用的是Python 3.5或更高版本，推荐使用这两种方法之一。如果你使用的是Python 3.9或更高版本，| 运算符提供了最直接的合并字典的方式。

输出字典中的元素

在Python中，输出字典中的元素可以通过几种不同的方式来实现。以下是一些常见的方法：

1.直接打印整个字典：

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
print(my_dict)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York'}

2.遍历字典并打印键和值：

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
for key in my_dict:
    print(key, my_dict[key])  # 输出键和对应的值

3.使用 `items()` 方法遍历字典：

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
for key, value in my_dict.items():
    print(key, value)  # 输出键和对应的值

4.使用 `values()` 方法遍历字典的值：

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
for value in my_dict.values():
    print(value)  # 输出字典中的所有值

5.使用`keys()`方法遍历字典的键：

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
for key in my_dict.keys():
    print(key)  # 输出字典中的所有键

6.格式化输出：

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
for key, value in my_dict.items():
    print(f"{key}: {value}")  # 使用f-string格式化输出键和值

选择哪种方法取决于你想要的输出格式和你对字典中元素的访问需求。直接打印整个字典会显示所有的键值对，而遍历字典则允许你以更灵活的方式访问和处理每个键值对。

访问元素

在Python中，你可以通过字典的键来访问字典中的元素。以下是如何访问字典中特定元素的几种方法：

1. 直接通过键访问：

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
name = my_dict['name']   # 输出: Alice

2. 使用`get()`方法：

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
age = my_dict.get('age')   # 输出: 25

get()方法允许你指定一个默认值，如果键不存在于字典中，它会返回这个默认值而不是抛出一个KeyError异常。

age = my_dict.get('height', 'Unknown')   # 如果'height'不在字典中，输出: Unknown

3. 使用`pop()`方法：

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
city = my_dict.pop('city')   # 输出: New York

pop()方法会移除字典中指定键的元素，并返回该元素的值。如果键不存在，它会抛出一个KeyError异常。

4. 使用`popitem()`方法：

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
key, value = my_dict.popitem()   # 输出: ('city', 'New York')

popitem()方法会移除字典中的最后一个键值对，并返回一个包含该键值对的元组。如果字典为空，它会抛出一个KeyError异常。

5. 使用`keys()`、`values()`和`items()`方法：

这些方法返回字典的视图对象，可以用来遍历字典中的键、值或键值对。

for key in my_dict.keys():
    print(key)   # 输出字典中的所有键

for value in my_dict.values():
    print(value)   # 输出字典中的所有值

for key, value in my_dict.items():
    print(key, value)   # 输出字典中的所有键值对

在使用这些方法时，请确保你访问的键确实存在于字典中，否则可能会引发KeyError异常。如果不确定键是否存在，使用get()方法是一个安全的选择。

删除元素

删除字典中的元素可以通过几种不同的方法来实现：

1. 使用`del`语句：

del语句可以用来删除字典中的特定元素。你需要指定要删除的键。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
del my_dict['age']  # 删除键为'age'的元素

2. 使用`pop()`方法：

pop()方法可以用来删除字典中的特定元素，并且可以选择返回该元素的值。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
age = my_dict.pop('age')  # 删除键为'age'的元素，并返回其值

3. 使用`popitem()`方法：

popitem()方法可以用来删除字典中的一个随机元素（在Python 3.7+中，字典是有序的，所以它会删除最后一个元素）。这个方法不接受参数。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
item = my_dict.popitem()  # 删除并返回一个键值对

4. 使用`clear()`方法：

clear()方法可以用来删除字典中的所有元素，但不返回任何值。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
my_dict.clear()  # 删除字典中的所有元素

5. 使用`dict`构造函数：

通过字典推导式和dict构造函数，可以创建一个新的字典，其中不包含特定的键。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
my_dict = {key: value for key, value in my_dict.items() if key != 'age'}  # 删除键为'age'的元素

在使用这些方法时，请确保你尝试删除的键确实存在于字典中，否则可能会引发KeyError异常。如果不确定键是否存在，使用pop()方法并提供一个默认值是一个安全的选择。

检查是否存在

在Python中，检查字典中是否存在某个键，可以使用in关键字。in关键字可以用来检查一个值是否存在于列表、元组、字符串、字典等可迭代对象中。对于字典，in关键字检查的是键（key）是否存在，而不是值（value）。

使用in关键字检查字典中键的存在：

1.检查键是否存在：

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 检查键'name'是否存在
if 'name' in my_dict:
    print("The key 'name' exists in the dictionary.")
else:
    print("The key 'name' does not exist in the dictionary.")

# 检查键'height'是否存在
if 'height' in my_dict:
    print("The key 'height' exists in the dictionary.")
else:
    print("The key 'height' does not exist in the dictionary.")

输出将会是：

The key 'name' exists in the dictionary.
The key 'height' does not exist in the dictionary.

2.检查值是否存在：

遍历字典的值，或者使用values()方法来获取一个包含所有值的视图对象，然后使用in关键字进行检查：

# 检查值'New York'是否存在
if 'New York' in my_dict.values():
    print("The value 'New York' exists in the dictionary.")
else:
    print("The value 'New York' does not exist in the dictionary.")

输出将会是：

The value 'New York' exists in the dictionary.

请注意，in关键字检查的是值的精确匹配，如果字典中有多个值，它会检查是否有一个值完全等于要查找的值。如果需要检查值是否在字典的某个键值对中，可以使用any()函数结合字典推导式：

# 检查值'New York'是否在字典的某个键值对中
if any(value == 'New York' for value in my_dict.values()):
    print("The value 'New York' exists in the dictionary.")
else:
    print("The value 'New York' does not exist in the dictionary.")

输出将会是：

The value 'New York' exists in the dictionary.

这种方法适用于值可能在多个键值对中出现的情况。

遍历字典

对字典中进行遍历的方法：

1. 使用`.items()`方法遍历键值对：

my_dict = {'a': 1, 'b': 2, 'c': 3}
for key, value in my_dict.items():
    print(f"键: {key}, 值: {value}")

2. 使用`.keys()`方法遍历键：

for key in my_dict.keys():
    print(f"键: {key}")

3. 使用`.values()`方法遍历值：

for value in my_dict.values():
    print(f"值: {value}")

4. 使用`enumerate()`遍历键值对，并获取索引：

for index, (key, value) in enumerate(my_dict.items()):
    print(f"索引: {index}, 键: {key}, 值: {value}")

这些方法都可以的，实际中根据需要选择使用。

获取字典的长度

复制字典

复制方法：

1. 使用字典推导式：

字典推导式可以用来创建一个新的字典，其中包含原字典的所有键值对。

original_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
copied_dict = {key: value for key, value in original_dict.items()}

2. 使用`dict()`构造函数：

dict()构造函数可以用来创建一个新的字典，同样包含原字典的所有键值对。

original_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
copied_dict = dict(original_dict.items())

3. 使用`copy()`方法：

字典有一个copy()方法，可以用来创建一个浅拷贝（shallow copy）的副本。

original_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
copied_dict = original_dict.copy()

4. 使用`copy`模块：

copy模块提供了copy()函数，可以用来创建一个浅拷贝的副本。

import copy
original_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
copied_dict = copy.copy(original_dict)

注意：

上述四种方法创建的都是浅拷贝（shallow copy），这意味着如果字典中的值是可变对象（如列表、字典、集合等），那么在新字典中修改这些值会影响到原字典。如果需要深拷贝（deep copy），即复制字典及其所有嵌套的可变对象，可以使用copy模块的deepcopy()函数：

import copy
original_dict = {'name': 'Alice', 'age': 25, 'city': 'New York', 'details': {'height': 165}}
copied_dict = copy.deepcopy(original_dict)

在使用deepcopy()时，即使字典中的值是可变对象，新字典中的这些对象也会是原对象的独立副本，不会相互影响。

清空字典

在Python中，清空字典可以通过几种不同的方法来实现。以下是一些常见的方法：

1. 使用`clear()`方法：

字典有一个内置的clear()方法，可以用来移除字典中的所有键值对，从而清空字典。

   my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
   my_dict.clear()
   print(my_dict)  # 输出: {}

2. 重新赋值：

你可以通过将一个空字典赋值给原字典变量来清空它。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
my_dict = {}
print(my_dict)  # 输出: {}

3. 使用`dict()`构造函数：

你可以使用dict()构造函数创建一个新的空字典，并将它赋值给原字典变量。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
my_dict = dict()
print(my_dict)  # 输出: {}

4. 使用`dict.fromkeys()`方法：

dict.fromkeys() 方法可以用来创建一个新的字典，其中包含指定的键和指定的值（默认为None）。如果你不提供值，它会创建一个只包含指定键的空字典。fromkeys()方法：

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
my_dict = dict.fromkeys(my_dict.keys())
print(my_dict)  # 输出: {'name': None, 'age': None, 'city': None}

上述司四种方法都会创建一个新的空字典，并将原字典变量指向这个新字典。原字典中的所有键值对都会被移除，从而实现清空字典的目的。

实现多值与一个键相关联

如果你需要存储多个值与同一个键相关联，你可以使用以下方法：

1.使用列表或集合作为值：

如果一个键对应多个值，你可以将这些值存储在一个列表或集合中。

my_dict = {'name': ['Alice', 'Bob'], 'age': [25, 26]}

将这个字典输出为表格的样式，对齐。（加上下面的代码）

for key in my_dict:  
    print(key.ljust(10), end='\t')  
print()  
for i in range(len(my_dict[key])):  
    for key in my_dict:  
        print(str(my_dict[key][i]).ljust(10), end='\t')  
    print()

ljust(10) 是列宽为10，end='\t' 是制表符。

2.使用字典嵌套：

如果需要更复杂的结构，可以将字典嵌套在另一个字典中。

my_dict = {'name': {'first': 'Alice', 'last': 'Smith'}, 'age': [25, 26]}

在任何情况下，字典的键都是唯一的，但它们可以关联到包含多个元素的复杂数据结构。

zhjx0903

关注

11
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
python 字典的基础

python中字典的基础知识点整理。
复制链接

扫一扫

python 字典的基础

简介：

创建字典：

1.使用花括号{}创建字典：

2.使用dict()构造函数创建字典：

3.从键值对列表创建字典：

4.从两个列表创建字典（一个列表包含键，另一个包含值）：

在字典中添加

添加单个键值

方法描述：

例子：

1.键不存在时

2.键存在时(不是进行添加的操作)

添加多个：

方法一：直接赋值：

例子：(直接赋值)

方法二：

[[合并字典]]：

什么是合并字典？

常见的方法：

1. 使用 [[.update()]]方法：

2. 使用 ** 运算符（Python 3.5+）：

3. 使用 | 运算符（Python 3.9+）：

4. 使用 [[copy()]] 方法和 [[.update()]] 方法：

5. 使用 dict() 构造函数和 ** 运算符：

6. 使用循环手动合并：

输出字典中的元素

1.直接打印整个字典：

2.遍历字典并打印键和值：

3.使用 items() 方法遍历字典：

4.使用 values() 方法遍历字典的值：

5.使用keys()方法遍历字典的键：

6.格式化输出：

访问元素

1. 直接通过键访问：

2. 使用get()方法：

3. 使用pop()方法：

4. 使用popitem()方法：

5. 使用keys()、values()和items()方法：

删除元素

1. 使用del语句：

2. 使用pop()方法：

3. 使用popitem()方法：

4. 使用clear()方法：

5. 使用dict构造函数：

检查是否存在

1.检查键是否存在：

2.检查值是否存在：

遍历字典

1. 使用.items()方法遍历键值对：

2. 使用.keys()方法遍历键：

3. 使用.values()方法遍历值：

4. 使用enumerate()遍历键值对，并获取索引：

获取字典的长度

复制字典

复制方法：

1. 使用字典推导式：

2. 使用dict()构造函数：

3. 使用copy()方法：

4. 使用copy模块：

注意：

清空字典

1. 使用clear()方法：

2. 重新赋值：

3. 使用dict()构造函数：

4. 使用dict.fromkeys()方法：

实现多值与一个键相关联

1.使用列表或集合作为值：

2.使用字典嵌套：

1.使用花括号`{}`创建字典：

2.使用`dict()`构造函数创建字典：

1. 使用 [[`.update()`]]方法：

2. 使用 `**` 运算符（Python 3.5+）：

3. 使用 `|` 运算符（Python 3.9+）：

4. 使用 [[`copy()`]] 方法和 [[`.update()`]] 方法：

5. 使用 `dict()` 构造函数和 `**` 运算符：

3.使用 `items()` 方法遍历字典：

4.使用 `values()` 方法遍历字典的值：

5.使用`keys()`方法遍历字典的键：

2. 使用`get()`方法：

3. 使用`pop()`方法：

4. 使用`popitem()`方法：

5. 使用`keys()`、`values()`和`items()`方法：

1. 使用`del`语句：

2. 使用`pop()`方法：

3. 使用`popitem()`方法：

4. 使用`clear()`方法：

5. 使用`dict`构造函数：

1. 使用`.items()`方法遍历键值对：

2. 使用`.keys()`方法遍历键：

3. 使用`.values()`方法遍历值：

4. 使用`enumerate()`遍历键值对，并获取索引：

2. 使用`dict()`构造函数：

3. 使用`copy()`方法：

4. 使用`copy`模块：

1. 使用`clear()`方法：

3. 使用`dict()`构造函数：

4. 使用`dict.fromkeys()`方法：