知识点一：函数基础
1.函数定义
def 函数名(参数):
函数体
无参函数：
def func1():
print('hello world!')
单参函数：
def func2(a):
print(a*3)
多参函数：
def func3(a,b):
print(a*b)2. 函数调用
直接使用函数名调用
func1()
func2(23)
func3(4,5)3. 参数
函数的参数分为形参（形式参数）与实参（实际参数）
形参：函数定义阶段的参数，作用域仅限于函数定义位置，在函数外无意义
实参：函数调用阶段的参数，用于传入函数内部进行处理的数据
参数的设置方式：
1. 位置参数
按照函数定义的参数位置进行传参
位置顺序必须与定义时相同
def f(a,b,c):
print(a+b*c)
f(1,2,3)2. 关键词参数
直接使用关键词进行传参
位置顺序可与定义不相同
def f(a,b,c):
print(a+b*c)
f(b=2,a=1,c=3)3. 参数默认值
如果函数设置默认值，调用时可以不传参
def f(a,b,c=3):
print(a+b*c)
f(1,2,3)
f(1,2)
f(1,2,4) # 如果不传参，参数使用默认值，如果传参，使用新参数值4. 位置参数与关键词参数混用
位置参数在前，关键词参数在后
def f(a,b,c):
print(a+b*c)
f(1,2,c=3) # 正确调用方式
f(c=3,1,2) # 错误调用方式5. 可变参数
1）# 在形参中带*会将调用函数时溢出位置实参保存成元组的形式,然后赋值*后的变量名
def foo(x, y, *z):
print(x, y)
print(z)
print(*z)
foo(1, 2, 3, 4, 5, 6)2）# 实参打散
# 序列类型可以被*打散
foo(1, *(2, 3))
foo(1, 2)
foo(*[1, 2, 3])3）# 在形参中带**:会将调用函数时溢出关键字实参保存成字典的形式,然后赋值**后的变量名
def foo(x,y,**z):
print(x,y)
print(z)
# **只能接受关键字实参4）# 实参可以打散字典变成关键字实参进行传参
a = {'x':1,'y':2,'z':3}
foo(**a)4. 返回值
返回值是一个函数的处理结果 return
函数运行之后，函数本身就等于返回值
def s(a,b):
c=a+b
return c
m=s(2,5)
print(m)'''
1.函数内可以有多个return，但只要执行一次，整个函数就会结束运行，默认return None
2.return 的返回值无类型限制，即可以是任意数据类型、表达式
3.return 的返回值无个数限制，即可以用逗号分隔开多个任意类型的值
4.return关键字:return也可以作为函数结束的标志
'''5. 局部变量和全局变量
在函数内部被赋值的变量，处于该函数的“局部作用域”，属于局部变量
在函数外部被赋值的变量，处于该函数的“全局作用域”，属于全局变量
一个变量，要么是局部变量，要么是全局变量，鱼和熊掌不可兼得
注意：不同的局部作用域是相互独立的，一个局部作用域不能使用其他局部作用域里面的变量。
1.# 外部不能访问函数内部的变量
def f():
a=12
print(a)2.# 函数内部能够访问函数外部的变量
a=12
def f():
b=a*2
return b
print(f())3.# 函数里面不能修改函数外部的变量，会报错
a=12
def f():
a = a + 1
f()
print(a)4.# 但是可以在函数内部读取外部的变量
a=12
def f():
b = a + 1
print(b)
f()
print(a)5.# 可变类型可以在函数内部进行修改
# 但是不可以重新赋值
a=[1,2,3]
def f():
a.append(4)
f()
print(a)6.# global 能让我们在函数里面去修改全局变量的值
def f():
global a
a = a + 1
f()
print(a)7.# nonlocal 让嵌套函数能够修改嵌套函数之外的值
def f():
a = 12
def ff():
nonlocal a
a += 1
print(a)
f()
作用域判断的四条法则：
1.如果变量在全局作用域中使用（所有函数之外），它就是全局变量
2.如果在一个函数中，有针对该变量的global语句，它就是全局变量
3.否则，如果该变量在函数内部被赋值它就是局部变量
4.但是如果该变量没有用在函数内部的赋值语句中，它就是全局变量
def f1():
global a
a = 12 # 全局变量a
print('我是全局变量%d' % a)
def f2():
a = 12 # 局部变量a
print('我是局部变量%d' % a)
def f3():
print('我也是全局变量%d' % a)
a = 12 # 全局变量
print('我也是全局变量%d' % a)6. 常用内置函数
# 求绝对值
print(abs(-2))# 求最大值
nums=[1,3,5,3,2,5,7,4]
print(max(nums))# 求最小值
nums=[1,3,5,3,2,5,7,4]
print(min(nums))
# 求和
nums=[1,3,5,3,2,5,7,4]
print(sum(nums))
# 把字符转换成编码
print(ord('a'))# 把编码转换成字符
print(chr(65))# 拉链函数
l1=[1,2,3,4,5]
l2=['a','b','c','d','e','f']
print(zip(l1,l2)) # 返回的是<zip object at 0x000001CED5496640>对象
print(list(zip(l1,l2))) # 转换成列表
print(dict(zip(l1,l2))) # 转换成字典# 执行字符串里面的表达式
print(eval('2+3'))# 执行字符串里面的语句
exec('print("hello world")')知识点二：函数进阶
1. 匿名函数
1.1 什么是匿名函数
匿名函数就是不再使用def语句这样的标准形式定义一个函数
Python使用lambda创建匿名函数。lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块，仅能在lambda表达式中封装有限的逻辑。
注意：lambda函数拥有自己的命名空间，不能访问自有参数列表之外或全局命名空间的参数。
lambda函数的语法只包含一个语句，语句如下：
lambda 参数:表达式（返回值）1.2 匿名函数如何应用
示例一：求两个数的和
使用def语句：
def func(x, y):
return x + y使用lambda表达式：
lambda x, y: x + y由上面的代码可以看到，使用lambda表达式编写的代码比使用def语句少。这里不太明显，再看一个代码更多的示 例。
示例二：求一个列表中大于3的元素。
方法一：通过过程式编程实现，也是常规的方法。
list_1 = [1, 2, 3, 4, 5]
list_2 = []
for i in list_1:
if i > 3:
list_2.append(i)
print('列表中大于3的元素有: ', list_2)方法二：通过函数式编程实现，运用filter内置函数+列表推导式，给出一个判断条件：
def func_filter(x):
return x > 3
f_list = filter(func_filter, [1, 2, 3, 4, 5])
print('列表中大于3的元素有: ', [item for item in f_list])方法三：运用匿名函数，就会更加精简，一行代码即可：
print('列表中大于3的元素有: ', [item for item in filter(lambda x: x > 3, [1, 2, 3, 4, 5])])从上面的操作可以看出，lambda一般应用于函数式编程，代码简洁，常和filter等函数结合使用。
1.3 匿名函数使用场景
1. 程序一次性使用、不需要定义函数名时，用匿名函数可以节省内存中定义变量所占的空间。
2. 如果想让程序更加简洁，使用匿名函数就可以做到。
#匿名函数使用规则：
1. 一般有一行表达式，必须有返回值。
2. 不能有return。
3. 可以没有参数，也可以有一个或多个参数。
1.4 匿名函数示例
无参匿名函数：
t = lambda : True
t()
带参数匿名函数：
lambda x: x ** 3
lambda x, y, z: x + y + z
lambda x, y = 3: x * y2. 闭包函数
有的时候函数还可以返回函数，而且是函数内部自己定义的函数。
示例：
def outer(*args):
def inner():
s = 0
for n in args:
s = s + n
return s
return inner
print(f'调用外部函数的结果: {outer(1, 2, 3, 4)}')
inner = out(1, 2, 3, 4)
print(f'调用内部函数的结果: {inner()}')在这个例子中，在函数outer中又定义了函数inner，并且内部函数inner可以引用外部函数outer的参数和局部变 量。当outer返回函数inner时，相关参数和变量都保存在返回的函数中，称为闭包。这种程序结构威力极大，先作 了解，后续还会再详细讲解。
3. 递归函数
3.1 什么是递归函数
如果一个函数在内部调用自身，这个函数就称作递归函数。
递归函数的简单定义如下：
def fun():
print('hello')
return fun()我们来看一个递归示例，计算阶乘n=1×2×3×…×n，用函数fact(n)表示：
def fact(n):
if n == 1:
return 1
return n * fact(n - 1)
print(f'调用递归函数执行结果为: {fact(5)}')计算fact(5)时可以根据函数定义看到计算过程：
===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120