一、函数变量
def 函数名(参数列表):
函数体
我们在声明函数的时候,其实就是在声明一个类型是函数类型(function)的变量
普通变量能做的事情，函数变量都能做
-
1.函数名就是函数类型变量(类型名:function),存的是函数入口的地址
def func1(): print('aaa') print(type(func1)) #num = 10 print(type(num)) # -
2.可以用一个变量给另一个变量赋值
a = func1() 这样赋值，是将函数func1的返回值赋给a
a = func1 # 将函数变量func1赋给a，a就会变成一个函数
a() # 现在就可以用函数变量a去调用函数func1。 打印结果:aaa
def func2(num):
return num * 2
b = func2
print(func2(10)) # 20
print(b(20)) # 40
-
3.将函数变量作为函数的参数
def calculate(num1, num2, fn): # num1 = 10, num2 = 20, fn = func_add if not (isinstance(num1, int) or isinstance(num1, float)): print('num1输入错误') return None if not (isinstance(num2, int) or isinstance(num2, float)): print('num2输入错误') return None return fn(num1, num2) # return func_add(10, 20) return 30 def func_add(m, n): # m = 10, n = 20 return m + n # return 30 def func_sub(m, n): return m - n result = calculate(10, 20, func_add) print(result) # 30 -
4.函数作为返回值
写一个函数，func3('+') --> 返回求和的功能；func3('*') --> 返回求乘积的功能
def func3(char):
if char == '+':
# python中是可以在函数中声明函数的
def fn(*nums):
sum1 = 0
for x in nums:
sum1 += x
return sum1
return fn
if char == '*':
def fn(*nums):
sum1 = 1
for x in nums:
sum1 *= x
return sum1
return fn
result = func3('+') # result是一个求和功能的函数变量
result = result(1, 2, 3, 4)
print(result) # 10
result2 = func3('*')(10, 20)
print(result2) # 200
列表作为返回值(对象变量作为返回值)
def func4():
list1 = [1, 2, 3]
return list1
result = func4()
print(result) # [1, 2, 3]
print(func4()[0]) # 1
二、匿名函数
python中使用lambda关键字来声明一个匿名函数
格式: lambda 参数列表:返回值
参数列表:多个参数之间用逗号隔开
只能实现一些简单的函数功能
使用函数求两个数的和
def func1(num1, num2):
return num1 + num2
print(func1(10, 20)) # 30
使用匿名函数实现求两个数的和
func2 = lambda num1, num2: num1 + num2
print(func2(10, 20)) # 30
练习:使用匿名函数求指定列表中，指定的两个下标对应的元素的和
func3 = lambda list1, n, m: list1[n] + list1[m]
print(func3([1, 2, 3, 4, 5], 2, 4)) # 8
使用指定的功能去计算num1和num2
def calculate(num1, num2, fn):
return fn(num1, num2)
sum1 = calculate(10, 20, lambda a, b: a + b)
print(sum1) # 30
三、递归函数
-
1.递归函数:在函数声明中调用函数本身
def func1(): print('aaa') func1() func1() -
2.递归作用:理论上循环可以做的事情递归都可以做(但实际除非是非用不可的情况，一般不使用递归)
因为调用一次函数就会开辟一次空间，对CPU消耗比较大
-
3.步骤:
递归函数:f(n)
a.确定临界值(结束函数的时刻)
b.假设函数已经实现，然后找到f(n)和f(n-1)关系
c.使用f(n)和f(n-1)的关系去实现f(n)的功能
计算1+2+3+4+....+n
方法1:使用循环
def func1(n):
sum1 = 0
for x in range(1, n+1):
sum1 += x
return sum1
print(func1(10)) # 55
方法2:使用递归函数
def func2(n):
# 1.确定临界值
if n == 1:
return 1
# 2.假设func2功能已经实现，找到func2(n-1),func2(n)的关系
# func2(n-1) = 1+2+3+...+n-1
# func2(n) = 1+2+3+...+n-1+n = func2(n-1)+n
# 3.通过func2(n-1)去实现func2(n)的功能
return func2(n-1) + n
print(func2(10)) # 55
练习:使用递归实现：246....n(n是偶数)
def func3(n):
if n % 2 != 0:
print('n必须是偶数')
return None
# 1.确定临界值
if n == 2:
return 2
# 2.找规律
# f(n) = 2*4*6*...*n-2*n
# f(n-2) = 2*4*6*...*n-2
# f(n) = f(n-2) * n
return func3(n-2) * n
print(func3(6))
使用递归函数做
-n=5
-***** 0 5*
-**** 1 4*
-*** 2 3*
-** 3 2*
-* 4 1*
1.用循环
def print_str(n):
# x = (0,1,2,3,4)
for x in range(n):
print('*' * (n-x))
print_str(5)
2.用递归
def print_str1(n):
# 1.确定临界值(一定要让函数结束)
if n == 1:
print('*')
return None
# 2.找关系f(n)和f(n-1)
n=5
*****
****
***
**
*
n=5-1
****
***
**
*
f(n)和f(n-1)关系:打印一行n个*，在执行f(n-1)
print('*' * n)
print_str1(n-1)
print_str1(6)
n=5
*
**
***
****
*****
def print_str2(n):
if n == 1:
print('*')
return None
print_str2(n-1)
print('*' * n)
print_str2(5)
四、调用函数的过程
函数的调用过程是一个压栈的过程:
a.调用函数的时候，首先会在栈中开辟一块内存空间，
用来保存函数调用过程中产生的数据(包括函数的参数和在函数中声明的变量)
b.当函数执行完成后，被调用函数对应的内存空间会被回收(释放)
栈:是内存中的一块特殊的区域。数字和字符串的值是存在栈里面的
堆:对象是存在堆里面的
总结:递归要慎用，能用循环做的，就不要用递归。递归消耗内存也消耗CPU资源
五、使用模块管理函数
模块就是指一个.py文件(一个.py文件就是一个 模块)
可以在一个模块中使用其他模块的函数和类
模块的使用(内置（python自己的：random、math、json等）、第三方(别人写的：)、
怎么使用其他模块中的函数？
1.通过import关键字导入模块，然后通过模块名.函数的方法去使用模块中的函数
注意:当我们导入其他模块的时候，会将其他模块中所有的内容导入到当前文件中
a.怎么避免:
是在被导入的模块加，不是在当前文件加
判断模块的内置属性name的值是否是'main',
将不需要被其他模块导入的代码写到这个if语句中
if name == 'main':
不需要导入的代码
b.为什么可以:
关于name属性:
name是每个模块都有的属性，作用是用来存储模块的名字。
当模块不是正在执行的模块，name属性的值是模块对应的文件名；
当模块正在执行的时候，name的值就是一个固定值'main'
2.通过from-import直接导入指定的函数或者类。导入后就可以直接调用函数
格式:from 模块名 import 函数名1，函数名2
3.通过 as 关键字给导入的模块或函数重命名
import qf_math as my_math
重命名后就可以用新的模块名去调用函数
print(my_math.sum())
form qf_math import sum as my_sum
重命名后使用新的函数名去使用函数
print(my_sum())