本文引自极客时间：Python 核心技术与实战10 | 简约不简单的匿名函数 (geekbang.org)以及09 | 不可或缺的自定义函数 (geekbang.org)
1. map()
map(function, iterable) 函数，表示对 iterable 中的每个元素，都运用 function 这个函数，最后返回一个新的可遍历的集合（map对象）。
例如：对列表中的每个元素乘以2
list1 = [1,2,3,4,5] #创建一个集合
new_list = map(lambda x: x * 2, list1) #使用map函数和lambda表达式对list1每个元素乘以2
print('new_list的类型是：',type(new_list), '\n')
for i in new_list:
print(i)
运行结果为：
new_list的类型是： <class 'map'>
2
4
6
8
10
2. filter()
filter(function, iterable) 函数，它和 map 函数类似，function 同样表示一个函数对象。filter() 函数表示对 iterable 中的每个元素，都使用 function 判断，并返回 True 或者 False，最后将返回 True 的元素组成一个新的可遍历的集合（filter对象）。
例如：返回列表中的偶数
bool_list = filter(lambda x: x % 2 == 0, list1) #返回列表list中的偶数
print('bool_list的类型是：',type(bool_list), '\n')
for i in bool_list:
print(i)
运行结果为：
bool_list的类型是： <class 'filter'>
2
4
3. reduce()
reduce(function, iterable) 函数，对 iterable 中的每个元素以及上一次调用后的结果，运用 function 进行计算，所以最后返回的是一个单独的数值，它通常用来对一个集合做一些累积操作。
例如：计算某个列表元素的乘积
4. lambda()
具体应用见这里：2022-08-12 python暑期面试题目 - 简书 (jianshu.com)
5.函数的参数列表tips
- 默认参数
函数的参数可以设置默认值，传入其他值则将其覆盖掉：
# 参数的默认值
def sum(a = 1, b = 2):
return a + b
print(sum()) #可以不传入参数，函数采取默认值计算
print(sum(2)) #传入一个参数，覆盖掉第一个默认值
print(sum(2,3)) #传入两个参数，覆盖掉两个默认值
运行结果如下：
3
4
5
- 函数的调用顺序
在外部主程序调用某个函数时，必须保证该函数在前面已经被定义，不然会报错：
fun2() #先执行后定义
def fun2():
print('fun2被调用\n')
报错：
NameError Traceback (most recent call last)
Input In [1], in <cell line: 1>()
----> 1 fun2()
NameError: name 'fun2' is not defined
但在函数内部，函数间哪个声明在前、哪个在后就无所谓，因为 def 是可执行语句，函数在调用之前都不存在，我们只需保证调用时，所需的函数都已经声明定义：
# 函数的互相调用
#fun2()
def fun1():
print('fun1函数被调用') #函数内部调用另一个函数时只要后者被定义即可，顺序不影响
fun2()
def fun2():
print('fun2函数被调用')
fun1() #这里主程序调用fun1()时仍需放在fun1()和fun2()之后，但fun1()里可先调用fun2()
运行结果如下：
fun1函数被调用
fun2函数被调用
- 函数的嵌套
函数的嵌套便是在函数的内部再定义函数，以上面的fun1函数和fun2函数为例，要想主程序内不能直接访问fun2函数，可将其定义放在fun1内部，如下：
# 函数的嵌套
def fun1():
print('fun1函数被调用\n')
def fun2():
print('fun2函数被调用\n')
fun2() # 在fun1()内部调用fun2()
fun1()
运行结果如下：
fun1函数被调用
fun2函数被调用
- 函数变量作用域
变量按照作用域分为全局变量与局部变量，全局变量在程序的任意位置均可访问，局部变量只能在函数体内被访问。如下所示：
# 函数的作用域
# 函数的作用域
A = 2 # 全局变量
def fun3():
a = 1; #局部变量
print('函数内访问局部变量a: {}'.format(a))
#global A
#A = 3
print('函数内访问全局变量A: {}'.format(A))
fun3()
print('函数外访问全局变量A: {}'.format(A))
print('函数外访问局部变量a: {}'.format(a))
运行结果为：
函数内访问局部变量a: 1
函数内访问全局变量A: 2
函数外访问全局变量A: 2
NameError: name 'a' is not defined
尽管能够在函数内部访问全局变量，但要想在函数内部修改全局变量必须先用关键字global声明该全局变量，否则会报错：
# 函数的作用域
A = 2 # 全局变量
def fun3():
a = 1; #局部变量
print('函数内访问局部变量a: {}'.format(a))
print('函数内访问全局变量A: {}'.format(A))
global A
A = 3
fun3()
print('函数外访问全局变量A: {}'.format(A))
#print('函数外访问局部变量a: {}'.format(a))
上面程序会报错，因为对A的全局声明在其使用之后，如下：
name 'A' is used prior to global declaration
将声明放在输出语句前面：
# 函数的作用域
A = 2 # 全局变量
def fun3():
a = 1; #局部变量
print('函数内访问局部变量a: {}'.format(a))
global A
print('函数内访问全局变量A: {}'.format(A))
A = 3
fun3()
print('函数外访问全局变量A: {}'.format(A))
#print('函数外访问局部变量a: {}'.format(a))
运行结果如下：在函数外访问的全局变量A已经是被修改过的。
函数内访问局部变量a: 1
函数内访问全局变量A: 2
函数外访问全局变量A: 3
在函数内部定义与全局变量同名的局部变量会在函数体内覆盖掉此全局变量，但不影响其在其他地方的使用：
def fun4():
A = 4
print('函数体内A变量此时的值为: {}'.format(A))
fun4()
print('函数体外A变量此时的值为: {}'.format(A))
运行结果如下，可以看到函数体内输出的A是被覆盖后的值，函数体外输出的A仍是原值。
函数体内A变量此时的值为: 4
函数体外A变量此时的值为: 3
类似地，嵌套函数中内部函数可以访问外部函数的变量，但不能直接修改。若要修改，需加nonlocal关键字：
# 函数的嵌套
def fun1():
B = 3
print('fun1函数被调用',B)
def fun2():
nonlocal B # 声明这里的B就是外部函数的B
print('fun2函数被调用',B)
B = 4 # 修改外部函数的变量
fun2() # 在fun1()内部调用fun2()
print('被修改后的B: {}'.format(B))
fun1()
运行结果如下：
fun1函数被调用 3
fun2函数被调用 3
被修改后的B: 4
- 闭包
闭包与嵌套函数类似，但其外部函数的返回值是一个函数，这个函数在后续会被赋予变量执行计算。
