Python入门【可变参数、lambda表达式和匿名函数、eval()函数、递归函数、嵌套函数(内部函数)、 nonlocal关键字】(十二)
作者简介：大家好，我是爱敲代码的小王，CSDN博客博主,Python小白
系列专栏：python入门到实战、Python爬虫开发、Python办公自动化、Python数据分析、Python前后端开发
如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步
如果感觉博主的文章还不错的话，请三连支持一下博主哦
博主正在努力完成2023计划中：以梦为马，扬帆起航，2023追梦人
python入门到实战专栏：从入门到实战
Python爬虫开发专栏：从入门到实战
Python办公自动化专栏：从入门到实战
Python数据分析专栏：从入门到实战
Python前后端开发专栏：从入门到实战
目录
可变参数
lambda表达式和匿名函数
eval()函数
递归函数
嵌套函数(内部函数)
nonlocal关键字
可变参数
可变参数指的是“可变数量的参数”。分两种情况：
1、 *param （一个星号），将多个参数收集到一个“元组”对象中。
2、 **param （两个星号），将多个参数收集到一个“字典”对象中。
【操作】测试可变参数处理（元组、字典两种方式）
def f1(a,b,*c):
print(a,b,c)
f1(8,9,19,20)
def f2(a,b,**c):
print(a,b,c)
f2(8,9,name='gaoqi',age=18)
def f3(a,b,*c,**d):
print(a,b,c,d)
f3(8,9,20,30,name='tong',age=18)执行结果：
8 9 (19, 20)
8 9 {'name': 'tong', 'age': 18}
8 9 (20, 30) {'name': 'tong', 'age': 18}
强制命名参数
在带星号的“可变参数”后面增加新的参数，必须在调用的时候“强制 命名参数”。
def f1(*a,b,c):
print(a,b,c)
#f1(2,3,4) #会报错。由于a是可变参数，将2,3,4全部收集。造成b和c没有赋值。
f1(2,b=3,c=4)执行结果：
(2,) 3 4实时效果反馈
1. 如下关于可变参数的代码，调用时，错误的是：
def f1(a,b,*c):
print(a,b,c)
def f2(a,b,**c):
print(a,b,c)
def f3(a,b,*c,**d):
print(a,b,c,d)
A f1(8,9,19,20)
B f2(8,9,name='tong',age=18)
C f3(8,9,20,30,name='tong',age=18)
D f2(7)
2. 如下是强制命名参数，调用时，错误的是：
def f1(*a,b,c):
print(a,b,c)A f1(2,3,4)
B f1(2,b=3,c=4)
C f1(2,c=3,b=4)
D f1(20,c=3,b=4)
lambda表达式和匿名函数
lambda 表达式可以用来声明匿名函数。
lambda 函数是一种简单的、在 同一行中定义函数的方法。 lambda 函数实际生成了一个函数对象。
lambda 表达式只允许包含一个表达式，不能包含复杂语句，该表达式 的计算结果就是函数的返回值。
lambda 表达式的基本语法如下：
lambda arg1,arg2,arg3... : <表达式>
arg1 arg2 arg3 为函数的参数。相当于函数体。运算结果是：表达式的运算结果。
【操作】lambda表达式使用
f = lambda a,b,c:a+b+c
print(f)
print(f(2,3,4))
g = [lambda a:a*2,lambda b:b*3,lambda c:c*4]
print(g[0](6),g[1](7),g[2](8))
执行结果：
at 0x0000000002BB8620>
9
12 21 32 实时效果反馈
1. 如下关于lambda表达式，错误的是：
f = lambda a,b,c:a+b+c
print(f(2,3,4))A lambda 函数是一种简单的、在同一行中定义函数的方法
B lambda 函数实际生成了一个函数对象
C lambda 表达式只允许包含一个表达式，该表达式的计算结果就是 函数的返回值
D lambda 函数 f 不会生成函数对象，但是可以通过 f(2,3,4) 调用
eval()函数
功能：将字符串 str 当成有效的表达式来求值并返回计算结果。
语法： eval(source[, globals[, locals]]) -> value
参数：
1 source ：一个Python表达式或函数 compile() 返回的代码对象
2 globals ：可选。必须是 dictionary
3 locals ：可选。任意映射对象
#测试eval()函数
s = "print('abcde')"
eval(s)
a = 10
b = 20
c = eval("a+b")
print(c)
dict1 = dict(a=100,b=200)
d = eval("a+b",dict1)
print(d)⚠️⚠️⚠️eval函数 会将字符串当做语句来执行，因此会被注入安 全隐患。比如：字符串中含有删除文件的语句。那就麻烦大了。因此，使用时候，要慎重！！！
实时效果反馈
1. 如下关于 eval() 函数，错误的是：
a = 10
b = 20
c = eval("a+b")
print(c)A eval(str) 函数的作用：将字符串 str 当成有效的表达式来求值并返 回计算结果。
B 上面代码的执行结果是： 1020
C eval函数 会将字符串当做语句来执行，因此会被注入，安全隐患
D 上面代码的执行结果是： 30
递归函数
1 递归(recursion)是一种常见的算法思路，在很多算法中都会用到。比如：深度优先搜索（DFS:Depth First Search）等。
2 递归的基本思想就是“自己调用自己”
递归函数指的是：自己调用自己的函数，在函数体内部直接或间接 的自己调用自己。每个递归函数必须包含两个部分：
1 终止条件 表示递归什么时候结束。一般用于返回值，不再调用自己。
2 递归步骤 把第n步的值和第n-1步相关联。
⚠️递归函数由于会创建大量的函数对象、过量的消耗内存和运 算能力。在处理大量数据时，谨慎使用。
如下是一个简单的递归程序：
def my_recursion(n):
print("start:" + str(n))
if n == 1:
print("recursion over!")
else:
my_recursion(n - 1)
print("end:" + str(n))
my_recursion(3)运算结果：
start:3
start:2
start:1
recursion over!
end:1
end:2
end:3
实时效果反馈
1. 如下关于递归函数，错误的是：
A 递归函数指的是：自己调用自己的函数
B 深度优先搜索（DFS:Depth First Search）中使用了递归算法
C 在处理大量数据时，谨慎使用
D 递归函数可以不包含“终止条件”
【操作】 使用递归函数计算阶乘(factorial)
def factorial(n):
if n==1:
return 1
return n*factorial(n-1)
print(factorial(5))
执行结果：
120
嵌套函数(内部函数)
嵌套函数：在函数内部定义的函数！
def outer():
print('outer running...')
def inner():
print('inner running...')
inner()
outer()执行结果：
outer running...
inner running...上面程序中， inner() 就是定义在 outer() 函数内部的函数。 inner() 的定义 和调用都在 outer() 函数内部。
一般在什么情况下使用嵌套函数？
1 封装 - 数据隐藏 外部无法访问“嵌套函数”。
2 贯彻 DRY(Don’t Repeat Yourself) 原则
3 嵌套函数，可以让我们在函数内部避免重复代码。
4 闭包（后面会讲解）
【操作】使用嵌套函数避免重复代码
def printChineseName(name,familyName):
print("{0} {1}".format(familyName,name))
def printEnglishName(name,familyName):
print("{0} {1}".format(name, familyName))
使用1个函数代替上面的两个函数
def printName(isChinese,name,familyName):
def inner_print(a,b):
print("{0} {1}".format(a,b))
if isChinese:
inner_print(familyName,name)
else:
inner_print(name,familyName)
printName(True,"小七","童")
printName(False,"xiaotong","Bush")
实时效果反馈
1. 如下关于嵌套函数(内部函数)，错误的是：
def f1():
print('f1 running...')
def f2():
print('f2 running...')
f2()A 调用 f1() ，则会执行： f1() 、 f2()
B 调用 f1() ，则只执行： f1() ，不会执行 f2()
C 嵌套函数：在函数内部定义的函数！
D 嵌套函数，可以让我们在函数内部避免重复代码。
nonlocal关键字
nonlocal 用来在内部函数中，声明外层的局部变量。
global 函数内声明全局变量，然后才使用全局变量
【操作】使用nonlocal声明外层局部变量
#测试nonlocal、global关键字的用法
a = 100
def outer():
b = 10
def inner():
nonlocal b #声明外部函数的局部变量
print("inner b:",b)
b = 20
global a #声明全局变量
a = 1000
inner()
print("outer b:",b)
outer()
print("a：",a)实时效果反馈
1. 如下关于 nonlocal 和 global 的说法，错误的是：
A nonlocal 用来声明外层的局部变量。
B global 用来声明全局变量。
C 函数内用 global 声明全局变量，然后才可以使用全局变量
D 函数内不用 nonlocal 声明变量，也可以使用外层的局部变量