目录
一、函数定义
二、函数调用
1.打印Hello World
2.判断最大值
3.计算矩形面积
4.help说明文档
三、参数传递
(一)位置参数
(二)关键字参数
(三)默认参数(缺省参数)
(四)可变参数(收集参数)
1.位置可变参数(接收所有的位置参数，返回一个元组)
2.关键字可变参数(接收所有关键字，返回一个字典)
(五)变量
1.局部变量
2.全局变量
3.在函数内部修改全局变量(global)
四、多函数程序
(一)多函数程序执行流程
(二)代码示例
五、函数返回值
(一)return
(二)多函数返回值做参数传递
六、拆包
(一)元组拆包
1.代码示例：
2.元组拆包：
(二)字典拆包
七、递归函数
八、Lambda表达式
(一)Lambda表达式概述
1.什么时候用lambda表达式？
2.lambda表达式语法
3.注意事项
(二)lambda表达式参数形式
1.无参数：
2.一个参数：
3.多个参数：
4.默认参数：
5.可变位置参数：
6.带条件的lambda表达式：
7.列表中的字典数据排序：
九、Lambda表达式之——高阶函数
(一)filter(函数名,可迭代对象)
1.查找[1,10]中的偶数：
(二)map(函数名,迭代对象)
1.计算[1,4]中每个元素的平方：
(三) reduce(函数名(x,y),可迭代对象)
1.求列表内值的累加和：
2.计算[1,100]累加和：
一、函数定义
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。python中的函数相当于java中的方法。
Python 定义函数使用 def 关键字，一般格式如下：
def 函数名（参数列表）:
函数体
默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。
注意：函数名要小写，函数一定要调用，不调用不会执行，有形参要传入参数
二、函数调用
1.打印Hello World
def helloworld():
print('Hello World!!!')
helloworld() # Hello World!!!2.判断最大值
def nummax(a, b):
if b > a:
return b
else:
return a
a = 10
b = 8
print(nummax(a, b)) # 103.计算矩形面积
# 计算面积函数(长*宽)
def area(height, width):
return height * width
i = area(height=10, width=2)
print('面积为：', i) # 面积为： 204.help说明文档
注意：help的内容一定要写在函数名下方才可以打印出来，否则无效，支持换行
def test01(a, b): # a,b是形参
"""最大值
函数""" # 说明文档可以换行
if a >= b:
return a
else:
return b
# 调用函数
print('最大值为：', test01(4, 8))
help(test01)运行结果：
三、参数传递
(一)位置参数
定义：在定义函数时，参数的名字和位置已被确定。
def 函数名(姓名,年龄,性别):
print(f'您的姓名是{姓名},性别是{性别},年龄是{年龄}')
函数名(‘张三’,20,男)
注意：形参与实参位置对应才能够生效
def abc(姓名, 年龄, 性别):
print(f'您的姓名是{姓名},性别是{性别},年龄是{年龄}岁')
abc('张三', 20, '男') # 您的姓名是张三,性别是男,年龄是20岁(二)关键字参数
定义：传入实参时，明确参数的变量名，参数之间不存在先后顺序。函数调用时，通过“键-值”的形式加以指定，清除了参数的顺序问题。
def test02(姓名, 年龄, 性别):
print(f'您的姓名是{姓名},性别是{性别},年龄是{年龄}岁')
test02('张三', 性别='男', 年龄=20) # 您的姓名是张三,性别是男,年龄是20岁注意：调用函数时，如果有位置参数，位置参数必须在关键字参数的前面，否则会报错。
(三)默认参数(缺省参数)
定义：参数指定默认值，调用时不传实参，就用默认值。
def test03(姓名, 年龄, 性别='男'):
print(f'您的姓名是{姓名},性别是{性别},年龄是{年龄}岁')
test03('张三', 20) # 您的姓名是张三,性别是男,年龄是20岁
test03('李四', 23, 性别='男') # 您的姓名是李四,性别是男,年龄是23岁
注意：调用函数时，如果由位置参数，位置参数必须在默认参数的前面，否则会报错。
(四)可变参数(收集参数)
1.位置可变参数(接收所有的位置参数，返回一个元组)
def 函数名(*args):
print(args)
def test04(*args):
print(args)
test04(20, 80) # (20, 80)2.关键字可变参数(接收所有关键字，返回一个字典)
def test05(**kwargs):
print(kwargs)
test05(name='王五', age=17, gender='男')
# {'name': '王五', 'age': 17, 'gender': '男'}(五)变量
1.局部变量
定义在函数内部的变量，即只在函数内部生效。
def test06():
a = 45 # 定义局部变量
print(a) # 函数体内部(定义函数下方缩进代码)访问，能访问到a这个变量
test06() # 调用函数
print(a) # 报错！！！ a是内部变量，作用域在函数内部，外部无法访问2.全局变量
定义在函数外部的变量，即只在函数内部和外部都生效。
a = 78
def test07():
print(a)
test07() # 调用函数 78
print(a) # 783.在函数内部修改全局变量(global)
注意：不要轻易修改全局变量，除非万不得已！！！
a = 78
def test07():
global a # 声明a为全局变量(外部变量)
a = 10 # 对变量a重新赋值
print(a)
test07() # 调用函数 10四、多函数程序
(一)多函数程序执行流程
一般在实际开发过程中，一个程序往往由多个函数组成，并且多个函数共享某些数据。
多函数公用全局变量的流程：
1.声明全局变量
2.定义两个函数
3.函数1修改全局变量，函数2访问全局变量
4.先调用函数1(函数1修改了全局变量)，再调用函数2时就可以使用修改后的全局变量了。
(二)代码示例
a = 999
def test08():
global a # 声明a是一个全局变量，就是外部变量
a = 20 # 修改变量a的值
print(a)
def test09():
print(a)
test09() # 999
test08() # 20五、函数返回值
(一)return
原理与java中的return一样。
1.如果函数中有多个return只返回符合条件的那一句，遇到return退出当前函数。
2.多个返回值携程return a,b 返回为一个元组。
3.return后面可以连接列表、元组或字典，也能返回多个返回值。
代码示例：
def test10(a, b):
return a + b
i = test10(4, -9)
print(i) # -5(二)多函数返回值做参数传递
编写步骤：
1.定义函数1，return返回一个值。
2.定义带形参的函数2，打印形参。
3.将调用函数1的返回值，赋值给一个变量。例如：变量名=函数名1()。
4.调用函数2，用刚才的变量做参数。例如：函数名2(变量名)。
代码示例：
def test11():
return 11
def test12(a):
return a
b = test11()
print(b) # 11
c = test12(b)
print(c) # 11六、拆包
(一)元组拆包
元组拆包——return后面有多个变量,用","号分割会返回一个元组。
如果不显示元组，而是分开显示后面的变量值就要用到元组拆包。
1.代码示例：
def test13(a, b, c):
return a, b, c
i = test13(7, 8, 9)
print(i) # (7, 8, 9)2.元组拆包：
def test14():
return 11, 45
a, b = test14()
print(a) # 11
print(b) # 45(二)字典拆包
对字典拆包取来的是字典的“键”。
代码示例：
# 新建一个字典
sites = {'name': '张三', 'age': 18}
def test14():
return sites
a, b = test14()
print(a) # 返回键
print(b)
print(sites[a]) # 返回键对应的值
print(sites[b])
print(a, '-->', sites[a]) # 返回键和值
print(b, '-->', sites[b])运行结果：
七、递归函数
函数内部自己调用自己，必须留有出口。
经典案例：计算1~100的和
递归只能计算[1,998]以内的累加和，>=999就会报RecursionError错误。
# 计算1~100的和
def test15(a):
if a == 1:
return 1 # 如果是1，直接返回1--设置的出口
num = a + test15(a - 1) # 如果不是1，重复执行累加
return num # 返回累加的结果
i = test15(100)
print(i) # 5050八、Lambda表达式
(一)Lambda表达式概述
1.什么时候用lambda表达式？
当函数有一个返回值，且只有一句代码，可以用lambda简写。
2.lambda表达式语法
lambda 形参:表达式
3.注意事项
1.形参可以省略，函数的参数在lambda中也适用。
2.lambda函数能接收任何数量的参数但只能返回一个表达式的值。
(二)lambda表达式参数形式
1.无参数：
def test16():
return 16
print(test16()) # 16
# 使用lambda改进后：
test17 = lambda: 100
print(test17()) # 100
# 更简洁的写法：
print((lambda: 100)()) # 1002.一个参数：
def test18(a):
return a
print(test18(100)) # 100
# lambda写法
print((lambda a: a)(100)) # 1003.多个参数：
def test19(a, b):
return a + b
print(test19(10, -1)) # 9
# lambda写法：
print((lambda a, b: a + b)(10, -1)) # 94.默认参数：
def test20(name, age, gender='男'):
return name, age, gender
print(test20('张三', 10)) # ('张三', 10, '男')
# lambda写法：
print((lambda a, b, c=5: a + b + c)(1, 3)) # 95.可变位置参数：
def test21(*args):
return args
print(test21(1, 2, 3)) # (1, 2, 3)
# 返回元组
print((lambda *args: args)(1, 2, 3)) # (1, 2, 3)
# 返回字典
print((lambda **kwargs: kwargs)(name='张三', age=20)) # {'name': '张三', 'age': 20}6.带条件的lambda表达式：
条件语句(三目运算)：条件成立执行的表达式if条件else条件不成立执行的表达式。
print((lambda a, b: a if a > b else b)(1, 4)) # 47.列表中的字典数据排序：
sites = [{'name': '张三', 'age': 48},
{'name': '李四', 'age': 28},
{'name': '王五', 'age': 38}]
sites.sort(key=lambda x: x['age'], reverse=False)
print(sites)
# [{'name': '李四', 'age': 28}, {'name': '王五', 'age': 38}, {'name': '张三', 'age': 48}]九、Lambda表达式之——高阶函数
高阶函数就是基于已有的函数定义新函数，以函数作为参数，返回也是函数。
(一)filter(函数名,可迭代对象)
1.查找[1,10]中的偶数：
print(list(filter(lambda x: x % 2 == 0, range(1, 11))))
# [2, 4, 6, 8, 10](二)map(函数名,迭代对象)
1.计算[1,4]中每个元素的平方：
print(list(map(lambda x: x ** 2, range(1, 5)))) # [1, 4, 9, 16](三) reduce(函数名(x,y),可迭代对象)
1.求列表内值的累加和：
import functools # 导入模块
sites = [1, 2, 3, 4]
def test21(a, b):
return a + b
num = functools.reduce(test21, sites)
print(num) # 102.计算[1,100]累加和：
import functools # 导入模块
print(functools.reduce(lambda x, y: x + y, range(1, 101))) # 5050
