知识点一:函数基础
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 * y
2. 闭包函数
有的时候函数还可以返回函数,而且是函数内部自己定义的函数。
示例:
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