Python 函数超全详解｜从基础定义到高阶用法一站式总结
函数是 Python 编程里模块化编程、代码复用的核心基石，也是从入门到进阶必须吃透的核心知识点。本篇文章结合教材知识点 + 实战案例，完整讲解函数的全部核心内容：从基础概念、定义调用、全类型参数、返回值分类，到嵌套调用、变量作用域、递归 & 匿名函数，再到 Python 内置常用库函数，每一个知识点都配套完整可运行代码案例，零基础也能轻松看懂。
目录
7.4 nonlocal 关键字（嵌套函数修改外层局部变量）
一、函数到底是什么？
在程序开发中，我们经常会在代码的不同位置，重复编写实现相同功能的代码块（比如重复打印菜单、重复计算数值、重复输出固定格式内容）。
大量重复代码会让程序臃肿、维护困难、可读性极差。而函数，就是把具有独立功能、可重复使用的代码块，封装成一个独立模块，给这个模块起一个名字。后续只要通过这个名字，就可以随时随地执行这段代码，不用重复编写。
函数的核心优势
- 代码复用：一次编写，无数次调用，彻底消除重复代码
- 模块化编程：把复杂大程序拆解成多个独立小功能函数，结构清晰
- 易维护易扩展：修改功能只需要修改函数内部代码，所有调用处全部同步生效
- 提升可读性：函数名可以直观描述功能，他人阅读代码能快速理解逻辑
Python 中函数分为两大类：
- 内置函数：Python 解释器自带、直接就能调用的函数，比如
print()、input()、len()、max()等 - 自定义函数：程序员根据自身业务需求，自己手动定义的函数
二、函数的定义与调用
2.1 函数的定义（def关键字）
Python 中统一使用 def 关键字来定义自定义函数，严格遵循固定语法格式：
def 函数名(参数列表):
"""函数文档字符串（功能说明，可选）"""
函数体代码 # 核心功能代码，必须缩进
return 表达式 # 返回值，可选
语法规则详细说明
- 函数代码块必须以
def关键字开头，后面紧跟函数名 + 英文圆括号() - 所有需要传入的参数、自定义变量，全部写在圆括号内，括号之间定义参数
- 第一行可以选择性编写文档字符串（三引号包裹），用来描述函数功能、参数、返回值，用于代码说明
- 函数体所有代码以冒号
:结尾开头，全部需要缩进（Python 强制缩进，一般 4 个空格） return语句：用来结束函数、向调用处返回数据。不写 return、或者 return 后面不带内容，默认返回None- 函数名命名规则：和变量命名完全一致，只能由字母、数字、下划线组成，不能数字开头，不能使用 Python 关键字（比如
if、for、def）
案例：定义菜单打印函数
实现【学生信息管理系统】菜单打印功能，完整定义代码：
# 定义一个函数，实现打印学生信息管理系统菜单
def menu():
print("*" * 38)
print(" "*10+"学生信息管理系统 v1.0")
print(" "*6+"【1】 添加学生信息")
print(" "*6+"【2】 删除学生信息")
print(" "*6+"【3】 修改学生信息")
print(" "*6+"【4】 显示所有学生信息")
print(" "*6+"【5】 退出系统")
print("*" * 38)
2.2 函数的调用
函数定义完成后，代码不会自动执行！必须手动调用，函数内部代码才会运行。调用语法极其简单：
函数名()只需要写函数名 + 圆括号，即可完成调用。
以上面定义的menu()函数为例，调用代码：
# 调用函数，执行内部所有代码
menu()运行结果
**************************************
学生信息管理系统 v1.0
【1】 添加学生信息
【2】 删除学生信息
【3】 修改学生信息
【4】 显示所有学生信息
【5】 退出系统
**************************************补充：多次调用函数，就会多次执行函数内部全部代码，完美实现代码复用。
# 连续调用3次，菜单会连续打印3遍
menu()
menu()
menu()三、函数的参数详解
上面定义的menu()函数，所有运行逻辑、输出内容全部写死，功能局限性极强。比如我们想计算两个数字的差值，每次都只能算20-8，无法计算其他数字。
函数参数，就是函数接收外部传入数据的载体。定义函数时设置参数，调用函数时传入数据，函数内部就可以根据传入的不同数据，得到不同运行结果，让函数具备通用性。
本节完整讲解：位置参数传递、默认参数、不定长参数（元组*args、字典**kwargs）全部知识点。
3.1 位置参数（普通参数）传递
定义函数时，在括号内定义形参（形式参数）；调用函数时，括号内传入实参（实际参数），实参会按照从左到右的顺序，一一对应赋值给形参。
基础案例：固定计算函数的局限性
下面这个函数只能计算20-8，调用多少次结果都固定，没有通用性
def subtraction2num():
c = 20 - 8
print(c)
subtraction2num() # 运行结果永远输出 12改造：带位置参数的差值计算函数
定义两个形参，接收外部传入的任意两个数字，计算差值
# 定义函数，num1、num2 是形参（位置参数）
def subtraction2num(num1, num2):
num3 = num1 - num2
print("两个数的差值为：", num3)
# 调用函数，传入实参 20、8，按位置依次赋值给 num1、num2
subtraction2num(20, 8)
# 运行结果：两个数的差值为： 12
# 再次调用，传入其他数字，实现通用计算
subtraction2num(100, 30)
# 运行结果：两个数的差值为： 70
subtraction2num(50, 120)
# 运行结果：两个数的差值为： -70位置参数核心规则
- 调用函数时，传入的实参个数、顺序，必须和定义的形参一一对应
- 形参仅在函数内部生效，函数外部无法直接使用
3.2 默认参数
定义函数时，可以直接给形参提前赋值，这个带初始值的参数就叫做默认参数。
核心规则
- 调用函数时，默认参数可以不传参：函数会自动使用定义时设置的默认值
- 调用函数时，给默认参数传入新值：会用传入的新值，覆盖掉原本的默认值
- ⚠️ 硬性语法禁忌：所有带默认值的参数，必须写在【无默认值的普通参数】的后面！顺序写反程序会直接报语法错误！
案例：默认参数完整实战
# 定义函数：name是普通参数，age是默认参数（默认值19）
def studentinfo(name, age=19):
print("Name", name)
print("age", age)
# 第1次调用：只传入name参数，age自动使用默认值19
studentinfo(name="tom")
# 运行结果：
# Name tom
# age 19
# 第2次调用：两个参数全部传入，age使用传入的新值20，覆盖默认值
studentinfo(name="tom", age=20)
# 运行结果：
# Name tom
# age 20错误案例（顺序禁忌演示）
违反「默认参数必须在普通参数后面」的规则，代码直接报错
# 错误写法：默认参数age=19 写在了无默认参数sex前面
def studentinfo(name, age=19, sex):
print(name, age, sex)
# 报错信息：SyntaxError: non-default argument follows default argument
# 语法错误：无默认值参数跟在了有默认值参数之后3.3 不定长参数
日常开发中，我们经常遇到调用函数时，传入的参数个数不确定的场景（有时候传 2 个、有时候传 5 个、个数不固定）。普通参数无法适配这种场景，Python 专门提供不定长参数，完美适配参数个数不固定的需求。
不定长参数分为 2 种，全部来自教材案例 + 完整拓展讲解：
*args：接收无关键字的多余位置参数，内部封装为元组 tuple**kwargs：接收带关键字的多余命名参数，内部封装为字典 dict
3.3.1 单星号不定长参数 *args
语法格式：
def 函数名(普通参数1, 普通参数2, *args):
函数体匹配规则
函数调用传参时，先从左到右，优先匹配前面的普通固定参数；所有匹配完成后，剩下所有多余的、没有名字的位置参数，全部被*args收集，打包成一个元组。即使没有多余参数，args也是一个空元组。
完整案例
# 定义函数：name、cpu为固定普通参数，*args 为不定长位置参数
def computerinfo(name, cpu, *args):
print("电脑品牌：", name)
print("处理器：", cpu)
print("其余硬件参数元组：", args)
# 调用1：只传入固定参数，无多余参数 → args为空元组
computerinfo("华硕", "i5")
# 运行结果：
# 电脑品牌： 华硕
# 处理器： i5
# 其余硬件参数元组： ()
# 调用2：传入固定参数+多个多余位置参数，全部被args收集为元组
computerinfo("华硕", "i5", "8g", "1TB+128GB", "GTX1050Ti")
# 运行结果：
# 电脑品牌： 华硕
# 处理器： i5
# 其余硬件参数元组： ('8g', '1TB+128GB', 'GTX1050Ti')3.3.2 双星号不定长参数 **kwargs
语法格式：
def 函数名(普通参数1, 普通参数2, *args, **kwargs):
函数体匹配规则
传参时，固定参数、*args匹配完成后，剩下所有 **key=value格式的关键字参数 **，全部被**kwargs收集，打包成一个字典。没有多余关键字参数时，kwargs为空字典。
完整案例
# 完整定义：固定参数 + *args + **kwargs
def computerinfo(name, cpu, *args, **kwargs):
print("电脑品牌：", name)
print("处理器：", cpu)
print("多余位置参数元组 args：", args)
print("多余关键字参数字典 kwargs：", kwargs)
# 调用：固定参数+多余位置参数+key=value格式关键字参数
computerinfo("华硕", "i5", "8g", harddisk="1TB+128GB", Graphic="GTX1050Ti")
# 运行结果：
# 电脑品牌： 华硕
# 处理器： i5
# 多余位置参数元组 args： ('8g',)
# 多余关键字参数字典 kwargs： {'harddisk': '1TB+128GB', 'Graphic': 'GTX1050Ti'}不定长参数总结
| 参数格式 | 接收参数类型 | 内部存储类型 | 备注 |
|---|---|---|---|
*args |
多余无名称位置参数 | 元组 tuple | args 前面只有 1 个* |
**kwargs |
多余key=value关键字参数 |
字典 dict | kwargs 前面有 2 个* |
| 参数顺序 | 固定普通参数 → *args → **kwargs |
- | 固定语法顺序，不可调换 |
四、函数的返回值 & 函数的 4 种分类
4.1 函数返回值基础
函数运行完成后，给调用它的代码返回运算结果，这个结果就是返回值。Python 中统一用 return 关键字实现返回值。
基础语法
def 函数名(参数):
功能代码
return 需要返回的数据核心知识点
return执行后，函数立刻结束，return后面的所有代码都不会执行- 函数不写
return、或者return后面无内容，默认返回None（空类型） - 返回值可以是任意数据类型：数字、字符串、列表、字典、甚至另一个函数
- 调用函数时，可以用变量接收函数的返回值，后续代码继续使用该结果
案例：两数相加函数
# 写法1：分步写法
def add(num1, num2):
sum_res = num1 + num2
return sum_res # 返回相加结果
# 写法2：精简写法，直接return表达式
def add2(num1, num2):
return num1 + num2
# 调用函数，用变量接收返回值
result = add(10, 20)
print("两数相加结果：", result)
# 运行结果：两数相加结果： 304.2 函数的四种完整类型
根据有无参数、有无返回值两个维度，Python 函数严格分为 4 大类，全部配套教材原版案例 + 完整代码。
类型 1：无参数、无返回值函数
特点：函数定义括号内无参数；函数内部没有return语句，调用后仅执行内部功能（打印、输出），不对外返回任何数据。适用场景：固定功能打印，比如菜单、固定格式输出。
案例代码：
# 无参数、无返回值：仅打印宿舍信息系统菜单
def studentMenu():
print("------------------------------")
print('男生宿舍信息系统')
print('1.成员介绍')
print('2.宿舍活动')
print('3.退出')
print("------------------------------")
# 调用函数
studentMenu()
# 运行结果：
# ------------------------------
# 男生宿舍信息系统
# 1.成员介绍
# 2.宿舍活动
# 3.退出
# ------------------------------类型 2：无参数、有返回值函数
特点：函数无传入参数，但是内部有return语句，调用后会返回一个固定数据给调用处。适用场景：获取固定常量、基础配置数据。
案例代码：
# 无参数、有返回值：返回大学新生标准年龄
def getAge():
return 19 # 直接返回固定数据
# 调用函数，变量接收返回值
age = getAge()
print("当前大学新生的入学标准年龄为：", age)
# 运行结果：当前大学新生的入学标准年龄为： 19类型 3：有参数、无返回值函数
特点：可以接收外部传入的参数，函数内部处理数据、直接打印结果，没有 return 返回语句，不把结果返回给调用处。日常使用频率较低，因为结果只能函数内部打印，外部无法复用计算结果。
案例代码：
# 有参数、无返回值：计算两数平均值，内部直接打印，不返回
def average(num1, num2):
result = (num1 + num2) / 2
print("平均值为：%d" % result)
# 调用函数，传入参数
average(10, 20)
# 运行结果：平均值为：15类型 4：有参数、有返回值函数（开发最常用！）
特点：既可以接收外部传入的任意参数，内部完成数据运算，又可以通过return把最终结果返回给调用处。外部可以用变量接收返回值，后续代码无限次复用结果，通用性、灵活性最强。
案例代码：
# 有参数、有返回值：计算平均值，返回结果给调用处
def average(num1, num2):
result = (num1 + num2) / 2
return result # 返回计算结果
# 调用函数，变量接收返回值，后续可继续使用
res = average(10, 20)
print("函数返回的平均值为：", res)
# 运行结果：函数返回的平均值为： 15.0
# 拿到返回值继续二次运算
print("平均值的2倍：", res * 2)
# 运行结果：平均值的2倍： 30.0五、综合实战案例：学生通讯录管理系统（函数版）
结合前面全部基础知识点，封装一个完整的学生通讯录管理系统，把增、删、查、遍历、退出全部功能封装为独立函数，实现完整模块化程序。
# 初始化通讯录：全局列表存储所有联系人
contact_list = []
# 1. 菜单打印函数（无参无返回值）
def show_menu():
print("="*30)
print(" 学生通讯录管理系统")
print("1. 添加联系人")
print("2. 删除联系人")
print("3. 查询联系人")
print("4. 遍历全部联系人")
print("5. 退出系统")
print("="*30)
# 2. 添加联系人函数（有参有返回值）
def add_contact(name, phone):
# 封装联系人字典
contact = {"姓名": name, "电话": phone}
contact_list.append(contact)
return True # 返回添加成功状态
# 3. 查询联系人函数（有参有返回值）
def search_contact(name):
for person in contact_list:
if person["姓名"] == name:
return person # 查到返回联系人信息
return None # 没查到返回None
# 4. 遍历全部联系人（无参无返回值）
def show_all():
if len(contact_list) == 0:
print("通讯录暂无联系人！")
return
for p in contact_list:
print(f"姓名：{p['姓名']} 电话：{p['电话']}")
# 主程序循环测试代码
if __name__ == "__main__":
# 测试调用
show_menu()
# 测试添加联系人
flag = add_contact("张三", "13800138000")
if flag:
print("联系人添加成功！")
六、函数的嵌套调用
6.1 概念定义
函数嵌套调用：在一个函数的内部代码块中，调用另外一个函数。Python 支持无限层嵌套，函数 A 内部调用函数 B，函数 B 内部还可以调用函数 C，以此类推。
6.2 执行过程原理
严格遵循调用 - 执行 - 返回的流程：
- 程序从上到下执行，先调用外层函数
- 外层函数执行到内部调用语句时，暂停自身代码，跳转去执行被调用的内层函数
- 内层函数全部代码执行完毕（遇到 return / 代码走完），返回到外层函数暂停的位置
- 外层函数继续执行后续剩余代码，全部执行完毕后结束
6.3 完整实战案例
# 内层函数1
def func_b():
print("----进入函数B----")
print("函数B内部执行代码")
print("----退出函数B----")
# 内层函数2
def func_c():
print("----进入函数C----")
print("函数C内部执行代码")
print("----退出函数C----")
# 外层函数：内部嵌套调用func_b、func_c
def func_a():
print("====进入最外层函数A====")
# 函数内部嵌套调用其他函数
func_b()
func_c()
print("====函数A剩余代码执行====")
print("====退出函数A====")
# 调用最外层函数
func_a()
# 运行结果：
# ====进入最外层函数A====
# ----进入函数B----
# 函数B内部执行代码
# ----退出函数B----
# ----进入函数C----
# 函数C内部执行代码
# ----退出函数C----
# ====函数A剩余代码执行====
# ====退出函数A====6.4 多层嵌套经典案例
def a():
print("函数a执行")
b()
print("函数a结束")
def b():
print("函数b执行")
c()
print("函数b结束")
def c():
print("函数c执行")
# 调用最顶层函数
a()
# 运行结果：
# 函数a执行
# 函数b执行
# 函数c执行
# 函数b结束
# 函数a结束七、变量作用域（局部变量、全局变量）
变量不是在哪里都能随便使用的，变量能被访问、生效的代码范围，就叫做变量作用域。Python 分为局部变量、全局变量，以及global、nonlocal两个修改关键字。
7.1 局部变量
定义
定义在函数内部的变量，叫做局部变量。
核心特点
- 作用域仅限当前函数内部，函数外部完全无法访问、使用
- 函数每一次调用，都会重新创建局部变量，函数调用结束，变量自动销毁释放
- 不同函数的局部变量相互独立，互不干扰
案例代码：
def test_func():
# 局部变量：仅函数内部可用
num = 100
print("函数内部局部变量num：", num)
test_func()
# 运行结果：函数内部局部变量num： 100
# 函数外部访问局部变量 → 直接报错
# print(num) # NameError: name 'num' is not defined7.2 全局变量
定义
定义在所有函数外部、整个代码顶层的变量，叫做全局变量。
核心特点
- 作用域是整个代码文件，文件内所有函数内部、外部都可以直接 ** 访问（读取）** 全局变量
- ⚠️ 重点：函数内部默认不能直接修改全局变量！如果函数内部直接给全局变量赋值，Python 会默认把它当成一个全新的局部变量，不会修改外部全局变量。
案例代码：
# 全局变量：定义在所有函数外部
global_num = 200
def test1():
# 函数内部可以直接读取全局变量
print("函数1读取全局变量：", global_num)
def test2():
# 错误示范：函数内部直接赋值，不会修改全局变量，而是创建同名局部变量
global_num = 300
print("函数内部同名局部变量：", global_num)
test1()
# 运行结果：函数1读取全局变量： 200
test2()
# 运行结果：函数内部同名局部变量： 300
print("函数外部原始全局变量：", global_num)
# 运行结果：函数外部原始全局变量： 2007.3 global 关键字（函数内修改全局变量）
想要在函数内部真正修改全局变量，必须先用global关键字声明该变量。
语法：
def 函数名():
global 全局变量名
# 后续赋值、修改，全部作用于外部全局变量完整案例：
# 全局变量
a = 10
print("修改前全局变量a：", a)
# 运行结果：修改前全局变量a： 10
def change_global():
global a # 声明：此处的a是外部全局变量，不是局部变量
a = 100 # 真正修改全局变量的值
print("函数内部修改后的全局变量a：", a)
change_global()
# 运行结果：函数内部修改后的全局变量a： 100
print("修改后全局变量a：", a)
# 运行结果：修改后全局变量a： 1007.4 nonlocal 关键字（嵌套函数修改外层局部变量）
在函数嵌套场景中：内层函数想要修改外层函数的局部变量，需要使用nonlocal关键字声明。
区分：
global：操作全局变量（最顶层）nonlocal：操作外层嵌套函数的局部变量，不触碰全局变量
完整案例：
def outer():
# 外层函数的局部变量
num = 50
print("外层函数原始num：", num)
# 运行结果：外层函数原始num： 50
# 内层嵌套函数
def inner():
nonlocal num # 声明：修改外层函数的局部变量num
num = 200
print("内层函数修改后num：", num)
# 运行结果：内层函数修改后num： 200
inner()
print("外层函数最终num：", num)
# 运行结果：外层函数最终num： 200
outer()八、递归函数
8.1 概念定义
递归函数：自己调用自己的函数，就是递归函数。函数在自身的函数体内部，调用函数本身。
8.2 递归必备 2 个核心条件
写递归函数必须严格满足，否则会无限递归、程序内存溢出崩溃：
- 递归调用：函数内部自己调用自己
- 递归出口（终止条件）：必须有一个边界条件，满足时停止递归调用，不再继续自己调用自己
8.3 经典案例：阶乘计算
数学定义：n! = n * (n-1) * (n-2) * ... * 1，规定 0! = 1用递归实现：n! = n * (n-1)!，终止条件：n=1 时返回 1
# 递归函数：计算n的阶乘
def factorial(n):
# 1. 递归出口（终止条件）
if n == 1:
return 1
# 2. 递归调用：自己调用自己
return n * factorial(n-1)
# 调用测试
print("5的阶乘：", factorial(5))
# 运行结果：5的阶乘： 120
print("7的阶乘：", factorial(7))
# 运行结果：7的阶乘： 5040递归执行流程拆解（以factorial(5)为例）
factorial(5) = 5 * factorial(4)
factorial(4) = 4 * factorial(3)
factorial(3) = 3 * factorial(2)
factorial(2) = 2 * factorial(1)
factorial(1) = 1 # 到达终止条件，开始回溯计算
回溯：
factorial(2) = 2*1 = 2
factorial(3) = 3*2 = 6
factorial(4) = 4*6 = 24
factorial(5) = 5*24 = 1208.4 优缺点总结
- 优点：数学公式天然适配递归（阶乘、斐波那契、遍历树结构），代码极简优雅
- 缺点：相比循环，递归有函数调用开销，层级过深会超出 Python 最大递归深度报错
九、匿名函数 lambda
9.1 概念定义
Python 用 lambda 关键字创建匿名函数，也就是没有函数名的简易函数。专门用于实现功能极其简单、一次性使用的小型逻辑，不需要用def单独定义命名函数。
9.2 语法格式
lambda 参数1,参数2,... : 表达式- 冒号
:前面：函数的参数，多个参数用逗号分隔 - 冒号
:后面：只能写一个表达式，表达式运算结果会自动返回，不需要写 return - 整体就是一个函数对象，没有函数名
9.3 基础案例对比
普通def函数实现两数相加：
def add(x, y):
return x + y
print(add(10, 20))
# 运行结果：30等价 lambda 匿名函数：
# 赋值给变量，模拟函数名调用
add_lambda = lambda x, y : x + y
print(add_lambda(10, 20))
# 运行结果：309.4 常用场景（配合内置高阶函数）
lambda 绝大多数场景，配合map()、filter()、sorted()等高阶函数使用，作为临时参数传入。案例：列表元素平方计算
list1 = [1,2,3,4,5]
# map+lambda：批量处理列表元素
res = list(map(lambda x : x**2, list1))
print(res)
# 运行结果：[1, 4, 9, 16, 25]9.5 lambda 限制总结
- 函数体只能有一行表达式，不能写循环、多分支多行代码
- 自动返回表达式结果，无需 return
- 仅适合简单逻辑，复杂功能必须用 def 定义普通命名函数
十、Python 常用内置 & 标准库函数
结合入门高频考点，讲解日常开发最常用的函数：基础内置函数、日历函数、随机数函数，全部配套可运行代码。
10.1 Python 高频内置基础函数
Python 解释器自带，直接调用即可
# len() 获取数据长度
print(len([1,2,3,4]))
# 运行结果：4
# max() 获取最大值、min()获取最小值
print(max(10,20,5,30))
# 运行结果：30
# sum() 序列求和
print(sum([1,2,3,4,5]))
# 运行结果：1510.2 日历函数（calendar标准库）
Python 内置日历库，专门用于处理年、月、日日历相关操作，需要先导入库 import calendar
import calendar
# 1. 获取指定年月的日历
print(calendar.month(2026, 4))
# 运行结果：
# April 2026
# Mo Tu We Th Fr Sa Su
# 1 2 3 4
# 5 6 7 8 9 10 11
# 12 13 14 15 16 17 18
# 19 20 21 22 23 24 25
# 26 27 28 29 30
# 2. 判断是否为闰年
print("2026是否为闰年：", calendar.isleap(2026))
# 运行结果：2026是否为闰年： False
print("2024是否为闰年：", calendar.isleap(2024))
# 运行结果：2024是否为闰年： True
# 3. 获取某月第一天星期数、当月总天数
week, days = calendar.monthrange(2026, 4)
print(f"2026年4月第一天星期{week}，当月共{days}天")
# 运行结果：2026年4月第一天星期2，当月共30天10.3 随机数函数（random标准库）
开发高频库，用于生成各类随机数、随机选取数据，需要先导入 import random
import random
# 1. 生成 [0,1) 之间的随机浮点数
print(random.random())
# 运行结果示例：0.356215489
# 2. 生成 [a,b] 闭区间随机整数
print(random.randint(1, 100))
# 运行结果示例：56
# 3. 从序列中随机选取一个元素
list_data = ["A","B","C","D"]
print(random.choice(list_data))
# 运行结果示例：B
# 4. 从序列中随机选取k个元素，返回新列表
print(random.sample(list_data, 2))
# 运行结果示例：['A', 'D']十一、全篇知识点总结
- 函数核心价值是代码复用、模块化编程，
def定义、函数名 () 调用 - 参数体系：位置参数 → 默认参数（必须在普通参数后方）→
*args元组不定长 →**kwargs字典不定长 - 返回值
return：结束函数、返回数据，无 return 默认返回None；函数按「有无参数、有无返回值」分为 4 大类 - 函数支持嵌套调用，严格遵循「外层调用内层，内层执行完返回外层」的执行流程
- 变量作用域：局部变量仅限函数内部；全局变量全文件可读，函数内修改必须
global；嵌套内层改外层局部变量用nonlocal - 递归函数 = 自己调用自己 + 终止出口；lambda 匿名函数适合简单单行逻辑，配合高阶函数使用
- 入门必备库函数：日历
calendar、随机数random库，是日常开发高频工具函数
这里是“一人公司”的成长家园。我们提供从产品曝光、技术变现到法律财税的全栈内容，并连接云服务、办公空间等稀缺资源，助你专注创造，无忧运营。
更多推荐
13
0- 0
已为社区贡献6条内容
所有评论(0)