Python控制流与函数编程：从零基础到实践-优快云博客

文章目录

Python控制流与函数编程：从零基础到实践

Python控制流与函数编程：从零基础到实践

一、控制流：程序执行的逻辑骨架

控制流是程序根据条件或规则决定执行路径的机制，核心包括条件语句和循环结构，是实现复杂逻辑的基础。

1. 条件语句（if-else）

条件语句通过判断表达式的真假，决定执行不同代码块，核心语法为if-elif-else。

基本语法

score = 85

if score >= 90:
    print("优秀")
elif score >= 80:  # 多条件分支
    print("良好")
elif score >= 60:
    print("及格")
else:  # 所有条件不满足时执行
    print("不及格")

使用技巧

简化条件判断：利用Python的"短路特性"简化逻辑，例如：

# 替代冗长的if-else
result = "及格" if score >= 60 else "不及格"

多条件合并：用and/or合并相关条件，避免嵌套过深：

# 清晰表达"年龄在18-60岁之间且有身份证"
if 18 <= age <= 60 and has_id:
  print("可办理")

最佳实践

条件分支顺序遵循"先特殊后一般"，避免后续条件被忽略（例如先判断score == 100再判断score >= 90）。
嵌套层数不超过3层，过深的嵌套会降低可读性，可拆分为函数优化。

注意事项

缩进是Python的语法要求，同一代码块必须保持一致缩进（建议4个空格）。
避免在条件中执行复杂表达式，可提前计算并赋值给变量，提高可读性：

# 不推荐：条件中包含复杂计算
if (x + y) * 2 > 100 and len(list_data) < 5:
  ...
  
# 推荐：提前计算
sum_double = (x + y) * 2
list_len = len(list_data)
if sum_double > 100 and list_len < 5:
  ...

2. 循环结构

循环用于重复执行代码块，Python提供for（遍历序列）和while（条件循环）两种方式。

（1）for循环：遍历可迭代对象

适用于已知迭代次数的场景（如列表、字符串、字典等），语法为for 变量 in 可迭代对象。

基础示例：

# 遍历列表
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(f"I like {fruit}")

# 遍历字典（默认遍历key）
person = {"name": "Alice", "age": 30}
for key in person:
    print(f"{key}: {person[key]}")

# 带索引遍历（用enumerate）
for index, fruit in enumerate(fruits, start=1):  # start指定索引起始值
    print(f"{index}. {fruit}")

进阶技巧：

用range()生成数字序列：for i in range(1, 10, 2)（生成1-9的奇数）。
用zip()同时遍历多个序列：

names = ["Alice", "Bob"]
ages = [30, 25]
for name, age in zip(names, ages):
  print(f"{name} is {age} years old")

（2）while循环：基于条件的循环

适用于未知迭代次数，需根据条件终止的场景，语法为while 条件表达式。

基础示例：

# 计算1-100的和
total = 0
i = 1
while i <= 100:
    total += i
    i += 1  # 必须手动更新条件变量，避免死循环
print(f"Sum: {total}")

循环控制：

break：立即终止当前循环，跳出循环体。
continue：跳过本次循环剩余代码，直接进入下一次循环。

# 寻找第一个能被7整除的数（找到后break）
for num in range(1, 100):
  if num % 7 == 0:
      print(f"First multiple of 7: {num}")
      break

最佳实践

遍历序列优先用for循环，更简洁且不易出错（无需手动控制索引）。
避免在循环中修改迭代对象（如列表增删元素），可能导致漏遍历或重复遍历：

# 错误示例：遍历中删除元素导致漏项
nums = [1, 2, 3, 4]
for num in nums:
  if num % 2 == 0:
      nums.remove(num)  # 实际会漏删4
print(nums)  # 结果：[1, 3]（正确应删除2和4）

循环逻辑复杂时，可拆分为函数，例如将"处理单个元素"的逻辑封装，循环中仅调用函数。

注意事项

while循环必须确保条件最终会为False，否则会陷入死循环（可用Ctrl+C强制终止）。
大规模数据迭代时，优先使用生成器（yield）或列表推导式，减少内存占用。

二、函数：代码复用与逻辑封装

函数是封装特定功能的代码块，通过def定义，可接收参数并返回结果，是模块化编程的核心。

1. 函数的基本定义与调用

def add(a, b):
    """返回两个数的和（文档字符串：描述函数功能）"""
    return a + b

# 调用函数
result = add(3, 5)
print(result)  # 输出：8

参数类型

位置参数：必须按顺序传递，数量与定义一致。
关键字参数：调用时指定参数名，可打乱顺序：

def greet(name, age):
  print(f"Hello {name}, you are {age} years old")
  
greet(age=30, name="Alice")  # 关键字参数调用，顺序无关

默认参数：定义时指定默认值，调用时可省略：

def greet(name, age=18):  # age默认值为18
  print(f"Hello {name}, you are {age} years old")
  
greet("Bob")  # 输出：Hello Bob, you are 18 years old

可变参数：接收任意数量的参数，用*args（元组）和**kwargs（字典）表示：

def sum_all(*args):  # *args接收任意个位置参数，打包为元组
  return sum(args)
  
print(sum_all(1, 2, 3, 4))  # 输出：10

def print_info(** kwargs):  # **kwargs接收任意个关键字参数，打包为字典
  for key, value in kwargs.items():
      print(f"{key}: {value}")
      
print_info(name="Alice", age=30)  # 输出：name: Alice; age: 30

2. 函数的高级特性

（1）嵌套函数与作用域

函数内部可定义函数，内部函数可访问外部函数的变量（闭包）：

def outer(x):
    def inner(y):
        return x + y  # inner访问outer的变量x
    return inner  # 返回内部函数

add5 = outer(5)
print(add5(3))  # 输出：8（等价于5+3）

（2）函数作为参数或返回值

Python中函数是"一等公民"，可作为参数传递或作为返回值：

def apply_func(func, x, y):
    return func(x, y)

def multiply(a, b):
    return a * b

print(apply_func(multiply, 3, 4))  # 输出：12（传递multiply函数作为参数）

3. 使用技巧

单一职责原则：一个函数只做一件事，避免"万能函数"（例如不要在一个函数中同时处理数据读取、清洗和分析）。
参数默认值陷阱：默认参数为可变对象（如列表、字典）时，会在函数定义时初始化一次，后续调用会共享该对象：

# 错误示例：默认参数为可变对象导致意外结果
def add_item(item, items=[]):
  items.append(item)
  return items
  
print(add_item(1))  # [1]
print(add_item(2))  # [1, 2]（预期应为[2]）

# 正确写法：用None作为默认值
def add_item(item, items=None):
  if items is None:
      items = []
  items.append(item)
  return items

文档字符串：用"""定义函数说明，便于help()查询和自动生成文档。

最佳实践

函数名使用小写字母+下划线（snake_case），清晰表达功能（如calculate_average而非func1）。
函数长度控制在20-30行内，过长则考虑拆分。
避免使用全局变量，通过参数传递和返回值交互数据，增强函数独立性。

三、匿名函数（lambda）：简洁的单行函数

lambda是一种无需定义名称的"匿名函数"，语法为lambda 参数: 表达式，适用于简单逻辑的临时函数。

基本用法

# 等价于def add(a, b): return a + b
add = lambda a, b: a + b
print(add(3, 5))  # 输出：8

典型应用场景

结合高阶函数：与map()、filter()、sorted()等配合，简化代码：

# 用lambda排序字典列表（按age字段）
people = [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]
sorted_people = sorted(people, key=lambda x: x["age"])
print(sorted_people)  # 按age升序排列

# 用lambda过滤偶数
nums = [1, 2, 3, 4, 5]
even_nums = list(filter(lambda x: x % 2 == 0, nums))
print(even_nums)  # [2, 4]

临时简单逻辑：替代仅使用一次的简单函数，避免代码冗余。

注意事项

lambda仅能包含一个表达式，不能有循环、条件语句（除非用三元表达式）等复杂逻辑：

# 允许：三元表达式
max_num = lambda a, b: a if a > b else b

# 不允许：多行逻辑
# lambda a, b:
#     if a > b:
#         return a
#     else:
#         return b  # 语法错误