- 函数的创建与调用
- 函数的参数定义
- 函数的返回值’
- 函数的参数定义
- 变量的作用域
- 递归函数
1函数的创建与调用
函数就是执行特定任务以完成特定功能的一段代码
需要函数的原因
复用代码
隐藏实现细节
提高可维护性
提高可读性便于调试
def 函数名([输入函数])
函数体
[return xxx]
函数的创建
def calc(a,b)
c=a+b
return c
====================================================================
函数的调用
函数名([实际参数])
result=calc(10,20)
print(result)
============================================================================
函数的参数传递
位置实参
根据形参对应的位置进行实参传递
关键字实参
根据形参名称进行实参传递
def calc(a, b):#a.b称为形参,形参的位置是在函数的定义处
c=a+b
return c
result=calc(10,20)#10,20为实参值,实参的位置是函数的调用处
print(result)
3函数的返回值’
def fun(num):
odd=[]#存奇数
even=[]#存偶数
for i in num:
if i%2:
odd.append(i)
else:
even.append(i)
return odd, even
return odd, even
#函数的调用
print(fun([10, 29, 34, 44, 53, 55]))
'''函数返回值
(1)如果函数没有返回值[函数执行完毕之后,不需要给调用处提供数据]return可以省略不写
(2)函数的返回值,如果是1个,直接返回类型
(3)函数的返回值,如果是多个,返回的结果是元组
'''
def fun1():
print('hello')
fun1()
def fun2():
return'hello'
res=fun2()
print(res)
def fun3():
return'hello', 'world'
print(fun3())
#函数在定义时,是否需要返回值,视情况而定
4.函数的参数定义
函数定义时,给形参设置默认值,只有与默认值不符的时候才需要传递实参
def fun(a, b=10):
print(a, b)
#函数的调用
fun(100)#当只赋一个值时,只传一个参b采用默认值
fun(20, 30)#将三十替换为10
个数可变的位置参数
定义函数时,可能无法事先确定传递位置实参的个数时,使用可变的位置参数
使用*定义个数可变的位置形参
结果为一个元组
def fun(*args):#可变的位置参数可变的位置参数只能是一个
print(args)
fun(10)
fun(10, 20)
fun(10, 20, 30)
个数可变的关键字形参
定义函数时,无法确定传递的关键字实参的个数时,使用可变的关键字形参
使用**定义个数可变的关键字形参
结果为一个字典
def fun(**args):#个数参数可变的位置参数只能是一个
print(args)
fun(a=10)
fun(a=10, b=20, c=30)
print('hello', 'world', 'python')
在一个函数的定义过程中,既有个数可变的关键字形参,也有个数可变的位置形参,要求,个数可变的位置形参,放在个数可变的关键字形参之前
序号 | 参数的类型 | 函数的定义 | 函数的调用 | 备注 |
1 | 位置实参 | J | ||
将序列中的每个元素都转换为位置实参 | J | 使用* | ||
2 | 关键字实参 | J | ||
将字典中的每个键值对都转换为关键字实参 | J | 使用** | ||
3 | 默认值形参 | J | ||
4 | 关键字形参 | J | 使用* | |
5 | 个数可变的位置形参 | J | 使用* | |
6 | 个数可变的关键字形参 | J | 使用** |
def fun(a, b, c):#a,b,c在函数的定义处,所以是形式参数
print('a=', a)
print('b=', b)
print('c=', c)
#函数的调修
fun(10, 20, 30)#函数调用时的参数传递,称为位置传参
lst=[11, 22, 33]
fun(*lst)#在函数调用时,将列表中的每个元素都转换为位置实参传入
fun(a=100, b=200, c=300)#函数的调用关键字参数实参
dic={'a':111, 'b':222, 'c':333}
fun(**dic)#在函数调用时,将字典中的键值对都转换为关键字实参传入
def fun4(a, b, c, d):
print('a=', a)
print('b=', b)
print('c=', c)
print('d=', d)
#调用fun4函数
fun4(10, 20, 30, 40)#位置实参传递
fun4(a=10, b=20, c=30, d=40)#关键字实参传递
fun4(10, 20, c=30, d=44)#前两个参数,采用的是位置实参传递,而后面两个是进行关键字传递
#需求,cd只能采用关键字传参
def fun4(a, b, *, c, d):#从*之后的参数,在函数调用时,只能采取关键字参数
print('a=', a)
print('b=', b)
print('c=', c)
print('d=', d)
#调用fun4函数
#fun4(10, 20, 30, 40)#位置实参传递
fun4(a=10, b=20, c=30, d=40)#关键字实参传递
fun4(10, 20, c=30, d=44)#前两个参数,采用的是位置实参传递,而后面两个是进行关键字传递
#函数定义的参数的顺序问题
def fun5(a, b, *, c, d, **args):
pass
def fun6(*args, **args2):
pass
def fun7(a, b=10, *args,**args2):
pass
5.变量的作用域
程序代码能访问该变量的区域
根据变量的有效范围可分为
局部变量
在函数内定义并使用的变量,只在函数的内部有效,局部变量使用global声明,这个变量就会就成全局变量
全局变量
函数体定义的变量,可作用于函数内外
def fun(a, b):
c=a+b #c,就称为局部变量,因为c是函数体内进行定义的变量a和b为函数的形参,作用范围也是函数内部,相当于局部变量
print(c)
#print(c),因为a,c超出了起作用的范围,(超出了作用范围)
name='懒羊羊'#name的作用范围为函数内部和外部都可以使用--=》称为全局变量
print(name)
def fun2():
print(name)
#调用函数
fun2()
def fun3():
global age#函数内部定义的变量,局部变量,局部变量使用global声明,这个变量实际上就变成了全局变量
age=20
print(age)
fun3()
print(age)
6,递归函数
如果在一个函数的函数体内调用了该函数本身,这个函数就称为递归函数
递归函数的组成部分
递归调用与递归的终止条件
递归的调用的过程
每递归调用一次函数,都会在栈内存分配一个栈帧
每执行完一次函数,都会释放相应的空间
递归的优缺点
缺点:占用内存多,效率低下
优点:思路和代码简单
def fac(n):
if n==1:
return 1
else:
return n*fac(n-1)
print(fac(6))
总结
函数的定义与调用 | 函数使用def定义 | |
函数定义的形参 | ||
*定义个数可变的位置形参
| ||
**定义个数可变的关键字形参 | ||
定义默认值参数 | ||
函数调用的实参 | 位置参数 | |
关键字参数 | ||
函数可以多返回值 |
变量的作用域 | 局部变量 |
全局变量 |
递归函数 | 函数本身调用本身 | |
递归的组成部分 | 调用条件 | |
终止条件 |