循环语句是Python编程中用于重复执行一段代码的核心结构。Python提供了多种循环语句，主要包括for循环和while循环。本文将详细介绍Python循环语句的特性、用法和最佳实践。
一、循环概述
1. 什么是循环？
循环是编程语言中用于重复执行一段代码块的结构。当需要多次执行相同或相似的操作时，可以使用循环语句来简化代码，提高效率。
2. Python的循环类型
Python主要提供两种循环类型：
- for循环：用于遍历序列（如列表、元组、字符串）或可迭代对象
- while循环
3. 循环的基本原理
循环的基本原理是：
- 检查循环条件（for循环的可迭代对象是否还有元素，while循环的条件表达式是否为True）
- 更新循环状态（for循环移动到下一个元素，while循环可能需要手动更新条件）
二、for循环
1. 基本语法
for循环用于遍历序列或可迭代对象，基本语法如下：
# for循环的基本语法
for 变量 in 可迭代对象:
# 循环体代码块
代码1
代码2
...
其中，可迭代对象包括列表、元组、字符串、range对象、字典、集合等。
2. 遍历序列
遍历列表
# 遍历列表示例
fruits =["apple","banana","orange","grape"]
for fruit in fruits:
print(fruit)
# 输出：
# apple
# banana
# orange
# grape
遍历元组
# 遍历元组示例
numbers =(1,2,3,4,5)
sum=0
for num in numbers:
sum+= num
print(f"总和为: {sum}")# 输出：总和为: 15
遍历字符串
# 遍历字符串示例
word ="python"
for char in word:
print(char, end=" ")# 输出：p y t h o n
遍历range对象
range()函数用于生成一个整数序列，常用于for循环中控制循环次数：
# 遍历range对象示例
# range(5) 生成 0, 1, 2, 3, 4
for i inrange(5):
print(i)
# range(1, 6) 生成 1, 2, 3, 4, 5
for i inrange(1,6):
print(i)
# range(1, 10, 2) 生成 1, 3, 5, 7, 9
for i inrange(1,10,2):
print(i)
# range(5, 0, -1) 生成 5, 4, 3, 2, 1
for i inrange(5,0,-1):
print(i)
3. 遍历字典
遍历字典可以通过keys()、values()和items()方法：
# 遍历字典示例
person ={
"name":"张三",
"age":30,
"city":"北京",
"email":"zhangsan@example.com"
}
# 遍历字典的键
print("遍历字典的键:")
for key in person:
print(key)
# 或者使用keys()方法
for key in person.keys():
print(key)
# 遍历字典的值
print("\n遍历字典的值:")
for value in person.values():
print(value)
# 遍历字典的键值对
print("\n遍历字典的键值对:")
for key, value in person.items():
print(f"{key}: {value}")
4. 遍历集合
# 遍历集合示例
colors ={"red","green","blue","yellow"}
for color in colors:
print(color)
# 注意：集合是无序的，每次遍历的顺序可能不同
5. 嵌套for循环
嵌套for循环是指在一个for循环的循环体中包含另一个for循环：
# 嵌套for循环示例
# 打印乘法表
for i inrange(1,10):
for j inrange(1, i +1):
print(f"{j}×{i}={i * j}", end="\t")
print()# 换行
# 输出：
# 1×1=1
# 1×2=2 2×2=4
# 1×3=3 2×3=6 3×3=9
# ...
# 遍历二维列表
matrix =[[1,2,3],[4,5,6],[7,8,9]]
for row in matrix:
for num in row:
print(num, end=" ")
print()
# 输出：
# 1 2 3
# 4 5 6
# 7 8 9
三、while循环
1. 基本语法
while循环当条件为True时重复执行代码块，基本语法如下：
# while循环的基本语法
while 条件表达式:
# 循环体代码块
代码1
代码2
...
# 更新条件（避免无限循环）
更新语句
2. 使用示例
# while循环示例
# 打印1到5的数字
count =1
while count <=5:
print(count)
count +=1# 更新条件，避免无限循环
# 输出：
# 1
# 2
# 3
# 4
# 5
# 计算1到100的和
sum=0
num =1
while num <=100:
sum+= num
num +=1
print(f"1到100的和为: {sum}")# 输出：1到100的和为: 5050
# 猜数字游戏
import random
secret_number = random.randint(1,100)
guess =0
attempts =0
while guess != secret_number:
guess =int(input("请输入你猜测的数字(1-100): "))
attempts +=1
if guess < secret_number:
print("猜小了")
elif guess > secret_number:
print("猜大了")
else:
print(f"恭喜你，猜对了！你共尝试了{attempts}次")
3. 无限循环
当while循环的条件始终为True时，会导致无限循环。在某些情况下，这是有意为之的，但通常应该避免：
# 无限循环示例
# 有意的无限循环（需要用户中断）
whileTrue:
user_input =input("请输入内容（输入'quit'退出）: ")
if user_input =="quit":
break
print(f"你输入的内容是: {user_input}")
# 无意的无限循环（错误）
count =1
while count <=5:
print(count)
# 缺少count += 1，导致无限循环
4. 嵌套while循环
嵌套while循环是指在一个while循环的循环体中包含另一个while循环：
# 嵌套while循环示例
# 打印星号三角形
row =1
while row <=5:
col =1
while col <= row:
print("*")
col +=1
print()# 换行
row +=1
# 输出：
# *
# **
# ***
# ****
# *****
# 寻找两个数的最大公约数
a =int(input("请输入第一个数: "))
b =int(input("请输入第二个数: "))
while b !=0:
temp = a % b
while temp !=0:
a = b
b = temp
temp = a % b
print(f"最大公约数为: {b if b !=0else a}")
break
四、循环控制语句
1. break语句
break语句用于终止当前循环，跳出循环体：
# break语句示例
# 在for循环中使用break
fruits =["apple","banana","orange","grape"]
for fruit in fruits:
if fruit =="orange":
print("找到橙子了")
break
print(fruit)
# 输出：
# apple
# banana
# 找到橙子了
# 在while循环中使用break
count =1
whileTrue:
print(count)
if count ==5:
break
count +=1
# 输出：
# 1
# 2
# 3
# 4
# 5
# 在嵌套循环中使用break（只终止内层循环）
for i inrange(1,4):
print(f"外层循环: {i}")
for j inrange(1,4):
if j ==2:
break
print(f"内层循环: {j}")
# 输出：
# 外层循环: 1
# 内层循环: 1
# 外层循环: 2
# 内层循环: 1
# 外层循环: 3
# 内层循环: 1
2. continue语句
continue语句用于跳过当前循环的剩余部分，直接进入下一次循环：
# continue语句示例
# 在for循环中使用continue
numbers =[1,2,3,4,5,6,7,8,9,10]
for num in numbers:
if num %2==0:
continue# 跳过偶数
print(num)# 只打印奇数
# 输出：
# 1
# 3
# 5
# 7
# 9
# 在while循环中使用continue
count =0
while count <10:
count +=1
if count %2==0:
continue# 跳过偶数
print(count)# 只打印奇数
# 输出：
# 1
# 3
# 5
# 7
# 9
# 处理用户输入
whileTrue:
user_input =input("请输入数字（输入'quit'退出）: ")
if user_input =="quit":
break
ifnot user_input.isdigit():
print("请输入有效的数字")
continue
print(f"你输入的数字是: {user_input}")
3. pass语句
pass语句是一个空操作，不执行任何操作，主要用于占位：
# pass语句示例
# 在for循环中使用pass
for i inrange(5):
pass# 暂时不实现，占位用
# 在while循环中使用pass
count =0
while count <5:
pass# 暂时不实现，占位用
count +=1
# 在条件语句中使用pass
age =18
if age >=18:
pass# 暂时不实现成年后的逻辑
else:
print("未成年")
# 在函数中使用pass
defmy_function():
pass# 暂时不实现函数体
# 在类中使用pass
classMyClass:
pass# 暂时不实现类的内容
4. else子句
Python的循环语句可以带有else子句，当循环正常结束时（即没有被break语句终止），会执行else子句中的代码：
# else子句示例
# 在for循环中使用else
for i inrange(5):
print(i)
else:
print("循环正常结束")
# 输出：
# 0
# 1
# 2
# 3
# 4
# 循环正常结束
# 在for循环中使用break，else子句不会执行
for i inrange(5):
if i ==3:
break
print(i)
else:
print("循环正常结束")
# 输出：
# 0
# 1
# 2
# 在while循环中使用else
count =1
while count <=5:
print(count)
count +=1
else:
print("循环正常结束")
# 输出：
# 1
# 2
# 3
# 4
# 5
# 循环正常结束
# 在while循环中使用break，else子句不会执行
count =1
while count <=5:
if count ==3:
break
print(count)
count +=1
else:
print("循环正常结束")
# 输出：
# 1
# 2
# 使用else子句检查素数
defis_prime(num):
if num <=1:
returnFalse
for i inrange(2,int(num **0.5)+1):
if num % i ==0:
returnFalse
else:
# 循环正常结束，说明num是素数
returnTrue
print(is_prime(7))# True
print(is_prime(12))# False
五、循环的高级特性
1. 列表推导式
列表推导式是一种简洁创建列表的方法，可以替代简单的for循环：
# 列表推导式示例
# 基本列表推导式
# 传统方法
numbers =[]
for i inrange(1,6):
numbers.append(i)
print(numbers)# [1, 2, 3, 4, 5]
# 列表推导式
numbers =[i for i inrange(1,6)]
print(numbers)# [1, 2, 3, 4, 5]
# 带有条件的列表推导式
# 传统方法
evens =[]
for i inrange(1,11):
if i %2==0:
evens.append(i)
print(evens)# [2, 4, 6, 8, 10]
# 列表推导式
evens =[i for i inrange(1,11)if i %2==0]
print(evens)# [2, 4, 6, 8, 10]
# 嵌套列表推导式
# 传统方法
matrix =[[1,2,3],[4,5,6],[7,8,9]]
flattened =[]
for row in matrix:
for num in row:
flattened.append(num)
print(flattened)# [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 列表推导式
flattened =[num for row in matrix for num in row]
print(flattened)# [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 带有条件的嵌套列表推导式
# 传统方法
squares =[]
for i inrange(1,11):
if i %2==0:
squares.append(i **2)
print(squares)# [4, 16, 36, 64, 100]
# 列表推导式
squares =[i **2for i inrange(1,11)if i %2==0]
print(squares)# [4, 16, 36, 64, 100]
2. 字典推导式
字典推导式是一种简洁创建字典的方法：
# 字典推导式示例
# 基本字典推导式
# 传统方法
squares ={}
for i inrange(1,6):
squares[i]= i **2
print(squares)# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# 字典推导式
squares ={i: i **2for i inrange(1,6)}
print(squares)# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# 带有条件的字典推导式
# 传统方法
even_squares ={}
for i inrange(1,11):
if i %2==0:
even_squares[i]= i **2
print(even_squares)# {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}
# 字典推导式
even_squares ={i: i **2for i inrange(1,11)if i %2==0}
print(even_squares)# {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}
# 从两个列表创建字典
# 传统方法
keys =["name","age","city"]
values =["张三",30,"北京"]
person ={}
for k, v inzip(keys, values):
person[k]= v
print(person)# {'name': '张三', 'age': 30, 'city': '北京'}
# 字典推导式
person ={k: v for k, v inzip(keys, values)}
print(person)# {'name': '张三', 'age': 30, 'city': '北京'}
# 转换字典的键值对
# 传统方法
original ={"a":1,"b":2,"c":3}
reversed_dict ={}
for k, v in original.items():
reversed_dict[v]= k
print(reversed_dict)# {1: 'a', 2: 'b', 3: 'c'}
# 字典推导式
reversed_dict ={v: k for k, v in original.items()}
print(reversed_dict)# {1: 'a', 2: 'b', 3: 'c'}
3. 集合推导式
集合推导式是一种简洁创建集合的方法：
# 集合推导式示例
# 基本集合推导式
# 传统方法
squares =set()
for i inrange(1,6):
squares.add(i **2)
print(squares)# {1, 4, 9, 16, 25}
# 集合推导式
squares ={i **2for i inrange(1,6)}
print(squares)# {1, 4, 9, 16, 25}
# 带有条件的集合推导式
# 传统方法
even_squares =set()
for i inrange(1,11):
if i %2==0:
even_squares.add(i **2)
print(even_squares)# {4, 16, 36, 64, 100}
# 集合推导式
even_squares ={i **2for i inrange(1,11)if i %2==0}
print(even_squares)# {4, 16, 36, 64, 100}
# 从字符串创建集合（去重）
# 传统方法
word ="hello"
unique_chars =set()
for char in word:
unique_chars.add(char)
print(unique_chars)# {'h', 'e', 'l', 'o'}
# 集合推导式
unique_chars ={char for char in word}
print(unique_chars)# {'h', 'e', 'l', 'o'}
# 嵌套集合推导式
# 传统方法
matrix =[[1,2,3],[4,5,6],[7,8,9]]
unique_nums =set()
for row in matrix:
for num in row:
unique_nums.add(num)
print(unique_nums)# {1, 2, 3, 4, 5, 6, 7, 8, 9}
# 集合推导式
unique_nums ={num for row in matrix for num in row}
print(unique_nums)# {1, 2, 3, 4, 5, 6, 7, 8, 9}
4. 生成器表达式
生成器表达式是一种简洁创建生成器的方法，与列表推导式类似，但使用圆括号：
# 生成器表达式示例
# 基本生成器表达式
# 列表推导式（创建完整列表）
squares_list =[i **2for i inrange(1,6)]
print(squares_list)# [1, 4, 9, 16, 25]
print(type(squares_list))# <class 'list'>
# 生成器表达式（创建生成器）
squares_gen =(i **2for i inrange(1,6))
print(squares_gen)# <generator object <genexpr> at 0x...>
print(type(squares_gen))# <class 'generator'>
# 遍历生成器
for square in squares_gen:
print(square)
# 输出：
# 1
# 4
# 9
# 16
# 25
# 带有条件的生成器表达式
# 传统方法
even_gen =(i for i inrange(1,11)if i %2==0)
for num in even_gen:
print(num)
# 输出：
# 2
# 4
# 6
# 8
# 10
# 生成器表达式的优势（节省内存）
import sys
# 列表推导式占用的内存
list_comp =[i for i inrange(1000000)]
print(f"列表推导式占用内存: {sys.getsizeof(list_comp)} 字节")
# 生成器表达式占用的内存
gen_expr =(i for i inrange(1000000))
print(f"生成器表达式占用内存: {sys.getsizeof(gen_expr)} 字节")
# 处理大文件
defread_large_file(file_path):
withopen(file_path,'r')asfile:
lines =(line.strip()for line infile)# 生成器表达式
for line in lines:
yield line
# 遍历生成器
# for line in read_large_file('large_file.txt'):
# process_line(line)
六、循环的性能分析
1. 时间复杂度
循环的时间复杂度主要取决于循环体的执行次数：
2. 性能优化建议
- 优先使用内置函数和方法，它们通常是用C实现的，比Python代码快
- 对于大型数据集，使用生成器表达式代替列表推导式，节省内存
3. 性能比较示例
# 性能比较示例
import time
# 使用for循环和append()方法
start_time = time.time()
result =[]
for i inrange(1000000):
result.append(i)
end_time = time.time()
print(f"for循环和append(): {end_time - start_time:.6f}秒")
# 使用列表推导式
start_time = time.time()
result =[i for i inrange(1000000)]
end_time = time.time()
print(f"列表推导式: {end_time - start_time:.6f}秒")
# 使用range()直接转换为列表
start_time = time.time()
result =list(range(1000000))
end_time = time.time()
print(f"list(range()): {end_time - start_time:.6f}秒")
# 内置函数vs自定义函数
defsquare(n):
return n **2
start_time = time.time()
result =[square(i)for i inrange(1000000)]
end_time = time.time()
print(f"自定义函数: {end_time - start_time:.6f}秒")
start_time = time.time()
result =[i **2for i inrange(1000000)]
end_time = time.time()
print(f"内置运算符: {end_time - start_time:.6f}秒")
七、循环的最佳实践
1. 代码可读性
2. 避免常见的错误
3. 示例对比
# 不好的写法
defcalculate_sum(numbers):
total =0
for i inrange(len(numbers)):
total += numbers[i]
return total
# 好的写法
defcalculate_sum(numbers):
total =0
for num in numbers:
total += num
return total
# 更好的写法
defcalculate_sum(numbers):
returnsum(numbers)
# 不好的写法
result =[]
for i inrange(10):
if i %2==0:
result.append(i *2)
# 好的写法
result =[i *2for i inrange(10)if i %2==0]
# 不好的写法
for i inrange(len(fruits)):
if fruits[i]=="apple":
print("找到苹果了")
break
# 好的写法
for fruit in fruits:
if fruit =="apple":
print("找到苹果了")
break
八、常见错误
1. 无限循环
# 无限循环示例
# 错误：缺少循环变量的更新
count =1
while count <=5:
print(count)
# 缺少count += 1，导致无限循环
# 错误：条件永远为True
whileTrue:
print("无限循环")
# 缺少break语句，导致无限循环
# 正确的写法
count =1
while count <=5:
print(count)
count +=1# 更新循环变量
whileTrue:
user_input =input("请输入内容（输入'quit'退出）: ")
if user_input =="quit":
break# 提供退出条件
print(f"你输入的内容是: {user_input}")
2. 循环条件错误
# 循环条件错误示例
# 错误：使用赋值运算符代替比较运算符
count =1
while count =5:# 错误，应该使用==
print(count)
count +=1
# 错误：条件表达式错误
numbers =[1,2,3,4,5]
for i in numbers:
if i >10# 缺少冒号
break
print(i)
# 正确的写法
count =1
while count ==5:# 使用==
print(count)
count +=1
for i in numbers:
if i >10:# 添加冒号
break
print(i)
3. 索引错误
# 索引错误示例
# 错误：索引超出范围
numbers =[1,2,3,4,5]
for i inrange(6):# 错误，列表只有5个元素，索引0-4
print(numbers[i])
# 错误：修改正在遍历的列表
numbers =[1,2,3,4,5]
for i in numbers:
if i ==3:
numbers.remove(i)# 修改正在遍历的列表，可能导致不可预期的结果
print(i)
# 正确的写法
numbers =[1,2,3,4,5]
for i inrange(len(numbers)):
if i <5:# 确保索引不超出范围
print(numbers[i])
# 或者直接遍历列表
for num in numbers:
print(num)
# 修改列表的正确方法
numbers =[1,2,3,4,5]
# 创建一个新列表
new_numbers =[i for i in numbers if i !=3]
print(new_numbers)# [1, 2, 4, 5]
4. 变量作用域问题
# 变量作用域问题示例
# 错误：在循环体外使用循环变量
for i inrange(5):
print(i)
print(f"循环结束后的i值: {i}")# 在Python中这是允许的，但不推荐
# 错误：在嵌套循环中使用相同的变量名
for i inrange(3):
print(f"外层循环i: {i}")
for i inrange(2):
print(f"内层循环i: {i}")
print(f"外层循环i: {i}")# 内层循环修改了外层循环的变量i
# 正确的写法
# 使用不同的变量名
i =None# 在循环外初始化变量
for i inrange(5):
print(i)
print(f"循环结束后的i值: {i}")
# 在嵌套循环中使用不同的变量名
for i inrange(3):
print(f"外层循环i: {i}")
for j inrange(2):
print(f"内层循环j: {j}")
print(f"外层循环i: {i}")# i的值保持不变
九、总结
Python的循环语句是编程中实现重复操作的核心结构，主要包括：
for循环：用于遍历序列或可迭代对象
while循环：当条件为True时重复执行代码块
循环控制语句：
循环的高级特性：
循环的性能分析：
循环的最佳实践：
在使用循环语句时，应注意：
通过掌握Python的循环语句，可以编写出更高效、更灵活的程序。
发布网站：荣殿教程（zhangrongdian.com）
作者：张荣殿
