Python入门第十一章---函数

函数：执行特定任务以完成特定功能

函数的创建

def 函数名([输入参数]):
   函数体
   [return xxx]

函数的调用：函数名 ([实际参数])***

形式参数，简称形参，在函数定义处
实际参数的值，简称实参，在函数调用处
关键字形参，=左侧的变量名称称为关键字参数，在函数调用处

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)

re=calc(10,b=10)           #前一个是位置实参，后一个是关键字实参
print(re)

函数调用过程的参数传递

如果是不可变对象（元组），在函数体的修改不会影响实参的值
如果是可变对象（列表、字典、集合），在函数体的修改会影响到实参的值

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)
print('-----函数调用后-----')
print('n1:',n1)         #n1: 11
print('n2:',n2)        #n2: [22, 33, 44, 10]

函数的参数定义

函数定义默认值参数

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

def fun(a,b=10):       #b称为默认值参数
    print(a,b)
fun(100)            #a=100，b未指定采用默认值10
fun(20,30)          #20 30

print()函数默认结束换行

print('hello')          #ef print(self, *args, sep=' ', end='\n', file=None)默认换行
print('world')

print('hello',end='\t')     #指定end不换行
print('world')

个数可变的位置参数 只能定义一个

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

def fun1(*a):
    print(a)
    print(a[0])
fun1(10)             #(10,)     10
fun1(10,20)          #(10, 20)      10
fun1(10,20,30)       #(10, 20, 30)       10

个数可变的关键字形参 只能定义一个

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

def fun2(**a):
    print(a)
fun2(a=10)                  #{'a': 10}
fun2(a=10,b=20)             #{'a': 10, 'b': 20}
fun2(a=10,b=20,c=30)        #{'a': 10, 'b': 20, 'c': 30}

在一个函数定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参时，要求位置形参必须在关键字形参之前

def fun3(*arg1,**arg2):
    pass

# def fun3(**arg1,*arg2):   #错误
#     pass

将序列中的每个元素都转换成位置实参 使用*

def func(a,b,c):
    print('a=', a)
    print('b=', b)
    print('c=', c)

func(10,20,30)

lst=[11,22,33]
func(*lst)

运行结果：

将字典中的每个键值对都转换成关键字实参 使用**

func(a=100,b=200,c=300)

dic={'a':111,'b':222,'c':333}
func(**dic)

运行结果：

规定只能使用关键字实参传递：从*之后的参数，在函数调用时，只能采用关键字参数传递

def fun4(a,b,*,c,d):          #从*之后的参数，在函数调用时，只能采用关键字参数传递
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('d=', d)
# fun4(10,20,30,40)      #TypeError: fun4() takes 2 positional arguments but 4 were given
fun4(10,20,c=30,d=40)
fun4(b=10,a=20,c=30,d=40)

运行结果：

函数定义时形参的顺序问题

def fun5(a,b,*,c,d,**args):
    pass

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

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

函数的返回值

如果函数没有返回值（函数执行完毕后，不需要给调用处提供数据），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=[1,2,3,4,5,6]
print('原列表为：',lst)           #原列表为： [1, 2, 3, 4, 5, 6]
print(fun(lst))                  #([1, 3, 5], [2, 4, 6])

变量的作用域

程序代码能访问该变量的区域称为变量的作用域
局部变量：在函数内定义并使用的变量，只在函数内部有效

def fun1(a,b):
    c=a+b                #c就称为局部变量，因为c是在函数体内定义的变量。  a，b为函数的形参，作用范围也是函数内部，相当于局部变量
    print(c)
# print(a)         #因为a超出了作用的范围（超出了作用域）

局部变量使用global声明，这个变量就会变成全局变量

def fun3():
    global age                 #局部变量使用global声明，这个变量就会变成全局变量
    age=20
    print(age)
fun3()
print(age)

**全局变量：**函数体外定义的变量，可作用于函数内外

name='lisa'           #name的作用范围为函数内部和外部都可以使用，称为全局变量
print(name)
def fun2():
    print(name)
fun2()

递归函数

例：使用递归来计算阶乘

def fac(n):
    if n==1:
        return 1
    else:
        return n*fac(n-1)
i=int(input('请输入一个整数：'))
print(i,'!=',fac(i))

例：斐波那契数列（某一项是前两项的和）1,1,2,3,5,8

def fib(n):
    if n==1:
        return 1
    elif n==2:
        return 1
    else:
        return fib(n-1)+fib(n-2)
i=int(input('请问查看第几位斐波那契数列：'))
print('第',i,'位斐波那契数列是',fib(i))

#输出这个数列的前6位数字
print('---------------')
for item in range(1,7):
    print(fib(item))