开发者

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

开发者 https://www.devze.com 2025-11-05 10:12 出处：网络 作者： wudl5566
目录第6篇：函数定义与使用函数概述函数的优点函数定义基本语法简单函数示例函数调用基本调用函数调用的过程函数参数位置参数关键字参数默认参数可变参数参数组合使用返回值基本返回值返回多个值无返回值的函数变量作
相关专题：python 函数使用
目录
  • 第6篇：函数定义与使用
    • 函数概述
      • 函数的优点
    • 函数定义
      • 基本语法
      • 简单函数示例
    • 函数调用
      • 基本调用
      • 函数调用的过程
    • 函数参数
      • 位置参数
      • 关键字参数
      • 默认参数
      • 可变参数
      • 参数组合使用
    • 返回值
      • 基本返回值
      • 返回多个值
      • 无返回值的函数
    • 变量作用域
      • 局部变量
      • 全局变量
      • 嵌套函数中的变量作用域
      • nonlocal关键字
    • 匿名函数
      • 基本语法
      • 简单示例
      • 匿名函数的应用
    • 高阶函数
      • 函数作为参数
      • 函数作为返回值
    • 递归函数
      • 基本递编程归示例
      • 递归注意事项
    • 函数文档字符串
      • 基本格式
      • 详细的文档字符串
    • 函数最佳实践
      • 函数设计原则
      • 函数测试
    • 综合应用示例
      • 总结

      第6篇：函数定义与使用

      函数概述

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

      函数的优点

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

      函数定义

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

      基本语法

      def 函数名(参数列表):
    """文档字符串（可选）"""
    函数体
    re编程客栈turn 返回值  # 可选

      简单函数示例

      # 定义一个简单的函数
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：接收任意数量www.devze.com的关键字参数
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}

      返回值

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

      基本返回值

      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()

      nonlocal关键字

      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_nuhttp://www.devze.commbers)  # 输出：[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 函数定义与使用内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！

      0

      上一篇:

      :下一篇

      更多 开发 相关资讯：

      精彩评论

      暂无评论...
      登录 注册
      Qedev.com
      验证码 换一张
      取 消

      关注公众号

      热门标签

      图文推荐

      SpringBoot Maven的操作与配置图文教程

      SpringBoot Maven的操作与配置图文教程
      springboot集成activiti全过程

      springboot集成activiti全过程
      HttpServletRequest参数丢失问题及解决

      HttpServletRequest参数丢失问题及解决
      Java21之字符串模板的使用小结

      Java21之字符串模板的使用小结
      Golang中Context.WithCancel 的实战指南

      Golang中Context.WithCancel 的实战指南
      Golang单元测试、go协程和管道示例详解

      Golang单元测试、go协程和管道示例详解
      Golang中web参数校验的实现

      Golang中web参数校验的实现
      轻松管理多个Go版本之g工具安装与使用方法

      轻松管理多个Go版本之g工具安装与使用方法

      开发者开发者网给大家分享系统运维,大数据运维,云计算,编程开发技巧,路由交换,运维和开发相关的资讯及技术文章，同时StackOverflow中文社区，知识经验交流分享。

      法律声明：本站内容均为网友上传，网站举办方负责审核和监督，如存在版权或非法内容，欢迎举报，我们将尽快予以删除。邮箱：devze@qq.com

      Copyright © 2018-2020 开发者. All rights reserved. Powered by 开发者ICP备案号: 京ICP备10032868号-9