Python重点数据结构基本用法

Python重点数据结构用法

分支结构

if、elif和else

在Python中，要构造分支结构可以使用if、elif和else关键字。

循环结构

在Python中构造循环结构有两种做法，一种是for-in循环，另一种是while循环。

range

在Python中，range() 函数是一个非常实用的工具，主要用于生成一个不可变的数字序列。它通常用在循环（如 for 循环）中，以控制循环的次数。下面详细介绍 range() 函数的用法和一些示例。

用法

range() 函数可以有以下几种形式的参数：

1. range(stop): 生成从0开始到 stop-1 的整数序列。
2. range(start, stop): 生成从 start 开始到 stop-1 的整数序列。
3. range(start, stop, step): 生成从 start 开始到 stop-1 的整数序列，增量为 step。

参数说明

• start: 序列的起始值，默认为0。
• stop: 序列的结束值，但不包括此值。
• step: 序列中每个数的增量，默认为1。如果 step 是正数，序列递增；如果是负数，序列递减。

示例

1. 使用一个参数:

   for i in range(5):
       print(i)
   # 输出: 0, 1, 2, 3, 4
   1
   2
   3

2. 使用两个参数:

   for i in range(3, 8):
       print(i)
   # 输出: 3, 4, 5, 6, 7
   1
   2
   3

3. 使用三个参数（正步长）:

   for i in range(10, 20, 2):
       print(i)
   # 输出: 10, 12, 14, 16, 18
   1
   2
   3

4. 使用三个参数（负步长）:

   for i in range(20, 10, -2):
       print(i)
   # 输出: 20, 18, 16, 14, 12
   1
   2
   3

注意事项

• range() 生成的是一个 range 对象，而不是列表。这意味着它在任何时间点只保存起始点、终点和步长，而不是整个列表，这有助于节省内存。
• 你可以使用 list(range(...)) 来查看 range 对象生成的完整列表。

适用场景

• 控制循环次数。
• 生成数值列表。
• 递增或递减数列的生成。

range() 因其简洁和内存效率而在Python编程中广泛使用，特别是在需要明确次数的循环中非常有用。

列表

列表生成式（list comprehensions）

在Python中，列表生成式（list comprehensions）提供了一种简洁且高效的方式来创建列表。这种方法可以用来从其他列表或任何可迭代对象中创建新列表，同时可以在创建时对数据进行处理和过滤。

基本语法

列表生成式的基本语法如下：

[expression for item in iterable if condition]
1

这里的各部分意义为：

• expression: 用于产生列表中的元素的表达式，可以是对 item 的计算或其它操作。
• item: 是 iterable 中的当前元素。
• iterable: 任何Python可迭代对象。
• condition: 一个可选的条件语句，用于筛选符合条件的元素。

示例

让我们通过一些具体示例来看看如何使用列表生成式：

1. 基础示例 - 生成一个数值列表：

squares = [x**2 for x in range(10)]
print(squares)
# 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
1
2
3

2. 使用条件过滤 - 只包含偶数的平方：

even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)
# 输出: [0, 4, 16, 36, 64]
1
2
3

3. 对字符串列表操作 - 将所有单词转换为大写形式：

words = ['hello', 'world', 'python', 'is', 'awesome']
upper_words = [word.upper() for word in words]
print(upper_words)
# 输出: ['HELLO', 'WORLD', 'PYTHON', 'IS', 'AWESOME']
1
2
3
4

4. 嵌套列表生成式 - 生成一个二维数组（矩阵）：

matrix = [[j for j in range(5)] for i in range(3)]
print(matrix)
# 输出: [[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
1
2
3

5. 从列表中提取元素的特定属性 - 例如从字典列表中提取特定键的值：

dict_list = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}, {'name': 'Cathy', 'age': 22}]
names = [d['name'] for d in dict_list]
print(names)
# 输出: ['

Alice', 'Bob', 'Cathy']
1
2
3
4
5
6

6. 使用多个迭代器 - 创建一个笛卡尔积（从两个列表中创建元组的所有可能组合）：

colors = ['red', 'blue', 'green']
sizes = ['S', 'M', 'L']
tshirts = [(color, size) for color in colors for size in sizes]
print(tshirts)
# 输出: [('red', 'S'), ('red', 'M'), ('red', 'L'), ('blue', 'S'), ('blue', 'M'), ('blue', 'L'), ('green', 'S'), ('green', 'M'), ('green', 'L')]
1
2
3
4
5

7. 结合函数调用 - 使用列表生成式运行函数：

def square(x):
    return x * x

squares = [square(x) for x in range(5)]
print(squares)
# 输出: [0, 1, 4, 9, 16]
1
2
3
4
5
6

8. 复杂条件 - 生成一个列表，包含小于100的非平方数：

non_squares = [x for x in range(100) if x not in [y**2 for y in range(10)]]
print(non_squares)
# 这会输出0到99之间所有非平方数的列表
1
2
3

列表生成式是Python中一种非常强大且常用的特性，它可以使代码更加简洁易读，同时在很多情况下也能提高程序的执行效率。通过掌握列表生成式，你可以有效地简化代码并减少冗长的循环和条件判断语句。

嵌套列表

嵌套列表是Python中的一种数据结构，指的是列表中包含一个或多个列表。这种结构非常适用于表示矩阵、网格或其他形式的多维数据。通过嵌套列表，我们可以方便地模拟二维或更高维度的数组。下面将介绍如何创建和操作嵌套列表。

创建嵌套列表

基础示例

创建一个简单的嵌套列表：

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(nested_list)
# 输出: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
1
2
3

这个例子创建了一个3x3的矩阵，类似于数学中的矩阵。

列表生成式创建嵌套列表

使用列表生成式来创建一个二维列表（矩阵）：

matrix = [[j for j in range(5)] for i in range(3)]
print(matrix)
# 输出: [[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
1
2
3

访问嵌套列表元素

要访问嵌套列表中的元素，需要通过多个索引来访问：

print(nested_list[0][1])  # 访问第一行的第二个元素
# 输出: 2
1
2

遍历嵌套列表

遍历嵌套列表通常需要使用嵌套循环：

for row in nested_list:
    for item in row:
        print(item, end=' ')
    print()
# 输出:
# 1 2 3
# 4 5 6
# 7 8 9
1
2
3
4
5
6
7
8

修改嵌套列表

修改嵌套列表中的元素同样需要通过索引进行：

nested_list[0][0] = 10
print(nested_list)
# 输出: [[10, 2, 3], [4, 5, 6], [7, 8, 9]]
1
2
3

嵌套列表的高级操作

• 扁平化嵌套列表

将嵌套列表转换成一维列表：

flattened = [item for sublist in nested_list for item in sublist]
print(flattened)
# 输出: [10, 2, 3, 4, 5, 6, 7, 8, 9]
1
2
3

• 转置矩阵

使用嵌套列表生成式来转置一个矩阵：

transposed = [[nested_list[j][i] for j in range(len(nested_list))] for i in range(len(nested_list[0]))]
print(transposed)
# 输出: [[10, 4, 7], [2, 5, 8], [3, 6, 9]]
1
2
3

嵌套列表是处理多维数据时非常有用的工具，掌握它们的使用可以在多种编程任务中帮助你更有效地组织和处理数据。

元组

元组打包和解包

在Python中，元组打包和解包是一种便捷的数据操作方式，它使得我们可以在没有中间变量的情况下，轻松地从元组中提取值或将多个值组合成一个元组。这两种操作在Python编程中非常有用，特别是在函数参数传递和多变量赋值场景中。

元组打包 (Tuple Packing)

元组打包是将多个值组合成一个元组的过程。这不需要特殊的语法；你只需要将多个值用逗号隔开，Python就会自动将它们打包成一个元组。

示例：

# 元组打包
my_tuple = 1, 2, 3
print(my_tuple)
# 输出: (1, 2, 3)
1
2
3
4

在这个例子中，数字1, 2, 和 3被打包成一个元组 my_tuple。

元组解包 (Tuple Unpacking)

元组解包允许你将一个元组（或任何可迭代对象）的元素分配给一组变量。这是一种非常方便的方式，可以一次性将元组中的所有值分配给相应数量的变量。

示例：

# 元组解包
a, b, c = my_tuple
print(a)  # 输出: 1
print(b)  # 输出: 2
print(c)  # 输出: 3
1
2
3
4
5

在这个例子中，my_tuple 中的元素被解包到变量 a, b, c 中。

高级元组解包

元组解包可以使用 * 运算符来执行更高级的操作，比如解包列表的一部分，而其余部分可以分配给另一个变量。

示例：

# 高级元组解包
data = (1, 2, 3, 4, 5)
first, *middle, last = data
print(first)   # 输出: 1
print(middle)  # 输出: [2, 3, 4]
print(last)    # 输出: 5
1
2
3
4
5
6

在这个例子中，first 被赋值为1，last 被赋值为5，而剩余的元素2, 3, 4被打包成一个列表赋值给 middle。

元组解包在函数中的应用

元组解包可以用来传递参数给函数。使用 * 操作符，你可以将列表或元组的元素直接作为参数传递给函数。

示例：

def my_func(x, y, z):
    print(x, y, z)

args = (1, 2, 3)
my_func(*args)
# 输出: 1 2 3
1
2
3
4
5
6

在这个例子中，args 元组被解包，并且它的每个元素都按顺序被传递给了 my_func 函数作为参数。

元组的打包和解包特性大大提高了Python代码的简洁性和可读性，尤其在处理函数参数和多变量赋值时非常有用。

字符串

字符串的切片

字符串切片是Python中一种非常有用的功能，允许你从一个字符串中提取子字符串。使用切片操作，你可以指定开始索引、结束索引和步长来获取字符串的一部分。

切片语法

字符串的切片语法如下：

string[start:stop:step]
1

其中：

• start（可选）- 切片的起始位置，包括此位置的字符。如果省略，切片将从字符串的开头开始。
• stop（可选）- 切片的结束位置，不包括此位置的字符。如果省略，切片将一直进行到字符串的末尾。
• step（可选）- 切片的步长，表示从一个字符到下一个字符的距离。如果省略，默认为1，即获取每个字符。

示例

这里有一些基本示例来说明字符串切片是如何工作的：

s = "Hello, world!"

# 从位置2到位置7（不包括7）
print(s[2:7])  # 输出: llo, 

# 从开头切片到位置5
print(s[:5])   # 输出: Hello

# 从位置7切片到末尾
print(s[7:])   # 输出: world!

# 完整的字符串
print(s[:])    # 输出: Hello, world!

# 每两个字符取一个
print(s[::2])  # 输出: Hlo ol!

# 负数索引，从倒数第三个字符切片到倒数第一个
print(s[-3:-1]) # 输出: ld

# 字符串逆序
print(s[::-1])  # 输出: !dlrow ,olleH
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

使用场景

字符串切片非常适用于从较大的文本数据中提取需要的信息。例如，从日期字符串中提取年、月、日，或从URL中提取特定部分。此外，通过逆序切片操作，可以方便地实现字符串的反转。

注意事项

• 如果 start 或 stop 指定的索引超出了字符串的边界，Python将会自动处理，不会引发错误。
• 如果 start 大于 stop 的值，并且步长为正，或者 start 小于 stop 并且步长为负，则结果为空字符串。
• 切片不会修改原字符串，而是生成一个新的字符串。

通过灵活使用切片，你可以高效地处理字符串数据，这是掌握Python字符串操作的关键技能之一。

集合set

Python中的集合底层使用了哈希存储的方式

创建集合

在 Python 中，集合（set）是一个无序的、不重复的元素集。集合用于存储唯一的元素，并且提供了多种有用的操作，如并集、交集、差集和对称差等，非常适用于数学中的集合操作。

使用大括号 {}

你可以使用大括号来创建一个集合。如果你创建一个空集合，必须使用 set()，因为空的大括号 {} 用于创建空字典。

# 创建一个包含一些元素的集合
my_set = {1, 2, 3, 4, 5}
print(my_set)  # 输出: {1, 2, 3, 4, 5}

# 创建一个空集合
empty_set = set()
print(empty_set)  # 输出: set()
1
2
3
4
5
6
7

使用 set() 构造函数

你也可以使用 set() 构造函数来从任何可迭代对象创建集合，例如列表、元组、字典的键等。

# 从列表创建集合
list_set = set([1, 2, 3, 3, 2, 1])
print(list_set)  # 输出: {1, 2, 3}

# 从字符串创建集合
string_set = set("hello")
print(string_set)  # 输出: {'e', 'h', 'l', 'o'}

# 从元组创建集合
tuple_set = set((1, 2, 3, 4, 4, 3))
print(tuple_set)  # 输出: {1, 2, 3, 4}
1
2
3
4
5
6
7
8
9
10
11

注意，当从包含重复元素的列表或元组创建集合时，重复的元素将被自动去除，因为集合不允许重复的元素。

特性

• 无序：集合中的元素没有特定的顺序。
• 唯一性：集合自动去除重复元素。
• 不支持索引：由于集合是无序的，所以你不能通过索引来访问或修改集合中的元素。

操作集合

集合支持多种操作，包括但不限于：

• 添加元素：add()
• 删除元素：remove()（如果元素不存在，则抛出 KeyError）、discard()（如果元素不存在，不会抛出错误）
• 检查成员资格：使用 in 关键字
• 集合的数学运算：如并集（union() 或 |）、交集（intersection() 或 &）、差集（difference() 或 -）、对称差（symmetric_difference() 或 ^）

集合是处理不需要重复元素的数据集时的有力工具。例如，如果你需要快速检查元素是否存在于某个数据集中，或者需要执行集合之间的运算，使用集合是一个非常合适的选择。

字典（dictionary）

这种数据类型最适合把相关联的信息组装到一起，并且可以帮助我们解决程序中为真实事物建模的问题。

创建和使用字典

在 Python 中，字典（dictionary）是一种非常灵活的数据结构，用于存储键值对。每个键映射到一个值，字典通过键而不是像列表那样通过偏移来索引。字典是无序的集合（在 Python 3.7+ 中是按插入顺序排序的），并且键必须是唯一的。

创建字典

使用花括号 {}

你可以使用花括号创建字典，并使用逗号来分隔键值对。

# 创建一个简单的字典
my_dict = {"name": "John", "age": 30, "city": "New York"}
print(my_dict)  # 输出: {'name': 'John', 'age': 30, 'city': 'New York'}

# 创建一个空字典
empty_dict = {}
print(empty_dict)  # 输出: {}
1
2
3
4
5
6
7

使用 dict() 构造函数

dict() 构造函数可以通过其他方式创建字典，如通过键值对列表或通过关键字参数。

# 使用键值对列表
dict_from_pairs = dict([("name", "Alice"), ("age", 24), ("city", "Boston")])
print(dict_from_pairs)  # 输出: {'name': 'Alice', 'age': 24, 'city': 'Boston'}

# 使用关键字参数
dict_from_keywords = dict(name="Bob", age=25, city="Chicago")
print(dict_from_keywords)  # 输出: {'name': 'Bob', 'age': 25, 'city': 'Chicago'}
1
2
3
4
5
6
7

使用字典

访问元素

你可以通过键来访问字典中的元素。

name = my_dict["name"]
print(name)  # 输出: John

# 使用 get 方法，如果键不存在时返回 None，而不是抛出异常
age = my_dict.get("age")
print(age)  # 输出: 30
1
2
3
4
5
6

添加和修改元素

添加或修改字典的元素同样简单。

# 添加新键值对
my_dict["email"] = "john@example.com"
print(my_dict)  # 输出: {'name': 'John', 'age': 30, 'city': 'New York', 'email': 'john@example.com'}

# 修改现有键的值
my_dict["email"] = "john.doe@example.com"
print(my_dict)  # 输出: {'name': 'John', 'age': 30, 'city': 'New York', 'email': 'john.doe@example.com'}
1
2
3
4
5
6
7

删除元素

你可以使用 del 语句或 pop() 方法删除字典中的元素。

# 使用 del 删除元素
del my_dict["email"]
print(my_dict)  # 输出: {'name': 'John', 'age': 30, 'city': 'New York'}

# 使用 pop 移除元素并获取其值
city = my_dict.pop("city")
print(city)  # 输出: New York
print(my_dict)  # 输出: {'name': 'John', 'age': 30}
1
2
3
4
5
6
7
8

遍历字典

字典可以通过多种方式遍历。

# 遍历所有键
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
2
3
4
5
6
7
8
9
10
11

实用性

字典在 Python 中非常有用，广泛用于需要快速按键索引数据的情况。例如，它们经常用于缓存数据、处理 API 响应、配置设置、计数和数据汇总等场景。