【基础】列表与字典的高级用法

# 2.1 列表的生成和初始化

### 2.1.1 列表推导式

列表推导式是一种简洁高效的列表生成方式，其语法如下：

[expression for item in iterable]

其中：

- `expression`：生成列表中每个元素的表达式。
- `item`：循环变量，遍历 `iterable` 中的元素。
- `iterable`：可迭代对象，如列表、元组或字符串。

例如，生成一个包含 1 到 10 的平方数列表：

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

### 2.1.2 列表生成函数

Python 提供了几个内置函数来生成列表，包括 `list()`、`range()` 和 `enumerate()`。

- `list()`：将可迭代对象转换为列表。
- `range()`：生成一个指定范围内的整数序列。
- `enumerate()`：生成一个包含索引和元素的元组序列。

例如，使用 `range()` 生成一个包含 1 到 10 的列表：

numbers = list(range(1, 11))

# 2. 列表的高级操作

### 2.1 列表的生成和初始化

#### 2.1.1 列表推导式

列表推导式是一种简洁高效的方式来生成列表。它使用一个表达式和一个 for 循环来创建新列表，其中每个元素都是表达式在 for 循环中迭代的每个元素上求值的结果。

# 创建一个包含 1-10 的列表
my_list = [x for x in range(1, 11)]
print(my_list)  # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#### 2.1.2 列表生成函数

列表生成函数是生成列表的另一种方法。它使用内置的 list() 函数，该函数将可迭代对象转换为列表。

# 创建一个包含 1-10 的列表
my_list = list(range(1, 11))
print(my_list)  # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

### 2.2 列表的遍历和操作

#### 2.2.1 循环遍历列表

可以使用 for 循环来遍历列表中的每个元素。

# 遍历列表并打印每个元素
for item in my_list:
    print(item)

#### 2.2.2 切片和索引

切片和索引用于访问列表中的特定元素或元素范围。切片使用冒号 (:) 来指定起始和结束索引，而索引使用方括号 ([]) 来访问特定索引处的元素。

# 获取列表中前三个元素
my_list[:3]  # 输出：[1, 2, 3]

# 获取列表中最后一个元素
my_list[-1]  # 输出：10

#### 2.2.3 列表的排序和反转

可以使用 sort() 方法对列表进行排序，该方法会就地修改列表。reverse() 方法可用于反转列表。

# 对列表进行升序排序
my_list.sort()
print(my_list)  # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 反转列表
my_list.reverse()
print(my_list)  # 输出：[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

### 2.3 列表的扩展和修改

#### 2.3.1 列表的追加和删除

可以使用 append() 方法将元素追加到列表末尾，使用 remove() 方法删除列表中的特定元素。

# 将 11 追加到列表末尾
my_list.append(11)
print(my_list)  # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

# 删除列表中的 5
my_list.remove(5)
print(my_list)  # 输出：[1, 2, 3, 4, 6, 7, 8, 9, 10, 11]

#### 2.3.2 列表的合并和拆分

可以使用 + 运算符合并列表，使用 split() 方法拆分列表。

# 合并两个列表
my_list1 = [1, 2, 3]
my_list2 = [4, 5, 6]
my_list3 = my_list1 + my_list2
print(my_list3)  # 输出：[1, 2, 3, 4, 5, 6]

# 拆分列表
my_list4, my_list5 = my_list3[0:3], my_list3[3:]
print(my_list4)  # 输出：[1, 2, 3]
print(my_list5)  # 输出：[4, 5, 6]

# 3. 字典的高级操作

### 3.1 字典的生成和初始化

#### 3.1.1 字典推导式

字典推导式提供了一种简洁的方式来创建字典，其语法与列表推导式类似。其格式为：

{key: value for key, value in iterable}

例如：

# 创建一个从数字到其平方的字典
numbers_to_squares = {x: x**2 for x in range(1, 11)}
print(numbers_to_squares)  # 输出：{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}

#### 3.1.2 字典生成函数

除了字典推导式，还可以使用 `dict()` 函数来创建字典。其语法为：

dict(iterable)

其中，`iterable` 可以是元组列表或其他可迭代对象，每个元素都是一个键值对。例如：

# 创建一个从水果名称到其颜色的字典
fruits_to_colors = dict([('apple', 'red'), ('banana', 'yellow'), ('orange', 'orange')])
print(fruits_to_colors)  # 输出：{'apple': 'red', 'banana': 'yellow', 'orange': 'orange'}

### 3.2 字典的遍历和操作

#### 3.2.1 循环遍历字典

遍历字典可以访问其键和值。可以使用 `for` 循环来遍历字典的键或值。例如：

# 遍历字典的键
for key in fruits_to_colors:
    print(key)  # 输出：apple, banana, orange

# 遍历字典的值
for value in fruits_to_colors.values():
    print(value)  # 输出：red, yellow, orange

#### 3.2.2 键值获取和修改

可以通过字典的键来获取其值。可以使用 `get()` 方法来获取键对应的值，如果键不存在则返回 `None`。例如：

# 获取苹果的颜色
apple_color = fruits_to_colors.get('apple')
print(apple_color)  # 输出：red

可以使用 `[]` 操作符来设置或修改键对应的值。如果键不存在，则会创建该键。例如：

# 修改香蕉的颜色
fruits_to_colors['banana'] = 'green'
print(fruits_to_colors)  # 输出：{'apple': 'red', 'banana': 'green', 'orange': 'orange'}

#### 3.2.3 字典的排序和反转

字典本身是无序的，但可以使用 `sorted()` 函数对字典的键或值进行排序。例如：

# 对字典的键进行排序
sorted_keys = sorted(fruits_to_colors.keys())
print(sorted_keys)  # 输出：['apple', 'banana', 'orange']

# 对字典的值进行排序
sorted_values = sorted(fruits_to_colors.values())
print(sorted_values)  # 输出：['green', 'orange', 'red']

### 3.3 字典的扩展和修改

#### 3.3.1 字典的添加和删除

可以使用 `update()` 方法来添加或更新字典中的键值对。例如：

# 添加一个新的键值对
fruits_to_colors.update({'grape': 'purple'})
print(fruits_to_colors)  # 输出：{'apple': 'red', 'banana': 'green', 'orange': 'orange', 'grape': 'purple'}

# 更新一个已存在的键值对
fruits_to_colors.update({'banana': 'yellow'})
print(fruits_to_colors)  # 输出：{'apple': 'red', 'banana': 'yellow', 'orange': 'orange', 'grape': 'purple'}

可以使用 `pop()` 方法来删除一个键值对。例如：

# 删除香蕉的键值对
fruits_to_colors.pop('banana')
print(fruits_to_colors)  # 输出：{'apple': 'red', 'orange': 'orange', 'grape': 'purple'}

#### 3.3.2 字典的合并和拆分

可以使用 `dict.update()` 方法来合并两个字典。例如：

# 合并两个字典
new_fruits_to_colors = {'strawberry': 'red', 'blueberry': 'blue'}
fruits_to_colors.update(new_fruits_to_colors)
print(fruits_to_colors)  # 输出：{'apple': 'red', 'orange': 'orange', 'grape': 'purple', 'strawberry': 'red', 'blueberry': 'blue'}

可以使用 `dict.copy()` 方法来创建一个字典的副本，从而实现字典的拆分。例如：

# 创建字典的副本
new_fruits_to_colors = fruits_to_colors.copy()
new_fruits_to_colors.pop('apple')
print(fruits_to_colors)  # 输出：{'apple': 'red', 'orange': 'orange', 'grape': 'purple', 'strawberry': 'red', 'blueberry': 'blue'}
print(new_fruits_to_colors)  # 输出：{'orange': 'orange', 'grape': 'purple', 'strawberry': 'red', 'blueberry': 'blue'}

# 4.1 列表与字典的相互转换

### 4.1.1 列表转字典

#### 操作步骤

将列表中的元素作为字典的键值对，使用 `dict()` 函数进行转换。

# 创建一个列表
my_list = ['name', 'age', 'city']

# 使用 dict() 函数将列表转为字典
my_dict = dict(zip(my_list, my_list))

# 打印字典
print(my_dict)

#### 参数说明

* `zip()` 函数：将两个序列的对应元素打包为元组，形成一个元组列表。
* `dict()` 函数：将元组列表转换为字典，元组中的第一个元素作为键，第二个元素作为值。

#### 逻辑分析

该代码首先使用 `zip()` 函数将列表中的元素打包为元组，形成元组列表。然后使用 `dict()` 函数将元组列表转换为字典，元组中的第一个元素作为键，第二个元素作为值。最终输出转换后的字典。

### 4.1.2 字典转列表

#### 操作步骤

将字典的键值对分别提取为两个列表，使用 `list()` 函数进行转换。

# 创建一个字典
my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}

# 使用 list() 函数将字典的键和值转为列表
keys_list = list(my_dict.keys())
values_list = list(my_dict.values())

# 打印列表
print(keys_list)
print(values_list)

#### 参数说明

* `list()` 函数：将可迭代对象转换为列表。

#### 逻辑分析

该代码首先使用 `list()` 函数将字典的键和值分别转换为列表。最终输出转换后的列表。

## 4.2 列表与字典的排序和筛选

### 4.2.1 列表的排序

#### 操作步骤

使用 `sorted()` 函数对列表进行排序，可以指定升序或降序。

# 创建一个列表
my_list = [5, 2, 8, 3, 1]

# 使用 sorted() 函数对列表进行升序排序
sorted_list = sorted(my_list)

# 打印排序后的列表
print(sorted_list)

#### 参数说明

* `sorted()` 函数：对可迭代对象进行排序，返回一个新的排序后的列表。
* `reverse=True` 参数：指定降序排序。

#### 逻辑分析

该代码使用 `sorted()` 函数对列表进行升序排序，并输出排序后的列表。

### 4.2.2 字典的排序

#### 操作步骤

使用 `sorted()` 函数对字典的键或值进行排序，返回一个新的排序后的字典。

# 创建一个字典
my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}

# 使用 sorted() 函数对字典的键进行升序排序
sorted_dict = dict(sorted(my_dict.items()))

# 打印排序后的字典
print(sorted_dict)

#### 参数说明

* `sorted()` 函数：对可迭代对象进行排序，返回一个新的排序后的列表。
* `dict()` 函数：将元组列表转换为字典，元组中的第一个元素作为键，第二个元素作为值。

#### 逻辑分析

该代码使用 `sorted()` 函数对字典的键进行升序排序，并输出排序后的字典。

### 4.2.3 列表和字典的筛选

#### 操作步骤

使用 `filter()` 函数对列表或字典进行筛选，返回一个新的满足条件的列表或字典。

# 创建一个列表
my_list = [5, 2, 8, 3, 1]

# 使用 filter() 函数筛选出大于 3 的元素
filtered_list = list(filter(lambda x: x > 3, my_list))

# 打印筛选后的列表
print(filtered_list)

#### 参数说明

* `filter()` 函数：对可迭代对象进行筛选，返回一个新的满足条件的列表。
* `lambda` 函数：定义一个匿名函数，作为筛选条件。

#### 逻辑分析

该代码使用 `filter()` 函数筛选出列表中大于 3 的元素，并输出筛选后的列表。

# 5.1 数据分析和处理

### 5.1.1 使用列表和字典存储和处理数据

在数据分析和处理中，列表和字典是存储和处理数据的常用数据结构。

- **列表：**用于存储有序的数据序列，每个元素都有一个索引。列表可以包含各种数据类型，如数字、字符串和对象。
- **字典：**用于存储键值对，其中键是唯一的标识符，值可以是任何类型的数据。字典特别适合于存储结构化数据，例如用户信息或配置设置。

使用列表和字典存储和处理数据时，可以采用以下步骤：

1. **数据收集：**从各种来源收集数据，例如文件、数据库或 API。
2. **数据清理：**删除重复项、处理缺失值并转换数据以使其适合分析。
3. **数据存储：**使用列表或字典存储收集到的数据。
4. **数据分析：**使用列表和字典中的数据进行统计分析、可视化和建模。

### 5.1.2 数据的统计和可视化

使用列表和字典存储和处理数据后，可以进行数据统计和可视化以获得有价值的见解。

- **数据统计：**使用列表和字典中的数据计算统计指标，例如平均值、中位数、标准差和频率分布。
- **数据可视化：**使用图表、图形和仪表板将数据可视化，以直观地展示数据模式和趋势。

例如，以下 Python 代码使用列表和字典存储和处理销售数据，并计算销售额的统计信息：

sales_data = [
    {'product': 'A', 'sales': 100},
    {'product': 'B', 'sales': 200},
    {'product': 'C', 'sales': 300}
]

# 计算销售额的总和
total_sales = sum(sale['sales'] for sale in sales_data)

# 计算销售额的平均值
average_sales = total_sales / len(sales_data)

# 计算销售额的标准差
import statistics
sales_values = [sale['sales'] for sale in sales_data]
sales_stddev = statistics.stdev(sales_values)

# 输出统计信息
print(f"Total sales: {total_sales}")
print(f"Average sales: {average_sales}")
print(f"Standard deviation of sales: {sales_stddev}")