有教做素食的网站吗,pagespeed WordPress,苏州园区手机网站制作,嘉兴商城网站开发设计欢迎来到ZyyOvO的博客✨#xff0c;一个关于探索技术的角落#xff0c;记录学习的点滴#x1f4d6;#xff0c;分享实用的技巧#x1f6e0;️#xff0c;偶尔还有一些奇思妙想#x1f4a1; 本文由ZyyOvO原创✍️#xff0c;感谢支持❤️#xff01;请尊重原创#x1… 欢迎来到ZyyOvO的博客✨一个关于探索技术的角落记录学习的点滴分享实用的技巧️偶尔还有一些奇思妙想 本文由ZyyOvO原创✍️感谢支持❤️请尊重原创欢迎评论区留言交流 个人主页 ZyyOvO 本文专栏➡️Python 算法研究所 快速复习【Python 速览 】 —— 课前甜点打开你的味蕾
课前导入
我们知道数学中的函数我们输入一个数在通过对应的映射关系得到另一个数如下图给出了两个简单的数学函数
什么是函数
那在Python编程中函数是什么呢
在编程中函数Function 是一段被命名、可重复使用的代码块用于执行特定任务它通过接收输入参数处理逻辑并返回输出结果将复杂的程序拆分为模块化的组件让代码更简洁、高效且易于维护。
函数的优势
在 Python 中函数是编程的核心工具之一它通过将代码逻辑封装为可重复使用的模块显著提升了代码的可维护性、复用性和可读性。
避免代码重复DRY 原则Dont Repeat Yourself
问题场景 当同一段代码需要多次使用时复制粘贴会导致代码臃肿且后续修改需要逐一调整所有副本。函数解决方案 将重复代码封装为函数通过一次定义、多次调用来实现逻辑复用。
# 重复代码示例计算圆面积
radius1 5
area1 3.14 * radius1 ** 2radius2 7
area2 3.14 * radius2 ** 2# 使用函数优化
def calculate_circle_area(radius):return 3.14 * radius ** 2area1 calculate_circle_area(5)
area2 calculate_circle_area(7)修改逻辑只需调整函数内部代码例如将 3.14 改为 math.pi。减少代码量避免冗余。
模块化编程分解复杂问题
问题场景 一个大型程序如果写成连续的代码块会难以理解和维护。函数解决方案 将程序拆分为多个函数每个函数负责单一职责。
# 未使用函数的复杂逻辑
data [1, 2, 3, 4, 5]
sum 0
for num in data:sum num
average sum / len(data)
print(f平均值: {average})# 使用函数模块化
def calculate_average(data):return sum(data) / len(data)data [1, 2, 3, 4, 5]
print(f平均值: {calculate_average(data)})代码逻辑清晰每个函数聚焦一个子任务。便于团队协作开发。
提升代码可读性
问题场景 长段代码缺乏注释时阅读者需要逐行理解逻辑。函数解决方案 通过函数名称直接表明代码意图。
# 难读的代码
x 5
y 10
result (x ** 2 y ** 2) ** 0.5# 使用函数自解释
def calculate_hypotenuse(a, b):return (a**2 b**2) ** 0.5result calculate_hypotenuse(5, 10)函数名如 calculate_hypotenuse直接说明功能。减少对注释的依赖。
参数化与灵活性
问题场景 相似逻辑需要处理不同输入数据时硬编码值会限制灵活性。函数解决方案 通过参数动态接收输入返回处理结果。
# 硬编码的欢迎语
print(欢迎张三)
print(欢迎李四)# 参数化函数
def greet(name):print(f欢迎{name})greet(张三)
greet(李四)同一函数适应不同输入。支持动态数据处理。
错误隔离与调试效率
问题场景 代码错误可能出现在任意位置调试时需全局排查。函数解决方案 将代码划分为函数后错误通常能被隔离到特定函数内。
def load_data(filename):# 假设此处可能抛出文件不存在的错误with open(filename, r) as f:return f.read()def process_data(data):# 此处可能处理数据时出错return data.upper()try:data load_data(data.txt)result process_data(data)
except Exception as e:print(f错误发生在: {e})快速定位问题函数。通过单元测试单独验证每个函数。
支持代码复用与库开发
问题场景 通用功能如数据验证、数学计算需要在多个项目中重复实现。函数解决方案 将通用函数封装为模块.py 文件供其他程序导入。
# utils.py
def is_prime(n):if n 1:return Falsefor i in range(2, int(n**0.5)1):if n % i 0:return Falsereturn True# main.py
from utils import is_prime
print(is_prime(17)) # 输出: True积累个人代码库提升开发效率。促进开源社区协作如 numpy、requests 等库。
实现递归算法
问题场景 某些问题如阶乘、斐波那契数列天然适合递归解决。函数解决方案 函数可以调用自身简化递归逻辑。
def factorial(n):if n 0:return 1else:return n * factorial(n-1)print(factorial(5)) # 输出: 120以简洁方式解决复杂递归问题。代码更接近数学定义。
应用场景函数的核心作用代码重复封装重复逻辑实现 DRY 原则复杂问题分解为模块化组件降低认知负担可读性差通过命名自解释代码意图动态数据处理参数化输入提升灵活性错误调试隔离问题范围简化排查流程代码复用构建可共享的代码库递归问题实现自我调用的算法逻辑
通过函数Python 代码从“一次性脚本”升级为可维护、可扩展的工程化项目。它是构建大型应用、开源库和高效算法的基石。 定义函数
例如我们写一段代码来求斐波那契数列
def fib(n): # 打印小于 n 的斐波那契数列Print a Fibonacci series less than n.a, b 0, 1while a n:print(a, end )a, b b, ab定义 函数使用关键字 def后跟函数名与括号内的形参列表。函数语句从下一行开始并且必须缩进。
函数内的第一条语句是字符串时该字符串就是文档字符串也称为 docstring。Python 开发者最好养成在代码中加入文档字符串的好习惯。
函数在 执行 时使用函数局部变量符号表所有函数变量赋值都存在局部符号表中引用变量时首先在局部符号表里查找变量然后是外层函数局部符号表再是全局符号表最后是内置名称符号表。因此尽管可以引用全局变量和外层函数的变量但最好不要在函数内直接赋值除非是 global 语句定义的全局变量或 nonlocal 语句定义的外层函数变量。 函数对象的概念 在调用函数时会将实际参数实参引入到被调用函数的局部符号表中因此实参是使用 按值调用 来传递的其中的 值 始终是对象的 引用 而不是对象的值。 当一个函数调用另外一个函数时会为该调用创建一个新的局部符号表。
在Python中遵循着一切皆对象的原则无论是变量函数亦或是类在Python看来都是对象因此函数定义在当前符号表中把函数名与函数对象关联在一起。解释器把函数名指向的对象作为用户自定义函数。 还可以使用其他名称指向同一个函数对象并访问访该函数例如我们上面写的求斐波那契数列的函数
def fib(n): # 打印小于 n 的斐波那契数列Print a Fibonacci series less than n.a, b 0, 1while a n:print(a, end )a, b b, abf fib #将函数对象赋值给ff(100) #调用f
print()
fib(100) #调用fib()输出
0 1 1 2 3 5 8 13 21 34 55 89
0 1 1 2 3 5 8 13 21 34 55 89 如果你学过其他语言比如C语言或者C你可能会认为 fib 不是函数而是一个过程语句因为它没有返回值。 事实上即使没有 return 语句的函数也有返回值 这个值被称为 None (是一个内置名称Python中函数的默认返回值)。 通常解释器会屏蔽单独的返回值 None。 如果你确有需要可以使用 print() 查看它:
print(fib(0))
#输出
None编写不直接输出斐波那契数列运算结果而是返回运算结果列表的函数也非常简单只需要在函数中定义列表将斐波那契数使用append接口加入到列表中最后返回列表对象即可
def fib2(n): # 返回斐波那契数组直到 nReturn a list containing the Fibonacci series up to n.result []a, b 0, 1while a n:result.append(a) # 见下a, b b, abreturn resultf100 fib2(100) # 调用它
f100 # 输出结果
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]函数定义详解
函数定义支持可变数量的参数。这里列出三种可以组合使用的形式。
默认值参数
为参数指定默认值是非常有用的方式。调用函数时可以使用比定义时更少的参数例如
def ask_ok(prompt, retries4, reminderPlease try again!):while True:reply input(prompt)if reply in {y, ye, yes}:return Trueif reply in {n, no, nop, nope}:return Falseretries retries - 1if retries 0:raise ValueError(invalid user response)print(reminder)该函数有三种调用方式
只给出必选实参ask_ok(Do you really want to quit?)给出一个可选实参ask_ok(OK to overwrite the file?, 2)给出所有实参
ask_ok(OK to overwrite the file?, 2, Come on, only yes orno!)retries 和 reminder 是 默认参数。默认参数在函数定义时指定了默认值调用函数时如果没有为这些参数提供值就会使用默认值。而prompt是位置参数调用函数时必须按照顺序传递参数否则就会导致错误
使用示例
try:#异常捕获result ask_ok(Do you want to continue? )if result:print(You agreed!)else:print(You disagreed!)
except ValueError as e:print(e)默认值在 定义 作用域里的函数定义中求值 所以
i 5def f(argi):print(arg)i 6
f()上例输出的是 5。为什么呢 这里创建了一个全局变量 i并将其赋值为 5。在定义函数 f 时默认参数 arg 的值被设定为当前全局变量 i 的值也就是 5。需要注意的是Python 函数的默认参数值是在函数定义时就确定下来的而不是在函数调用时确定。
将全局变量 i 的值修改为 6但这并不会影响函数 f 中默认参数 arg 的值因为 arg 的默认值在函数定义时就已经确定为 5 了。
值得注意的是 默认值只计算一次。默认值为列表、字典或类实例等可变对象时会产生与该规则不同的结果。例如下面的函数会累积后续调用时传递的参数
def f(a, L[]):L.append(a)return Lprint(f(1))
print(f(2))
print(f(3))输出结果如下
[1]
[1, 2]
[1, 2, 3]这里定义了函数 f其中参数 L 的默认值是一个空列表 []。需要特别注意的是在 Python 中函数的默认参数是在函数定义时就被创建的并且只创建一次。也就是说无论函数被调用多少次这个默认的列表 L 始终是同一个对象。
如果不想在后续调用之间共享默认值时应以如下方式编写函数
def f(a, LNone):if L is None:L []L.append(a)return L这样修改后每次调用函数时如果没有传入 L 参数都会创建一个新的空列表输出结果将分别为
[1]
[2]
[3]关键字参数
keyvalue 形式的 关键字参数 也可以用于调用函数。函数示例如下
def parrot(voltage, statea stiff, actionvoom, typeNorwegian Blue):print(-- This parrot wouldnt, action, end )print(if you put, voltage, volts through it.)print(-- Lovely plumage, the, type)print(-- Its, state, !)该函数接受一个必选参数voltage和三个可选参数state, action 和 type。该函数可用下列方式调用
parrot(1000) # 1 个位置参数
parrot(voltage1000) # 1 个关键字参数
parrot(voltage1000000, actionVOOOOOM) # 2 个关键字参数
parrot(actionVOOOOOM, voltage1000000) # 2 个关键字参数
parrot(a million, bereft of life, jump) # 3 个位置参数
parrot(a thousand, statepushing up the daisies) # 1 个位置参数1 个关键字参数以下调用函数的方式都无效
parrot() # 缺失必需的参数
parrot(voltage5.0, dead) # 关键字参数后存在非关键字参数
parrot(110, voltage220) # 同一个参数重复的值
parrot(actorJohn Cleese) # 未知的关键字参数函数调用时关键字参数必须跟在位置参数后面.
例如以下调用方式是错误的
# 错误示例位置参数应在关键字参数之前
parrot(statedead, 300)所有传递的关键字参数都必须匹配一个函数接受的参数比如actor 不是函数 parrot 的有效参数关键字参数的顺序并不重要。这也包括必选参数比如parrot(voltage1000) 也有效。不能对同一个参数多次赋值下面就是一个因此限制而失败的例子
def function(a):passfunction(0, a0)最后一个形参为 **name 形式时接收一个字典(映射类型 — dict)该字典包含与函数中已定义形参对应之外的所有关键字参数。**name 形参可以与 *name 形参下一小节介绍组合使用*name 必须在 **name 前面 *name 形参接收一个 元组该元组包含形参列表之外的位置参数。例如可以定义下面这样的函数
def cheeseshop(kind, *arguments, **keywords):print(-- Do you have any, kind, ?)print(-- Im sorry, were all out of, kind)for arg in arguments:print(arg)print(- * 40)for kw in keywords:print(kw, :, keywords[kw])参数解释:
kind这是一个普通的位置参数调用函数时必须提供该参数的值用于指定奶酪的种类。*arguments这是一个可变位置参数它会将函数调用时传入的除了第一个位置参数即 kind之外的所有位置参数收集到一个元组中。在函数内部可以通过遍历这个元组来处理这些参数。**keywords这是一个可变关键字参数它会将函数调用时传入的所有未在函数定义中明确指定的关键字参数收集到一个字典中。字典的键是关键字参数的名称值是对应的参数值。
该函数可以用如下方式调用
cheeseshop(Limburger, Its very runny, sir.,Its really very, VERY runny, sir.,shopkeeperMichael Palin,clientJohn Cleese,sketchCheese Shop Sketch)第一个参数 Limburger 被赋值给 kind。 接下来的两个字符串 Its very runny, sir. 和 Its really very, VERY runny, sir. 被收集到 arguments 元组中。 最后三个关键字参数 shopkeeperMichael Palin、clientJohn Cleese 和 sketchCheese Shop Sketch 被收集到 keywords 字典中。
输出结果如下
-- Do you have any Limburger ?
-- Im sorry, were all out of Limburger
Its very runny, sir.
Its really very, VERY runny, sir.
----------------------------------------
shopkeeper : Michael Palin
client : John Cleese
sketch : Cheese Shop Sketch在 Python 中*arguments可变位置参数必须放在 **keywords可变关键字参数之前否则会导致语法错误为什么呢
Python 函数在调用时会按照特定的顺序解析传入的参数具体顺序为
位置参数 - 可变位置参数 - 关键字参数 - 可变关键字参数。位置参数是按照参数定义的顺序依次接收传入的值。可变位置参数会收集所有剩余的位置参数即除了已被普通位置参数接收的部分到一个元组中。关键字参数通过参数名来指定传入的值。可变关键字参数会收集所有未在函数定义中明确指定的关键字参数到一个字典中。
如果 **keywords 放在 *arguments 之前当函数调用时Python 解释器在解析参数时就会遇到问题。因为 **keywords 会优先收集所有的关键字参数而此时如果还有剩余的位置参数就无法正确地将它们收集到 *arguments 中因为 *arguments 是用来收集位置参数的而在 **keywords 之后解释器已经无法区分哪些是位置参数了。
注意关键字参数在输出结果中的顺序与调用函数时的顺序一致。 特殊参数
默认情况下参数可以按位置或显式关键字传递给 Python 函数。为了让代码易读、高效最好限制参数的传递方式这样开发者只需查看函数定义即可确定参数项是仅按位置、按位置或关键字还是仅按关键字传递。
函数定义如下
def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):----------- ---------- ----------| | || 位置或关键字 || - 仅限关键字-- 仅限位置/ 和 * 是可选的。这些符号表明形参如何把参数值传递给函数位置、位置或关键字、关键字。关键字形参也叫作命名形参。
位置或关键字参数
函数定义中未使用 / 和 * 时参数可以按位置或关键字传递给函数。
仅位置参数
此处再介绍一些细节特定形参可以标记为 仅限位置。仅限位置 时形参的顺序很重要且这些形参不能用关键字传递。仅限位置形参应放在 / 正斜杠前。/ 用于在逻辑上分割仅限位置形参与其它形参。如果函数定义中没有 /则表示没有仅限位置形参。 / 后可以是 位置或关键字 或 仅限关键字 形参。
仅限关键字参数
把形参标记为 仅限关键字表明必须以关键字参数形式传递该形参应在参数列表中第一个 仅限关键字 形参前添加 *。
简单的函数示例
注意 / 和 * 标记
def standard_arg(arg):print(arg)def pos_only_arg(arg, /):print(arg)def kwd_only_arg(*, arg):print(arg)def combined_example(pos_only, /, standard, *, kwd_only):print(pos_only, standard, kwd_only)第一个函数定义 standard_arg 是最常见的形式对调用方式没有任何限制可以按位置也可以按关键字传递参数
位置参数
standard_arg(2)
#输出
2关键字参数
standard_arg(arg2)
#输出
2第二个函数 pos_only_arg 的函数定义中有 /仅限使用位置形参
位置形参
pos_only_arg(1)
#输出
1关键字参数报错
pos_only_arg(arg1)
Traceback (most recent call last):File stdin, line 1, in module
TypeError: pos_only_arg() got some positional-only arguments passed as keyword arguments: arg第三个函数 kwd_only_arg 如在函数定义中通过 * 所指明的那样只允许关键字参数。
位置参数报错
kwd_only_arg(3)
Traceback (most recent call last):File stdin, line 1, in module
TypeError: kwd_only_arg() takes 0 positional arguments but 1 was given关键字参数
kwd_only_arg(arg3)
#输出
3最后一个函数在同一个函数定义中使用了全部三种调用惯例
全部位置参数报错
combined_example(1, 2, 3)
Traceback (most recent call last):File stdin, line 1, in module
TypeError: combined_example() takes 2 positional arguments but 3 were given位置参数和关键字参数
combined_example(1, 2, kwd_only3)
#输出
1 2 3combined_example(1, standard2, kwd_only3)
#输出
1 2 3全部关键字参数报错
combined_example(pos_only1, standard2, kwd_only3)
Traceback (most recent call last):File stdin, line 1, in module
TypeError: combined_example() got some positional-only arguments passed as keyword arguments: pos_only下面的函数定义中kwds 把 name 当作键因此可能与位置参数 name 产生潜在冲突
def foo(name, **kwds):return name in kwds调用该函数不可能返回 True因为关键字 name 总与第一个形参绑定。例如
foo(1, **{name: 2})
Traceback (most recent call last):File stdin, line 1, in module
TypeError: foo() got multiple values for argument name代码报错原因
当执行 foo(1, **{name: 2}) 时 首先Python 会把位置参数 1 赋值给 name这是按照位置参数的传递规则来的。 接着要把字典 {name: 2} 解包传递给函数。但是这时 Python 发现name 这个参数已经被位置参数 1 赋值过了现在又有一个关键字参数 name2 要进来就会产生冲突。因为在 Python 里一个参数不能被多次赋值所以就会抛出 TypeError: foo() got multiple values for argument name 异常。
正确做法
加上 / 仅限位置参数后就可以了。此时函数定义把 name 当作位置参数name 也可以作为关键字参数的键
def foo(name, /, **kwds):return name in kwdsfoo(1, **{name: 2})
#输出
True这里的 / 起到了关键作用它把 name 变成了仅限位置参数。这就规定了 name 只能通过位置的方式来传值不能用关键字参数的方式传值。
调用过程分析 当调用 foo(1, **{name: 2}) 时 位置参数 1 会被正常赋值给仅限位置参数 name这是符合仅限位置参数的传递规则的。 对于字典 {name: 2}由于 name 是仅限位置参数字典里的 name 键就不会和函数定义里的 name 参数冲突了。**kwds 会把这个 {name: 2} 字典收集起来成为一个包含 name: 2 的字典。 函数内部的 name in kwds 语句会去检查 name 这个键是否在 kwds 字典里因为 kwds 字典里确实有 name 键所以函数就会返回 True。
可以把这种情况想象成有两个不同的 “区域”一个区域仅限位置参数 name只能通过位置传递的方式放东西进去另一个区域**kwds 字典可以接收关键字参数。这样就避免了参数名的冲突。
换句话说仅限位置形参的名称可以在 **kwds 中使用而不产生歧义。
小结
以下用例决定哪些形参可以用于函数定义
def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):说明
使用仅限位置形参可以让用户无法使用形参名。形参名没有实际意义时强制调用函数的实参顺序时或同时接收位置形参和关键字时这种方式很有用。当形参名有实际意义且显式名称可以让函数定义更易理解时阻止用户依赖传递实参的位置时才使用关键字。对于 API使用仅限位置形参可以防止未来修改形参名时造成破坏性的 API 变动。
函数的变量
变量的作用域 在 Python 中作用域定义了变量和函数的可见性与生命周期它决定了在程序的哪些部分可以访问特定的变量或函数。Python 中有四种主要的作用域按照搜索变量的顺序依次为局部作用域Local、闭包作用域Enclosing、全局作用域Global和内置作用域Built-in通常用 LEGB 规则来描述这个搜索顺序。下面为你详细介绍这四种作用域。
内置作用域Built-in
定义内置作用域是 Python 预先定义好的包含了所有内置的函数、异常和对象如 print()、len()、int 等。这些名称在整个 Python 程序中都是可用的无需额外导入。 示例
# 直接使用内置函数 print 和 len
print(len([1, 2, 3]))在这个例子中print 和 len 都是内置作用域中的函数可以直接使用。 全局作用域Global
定义全局作用域是在整个模块即 .py 文件中定义的作用域。在模块顶层定义的变量和函数都属于全局作用域它们可以在模块的任何地方被访问但在函数内部如果要修改全局变量需要使用 global 关键字。 示例
# 定义全局变量
global_variable 10def print_global_variable():# 可以在函数内部访问全局变量print(global_variable)print_global_variable() # 输出: 10def modify_global_variable():global global_variableglobal_variable 20modify_global_variable()
print(global_variable) # 输出: 20在上述代码中global_variable 是全局变量可以在函数 print_global_variable 中直接访问。而在 modify_global_variable 函数中如果要修改全局变量的值需要使用 global 关键字声明。
闭包作用域Enclosing
定义闭包作用域也称为嵌套作用域它出现在嵌套函数中。当一个函数内部定义了另一个函数时内部函数可以访问外部函数的局部变量这些外部函数的局部变量就处于闭包作用域中。在 Python 中闭包是一种特殊的对象它可以捕获并保存外部函数的局部变量状态。 示例
def outer_function():enclosing_variable 5def inner_function():# 内部函数可以访问外部函数的局部变量print(enclosing_variable)return inner_functionclosure outer_function()
closure() # 输出: 5在这个例子中inner_function 是嵌套在 outer_function 内部的函数enclosing_variable 是 outer_function 的局部变量对于 inner_function 来说它处于闭包作用域中因此 inner_function 可以访问这个变量。
局部作用域Local
定义局部作用域是在函数内部定义的作用域。函数内部定义的变量和参数都属于局部作用域它们只能在函数内部被访问函数执行结束后局部变量会被销毁。 示例
def local_scope_example():local_variable 3print(local_variable)local_scope_example() # 输出: 3
# print(local_variable) # 会报错因为 local_variable 是局部变量外部无法访问在 local_scope_example 函数内部定义的 local_variable 是局部变量只能在函数内部访问在函数外部尝试访问会引发 NameError 异常。 函数中变量的查找顺序 在 Python 中函数内部的变量查找遵循 LEGB 规则即按照以下顺序逐层查找变量 L → E → G → B
Local局部作用域 → Enclosing闭包外层 → Global全局 → Built-in内置Local局部作用域
优先级最高首先在函数内部查找变量
示例
def func():x 10 # 局部变量print(x) # 输出 10优先查找局部func()Enclosing闭包外层
适用于嵌套函数在外层函数的作用域中查找
示例
def outer():y 20def inner():print(y) # 查找闭包外层的 y → 20inner()outer()Global全局作用域
模块级变量在函数外部定义的变量
示例
z 30
def func():print(z) # 查找全局的 z → 30func()Built-in内置作用域
Python 内置函数/变量如 len, str, True 等
示例
def func():print(len) # 找到内置函数 len → built-in function lenfunc()关键注意
赋值操作的影响
若在函数内部对变量赋值Python 会默认将其视为局部变量即使全局存在同名变量
x 100
def func():x 200 # 创建新的局部变量print(x) # 输出 200func()
print(x) # 输出 100全局变量未变global 关键字 强制使用全局变量
x 100
def func():global xx 200 # 修改全局变量print(x) # 输出 200func()
print(x) # 输出 200nonlocal 关键字 在嵌套函数中使用外层非全局变量
def outer():x 10def inner():nonlocal xx 20 # 修改闭包外层的 xinner()print(x) # 输出 20outer()变量未定义时的报错若所有作用域均未找到变量
def func():print(undefined_var) # 报错 NameErrorfunc()#mermaid-svg-Ec0KNvMoVDPn9LWJ {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .error-icon{fill:#552222;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .marker{fill:#333333;stroke:#333333;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .marker.cross{stroke:#333333;}#mermaid-svg-Ec0KNvMoVDPn9LWJ svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .cluster-label text{fill:#333;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .cluster-label span{color:#333;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .label text,#mermaid-svg-Ec0KNvMoVDPn9LWJ span{fill:#333;color:#333;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .node rect,#mermaid-svg-Ec0KNvMoVDPn9LWJ .node circle,#mermaid-svg-Ec0KNvMoVDPn9LWJ .node ellipse,#mermaid-svg-Ec0KNvMoVDPn9LWJ .node polygon,#mermaid-svg-Ec0KNvMoVDPn9LWJ .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .node .label{text-align:center;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .node.clickable{cursor:pointer;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .arrowheadPath{fill:#333333;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .cluster text{fill:#333;}#mermaid-svg-Ec0KNvMoVDPn9LWJ .cluster span{color:#333;}#mermaid-svg-Ec0KNvMoVDPn9LWJ div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-Ec0KNvMoVDPn9LWJ :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 是 否 是 否 是 否 是 否 函数内访问变量 是局部变量? 使用局部变量 是闭包外层变量? 使用外层变量 是全局变量? 使用全局变量 是内置变量? 使用内置变量 抛出 NameError 本文小结
本文有关Python中初级函数话题到这里就结束了后面的文章我们会展开继续 Python函数的更多话题如内置高级函数lambda表达式任意实参列表等等… 感谢您的观看 如果你觉得这篇文章对你有所帮助请为我的博客 点赞收藏⭐️ 评论或 分享 支持一下你的每一个支持都是我继续创作的动力✨ 如果你有任何问题或想法也欢迎 留言 交流一起进步❤️ 感谢你的阅读和支持 祝各位大佬吃得饱睡得好日有所得逐梦扬帆⛵
