一、字典的基本操作
字典(Dictionary)是一种Python基本数据类型,是一种无序、可变的数据类型,它由键值对(key-value)组成。
字典使用大括号{}来表示,键和值之间使用冒号:分隔,键值对之间使用逗号,分隔。
字典中的键必须是唯一的,且不可变的数据类型,而值可以是任意类型的对象。
字典可以通过键来访问对应的值。
1、创建字典
方法1:使用 {} 创建字典
当使用{}创建字典时,可以通过不同的方式创建空字典和非空字典。下面是相应的示例:
# 创建空字典
empty_dict = {}
# 创建非空字典
non_empty_dict = {'name': 'John', 'age': 25, 'city': 'New York'}
方法2:使用dict() 函数创建字典
当使用dict()函数创建字典时,你可以通过传递不同的参数来创建空字典和非空字典。下面是相应的示例:
# 创建空字典
empty_dict = dict()
# 创建非空字典
non_empty_dict = dict(name='John', age=25, city='New York')
dict()函数注释如下:
class dict(object):
"""
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
(key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
d = {}
for k, v in iterable:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list. For example: dict(one=1, two=2)
"""
由上可知,dict()函数提供了多种创建字典的方式,具体取决于你传递给它的参数。下面是几种常见的用法:
2.1 使用dict(**kwargs) 函数传入关键字参数创建字典
person = dict(name='Alice', age=25, city='New York')
print(person ) # {'name': 'Alice', 'age': 25, 'city': 'New York'}
2.2 使用dict(iterable) 函数传入可迭代对象创建字典
pairs = [('name', 'Alice'), ('age', 25), ('city', 'New York')]
person = dict(pairs)
print(person) # {'name': 'Alice', 'age': 25, 'city': 'New York'}
2.3 使用dict()函数和zip()函数结合创建字典
keys = ['name', 'age', 'city']
values = ['Alice', 25, 'New York']
dictionary = dict(zip(keys, values))
print(dictionary) # {'name': 'Alice', 'age': 25, 'city': 'New York'}
使用这种方法,你可以根据需要灵活地创建字典,而不需要显式地编写键值对。
2.4 使用dict.fromkeys()函数创建字典
keys = ['name', 'age', 'city']
default_value = 'Unknown'
new_dict = dict.fromkeys(keys, default_value)
print(new_dict) # {'name': 'Unknown', 'age': 'Unknown', 'city': 'Unknown'}
`dict.fromkeys(*args, **kwargs)`函数接受两个参数:一个可迭代对象作为键的集合,以及一个可选参数作为默认值。它将使用可迭代对象中的每个元素作为字典的键,并将默认值分配给每个键。
总之,dict.fromkeys()函数是一个快速创建具有相同默认值的字典的方便方法。
2、访问字典
使用 dict['key'] 的方式来访问字典,其中 'key' 是要访问的键名。通过这种方式,可以直接获取字典中指定键的对应值。
以下是两种常见的访问字典元素的方法:
# 创建一个字典
person = {'name': 'Alice', 'age': 25, 'city': 'New York'}
# 使用方括号[]访问字典元素
name = person['name']
# 使用get()方法访问字典元素
age = person.get('age')
需要注意的是,如果使用方括号`[]`访问一个不存在的键,会抛出`KeyError`异常。而使用`get()`方法访问一个不存在的键时,会返回`None`,或者也可以指定一个默认值作为`get()`方法的第二个参数。
3、更新字典
可以使用 `dict['key'] = value` 的方式来更新字典中特定键的值。如果键存在,则该值将被更新;如果键不存在,则将创建一个新的键值对。
键存在的示例代码:
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict['b'] = 4 # 更新键 'b' 的值为 4
print(my_dict) # 输出: {'a': 1, 'b': 4, 'c': 3}
在上面的示例中,通过 `my_dict['b'] = 4` 的方式将键 `'b'` 的值从原来的 `2` 更新为 `4`。
键不存在的示例代码:
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict['d'] = 5 # 添加新的键值对 {'d': 5}
print(my_dict) # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 5}
在上面的示例中,通过 `my_dict['d'] = 5` 的方式添加了一个新的键值对 `{'d': 5}` 到字典中。
二、字典的属性方法
可以使用dir(dict)函数,打印输出字典dict的所有属性和方法。
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
根据每种方法的用途可以分为如下几类:
增:'update',
删:'pop', 'popitem',clear',
改:'update',
查:'keys', 'values','items', 'get','setdefault',
其它:'copy', 'fromkeys',
1、更新字典(update)
dict.update()方法用于更新字典中的键值对。如果给定的字典与原字典中的键相同,则更新原字典中的键对应的值;如果给定的字典中的键在原字典中不存在,则将其添加到原字典中。
语法如下:
def update(self, E=None, **F): -> None
- dict:表示要更新的字典对象。
- E:可选参数,可以是一个字典或可迭代对象。用于更新字典的键值对。
- **F:可变关键字参数,用于接收额外的键值对。这些键值对会在更新字典时被添加或更新。
- 返回值:None,所以该方法会直接修改原始字典,而不会返回一个新的字典。
代码实例:
1. 使用字典对象更新字典:
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict1.update(dict2)
print(dict1) # 输出: {'a': 1, 'b': 3, 'c': 4}
2. 使用可迭代对象更新字典:
dict1 = {'a': 1, 'b': 2}
items = [('b', 3), ('c', 4)]
dict1.update(items)
print(dict1) # 输出: {'a': 1, 'b': 3, 'c': 4}
3. 使用关键字参数更新字典:
dict1 = {'a': 1, 'b': 2}
dict1.update(c=3, d=4)
print(dict1) # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}
2、删除字典中元素(del、pop、popitem、clear)
删除字典中的元素有多种方法,以下是一些常用的方式:
1. 使用 del 关键字删除指定键的元素:
my_dict = {'a': 1, 'b': 2, 'c': 3}
del my_dict['a']
print(my_dict) # 输出: {'b': 2, 'c': 3}
2. 使用 pop(key) 方法删除指定键的元素:
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict.pop('a')
print(my_dict) # 输出: {'b': 2, 'c': 3}
3. 用 popitem() 方法随机删除并返回一个键值对:
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict.popitem()
print(my_dict) # 输出: {'a': 1, 'b': 2}
4. 使用 clear() 方法清空整个字典:
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict.clear()
print(my_dict) # 输出: {}
3、获取字典中所有键和值(keys、values、items)
字典的 `keys()`、`values()` 和 `items()` 方法是用于获取字典中元素的方法。
- `keys()` 方法返回一个包含字典所有键的视图(view)。可以通过将其转换为其他类型(如列表)来获取键的列表。
- `values()` 方法返回一个包含字典所有值的视图(view)。同样可以通过将其转换为其他类型来获取值的列表。
- `items()` 方法返回一个包含字典所有键值对的视图(view)。每个键值对都表示为一个元组,可以通过将其转换为其他类型来获取键值对的列表。
下面是一些示例代码:
my_dict = {'a': 1, 'b': 2, 'c': 3}
keys = my_dict.keys()
values = my_dict.values()
items = my_dict.items()
print(keys) # 输出: dict_keys(['a', 'b', 'c'])
print(values) # 输出: dict_values([1, 2, 3])
print(items) # 输出: dict_items([('a', 1), ('b', 2), ('c', 3)])
# 转换为列表
key_list = list(keys)
value_list = list(values)
item_list = list(items)
print(key_list) # 输出: ['a', 'b', 'c']
print(value_list) # 输出: [1, 2, 3]
print(item_list) # 输出: [('a', 1), ('b', 2), ('c', 3)]
4、获取字典中指定键的值(get、setdefault)
1. `get(key, default)` 方法用于获取指定键的值。如果字典中存在该键,则返回对应的值;如果字典中不存在该键,则返回指定的默认值。示例代码如下:
my_dict = {'a': 1, 'b': 2, 'c': 3}
value = my_dict.get('a', 0)
print(value) # 输出: 1
value = my_dict.get('d', 0)
print(value) # 输出: 0
在上面的示例中,第一个 `get()` 方法返回了键 `'a'` 对应的值 `1`,而第二个 `get()` 方法返回了指定的默认值 `0`,因为字典中不存在键 `'d'`。
2. `setdefault(key, default)` 方法用于获取指定键的值。如果字典中存在该键,则返回对应的值;如果字典中不存在该键,则将指定的键值对添加到字典中,并返回指定的默认值。示例代码如下:
my_dict = {'a': 1, 'b': 2, 'c': 3}
value = my_dict.setdefault('a', 0)
print(value) # 输出: 1
value = my_dict.setdefault('d', 4)
print(value) # 输出: 4
print(my_dict) # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}
在上面的示例中,第一个 `setdefault()` 方法返回了键 `'a'` 对应的值 `1`,而第二个 `setdefault()` 方法将键 `'d'` 和默认值 `4` 添加到字典中,并返回了指定的默认值 `4`。
5、复制字典(copy)
`copy()` 方法用于创建字典的副本。通过 `copy()` 方法可以复制一个字典,将原字典的键值对复制到新的字典中。
下面是一个示例代码:
my_dict = {'a': 1, 'b': 2, 'c': 3}
new_dict = my_dict.copy()
print(new_dict) # 输出: {'a': 1, 'b': 2, 'c': 3}
在上面的示例中,`copy()` 方法创建了一个新的字典 `new_dict`,并将 `my_dict` 中的键值对复制到了 `new_dict` 中。这样,`new_dict` 和 `my_dict` 是两个独立的字典对象,对其中一个字典的修改不会影响到另一个字典。
需要注意的是,使用 `copy()` 方法进行复制时,复制的是字典的内容而不是引用,因此对复制后的字典进行修改不会影响到原始字典。
reference: