函数
函数定义：函数就是执行特定任何以完成特定功能的一段代码
函数的创建和调用
def 函数名([输入参数])
函数体
[return XXX]
#函数的创建 def calc(a,b): #a,b称为形式参数，简称形参，形参的位置是在函数的定义处 c=a+b return c #函数的调用 relsult=calc(10,20) #10,20称为实际参数的值，简称实参，实参的位置是函数的调用处 print(relsult) #30
函数的参数传递
- 位置实参——根据形参对应的位置进行实参传递；
- 关键字实参——根据实参名称进行实参传递
def calc(a, b): # a,b称为形式参数，简称形参，形参的位置是在函数的定义处 c = a + b return c #位置实参 result = calc(10, 20) # 10,20称为实际参数的值，简称实参，实参的位置是函数的调用处 print(result) # 30 #关键字实参 res=calc(b=10,a=20) #等号左侧的变量称为关键字参数 print(res)
例子： def fun(arg1,arg2): print('arg1',arg1) #arg1 11 print('arg2',arg2) #arg2 [22, 33, 44] arg1=100 arg2.append(10) print('arg1',arg1) #arg1 100 print('arg2',arg2) #arg2 [22, 33, 44, 10] n1=11 n2=[22,33,44] print('n1',n1) #n1 11 print('n2',n2) #n2 [22, 33, 44] fun(n1,n2) #位置传参，arg1,arg2 是函数定义处的形参，n1,n2是函数调用处的实参；总结：实参名称与形参名称可以不一致 print('n1',n1) #n1 11 print('n2',n2) #n2 [22, 33, 44, 10]
- 在函数调用过程中，进行参数的传递
如果是不可变对象，在函数体的修改不会影响实参值，arg1的修改为100，不会影响n1的值；
如果是可变对象，在函数体的修改会影响到实参值，arg2的修改，append(10)，会影响到n2值。
函数的返回值
- 函数的返回值
- 如果函数没有返回值【函数执行完毕后，不需要给调用处提供数据】 return可以省略不写
- 函数的返回值，如果是1个，直接返回类型
- 函数的返回值，如果是多个，返回的结果为元组
def fun1(): print('hello') #return fun1() #hello def fun2(): return 'hello' res=fun2() print(res) #hello def fun3(): return 'hello', 'world' print(fun3()) #('hello', 'world')
例子： 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,34,23,44,53] print(fun(lst)) #([29, 23, 53], [10, 34, 44])
函数在定义时是否需要返回值，视情况而定
函数参数定义
- 函数定义默认值参数
函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参。
def fun(a,b=10): #b称为默认值参数， print(a,b) #函数的调用 fun(100) #100 10 fun(20,30) #20 30
- 个数可变的位置参数
定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数；
使用*定义个数可变的位置形参；
结果为一个元组
def fun(*args): print(args) #函数定义时的 可变位置参数 fun(10) #(10,) fun(10,30) #(10, 30) fun(34,56,31) #(34, 56, 31)
- 个数可变的关键字形参
定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字参数；
使用**定义个数可变的关键字形参；
结果为一个字典
def fun(**args): print(args) fun(a=10) #{'a': 10} fun(a=12,b=34,c=56) #{'a': 12, 'b': 34, 'c': 56}
注意：
def fun1(*args,*a):
pass
以上代码，程序会报错，个数可变的位置参数，只能是1个
def fun2(**args,**a):
pass
以上代码，程序会报错，个数可变的关键字参数，只能是1个
def fun1(**args,*a):
pass #以上代码，程序会报错
________________________________________________________________________________
def fun2(*args,**a):
pass
结论：在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求，个数可变的位置形参放在个数可变的关键字形参之前
变量的作用域
- 程序代码能访问该变量的区域
- 根据句变量的有效范围可分为：
- 局部变量
在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就会变成全局变量 - 全局变量
函数体外定义的变量，可作用于函数体外
def fun(a,b): c=a+b #c 就称为局部变量，因为c是在函数体内进行定义的变量，a,b为函数的形参，作用范围是函数内部，相当于局部变量 print(c) #print(c) #print(a) #报错，因为a,c超出了起作用的范围（超出作用域） name = 'duck' #name的作用范围为函数内部和外部都可以使用，称为全局变量 print(name) #duck def fun2(): print(name) #duck #调用函数 fun2() def fun3(): global age #函数内部定义的变量，局部变量，局部变量使用global声明，这个变量实际上就成了全局变量 age = 20 print(age) fun3() print(age)
递归函数
- 定义：如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数
- 递归函数的组成部分：递归调用与递归终止条件
- 递归的调用过程
a. 每递归调用一次函数，都会在栈内存分配一个栈帧
b. 每执行完一次函数，都会释放相应的空间
- 递归的优点：
a.缺点：占用内存多，效率低下
b. 思路和代码简单
def fac(n): if n==1: return 1 else: res=n*fac(n-1) return res print(fac(6)) #720
斐波那契数列
def fib(n): if n==1: return 1 elif n==2: return 1 else: return fib(n-1)+fib(n-2) #斐波那契数列第6位上的数字 print(fib(6)) #8 #输出这个数列的前6位上的数字 for i in range(1,7): print(fib(i)) ''' 1 1 2 3 5 8 '''
总结
| 序号 | 参数的类型 | 函数的定义 | 函数的调用 | 备注 |
| 1 | 位置实参——将序列中的每个元素都转换为位置实参 | 是 | 使用* | |
| 2 | 关键字实参——将字典中的每个键值对都转换为关键字实参 | 是 | 使用** | |
| 3 | 默认值形参 | 是 | ||
| 4 | 关键字形参 | 是 | 使用* | |
| 5 | 个数可变的位置形参 | 是 | 使用* | |
| 6 | 个数可变的关键字形参 | 是 | 使用** |
