3、Python控制流与函数 - 从Java到Python的转变

Python控制流与函数 - 从Java到Python的转变

1. Python控制流概述

控制流是任何编程语言的核心部分。作为Java开发者，您会发现Python的控制流结构在概念上相似，但语法更加简洁。

2. 条件语句

if-elif-else语句

Python的条件语句使用if、elif(else if的缩写)和else关键字，没有括号和花括号：

# Python条件语句
age = 25

if age < 18:
    print("未成年")
elif age < 65:
    print("成年人")
else:
    print("老年人")

对比Java：

// Java条件语句
int age = 25;

if (age < 18) {
    System.out.println("未成年");
} else if (age < 65) {
    System.out.println("成年人");
} else {
    System.out.println("老年人");
}

三元运算符

Python的条件表达式（三元运算符）与Java的语法不同：

# Python条件表达式
status = "成年" if age >= 18 else "未成年"

对比Java：

// Java三元运算符
String status = age >= 18 ? "成年" : "未成年";

3. 循环结构

for循环

Python的for循环主要用于迭代序列（如列表、元组、字典等），类似于Java的增强型for循环：

# Python for循环
fruits = ["苹果", "香蕉", "樱桃"]

# 迭代列表元素
for fruit in fruits:
    print(fruit)

# 使用range()生成数字序列
for i in range(5):  # 0, 1, 2, 3, 4
    print(i)

# 指定范围
for i in range(2, 8):  # 2, 3, 4, 5, 6, 7
    print(i)

# 指定步长
for i in range(0, 10, 2):  # 0, 2, 4, 6, 8
    print(i)

对比Java：

// Java增强型for循环
List<String> fruits = Arrays.asList("苹果", "香蕉", "樱桃");

// 迭代列表元素
for (String fruit : fruits) {
    System.out.println(fruit);
}

// 传统for循环
for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

while循环

Python的while循环与Java非常相似：

# Python while循环
count = 0
while count < 5:
    print(count)
    count += 1

对比Java：

// Java while循环
int count = 0;
while (count < 5) {
    System.out.println(count);
    count++;
}

break和continue

Python的break和continue语句与Java的用法相同：

# break示例
for i in range(10):
    if i == 5:
        break  # 跳出循环
    print(i)  # 输出: 0, 1, 2, 3, 4

# continue示例
for i in range(10):
    if i % 2 == 0:
        continue  # 跳过当前迭代
    print(i)  # 输出: 1, 3, 5, 7, 9

else子句

Python的循环可以有else子句，当循环正常完成（不是通过break退出）时执行：

# 循环的else子句
for i in range(5):
    print(i)
else:
    print("循环正常完成")  # 会执行

for i in range(5):
    if i == 3:
        break
    print(i)
else:
    print("循环正常完成")  # 不会执行，因为循环被break中断

这在Java中没有直接等价物。

4. 函数定义与调用

函数调用流程图

sequenceDiagram participant 主程序 participant 函数A participant 函数B 主程序->>函数A: 调用函数A(参数) 函数A->>函数B: 调用函数B(参数) 函数B-->>函数A: 返回结果 函数A-->>主程序: 返回最终结果 Note over 主程序,函数A: Python函数调用过程

基本函数定义

Python使用def关键字定义函数：

# 基本函数定义
def greet(name):
    """这是函数的文档字符串，描述函数的功能"""
    return f"你好，{name}！"

# 调用函数
message = greet("张三")
print(message)  # 输出: 你好，张三！

对比Java：

// Java方法定义
/**
 * 这是方法的JavaDoc注释
 */
public String greet(String name) {
    return "你好，" + name + "！";
}

// 调用方法
String message = greet("张三");
System.out.println(message);

参数默认值

Python支持参数默认值，这在Java中需要通过方法重载实现：

# 带默认参数的函数
def greet(name, greeting="你好"):
    return f"{greeting}，{name}！"

print(greet("张三"))  # 输出: 你好，张三！
print(greet("李四", "早上好"))  # 输出: 早上好，李四！

关键字参数

Python允许通过参数名指定参数，不必遵循参数顺序：

def create_profile(name, age, city):
    return f"{name}, {age}岁, 来自{city}"

# 使用关键字参数
profile = create_profile(age=30, city="北京", name="王五")
print(profile)  # 输出: 王五, 30岁, 来自北京

可变参数

Python支持收集任意数量的位置参数和关键字参数：

# *args收集位置参数
def sum_all(*numbers):
    return sum(numbers)

print(sum_all(1, 2, 3, 4, 5))  # 输出: 15

# **kwargs收集关键字参数
def print_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

print_info(name="赵六", age=35, job="工程师", city="上海")

Lambda表达式

Python的lambda表达式创建匿名函数：

# lambda表达式
square = lambda x: x ** 2
print(square(5))  # 输出: 25

# 在函数式编程中使用lambda
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # 输出: [1, 4, 9, 16, 25]

even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出: [2, 4]

对比Java 8+：

// Java lambda表达式
Function<Integer, Integer> square = x -> x * x;
System.out.println(square.apply(5));  // 输出: 25

// 在Stream API中使用lambda
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squared = numbers.stream()
                              .map(x -> x * x)
                              .collect(Collectors.toList());
System.out.println(squared);  // 输出: [1, 4, 9, 16, 25]

List<Integer> evenNumbers = numbers.stream()
                                 .filter(x -> x % 2 == 0)
                                 .collect(Collectors.toList());
System.out.println(evenNumbers);  // 输出: [2, 4]

5. 函数作为一等公民

在Python中，函数是"一等公民"，可以像其他对象一样传递和操作：

# 将函数作为参数传递
def apply_operation(x, y, operation):
    return operation(x, y)

def add(a, b):
    return a + b

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

print(apply_operation(5, 3, add))  # 输出: 8
print(apply_operation(5, 3, multiply))  # 输出: 15

# 函数返回函数
def get_operation(operation_name):
    if operation_name == "add":
        return add
    elif operation_name == "multiply":
        return multiply
    else:
        return lambda a, b: None

operation = get_operation("add")
print(operation(10, 5))  # 输出: 15

6. 作用域和闭包

Python的作用域规则与Java类似，但有一些细微差别：

# 全局和局部作用域
x = 10  # 全局变量

def outer_function():
    y = 20  # 外部函数的局部变量
    
    def inner_function():
        z = 30  # 内部函数的局部变量
        print(x, y, z)  # 可以访问全局变量和外部函数的变量
    
    inner_function()

outer_function()  # 输出: 10 20 30

# 修改全局变量
def modify_global():
    global x
    x = 100

modify_global()
print(x)  # 输出: 100

闭包

Python闭包与Java的匿名内部类或lambda闭包类似：

def create_counter():
    count = 0
    
    def increment():
        nonlocal count  # 声明使用外部函数的变量
        count += 1
        return count
    
    return increment

counter = create_counter()
print(counter())  # 输出: 1
print(counter())  # 输出: 2
print(counter())  # 输出: 3

7. 装饰器

装饰器是Python的一个强大特性，用于修改函数的行为：

# 基本装饰器
def timer(func):
    import time
    
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"函数 {func.__name__} 执行时间: {end - start:.6f} 秒")
        return result
    
    return wrapper

@timer
def slow_function():
    import time
    time.sleep(1)
    return "完成"

print(slow_function())  # 输出函数执行时间和返回值

装饰器类似于Java中的注解，但更加灵活和强大。

8. 练习：控制流和函数转换

将以下Java代码转换为Python：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class NumberProcessor {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 1; i <= 20; i++) {
            numbers.add(i);
        }
        
        System.out.println("所有数字: " + numbers);
        System.out.println("偶数: " + filterNumbers(numbers, n -> n % 2 == 0));
        System.out.println("3的倍数: " + filterNumbers(numbers, n -> n % 3 == 0));
        System.out.println("偶数的平方: " + transformNumbers(
            filterNumbers(numbers, n -> n % 2 == 0),
            n -> n * n
        ));
    }
    
    public static List<Integer> filterNumbers(List<Integer> numbers, Predicate<Integer> condition) {
        List<Integer> result = new ArrayList<>();
        for (Integer number : numbers) {
            if (condition.test(number)) {
                result.add(number);
            }
        }
        return result;
    }
    
    public static List<Integer> transformNumbers(List<Integer> numbers, java.util.function.Function<Integer, Integer> transformer) {
        List<Integer> result = new ArrayList<>();
        for (Integer number : numbers) {
            result.add(transformer.apply(number));
        }
        return result;
    }
}

Python解决方案：

def main():
    # 创建数字列表
    numbers = list(range(1, 21))
    
    print(f"所有数字: {numbers}")
    print(f"偶数: {filter_numbers(numbers, lambda n: n % 2 == 0)}")
    print(f"3的倍数: {filter_numbers(numbers, lambda n: n % 3 == 0)}")
    print(f"偶数的平方: {transform_numbers(
        filter_numbers(numbers, lambda n: n % 2 == 0),
        lambda n: n * n
    )}")
    
    # 使用列表推导式的更简洁写法
    print(f"偶数(列表推导式): {[n for n in numbers if n % 2 == 0]}")
    print(f"偶数的平方(列表推导式): {[n * n for n in numbers if n % 2 == 0]}")

def filter_numbers(numbers, condition):
    result = []
    for number in numbers:
        if condition(number):
            result.append(number)
    return result

def transform_numbers(numbers, transformer):
    result = []
    for number in numbers:
        result.append(transformer(number))
    return result

if __name__ == "__main__":
    main()

9. 今日总结

• Python的控制流结构（if-elif-else、for、while）在概念上与Java相似，但语法更简洁
• Python函数使用def关键字定义，支持默认参数值、关键字参数和可变参数
• Python的lambda表达式创建匿名函数，类似于Java的lambda表达式
• Python中函数是一等公民，可以作为参数传递和从函数返回
• Python的装饰器是一个强大的特性，用于修改函数的行为

10. 明日预告

明天我们将学习Python的面向对象编程，包括类定义、继承、多态和特殊方法，以及它们与Java面向对象编程的对比。