控制结构是编程语言中用来控制程序执行流程的语句。Python提供了条件语句、循环语句等控制结构，让程序能够根据不同条件执行不同的代码块。
kotlin
程序执行流程图：
┌─────────────────────────────────────────────┐
│ 程序控制流程 │
├─────────────────────────────────────────────┤
│ │
│ 顺序执行 ──→ 条件分支 ──→ 循环重复 │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ 语句1 if/elif for/while │
│ 语句2 else break │
│ 语句3 continue │
│ │
└─────────────────────────────────────────────┘条件语句（if, elif, else）
条件语句允许程序根据条件的真假来选择不同的执行路径。
1. 基本if语句
python
# 基本if语句
age = 18
if age >= 18:
print("你已经成年了！")
print("可以投票和工作")
print("程序继续执行")
# 带else的if语句
score = 85
if score >= 60:
print("考试及格！")
else:
print("考试不及格，需要补考")
# 嵌套if语句
weather = "晴天"
temperature = 25
if weather == "晴天":
print("天气不错！")
if temperature > 30:
print("有点热，记得防晒")
elif temperature < 10:
print("有点冷，多穿点衣服")
else:
print("温度刚好，适合出门")
else:
print("天气不太好")2. elif语句（多重条件）
python
# 成绩等级判断
score = 92
if score >= 90:
grade = "A"
comment = "优秀"
elif score >= 80:
grade = "B"
comment = "良好"
elif score >= 70:
grade = "C"
comment = "中等"
elif score >= 60:
grade = "D"
comment = "及格"
else:
grade = "F"
comment = "不及格"
print(f"分数: {score}, 等级: {grade}, 评价: {comment}")
# 多条件判断
username = "admin"
password = "123456"
is_active = True
if username == "admin" and password == "123456" and is_active:
print("登录成功！")
elif not is_active:
print("账户已被禁用")
elif username != "admin":
print("用户名错误")
else:
print("密码错误")3. 条件表达式（三元运算符）
python
# 传统写法
age = 20
if age >= 18:
status = "成年人"
else:
status = "未成年人"
print(f"状态: {status}")
# 条件表达式（三元运算符）
age = 16
status = "成年人" if age >= 18 else "未成年人"
print(f"状态: {status}")
# 更复杂的条件表达式
score = 85
result = "优秀" if score >= 90 else "良好" if score >= 80 else "及格" if score >= 60 else "不及格"
print(f"成绩: {score}, 评价: {result}")
# 实际应用示例
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = [x if x % 2 == 0 else 0 for x in numbers]
print(f"偶数或0: {even_numbers}")4. 条件语句的最佳实践
python
# ✅ 好的写法：使用in操作符
day = "星期六"
if day in ["星期六", "星期日"]:
print("今天是周末")
# ❌ 不好的写法
# if day == "星期六" or day == "星期日":
# print("今天是周末")
# ✅ 好的写法：利用布尔值的特性
name = ""
if not name: # 空字符串为False
print("请输入姓名")
# ❌ 不好的写法
# if name == "":
# print("请输入姓名")
# ✅ 好的写法：使用is比较None
value = None
if value is None:
print("值为空")
# ❌ 不好的写法
# if value == None:
# print("值为空")
# ✅ 好的写法：避免深层嵌套
def process_user(user):
if not user:
return "用户不存在"
if not user.get("active"):
return "用户未激活"
if user.get("age", 0) < 18:
return "用户未成年"
return "用户验证通过"
# 测试
user1 = {"name": "张三", "age": 25, "active": True}
user2 = {"name": "李四", "age": 16, "active": True}
user3 = None
print(process_user(user1))
print(process_user(user2))
print(process_user(user3))循环语句
循环语句允许重复执行一段代码，直到满足某个条件为止。
1. for循环
for循环用于遍历序列（如列表、元组、字符串）或其他可迭代对象。
python
# 遍历列表
fruits = ["苹果", "香蕉", "橙子", "葡萄"]
print("水果清单:")
for fruit in fruits:
print(f"- {fruit}")
# 遍历字符串
word = "Python"
print("\n字母分解:")
for char in word:
print(f"字母: {char}")
# 遍历字典
student = {"姓名": "张三", "年龄": 20, "专业": "计算机科学"}
print("\n学生信息:")
for key, value in student.items():
print(f"{key}: {value}")
# 只遍历键
print("\n只显示键:")
for key in student.keys():
print(key)
# 只遍历值
print("\n只显示值:")
for value in student.values():
print(value)2. range()函数
python
# 基本用法
print("0到4:")
for i in range(5):
print(i, end=" ")
print()
# 指定起始和结束
print("\n1到5:")
for i in range(1, 6):
print(i, end=" ")
print()
# 指定步长
print("\n偶数0到10:")
for i in range(0, 11, 2):
print(i, end=" ")
print()
# 倒序
print("\n倒数5到1:")
for i in range(5, 0, -1):
print(i, end=" ")
print()
# 实际应用：打印乘法表
print("\n九九乘法表:")
for i in range(1, 10):
for j in range(1, i + 1):
print(f"{j}×{i}={i*j:2d}", end=" ")
print() # 换行3. enumerate()函数
python
# 获取索引和值
fruits = ["苹果", "香蕉", "橙子"]
print("带索引的遍历:")
for index, fruit in enumerate(fruits):
print(f"{index}: {fruit}")
# 指定起始索引
print("\n从1开始编号:")
for index, fruit in enumerate(fruits, start=1):
print(f"第{index}个水果: {fruit}")
# 实际应用：处理文件行号
lines = ["第一行内容", "第二行内容", "第三行内容"]
for line_num, content in enumerate(lines, start=1):
print(f"行{line_num}: {content}")4. zip()函数
python
# 同时遍历多个序列
names = ["张三", "李四", "王五"]
ages = [20, 25, 30]
cities = ["北京", "上海", "广州"]
print("学生信息:")
for name, age, city in zip(names, ages, cities):
print(f"{name}, {age}岁, 来自{city}")
# 长度不同的序列
list1 = [1, 2, 3, 4, 5]
list2 = ['a', 'b', 'c']
print("\n长度不同的序列:")
for num, letter in zip(list1, list2):
print(f"{num} - {letter}")
# 创建字典
keys = ["name", "age", "city"]
values = ["Alice", 25, "New York"]
person = dict(zip(keys, values))
print(f"\n创建的字典: {person}")
# 矩阵转置
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transposed = list(zip(*matrix))
print(f"\n原矩阵: {matrix}")
print(f"转置后: {list(transposed)}")5. while循环
while循环在条件为真时重复执行代码块。
python
# 基本while循环
count = 0
print("倒计时:")
while count < 5:
print(f"{5 - count}...")
count += 1
print("发射！")
# 用户输入循环
print("\n猜数字游戏:")
import random
target = random.randint(1, 100)
guess_count = 0
max_guesses = 7
print(f"我想了一个1到100之间的数字，你有{max_guesses}次机会猜中它！")
while guess_count < max_guesses:
try:
guess = int(input(f"第{guess_count + 1}次猜测，请输入数字: "))
guess_count += 1
if guess == target:
print(f"恭喜！你猜中了！数字是{target}")
break
elif guess < target:
print("太小了！")
else:
print("太大了！")
if guess_count == max_guesses:
print(f"游戏结束！正确答案是{target}")
except ValueError:
print("请输入有效的数字！")
# 无限循环（需要break退出）
print("\n简单计算器（输入'quit'退出）:")
while True:
user_input = input("请输入表达式（如: 2+3）或'quit': ")
if user_input.lower() == 'quit':
print("再见！")
break
try:
result = eval(user_input) # 注意：实际项目中不建议使用eval
print(f"结果: {result}")
except:
print("无效的表达式！")循环控制（break, continue, pass）
1. break语句
break用于完全退出循环。
python
# 在for循环中使用break
print("查找第一个偶数:")
numbers = [1, 3, 5, 8, 9, 10, 11]
for num in numbers:
if num % 2 == 0:
print(f"找到第一个偶数: {num}")
break
print(f"{num}是奇数")
# 在嵌套循环中使用break
print("\n在矩阵中查找特定值:")
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
target = 5
found = False
for i, row in enumerate(matrix):
for j, value in enumerate(row):
if value == target:
print(f"在位置({i}, {j})找到{target}")
found = True
break
if found:
break
# 使用标志变量的替代方案
def find_in_matrix(matrix, target):
for i, row in enumerate(matrix):
for j, value in enumerate(row):
if value == target:
return i, j
return None
position = find_in_matrix(matrix, 8)
if position:
print(f"数字8在位置{position}")
else:
print("未找到数字8")2. continue语句
continue用于跳过当前迭代，继续下一次迭代。
python
# 跳过偶数，只打印奇数
print("只打印奇数:")
for i in range(1, 11):
if i % 2 == 0:
continue # 跳过偶数
print(i, end=" ")
print()
# 处理列表，跳过无效数据
data = [1, -2, 3, 0, -5, 6, 7, -8]
positive_sum = 0
print("\n处理数据（跳过负数和零）:")
for num in data:
if num <= 0:
print(f"跳过: {num}")
continue
positive_sum += num
print(f"累加: {num}, 当前和: {positive_sum}")
print(f"正数总和: {positive_sum}")
# 在while循环中使用continue
print("\n输入验证（跳过无效输入）:")
valid_inputs = []
count = 0
while len(valid_inputs) < 3:
count += 1
user_input = input(f"请输入第{count}个正整数: ")
try:
num = int(user_input)
if num <= 0:
print("请输入正整数！")
continue
valid_inputs.append(num)
print(f"有效输入: {num}")
except ValueError:
print("请输入数字！")
continue
print(f"收集到的有效输入: {valid_inputs}")3. pass语句
pass是一个空操作，用作占位符。
python
# 作为占位符
def future_function():
pass # 暂时不实现，避免语法错误
class FutureClass:
pass # 暂时不实现
# 在条件语句中使用
age = 25
if age < 18:
pass # 暂时不处理未成年情况
elif age >= 65:
print("享受老年优惠")
else:
print("正常价格")
# 在异常处理中使用
data = [1, 2, "invalid", 4, 5]
processed = []
for item in data:
try:
result = int(item) * 2
processed.append(result)
except ValueError:
pass # 忽略无效数据
print(f"处理后的数据: {processed}")
# 调试时的临时代码
def debug_function(x):
if x < 0:
pass # TODO: 处理负数情况
return x * 2
print(debug_function(5))4. else子句在循环中的使用
Python的循环可以有else子句，当循环正常结束（没有被break中断）时执行。
python
# for循环的else子句
print("查找质数:")
def is_prime(n):
if n < 2:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
print(f"{n}不是质数，因为{i} × {n//i} = {n}")
return False
else:
print(f"{n}是质数")
return True
# 测试
test_numbers = [17, 18, 19, 20]
for num in test_numbers:
is_prime(num)
print()
# while循环的else子句
print("密码验证（最多3次机会）:")
correct_password = "python123"
attempts = 0
max_attempts = 3
while attempts < max_attempts:
password = input(f"请输入密码（第{attempts + 1}次尝试）: ")
attempts += 1
if password == correct_password:
print("密码正确，登录成功！")
break
else:
print("密码错误")
else:
print("尝试次数过多，账户被锁定！")推导式（Comprehensions）
推导式是Python的一个强大特性，可以用简洁的语法创建列表、字典和集合。
1. 列表推导式
python
# 基本语法：[expression for item in iterable]
# 创建平方数列表
squares = [x**2 for x in range(1, 6)]
print(f"平方数: {squares}")
# 等价的传统写法
squares_traditional = []
for x in range(1, 6):
squares_traditional.append(x**2)
print(f"传统写法: {squares_traditional}")
# 带条件的列表推导式
# 语法：[expression for item in iterable if condition]
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print(f"偶数的平方: {even_squares}")
# 字符串处理
words = ["hello", "world", "python", "programming"]
uppercase_words = [word.upper() for word in words]
long_words = [word for word in words if len(word) > 5]
print(f"大写单词: {uppercase_words}")
print(f"长单词: {long_words}")
# 嵌套列表推导式
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(f"展平矩阵: {flattened}")
# 等价的传统写法
flattened_traditional = []
for row in matrix:
for num in row:
flattened_traditional.append(num)
print(f"传统写法: {flattened_traditional}")
# 复杂的列表推导式
sentences = ["Hello World", "Python Programming", "Data Science"]
word_lengths = [[len(word) for word in sentence.split()] for sentence in sentences]
print(f"单词长度: {word_lengths}")2. 字典推导式
python
# 基本语法：{key_expr: value_expr for item in iterable}
# 创建平方数字典
squares_dict = {x: x**2 for x in range(1, 6)}
print(f"平方数字典: {squares_dict}")
# 从两个列表创建字典
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
people = {name: age for name, age in zip(names, ages)}
print(f"人员信息: {people}")
# 带条件的字典推导式
even_squares_dict = {x: x**2 for x in range(1, 11) if x % 2 == 0}
print(f"偶数平方字典: {even_squares_dict}")
# 字符串处理
words = ["apple", "banana", "cherry", "date"]
word_lengths = {word: len(word) for word in words}
long_words_dict = {word: len(word) for word in words if len(word) > 5}
print(f"单词长度: {word_lengths}")
print(f"长单词: {long_words_dict}")
# 转换现有字典
original_dict = {"a": 1, "b": 2, "c": 3, "d": 4}
# 键值互换
swapped_dict = {value: key for key, value in original_dict.items()}
print(f"键值互换: {swapped_dict}")
# 过滤和转换
filtered_dict = {key: value * 2 for key, value in original_dict.items() if value % 2 == 0}
print(f"偶数值翻倍: {filtered_dict}")3. 集合推导式
python
# 基本语法：{expression for item in iterable}
# 创建平方数集合
squares_set = {x**2 for x in range(1, 6)}
print(f"平方数集合: {squares_set}")
# 去重
numbers = [1, 2, 2, 3, 3, 3, 4, 4, 5]
unique_numbers = {x for x in numbers}
print(f"去重后: {unique_numbers}")
# 字符串去重
text = "hello world"
unique_chars = {char for char in text if char != ' '}
print(f"唯一字符: {unique_chars}")
# 数学集合操作
set_a = {x for x in range(1, 11) if x % 2 == 0} # 偶数
set_b = {x for x in range(1, 11) if x % 3 == 0} # 3的倍数
print(f"偶数集合: {set_a}")
print(f"3的倍数集合: {set_b}")
print(f"交集: {set_a & set_b}")
print(f"并集: {set_a | set_b}")4. 生成器表达式
生成器表达式类似列表推导式，但使用圆括号，返回生成器对象。
python
# 生成器表达式
squares_gen = (x**2 for x in range(1, 6))
print(f"生成器对象: {squares_gen}")
print(f"生成器类型: {type(squares_gen)}")
# 遍历生成器
print("生成器内容:")
for square in squares_gen:
print(square, end=" ")
print()
# 生成器只能遍历一次
print("再次遍历生成器:")
for square in squares_gen:
print(square, end=" ") # 不会输出任何内容
print("（空的，因为生成器已耗尽）")
# 内存效率比较
import sys
# 列表推导式（占用更多内存）
list_comp = [x**2 for x in range(1000)]
print(f"列表推导式内存: {sys.getsizeof(list_comp)} 字节")
# 生成器表达式（占用很少内存）
gen_expr = (x**2 for x in range(1000))
print(f"生成器表达式内存: {sys.getsizeof(gen_expr)} 字节")
# 实际应用：处理大文件
def process_large_file(filename):
"""使用生成器处理大文件"""
with open(filename, 'r') as file:
# 生成器表达式，逐行处理，不会一次性加载整个文件
processed_lines = (line.strip().upper() for line in file if line.strip())
return processed_lines
# 数学应用：无限序列
def fibonacci_gen():
"""斐波那契数列生成器"""
a, b = 0, 1
while True:
yield a
a, b = b, a + b
# 获取前10个斐波那契数
fib_gen = fibonacci_gen()
first_10_fib = [next(fib_gen) for _ in range(10)]
print(f"前10个斐波那契数: {first_10_fib}")实际应用示例
1. 数据处理
python
# 学生成绩处理系统
students = [
{"name": "张三", "scores": [85, 92, 78, 96]},
{"name": "李四", "scores": [76, 88, 92, 84]},
{"name": "王五", "scores": [95, 87, 91, 89]},
{"name": "赵六", "scores": [68, 72, 75, 70]}
]
print("学生成绩分析:")
print("=" * 40)
for student in students:
name = student["name"]
scores = student["scores"]
# 计算平均分
average = sum(scores) / len(scores)
# 判断等级
if average >= 90:
grade = "优秀"
elif average >= 80:
grade = "良好"
elif average >= 70:
grade = "中等"
elif average >= 60:
grade = "及格"
else:
grade = "不及格"
print(f"{name}: 平均分 {average:.1f}, 等级 {grade}")
# 找出最高分和最低分
max_score = max(scores)
min_score = min(scores)
print(f" 最高分: {max_score}, 最低分: {min_score}")
# 统计各分数段
excellent = sum(1 for score in scores if score >= 90)
good = sum(1 for score in scores if 80 <= score < 90)
average_count = sum(1 for score in scores if 70 <= score < 80)
poor = sum(1 for score in scores if score < 70)
print(f" 分数分布 - 优秀:{excellent}, 良好:{good}, 中等:{average_count}, 较差:{poor}")
print()
# 班级统计
all_scores = [score for student in students for score in student["scores"]]
class_average = sum(all_scores) / len(all_scores)
print(f"班级平均分: {class_average:.1f}")
# 找出班级最高分学生
best_student = max(students, key=lambda s: sum(s["scores"]) / len(s["scores"]))
print(f"班级第一名: {best_student['name']}")2. 文本处理
python
# 文本分析工具
def analyze_text(text):
"""分析文本的各种统计信息"""
print(f"原文本: {text}")
print("=" * 50)
# 基本统计
char_count = len(text)
word_count = len(text.split())
sentence_count = text.count('.') + text.count('!') + text.count('?')
print(f"字符数: {char_count}")
print(f"单词数: {word_count}")
print(f"句子数: {sentence_count}")
# 字符频率统计
char_freq = {}
for char in text.lower():
if char.isalpha():
char_freq[char] = char_freq.get(char, 0) + 1
print("\n字符频率（前5个）:")
sorted_chars = sorted(char_freq.items(), key=lambda x: x[1], reverse=True)
for char, freq in sorted_chars[:5]:
print(f" {char}: {freq}次")
# 单词频率统计
words = text.lower().split()
word_freq = {}
for word in words:
# 去除标点符号
clean_word = ''.join(char for char in word if char.isalnum())
if clean_word:
word_freq[clean_word] = word_freq.get(clean_word, 0) + 1
print("\n单词频率（前5个）:")
sorted_words = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)
for word, freq in sorted_words[:5]:
print(f" {word}: {freq}次")
# 查找长单词
long_words = [word for word in words if len(word) > 6]
print(f"\n长单词（>6字符）: {len(long_words)}个")
if long_words:
print(f" 示例: {', '.join(long_words[:3])}")
# 测试文本分析
sample_text = """
Python is a powerful programming language.
It is easy to learn and has a simple syntax.
Python is widely used in data science, web development, and automation.
"""
analyze_text(sample_text)3. 游戏开发
python
# 简单的猜数字游戏
import random
def number_guessing_game():
"""数字猜测游戏"""
print("欢迎来到猜数字游戏！")
print("我想了一个1到100之间的数字，请你来猜！")
# 游戏设置
target_number = random.randint(1, 100)
max_attempts = 7
attempts = 0
guessed_numbers = []
print(f"你有{max_attempts}次机会猜中这个数字。")
print("输入'hint'获取提示，输入'quit'退出游戏。")
while attempts < max_attempts:
# 显示当前状态
remaining = max_attempts - attempts
print(f"\n剩余机会: {remaining}")
if guessed_numbers:
print(f"已猜过的数字: {sorted(guessed_numbers)}")
# 获取用户输入
user_input = input("请输入你的猜测: ").strip().lower()
# 处理特殊命令
if user_input == 'quit':
print(f"游戏结束！正确答案是 {target_number}")
return
elif user_input == 'hint':
# 提供提示
if target_number % 2 == 0:
print("提示: 这是一个偶数")
else:
print("提示: 这是一个奇数")
continue
# 验证输入
try:
guess = int(user_input)
except ValueError:
print("请输入有效的数字！")
continue
if guess < 1 or guess > 100:
print("请输入1到100之间的数字！")
continue
if guess in guessed_numbers:
print("你已经猜过这个数字了！")
continue
# 处理猜测
attempts += 1
guessed_numbers.append(guess)
if guess == target_number:
print(f"\n🎉 恭喜你！猜中了！")
print(f"正确答案是 {target_number}")
print(f"你用了 {attempts} 次机会")
# 评价表现
if attempts <= 3:
print("太厉害了！你是猜数字高手！")
elif attempts <= 5:
print("不错的表现！")
else:
print("终于猜中了！")
return
elif guess < target_number:
print("太小了！试试更大的数字")
# 给出范围提示
larger_guesses = [n for n in guessed_numbers if n < target_number]
if larger_guesses:
min_range = max(larger_guesses) + 1
print(f"提示: 答案在 {min_range} 到 100 之间")
else:
print("太大了！试试更小的数字")
# 给出范围提示
smaller_guesses = [n for n in guessed_numbers if n > target_number]
if smaller_guesses:
max_range = min(smaller_guesses) - 1
print(f"提示: 答案在 1 到 {max_range} 之间")
# 游戏失败
print(f"\n😞 很遗憾，你没有在{max_attempts}次机会内猜中！")
print(f"正确答案是 {target_number}")
print("再试一次吧！")
# 运行游戏
# number_guessing_game()性能优化技巧
python
import time
# 1. 列表推导式 vs 传统循环
def compare_list_creation():
"""比较不同创建列表的方法的性能"""
n = 100000
# 方法1：传统for循环
start = time.time()
result1 = []
for i in range(n):
if i % 2 == 0:
result1.append(i * 2)
time1 = time.time() - start
# 方法2：列表推导式
start = time.time()
result2 = [i * 2 for i in range(n) if i % 2 == 0]
time2 = time.time() - start
# 方法3：filter + map
start = time.time()
result3 = list(map(lambda x: x * 2, filter(lambda x: x % 2 == 0, range(n))))
time3 = time.time() - start
print(f"传统循环: {time1:.4f}秒")
print(f"列表推导式: {time2:.4f}秒")
print(f"filter+map: {time3:.4f}秒")
print(f"列表推导式比传统循环快 {time1/time2:.1f} 倍")
# 2. 成员检测：list vs set
def compare_membership_test():
"""比较列表和集合的成员检测性能"""
data = list(range(10000))
data_set = set(data)
search_items = [1000, 5000, 9999]
# 列表查找
start = time.time()
for item in search_items * 1000: # 重复1000次
result = item in data
list_time = time.time() - start
# 集合查找
start = time.time()
for item in search_items * 1000: # 重复1000次
result = item in data_set
set_time = time.time() - start
print(f"列表查找: {list_time:.4f}秒")
print(f"集合查找: {set_time:.4f}秒")
print(f"集合比列表快 {list_time/set_time:.1f} 倍")
print("性能比较:")
print("=" * 30)
compare_list_creation()
print()
compare_membership_test()总结
本章详细介绍了Python的控制结构：
- 条件语句: if、elif、else，用于程序分支
- 循环语句: for和while，用于重复执行代码
- 循环控制: break、continue、pass，用于控制循环流程
- 推导式: 列表、字典、集合推导式，提供简洁的数据处理方式
arduino
控制结构使用指南：
┌─────────────────────────────────────────────┐
│ 何时使用哪种控制结构 │
├─────────────────────────────────────────────┤
│ if语句: │
│ • 根据条件执行不同代码 │
│ • 数据验证和错误处理 │
│ │
│ for循环: │
│ • 遍历已知序列 │
│ • 执行固定次数的操作 │
│ │
│ while循环: │
│ • 条件未知时的重复执行 │
│ • 用户交互和事件处理 │
│ │
│ 推导式: │
│ • 简洁的数据转换 │
│ • 过滤和映射操作 │
│ • 性能要求较高的场景 │
└─────────────────────────────────────────────┘掌握这些控制结构是编写高效Python程序的基础，它们让程序能够处理复杂的逻辑和数据操作。
下一章预告: 函数与模块 - 学习如何定义函数、参数传递、作用域和模块化编程。
更多经常文章请移步到
