Python学习系列之函数（十九）

函数

一、大纲：

1、函数的创建和调用

2、函数的参数传递

3、函数的返回值

4、函数的参数定义

5、变量的作用域

6、递归函数

 

二、 函数的创建和调用

1.什么是函数

• 函数就是执行特定任务和以完成特定功能的一段代码

2.为什么需要函数

• 复用代码
• 隐藏实现细节
• 提高可维护性
• 提高可读性便于调试

3.函数的创建

创建格式：

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

　　函数体

　　[return xxx]

代码示例：

'''函数的创建和调用'''
def calc(a,b):
    c=a+b
    return c

result=calc(10,20)
print(result)

　　执行结果：

  图解函数执行：

 说明：当执行到calc(10,20)时，会先去找到calc()函数，然后带入参数，函数计算完成后退出函数，然后继续执行下一条语句

 使用debug模式查看程序执行顺序：

首先在函数调用所在行打断点，如下图，然后点击debug图标（绿色小虫子）调出debug模式

 点一下向下的箭头开始执行，如下图： 

  会跳转到下一步，即函数定义处

  再点击一次向下箭头，会跳转到定义函数的下一行，即执行该行

 再点一次向下箭头，返回到函数调用处，即断点所在行

  再点击一次向下箭头，会执行最后的Print函数，将结果输出

  再点击一次向下箭头，则结束debug，返回Console视图，则可以看到返回结果是30

 

三、函数的参数传递（位置实参和关键字实参）

函数调用的参数传递

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

位置实参示意图：

  关键字实参示意图：

  代码示例：

#函数的形参与实参
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)

　　执行结果：

  说明：calc(10,20)使用的是位置实参，即在调用处不定义形参，按照位置来一一传值，也就是会将10传递给a，20传递给b，如下图：

  calc(b=10,a=20)因为定义了形参，则会根据形参来传值，即10对应的关键字参数是b，则会将10传递给b,20对应的关键字参数是a，则会将20传递给a,如下图：

  

四、函数参数传递的内存分析

代码示例：

'''函数参数传递的内存分析'''
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',n1)
print('n2',n2)
fun(n1,n2)      #位置传参，arg1,arg2，是函数定义处的形参，n1,n2是函数调用处的实参，总结，实参名称和形参名称可以不一致

print('n1',n1)
print('n2',n2)

'''在函数调用过程中，进行参数的传递

如果是可变对象，在函数体的修改不会影响实参的值， arg1修改为100，不会影响n1的值
如果是可变对象，在函数体的修改会影响到实参的值， arg2的修改，append(10),会影响到n2的值
'''

　　执行结果：

  说明：fun(n1,n2)使用的是位置传参，所以函数调用之时n1的值11 会赋给函数定义处的arg1，n2的值[22,33,44]会赋给函数定义处的arg2，因11是字符串，是不可变类型，所以尽管在函数定义处将arg1赋值了100，还是不会影响最后n1的值，所以最后输出的n1的值是11，n2是列表，是可变类型，在函数定义处将n2添加了一个10，所以最后输出n2的值是[22,33,44,10]，示意图如下：

 

 

五、函数的返回值

函数返回多个值时，结果为元组，返回一个值则返回原类型，视情况判断是否需要返回(return)信息

代码示例：

每个字符串都有一个bool值，0的bool值是False，非0的bool值是True

print(bool(0))  #False
print(bool(8))  #True

　　执行结果：

 

 案例：将判断列表[10,29,34,23,44,53,55]中的数据是奇数还是偶数

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,55]
print(fun(lst))

　　执行结果：

  说明：

函数的返回值：

　　（1）如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】return可以省略不写

　　（2）函数的返回值，如果是1个，直接返回原类型

　　（3）函数的返回值，如果是多个，返回的结果为元组

所以案例中的返回值为元组，元组中有2个列表，第一个列表是奇数，第二个列表是偶数

• 没有返回值的情况

def fun1():
    print('hello')

fun1()

　　执行结果：

  说明：当没有返回值时，可以不写return

• 返回值是1个的情况

def fun1():
    return 'hello'

res=fun1()
print(res)

　　执行结果：

  说明：当返回值是一个时，返回原类型

• 返回值是多个的情况

def fun2():
    return 'hello','world'

print(fun2())

　　执行结果：

  说明：当返回值是多个值时，返回的是一个元组

 

六、函数的参数定义（默认值参数）

函数定义默认值参数

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

代码示例：

def fun(a,b=10):    #b称为默认值参数
    print(a,b)

fun(100)
fun(20,30)

　　执行结果：

  说明：fun(100)只传递了一个参数，那么会将100传递给a,b的值保持默认10，输出则为100,10，fun(20,30)将20传递给a,30传递给b，此时b的默认值值被覆盖，所以输出为20,30

实参覆盖形参以print()函数为例：

在Pycharm中新建python 文件，写上print()函数，然后按住CTRL不放，鼠标点击print，即可跳转到print函数的调用处，如下图，print函数有一个end形参的值是'\n'即换行，那么我们来试试覆盖这个形参

 

  

  代码示例：

#不覆盖end形参的情况，输出两个值时会默认换行
print('hello')
print('world')
#覆盖end形参的值为'\t'，输出两个值时会在同一行显示
print('hello',end='\t')
print('world')

　　执行结果：

 说明：当不覆盖形参时，会使用形参的默认值，当覆盖形参后会使用实参的值

 

七、函数参数定义（个数可变的位置形参，个数可变的关键字形参）

1. 个数可变的位置参数

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

2. 个数可变的关键字形参

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

3. 个数可变的位置参数 代码示例

def fun(*args):
    print(args)

fun(10)
fun(20,30)
fun(40,50,60)

　　执行结果：

 说明：当不知道多少个位置形参时，定义函数时可以使用*args进行定义，支持多个位置实参的输入，输出结果是一个元组

 4. 个数可变的关键字形参 代码示例

'''个数可变的关键字形参'''
def fun(**args):
    print(args)

fun(a=1)
fun(a=2,b=3)
fun(a=4,b=5,c=6)

　　执行结果：

  说明：当不知道要输入多少个关键字形参时，定义函数时参数可以使用**args来代替，调用函数时支持输入多个关键字形参，输出结果是字典

 

再看，print函数定义时有一个参数是*args，表示print函数支持多个形参输入，所以pint支持同时输入多个实参

print('hello','world','python')

　　执行结果：

可否同时定义多个个数可变的位置形参和个数可变的关键字形参？答案是：一个函数中只能定义一个位置形参和关键字形参，而且必须位置形参在前，否则代码会报SyntaxError: invalid syntax错误

'''是否可定义多个位置形参和关键字形参？'''
#以下代码会报错，同一个函数中，只能定义一个位置形参
def fun2(*args,*args1):
    pass

#以下代码会报错，同一个函数中，只能定义一个关键字形参
def fun3(**args1,**args2):
    pass

#同一个函数中可以同时定义一个位置形参和一个关键字形参，但是必须是位置形参在前
def fun4(*args1,**args2):
    pass

#以下代码会报错，同一个参数中定义位置形参和关键字形参是，必须是位置形参在前
def fun5(**args1,*args2):
    pass

 

八、函数的参数总结

  

 1. 位置实参

'''函数的参数总结'''
#位置实参
def fun(a,b,c):     #a,b,c在函数的定义处，所以是形式参数
    print('a=',a)
    print('b=', b)
    print('b=', c)

#函数的调用
fun(10,20,30)   #函数调用时的参数传递，称为位置传参

　　执行结果：

  

 2. 将序列中的每个元素都转换为位置实参

#位置实参
def fun(a,b,c):     #a,b,c在函数的定义处，所以是形式参数
    print('a=',a)
    print('b=', b)
    print('b=', c)

#函数的调用
lst=[11,22,33]
fun(*lst)

　　执行结果：

 说明：将列表的值转换为位置实参时，需要在方法调用处的列表前加一个*，最终形式为fun(*lst)，如果写成fun(lst)会报TypeError: fun() missing 2 required positional arguments: 'b' and 'c'，如下图

  

 3. 关键字实参

def fun(a,b,c):     #a,b,c在函数的定义处，所以是形式参数
    print('a=',a)
    print('b=', b)
    print('b=', c)

#函数的调用
fun(a=100,b=200,c=300)  #函数的调用，所以是关键字实参

　　执行结果：

  

 4. 将字典中的每个键值对都转换为关键字实参

def fun(a,b,c):     #a,b,c在函数的定义处，所以是形式参数
    print('a=',a)
    print('b=', b)
    print('b=', c)

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

　　执行结果：

  

5. 默认值形参

'''默认值形参'''
def fun(a,b=10):    #b是在函数的定义处，所以b是形参，而且进行了赋值，所以b称为默认值形参
    print('a=',a)
    print('b=', b)

　　

6.个数可变的位置形参和个数可变的关键字形参 

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(10,20,30,40)　　#位置实参传递
fun4(a=11,b=22,c=33,d=44)　　#关键字实参传递
fun4(10,20,c=30,d=40)　　　　#前两个参数，采用的是位置实参传递，后两个采用关键字实参传递

　　执行结果：

 

 练习：参数c，d只能采用关键字实参传递

def fun4(a,b,*,c,d):    #从*之后的参数，在函数调用时，只能采用关键字参数传递
    print('a=',a)
    print('b=', b)
    print('c=', c)
    print('d=', d)

fun4(a=11,b=22,c=33,d=44)
fun4(10,20,c=30,d=40)

　　执行结果：

  

 7. 在Pyton中，一个函数的参数可以同时存在位置形参、关键字形参，个数可变的位置形参和个数可变的关键字形参，如下：

'''函数定义时的形参的顺序问题，以下几种参数的混合写法都是可以的'''
def fun5(a,b,*,c,d,**args):
    pass

def fun6(*args,**args2):
    pass

def fun7(a,b=10,*args,**args2):
    pass

　　

 ------------------------------以上为Python中函数的基本内容