Python字典列表的创建与使用

Python字典列表的创建

字典的创建基础

在Python中，字典（dictionary）是一种可变的、无序的数据结构，用于存储键值对（key - value pairs）。创建字典的最基本方式是使用花括号 {} 并在其中定义键值对，键和值之间用冒号 : 分隔，不同键值对之间用逗号 , 分隔。例如：

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

上述代码创建了一个名为 my_dict 的字典，其中包含三个键值对。name、age 和 city 是键，'Alice'、30 和 'New York' 分别是对应的值。

你也可以使用 dict() 函数来创建字典。通过传递一系列的键值对作为参数，每个键值对用逗号分隔，并且键值对本身使用括号括起来。例如：

new_dict = dict((('fruit', 'apple'), ('count', 5)))
print(new_dict)

此外，还可以使用关键字参数的方式来创建字典：

kwargs_dict = dict(fruit='banana', count=10)
print(kwargs_dict)

字典创建的进阶方式

1. 从其他可迭代对象创建字典
   • 使用 zip() 函数和字典推导式。zip() 函数用于将多个可迭代对象中的元素一一配对。假设有两个列表，一个列表存储键，另一个列表存储值，可以通过如下方式创建字典：

keys = ['a', 'b', 'c']
values = [1, 2, 3]
new_dict_zip = {k: v for k, v in zip(keys, values)}
print(new_dict_zip)

• 还可以从元组列表创建字典。元组列表中的每个元组包含两个元素，第一个元素作为键，第二个元素作为值。例如：

tuple_list = [('x', 10), ('y', 20)]
dict_from_tuples = dict(tuple_list)
print(dict_from_tuples)

2. 默认字典的创建
   • collections 模块中的 defaultdict 类提供了一种特殊的字典创建方式。defaultdict 会在访问不存在的键时，自动使用一个默认值生成器来提供默认值。首先需要导入 defaultdict：

from collections import defaultdict
# 创建一个默认值为列表的defaultdict
dd = defaultdict(list)
print(dd['new_key'])  # 访问不存在的键，会自动创建一个空列表

• 这里 defaultdict 的参数 list 就是默认值生成器，它告诉 defaultdict 当遇到不存在的键时，要创建一个空列表作为默认值。

列表的创建基础

列表（list）是Python中最常用的数据结构之一，它是一个有序的、可变的元素集合。创建列表最简单的方式是使用方括号 []，并在其中放入元素，元素之间用逗号 , 分隔。例如：

my_list = [1, 'two', 3.14]
print(my_list)

上述代码创建了一个包含整数、字符串和浮点数的列表 my_list。

你也可以使用 list() 函数来创建列表。如果传递一个可迭代对象给 list() 函数，它会将可迭代对象中的元素逐个添加到新创建的列表中。例如：

string = 'hello'
list_from_string = list(string)
print(list_from_string)

这里将字符串 'hello' 转换为了一个包含字符 'h', 'e', 'l', 'l', 'o' 的列表。

列表创建的进阶方式

1. 列表推导式
   • 列表推导式是一种简洁的创建列表的方式。其基本语法是 [expression for item in iterable]，其中 expression 是对 item 进行操作后返回的结果，item 是从 iterable 中取出的元素。例如，要创建一个包含1到10的平方的列表：

squares = [i**2 for i in range(1, 11)]
print(squares)

• 还可以在列表推导式中添加条件。例如，要创建一个包含1到10中偶数的平方的列表：

even_squares = [i**2 for i in range(1, 11) if i % 2 == 0]
print(even_squares)

2. 生成器表达式创建列表
   • 生成器表达式与列表推导式类似，但它返回的是一个生成器对象，而不是一个列表。要将其转换为列表，可以使用 list() 函数。生成器表达式的语法是 (expression for item in iterable)。例如：

gen_exp = (i**2 for i in range(1, 5))
list_from_gen_exp = list(gen_exp)
print(list_from_gen_exp)

• 生成器表达式在处理大数据集时更节省内存，因为它是按需生成值，而不是一次性生成所有值并存储在列表中。

Python字典列表的使用

字典的基本使用

1. 访问字典中的值
   • 要访问字典中的值，可以使用键作为索引。例如，对于前面创建的 my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}，要获取 name 对应的值，可以这样做：

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
name_value = my_dict['name']
print(name_value)

• 但是，如果使用不存在的键来访问字典，会引发 KeyError。为了避免这种情况，可以使用 get() 方法。get() 方法在键不存在时会返回 None（也可以指定一个默认返回值）。例如：

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
nonexistent_value = my_dict.get('nonexistent_key')
print(nonexistent_value)
default_value = my_dict.get('nonexistent_key', 'default value')
print(default_value)

2. 修改字典中的值
   • 可以通过键来直接修改字典中对应的值。例如，将 my_dict 中 age 的值修改为31：

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
my_dict['age'] = 31
print(my_dict)

3. 添加新的键值对
   • 只需使用一个新的键，并为其赋值即可向字典中添加新的键值对。例如，向 my_dict 中添加一个 'occupation' 键值对：

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
my_dict['occupation'] = 'Engineer'
print(my_dict)

4. 删除键值对
   • 使用 del 语句可以删除字典中的键值对。例如，删除 my_dict 中的 'city' 键值对：

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
del my_dict['city']
print(my_dict)

• 还可以使用 pop() 方法，它不仅会删除指定键的键值对，还会返回被删除的值。例如：

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
popped_value = my_dict.pop('city')
print(popped_value)
print(my_dict)

字典的高级使用

1. 遍历字典
   • 遍历键：可以使用 keys() 方法来遍历字典的键。例如：

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
for key in my_dict.keys():
    print(key)

• 实际上，在 for 循环中直接使用字典时，默认就是遍历键，所以 for key in my_dict: 与 for key in my_dict.keys(): 效果相同。
• 遍历值：使用 values() 方法来遍历字典的值。例如：

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
for value in my_dict.values():
    print(value)

• 遍历键值对：使用 items() 方法，它会返回一个包含键值对元组的可迭代对象。例如：

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
for key, value in my_dict.items():
    print(f'Key: {key}, Value: {value}')

2. 字典的嵌套
   • 字典可以嵌套，即一个字典的值可以是另一个字典。例如：

nested_dict = {
    'person1': {
        'name': 'Alice',
        'age': 30
    },
    'person2': {
        'name': 'Bob',
        'age': 25
    }
}
print(nested_dict['person1']['name'])

• 在处理嵌套字典时，要注意访问深层键值对时键的顺序和正确性，否则可能会引发 KeyError。

3. 字典的合并
   • 在Python 3.5及以上版本，可以使用字典解包的方式合并两个字典。例如：

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

• 如果两个字典有相同的键，后面字典的值会覆盖前面字典的值。

列表的基本使用

1. 访问列表中的元素
   • 列表中的元素可以通过索引来访问。索引从0开始，例如，对于列表 my_list = [1, 'two', 3.14]，要访问第一个元素，可以这样做：

my_list = [1, 'two', 3.14]
first_element = my_list[0]
print(first_element)

• 也可以使用负数索引，负数索引从列表末尾开始计数，-1 表示最后一个元素，-2 表示倒数第二个元素，以此类推。例如：

my_list = [1, 'two', 3.14]
last_element = my_list[-1]
print(last_element)

2. 修改列表中的元素
   • 通过索引可以直接修改列表中的元素。例如，将 my_list 中第二个元素修改为 'three'：

my_list = [1, 'two', 3.14]
my_list[1] = 'three'
print(my_list)

3. 添加元素到列表
   • 使用 append() 方法：append() 方法用于在列表末尾添加一个元素。例如：

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)

• 使用 extend() 方法：extend() 方法用于将一个可迭代对象（如列表、元组等）中的元素添加到列表末尾。例如：

my_list = [1, 2, 3]
new_list = [4, 5]
my_list.extend(new_list)
print(my_list)

• 使用 insert() 方法：insert() 方法可以在列表的指定位置插入一个元素。它的第一个参数是插入位置的索引，第二个参数是要插入的元素。例如：

my_list = [1, 2, 3]
my_list.insert(1, 'new')
print(my_list)

4. 删除列表中的元素
   • 使用 del 语句：del 语句可以根据索引删除列表中的元素。例如，删除 my_list 中第二个元素：

my_list = [1, 2, 3]
del my_list[1]
print(my_list)

• 使用 pop() 方法：pop() 方法会删除并返回列表中指定位置的元素。如果不指定位置，默认删除并返回最后一个元素。例如：

my_list = [1, 2, 3]
popped_element = my_list.pop()
print(popped_element)
print(my_list)
popped_element_index = my_list.pop(0)
print(popped_element_index)
print(my_list)

• 使用 remove() 方法：remove() 方法用于删除列表中第一个匹配的元素。例如：

my_list = [1, 2, 2, 3]
my_list.remove(2)
print(my_list)

列表的高级使用

1. 列表的切片
   • 切片允许从列表中获取一个子列表。其语法是 list[start:stop:step]，start 是起始索引（包含），stop 是结束索引（不包含），step 是步长。例如，要获取列表 my_list = [1, 2, 3, 4, 5] 中从第二个元素到第四个元素（不包含）的子列表：

my_list = [1, 2, 3, 4, 5]
sub_list = my_list[1:3]
print(sub_list)

• 如果省略 start，则从列表开头开始；如果省略 stop，则到列表末尾结束。例如：

my_list = [1, 2, 3, 4, 5]
first_three = my_list[:3]
last_two = my_list[3:]
print(first_three)
print(last_two)

• 步长为负数时，可以实现反向切片。例如，要反向获取列表中的元素：

my_list = [1, 2, 3, 4, 5]
reversed_list = my_list[::-1]
print(reversed_list)

2. 列表的排序
   • 使用 sort() 方法：sort() 方法会对列表进行原地排序，即直接修改列表本身。例如，对一个整数列表进行升序排序：

num_list = [3, 1, 4, 1, 5]
num_list.sort()
print(num_list)

• 可以通过传递 reverse=True 参数来进行降序排序：

num_list = [3, 1, 4, 1, 5]
num_list.sort(reverse=True)
print(num_list)

• 使用 sorted() 函数：sorted() 函数会返回一个新的已排序列表，而不会修改原列表。例如：

num_list = [3, 1, 4, 1, 5]
new_sorted_list = sorted(num_list)
print(new_sorted_list)
print(num_list)

3. 列表的嵌套
   • 列表可以嵌套，即一个列表的元素可以是另一个列表。例如：

nested_list = [[1, 2], [3, 4], [5, 6]]
print(nested_list[0][1])

• 访问嵌套列表中的元素时，需要使用多层索引，先指定外层列表的索引，再指定内层列表的索引。

字典列表的综合应用

字典列表的创建

1. 创建字典列表
   • 有时候我们需要创建一个包含多个字典的列表。例如，假设有多个学生的信息，每个学生的信息用字典表示，然后将这些字典放入一个列表中：

student1 = {'name': 'Alice', 'age': 20,'major': 'Computer Science'}
student2 = {'name': 'Bob', 'age': 21,'major': 'Mathematics'}
student_list = [student1, student2]
print(student_list)

• 也可以使用列表推导式来创建字典列表。例如，创建一个包含1到5的数字作为键，其平方作为值的字典列表：

dict_list = [{'number': i,'square': i**2} for i in range(1, 6)]
print(dict_list)

2. 字典中包含列表
   • 字典的值也可以是列表。例如，假设有一个字典，键是班级名称，值是该班级学生的名字列表：

class_dict = {
    'Class1': ['Alice', 'Bob'],
    'Class2': ['Charlie', 'David']
}
print(class_dict['Class1'])

字典列表的操作

1. 访问字典列表中的元素
   • 要访问字典列表中的元素，需要先通过列表索引找到对应的字典，然后再通过字典的键来获取值。例如，对于前面的 student_list，要获取第二个学生的专业：

student1 = {'name': 'Alice', 'age': 20,'major': 'Computer Science'}
student2 = {'name': 'Bob', 'age': 21,'major': 'Mathematics'}
student_list = [student1, student2]
major = student_list[1]['major']
print(major)

2. 修改字典列表中的元素
   • 可以修改字典列表中字典的值。例如，将 student_list 中第一个学生的年龄增加1：

student1 = {'name': 'Alice', 'age': 20,'major': 'Computer Science'}
student2 = {'name': 'Bob', 'age': 21,'major': 'Mathematics'}
student_list = [student1, student2]
student_list[0]['age'] += 1
print(student_list[0]['age'])

3. 添加和删除字典列表中的元素
   • 添加元素：可以使用 append() 方法向字典列表中添加一个新的字典。例如，添加一个新的学生信息到 student_list 中：

student1 = {'name': 'Alice', 'age': 20,'major': 'Computer Science'}
student2 = {'name': 'Bob', 'age': 21,'major': 'Mathematics'}
student_list = [student1, student2]
new_student = {'name': 'Eve', 'age': 22,'major': 'Physics'}
student_list.append(new_student)
print(student_list)

• 删除元素：可以使用 del 语句或 pop() 方法删除字典列表中的字典。例如，删除 student_list 中的第二个学生：

student1 = {'name': 'Alice', 'age': 20,'major': 'Computer Science'}
student2 = {'name': 'Bob', 'age': 21,'major': 'Mathematics'}
student_list = [student1, student2]
del student_list[1]
print(student_list)

基于字典列表的数据分析示例

假设我们有一个字典列表，每个字典代表一个销售记录，包含产品名称、销售数量和销售额：

sales_records = [
    {'product': 'Product A', 'quantity': 10,'revenue': 100},
    {'product': 'Product B', 'quantity': 5,'revenue': 75},
    {'product': 'Product A', 'quantity': 15,'revenue': 150}
]

1. 计算总销售额
   • 可以通过遍历字典列表来计算总销售额：

total_revenue = 0
for record in sales_records:
    total_revenue += record['revenue']
print(total_revenue)

2. 计算每种产品的总销售数量
   • 可以使用一个新的字典来存储每种产品的总销售数量：

product_quantity = {}
for record in sales_records:
    product = record['product']
    if product not in product_quantity:
        product_quantity[product] = record['quantity']
    else:
        product_quantity[product] += record['quantity']
print(product_quantity)

通过以上对Python字典列表的创建与使用的详细介绍，希望读者能够深入理解并熟练运用这两种重要的数据结构，在实际的编程项目中更好地解决问题。无论是简单的数据存储还是复杂的数据分析，字典和列表都能发挥重要的作用。在日常编程中，要根据具体需求选择合适的数据结构和操作方法，以提高代码的效率和可读性。