目录
1、函数的定义
函数：是组织好的、可重复使用的，用来实现特定功能的代码段。
函数的格式如下：
def 函数名（传入参数）：
函数体
return 值或变量
使用函数的好处：
（1）将功能封装在函数内，可供随时随地重复利用。
（2）提高程序的复用性，减少重复性代码，提高开发效率。
s = "asdfghjkl"
#定义函数
def my_len(date):
count = 0
for i in date:
count += 1
print(f"字符串{date}的长度是{count}")
#调用函数
my_len(s)
#结果
字符串asdfghjkl的长度是92、函数的参数
传入参数：在函数进行计算的时候，接受外部（调用时）提供的数据，数量不受限制。
形式参数（形参）：表示函数声明将要使用的参数，参数之间使用逗号分隔。
实际参数（实参）：表示函数执行时真正使用的参数值，传入时要和形式参数一一对应，参数之间用逗号分隔。
#定义函数
def add(x,y): #x,y是形式参数
result = x + y
print(f"{x}+{y}的结果是{result}")
#调用函数
add(5,5) #5,5是对应的实际参数
#结果
5+5的结果是10（1）位置参数：调用函数时按照定义的参数位置，依次传递参数。
注意：传递的参数和定义的参数的顺序及个数必须一致。
（2）关键字参数：函数调用时通过“键=值”形式传递参数。
注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。
（3）缺省值参数：也叫默认参数，在定义函数时，为参数提供默认值，调用函数时可不传该默认参数的值
注意：1.所有位置参数必须出现在默认参数前面，包括函数的定义和调用，即默认值必须定义在最后面。
2.函数调用时，如果为缺省参数传值，则修改默认参数值，否则使用这个默认值。
（4）可变参数：也叫不定长传参，用于参数个数不确定（不传参也可以）的场景。
类型：
位置传递：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组（tuple），args是元组类型。形式参数一般命名为args。
关键字传递：参数是“键=值”形式的情况下，所有的“键=值”都会被kwargs接收，同时会根据“键=值”组成字典。形式参数一般命名为kargs。
def use(name,age,gender):
print(f"你的名字是{name},年龄是{age},性别是{gender}")
# 位置传参
use("小明",20,"男")
# 关键字传参
use(name="小明",age=20,gender="男")
use(name="小明",gender="男",age=20) # 可以不按照固定顺序
use("小明",age=20,gender="男") # 可以和位置参数混用，位置参数必须在前，且按照参数顺序，但关键字参数不存在先后顺序
# 缺省传参
def use(name,age,gender="男"):
print(f"你的名字是{name},年龄是{age},性别是{gender}")
use("小明",20)
use("小明",20,"女")
# 可变参数--位置传递*号
def use_f(*args):
print(args)
use_f("A") # 不定长定义的形式参数会作为元组存在
use_f("A","B",18)
# 可变参数--关键字传递**号
def use_f(**kargs):
print(kargs)
use_f(name="A") # # 不定长定义的形式参数会作为字典存在
use_f(name="A",id=666666,age=18)
#结果
你的名字是小明,年龄是20,性别是男
你的名字是小明,年龄是20,性别是男
你的名字是小明,年龄是20,性别是男
你的名字是小明,年龄是20,性别是男
你的名字是小明,年龄是20,性别是男
你的名字是小明,年龄是20,性别是女
('A',)
('A', 'B', 18)
{'name': 'A'}
{'name': 'A', 'id': 666666, 'age': 18}3、函数作为参数传递
#定义一个函数，接受另一个函数作为传入参数
def func(compute):
result = compute(3,4) #确定compute是函数
print(result)
#定义一个函数，准备作为参数传入另一个函数
def compute(x,y):
return x+y
#调用，并传入函数
func(compute)
#结果
7函数compute，作为参数，传入了func函数中使用。
（1）func需要一个函数作为参数传入，这个函数需要接受2个数字进行计算，计算逻辑由这个被传入的函数决定。
（2）compute函数接受2个数字对其进行计算，compute函数作为参数，传递给了func函数使用。
（3）最终，在func函数内部，由传入的compute函数，完成了对数字的计算操作。
注意：1°这是计算逻辑的传递，而非数据的传递。
2°任何逻辑都可以自行定义并作为函数传入。
4、lambda匿名函数
函数的定义中：
def关键字，可以定义带有名称的函数
lambda关键字，可以定义匿名函数（无名称）
注意：（1）由名称的函数，可以基于函数名重复使用
（2）无名称的匿名函数，只可以临时使用一次
（3）二者定义的函数功能完全一致
匿名函数的定义语法：
lambda 传入参数：函数体（一行代码）
注意：（1）lambda是关键字，表示定义匿名函数
（2）传入参数表示匿名函数的形式参数，如：x，y表示接收2个形式参数
（3）函数体：就是函数的执行逻辑，要注意：只能写一行，无法写多行代码。
def func(compute):
result = compute(1,2)
print(result)
func(lambda x,y:x+y)
#结果
35、函数的返回值
程序中函数完成事情后，最后返回给调用者的结果
def 函数名（传入参数）：
函数体
return 返回值
变量=函数（参数）
如图，定义两数相加的函数功能，完成功能后，会将相加的结果返回给函数调用者，所以，变量a接收到了函数的执行结果。
def add(x,y):
result = x + y
return result
a = add(1,2)
print(a)
#结果
3注意：函数体在遇到return后就结束了，所以写在return后的代码不会执行。
（1）None（None表示：空的，无实际意义）
如果函数没有使用return语句返回数据，那么函数就会返回None。
函数返回的None，就表示，这个函数没有返回什么有意义的内容，也就是返回了空的意思。
注意：None可以主动使用return返回，效果等于不写return语句。
def say():
print("hello")
# 使用变量接受say()函数的返回值
result = say()
# 打印返回值
print(result)
def say():
print("hello")
return None
# 使用变量接受say()函数的返回值
result = say()
# 打印返回值
print(result)
#结果
hello
None
hello
NoneNone类型的应用场景：
1°用在函数无返回值
2°用在if判断上：None等于False（一般用于函数主动返回None）
def check_age(age):
if age > 18:
return "success"
return None
result =check_age(5)
# 进入if表示result是None值，也就是False
if not result:
print("未成年，不可以进入")
if result:
print(result)
print("成年，可以进入")
#结果
未成年，不可以进入3°用于声明无内容的变量上：定义变量，但暂时不需要变量有具体值
name=None
（2）多个返回值
按照返回值的顺序，写对应顺序的多个变量接收即可：
变量之间用逗号隔开，支持不同类型的数据return
#多个返回值
def test_return():
return 1,2
return 3 # 不执行，上一个return已经退出当前函数
x,y = test_return()
print(x)
print(y)
#结果
1
26、函数的说明文档
通过多行注释的形式，对函数进行说明解释，辅助理解函数的作用。内容写在函数体之前。
def func（x，y）：
"""
函数说明
：param x：形参x的说明
：param y：形参y的说明
：return：返回值的说明
"""
函数体
return 返回值
7、函数的嵌套
函数嵌套调用：一个函数里面又调用了另一个函数
def func_b():
print("---2---")
def func_a():
print("---1---")
func_b()
print("---3---")
func_a()
#结果
---1---
---2---
---3---执行流程：
如果函数A中调用了另一个函数B，那么 先把函数B中的任务都执行完毕之后才会回到上次函数A执行的位置。
8、变量在函数中的作用域
变量的作用域：指的是变量的作用范围（变量在哪里可用，在哪里不可用）
分类：
（1）局部变量：定义在函数体内部的变量，即只在函数体内部生效
作用：在函数体内部，临时保存数据，即当函数调用完成之后，就销毁局部变量。
（2）全局变量：指的是在函数体内、外都能生效的变量
global关键字
使用global关键字可以在函数内部声明变量为全局变量
global 变量
num = 100
def A():
print(num)
def B():
# 设置内部定义的变量为全局变量
global num
num = 200
print(num)
A()
B()
print(f"全局变量num={num}")
#结果
100
200
全局变量num=200编写不易，谢谢宝子们的认真阅读~ 点赞关注支持一下吧！！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
