python中的字典

字典

在Python中，字典是一种无序的、可变的数据结构，用于存储键值对。字典使用大括号 {} 来创建，每个键值对使用冒号 : 分隔，键值对之间使用逗号 , 分隔。

以下是一个示例字典：

person = {
    "name": "Alice",
    "age": 28,
    "city": "New York"
}

在上述示例中，我们创建了一个字典 person，包含了名为 “name”、“age” 和 “city” 的键值对。可以通过键来访问对应的值，例如 person["name"] 将返回 “Alice”。

字典是可变的，可以通过给定键赋予新值来修改字典中的值，例如 person["age"] = 29 将年龄从 28 修改为 29。

字典也提供了一些常用的方法，例如 keys() 方法可用于获取所有的键，values() 方法可用于获取所有的值，items() 方法可用于获取所有的键值对。

要注意的是，字典中的键必须是唯一的，如果使用相同的键进行赋值，后面的值将覆盖前面的值。

字典的创建

字典可以通过两种方式来创建。

1. 使用大括号 {} 和冒号 : 创建字典，每个键值对之间用逗号 , 分隔。键和值可以是任意类型的对象，但键必须是不可变类型，例如字符串、整数或元组。

   person = {"name": "Alice", "age": 28, "city": "New York"}
   

2. 使用 dict() 函数创建字典，可以在函数中传递键值对作为参数，或者传递一个包含键值对的元组列表。

   person = dict(name="Alice", age=28, city="New York")
   

   或者

   person = dict([("name", "Alice"), ("age", 28), ("city", "New York")])
   

这两种方式都可以创建一个类似的字典对象。需要注意的是，第二种方式中的键值对列表可以是任意可迭代对象，每个元素都必须是包含两个元素的元组。

可以使用 len() 函数获取字典中键值对的数量，例如 len(person) 返回字典 person 中的键值对数量。

还可以使用 in 和 not in 运算符来检查一个键是否存在于字典中。例如 if "name" in person: 将检查字典 person 是否包含键 “name”。

设置默认值（fromkeys函数）

fromkeys() 是字典对象的一个方法，用于创建一个新字典，其中包含指定的键和每个键对应的初始值。

fromkeys() 方法的语法如下：

new_dict = dict.fromkeys(iterable, value)

其中：

• iterable 是一个可迭代对象，用于指定新字典中的键。
• value 是可选的参数，用于指定新字典中每个键对应的初始值。如果不提供该参数，则默认值为 None。

示例1：使用列表作为可迭代对象并指定初始值

keys = ["name", "age", "city"]
person = dict.fromkeys(keys, "unknown")
print(person)

输出：

{'name': 'unknown', 'age': 'unknown', 'city': 'unknown'}

示例2：使用字符串作为可迭代对象但不指定初始值

keys = "abc"
my_dict = dict.fromkeys(keys)
print(my_dict)

输出：

{'a': None, 'b': None, 'c': None}

该方法提供了一种方便地初始化字典的方式，特别是在需要为新字典中的所有键设置相同的初始值时非常有用。

字典的基本操作

字典是Python中的一种数据结构，用于存储键-值对。以下是一些基本操作：

1. 创建字典：

my_dict = {}  # 创建空字典
my_dict = {'apple': 1, 'banana': 2, 'orange': 3}  # 创建带有初始值的字典

2. 添加或更新键-值对：

my_dict['apple'] = 5  # 添加或更新键'apple'的值为5
my_dict.update({'banana': 10, 'grape': 7})  # 批量添加或更新键-值对

3. 访问字典的值：

print(my_dict['apple'])  # 输出：5
print(my_dict.get('banana'))  # 输出：10

4. 删除键-值对：

del my_dict['apple']  # 删除键'apple'的键-值对
my_dict.pop('banana')  # 删除键'banana'的键-值对

5. 遍历字典：

for key in my_dict:
    print(key, my_dict[key])  # 输出所有键和对应的值

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

6. 检查键是否存在：

if 'apple' in my_dict:
    print("键'apple'存在")

7. 获取字典的长度：

length = len(my_dict)
print(length)  # 输出：2

这些是字典的一些基本操作，通过它们可以对字典进行创建、访问、修改、删除和遍历等操作。

字典的内建函数

字典作为Python中的一种内建数据类型，有一些内建函数可以用来操作和处理字典。以下是一些常用的字典内建函数：

1. len()：用于返回字典中键-值对的数量。

my_dict = {'apple': 1, 'banana': 2, 'orange': 3}
length = len(my_dict)
print(length)  # 输出：3

2. keys()：用于返回一个包含字典所有键的列表。

my_dict = {'apple': 1, 'banana': 2, 'orange': 3}
keys = my_dict.keys()
print(keys)  # 输出：dict_keys(['apple', 'banana', 'orange'])

3. values()：用于返回一个包含字典所有值的列表。

my_dict = {'apple': 1, 'banana': 2, 'orange': 3}
values = my_dict.values()
print(values)  # 输出：dict_values([1, 2, 3])

4. items()：用于返回一个包含字典所有键-值对的列表，每个键-值对以元组的形式表示。

my_dict = {'apple': 1, 'banana': 2, 'orange': 3}
items = my_dict.items()
print(items)  # 输出：dict_items([('apple', 1), ('banana', 2), ('orange', 3)])

5. get(key, default)：用于返回指定键的值，如果键不存在，则返回默认值。默认值参数是可选的。

my_dict = {'apple': 1, 'banana': 2, 'orange': 3}
value = my_dict.get('apple', 0)
print(value)  # 输出：1
value = my_dict.get('grape', 0)
print(value)  # 输出：0

6. dict()：创建一个空的字典或将其他类型的对象转换为字典。

my_dict = dict()  # 创建一个空字典
my_dict = dict([(1, 'one'), (2, 'two')])  # 将列表转换为字典

7.hash():hash()是Python的一个内建函数，用于计算给定对象的哈希值。哈希值是对象的唯一的整数标识符。

hash()函数可以应用于大多数内建数据类型（例如整数、浮点数、字符串、元组等）。它还可以应用于一些不可变对象，但不能应用于可变对象（如列表、字典和集合）。

下面是几个示例：

1. 对整数进行哈希计算：

num = 42
print(hash(num))

输出：

42

2. 对字符串进行哈希计算：

word = "hello"
print(hash(word))

输出：

530933906909695264

3. 对元组进行哈希计算：

my_tuple = (1, 2, 3)
print(hash(my_tuple))

输出：

2528502973977326415

需要注意的是，hash()函数的返回值类型是整数，并且对于相同的对象，始终会返回相同的哈希值。但是对于不同的对象，有时可能会返回相同的哈希值，这种情况称为哈希碰撞。因此，在设计使用哈希值的数据结构时，需要考虑如何避免或处理哈希碰撞。

这些是一些常用的字典内建函数，使用它们可以对字典进行各种操作，如获取键或值的列表、获取键-值对的列表、返回字典的长度等。

update方法（更新字典）

字典的update()方法用于将一个字典的键值对更新到另一个字典中。它接受一个字典作为参数，然后将该字典中的键值对更新到调用update()方法的字典中。

以下是使用update()方法的示例:

dict1 = {'name': 'John', 'age': 25}
dict2 = {'city': 'New York', 'age': 26}

dict1.update(dict2)

print(dict1)  # 输出: {'name': 'John', 'age': 26, 'city': 'New York'}

在上面的示例中，dict1是要更新的字典，dict2是提供要更新的键值对的字典。使用update()方法将dict2中的键值对更新到dict1中。注意，如果两个字典中存在相同的键，那么使用update()方法后，被更新字典中的对应键的值会被替换为来自提供字典的值。

除了接受字典作为参数外，update()方法还可以接受其他数据结构，如元组或具有items()方法返回键值对的对象。以下是使用元组和items()方法的示例：

dict1 = {'name': 'John', 'age': 25}
tuple1 = ('city', 'New York')
dict2 = {'age': 26}

dict1.update(tuple1)
print(dict1)  # 输出: {'name': 'John', 'age': 25, 'city': 'New York'}

dict1.update(dict2.items())#元组
print(dict1)  # 输出: {'name': 'John', 'age': 26, 'city': 'New York'}

在上述示例中，元组tuple1包含了要更新到dict1中的键值对。通过调用update()方法，将元组中的键值对更新到dict1中。同样地，使用dict2.items()返回的键值对列表进行更新也是可以的。

需要注意的是，update()方法会在原地修改字典，而不是返回一个新的字典。

删除字典

字典的clear()方法用于清空字典中的所有键值对，即将字典重置为空字典。

以下是使用clear()方法的示例:

dict1 = {'name': 'John', 'age': 25}

dict1.clear()

print(dict1)  # 输出: {}

在上面的示例中，dict1是要清空的字典。通过调用clear()方法，将字典中的键值对全部删除，使其变为空字典。

需要注意的是，调用clear()方法后，字典对象本身仍然存在，只是字典中的键值对被删除了。因此，使用clear()方法后，字典对象仍然可以被赋值新的键值对，或者使用其他字典方法进行操作。

dict1.clear()

dict1['name'] = 'Lisa'

print(dict1)  # 输出: {'name': 'Lisa'}

在上面的示例中，调用clear()方法后，dict1变为空字典。之后，我们可以通过重新赋值的方式，向字典中添加新的键值对。最后，打印字典内容时输出{'name': 'Lisa'}。

字典的常用方法

字典通过建确定对象

字典是Python中常用的数据类型之一，它提供了一系列方法来操作和管理字典对象。下面是几个常用的字典方法：

1. len()：返回字典中键值对的数量。

dict1 = {'name': 'John', 'age': 25}
print(len(dict1))  # 输出: 2

2. keys()：返回一个包含字典所有键的列表。

dict1 = {'name': 'John', 'age': 25}
print(dict1.keys())  # 输出: dict_keys(['name', 'age'])

3. values()：返回一个包含字典所有值的列表。

dict1 = {'name': 'John', 'age': 25}
print(dict1.values())  # 输出: dict_values(['John', 25])

4. items()：返回一个包含字典所有键值对的元组列表。

dict1 = {'name': 'John', 'age': 25}
print(dict1.items())  # 输出: dict_items([('name', 'John'), ('age', 25)])

5. get(key, default)：返回指定键的值，如果键不存在，则返回指定的默认值（默认为None）。

dict1 = {'name': 'John', 'age': 25}
print(dict1.get('name'))  # 输出: John
print(dict1.get('gender', 'Unknown'))  # 输出: Unknown

6. update(other_dict)：将另一个字典的键值对更新到当前字典中，如果键已存在，则会更新其对应的值。

dict1 = {'name': 'John'}
dict2 = {'age': 25, 'gender': 'Male'}
dict1.update(dict2)
print(dict1)  # 输出: {'name': 'John', 'age': 25, 'gender': 'Male'}

7. pop(key, default)：删除指定键的键值对，并返回对应的值。如果键不存在，则返回指定的默认值（默认会抛出KeyError异常）。

dict1 = {'name': 'John', 'age': 25}
print(dict1.pop('name'))  # 输出: John
print(dict1)  # 输出: {'age': 25}

这些是字典中常用的一些方法，可以帮助我们实现字典的增删改查操作和其他常见操作。需要根据实际需要选择适合的方法来操作和管理字典对象。