1.流程控制：让代码 “有逻辑” 地执行

       流程控制分为顺序结构（默认）、分支结构（条件判断）、循环结构（重复执行）三类，是 Python 代码的 “骨架”。

        顺序结构：代码从上往下依次执行，从左向右依次执行
        分支结构：根据不同的条件执行不同的代码
        循环结构：重复执行某一个代码块

        判断条件：
            1.非0的数字都为真
            2.非空的字符串都为真
            3.表达式最终转为布尔值
            4.能够返回布尔值的运算
        使用多分支：
            1.一个if只能匹配一个else
            2.可以拥有多个elif
            3.一旦某个分支条件为True，其他语句不在执行

1. 分支结构：if-elif-else 条件判断

                if 判断条件：
                        条件成立执行的代码1

                elif 判断条件:

                        条件成立执行的代码2

                else:

                        条件成立执行的代码3

        
                代码4

if age >= 18:
    print("已成年")
else:
    print("未成年")

# 多分支：多个条件依次判断（匹配一个即终止）
score = 85
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")


gender = "女"
age = 25
if age >= 18:
    print("成年女性")
    if age <= 30:
        print("青年阶段")
    else:
        print("中年阶段")
else:
    print("未成年女性")

2. 循环结构：重复执行代码块

（1）while 循环：不确定循环次数时用

核心逻辑：只要条件为True，就重复执行代码块，需手动更新条件避免死循环。  

while 循环条件：
    条件成立时执行的代码

while:条件驱动（只要条件为True/False)
      不确定循环次数，需要手动维护条件

# 基础用法：打印1-5
n = 1
while n <= 5:
    print(f"当前数字：{n}")
    n += 1  # 必须更新条件，否则无限循环

# 死循环（需谨慎使用，通常搭配break）
# while True:
#     user_input = input("输入q退出：")
#     if user_input == "q":
#         break

（2）for 循环：遍历可迭代对象时用

for 临时变量 in 可迭代对象：
    需要执行的代码语句

for 迭代驱动循环（遍历一组数据）
        确定循环次数 不容易发生死循环

语法	说明	示例
range(n)	从 0 到 n-1，步长 1	range(3) → 0,1,2
range(a, b)	从 a 到 b-1，步长 1	range(1,4) → 1,2,3
range(a, b, step)	从 a 到 b-1，步长 step	range(1,10,2) → 1,3,5,7,9

# 示例：7天，每天学5个单词
for day in range(1, 8):
    print(f"===== 第{day}天 =====")
    for word in range(1, 6):
        print(f"学习第{word}个单词")

（3）循环控制关键字：continue/break

        continue: 跳过本次循环，，执行后续的代码
        break： 立即终止循环，不再执行后续的代码

for i in range(1,5):
    print(f'这是第{i}天')
    print('每天上班')
    for j in range(1,4):
        if j == 3:
            continue
        print(f'这是我上的第{j}节课')
    print('每天下班')


for i in range(1,5):
    print(f'这是第{i}天')
    print('每天上班')
    for j in range(1,4):
        if j == 3:
            break
        print(f'这是我上的第{j}节课')
    print('每天下班')

二、数据容器：存储多个数据的 “容器”

Python 中常用的数据容器有列表（list）、元组（tuple）、字符串、集合、字典，本文重点讲解最基础的列表和元组(其余在后续)。

1. 列表（list）：可变的有序容器

列表是可变、有序的序列，支持增删改查，是 Python 最常用的数据容器。
列表的特点：
1.可以存放不同类型的元素
2.元素是有顺序的（正索引和负索引）
3.列表中的元素是可以重复的
4.列表可以增删改查
5.列表的长度不固定，可以随意操作

# 基础定义（支持不同数据类型）
nums = [1, 2, 3, 4]
info = ["张三", 18, True, [1.75, 60]]  # 嵌套列表
# 空列表
empty_list = []
empty_list2 = list()

增删改查

操作	语法	示例
查（取值）	列表[下标]	nums[0] → 1（正索引）；nums[-1] → 4（负索引）
改（赋值）	列表[下标] = 新值	nums[1] = 10 → nums 变为 [1,10,3,4]
增（末尾加）	append(值)	nums.append(5) → [1,10,3,4,5]
增（指定位置加）	insert(下标, 值)	nums.insert(2, 20) → [1,10,20,3,4,5]
删（指定下标）	pop(下标)	nums.pop(2) → 删除 20，返回 20
删（指定值）	remove(值)	nums.remove(10) → 删除第一个 10
清空	clear()	nums.clear() → 空列表

常用内置方法

list.index(值)  返回元素第一次出现的下标
list.count(值)  返回统计元素在列表当中出现的次数
list.reverse()  反转列表，不需要参数，直接操作的原列表
list.sort(reverse=布尔值)  对列表进行排序，默认从小到大，会改变原列表。
                    如果列表里有多个数据类型的元素，会报错
sorted(list) 不改变原先列表 返回一个新的列表

stu = ["张三", "李四", "张三", "王五"]
nums = [5, 2, 9, 1, 5]

# 统计类
print(len(stu))          # 长度：4
print(stu.count("张三")) # 出现次数：2
print(stu.index("李四")) # 第一次出现的下标：1
print(max(nums))         # 最大值：9
print(sum(nums))         # 求和：22

# 排序/反转
nums.sort()              # 升序排序（修改原列表）→ [1,2,5,5,9]
nums.sort(reverse=True)  # 降序排序 → [9,5,5,2,1]
stu.reverse()            # 反转列表 → ["王五","张三","李四","张三"]
sorted_nums = sorted(nums)  # 排序（返回新列表，不修改原列表）

遍历列表

# 方式1：for直接遍历（推荐）
for name in stu:
    print(name)

# 方式2：while+下标遍历
index = 0
while index < len(stu):
    print(stu[index])
    index += 1

2. 元组（tuple）：不可变的有序容器

元组 用来存放一组有序的数据，元组一旦创建就不可修改（不能增删改，只能查）
    由一系列变量组成的不可变的有序序列容器
元组的特点：
    1.可以存放不同类型的数据
    2.元素是有序存储的
    3.元组中的数据可以重复
    4.元组数据不可以修改，只能查看
    5.元组的长度固定

# 基础定义
t1 = (1, 2, 3, "张三")
# 空元组
empty_tup = ()
empty_tup2 = tuple()
# 单元素元组：必须加逗号（否则视为普通变量）
t2 = ("张三",)  # 类型：tuple
t3 = ("张三")    # 类型：str（错误写法）

核心操作：仅支持查询

t = (1, 8, 77, 8, 45)

# 取值/统计（和列表一致）
print(t[2])          # 77
print(t.count(8))    # 2
print(t.index(45))   # 4
print(max(t))        # 77

# 遍历（和列表一致）
for num in t:
    print(num)

三、列表 vs 元组 核心对比

特性	列表（list）	元组（tuple）
可修改性	支持增删改查	仅支持查询，不可修改
语法符号	方括号 []	圆括号 ()
长度	可变	固定
适用场景	需动态更新的数据（如待办列表）	固定不变的数据（如坐标、配置项）

四、核心知识点总结

• 流程控制：分支用if-elif-else，循环优先选for（固定次数），while适合不确定次数；continue跳过本次，break终止当前循环。
• 输出格式：print(end="\t")可实现横向对齐，\t是制表符（等价 Tab 键），空print()手动换行。
• 列表：可变有序容器，增删改查全支持，sort()修改原列表，sorted()返回新列表（默认升序reverse=False）。
• 元组：不可变有序容器，单元素定义必须加逗号，仅支持查询操作，适合存储固定数据。