👏作者简介:大家好,我是爱敲代码的小王,CSDN博客博主,Python小白
📕系列专栏:python入门到实战、Python爬虫开发、Python办公自动化、Python数据分析、Python前后端开发
📧如果文章知识点有错误的地方,请指正!和大家一起学习,一起进步👀
🔥如果感觉博主的文章还不错的话,请👍三连支持👍一下博主哦
🍂博主正在努力完成2023计划中:以梦为马,扬帆起航,2023追梦人
🔥🔥🔥 python入门到实战专栏:从入门到实战
🔥🔥🔥 Python爬虫开发专栏:从入门到实战
🔥🔥🔥 Python办公自动化专栏:从入门到实战
🔥🔥🔥 Python数据分析专栏:从入门到实战
🔥🔥🔥 Python前后端开发专栏:从入门到实战
目录
可变参数
可变参数指的是“可变数量的参数”。分两种情况:
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 声明变量,也可以使用外层的局部变量