【Python-Day 16】代码复用基石：详解 Python 函数的定义与调用

大模型铲屎官2025-05-22 22:03

Langchain系列文章目录

01-玩转LangChain：从模型调用到Prompt模板与输出解析的完整指南
02-玩转 LangChain Memory 模块：四种记忆类型详解及应用场景全覆盖
03-全面掌握 LangChain：从核心链条构建到动态任务分配的实战指南
04-玩转 LangChain：从文档加载到高效问答系统构建的全程实战
05-玩转 LangChain：深度评估问答系统的三种高效方法（示例生成、手动评估与LLM辅助评估）
06-从 0 到 1 掌握 LangChain Agents：自定义工具 + LLM 打造智能工作流！
07-【深度解析】从GPT-1到GPT-4：ChatGPT背后的核心原理全揭秘
08-【万字长文】MCP深度解析：打通AI与世界的"USB-C"，模型上下文协议原理、实践与未来

Python系列文章目录

PyTorch系列文章目录

机器学习系列文章目录

深度学习系列文章目录

Java系列文章目录

JavaScript系列文章目录

Python系列文章目录

01-【Python-Day 1】告别编程恐惧：轻松掌握 Python 安装与第一个程序的 6 个步骤
02-【Python-Day 2】掌握Python基石：变量、内存、标识符及int/float/bool数据类型
03-【Python-Day 3】玩转文本：字符串(String)基础操作详解 (上)
04-【Python-Day 4】玩转文本：Python 字符串常用方法深度解析 (下篇)
05-【Python-Day 5】Python 格式化输出实战：%、format()、f-string 对比与最佳实践
06- 【Python-Day 6】从零精通 Python 运算符（上）：算术、赋值与比较运算全解析
07-【Python-Day 7】从零精通 Python 运算符（下）：逻辑、成员、身份运算与优先级规则全解析
08-【Python-Day 8】从入门到精通：Python 条件判断 if-elif-else 语句全解析
09-【Python-Day 9】掌握循环利器：for 循环遍历序列与可迭代对象详解
10-【Python-Day 10】Python 循环控制流：while 循环详解与 for 循环对比
11-【Python-Day 11】列表入门：Python 中最灵活的数据容器 (创建、索引、切片)
12-【Python-Day 12】Python列表进阶：玩转添加、删除、排序与列表推导式
13-【Python-Day 13】Python 元组 (Tuple) 详解：从创建、操作到高级应用场景一网打尽
14-【Python-Day 14】玩转Python字典(上篇)：从零开始学习创建、访问与操作
15-【Python-Day 15】深入探索 Python 字典 (下)：常用方法、遍历、推导式与嵌套实战

16-【Python-Day 16】代码复用基石：详解 Python 函数的定义与调用

文章目录

  • Langchain系列文章目录
  • Python系列文章目录
  • PyTorch系列文章目录
  • 机器学习系列文章目录
  • 深度学习系列文章目录
  • Java系列文章目录
  • JavaScript系列文章目录
  • Python系列文章目录
  • 前言
  • [一、为什么需要函数？------ 代码的"积木"](#一、为什么需要函数？—— 代码的“积木”)
    • [1.1 提高代码复用性 (Don't Repeat Yourself - DRY)](#1.1 提高代码复用性 (Don't Repeat Yourself - DRY))
      • [1.1.1 场景引入：重复的问候](#1.1.1 场景引入：重复的问候)
      • [1.1.2 函数的解决方案：一次定义，多次调用](#1.1.2 函数的解决方案：一次定义，多次调用)
    • [1.2 增强代码模块化与可读性](#1.2 增强代码模块化与可读性)
      • [1.2.1 将复杂问题分解为小任务](#1.2.1 将复杂问题分解为小任务)
      • [1.2.2 提高代码的可维护性](#1.2.2 提高代码的可维护性)
  • [二、函数的定义 ------ 创造你的第一个"魔法咒语"](#二、函数的定义 —— 创造你的第一个“魔法咒语”)
    • [2.1 `def` 关键字：函数的声明](#2.1 def 关键字：函数的声明)
      • [2.1.1 基本语法结构](#2.1.1 基本语法结构)
      • [2.1.2 一个简单的函数示例：`say_hello`](#2.1.2 一个简单的函数示例：say_hello)
    • [2.2 函数命名规则与PEP 8规范](#2.2 函数命名规则与PEP 8规范)
      • [2.2.1 见名知意的重要性](#2.2.1 见名知意的重要性)
      • [2.2.2 PEP 8 命名建议](#2.2.2 PEP 8 命名建议)
    • [2.3 函数体：函数的核心逻辑](#2.3 函数体：函数的核心逻辑)
      • [2.3.1 缩进的重要性](#2.3.1 缩进的重要性)
      • [2.3.2 函数体可以包含任何有效的 Python 语句](#2.3.2 函数体可以包含任何有效的 Python 语句)
  • [三、函数的调用 ------ 启动"魔法咒语"](#三、函数的调用 —— 启动“魔法咒语”)
    • [3.1 调用函数的基本方法](#3.1 调用函数的基本方法)
      • [3.1.1 函数名加括号 `()`](#3.1.1 函数名加括号 ())
      • [3.1.2 调用示例：执行 `say_hello`](#3.1.2 调用示例：执行 say_hello)
    • [3.2 函数调用的过程解析 (初探)](#3.2 函数调用的过程解析 (初探))
      • [3.2.1 程序执行流程的跳转](#3.2.1 程序执行流程的跳转)
      • [3.2.2 函数执行与返回](#3.2.2 函数执行与返回)
  • [四、函数文档字符串 (Docstring) ------ 给你的函数写"说明书"](#四、函数文档字符串 (Docstring) —— 给你的函数写“说明书”)
    • [4.1 什么是文档字符串？](#4.1 什么是文档字符串？)
      • [4.1.1 定义与作用](#4.1.1 定义与作用)
      • [4.1.2 单行与多行文档字符串](#4.1.2 单行与多行文档字符串)
    • [4.2 如何编写规范的文档字符串](#4.2 如何编写规范的文档字符串)
      • [4.2.1 PEP 257 规范简介](#4.2.1 PEP 257 规范简介)
      • [4.2.2 包含内容建议](#4.2.2 包含内容建议)
    • [4.3 如何访问文档字符串](#4.3 如何访问文档字符串)
      • [4.3.1 使用 `help()` 函数](#4.3.1 使用 help() 函数)
      • [4.3.2 使用 `doc` 属性](#4.3.2 使用 __doc__ 属性)
  • 五、实践与思考
    • [5.1 练习：编写一个计算两数之和的函数](#5.1 练习：编写一个计算两数之和的函数)
      • [5.1.1 需求分析](#5.1.1 需求分析)
      • [5.1.2 代码实现与测试](#5.1.2 代码实现与测试)
    • [5.2 常见问题与排查 (Q\&A)](#5.2 常见问题与排查 (Q&A))
      • [5.2.1 `NameError: name '...' is not defined`](#5.2.1 NameError: name '...' is not defined)
        • [（1） 问题描述](#（1） 问题描述)
        • [（2） 示例与原因](#（2） 示例与原因)
        • [（3） 解决方案](#（3） 解决方案)
      • [5.2.2 函数定义了但没有被调用](#5.2.2 函数定义了但没有被调用)
        • [（1） 问题描述](#（1） 问题描述)
        • [（2） 示例与原因](#（2） 示例与原因)
        • [（3） 解决方案](#（3） 解决方案)
  • 六、总结

前言

欢迎来到Python学习之旅的第16天！在前面的学习中，我们已经掌握了Python的基础语法、数据类型以及循环和条件语句等。今天，我们将进入一个非常重要且强大的概念------函数 (Function)。函数是组织好的、可重复使用的，用来实现单一，或相关联功能的代码段。它们能极大地提高代码的模块化程度和代码复用率，让我们的程序更加清晰、高效。本篇将带你从零开始，深入理解为什么需要函数，如何定义函数，如何调用函数，以及如何为函数编写规范的"说明书"------文档字符串。

一、为什么需要函数？------ 代码的"积木"

想象一下，你在搭建一个复杂的乐高模型。如果每一个小部件都需要你从头开始单独制作，那将是一项多么繁琐和重复的工作！函数就像是乐高中的标准积木，你可以预先设计好不同形状和功能的积木，然后在需要的时候直接拿来使用，大大提高搭建效率。

1.1 提高代码复用性 (Don't Repeat Yourself - DRY)

DRY 原则是软件开发中的一个核心思想，意为"不要重复你自己"。函数是实践这一原则的绝佳工具。

1.1.1 场景引入：重复的问候

假设我们需要向三位不同的用户显示欢迎信息：

python 复制代码 
print("您好，欢迎来到Python的世界，Alice！")
# ... 其他一些代码 ...
print("您好，欢迎来到Python的世界，Bob！")
# ... 其他一些代码 ...
print("您好，欢迎来到Python的世界，Charlie！")

在这段代码中，"您好，欢迎来到Python的世界，"这部分问候语是重复的。如果问候语需要修改，我们就必须修改三个地方，非常低效且容易出错。

1.1.2 函数的解决方案：一次定义，多次调用

我们可以将这个重复的问候逻辑封装到一个函数中：

python 复制代码 
def greet_user(username):
    """向指定用户显示标准的欢迎信息。"""
    print(f"您好，欢迎来到Python的世界，{username}！")

# 调用函数
greet_user("Alice")
# ... 其他一些代码 ...
greet_user("Bob")
# ... 其他一些代码 ...
greet_user("Charlie")

在这个例子中，greet_user 就是我们定义的函数。我们只需要定义一次，就可以在任何需要的地方通过函数名 greet_user() 来调用它。如果需要修改问候语，只需修改函数定义中的一行代码即可。

核心概念：代码复用 (Code Reuse)

指的是在不同的程序或同一程序的不同部分重复使用相同的代码片段或逻辑，以减少冗余、提高开发效率和代码可维护性。函数是实现代码复用的主要手段。

1.2 增强代码模块化与可读性

函数不仅能复用代码，还能帮助我们将复杂的程序分解成更小、更易于管理的部分。

1.2.1 将复杂问题分解为小任务

一个大型的软件项目通常包含许多不同的功能。通过函数，我们可以将每个功能实现为一个或多个独立的函数。这样做的好处是：

  • 逻辑清晰：每个函数负责一个特定的任务，使得整个程序的结构更加清晰。
  • 关注点分离：开发人员可以专注于实现单个函数的功能，而不需要同时考虑整个程序的复杂性。

核心概念：模块化 (Modularity)

指的是将一个复杂的系统分解为若干个独立的、可交互的模块或组件的过程。在编程中，函数是实现模块化的基本单元，每个函数可以看作是一个小的功能模块。

1.2.2 提高代码的可维护性

当代码被组织成一系列独立的函数后：

  • 易于调试：如果程序出现问题，我们可以更容易地定位到可能出错的函数。
  • 易于修改和升级：修改或增强某个特定功能时，只需要关注对应的函数，减少了对程序其他部分的影响。
  • 团队协作更方便：不同的开发者可以分工负责不同的函数或模块。

二、函数的定义 ------ 创造你的第一个"魔法咒语"

理解了函数的重要性后，我们来看看如何在Python中定义一个函数。定义函数就像是创造一个"魔法咒语"，你需要告诉计算机这个咒语的名字以及它被念动时应该执行哪些操作。

2.1 def 关键字：函数的声明

在Python中，我们使用 def (define的缩写) 关键字来定义函数。

2.1.1 基本语法结构

函数定义的基本语法如下：

python 复制代码 
def function_name(parameter1, parameter2, ...):
    """
    可选的文档字符串 (Docstring)，用于描述函数功能。
    """
    # 函数体 (Function Body / Suite)
    # 包含一系列的Python语句，实现函数的功能
    statement1
    statement2
    # ...
    return # 可选的return语句，用于返回结果

让我们来分解这个结构：

  • def：定义函数的关键字，必不可少。
  • function_name：你给函数起的名字。命名规则将在下一节详细介绍。
  • ()：括号是必须的，即使函数不需要任何输入信息（参数）。
  • parameter1, parameter2, ...：这些是参数列表 (Parameters)，是函数可以接收的输入信息。如果函数不需要参数，括号内为空。我们将在后续文章中详细学习参数。
  • :：冒号表示函数定义的头部结束，接下来是函数体。
  • 文档字符串 (Docstring) ：一个可选的字符串，通常用三引号 """...""" 包裹，用于解释函数的功能、参数、返回值等。强烈建议为你的函数编写文档字符串。
  • 函数体 (Function Body) ：一个或多个Python语句，它们组成了函数要执行的具体操作。函数体必须相对于 def 行进行缩进（通常是4个空格）。
  • return：一个可选的关键字，用于从函数中返回一个值。如果函数没有 return 语句，或者 return 语句后面没有表达式，它会默认返回 None。

2.1.2 一个简单的函数示例：say_hello

让我们定义一个非常简单的函数，它不接收任何参数，只是打印一句问候语：

python 复制代码 
def say_hello():
    """打印一句简单的问候语。"""
    message = "Hello, Python Functions!"
    print(message)

在这个例子中：

  • 函数名为 say_hello。
  • 它没有参数 (括号内为空)。
  • 它有一个文档字符串，描述了函数的功能。
  • 函数体包含两行代码：创建了一个变量 message 并打印了它的值。
  • 它没有 return 语句，所以调用它时会默认返回 None。

2.2 函数命名规则与PEP 8规范

给函数起一个好名字非常重要，它能让你的代码更易读、易懂。

2.2.1 见名知意的重要性

函数名应该清晰地描述函数的功能。例如，一个计算平均值的函数可以命名为 calculate_average，而不是模糊的 func1 或 calc。

2.2.2 PEP 8 命名建议

PEP 8 是Python的官方代码风格指南，其中包含了对函数命名的建议：

  • 小写字母与下划线 ：函数名应使用小写字母，并用下划线 _ 分隔单词，以提高可读性（这种风格称为蛇形命名法，snake_case）。例如：calculate_sum，get_user_info。
  • 避免与内置名称冲突 ：不要使用Python内置函数或关键字作为你的函数名 (例如 print, len, list, def 等)。
  • 描述性：名称应具有描述性，但又不过于冗长。

好的命名示例：

python 复制代码 
def send_email_notification():
    # ...
    pass # pass 是一个占位语句，表示什么也不做

def validate_input_data(data):
    # ...
    pass

不推荐的命名示例：

python 复制代码 
def SendEmail(): # 不推荐：使用了大写字母开头
    pass

def validatedata(data): # 不推荐：单词间没有分隔，可读性差
    pass

def str(): # 严重不推荐：与内置函数 str 冲突
    pass

2.3 函数体：函数的核心逻辑

函数体是函数的核心，它包含了实现特定功能的一系列Python语句。

2.3.1 缩进的重要性

Python 使用缩进 来定义代码块的层级关系，这与其他语言（如C++, Java）使用花括号 {} 不同。函数体内的所有语句必须具有相同的缩进级别，通常是相对于 def 行缩进4个空格。

python 复制代码 
def example_function():
    print("这是函数体的第一行") # 正确缩进
    if True:
        print("这是if语句块内的第一行") # 更深一层的正确缩进
    print("这是函数体的第二行") # 与第一行同级缩进
# print("这行代码不属于函数体") # 没有缩进，在函数外部

不正确的缩进会导致 IndentationError。

2.3.2 函数体可以包含任何有效的 Python 语句

函数体内可以包含任何你已经学过的Python语句，例如：

  • 变量赋值
  • 算术运算
  • 条件语句 (if/elif/else)
  • 循环语句 (for, while)
  • 甚至可以调用其他函数（包括调用自身，即递归，我们后续会讲到）

三、函数的调用 ------ 启动"魔法咒语"

定义了函数之后，它并不会自动执行。你需要通过"调用"函数来执行其内部的代码。

3.1 调用函数的基本方法

调用函数非常简单，只需要写出函数名，并在其后加上一对圆括号 ()。

3.1.1 函数名加括号 ()

语法：

python 复制代码 
function_name()

如果函数定义时需要参数，那么在调用时也需要提供相应的参数（我们将在下一篇文章中详细学习参数的传递）。

3.1.2 调用示例：执行 say_hello

让我们调用前面定义的 say_hello 函数：

python 复制代码 
# 首先定义函数
def say_hello():
    """打印一句简单的问候语。"""
    message = "Hello, Python Functions!"
    print(message)

# 然后调用函数
print("准备调用函数...")
say_hello() # 这会执行 say_hello 函数体内的代码
print("函数调用结束。")

输出结果将会是：

复制代码 
准备调用函数...
Hello, Python Functions!
函数调用结束。

3.2 函数调用的过程解析 (初探)

当你调用一个函数时，程序的执行流程会发生一些变化。

3.2.1 程序执行流程的跳转

  1. 暂停当前执行 ：当Python解释器遇到函数调用（如 say_hello()）时，它会暂停当前代码的执行。
  2. 跳转到函数定义 ：解释器会找到名为 say_hello 的函数定义。
  3. 执行函数体：解释器开始执行函数体内的代码。
  4. 返回到调用点 ：函数体内的代码执行完毕后（或者遇到 return 语句），解释器会返回到函数被调用的那一行代码之后，继续执行程序的剩余部分。

我们可以用一个简单的流程图来表示这个过程：

graph TD A[程序开始] --> B(执行到 say_hello() 调用点); B -- 调用 --> C{进入 say_hello 函数}; C -- 执行函数体 --> D[打印 "Hello, Python Functions!"]; D -- 函数结束 --> E{返回到 say_hello() 调用点之后}; E --> F[继续执行后续代码]; F --> G[程序结束];

3.2.2 函数执行与返回

  • 函数在执行时会创建一个新的作用域 (Scope)，函数内部定义的变量通常只在该函数内部可见（我们会在后续文章中详细学习作用域）。
  • 如果函数有 return 语句并返回一个值，那么这个值可以被赋给一个变量，或者直接用于表达式中。
  • 如果函数没有 return 语句，或者 return 语句后没有值，它默认返回特殊值 None。
python 复制代码 
def add_numbers(a, b): # 这个函数接收参数并返回一个值
    """计算两个数的和。"""
    return a + b

result = add_numbers(5, 3) # 调用函数，并将返回值赋给 result
print(f"5 + 3 = {result}") # 输出: 5 + 3 = 8

output_from_say_hello = say_hello() # 调用 say_hello
print(f"say_hello 函数的返回值是: {output_from_say_hello}") # 输出: say_hello 函数的返回值是: None

四、函数文档字符串 (Docstring) ------ 给你的函数写"说明书"

文档字符串 (Docstring) 是Python中一种非常重要的注释形式，它用于解释函数（以及模块、类）的用途和工作方式。

4.1 什么是文档字符串？

4.1.1 定义与作用

文档字符串是出现在函数定义（或模块、类定义）的第一条语句的一个字符串字面量，通常使用三引号 """...""" (单三引号或双三引号都可以) 来创建，这样可以方便地书写多行文本。

作用：

  • 自我说明：让阅读代码的人（包括未来的你）能够快速理解函数的功能。
  • 自动生成文档：许多工具（如Sphinx）可以从代码中提取文档字符串来自动生成项目文档。
  • 交互式帮助 ：Python的内置 help() 函数和一些IDE会显示文档字符串作为函数的帮助信息。

4.1.2 单行与多行文档字符串

  • 单行文档字符串：如果函数的说明很简单，可以用一行概括。三引号应在同一行。

    python 复制代码 
    def get_pi():
    """返回圆周率 Pi 的近似值。"""
    return 3.1415926535

  • 多行文档字符串：对于复杂的函数，文档字符串通常包含一个简短的摘要行，接着是一个空行，然后是更详细的解释。

    python 复制代码 
    def calculate_area_rectangle(length, width):
    """
    计算矩形的面积。

    这个函数接收矩形的长度和宽度作为参数，
    并返回它们的乘积，即矩形的面积。
    确保输入的长度和宽度是正数。
    """
    if length <= 0 or width <= 0:
        print("错误：长度和宽度必须是正数。")
        return None # 或者抛出异常
    return length * width

4.2 如何编写规范的文档字符串

PEP 257 是关于文档字符串约定的官方指南。

4.2.1 PEP 257 规范简介

PEP 257 建议：

  • 文档字符串的第一行应该是对对象目的的简洁摘要。这一行应该以大写字母开头，以句号结尾。
  • 如果文档字符串有多行，第二行应该是空白行，视觉上将摘要与其余描述分开。
  • 后续段落描述对象的调用约定、副作用等。

4.2.2 包含内容建议

一个好的多行文档字符串通常包含：

  1. 摘要行：简明扼要地说明函数做什么。
  2. (可选) 详细描述：如果需要，进一步解释函数的行为、算法或注意事项。
  3. (可选) 参数 (Arguments/Parameters)：如果函数接受参数，应列出每个参数的名称、类型（可选但推荐）及其含义。
  4. (可选) 返回值 (Returns)：如果函数返回值，应说明返回值的类型和含义。
  5. (可选) 可能抛出的异常 (Raises)：如果函数可能抛出特定异常，也应在此说明。

示例：一个更完整的文档字符串

python 复制代码 
def solve_quadratic_equation(a, b, c):
    """计算一元二次方程 ax^2 + bx + c = 0 的实数根。

    参数:
        a (float): 二次项系数。
        b (float): 一次项系数。
        c (float): 常数项。

    返回:
        tuple or float or None: 
            如果方程有两个不相等的实数根，则返回一个包含两个根的元组。
            如果方程有两个相等的实数根，则返回一个浮点数。
            如果方程没有实数根，则返回 None。
            如果 a 为 0，这不是一个二次方程，也返回 None。
    
    示例:
        >>> solve_quadratic_equation(1, -3, 2)
        (2.0, 1.0)
        >>> solve_quadratic_equation(1, 2, 1)
        -1.0
        >>> solve_quadratic_equation(1, 1, 1)
        None
    """
    if a == 0:
        print("错误：'a' 不能为0，这不是一个二次方程。")
        return None

    delta = b**2 - 4*a*c

    if delta > 0:
        x1 = (-b + delta**0.5) / (2*a)
        x2 = (-b - delta**0.5) / (2*a)
        return (x1, x2)
    elif delta == 0:
        x = -b / (2*a)
        return x
    else:
        # print("方程没有实数根。") # 可以选择不打印，直接返回None
        return None

4.3 如何访问文档字符串

Python 提供了几种方式来查看或访问一个函数的文档字符串。

4.3.1 使用 help() 函数

help() 是一个内置函数，可以显示对象的帮助信息，其中就包括文档字符串。

python 复制代码 
def my_simple_function():
    """这是一个简单的演示函数。"""
    pass

help(my_simple_function)

输出：

复制代码 
Help on function my_simple_function in module __main__:

my_simple_function()
    这是一个简单的演示函数。

4.3.2 使用 __doc__ 属性

每个函数（以及其他具有文档字符串的对象）都有一个特殊的属性 __doc__ (双下划线doc双下划线)，它存储了该对象的文档字符串。

python 复制代码 
def another_function():
    """这是另一个函数的文档字符串。
    它可以是多行的。
    """
    pass

print(another_function.__doc__)

输出：

复制代码 
这是另一个函数的文档字符串。
    它可以是多行的。

注意，__doc__ 属性直接返回字符串内容，包括原始的缩进。

五、实践与思考

理论学习之后，动手实践是巩固知识的最佳方式。

5.1 练习：编写一个计算两数之和的函数

现在，请你尝试编写一个函数，该函数不接收参数（为了简化，我们先在函数内部定义数字），计算这两个数字的和，并打印结果。记得为它编写文档字符串。

5.1.1 需求分析

  • 函数名：可以命名为 add_two_fixed_numbers。
  • 功能：计算两个预设数字（例如 10 和 20）的和，并打印出来。
  • 文档字符串：清晰描述函数的功能。

5.1.2 代码实现与测试

python 复制代码 
def add_two_fixed_numbers():
    """
    计算两个预设数字 (10 和 20) 的和，并打印结果。
    这个函数不接收参数，也不返回任何值。
    """
    num1 = 10
    num2 = 20
    total = num1 + num2
    print(f"预设数字 {num1} 和 {num2} 的和是: {total}")

# 测试函数
add_two_fixed_numbers()

# 你也可以查看它的文档字符串
help(add_two_fixed_numbers)
print("-" * 20) # 打印分隔线
print(add_two_fixed_numbers.__doc__)

预期输出：

复制代码 
预设数字 10 和 20 的和是: 30
Help on function add_two_fixed_numbers in module __main__:

add_two_fixed_numbers()
    计算两个预设数字 (10 和 20) 的和，并打印结果。
    这个函数不接收参数，也不返回任何值。

--------------------
    计算两个预设数字 (10 和 20) 的和，并打印结果。
    这个函数不接收参数，也不返回任何值。

5.2 常见问题与排查 (Q&A)

在初学函数时，可能会遇到一些常见错误。

5.2.1 NameError: name '...' is not defined

（1） 问题描述

当你尝试调用一个尚未定义或者名称拼写错误的函数时，Python会抛出 NameError。

（2） 示例与原因
python 复制代码 
# 错误示例1：调用前未定义
my_function() # 这里会报错，因为 my_function 还没有被定义

def my_function():
    print("Hello from my_function")

# 错误示例2：函数名拼写错误
def calculate_sum():
    print("Summing...")

calculat_sum() # 'calculat_sum' 与 'calculate_sum' 不同
（3） 解决方案
  • 确保先定义后调用：函数的定义必须出现在其首次调用之前。Python解释器是自上而下执行代码的。
  • 检查拼写：仔细核对函数调用时的名称是否与定义时的名称完全一致，包括大小写。

5.2.2 函数定义了但没有被调用

（1） 问题描述

你可能花费了时间编写了一个函数，但程序运行时却没有任何与该函数相关的输出或行为。

（2） 示例与原因
python 复制代码 
def important_task():
    print("正在执行重要任务...")
    # 假设这里有很多代码

# 程序结束了，但 'important_task' 函数的输出从未出现
print("程序执行完毕。")

原因很简单：函数仅仅被定义了，但从未被调用。

（3） 解决方案

在需要执行函数功能的地方，明确地调用它：

python 复制代码 
def important_task():
    print("正在执行重要任务...")

important_task() # 现在调用了函数
print("程序执行完毕。")

六、总结

恭喜你，完成了Python函数定义与调用的初步学习！回顾一下本篇的核心知识点：

  1. 函数的必要性：

    • 代码复用：避免重复编写相同的代码，遵循DRY原则。
    • 模块化：将复杂程序分解为更小、更易管理的功能单元，提高代码的可读性和可维护性。

  2. 函数的定义 (def)：

    • 使用 def 关键字，后跟函数名和圆括号 ()。
    • 函数体需要相对于 def 行进行缩进。
    • 函数名应遵循PEP 8规范（小写字母加下划线）。

  3. 函数的调用：

    • 通过函数名后加圆括号 () 来执行函数。
    • 调用时，程序控制流会跳转到函数内部执行，完成后返回。

  4. 文档字符串 (Docstring)：

    • 位于函数定义第一行的三引号字符串，用于解释函数功能。
    • 是编写可维护和易理解代码的重要组成部分。
    • 可通过 help() 函数或 __doc__ 属性访问。

函数是Python编程的基石之一。掌握了函数的定义和调用，你就拥有了构建更复杂、更强大程序的关键工具。在接下来的文章中，我们将继续深入探索函数的更多高级特性，如函数参数、返回值、作用域等。敬请期待！

相关推荐
中烟创新14 分钟前
安全可控的AI底座：灯塔大模型应用开发平台全面实现国产信创兼容适配认证
人工智能·安全
看到我，请让我去学习37 分钟前
数据结构—排序(斐波那契数列，冒泡，选择，插入，快速，归并，图，广度优先算法)
c语言·开发语言·数据结构·后端
程序员Bears43 分钟前
JSP与JSTL：EL表达式与MVC分层模式的完美结合
java·开发语言·mvc
测试19981 小时前
Selenium无法定位元素的几种解决方案详解
自动化测试·软件测试·python·selenium·测试工具·职场和发展·测试用例
兔兔爱学习兔兔爱学习1 小时前
创建Workforce
人工智能·算法
花菜会噎住2 小时前
Python 计算机网络TCP网络应用程序开发
网络·python·tcp/ip·计算机网络·客户端·服务端
louisliao_19812 小时前
钉钉开发之AI消息和卡片交互开发文档收集
人工智能·钉钉
wktomo2 小时前
GO语言学习（七）
开发语言·学习·golang
橙子小哥的代码世界2 小时前
GPT 等decoder系列常见的下游任务
人工智能·gpt·nlp·解释器模式·transformer
KY_chenzhao2 小时前
AI赋能R-Meta分析核心技术：从热点挖掘到高级模型
人工智能·r语言·论文·生态·meta分析·热点
热门推荐
01【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！02KGG转MP3工具|非KGM文件|解密音频03从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑04YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06DeepSeek各版本说明与优缺点分析07【超详细】Windows安装Npcap08YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU09Coze扣子平台完整体验和实践（附国内和国际版对比）10Anaconda +Jupyter Notebook安装（2025最新版）