for循环：高效遍历数据

基本循环语法

作为基本循环语法，for 循环是处理序列数据最常用的工具。它能让我们对列表中的每个元素执行相同的操作，以提升整体代码的可读性和扩展性。

# 电商网站处理用户购物车
shopping_cart = ["iPhone", "MacBook", "AirPods", "Apple Watch"]
total_price = 0
prices = {"iPhone": 999, "MacBook": 1299, "AirPods": 179, "Apple Watch": 399}

for item in shopping_cart:
    item_price = prices[item]
    total_price += item_price
    print(f"添加 {item}: ${item_price}")

print(f"购物车总价: ${total_price}")
# 输出:
# 添加 iPhone: $999
# 添加 MacBook: $1299
# 添加 AirPods: $179
# 添加 Apple Watch: $399
# 购物车总价: $2876

循环的命名

良好的列表命名让循环的代码更具可读性，建议遵循单复数对应原则：

# 处理员工考勤系统
employees = ["张三", "李四", "王五", "赵六"]

for employee in employees:
    print(f"记录: {record}")
    ...

Python 的循环语句中，支持用户提交多行代码，且 Python 中并没有设计以中括号囊括所有循环内容的规则。用户只需持续保持缩进，系统会自动判定是否属于循环内容。

所以，缩进机制对于 Python循环来讲，是重中之重。

Python缩进机制

Python通过缩进确定代码块结构，是Python语法的核心特性。理解缩进规则不仅对编写正确的循环至关重要，也是对整体代码逻辑的体现。

正确的缩进结构

# 数据分析：处理学生成绩
students = ["Alice", "Bob", "Charlie", "Diana"]
scores = [85, 92, 78, 96]

print("=== 成绩分析报告 ===")
for i in range(len(students)):
    student = students[i]
    score = scores[i]
    
    # 循环内的所有代码都需要缩进
    if score >= 90:
        grade = "A"
        comment = "优秀"
    elif score >= 80:
        grade = "B"
        comment = "良好"
    else:
        grade = "C"
        comment = "及格"
    
    print(f"{student}: {score}分 ({grade}级 - {comment})")

print("报告生成完成")  # 循环外，无需缩进
# 输出:
# === 成绩分析报告 ===
# Alice: 85分 (B级 - 良好)
# Bob: 92分 (A级 - 优秀)
# Charlie: 78分 (C级 - 及格)
# Diana: 96分 (A级 - 优秀)
# 报告生成完成

如下是两种常见的缩进错误。

错误示例1：忘记缩进

products = ["手机", "电脑", "平板"]
for product in products:
# print(f"库存检查: {product}")  
# IndentationError: expected an indented block

错误示例2：逻辑缩进错误

inventory = {"手机": 50, "电脑": 30, "平板": 20}
for product, quantity in inventory.items():
    print(f"商品: {product}")
    print(f"数量: {quantity}")
    if quantity < 25:
        print("⚠️ 库存不足，需要补货")
print("库存检查完成")  # 此行只在循环结束后执行一次（正确）
# 如果上行被错误缩进到循环内，则会执行3次

所谓逻辑错误，即会出现与原始设计逻辑不同的输出样式（比如本实例中最后一句结束性的话，如果缩进，会因被归属于循环内被执行3次），而并非会像第一种缩进错误直接报错退出。

---

数值列表操作

range() 函数灵活应用

range() 函数是创建数字序列的强大工具，在数据处理中应用广泛，常见的 range 函数有三种应用形式：

• range(a)：只包含一个参数，建立 $[0,a)$ 的列表
• range(a, b)：包含两个参数，建立 $[a,b)$ 的列表
• range(a, b, c)：包含三个参数，建立步长为 c 的 $[a,b)$ 的列表

示例：

list(range(5))  # 输出: [0, 1, 2, 3, 4]
list(range(2, 6))  # 输出: [2, 3, 4, 5]
list(range(1, 10, 2))  # 输出: [1, 3, 5, 7, 9]（步长为2）
list(range(10, 0, -2)) # 输出: [10, 8, 6, 4, 2]（步长为-2）

range() 函数的重点在于左闭右开区间，即 range(a, b) 包含 a 但不包含 b，且读者需要注意的是，range() 返回的是一个可迭代对象（而非直接生成列表），节省内存。通过 list() 可显式转换为列表。

range() 函数创建列表

如果我们需要使用 range() 创建数值列表时，可使用 list() 函数将结果直接转换为列表。

for i in range(1, 6):
	print(i)			# 输出 1,2,3,4,5
for i in list(range(1, 6)):
	print(i)			# 输出 1,2,3,4,5

上述表达式中两个输出结果一致，但是上一个表达式更节省内存，因为并未转化为列表形式，而是以 “可迭代对象” 形式，以 “惰性求值” 按需生成。第二个表达式则会先通过 range() 创建一个完整的列表，并遍历整个列表。

操作数值列表

有几个简单的Python函数可以辅助用户处理简单数值列表：

找列表中的最大值、最小值以及求和：

print(f"最高价: ${max(stock_prices)}")
print(f"最低价: ${min(stock_prices)}")
print(f"平均价: ${sum(stock_prices)/len(stock_prices):.2f}")...

---

列表推导式：优雅的数据转换

列表推导式：优雅的数据转换，以及其简洁高效的方案，提供数据处理代码方式：

# 数据清洗和转换
raw_temperatures = ["23.5°C", "25.1°C", "22.8°C", "26.3°C", "24.7°C"]

# 传统方法
celsius_temps = []
for temp_str in raw_temperatures:
    celsius = float(temp_str.replace("°C", ""))
    celsius_temps.append(celsius)

# 列表推导式方法
celsius_temps = [float(temp.replace("°C", "")) for temp in raw_temperatures]

如上述代码所示，三四行代码的内容只需一行列表推导式，即可解决。

---

切片：精准的数据提取

切片是Python处理列表元素的强大工具，语法为：
$$sequence[start:end:step]$$

按照语法，切片可以精准找到用户需要的部分内容，并按照默认/指定步长进行切分抽取。

简单切片模式

# 日志分析系统
log_entries = [
    "2024-01-15 09:00:01 INFO User login successful",
    "2024-01-15 09:15:23 WARN High memory usage detected", 
    "2024-01-15 09:30:45 ERROR Database connection failed",
    "2024-01-15 09:45:12 INFO User logout",
    "2024-01-15 10:00:33 CRITICAL System overload",
    "2024-01-15 10:15:56 INFO System recovery",
    "2024-01-15 10:30:18 WARN Disk space low"
]

print("=== 日志分析 ===")
# 获取最新3条日志
print("最新3条日志:")
for log in log_entries[-3:]:
    print(f"  {log}")

print("\n前4条历史日志:")
for log in log_entries[:4]:
    print(f"  {log}")

print("\n每2条取样分析:")
for log in log_entries[::2]:
    print(f"  {log}")

print("\n倒序查看(最新在前):")
for log in log_entries[::-1]:
    print(f"  {log}")
# 输出:
# === 日志分析 ===
# 最新3条日志:
#   2024-01-15 10:00:33 CRITICAL System overload
#   2024-01-15 10:15:56 INFO System recovery  
#   2024-01-15 10:30:18 WARN Disk space low
# ...

通过切片复制列表

切片提供了创建独立数据副本的安全方法：

# 权限管理系统
admin_permissions = ["用户管理", "系统配置", "数据备份", "日志查看"]
moderator_permissions = admin_permissions[:]  # 创建副本
user_permissions = ["数据查看", "个人设置"]

# 为版主分配部分管理权限
moderator_permissions.remove("系统配置")  # 移除敏感权限
moderator_permissions.extend(user_permissions)  # 添加基础权限

# 为用户添加新权限
user_permissions.append("消息通知")

print("权限分配结果:")
print(f"管理员权限: {admin_permissions}")
print(f"版主权限: {moderator_permissions}")
print(f"用户权限: {user_permissions}")
# 输出:
# 权限分配结果:
# 管理员权限: ['用户管理', '系统配置', '数据备份', '日志查看']
# 版主权限: ['用户管理', '数据备份', '日志查看', '数据查看', '个人设置']
# 用户权限: ['数据查看', '个人设置', '消息通知']

# 错误示例：引用复制
# wrong_copy = admin_permissions  # 这只是引用，不是独立副本
# wrong_copy.append("危险操作")  # 会影响原列表

---

元组

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，但是有时我们需要创建一系列不可修改的元素，元组可满足这种需求。

Python 元组是不可变序列，非常适合存储不应被修改的配置信息和结构化数据。此外，如果你想定义只包含一个元素的元组，必须在这个元素后面加上逗号，如 (3,)

# 数据库连接配置
DATABASE_CONFIG = ("localhost", 5432, "production_db", "utf8")
API_ENDPOINTS = (
    "https://api.company.com/users",
    "https://api.company.com/orders", 
    "https://api.company.com/products",
    "https://api.company.com/analytics"
)

一个元组的简单示例：

# 学生成绩管理系统
def create_student_record(name, age, *grades):
    """创建学生记录，成绩数量可变"""
    average = sum(grades) / len(grades) if grades else 0
    return (name, age, grades, average)

# 创建学生记录
students = [
    create_student_record("张三", 20, 85, 92, 78, 90),
    create_student_record("李四", 19, 88, 85, 91),
    create_student_record("王五", 21, 92, 89, 87, 94, 96)
]

print("=== 学生成绩报告 ===")
for student in students:
    name, age, grades, average = student  # 元组解包
    print(f"姓名: {name} | 年龄: {age} | 平均分: {average:.1f}")
    print(f"  各科成绩: {', '.join(map(str, grades))}")
    print(f"  成绩等级: {'优秀' if average >= 90 else '良好' if average >= 80 else '及格'}")
    print()
# 输出:
# === 学生成绩报告 ===  
# 姓名: 张三 | 年龄: 20 | 平均分: 86.2
#   各科成绩: 85, 92, 78, 90
#   成绩等级: 良好
# 
# 姓名: 李四 | 年龄: 19 | 平均分: 88.0
#   各科成绩: 88, 85, 91
#   成绩等级: 良好
# 
# 姓名: 王五 | 年龄: 21 | 平均分: 91.6  
#   各科成绩: 92, 89, 87, 94, 96
#   成绩等级: 优秀

修改元组变量

虽然不能修改元组的元素，但可以重新赋值整个元组变量：

# 系统配置版本管理
print("=== 系统配置管理 ===")
system_config = ("v1.0", "debug", 8080, True)
print(f"初始配置: 版本={system_config[0]}, 模式={system_config[1]}, "
      f"端口={system_config[2]}, 日志={system_config[3]}")

# 升级到生产环境配置
system_config = ("v2.1", "production", 443, False)
print(f"更新配置: 版本={system_config[0]}, 模式={system_config[1]}, "
      f"端口={system_config[2]}, 日志={system_config[3]}")

# 记录配置变更历史
config_history = [
    ("v1.0", "debug", 8080, True),
    ("v1.5", "staging", 8443, True), 
    ("v2.0", "production", 443, False),
    ("v2.1", "production", 443, False)
]

print("配置变更历史:")
for i, config in enumerate(config_history):
    version, mode, port, logging = config
    print(f"  {i+1}. 版本{version}: {mode}模式, 端口{port}")
# 输出:
# === 系统配置管理 ===
# 初始配置: 版本=v1.0, 模式=debug, 端口=8080, 日志=True
# 更新配置: 版本=v2.1, 模式=production, 端口=443, 日志=False
# 配置变更历史:
#   1. 版本v1.0: debug模式, 端口8080
#   2. 版本v1.5: staging模式, 端口8443
#   3. 版本v2.0: production模式, 端口443
#   4. 版本v2.1: production模式, 端口443

---

小结

本博文展开了Python处理数据的一些核心内容：

• for循环 是处理序列数据的基础工具，配合良好的命名规范和正确的缩进结构，能够编写清晰可读的遍历代码。理解Python的缩进机制对避免语法错误至关重要。
• 数值列表操作 通过range()函数和列表推导式，我们可以高效地生成、转换和分析数字数据。内置的统计函数（max、min、sum）为数据分析提供了便利。
• 切片技术 提供了精准的数据提取能力，无论是获取特定范围的数据，还是创建安全的数据副本，切片都是不可或缺的工具。
• 元组 作为不可变序列，在保护重要配置信息、存储结构化数据方面发挥重要作用，同时支持灵活的解包操作。

这些技术在实际开发中经常组合使用，掌握它们是写好Python的基础。优秀的程序不仅要功能正确，更要结构清晰、易于维护、可扩展性强。

---

2025.09 长椿街