python基础入门12：函数

前言

本文总结函数相关内容，系统总结函数的定义，调用，参数的不同定义类型。本文主要内容依据以下视频链接地址。 https://www.bilibili.com/video/BV1wD4y1o7AS?p=87

函数

函数即为执行特定任务以完成特定功能的一段代码

函数的代码语法：

def 函数名(参数1,参数2,...,参数n):
    函数体#(1)
    return 返回值#(2)

#(1)此处为想要实现啥功能的表达式，比如求一个线性函数的值y=3x,那么可将x写到参数位置，函数体部分即为y=3x,而这里的y就是我们想要求的值，这个值最后返回。
#(2)如果函数的函数体只是要求执行一些操作，比如输出一个值，没有具体的函数表达式，则此时不需要返回。如

def fun(a,b):
    print(a,b)

定义完函数后就可以使用啦，我们使用的方式称为调用，其方式为：

调用时的代码语法：

函数名(参数)

函数的调用：

fun(3,4)#输出3 4

【函数示意图】

函数具体解析之参数

在函数体内的参数称为形参，即形式参数。就比如执行一项生产工作，我们需要列上原材料的名字，我们所定义的函数就如此一台实现该生产的机器。具体材料是什么，我们在具体生产的时候再给出，即我们在调用的时候在函数体外给出原材料的情况，此时具体的原材料参数称为实参，即实际参数。

参数类型

明确参数个数的参数类型

参数可表示为位置参数与关键字参数。

位置参数: 指单纯写变量名的参数，如函数名(a,b)。我们在调用的时候，就可以直接将对应的值写在对应的位置即可。

关键字参数： 带有变量及其数值的参数，如函数名(a=3,b=4)。这种情况我们在调用的时候实参的变量名需要与形参的变量名一致，数值不一致时，形参会传递实参的数值。

【注】：函数定义时，给形参设置默认值（即在写函数体的时候给参数赋了值），若实参的数值与该默认值不符，则形参会传递实参的数值。如

#函数的定义
def fun(a,b=3):#b为含有默认值的形参
    print(a,b)

#函数的调用
fun(3,3)#传入参数数与函数体内形参的数目相同，且按位置传递第二个参数的传递值与默认值相等;
fun(3,4)#传入参数数与函数体内形参的数目相同，且按位置传递第二个参数的传递值与默认值相等，则在执行时形参会传递实参的值，即在执行操作时b=4;
fun(100)#100传递给了未赋值的参数,另一个参数则直接使用默认值;
fun(10,d=10)#进行关键字传递时，其关键字名必须与函数体参数名相同, 此时程序会报错。

参数个数不明确的参数类型

当我们在设计函数的时候，我们可能不清楚我们执行一项功能到底是需要多少种材料，比如我们要执行榨果汁的操作，可以单纯打苹果汁，也可以打蜂蜜梨汁，或柠檬柚子葡萄汁。即我们不清楚到底需要设定多少个参数。

1. 若在此情况下我们要设定位置参数，可使用一颗星+变量名，即*变量名来表示, 则可以写为：

def fun(*arg):
    函数体
    return 返回值

2. 若此情况下我们想写成关键字参数的形式，则可以用两颗星+变量名，即**变量名来表示,则可以写为：

def fun(**arg):
    函数体
    return 返回值

以上两种方式在调用参数时，可自行设定参数的个数。

对于第一种情况，我们称该参数为：个数可变的位置参数,其特点为：

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

对于第二种情况，我们称该参数为：个数可变的关键字形参, 其特点为：

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

【代码示例】

def fun(*arg):#传几个参数都可以，返回值为一个元组。位置参数即函数调用时没有变量名，只有具体的数据
    print(arg,'我是一个元组')
def fun1(*arg):
    return arg

fun(10)#(1)
fun(10,100)#(2)
fun([10,100])#(3)函数体内直接执行了输出操作，所以无需再输出，直接调用
print(fun1(10))#(4)只是内存里有了返回值，要想显示出来需要执行输出操作
print(fun1(10,100))#(5)
print(fun1([10,100]))#(6)
def fun2(**arg):#函数调用时指定变量名。函数的返回值为字典
    print(arg, '我是一个字典')
fun2(a=10,b=20)#(7)

def fun3(**arg):
    return(arg)
print(fun3(a=10,b=20), '我是一个字典')#(8)

输出结果为：

(10,) 我是一个元组#(1)
(10, 100) 我是一个元组#(2)
([10, 100],) 我是一个元组#(3)
(10,)#(4)
(10, 100)#(5)
([10, 100],)#(6)
{'a': 10, 'b': 20} 我是一个字典#(7)
{'a': 10, 'b': 20} 我是一个字典#(8)

【注】1. 在定义函数时，个数可变的位置参数与个数可变的关键字参数只能为1个，以下函数运行报错。

def fun4(*a,*b):#可变的位置参数只能为1个
    pass
def fun5(**a,**b):#可变的关键字参数也只能为1个
    pass

2. 在定义函数时，参数可同时为个数可变的位置参数与个数可变的关键字参数，定义时参数个数都为1个。

def fun6(*arg,**arg1):
    print(arg,arg1)
fun6(10,a=10)#输出时位置可变的参数的数值以元组的形式输出，关键字可变的参数的数值以字典的形式输出

输出为：

(10,) {'a': 10}

函数调用时的参数类型

1. 对于函数定义的时候给定了指定位数的位置参数，调用时所需引用的数值为一个仅有数值的序列，此时则可使用*获取序列的每个值进行调用，实现函数传递。若调用时给定了关键词实参的形式，此时可使用**获取关键词实参及其对应数值进行调用，实现函数传递。

【代码示例】

#函数定义
def fun(a,b,c):
    print('a=', a)
    print('b=', b)
    print('c=', c)
#函数调用
#使用*获取序列元素
lst = [20,30,40]
tupl =(20,30,40)
fun(*lst)#在函数调用时，将列表中的每个元素都转换为位置实参传入
fun(*tupl)
#使用**获取序列元素
fun(a=100,b=200,c=300)
dic = {'a': 100, 'b': 200, 'c': 300}#在函数调用时，将字典中的键值对都转换为关键字实参
fun(**dic)

其他函数定义方式

def fun5(a,b,*,c,d,**args):#(1)
    print(a,b,c,d)
def fun6(a,b=10,*args,**arg2):#(2)
    print(a,b)

#(1)表示*之后的变量为关键字参数，函数调用时需要写为关键字参数。
#(2)表示参数一个为位置参数，另一个为关键字参数。函数调用时可使用位置参数，也可使用关键字参数。

(1)(2)的调用方式可为

fun5(10,20,c=[33,44],d=22)
fun6(10,b=[10,20])

【注】函数调用有关可变对象与不可变对象参数传递
在函数调用过程中，进行参数的传递，如果是不可变对象，在函数体的修改不会影响实参的值；如果是可变对象，在函数体的修改会影响实参的值。

【代码示例】

#函数的定义
def fun(arg1, arg2):
    print(arg1)
    print(arg2)
    arg1 = 100
    arg2.append(10)
    print(arg1)
    print(arg2)
#函数的调用
n1 = (10,10)#不可变对象
n2 = [22,33,44]#可变对象
print('1.', n1)
print('2.', n2)
fun(n1,n2)
print('3.', n1)
print('4.', n2)

输出结果为：

1. (10, 10)
2. [22, 33, 44]
########调用函数产生结果
(10, 10)
[22, 33, 44]
100
[22, 33, 44, 10]
######################
4. (10, 10)#相比于1.的结果, 调用函数结束后，n1的值未发生改变
5. [22, 33, 44, 10]#相比于2.的结果，调用函数后，n2的值发生改变

变量的作用域

• 程序代码能访问该变量的区域
• 根据变量的有效范围可分为：

1. 局部变量： 在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明就会变成全局变量。若在函数体外执行输出操作会报错。如：

def fun1():
    global age#将局部变量声明为全局变量
    age = 3
    print(age)
fun1()
print(age)

2. 全局变量
   函数体外定义的变量，可作用于函数内外。

函数举例

• 递归函数

递归函数 在一个函数的函数体内调用了该函数本身，这个函数就成为递归函数。
递归的组成部分 递归调用与递归终止条件

递归调用过程 1. 每递归调用一次函数，都会在栈内存分配一个栈帧；2. 每执行完一次函数，都会释放相应的空间

递归的优缺点 缺点：占用内存多，效率低下；优点：思路代码简单

【代码示例】使用递归函数求1到$n$的阶乘！

def fac(n):
    if n==1:
        return 1
    else:
        return n*fac(n-1)
print(fac(6))#输出为720