Python(十八)函数

函数的创建

def 函数名（输入参数）：
函数体
[return xxx]

例：

def calc(a,b):
     c=a+b
     return c result=calc(10,20)
print(result)

结果：

30

函数调用的参数传递

• 位置参数：根据形参对应的位置进行实参传递
• 关键字传递：根据形参名称进行实参传递

例：

def calc(a,b):
    c=b+10
    return c
result=calc(b=20,a=100)
print(result)

结果：

30

函数调用的参数传递内存分析

例：

def fun(arg1,arg2):
    print(arg1)
    print(arg2)
    arg1=100
    arg2.append(10)
    print(arg1)
    print(arg2)
n1=11
n2=[22,33,44]
fun(n1,n2)
print(n1)
print(n2)

结果：

11

[22, 33, 44]

100

[22, 33, 44, 10]

11

[22, 33, 44, 10]

总结：在函数调用过程中，进行参数的传递，如果是不可变对象（例如常量、元组），在函数体的修改不会影响实参的值。如果是可变对象，会影响实参的值（例如字典）

函数的返回值

• 如果函数没有返回值，return可以不写
• 如果函数的返回值只有一个，则直接返回原类型
• 函数的返回值是多个元素时，结果为元组

例：

def fun(num):
    odd=[]
    even=[]
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even
print(fun([10,29,34,23,44,53,55]))

结果：

([29, 23, 53, 55], [10, 34, 44])

函数的参数定义

• 函数的默认值参数

函数定义时，给形参设置默认值，只有与默认值不符合的时候才会传递实参

例：

def fun(a,b=30):
    print(a,b)
fun(10)#此时b采用默认值30
fun(20,50)#此时b被50替代

结果：

10 30
20 50

个数可变的位置参数

• 定义参数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数
• 使用*定义个数可变的位置形参
• 结果为一个元组

例：

def fun(*arg):
    print(arg)
fun(10)
fun(10,20)
fun(10,20,30)

结果：

(10,)
(10, 20)
(10, 20, 30)

- 个数可变的关键字形参

• 定义函数时，无法事先确定传递的关键字参数的个数时，使用可变的关键字形参
• 使用**定义个数可变的关键字形参
• 结果为一个字典

例：

def fun(**arg):
    print(arg)
    print(type(arg))
fun(a=10)
fun(a=10,b=20,c=30)

结果：

{‘a’: 10}

<class ‘dict’>

{‘a’: 10, ‘b’: 20, ‘c’: 30}

<class ‘dict’>

函数的总结

例一：

def fun(a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)
lst=[11,12,13]
fun(lst)

结果：

TypeError: fun() missing 2 required positional arguments: ‘b’ and
‘c’（）报错

例二：

def fun(a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)
lst=[11,12,13]
fun(*lst)#在函数调用时，将列表中的每个元素都转换为位置实参传入

结果：

a= 11

b= 12

c= 13

例三：

def fun(a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)
dic={'a':111,'b':222,'c':333}
fun(dic)

结果：

报错

例四：

def fun(a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)
dic={'a':111,'b':222,'c':333}
fun(*dic)#在函数调用时，将字典的键转换为关键字传入
fun(**dic)#在函数调用时，将字典的键值对都转换为关键字实参传入

结果：

a= a

b= b

c= c

a= 111

b= 222

c= 333

例五：

def fun(a,b,*,c,d):   #*表示，从*之后，在函数调用时，只能采用关键字参数传递
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)
fun(10,20,30,40)

结果：

报错

例六：

def fun(a,b,*,c,d):   #*表示，从*之后，在函数调用时，只能采用关键字参数传递
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)
fun(10,20,c=30,d=40)#前两个为位置实参传递，而c,d采用的是关键字实参传递

结果：

a= 10

b= 20

c= 30

递归函数

递归函数定义：如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数

例：

def fac(n):
    if n==1:
        return 1
    else:
        return n*fac(n-1)
print(fac(6))

结果：

720

（6X5X4X3X2X1）