python函数定义与使用实践案例

目录

• 第6篇：函数定义与使用
• 函数概述
• 函数的优点
• 函数定义
• 基本语法
• 简单函数示例
• 函数调用
• 基本调用
• 函数调用的过程
• 函数参数
• 位置参数
• 关键字参数
• 默认参数
• 可变参数
• 参数组合使用
• 返回值
• 基本返回值
• 返回多个值
• 无返回值的函数
• 变量作用域
• 局部变量
• 全局变量
• 嵌套函数中的变量作用域
• nonlocal关键字
• 匿名函数
• 基本语法
• 简单示例
• 匿名函数的应用
• 高阶函数
• 函数作为参数
• 函数作为返回值
• 递归函数
• 基本递归示例
• 递归注意事项
• 函数文档字符串
• 基本格式
• 详细的文档字符串
• 函数最佳实践
• 函数设计原则
• 函数测试
• 综合应用示例
• 总结

函数是组织好的、可重复使用的、用来实现单一或相关联功能的代码段。函数能够提高应用的模块性，和代码的重复利用率。

1. 代码重用：避免重复编写相同功能的代码
2. 模块化：将复杂问题分解为更小的部分
3. 可维护性：修改功能时只需修改函数定义
4. 可读性：使代码结构更清晰，易于理解

在Python中使用def关键字定义函数。

def 函数名(参数列表):
    """文档字符串（可选）"""
    函数体
    return 返回值  # 可选

# 定义一个简单的函数
def greet():
    """打印问候语"""
    print("Hello, World!")
# 调用函数
greet()  # 输出：Hello, World!
# 带参数的函数
def greet_person(name):
    """向指定的人问好"""
    print(f"Hello, {name}!")
greet_person("张三")  # 输出：Hello, 张三!
greet_person("李四")  # 输出：Hello, 李四!

调用函数时需要使用函数名后跟圆括号，圆括号中可以包含传递给函数的参数。

# 定义函数
def say_hello():
    print("Hello!")
# 调用函数
say_hello()  # 输出：Hello!
# 多次调用
say_hello()  # 输出：Hello!
say_hello()  # 输出：Hello!

def calculate_sum(a, b):
    """计算两个数的和"""
    result = a + b
    return result
# 调用函数并保存返回值
sum_result = calculate_sum(10, 20)
print(sum_result)  # 输出：30
# 直接使用函数返回值
print(calculate_sum(5, 15))  # 输出：20

函数参数允许我们向函数传递数据，使函数更加灵活。

def introduce(name, age):
    """介绍一个人"""
    print(f"我叫{name}，今年{age}岁")
# 按位置传递参数
introduce("张三", 25)  # 输出：我叫张三，今年25岁
# 参数顺序很重要
introduce(25, "张三")  # 输出：我叫25，今年张三岁（逻辑错误）

def introduce(name, age):
    """介绍一个人"""
    print(f"我叫{name}，今年{age}岁")
# 使用关键字参数，顺序可以改变
introduce(age=25, name="张三")  # 输出：我叫张三，今年25岁
# 混合使用位置参数和关键字参数
introduce("李四", age=30)  # 输出：我叫李四，今年30岁
# 注意：位置参数必须在关键字参数之前
# introduce(age=30, "李四")  # 错误！

def greet(name, greeting="Hello"):
    """问候函数，默认问候语为Hello"""
    print(f"{greeting}, {name}!")
# 使用默认参数
greet("张三")  # 输出：Hello, 张三!
# 覆盖默认参数
greet("李四", "你好")  # 输出：你好, 李四!
greet("王五", greeting="Hi")  # 输出：Hi, 王五!

# *args：接收任意数量的位置参数
def sum_all(*args):
    """计算所有参数的和"""
    total = 0
    for num in args:
        total += num
    return total
print(sum_all(1, 2, 3))        # 输出：6
print(sum_all(1, 2, 3, 4, 5))  # 输出：15
# **kwargs：接收任意数量的关键字参数
def print_info(**kwargs):
    """打印所有关键字参数"""
    for key, value in kwargs.items():
        print(f"{key}: {value}")
print_info(name="张三", age=25, city="北京")
# 输出：
# name: 张三
# age: 25
# city: 北京

def complex_function(a, b=10, *args, **kwargs):
    """复杂的参数组合示例"""
    print(f"位置参数a: {a}")
    print(f"默认参数b: {b}")
    print(f"可变位置参数args: {args}")
    print(f"可变关键字参数kwargs: {kwargs}")
# 调用函数
complex_function(1, 2, 3, 4, 5, name="张三", age=25)
# 输出：
# 位置参数a: 1
# 默认参数b: 2
# 可变位置参数args: (3, 4, 5)
# 可变关键字参数kwargs: {'name': '张三', 'age': 25}

函数可以使用return语句返回值。

def add(a, b):
    """计算两个数的和"""
    return a + b
result = add(10, 20)
print(result)  # 输出：30
# 函数可以返回任意类型的值
def get_user_info():
    """返回用户信息"""
    return {"name": "张三", "age": 25}
user = get_user_info()
print(user)  # 输出：{'name': '张三', 'age': 25}

def calculate(a, b):
    """计算两个数的和与积"""
    sum_result = a + b
    product_result = a * b
    return sum_result, product_result
# 接收多个返回值
sum_val, product_val = calculate(3, 4)
print(f"和：{sum_val}，积：{product_val}")  # 输出：和：7，积：12
# 也可以作为元组接收
result = calculate(3, 4)
print(result)  # 输出：(7, 12)

def print_message(message):
    """打印消息"""
    print(message)
    # 没有return语句，隐式返回None
result = print_message("Hello")
print(result)  # 输出：None

变量的作用域决定了变量在程序中的可见范围。

def my_function():
    """演示局部变量"""
    local_var = "我是局部变量"
    print(local_var)
my_function()
# print(local_var)  # 错误：局部变量在函数外部不可访问

global_var = "我是全局变量"
def access_global():
    """访问全局变量"""
    print(global_var)  # 可以访问全局变量
access_global()
print(global_var)  # 在全局作用域也可以访问
def modify_global():
    """修改全局变量"""
    global global_var  # 声明使用全局变量
    global_var = "我被修改了"
    print(global_var)
modify_global()
print(global_var)  # 输出：我被修改了

def outer_function():
    """外层函数"""
    outer_var = "外层变量"
    def inner_function():
        """内层函数"""
        inner_var = "内层变量"
        print(f"在内层函数中访问外层变量：{outer_var}")
        print(f"内层变量：{inner_var}")
    inner_function()
    # print(inner_var)  # 错误：内层变量在外层函数中不可访问
outer_function()

def outer_function():
    """演示nonlocal关键字"""
    x = 10
    def inner_function():
        nonlocal x  # 声明使用外层函数的变量
        x += 5
        print(f"内层函数中的x：{x}")
    print(f"调用内层函数前的x：{x}")
    inner_function()
    print(f"调用内层函数后的x：{x}")
outer_function()
# 输出：
# 调用内层函数前的x：10
# 内层函数中的x：15
# 调用内层函数后的x：15

匿名函数是不带名称的函数，使用lambda关键字定义。

lambda 参数: 表达式

# 定义匿名函数
square = lambda x: x ** 2
print(square(5))  # 输出：25
# 匿名函数用于简单计算
add = lambda x, y: x + y
print(add(3, 4))  # 输出：7
# 匿名函数用于字符串操作
upper_case = lambda s: s.upper()
print(upper_case("hello"))  # 输出：HELLO

# 与内置函数结合使用
numbers = [1, 2, 3, 4, 5]
# 使用map函数和lambda
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # 输出：[1, 4, 9, 16, 25]
# 使用filter函数和lambda
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出：[2, 4]
# 使用sorted函数和lambda
students = [("张三", 85), ("李四", 90), ("王五", 78)]
sorted_students = sorted(students, key=lambda x: x[1])
print(sorted_students)  # 输出：[('王五', 78), ('张三', 85), ('李四', 90)]

高阶函数是接受函数作为参数或返回函数的函数。

def apply_operation(a, b, operation):
    """应用指定的操作"""
    return operation(a, b)
def add(x, y):
    """加法函数"""
    return x + y
def multiply(x, y):
    """乘法函数"""
    return x * y
# 将函数作为参数传递
result1 = apply_operation(5, 3, add)
result2 = apply_operation(5, 3, multiply)
print(result1)  # 输出：8
print(result2)  # 输出：15

def create_multiplier(n):
    """创建乘法器函数"""
    def multiplier(x):
        return x * n
    return multiplier
# 创建不同的乘法器
double = create_multiplier(2)
triple = create_multiplier(3)
print(double(5))   # 输出：10
print(triple(5))   # 输出：15

递归函数是调用自身的函数，必须有终止条件。

def factorial(n):
    """计算阶乘"""
    # 基础情况：递归终止条件
    if n == 0 or n == 1:
        return 1
    # 递归情况
    else:
        return n * factorial(n - 1)
print(factorial(5))  # 输出：120
def fibonacci(n):
    """计算斐波那契数列"""
    # 基础情况
    if n <= 1:
        return n
    # 递归情况
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)
print(fibonacci(6))  # 输出：8

import sys
# 查看递归限制
print(sys.getrecursionlimit())  # 通常为1000
# 设置递归限制（谨慎使用）
# sys.setrecursionlimit(2000)

文档字符串（docstring）用于描述函数的功能、参数和返回值。

def calculate_area(length, width):
    """
    计算矩形面积
    参数:
        length (float): 矩形的长度
        width (float): 矩形的宽度
    返回:
        float: 矩形的面积
    示例:
        >>> calculate_area(5, 3)
        15
    """
    return length * width
# 查看函数文档
print(calculate_area.__doc__)
help(calculate_area)

def complex_calculation(x, y, operation="add"):
    """
    执行复杂的数学计算
    这个函数可以根据指定的操作对两个数进行计算。
    参数:
        x (float): 第一个操作数
        y (float): 第二个操作数
        operation (str, optional): 操作类型，可选值为"add", "subtract", 
                                  "multiply", "divide"。默认为"add"
    返回:
        float: 计算结果
    异常:
        ValueError: 当操作类型不支持时抛出
        ZeroDivisionError: 当除数为0时抛出
    示例:
        >>> complex_calculation(10, 5, "add")
        15.0
        >>> complex_calculation(10, 5, "multiply")
        50.0
    """
    operations = {
        "add": lambda a, b: a + b,
        "subtract": lambda a, b: a - b,
        "multiply": lambda a, b: a * b,
        "divide": lambda a, b: a / b
    }
    if operation not in operations:
        raise ValueError(f"不支持的操作类型: {operation}")
    if operation == "divide" and y == 0:
        raise ZeroDivisionError("除数不能为0")
    return operations[operation](x, y)

# 1. 函数应该只做一件事，并且做好
def calculate_sum(numbers):
    """计算数字列表的和"""
    return sum(numbers)
def find_maximum(numbers):
    """找出数字列表中的最大值"""
    return max(numbers)
# 2. 函数名应该清晰表达函数的功能
def is_even(number):
    """判断数字是否为偶数"""
    return number % 2 == 0
# 3. 参数应该有合理的默认值
def create_greeting(name, greeting="Hello"):
    """创建问候语"""
    return f"{greeting}, {name}!"
# 4. 函数应该有适当的文档字符串
def convert_temperature(temp, from_unit, to_unit):
    """
    转换温度单位
    参数:
        temp (float): 温度值
        from_unit (str): 源单位 ("C" 或 "F")
        to_unit (str): 目标单位 ("C" 或 "F")
    返回:
        float: 转换后的温度值
    """
    if from_unit == "C" and to_unit == "F":
        return temp * 9/5 + 32
    elif from_unit == "F" and to_unit == "C":
        return (temp - 32) * 5/9
    else:
        return temp
# 5. 处理异常情况
def safe_divide(a, b):
    """安全除法，处理除零异常"""
    try:
        return a / b
    except ZeroDivisionError:
        print("错误：除数不能为0")
        return None

def test_functions():
    """测试函数功能"""
    # 测试计算函数
    assert calculate_sum([1, 2, 3, 4]) == 10
    assert is_even(4) == True
    assert is_even(5) == False
    # 测试温度转换
    assert abs(convert_temperature(0, "C", "F") - 32) < 0.01
    assert abs(convert_temperature(32, "F", "C") - 0) < 0.01
    print("所有测试通过！")
# 运行测试
test_functions()

# 学生成绩管理系统
class StudentGradeManager:
    """学生成绩管理器"""
    def __init__(self):
        self.students = []
    def add_student(self, name, scores):
        """添加学生"""
        student = {
            "name": name,
            "scores": scores,
            "average": self.calculate_average(scores)
        }
        self.students.append(student)
    def calculate_average(self, scores):
        """计算平均分"""
        if not scores:
            return 0
        return sum(scores) / len(scores)
    def get_grade(self, average):
        """根据平均分获取等级"""
        if average >= 90:
            return "优秀"
        elif average >= 80:
            return "良好"
        elif average >= 70:
            return "中等"
        elif average >= 60:
            return "及格"
        else:
            return "不及格"
    def display_report(self):
        """显示成绩报告"""
        print("学生成绩报告")
        print("-" * 40)
        for student in self.students:
            print(f"姓名: {student['name']}")
            print(f"成绩: {student['scores']}")
            print(f"平均分: {student['average']:.2f}")
            print(f"等级: {self.get_grade(student['average'])}")
            print("-" * 40)
# 使用示例
manager = StudentGradeManager()
manager.add_student("张三", [85, 90, 78, 92])
manager.add_student("李四", [76, 88, 82, 79])
manager.display_report()

本篇教程详细介绍了Python函数的定义与使用，包括函数参数、返回值、变量作用域、匿名函数、高阶函数、递归函数等重要概念。我们还学习了如何编写清晰的文档字符串和遵循函数设计的最佳实践。

函数是Python编程的核心概念之一，掌握函数的使用对于编写模块化、可维护的代码至关重要。

到此这篇关于python 函数定义与使用实践记录的文章就介绍到这了,更多相关python 函数定义与使用内容请搜索风君子博客以前的文章或继续浏览下面的相关文章希望大家以后多多支持风君子博客！

您可能感兴趣的文章:

• python 包(模块 函数 类 定义 导入)使用详解
• Python学习之函数的定义与使用详解
• Python pandas自定义函数的使用方法示例
• Python基础之函数的定义与使用示例
• 小议Python中自定义函数的可变参数的使用及注意点
• Python过滤函数filter()使用自定义函数过滤序列实例