|
函数的创建和调用
什么是函数？ 函数就是执行特定任务和以完成特定功能的一段代码 为什么需要函数？ 复用代码，隐藏实现细节，提高可维护性，提高可读性便于调试 函数的创建 def 函数名([输入参数]): h函数体 [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)
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)
n1=11
n2=[22,33,44]
print(n1)
print(n2)
fun(n1,n2) #将位置传参，arg1，arg2是函数定义处的形参，n1，n2是函数调用出的实参，实参名称和此乃更惨名称可以不一致
print('----------------------')
print(n1)
print(n2)
'''在函数的调用过程中进行参数的传递，
如果是不可变对象，在函数体的修改不会影响实参的值
如果是可变对象，在函数体内的修改会影响到实参的值'''
 函数的返回值 函数返回多个值时，结果为元组
def fun(num):
odd=[] #存奇数
even=[] #存偶数
for i in num:
if i%2:
odd.append(i)
else:
even.append(i)
return odd,even
#函数的调用
lst=[10,29,30,23,44,53,55]
print(fun(lst))
'''
函数的返回值
（1）如果函数没有返回值【函数执行完毕之后不需要给调用书提供数据】return可以省略不写
（2）函数的返回值，若果是1个，直接返回原类型
（3）函数的返回值如果是多个，返回的结果是元组
'''
def fun1():
print('hello')
#return
fun1()
def fun2():
return 'hello'
res=fun2()
print(res)
def fun3():
return 'hello','world'
print(fun3())
'''
函数在定义时，是否需要返回值，视情况而定
'''
函数的参数定义
函数定义默认值参数 函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参
def fun (a,b=10): #b称为默认值
print(a,b)
#函数的调用
fun(100)
fun(20,30)
 个数可变的位置参数 定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数，使用*定义个数可变的位置形参，结果为一个元组
个数可变的关键字参数 定义函数时，可能无法事先确定传递的关键字实参的个数时，使用可变的关键字形参，使用**定义个数可变的关键字形参，结果为一个字典
def fun(*args): #函数定义时的可变的位置参数
print(args)
#print(args[0])
fun(10)
fun(10,30)
fun(33,20,261)
def fun1(**args):
print(args)
fun1(a=10)
fun1(a=10,b=20,v=30) #结果是一个字典
'''def fun2(*args,*a):
pass
以上代码报错，个数可变的位置参数只能是一个
def fun2(**args,**argv):
pass
以上代码报错，个数可变的关键字参数只能是一个
'''
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) #在函数调用时，将列表中的每个元素都转换为位置实参传入
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(**args2): #个数可变的关键字形参
print(args2)
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) #前两个用的是位置实参传递，后两个是关键字实参传递
'''要求：c，d只能使用关键字传递'''
'''
函数定义时的形参顺序问题
'''
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被称为局部变量，在函数体内定义的变量，a，b是函数的形参，作用范围也是函数的内部，相当于局部变量
print(c)
#print(c) ,a和c超出了作用域
#print(a)
name='雷姆' #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:
res=n*fac(n-1)
return res
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))
print('-----------------------')
#输出前六位
for i in range(1,7):
print(fib(i))
print('---------------------')
#计算前六位和
sum=0
for i in range(1,7):
a=fib(i)
sum=sum+a
print(sum)
|