Python学习笔记-字典

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

字典的创建：

1. 使用大括号 {}： 这是创建字典的最直接的方式。键和值之间用冒号 : 分隔，各键值对之间用逗号 , 分隔。

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

2. 使用 dict() 函数： dict() 函数可以从包含键值对的序列创建字典。

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

或者，如果你有一个包含 (key, value) 对的列表，你也可以使用 dict() 函数：

my_list = [("name", "Alice"), ("age", 25), ("city", "New York")]
my_dict = dict(my_list)

3. 使用字典推导式： 字典推导式（dictionary comprehension）是一种从其他数据结构创建字典的简洁方式。

keys = ["name", "age", "city"]
values = ["Alice", 25, "New York"]
my_dict = {k: v for k, v in zip(keys, values)}

在这个例子中，zip(keys, values) 生成一个元组的序列，每个元组包含一个键和一个值。然后，字典推导式 {k: v for k, v in ...} 为每个元组创建一个键值对。

4. 使用 fromkeys() 方法： 如果你想创建一个所有值都相同的字典，可以使用 dict.fromkeys() 方法。

keys = ["name", "age", "city"]
my_dict = dict.fromkeys(keys, "unknown")
# Output: {'name': 'unknown', 'age': 'unknown', 'city': 'unknown'}

在这个例子中，dict.fromkeys(keys, "unknown") 创建了一个新的字典，其中每个键都来自 keys，并且所有的值都是 "unknown"。

主要操作：

1. 访问元素： 可以通过键来访问字典中的元素：

print(my_dict["name"])  # Output: Alice

如果键不存在，Python会抛出 KeyError。为了避免这种情况，可以使用 get() 方法，如果键不存在，它会返回 None 或者指定的默认值：

print(my_dict.get("name"))  # Output: Alice
print(my_dict.get("address"))  # Output: None
print(my_dict.get("address", "Not provided"))  # Output: Not provided

2. 修改元素： 可以通过键来修改字典中的元素：

my_dict["age"] = 26
print(my_dict)  # Output: {'name': 'Alice', 'age': 26, 'city': 'New York'}

3. 添加元素： 可以通过键来添加新的元素：

my_dict["address"] = "123 Main St"
print(my_dict)  # Output: {'name': 'Alice', 'age': 26, 'city': 'New York', 'address': '123 Main St'}

4. 合并字典： 可以使用 update() 方法来合并两个字典：

my_dict = {"name": "Alice", "age": 25}
extra_info = {"city": "New York", "job": "Engineer"}
my_dict.update(extra_info)

在这个例子中，my_dict.update(extra_info) 将 extra_info 字典中的键值对添加到 my_dict 中。如果两个字典有相同的键，那么 my_dict 中的值将被 extra_info 中的值覆盖。

5. 删除元素： 可以使用 del 关键字或 pop() 方法来删除元素，clear() 方法可以清空字典中的所有元素：

del my_dict["address"]
print(my_dict)  # Output: {'name': 'Alice', 'age': 26, 'city': 'New York'}

my_dict.pop("city")
print(my_dict)  # Output: {'name': 'Alice', 'age': 26}

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
my_dict.clear()

6. 遍历字典： 可以使用 for 循环来遍历字典的键或值，或者键-值对：

for key in my_dict:
    print(key)  # Output: name, age

for value in my_dict.values():
    print(value)  # Output: Alice, 26

for key, value in my_dict.items():
    print(key, value)  # Output: name Alice, age 26

7. 键值对的数量获取
在Python中，len()函数可以用来获取字典中键值对的数量。它返回字典中的元素数量，也就是键值对的数量。
下面是一个例子：

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
print(len(my_dict))  # Output: 3

在这个例子中，len(my_dict)返回的是3，因为字典my_dict中有3个键值对。

8. 视图对象
在Python中，视图对象是字典的一种特殊对象，它提供了字典的一个动态视图，而不是创建一个新的列表或元组。换句话说，视图对象反映了字典的当前状态。如果字典发生变化，视图对象也会相应地更新。
视图对象主要有三种：
1. 字典键的视图对象：可以通过调用字典的 keys() 方法获得。
2. 字典值的视图对象：可以通过调用字典的 values() 方法获得。
3. 字典键值对的视图对象：可以通过调用字典的 items() 方法获得。这个视图对象的每个元素都是一个元组，元组的第一个元素是键，第二个元素是值。
以下是一个示例，说明了如果字典发生变化，视图对象也会相应地更新：

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

# Get a view of all keys
keys = my_dict.keys()
print(keys)  # Output: dict_keys(['name', 'age', 'city'])

# Use items() to get a view of all key-value pairs
items = my_dict.items()

# Print all items
for item in items:
    print(item)

# Output:
# ('name', 'Alice')
# ('age', 25)
# ('city', 'New York')

# Now, let's add a new key-value pair to the dictionary
my_dict["country"] = "USA"

# If we print the keys view again, we'll see that it has been updated
print(keys)  

# Output: dict_keys(['name', 'age', 'city', 'country'])

也可以在遍历时直接解包元组，这样可以同时获取到键和值：

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

# Use items() to get a view of all key-value pairs
items = my_dict.items()

# Print all keys and values
for key, value in items:
    print(f"Key: {key}, Value: {value}")

# Output:
# Key: name, Value: Alice
# Key: age, Value: 25
# Key: city, Value: New York

注意，虽然视图对象在某些方面行为类似列表（例如，可以进行迭代），但它们并不支持所有的列表操作。例如，不能使用索引或切片来访问视图对象的元素。如果需要一个真正的列表，可以使用 list() 函数将它转换为列表。

9. 反转字典的顺序
在Python 3.8及之后的版本中，可以使用内置的 reversed() 函数来反转字典的顺序。这是因为在Python 3.7及更早版本中，字典被改为了有序的数据类型。例如：

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

# Reverse the order of the dictionary
reversed_dict = dict(reversed(my_dict.items()))

print(reversed_dict)
# Output: {'city': 'New York', 'age': 25, 'name': 'Alice'}

在这个例子中，reversed(my_dict.items()) 返回一个反转的迭代器，其中包含原字典的键值对。然后，我们使用 dict() 函数将这个迭代器转换为一个新的字典。
需要注意的是，reversed() 函数并不会交换字典的键和值，它只是改变了键值对的顺序。

10. 字典的逆操作
如果想要进行字典的逆操作，也就是将键和值交换，可以使用Python的字典推导式（dictionary comprehension）轻松实现这一点。以下是一个例子：

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

# Swap keys and values
inverse_dict = {value: key for key, value in my_dict.items()}

print(inverse_dict)
# Output: {'Alice': 'name', 25: 'age', 'New York': 'city'}

在这个例子中，我们遍历原字典的所有键值对，然后在新的字典推导式中将每个键值对交换。
注意，这种方法只有在字典的值也可以作为字典的键（也就是说，它们是不可变的）并且是唯一的时候才能工作。如果字典的值不是唯一的，那么在逆操作中，后来的键值对会覆盖掉之前的键值对，因为字典的键必须是唯一的。

11. 键的检查
在Python中，in 和 not in 关键字可以用来检查字典中是否存在某个键。这是一种非常方便的方式，可以在尝试访问字典中的某个键之前先检查该键是否存在，从而避免出现KeyError。
以下是一个示例：

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

# Check if "name" is in dictionary
if "name" in my_dict:
    print("Name is in the dictionary.")

# Check if "country" is not in dictionary
if "country" not in my_dict:
    print("Country is not in the dictionary.")

在这个例子中，"name" in my_dict 返回 True，因为 "name" 是字典 my_dict 的一个键。相反，"country" not in my_dict 也返回 True，因为 "country" 不是字典 my_dict 的一个键。
需要注意的是，in 和 not in 只能用来检查键，而不能用来检查值。如果需要检查某个值是否存在，则需要使用 values() 方法来获取所有的值，然后再进行检查。例如：

if "Alice" in my_dict.values():
    print("Alice is in the dictionary.")

12. 字典的嵌套
在Python中，字典可以包含其他字典，这就是所谓的嵌套字典。嵌套字典是一种非常强大的数据结构，它可以用来表示更复杂的信息。以下是一个例子：

# An example of a nested dictionary
people = {
    "Alice": {
        "age": 25,
        "city": "New York"
    },
    "Bob": {
        "age": 30,
        "city": "Chicago"
    }
}

print(people["Alice"]["age"])  # Output: 25
print(people["Bob"]["city"])   # Output: Chicago

在这个例子中，people 是一个字典，它的键是人的名字，值是另一个字典。这个内部的字典包含了关于每个人的更多信息，如年龄和城市。
可以通过两个键来访问嵌套字典中的值。第一个键用于访问外部字典，第二个键用于访问内部字典。例如，people["Alice"]["age"] 访问的是 "Alice" 的 "age"。
嵌套字典可以有任意多层，只要需要，就可以继续添加更多的嵌套字典。注意，嵌套过深可能使代码难以阅读和理解，因此在实际编程中需要谨慎使用。

将字典转换为列表

1. 将所有的键转换为列表：

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
keys_list = list(my_dict.keys())
print(keys_list)  # Output: ['name', 'age', 'city']

2. 将所有的值转换为列表：

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
values_list = list(my_dict.values())
print(values_list)  # Output: ['Alice', 25, 'New York']

3. 将所有的键值对转换为列表（每个元素都是一个元组）：

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
items_list = list(my_dict.items())
print(items_list)  # Output: [('name', 'Alice'), ('age', 25), ('city', 'New York')]

字典推导式

# Create a dictionary with keys as numbers and values as their squares
squares = {x: x**2 for x in range(1, 6)}

print(squares)  # Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Create a dictionary with keys as numbers and values as their squares, but only for even numbers
even_squares = {x: x**2 for x in range(1, 6) if x % 2 == 0}

print(even_squares)  # Output: {2: 4, 4: 16}