定义
函数：是组织好的，可重复使用的，用来实现特定功能的代码段。
• 将功能封装在函数内，可供随时随地重复利用
• 提高代码的复用性，减少重复代码，提高开发效率
# 函数的定义：
def 函数名(传入参数)：
函数体
return 返回值
# 函数的调用：
函数名(参数)
注意事项：
① 参数如不需要，可以省略
② 返回值如不需要，可以省略
③函数必须先定义后使用
lambda匿名函数
函数的定义中：
-
def关键字可以定义带有名称的函数
-
lambda关键字可以定义匿名函数（无名称）
-
有名称的函数，可以基于名称重复使用
-
无名称的函数，只可以临时使用一次
【语法】：lambda 传入参数：函数体(一行代码)
- lambda是关键字，表示定义匿名函数
- 传入参数表示匿名函数的形式参数，如：x,y表示接收2个形式参数
- 函数体，就是函数的执行逻辑，要注意：只能写一行，无法多行代码
【具体应用】
说明文档
函数是纯代码语言，想要理解其含义，就需要一行行的去阅读理解代码，效率比较低。
我们可以给函数添加说明文档，辅助理解函数的作用。
语法如下：
def add(x,y):
"""
函数说明
:param x:
:param y:
:return:
"""
函数体
return 返回值
其中：• :param 用于解释参数
• :return 用于解释返回值
在PyCharm编写代码时，可以通过鼠标悬停，查看调用函数的说明文档
参数
传入参数的功能是：在函数进行计算的时候，接收外部（调用时）提供的数据。
• 传入参数的数量是不受限制的。
• 可以不使用参数
• 也可以仅使用 任意 N 个参数
示例代码：
def add(x,y): # 定义两个数相加的函数
result = x + y
print(f"{x} + {y}的计算结果是：{result}")
# 调用函数，传入被计算的2个数字
add(5,6)
'''运行结果：
5 + 6的计算结果是：11'''
• 函数定义中，提供的 x 和 y ，称之为：形式参数（形参），表示函数声明将要使用 2 个参数
• 参数之间使用逗号进行分隔
• 函数调用中，提供的 5 和 6 ，称之为：实际参数（实参），表示函数执行时真正使用的参数值
• 传入的时候，要和形式参数一一对应，按照顺序传入数据，使用逗号分隔
使用方式上不同，函数有4种常见的参数使用方式：
位置参数
调用函数时根据函数定义的参数位置来传递参数
def user_info(name,age,gender):
print(f"您的名字是{name}，您的年龄是{age}，性别是{gender}")
user_info('Tom',20,'男')
注意：传递的参数和定义的参数的顺序及个数必须一致
关键字参数
函数调用时通过“键 = 值”形式传递参数
作用：可以让函数更加清晰，容易使用，同时也清除了参数的顺序需求
def user_info(name,age,gender):
print(f"您的名字是{name}，您的年龄是{age}，性别是{gender}")
user_info('Tom',20,'男')
# 关键字传参
user_info(name = "小明",age = 20,gender = "男")
# 可以不按照固定顺序
user_info(age = 20,gender = "男",name = "小明")
# 可以和为孩子参数混用，位置参数必须在前，且匹配参数顺序
user_info("小明",age = 20,gender = "男")
'''运行结果：
您的名字是Tom，您的年龄是20，性别是男
您的名字是小明，您的年龄是20，性别是男
您的名字是小明，您的年龄是20，性别是男
您的名字是小明，您的年龄是20，性别是男'''
注意：函数调用时，如果有位置参数时，位置参数必须在关键字的前面，但关键字参数之间不存在先后顺序。
缺省参数
缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）
作用：当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值
def user_info(name,age,gender='男'): # 默认gender是男
print(f"您的名字是{name},年龄是{age},性别是{gender}")
user_info('Tom',20)
user_info('Rose',18,'女')
注意：函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值。
不定长参数
不定长参数也叫可变参数，用于不确定调用的时候会传递多少个参数（不传参也可以）的场景
作用：当调用函数时不确定参数个数时，可以使用不定长参数
- 不定长参数的类型：
①位置传递：位置不定长，*号，不定长定义的形式参数会作为元组存在，接收不定长数量的参数传入
②关键字传递：关键字不定长，**号，
# 位置传递
def user_info(*args): # 通过*得到不定长
print(f"args参数的类型是：{type(args)}，内容是：{args}")
user_info(1,2,3,'Tom','男孩')
# 关键字传递
def user_info(**kwargs):
print(f"kwargs参数的类型是：{type(kwargs)}，内容是：{kwargs}")
user_info(name = '菜菜',age = 18,id = 110)
'''运行结果：
args参数的类型是：<class 'tuple'>，内容是：(1, 2, 3, 'Tom', '男孩')
kwargs参数的类型是：<class 'dict'>，内容是：{'name': '菜菜', 'age': 18, 'id': 110}'''
注意：①传递的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组，args是元组类型，这就是位置传递
②参数是**“键 = 值”**形式的形式情况下，所有的“键=值’都会被kwargs接受，同时会根据”键=值“组成字典
函数作为参数传递
所以，这是一种计算逻辑的传递，而非数据的传递
就像上述代码那样，不仅仅是相加，相乘，相除等任何逻辑都可以自行定义并作为函数传入
返回值
return返回值
函数在执行完成后，返回给调用者的结果
return 返回结果
# 可以用一个变量来接收这个结果
变量 = 函数(参数)
注意：函数体在遇到return后就结束了，所以写在return后的代码不会执行
def add(x,y): # 定义两个数相加的函数
result = x + y
return result
print("我完事了")
r = add(5,6)
print(f"5 + 6的计算结果是：{r}")
'''运行结果：
5 + 6的计算结果是：11'''
如果一个函数有多个返回值，该如何书写代码？
def test_return():
return 1,2
x,y = test_return()
print(x) # 结果1
print(y) # 结果2
按照返回值的顺序，写对应顺序的多个变量接收即可
变量之间用逗号隔开
支持不同类型的数据return
如果函数没有使用return语句返回数据，那么函数有返回值吗？
None返回值
Python中有一个特殊的字面量：None（表示：空的、无实际意义的意思），其类型是：<class 'NoneType'>
- 无返回值的函数，实际上就是返回了：None这个字面量
- 函数返回的None，就表示，这个函数没有返回什么有意义的内容。也就是返回了空的意思。
None的使用场景
- None可以主动使用return返回，效果等同于不写return语句：
return None
- 用在 if 判断上：在 if 判断中， None 等同于 False. 一般用于在函数中主动返回None ，配合 if 判断做相关处理
# None用于if判断
def check_age(age):
if age > 18:
return "SUCCESS"
else:
return None
result = check_age(16)
if result:
print(result)
if not result: # 进入if表示result是None值也是False
print("未成年，不可以进入")
'''运行结果：
未成年，不可以进入'''
- 用于声明无内容的变量上：定义变量，但暂时不需要变量有具体值，可以用None来代替
# None用于声明无初始内容的变量
name = None
嵌套使用
所谓函数嵌套调用指的是一个函数里面又调用了另外一个函数
如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置
注：其实函数调用非常简单，和正常使用函数无太大区别，多写几段代码就明白了
作用域
局部变量
全局变量
所谓全局变量，指的是在函数体内、外都能生效的变量
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
当全局变量和局部变量发生冲突时，优先使用局部变量
现在我们有一个需求，想在函数的内部去修改一下全局变量的值，那怎么办呢？
global关键字
☆ 使用 global关键字 可以在函数内部声明变量为全局变量, 如下所示：
num = 100
def testA():
print(num)
def testB():
# global关键字声明a是全局变量
global num
num = 200
print(num)
testA()
testB()
'''运行结果：
100
200'''
若不声明，则num = 100 因为： 当全局变量和局部变量发生冲突时，优先使用局部变量
函数
函数综合案例：黑马ATM
# 定义全局变量
money = 5000000
name = None
# 要求客户输入姓名
name = input("请输入您的姓名：")
def check(show_header):
if show_header: #通过传入参数控制下一行的运行与否
print("------------------查询余额-------------------")
print(f"{name}，您好，您的余额剩余：{money}元")
def saving(num):
global money # 使用 global关键字 才可以在函数内部声明变量为全局变量
money += num
print("--------------------存款--------------------")
print(f"{name}，您好，您存款{num}成功")
# 调用check()函数查询余额
check(False)
def get_money(num):
global money
money -= num
print("---------------------取款-------------------")
print(f"{name}，您好，您取款{num}成功")
check(False)
def main():
print("---------------------主菜单--------------------")
print(f"{name}，您好，欢迎来到黑马银行ATM。请选择操作：")
print("查询余额\t[输入1]") # 通过\t制表符对齐输出
print("存款\t\t[输入2]")
print("取款\t\t[输入3]")
print("退出\t\t[输入4]")
return input("请输入您的选择：")
# 设置无限循环，确保程序不退出
while True:
keyboard_input = main() # 调用main函数显示主菜单，同时接收键盘输入值
if keyboard_input == "1":
check(True)
continue
elif keyboard_input == "2":
num = int(input("您想要存入多少钱？请输入："))
saving(num)
continue
elif keyboard_input == "3":
num = int(input("您想要存入多少钱？请输入："))
get_money(num)
continue
else:
print("程序退出啦")
break
- global关键字
- 函数的嵌套
- 多次使用制表符