流程控制

# 示例：检查年龄
age = 20
if age >= 18:
    print("您已成年，可以访问此内容。")

# 示例：根据登录状态显示消息
is_logged_in = False
if is_logged_in:
    print("欢迎回来！")
else:
    print("请先登录。")

# 示例：根据分数评定等级
score = 85
if score >= 90:
    grade = 'A'
elif score >= 80:
    grade = 'B'
elif score >= 70:
    grade = 'C'
else:
    grade = 'D'

print(f"您的成绩等级是：{grade}") # 输出: 您的成绩等级是：B

# 模拟一个交通信号灯系统
light = input("请输入信号灯颜色（红/黄/绿）: ").strip()  # 获取用户输入并去除首尾空格

if light == "红":                    # 第一个条件：红灯
    print("停车等待")                 # 条件为真时执行
elif light == "黄":                  # 第二个条件：黄灯（仅在前面的条件都为假时才检查）
    print("减速准备停车")             # 条件为真时执行
elif light == "绿":                  # 第三个条件：绿灯
    print("通行")                     # 条件为真时执行
else:                                # 所有条件都不满足时的兜底分支
    print("无效的信号灯颜色")         # 兜底执行

# 重要：elif 是"互斥"的，一旦某个条件为真，后面的条件不再检查
# 这比写多个独立的 if 更高效，也更符合业务逻辑

# 示例：检查驾驶资格
age = 20
has_license = True

if age >= 18:
    print("年龄符合要求。")
    if has_license:
        print("您可以合法驾驶。")
    else:
        print("您需要先考取驾照。")
else:
    print("您还未成年，不能驾驶。")

# 示例：检查入学资格
age = 22
has_diploma = True

# and: 必须同时满足年龄和学历要求
if age >= 18 and has_diploma:
    print("资格审查通过。")

# or: 满足 VIP 或高分条件之一即可
is_vip = False
score = 95
if is_vip or score > 90:
    print("恭喜，您获得优先录取资格。")

# 示例：检查用户权限和披萨配料
banned_users = ['andrew', 'carolina', 'david']
user = 'marie'

if user not in banned_users:
    print(f"{user.title()}, 欢迎您发布内容。")

requested_toppings = ['mushrooms', 'onions', 'pineapple']
if 'mushrooms' in requested_toppings:
    print("正在添加蘑菇。")

requested_toppings = []

if requested_toppings: # 因为列表为空，所以条件为 False
    print("列表不为空，开始制作披萨！")
else:
    print("您确定要一个不加任何配料的披萨吗？")

# 示例 1：根据用户角色设置权限
is_admin = True
access_level = "完全访问" if is_admin else "受限访问"
print(f"您的访问级别: {access_level}") # 输出: 您的访问级别: 完全访问

# 示例 2：计算两数的差的绝对值
a = 10
b = 6
difference = a - b if a > b else b - a
print(f"差的绝对值为: {difference}") # 输出: 差的绝对值为: 4

# 示例 3：三元运算符完整示例（逐行注释）
score = 72                                               # 定义分数
result = "及格" if score >= 60 else "不及格"              # 如果分数>=60则"及格"，否则"不及格"
print(f"考试结果: {result}")                              # 输出: 考试结果: 及格

# 示例 4：三元运算符嵌套（不推荐，可读性差）
# 能用但难读——建议改用 if-elif-else
status = "优秀" if score >= 90 else "良好" if score >= 75 else "及格" if score >= 60 else "不及格"
# 更好的写法：
if score >= 90:
    status = "优秀"
elif score >= 75:
    status = "良好"
elif score >= 60:
    status = "及格"
else:
    status = "不及格"

# 示例：处理不同的 HTTP 状态码
status_code = 404

match status_code:
    case 200:
        print("请求成功")
    case 404:
        print("未找到资源")
    case 500:
        print("服务器内部错误")
    case _:
        print("未知的状态码")

# ========== 1. 守卫（Guard）：用 if 添加额外条件 ==========
point = (3, 4)

match point:
    case (x, y) if x == y:               # 匹配元组，且 x 等于 y
        print(f"在对角线上: ({x}, {y})")
    case (x, y) if x > 0 and y > 0:      # 匹配元组，且 x、y 均为正
        print(f"第一象限: ({x}, {y})")
    case (0, 0):
        print("原点")
    case _:                               # 通配符，兜底匹配
        print("其他位置")

# ========== 2. 解包匹配：解构列表/元组 ==========
command = "goto 42 87"

match command.split():                    # 按空格分割为列表
    case ["quit"]:                        # 匹配只有一个元素的列表
        print("退出程序")
    case ["goto", x, y]:                 # 匹配三个元素，后两个绑定到变量
        print(f"移动到坐标 ({x}, {y})")
    case ["pick", obj, *rest]:           # *rest 捕获剩余元素（类似 *args）
        print(f"拾取 {obj}，其余: {rest}")
    case _:
        print("未知命令")

# ========== 3. 类模式匹配：解构对象属性 ==========
class Point:
    __match_args__ = ("x", "y")          # 告诉 match 按什么顺序解构属性
    def __init__(self, x, y):
        self.x = x
        self.y = y

shape = Point(3, 4)

match shape:
    case Point(x=0, y=0):                # 匹配原点
        print("原点")
    case Point(x=x, y=y) if x > 0 and y > 0:  # 匹配第一象限
        print(f"第一象限: ({x}, {y})")
    case Point(x=x, y=y):               # 匹配任意点
        print(f"坐标: ({x}, {y})")

# ========== 4. OR 模式：用 | 合并多个匹配 ==========
status = 403

match status:
    case 200 | 201 | 204:                # 用 | 表示"或"关系
        print("成功响应")
    case 400 | 401 | 403 | 404:          # 多个值共享同一处理逻辑
        print("客户端错误")
    case 500 | 502 | 503:
        print("服务端错误")

# 示例 1: 遍历列表
fruits = ['苹果', '香蕉', '橙子']
for fruit in fruits:
    print(f"我喜欢吃 {fruit}")

# 示例 2: 遍历字符串
for char in "Python":
    print(char, end=' ') # P y t h o n
print()

# 示例 3: 使用 range() 生成数字序列
# range(5) -> 0, 1, 2, 3, 4
# range(1, 6) -> 1, 2, 3, 4, 5
# range(0, 10, 2) -> 0, 2, 4, 6, 8
for i in range(1, 6):
    print(f"当前数字: {i}")

# ========== range：生成整数序列 ==========
# range(start, stop, step) —— 左闭右开，不包含 stop
for i in range(5):                       # 0, 1, 2, 3, 4
    print(i, end=' ')
print()                                  # 换行

for i in range(2, 10, 3):                # 2, 5, 8（从2开始，步长3）
    print(i, end=' ')
print()

# ========== enumerate：同时获取索引和值 ==========
fruits = ['苹果', '香蕉', '橙子']
for index, fruit in enumerate(fruits):   # 默认索引从 0 开始
    print(f"第{index}个水果是{fruit}")

for index, fruit in enumerate(fruits, start=1):  # 索引从 1 开始
    print(f"第{index}个水果是{fruit}")

# ========== zip：并行遍历多个序列 ==========
names = ['Alice', 'Bob', 'Charlie']
scores = [95, 87, 72]
for name, score in zip(names, scores):   # 按最短序列对齐
    print(f"{name}: {score}分")

# zip 与 enumerate 结合
for i, (name, score) in enumerate(zip(names, scores), start=1):
    print(f"{i}. {name} — {score}分")

# ========== 遍历字典 ==========
person = {'name': '张三', 'age': 25, 'city': '北京'}
for key in person:                        # 默认遍历键
    print(f"{key}: {person[key]}")

for key, value in person.items():         # 同时遍历键和值（更常用）
    print(f"{key} = {value}")

# ========== 列表推导式 ==========
# 基本语法：[表达式 for 变量 in 可迭代对象 if 条件]
squares = [x ** 2 for x in range(10)]               # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
even_squares = [x ** 2 for x in range(10) if x % 2 == 0]  # 只保留偶数的平方: [0, 4, 16, 36, 64]

# 带嵌套的列表推导式
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [num for row in matrix for num in row]        # 展平: [1, 2, 3, 4, 5, 6, 7, 8, 9]

# ========== 字典推导式 ==========
# 基本语法：{键表达式: 值表达式 for 变量 in 可迭代对象 if 条件}
words = ['hello', 'world', 'python']
word_lengths = {word: len(word) for word in words}   # {'hello': 5, 'world': 5, 'python': 6}

# 翻转字典的键和值
original = {'a': 1, 'b': 2, 'c': 3}
flipped = {v: k for k, v in original.items()}        # {1: 'a', 2: 'b', 3: 'c'}

# ========== 集合推导式 ==========
# 基本语法：{表达式 for 变量 in 可迭代对象 if 条件}
nums = [1, 2, 2, 3, 3, 3, 4]
unique_squares = {x ** 2 for x in nums}              # {1, 4, 9, 16}（自动去重）

# ========== 生成器表达式（惰性求值） ==========
# 用圆括号而非方括号，不立即创建列表，而是按需生成
total = sum(x ** 2 for x in range(1000000))          # 不会一次性创建百万元素的列表
print(f"0到999999的平方和: {total}")

# 示例：倒计时
count = 5
while count > 0:
    print(f"倒计时: {count}")
    count -= 1
print("发射！")

# ========== 基本用法：条件驱动循环 ==========
password = ""                             # 初始化密码变量
while password != "secret":               # 只要密码不对就继续循环
    password = input("请输入密码: ")       # 提示用户输入
print("密码正确，欢迎进入！")              # 循环正常结束后执行

# ========== while-else：查找素数 ==========
n = 17                                    # 要检查的数字
i = 2                                     # 从 2 开始试除
while i < n:                              # 只要 i 还没到 n 就继续
    if n % i == 0:                        # 如果 n 能被 i 整除
        print(f"{n} 不是素数，能被 {i} 整除")
        break                             # 找到因子就跳出
    i += 1                                # 否则试下一个数
else:
    # while 的 else：只有循环正常结束（没被 break）才执行
    print(f"{n} 是素数")                  # 17 是素数

# ========== 无限循环 + break：等待特定条件 ==========
while True:                               # 无限循环
    response = input("输入 'exit' 退出: ")
    if response == 'exit':
        break                             # 满足条件时跳出
    print(f"你输入了: {response}")

# 经典场景：在列表中查找元素
def find_first_even(numbers):
    """查找列表中的第一个偶数，返回它；如果没有偶数，返回 None"""
    for num in numbers:
        if num % 2 == 0:
            print(f"找到偶数: {num}")
            break                         # 找到了就跳出
    else:
        # 没有 break → 意味着"没找到"
        print("没有偶数")
        return None
    return num                            # break 后执行这里

# 测试 1：列表中有偶数
find_first_even([1, 3, 5, 8, 9])          # 输出: 找到偶数: 8

# 测试 2：列表中没有偶数
find_first_even([1, 3, 5, 7, 9])          # 输出: 没有偶数

# while-else 同理
def is_prime(n):
    """判断 n 是否为素数"""
    if n < 2:
        return False
    i = 2
    while i * i <= n:                     # 只需检查到 sqrt(n)
        if n % i == 0:
            break                         # 找到因子，不是素数
        i += 1
    else:
        return True                       # 没被 break → 是素数
    return False                          # 被 break → 不是素数

print(is_prime(17))                        # True
print(is_prime(18))                        # False

# ========== break：找到即停 ==========
numbers = [1, 3, 5, 7, 8, 9, 11]
for num in numbers:                       # 遍历列表
    if num % 2 == 0:                      # 发现偶数
        print(f"找到第一个偶数: {num}")    # 输出它
        break                             # 立即跳出整个循环，不再检查后面的元素
else:
    print("列表中没有偶数。")              # 如果从未 break，执行这里

# ========== continue：跳过特定元素 ==========
for i in range(1, 10):                    # 1 到 9
    if i % 2 == 0:                        # 如果是偶数
        continue                          # 跳过本次迭代的剩余代码，直接进入下一次迭代
    print(i, end=' ')                     # 只打印奇数: 1 3 5 7 9
print()

# ========== 嵌套循环中跳出外层循环 ==========
# 方法：使用标志变量
found = False                             # 标志变量，初始为 False
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
target = 5

for row in matrix:
    for val in row:
        if val == target:
            print(f"找到 {target}")
            found = True                  # 设置标志
            break                         # 跳出内层循环
    if found:                             # 检查标志
        break                             # 跳出外层循环

# ========== 手动实现一个倒计时迭代器 ==========
class Countdown:
    """倒计时迭代器：从 n 倒数到 1"""
    
    def __init__(self, n):
        self.n = n                         # 起始数字
        self.current = n                   # 当前数字，从 n 开始
    
    def __iter__(self):
        """返回迭代器对象本身（self 就是迭代器）"""
        return self
    
    def __next__(self):
        """返回下一个值，没有更多值时抛出 StopIteration"""
        if self.current <= 0:              # 已经倒数到 0 以下
            raise StopIteration            # 告诉 for 循环：结束了
        self.current -= 1                  # 先减 1
        return self.current + 1            # 返回减之前的值（即当前值）

# 使用自定义迭代器
for num in Countdown(5):                   # for 会自动调用 __iter__ 和 __next__
    print(num, end=' ')                    # 5 4 3 2 1
print()

# 等价的手动调用过程
cd = Countdown(3)                          # 创建迭代器
it = iter(cd)                              # 调用 __iter__，获取迭代器
print(next(it))                            # 调用 __next__，输出 3
print(next(it))                            # 输出 2
print(next(it))                            # 输出 1
# print(next(it))                          # 会抛出 StopIteration 异常

# ========== 可迭代对象 vs 迭代器 ==========
# 可迭代对象（Iterable）：实现了 __iter__ 方法，返回一个迭代器
# 迭代器（Iterator）：同时实现了 __iter__ 和 __next__，自身就是迭代器

my_list = [1, 2, 3]                        # 列表是可迭代对象，但不是迭代器
# next(my_list)                            # TypeError: list 不是迭代器！

it = iter(my_list)                         # 调用 iter() 获取迭代器
print(next(it))                            # 1
print(next(it))                            # 2
print(next(it))                            # 3
# print(next(it))                          # StopIteration

# 迭代器是一次性的：耗尽后不能重用
print(list(it))                            # []（已经耗尽了）
it2 = iter(my_list)                        # 重新获取新的迭代器
print(list(it2))                           # [1, 2, 3]

# 错误的方式：使用 for 循环
numbers = [1, 2, 3, 4, 5, 6]
# for num in numbers:
#     if num % 2 == 0:
#         numbers.remove(num) # 这会导致跳过元素，例如 4 会被漏掉

# 正确的方式 1：使用 while 循环
numbers_while = [1, 2, 3, 4, 5, 6]
i = 0
while i < len(numbers_while):
    if numbers_while[i] % 2 == 0:
        numbers_while.pop(i)
    else:
        i += 1
print(f"使用 while 循环移除偶数后: {numbers_while}")

# 正确的方式 2：遍历副本
numbers_copy = [1, 2, 3, 4, 5, 6]
for num in numbers_copy[:]: # [:] 创建了一个完整的列表副本
    if num % 2 == 0:
        numbers_copy.remove(num)
print(f"遍历副本移除偶数后: {numbers_copy}")

# 正确的方式 3：使用列表推导式 (更 Pythonic)
numbers_comp = [1, 2, 3, 4, 5, 6]
odd_numbers = [num for num in numbers_comp if num % 2 != 0]
print(f"使用列表推导式筛选奇数: {odd_numbers}")

# 字典分发示例：用字典替代 if-elif
def handle_start(): print("启动")
def handle_stop():  print("停止")
def handle_pause(): print("暂停")

commands = {
    "start": handle_start,
    "stop":  handle_stop,
    "pause": handle_pause,
}

action = "start"
commands.get(action, lambda: print("未知命令"))()  # 输出: 启动

# 何时用哪个？看需求：
data = ['a', 'b', 'c']

# 只需要值 → 直接遍历
for item in data:
    print(item)

# 需要索引 → enumerate
for i, item in enumerate(data):
    print(f"{i}: {item}")

# 需要固定次数 → range
for _ in range(3):
    print("执行3次")

# 需要并行遍历 → zip
names = ['Alice', 'Bob']
scores = [95, 87]
for name, score in zip(names, scores):
    print(f"{name}: {score}")

import random

secret_number = random.randint(1, 100)
attempts = 0

print("欢迎来到猜数字游戏！我已经想好了一个 1 到 100 之间的数字。")

while True:
    try:
        guess_str = input("请输入你的猜测 (输入 'quit' 退出): ")
        if guess_str.lower() == 'quit':
            print("游戏结束。")
            break

        guess = int(guess_str)
        attempts += 1

        if guess < secret_number:
            print("太小了，再大一点！")
        elif guess > secret_number:
            print("太大了，再小一点！")
        else:
            print(f"恭喜你，猜对了！数字就是 {secret_number}。")
            print(f"你一共尝试了 {attempts} 次。")
            break
    except ValueError:
        print("无效输入，请输入一个整数或 'quit'。")

def print_menu():
    print("\n--- 简易计算器 ---")
    print("1. 加法")
    print("2. 减法")
    print("3. 乘法")
    print("4. 除法")
    print("5. 打印九九乘法表")
    print("6. 退出")

while True:
    print_menu()
    choice = input("请输入你的选择 (1-6): ")

    if choice == '6':
        print("感谢使用，再见！")
        break

    if choice == '5':
        for i in range(1, 10):
            for j in range(1, i + 1):
                print(f"{j} * {i} = {i*j}", end='\t')
            print() # 换行
        continue

    if choice in ['1', '2', '3', '4']:
        try:
            num1_str, num2_str = input("请输入两个数字，用空格隔开: ").split()
            num1 = float(num1_str)
            num2 = float(num2_str)
        except ValueError:
            print("输入无效，请输入两个数字。")
            continue

        if choice == '1':
            print(f"结果: {num1} + {num2} = {num1 + num2}")
        elif choice == '2':
            print(f"结果: {num1} - {num2} = {num1 - num2}")
        elif choice == '3':
            print(f"结果: {num1} * {num2} = {num1 * num2}")
        elif choice == '4':
            if num2 == 0:
                print("错误：除数不能为零。")
            else:
                print(f"结果: {num1} / {num2} = {num1 / num2}")
    else:
        print("无效选择，请输入 1 到 6 之间的数字。")

# 误解：以为 else 是"循环没执行"时运行
for i in range(3):                        # 循环会正常执行 3 次
    print(i)
else:
    print("else 执行了！")                 # 这行会执行！因为循环没被 break

# 正确理解：else = "没有 break"
for i in range(3):
    if i == 1:
        break                             # 被 break 了
else:
    print("这行不会执行")                   # 因为被 break 了，所以跳过

for x in range(5):
    pass                                   # 什么都不做

print(x)                                   # 输出 4！x 仍然存在，值为最后一次迭代

# 更危险的场景：
x = 100                                    # 外部变量
for x in [1, 2, 3]:                        # 同名变量会覆盖外部变量！
    pass
print(x)                                   # 3（被覆盖了，不再是 100）

# 如果列表为空，则不会覆盖
x = 100
for x in []:                               # 空列表，循环体不执行
    pass
print(x)                                   # 100（没被覆盖，因为循环体没执行过）

# 经典 bug：边遍历边删除，导致跳过元素
nums = [1, 2, 2, 3, 4, 2, 5]
# 意图：删除所有 2
for n in nums:
    if n == 2:
        nums.remove(n)
print(nums)                                # [1, 2, 3, 4, 5] —— 还剩一个 2！

# 原因：删除第一个 2 后，后面的元素前移，但迭代器已经跳过了那个位置
# 解决方案 1：遍历副本
nums = [1, 2, 2, 3, 4, 2, 5]
for n in nums[:]:                          # nums[:] 创建副本
    if n == 2:
        nums.remove(n)
print(nums)                                # [1, 3, 4, 5] ✓

# 解决方案 2：列表推导式（推荐）
nums = [1, 2, 2, 3, 4, 2, 5]
nums = [n for n in nums if n != 2]
print(nums)                                # [1, 3, 4, 5] ✓

# 常见原因 1：忘记更新条件变量
count = 0
# while count < 5:                         # 死循环！count 永远是 0
#     print(count)

# 正确写法
count = 0
while count < 5:
    print(count)
    count += 1                             # 别忘了更新！

# 常见原因 2：浮点数精度问题
x = 0.0
# while x != 1.0:                          # 死循环！浮点数累加有精度误差
#     x += 0.1

# 正确写法：用 > 或 < 而非 !=
x = 0.0
while x < 1.0:                             # 用 < 而非 !=
    x += 0.1
    print(round(x, 1))                     # 用 round 控制显示精度

# 调试技巧：添加最大迭代次数
max_iterations = 1000
iteration = 0
while some_condition():
    iteration += 1
    if iteration > max_iterations:
        print(f"警告：超过 {max_iterations} 次迭代，可能死循环！")
        break
    # ... 正常逻辑 ...

# C/Java 的 switch-case：
# - 只做值匹配，不做结构匹配
# - 需要手动 break，否则会 fall-through
# - 匹配值必须是常量

# Python 的 match-case：
# 1. 自动终止，不会 fall-through（不需要 break）
match 2:
    case 1:
        print("一")
    case 2:
        print("二")                        # 匹配后自动跳出，不会继续到 case _
    case _:
        print("其他")

# 2. 可以做结构解构，不仅仅是值比较
match [1, 2, 3]:
    case [1, _, 3]:                        # 匹配"首尾是 1 和 3 的三元素列表"
        print("匹配成功")                   # _ 是通配符，匹配任意值

# 3. 可以绑定变量
match (10, 20):
    case (x, y):                           # x=10, y=20
        print(f"坐标: {x}, {y}")

# 4. 可以用守卫（if 条件）进一步过滤
match 15:
    case n if n > 10:                      # 先匹配值，再检查守卫
        print(f"大于10的数: {n}")
    case _:
        print("其他")