简明 Python 教程（第7章 数据结构)

本章将详细介绍Python中的三种主要内置数据结构：列表（list）、元组（tuple）和字典（dict）。这些数据结构是Python编程中处理数据集合的基础，它们提供了不同的方式来存储和操作数据。

列表（List）

列表（List）是Python中一种非常灵活且功能强大的数据结构，它是一个有序的元素集合，可以包含不同类型的元素。列表是可变的，这意味着你可以在列表创建后添加、删除或更改元素。以下是列表的一些主要特性和操作：

创建列表

列表可以使用方括号[]来创建，或者使用list()构造函数：

# 使用方括号创建列表 
my_list = [1, 2, 3, 'a', 'b'] 
# 使用list()构造函数创建列表 
empty_list = list()

访问列表元素

使用索引操作符[]来访问列表中的元素，索引从0开始：

# 访问第一个元素 
first_element = my_list[0] 
# 访问最后一个元素 
last_element = my_list[-1]

修改列表元素

可以直接通过索引赋值来修改列表中的元素：

# 修改第二个元素 
my_list[1] = 'new value' 
# 打印修改后的列表 
print(my_list) 
# 输出: [1, 'new value', 3, 'a', 'b']

添加元素到列表

列表提供了多种方法来添加元素：

1. append()：在列表末尾添加一个元素。

2. extend()：将一个序列中的所有元素添加到列表末尾。

3. insert()：在指定位置插入一个元素。

   在列表末尾添加一个元素

   my_list.append('c')

   将另一个列表的元素添加到当前列表

   my_list.extend([4, 5])

   在指定位置插入元素

   my_list.insert(2, 'inserted')

删除列表元素

列表提供了几种删除元素的方法：

1. remove()：删除列表中第一个匹配的元素。

2. pop()：删除并返回指定位置的元素，如果不指定位置，则删除并返回最后一个元素。

3. clear()：删除列表中的所有元素。

4. del：使用del语句删除列表的一部分或整个列表。

   删除第一个出现的'a'

   my_list.remove('a')

   删除索引为2的元素

   del my_list[2]

   清空列表

   my_list.clear()

列表切片

使用切片操作符[start:end:step]来获取列表的一部分：

# 获取前三个元素 
first_three = my_list[0:3] 
# 获取倒数第二个到最后一个元素 
last_two = my_list[-2:]

遍历列表

使用for循环或in操作符来遍历列表中的所有元素：

# 使用for循环遍历 
for element in my_list: 
    print(element) 

列表推导式

首先介绍一下列表推导式，列表推导式（List Comprehension）是Python中一种优雅且简洁的构建列表的方法。它允许你通过一个表达式来创建一个新的列表，这个表达式会对另一个列表（或任何可迭代对象）中的每个元素执行操作，并将结果收集到一个新的列表中。

列表推导式基本语法

列表推导式的基本语法如下：

[expression for item in iterable if condition]

这里，expression是对item的操作或返回值，item是iterable中的元素，iterable可以是列表、元组、字符串等任何可迭代对象，condition是一个可选的条件语句，用于筛选满足条件的元素。

示例

假设我们有一个数字列表，我们想要创建一个新列表，其中包含原列表中所有偶数的平方：

original_list = [1, 2, 3, 4, 5, 6] 
squared_evens = [x**2 for x in original_list if x % 2 == 0] 
print(squared_evens) # 输出: [4, 16, 36]

在这个例子中，x**2是表达式，x是original_list中的每个元素，if x % 2 == 0是条件语句，用于筛选偶数。

多变量推导式

列表推导式还可以使用多个变量来遍历多个可迭代对象：

pairs = [(1, 'one'), (2, 'two'), (3, 'three')] 
pairs_with_index = [index + 1 for index, _ in pairs] 
print(pairsWith_index) # 输出: [2, 3, 4]

在这个例子中，我们使用了一个元组_作为占位符，因为我们只关心索引值。

嵌套推导式

列表推导式可以嵌套使用，例如，对每个元素应用多个操作：

original_list = [1, 2, 3, 4, 5, 6] 
nested_comprehension = [(x + 1) ** 2 for x in original_list if x % 2 == 0] 
print(nested_comprehension) # 输出: [25, 49, 81]

推导式与循环的等价性

列表推导式可以看作是for循环的简洁版本。上面的示例可以用传统的for循环重写如下：

squared_evens = [] 
for x in original_list: 
    if x % 2 == 0: 
        squared_evens.append(x**2) 
print(squared_evens) # 输出: [4, 16, 36]

注意事项

1. 列表推导式在处理大型数据集时可能比传统的循环更高效，因为它们是优化过的。
2. 过度复杂的推导式可能会降低代码的可读性，因此应该在简洁性和可读性之间找到平衡。
3. 推导式中的if条件不能省略，如果你想要包含所有元素，可以在条件中使用True。

列表推导式是一种创建列表的简洁方式，它基于已有列表生成新列表：

# 计算列表中每个元素的平方 
squared_list = [x**2 for x in my_list]

列表方法

列表还提供了其他有用的方法，如：

1. sort()：对列表进行排序。
2. reverse()：反转列表中的元素。
3. count()：计算某个元素在列表中出现的次数。
4. index()：返回列表中第一个匹配项的索引。

元组（Tuple）

元组（Tuple）是Python中的一种数据结构，它是一个不可变的序列，可以包含多个不同类型的元素。元组用圆括号()定义，并且一旦创建，其内容就不能被修改（即不可变）。这使得元组在某些情况下比列表（List）更安全，因为它们的内容不会被意外改变。

创建元组

元组可以通过直接在圆括号中放置一系列用逗号分隔的值来创建：

my_tuple = (1, 2, 3, 'a', 'b') 
empty_tuple = ()

访问元组元素

与列表类似，可以使用索引操作符[]来访问元组中的元素。索引从0开始，负数索引从-1开始，表示从元组的末尾开始计数。

# 访问第一个元素 
first_element = my_tuple[0] 
# 访问最后一个元素 
last_element = my_tuple[-1] 
# 使用切片访问元组的一部分 
slice_of_tuple = my_tuple[1:3] # 输出: (2, 3)

元组解包

Python允许你将元组中的值解包到多个变量中：

a, b, c = my_tuple 
# a = 1, b = 2, c = 3

不可变性

由于元组是不可变的，你不能修改、添加或删除元组中的元素。尝试这样做将会导致TypeError：

# 尝试修改元组中的元素将导致错误 
my_tuple[0] = 10 # TypeError: 'tuple' object does not support item assignment

元组与列表的区别

1. 可变性：列表是可变的，而元组是不可变的。
2. 语法 ：列表使用方括号[]，元组使用圆括号()。在创建空列表时，方括号是可选的，但在创建空元组时，圆括号是必须的。
3. 性能：由于元组的不可变性，它们通常在性能上比列表更优，尤其是在作为字典的键时。
4. 安全性：元组的不可变性提供了数据安全性，确保元组中的数据不会被更改。

元组推导式

与列表推导式类似，元组推导式允许你创建一个元组：

my_tuple = (x**2 for x in range(10))

字典（Dict）

字典（Dictionary）是Python中的一种内置数据结构，它存储键值对（key-value pairs）。字典中的键必须是不可变类型，通常是字符串或元组，而值可以是任何数据类型。字典是可变的，这意味着你可以在创建后添加、删除或更改键值对。字典提供了快速的数据检索、添加和更新的能力。

创建字典

字典可以通过花括号{}或dict()构造函数创建：

# 使用花括号创建字典 
my_dict = {'name': 'Alice', 'age': 25} 
# 使用dict()构造函数创建空字典 
empty_dict = dict()

访问字典元素

使用键来访问字典中的值，操作符也是[]：

# 访问键'name'对应的值 
name = my_dict['name'] 
# 如果键不存在，会抛出KeyError 
age = my_dict['age']

为了避免KeyError，可以使用get()方法，它允许你为不存在的键指定一个默认返回值：

# 使用get()方法，如果键不存在，返回'Unknown' 
occupation = my_dict.get('occupation', 'Unknown')

添加和修改字典元素

可以通过直接赋值来添加新的键值对或修改现有的键值对：

# 添加新的键值对 
my_dict['email'] = 'alice@example.com' 
# 修改已有的键对应的值 
my_dict['age'] = 26

删除字典元素

使用del语句删除字典中的键值对：

# 删除键'email'对应的项 
del my_dict['email']

也可以使用pop()方法删除一个键值对，并返回被删除的值：

# 删除键'age'对应的项，并返回它的值 
removed_age = my_dict.pop('age', None) 
# 返回None，因为'age'不存在

遍历字典

可以使用循环来遍历字典中的键、值或键值对：

# 遍历字典的键 
for key in my_dict: 
    print(key) 
# 遍历字典的值 
for value in my_dict.values(): 
    print(value) 
# 遍历字典的键值对 
for key, value in my_dict.items():
    print(key, value)

字典方法

字典提供了多种方法来操作字典：

1. clear()：删除字典中的所有项。
2. copy()：返回字典的浅拷贝。
3. update()：将一个字典的键值对更新到当前字典中。
4. keys()：返回字典中所有键的视图。
5. values()：返回字典中所有值的视图。
6. items()：返回字典中所有键值对的视图。

字典推导式

字典推导式提供了一种创建字典的简洁方式：

# 创建一个字典，其中包含数字及其平方 
squares = {x: x**2 for x in range(10)}

序列操作

序列操作是指在Python中对序列类型的数据结构（如列表、元组和字符串）执行的一系列操作。由于列表、元组和字符串在Python中都是序列，它们共享许多相似的方法和操作。以下是一些常见的序列操作：

索引

序列中的每个元素都有一个索引，从0开始。你可以使用索引来访问序列中的特定元素。

sequence = [1, 2, 3, 'a', 'b'] 
print(sequence[0]) # 输出: 1 
print(sequence[-1]) # 输出: 'b' (最后一个元素)

切片

切片操作允许你获取序列的一个子集。切片操作符[start:end:step]用于从序列中提取一段范围。

sequence = [1, 2, 3, 'a', 'b', 'c', 'd'] 
print(sequence[1:4]) # 输出: [2, 3, 'a'] 
print(sequence[:3]) # 输出: [1, 2, 3] 
print(sequence[2:]) # 输出: [3, 'a', 'b', 'c', 'd'] 
print(sequence[::2]) # 输出: [1, 'a', 'c'] (步长为2)

连接

可以使用加号+来连接两个或多个序列。

list1 = [1, 2, 3] 
list2 = [4, 5, 6] 
combined = list1 + list2 
print(combined) # 输出: [1, 2, 3, 4, 5, 6]

重复

可以使用星号*来重复序列多次。

repeated = [1, 2, 3] * 3 
print(repeated) # 输出: [1, 2, 3, 1, 2, 3, 1, 2, 3]

遍历

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

sequence = ['apple', 'banana', 'cherry'] 
for item in sequence: 
    print(item)

长度

使用内置的len()函数来获取序列的长度。

sequence = [1, 2, 3] 
print(len(sequence)) # 输出: 3

成员检查

使用in操作符来检查一个元素是否存在于序列中。

sequence = [1, 2, 3] 
print(3 in sequence) # 输出: True 
print(4 in sequence) # 输出: False

排序

列表可以使用sort()方法来就地排序，而sorted()函数可以返回一个新的排序后的序列。

list1 = [3, 1, 4, 1, 5, 9, 2, 6, 5] 
list1.sort() # 就地排序 
print(list1) # 输出: [1, 1, 2, 3, 4, 5, 5, 6, 9] 
sorted_list = sorted(list1) # 返回新的排序后的列表 
print(sorted_list) # 输出: [1, 1, 2, 3, 4, 5, 5, 6, 9]

反转

列表可以使用reverse()方法来就地反转，或者使用切片操作来创建一个反转后的副本。

list1 = [1, 2, 3, 4, 5] 
list1.reverse() # 就地反转 
print(list1) # 输出: [5, 4, 3, 2, 1] 
reversed_list = list1[::-1] # 创建一个反转后的副本 
print(reversed_list) # 输出: [1, 2, 3, 4, 5]