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))

执行结果：

<function <lambda> 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 声明变量，也可以使用外层的局部变量