函数的创建和调用
函数的参数传递
函数的返回值
函数的参数定义
变量的作用域
递归函数
函数的创建和调用
什么是函数
函数就是执行特定任务以完成特定功能的代码
为什么需要函数
复用代码
隐藏实现细节
提高可维护性
提高可读性便于调试
函数的创建
def 函数名(输入参数)
函数体
【return xxx】I
def calc(a,b):#创建了个函数,真牛
c=a+b
return c
result=calc(10,20)
print(result)
函数的参数传递
函数调用的参数传递
位置实参
根据形参(形式参数)对应的位置进行实参传递
关键字实参
根据形参名称进行实参传递
def calc(a,b):#创建了个函数,真牛#ab称为形参,在函数的定义处
c=a+b
return c
result=calc(10,20)#10,20称为实参,在函数的调用处
print(result)
res=calc(b=10,a=20)#等号左侧的变量的名称称为关键字参数,优先于顺序
print(res)
#函数参数传递的内存分析
def fun(arg1,arg2):
print('arg1',arg1)
print('arg2',arg2)
arg1=100
arg2.append(10)
print('arg1',arg1)
print('arg2',arg2)#由于后面没有东西,所以return可以不写
n1=11
n2=[22,33,44]
fun(n1,n2)
print('n1',n1)
print('n2',n2)
'''在函数调用过程中,进行参数的传递
如果是不可变对象,在函数体的修改不会影响到实参的值,arg1的修改不影响n1 的值
如果是可变对象,在函数体内的修改会影响到实参的值,arg2的修改会影响n2'''
函数的返回值
函数返回多个值时,结果为元组
def fun(num):
odd=[]#存奇数
even=[]#存偶数
for i in num:
if i%2:
odd.append(i)
else:
even.append(i)
return odd,even
#函数的调用
lst=[20,30,22,12,21,23,323,321]
print(fun(lst))
'''函数的返回值
(1)如果函数没有返回值【函数执行完毕后,不需要给调用处提供数据】
(2)函数的返回值如果是一个,直接返回原值
(3)函数的返回值如果是多个,那么返回的结果是元组)'''
#情况1
def fun1():
print('hello')
fun1()
#情况2
def fun2():
return 'hello'
res=fun2()
print(res)
#情况3
def fun3():
return 'hello','world'
print(fun3())
'''函数在定义时,是否需要写返回值,视情况而定'''
函数的参数定义
函数定义默认值参数
函数定义时,给形参设置默认值,只有与默认值不符的时候才需要传递实参
def fun(a,b=10):#b称为默认值参数
print(a,b)
#函数的调用
fun(100)
fun(20,30)
print('hello')
print('world')
print('hello',end='\t')
print('world')
print('hello')
print('world')
个数可变的位置参数
定义参数时,可能无法事先确定传递的位置实参的个数时,使用可变的位置参数
使用*定义个数可变的位置形参
结果为一个元组
个数可变的关键字形参
定义函数时,无法事先确定传递的关键字实参的个数时,使用可变的关键字形参
使用***定义个数可变的关键字形参
结果为一个字典
def fun(*args):#函数定义时,可变的位置参数
print(args)
print(args[0])
fun(10)
fun(1,2)
fun(1,2,3,4)
def fun1(**args):
print(args)
fun1(a=10)
fun1(a=10,b=20)
print('hello','world','python')
'''def fun2(*args,*a):
psss
以上代码会报错,个数可变的位置参数只能是1个(没太懂啊)'''
'''def fun2(**
也会报错,个数可变的关键字也只能有1个'''
def fun2(*args1,**args2):
pass #不报错,可以运行
'''def fun3(**args1,*args2):
pass
这样就报错
在一个函数的定义过程中,既有个数可变的关键字形参也有个数可变的位置形参,要求个数可变的位置形参放在个数可变的关键字形参之前'''
函数的参数总结
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)#在函数调用时,将列表中的每个元素都转换为位置参数传入
print('------------------')
fun(a=100,c=300,b=200)#函数的调用,所以是关键字实参
dic={'a':111,'b':222,'c':333}
fun(**dic) #在函数调用时,将字典中的键值对都转换为关键字实参传入
def fun(a,b=10): #b是在函数的定义处,所以b是形参,而且进行了赋值,所以b称为默认值形参
print('a=',a)
print('b=',b)
def fun2(*args): #个数可变的位置形参
print(args)
def fun3(**args): #个数可变的关键字形参
print(args)
fun2(10,20,30,40)
fun3(a=11,b=22,c=33,d=44,e=55)
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=40)#前两个参数,采用的是位置实参传递,而cd采用的是关键字实参传递
'''需求,cd只能采用关键字实参传递'''
'''函数定义时的形参顺序问题'''
def fun5(a,b,*,c,d,**args):
pass
def fun6(*args,**args2):
pass
def fun7(a,b=10,*args,**args2):
pass
变量的作用域
就是程序代码能访问该变量的区域
根据变量的有效范围可分为
局部变量
在函数内定义并使用的变量,只在函数内部有效,局部变量使用global声明,这个变量就会成全局变量
全局变量
函数体外定义的变量,可作用于函数内外
def fun(a,b):
c=a+b #c,就是局部变量,因为c是在函数体内部进行定义的变量,a,b为函数的形参,作用范围也是函数内部,相当与局部变量
print(c)
#print(c)
#print(a),因为a,c超出了作用范围(作用域),所以报错
name='bibi' #name的作用范围是函数的内部与外部都可以使用,称为全局变量
print(name)
def fun2():
print(name)
fun2()
def fun3():
global age #局部变量使用global变量声明,就可以了
age=20
print(age)
fun3()
print(age)
递归函数
定义
如果在一个函数的函数体内调用了该函数本身,这个函数就称为递归函数
递归的组成成分
递归调用与递归终止条件
递归的调用过程
每递归调用一个函数,都会在栈内存分配一个栈帧
每执行完一次函数,都会释放相应的空间
递归的优缺点
缺点:占用内存多,效率低下
优点:思路和代码简单
def fac(n):
if n==1:
return 1
else:
return n*fac(n-1)
print(fac(6))
#斐波那契数列。
def fib(n):
if n==1:
return 1
elif n==2:
return 1
else:
return fib(n-1)+fib(n-2)
print(fib(6))
#输出这个数列的前六位数字
for i in range(1,7):
print(fib(i))
知识点总结