Python学习历程——组织结构（包含for、if、while等等）

本章概述

本章将围绕Python中的组织结构进行讲解，对于组织架构的概念，实际上就是程序中代码的一些编写结构，主要包含for循环、if判断、while循环等，我们来详细解释。

一、程序的组织架构

1. 基本概念

💡 不要对这个概念有太多的困惑，代码我们一直在写，只不过很少从宏观的角度去看代码的结构，其实这就是对代码的结构进行了一个划分，可以分为顺序结构、选择/分支结构、循环结构，只要是代码都离不开这几个部分。

💡 当然，这只是从宏观角度看的几个大分类，还有很多的小分类我们在后续依次说明。

2. 三种分类

1. 顺序结构

2. 选择/分支结构

3. 循环结构

二、顺序结构（没那么简单哦）

1. 说明

💡 这是程序中最简单的一种实现方式，就是按照代码书写的顺序依次执行代码，得到结果，对于这种简单的示例我们不予说明，从严格意义上来说，真正的顺序结构指的是程序按照书写的顺序执行，得到的结果也得是依次得到的，这里要说的是，什么代码会破坏这种严格结构，又怎么能避免。

• 严格意义上的顺序结构是指：代码严格按照其书写的物理顺序，同步地、阻塞式地逐行执行。每一行代码的执行都必须等待前一行代码完全完成后才能开始。

2. 引入异步请求后的“非顺序”行为

2.1 同步I/O操作（表面顺序，实际系统级等待）

import requests
import timeprint("开始请求数据")  # 1# 同步网络请求 - 这里会发生阻塞
start = time.time()
response = requests.get('https://httpbin.org/delay/1')  # 模拟延迟1秒的API
data = response.json()  # 2print(f"收到响应: {data}")  # 3
print(f"请求耗时: {time.time() - start:.2f}秒")  # 4print("继续其他工作")  # 5

关键特征：

• 完全阻塞：for循环计算期间，整个程序被阻塞，无法做任何其他事情

• 严格顺序：每一行代码必须等待前一行完全完成

• 同步执行：执行顺序与代码书写顺序完全一致

2.2 真正的异步并发（asyncio）

import asyncio
import aiohttp
import timeasync def fetch_data(session, url, name):print(f"开始请求 {name}")  # 注意这里的执行顺序!start = time.time()async with session.get(url) as response:data = await response.json()elapsed = time.time() - startprint(f"{name} 完成, 耗时: {elapsed:.2f}秒")return dataasync def main():print("程序启动")async with aiohttp.ClientSession() as session:# 创建多个异步任务tasks = [fetch_data(session, 'https://httpbin.org/delay/1', '任务1'),fetch_data(session, 'https://httpbin.org/delay/2', '任务2'), fetch_data(session, 'https://httpbin.org/delay/1', '任务3')]print("所有任务已创建，开始并发执行")results = await asyncio.gather(*tasks)print("所有任务完成")print("程序结束")# 运行异步程序
asyncio.run(main())

简单聊聊这个例子，从代码来看没有什么难度，只是我们正常的异步请求打破严格的顺序结构，这在Java和JavaScript中体现的很多，大多数时候都是这么写的，只不过在有些时候，我们需要强行实现同步结构来达到我们的目的。

三、分支结构

1. 单分支结构（if）

语法

if condition:# 当condition为True时执行的语句statement1statement2

示例

age = 20
if age >= 18:print("您已成年，可以进入")print("欢迎光临！")print("程序继续执行")  # 这行总是会执行

2. 双分支结构（if-else）

语法

if condition:# 当condition为True时执行true_block
else:# 当condition为False时执行  false_block

示例

score = 85
if score >= 60:print("恭喜！您及格了")grade = "合格"
else:print("很遗憾，您需要补考")grade = "不合格"print(f"最终等级: {grade}")

3. 多分支结构（if-elif-else）

语法

if condition1:# condition1为True时执行block1
elif condition2:# condition1为False且condition2为True时执行block2
elif condition3:# 前两个都为False且condition3为True时执行block3
else:# 所有条件都为False时执行default_block

示例

score = 78if score >= 90:grade = "A"print("优秀！")
elif score >= 80:grade = "B" print("良好")
elif score >= 70:grade = "C"print("中等")
elif score >= 60:grade = "D"print("及格")
else:grade = "F"print("不及格")print(f"您的成绩等级是: {grade}")

4. 逻辑运算符组合（and 和 or等）

# 使用 and, or, not 组合条件
age = 25
has_license = True
has_insurance = Trueif age >= 18 and has_license:if has_insurance:print("可以租车")else:print("需要购买保险")
else:print("不符合租车条件")# 更简洁的写法
if age >= 18 and has_license and has_insurance:print("可以租车")
elif age >= 18 and has_license and not has_insurance:print("需要购买保险")
else:print("不符合租车条件")

5. 成员运算符

# 使用 in 检查成员关系
fruits = ['apple', 'banana', 'orange']
user_input = input("请输入水果名称: ")if user_input in fruits:print(f"我们有{user_input}")
else:print(f"抱歉，没有{user_input}")# 字符串检查
email = "[e-mail]"
if "@" in email and "." in email:print("邮箱格式基本正确")
else:print("邮箱格式错误")

6. 三元表达式（稍有不同）

语法

• Python：结果 if 条件 else 结果

• Java：条件 ? 结果 : 结果

示例

• Python

result = "通过" if score >= 60 else "不通过"

• Java

String result = score >= 60 ? "通过" : "不通过";

7. 字典映射（实际就是Map）

# 传统if-elif写法
def get_weather_advice(weather):if weather == "sunny":return "记得涂防晒霜"elif weather == "rainy":return "带伞"elif weather == "windy":return "多穿点衣服"elif weather == "snowy":return "小心路滑"else:return "享受这一天吧"# 字典映射写法
def get_weather_advice_dict(weather):advice_map = {"sunny": "记得涂防晒霜","rainy": "带伞", "windy": "多穿点衣服","snowy": "小心路滑"}return advice_map.get(weather, "享受这一天吧")# 使用
weather = "rainy"
print(f"建议: {get_weather_advice_dict(weather)}")

8. 新模式匹配 match-case（Python 3.10+ 新模式匹配）

实际就是Java中的switch

# 仅Python 3.10+ 支持
def handle_http_status(code):match code:case 200 | 201:return "成功"case 400:return "请求错误"case 401 | 403:return "认证失败"case 404:return "资源未找到"case 500 | 502 | 503:return "服务器错误"case _:return f"未知状态码: {code}"# 使用
print(handle_http_status(200))  # 输出: 成功
print(handle_http_status(404))  # 输出: 资源未找到

四、循环结构

1. 核心循环类型：

• for 循环：基于序列的遍历，已知迭代次数

• while 循环：基于条件判断，未知迭代次数

• 循环控制语句：break, continue, pass 用于精细控制循环流程

2. for循环

语法

for element in iterable:# 循环体 - 对每个element执行的操作statements

示例

# 1. 遍历列表
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:print(f"我喜欢吃{fruit}")# 2. 遍历字符串
word = "Python"
for char in word:print(char, end=" ")  # 输出: P y t h o n# 3. 遍历字典
person = {"name": "Alice", "age": 25, "city": "Beijing"}
for key in person:print(f"{key}: {person[key]}")# 更好的字典遍历方式
for key, value in person.items():print(f"{key}: {value}")# 4. 遍历数字序列 - range()函数
print("\n数字序列:")
for i in range(5):          # 0到4print(i, end=" ")print()
for i in range(2, 6):       # 2到5print(i, end=" ")print()  
for i in range(0, 10, 2):   # 0到8，步长为2print(i, end=" ")

这里重点要注意的是，Python中的for循环可以直接遍历对象、数组、字符串，而且写法基本一致，从理解上来讲确实更加容易入手和简单，同时指定次数循环也显得比较容易理解。

关于如何获取数组中的索引和enumerate（）函数

fruits = ["apple", "banana", "cherry"]# 传统方式（不推荐）
index = 0
for fruit in fruits:print(f"索引{index}: {fruit}")index += 1# 现代方式 - enumerate()
for index, fruit in enumerate(fruits):print(f"索引{index}: {fruit}")# 指定起始索引
for index, fruit in enumerate(fruits, start=1):print(f"第{index}个水果: {fruit}")

3. while循环

基础while循环

# 1. 计数器控制
count = 0
while count < 5:print(f"计数: {count}")count += 1  # 重要：更新循环条件# 2. 用户输入控制
total = 0
while True:  # 无限循环，需要内部breaknumber = input("请输入数字（输入'quit'退出）: ")if number == 'quit':breaktotal += float(number)print(f"当前总和: {total}")# 3. 条件验证
password = ""
while password != "secret123":password = input("请输入密码: ")if password != "secret123":print("密码错误，请重试！")
print("登录成功！")

复杂while循环应用

# 游戏循环示例
import randomtarget_number = random.randint(1, 100)
attempts = 0
max_attempts = 7print("猜数字游戏开始！目标数字在1-100之间")while attempts < max_attempts:guess = int(input(f"第{attempts + 1}次尝试，请输入你的猜测: "))attempts += 1if guess == target_number:print(f"恭喜！你在第{attempts}次猜对了！")breakelif guess < target_number:print("太小了，再大一点")else:print("太大了，再小一点")
else:# while-else结构：循环正常结束（非break退出）时执行print(f"游戏结束！正确答案是: {target_number}")

4. 循环控制语句

break - 立即退出循环

# 在列表中查找特定元素
numbers = [1, 3, 5, 7, 9, 2, 4, 6, 8]
target = 5
found = Falsefor num in numbers:print(f"检查: {num}")if num == target:print("找到目标！")found = Truebreak  # 找到后立即退出，不再检查后续元素if not found:print("未找到目标")

continue - 跳过当前迭代

# 只处理奇数
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]print("奇数:")
for num in numbers:if num % 2 == 0:  # 如果是偶数continue      # 跳过本次循环的剩余部分print(num, end=" ")# 输出: 1 3 5 7 9

pass - 空操作占位符

# 框架搭建时使用
for i in range(10):if i % 2 == 0:pass  # 暂时不处理，保持语法完整else:print(f"处理奇数: {i}")# 在类或函数定义中也常用
def future_feature():pass  # 待实现

5. 其余用法扩展

列表推导式

# 传统方式
squares = []
for x in range(10):squares.append(x ** 2)# 列表推导式
squares = [x ** 2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]# 带条件的列表推导式
even_squares = [x ** 2 for x in range(10) if x % 2 == 0]
print(even_squares)  # [0, 4, 16, 36, 64]

生成器表达式（Generator Expression）

适用于大数据量

# 列表推导式 - 立即创建完整列表
big_list = [x * 2 for x in range(1000000)]  # 占用大量内存# 生成器表达式 - 按需生成
big_generator = (x * 2 for x in range(1000000))  # 内存友好# 使用
for value in big_generator:if value > 100:  # 可能只需要前几个值breakprint(value)

map()、filter() 函数式编程

numbers = [1, 2, 3, 4, 5]# map() 替代转换循环
squares = list(map(lambda x: x ** 2, numbers))# filter() 替代过滤循环
evens = list(filter(lambda x: x % 2 == 0, numbers))# 与传统循环对比
squares_traditional = []
for x in numbers:squares_traditional.append(x ** 2)

解释一下上一段代码：

1. map(lambda x: x ** 2, numbers) 创建一个map对象
2. lambda x: x ** 2 对numbers中每个元素执行平方运算
3. list() 将map对象转换为列表

这是Java中非常经典的函数表达式，当然在Python中，还有基于此更加简洁的写法（列表推导式）
当然我个人不喜欢这种写法，可读性太差

# map() 的列表推导式替代
squares = [x ** 2 for x in numbers]# filter() 的列表推导式替代  
evens = [x for x in numbers if x % 2 == 0]# map() + filter() 组合的列表推导式替代
squared_evens = [x ** 2 for x in numbers if x % 2 == 0]

itertools 模块

提供高效的迭代工具。

import itertools# 无限循环
counter = itertools.count(1)
for i in range(5):print(next(counter))  # 1, 2, 3, 4, 5# 排列组合
letters = ['A', 'B', 'C']
combinations = list(itertools.combinations(letters, 2))
print(combinations)  # [('A', 'B'), ('A', 'C'), ('B', 'C')]

五、总结

💡 这一章相对来说比较简单，只是有几个知识点需要注意以下，好了，下一章我们继续，关于Python中的序列（也就是Java中的集合），只不过要比Java简单许多。