Python教程

七、Python for循环

7.1 什么是for循环

概念：for循环是编程中的一种控制结构，用于重复执行一段代码，直到达到特定条件。它是一种迭代语句，通常用于遍历数据结构（如列表、元组、字典和字符串）中的元素。

7.1.1 `for循环基本语法`

# for循环基本结构
for variable in iterable:
    # 执行代码块

variable：在每次迭代中表示当前元素的变量。
iterable：要迭代的对象，例如列表、字符串、元组或字典。
缩进的代码块是每次迭代时执行的代码。

7.1.2`for循环4种基本用法`

1.遍历列表：逐个访问列表中的元素。

# 遍历列表
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)
# 输出
apple
banana
cherry

2.遍历字符串：逐个访问字符串中的字符。

# 遍历字符串
for char in "hello":
    print(char)
# 输出
h
e
l
l
o

3.遍历元组：逐个访问元组中的元素。

# 遍历元组
numbers = (1, 2, 3)
for number in numbers:
    print(number)
# 输出
1
2
3

4.遍历字典：逐个访问字典中的键或键值对。

# 遍历字典
student_scores = {"Alice": 85, "Bob": 92, "Charlie": 78}
for student in student_scores:
    print(student, student_scores[student])
# 输出
Alice 85
Bob 92
Charlie 78

7.2 内置函数与for循环

7.2.1 range()函数

概念：range 函数是Python中一个非常有用的内置函数，用于生成一系列数字，通常用于在for循环中进行迭代。range 函数可以接受一个、两个或三个参数，根据提供的参数生成一个数字序列。 range()语法结构：

range(stop)
range(start, stop, step)

start: 序列的起始值（包含在内）。如果省略，默认为0。
stop: 序列的终止值（不包含在内）。
step: 序列中数字之间的间隔。默认为1。如果提供负值，序列将以递减的方式生成。

# range(stop)示例
for i in range(5):
    print(i)

# range(start, stop)示例
for i in range(1, 5):
    print(i)

# range(start, stop, step)示例
# 步长为正
for i in range(1, 10, 2):
    print(i)

# range(start, stop, step)示例
# 步长为负
for i in range(10, 1, -2):
    print(i)

range()常见用法：

1.遍历\迭代

for i in range(5):
    print(i)

range()有趣的用法场景：

1.结合len()使用

# range 生成的序列是一个 range 对象，可以将其转换为列表查看完整序列。
numbers = list(range(5))
print(numbers)

7.2.2 len()函数

概念：len 函数是Python中的一个内置函数，用于返回对象（如列表、字符串、元组、字典、集合等）中元素的数量。 len()语法结构：

len(s)

s：可以是序列（如字符串、列表、元组、范围对象）或集合（如字典、集合等）。

len()常见用法：

1. 计算字符串长度

string = "hello"
length = len(string)
print(length)

1. 计算列表长度

fruits = ["apple", "banana", "cherry"]
length = len(fruits)
print(length)

1. 计算元组长度

numbers = (1, 2, 3, 4)
length = len(numbers)
print(length)

1. 计算字典长度

student_scores = {"Alice": 85, "Bob": 92, "Charlie": 78}
length = len(student_scores)
print(length)

1. 计算集合长度

unique_numbers = {1, 2, 3, 4, 5}
length = len(unique_numbers)
print(length)

1. 计算范围对象长度

range_obj = range(10)
length = len(range_obj)
print(length)

len()有趣的用法场景：

1.搭配if语句使用

# 使用 len 函数检查列表是否包含元素。
items = []
if len(items) == 0:
    print("The list is empty")
else:
    print("The list is not empty")

# 根据字符串长度执行操作。
password = "mypassword123"
if len(password) < 8:
    print("Password is too short")
else:
    print("Password is long enough")

2.搭配for循环语句和range()使用

# 结合 len 和 range 函数遍历列表的索引。
fruits = ["apple", "banana", "cherry"]
for i in range(len(fruits)):
    print(f"Index {i}: {fruits[i]}")

7.2.3 zip()函数

概念：zip() 是Python内置函数之一，用于将多个可迭代对象（如列表、元组等）中对应的元素打包成一个元组，并返回一个由这些元组组成的迭代器。它常用于同时迭代多个序列，可以简单理解为将多个序列“拉链”在一起。

zip()语法结构：

zip(iterable1, iterable2, ...)

iterable1, iterable2, ...：可以是一个或多个可迭代对象，如列表、元组、字符串等。

zip()常见用法：

1. 合并两个列表

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
zipped = zip(list1, list2)
# 转换为列表查看结果
print(list(zipped))

1. 合并三个列表

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
list3 = ['!', '@', '#']
zipped = zip(list1, list2, list3)
# 转换为列表查看结果
print(list(zipped))

1. 迭代并打印

fruits = ['apple', 'banana', 'cherry']
counts = [10, 20, 15]
for fruit, count in zip(fruits, counts):
    print(f"There are {count} {fruit}s")

1. 解压缩

# 使用 zip() 可以方便地进行序列的解压缩。
pairs = [(1, 'a'), (2, 'b'), (3, 'c')]
numbers, letters = zip(*pairs)
print(numbers)
print(letters)

zip()注意事项：

当传入的可迭代对象长度不同时，zip() 将会以最短的对象为准进行迭代。多余的元素将被忽略。

list1 = [1, 2, 3]
list2 = ['a', 'b']
zipped = zip(list1, list2)
# 转换为列表查看结果
print(list(zipped))

zip()有趣的用法场景：

合并多个序列进行并行迭代。
创建字典时同时迭代键和值。
进行数据的同时处理和操作，如计算、过滤等。

7.2.4 enumerate()函数

概念：enumerate() 函数是 Python 中一个非常有用的内置函数，用于将一个可迭代对象（如列表、元组、字符串等）组合为一个索引序列，同时列出数据和数据下标（索引）。这个函数返回一个枚举对象，可以用于在循环中获取索引及其对应的值。

enumerate()语法结构：

enumerate(iterable, start=0)

iterable：必需，表示要枚举的可迭代对象，如列表、元组、字符串等。
start：可选，表示起始索引，默认为 0。

enumerate()常见用法：

1. 基本用法

fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits):
    print(index, fruit)

1. 指定起始索引

fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits, start=1):
    print(index, fruit)

enumerate()有趣的用法场景：

遍历并同时获取索引和元素值：适用于需要在循环中处理列表或其他可迭代对象元素时，同时需要索引信息的场景。
批量处理数据：当需要同时处理多个列表或数据结构的对应元素时，使用 enumerate() 可以简化代码并提高可读性。

enumerate()注意事项：

enumerate() 返回的对象是一个迭代器（iterator），它生成一系列的元组，每个元组包含一个索引和对应的元素。
可以通过 list() 函数将枚举对象转换为列表，以便获取所有的索引和元素对。

7.3 列表生成式与for循环

7.3.1 什么是列表生成式

概念：列表生成式是一种用简洁语法创建列表的方式，它可以在一行代码中根据一个可迭代对象生成一个新的列表。 列表生成式基本语法：

[expression for item in iterable if condition]

expression: 可以是任意操作，用来生成列表的元素。
item: 可以是变量名，表示可迭代对象中的每个元素。
iterable: 可以是列表、元组、字符串等可迭代对象。
condition (optional): 可选的条件，用于过滤元素。

7.3.2 列表生成式与for循环实例

列表生成式与for循环实例1

# 生成一个列表，包含原始列表中每个元素的平方：
numbers = [1, 2, 3, 4, 5]
squares = [x**2 for x in numbers]
print(squares)

列表生成式与for循环实例2

# 使用条件过滤元素，生成一个列表，仅包含偶数的平方：
numbers = [1, 2, 3, 4, 5]
even_squares = [x**2 for x in numbers if x % 2 == 0]
print(even_squares)

7.4 循环嵌套

概念：循环的嵌套是指在一个循环内部包含另一个或多个循环结构的情况。在编程中，循环的嵌套是一种常见的技术，用于处理复杂的迭代和数据结构。

7.4.1 嵌套 for 循环

最常见的嵌套循环是使用两个 for 循环。这种结构可以遍历二维数据结构（如列表的列表），或者进行组合操作。

# 二维列表的遍历
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

for row in matrix:
    for element in row:
        print(element, end=' ')
    print()

7.4.2 嵌套 while 循环

除了 for 循环，while 循环也可以嵌套使用。这种情况通常用于需要根据条件重复执行一段代码块的场景。

# 嵌套的 while 循环
row = 1
while row <= 3:
    col = 1
    while col <= 3:
        print(f"({row}, {col})", end=' ')
        col += 1
    print()
    row += 1

# 输出
(1, 1) (1, 2) (1, 3) 
(2, 1) (2, 2) (2, 3) 
(3, 1) (3, 2) (3, 3)

嵌套循环应用场景：

处理多维数据结构：例如矩阵、二维数组等。
组合和排列操作：例如生成排列组合、查找匹配等。
模式生成：例如生成金字塔、菱形等形状的图案。

注意事项：

性能考虑：嵌套循环的效率取决于内外循环的数量和循环体内的操作复杂度。在处理大数据量时，需要注意避免过深的嵌套。
代码可读性：尽量保持嵌套循环的代码结构清晰简洁，避免嵌套层级过深，可以通过函数或其他结构来分解复杂的嵌套逻辑。

7.5 for循环小案例

# 生成和打印菱形图案
size = 7  # 菱形的大小，必须是奇数

# 上半部分菱形
for i in range(size//2 + 1):
    for j in range(size//2 - i):
        print(" ", end="")
    for j in range(2*i + 1):
        print("*", end="")
    print()

# 下半部分菱形
for i in range(size//2):
    for j in range(i + 1):
        print(" ", end="")
    for j in range(size - 2*i - 1):
        print("*", end="")
    print()

博客信息