异常教程

Python 函数（建议收藏）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战(已更新的所有项目都能学习) / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

  • 新开坑项目:《Spring AI 项目实战》 正在持续爆肝中，基于 Spring AI + Spring Boot 3.x + JDK 21...， 点击查看 ;
  • 《从零手撸：仿小红书（微服务架构）》 已完结，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;演示链接： http://116.62.199.48:7070 ;
  • 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

前言

在编程的世界里，函数就像是搭建复杂建筑的“积木块”。无论是初学者还是资深开发者，都离不开函数这一核心工具。Python 函数以其简洁的语法和强大的功能，成为代码复用与逻辑组织的重要手段。本文将从基础概念到高级技巧，逐步解析如何高效使用函数，帮助读者理解其核心原理并掌握实际应用。

函数的基本概念与语法

什么是函数？

函数是一段封装了特定功能的代码块，通过名称调用即可执行。想象你正在组装乐高，每个乐高积木块（函数）负责一个功能，例如拼接车轮或车顶。调用函数时，只需提供必要的参数（如颜色、尺寸），即可快速完成复杂任务。

函数的定义与调用

定义函数的语法如下：

def function_name(parameters):  
    """文档字符串（Docstring）"""  
    # 函数体  
    return result  # 可选

示例：计算矩形面积

def calculate_area(length, width):  
    """计算矩形面积的函数  
    参数:  
        length (float): 长度  
        width (float): 宽度  
    返回:  
        float: 面积  
    """  
    return length * width  

area = calculate_area(5.0, 3.0)  
print(f"矩形面积为: {area}")  # 输出：15.0

函数的返回值与多返回值

函数通过 return 语句返回结果。若未显式 return，则默认返回 None。Python 允许多个值返回，实际是返回一个元组：

def get_rectangle_info(length, width):  
    area = length * width  
    perimeter = 2 * (length + width)  
    return area, perimeter  # 返回元组  

area, perimeter = get_rectangle_info(4, 2)  
print(f"面积: {area}, 周长: {perimeter}")  # 输出：面积: 8, 周长: 12

参数的灵活使用

参数类型详解

函数的参数分为以下类型，可通过组合实现灵活调用：

参数类型语法形式说明
位置参数def func(a, b)参数按传递顺序匹配
默认参数def func(a, b=10)参数可省略，使用默认值
可变参数（元组）def func(*args)接收任意数量的位置参数，存储为元组
可变参数（字典）def func(**kwargs)接收任意数量的关键字参数，存储为字典

示例：多功能计算器

def calculator(num1, num2, operator="+"):  
    """执行基本运算的函数  
    参数:  
        operator (str): 运算符（+、-、*、/）  
    """  
    if operator == "+":  
        return num1 + num2  
    elif operator == "-":  
        return num1 - num2  
    # ... 其他运算符逻辑  

result = calculator(5, 3, operator="-")  
print(result)  # 输出：2

参数的进阶用法

  • 可变参数的解包：调用函数时，使用 * 或 ** 解包序列或字典：

    def sum_numbers(*nums):  
    return sum(nums)  

numbers = [1, 2, 3]  
print(sum_numbers(*numbers))  # 输出：6

  • 关键字参数优先级：默认参数与关键字参数结合时需注意顺序：

    def greeting(name, message="Hello"):  
    return f"{message}, {name}!"  

print(greeting("Alice", "Hi"))  # 输出：Hi, Alice!

函数的作用域与生命周期

作用域规则（LEGB）

Python 变量的查找遵循 LEGB 规则：

  1. Local（本地）：当前函数内定义的变量。
  2. Enclosing（闭包）：外层嵌套函数的变量。
  3. Global（全局）：模块级别定义的变量。
  4. Built-in（内置）：Python 内置的变量（如 len）。

比喻：查找变量如同在图书馆找书——先查本地书架，再查外层书柜，接着是图书馆总目录，最后是城市所有图书馆的共享资源。

示例：变量作用域的冲突

global_var = 100  

def outer():  
    outer_var = 50  
    def inner():  
        inner_var = 20  
        print(f"inner_var: {inner_var}, outer_var: {outer_var}")  
    inner()  

outer()  # 输出：inner_var: 20, outer_var: 50

全局变量与 global 关键字

若需在函数内修改全局变量，需显式声明 global：

count = 0  

def increment():  
    global count  
    count += 1  

increment()  
print(count)  # 输出：1

匿名函数与Lambda表达式

Lambda 的语法与适用场景

Lambda 是一种单行函数，适合简单逻辑场景：

def square(x):  
    return x ** 2  

lambda_square = lambda x: x ** 2

Lambda 的典型用途

  1. 排序与过滤：结合 sorted() 或 filter()：

    numbers = [3, 1, 4, 1, 5, 9]  
sorted_numbers = sorted(numbers, key=lambda x: -x)  # 降序排序  
print(sorted_numbers)  # 输出：[9, 5, 4, 3, 1, 1]

  2. 高阶函数参数：作为其他函数的参数传递：

    def apply_operation(a, b, func):  
    return func(a, b)  

result = apply_operation(5, 3, lambda x, y: x * y)  
print(result)  # 输出：15

函数装饰器与高级技巧

装饰器的定义与作用

装饰器是修改或增强函数行为的函数，通过 @decorator 语法实现。其本质是对原函数的“包裹”：

def my_decorator(func):  
    def wrapper(*args, **kwargs):  
        print("装饰器开始执行")  
        result = func(*args, **kwargs)  
        print("装饰器结束执行")  
        return result  
    return wrapper  

@my_decorator  
def say_hello():  
    print("Hello, World!")  

say_hello()

带参数的装饰器

通过嵌套函数实现装饰器参数传递：

def repeat(num_times):  
    def decorator(func):  
        def wrapper(*args, **kwargs):  
            for _ in range(num_times):  
                func(*args, **kwargs)  
        return wrapper  
    return decorator  

@repeat(3)  
def greet(name):  
    print(f"Hi, {name}!")  

greet("Bob")  # 输出三次 "Hi, Bob!"

函数的性能优化

  • 缓存机制：使用 lru_cache 装饰器缓存重复计算的结果：

    from functools import lru_cache  

@lru_cache(maxsize=None)  
def fibonacci(n):  
    if n < 2:  
        return n  
    return fibonacci(n-1) + fibonacci(n-2)

  • 生成器函数：通过 yield 实现惰性计算，节省内存：

    def even_numbers(n):  
    for num in range(n):  
        if num % 2 == 0:  
            yield num  

for num in even_numbers(10):  
    print(num, end=" ")  # 输出：0 2 4 6 8

实际案例：函数在项目中的应用

案例 1：网络请求封装

通过函数封装 HTTP 请求，提升代码复用性：

import requests  

def make_request(url, method="GET", data=None):  
    """执行HTTP请求的通用函数"""  
    try:  
        if method.upper() == "GET":  
            response = requests.get(url)  
        elif method.upper() == "POST":  
            response = requests.post(url, json=data)  
        response.raise_for_status()  
        return response.json()  
    except Exception as e:  
        return str(e)  

print(make_request("https://api.example.com/data"))

案例 2：数据预处理流水线

使用函数组合构建数据处理流程：

def load_data(file_path):  
    with open(file_path, "r") as f:  
        return f.read().splitlines()  

def clean_data(data):  
    return [line.strip() for line in data if line]  

def process_pipeline(file_path):  
    raw_data = load_data(file_path)  
    cleaned_data = clean_data(raw_data)  
    return cleaned_data  

processed = process_pipeline("data.txt")

结论

Python 函数不仅是代码复用的基石，更是构建复杂系统的关键工具。从基础语法到装饰器、生成器等高级特性，函数为开发者提供了灵活且强大的表达能力。掌握函数的设计原则（如单一职责、高内聚低耦合）和最佳实践，能显著提升代码质量和开发效率。

无论是初学者通过函数理解模块化编程，还是中级开发者利用装饰器和生成器优化性能，函数始终是 Python 开发的核心技能之一。建议读者通过实际项目不断练习，逐步深入探索函数的无限可能。

本文通过示例代码和比喻，帮助读者循序渐进地掌握 Python 函数的使用方法，助力从基础到进阶的全面提升。

最新发布

查看更多文章