Python中的函数

1、函数的创建和调用

                    什么是函数？

                              函数就是执行特定任何以完成特定功能的一段代码。

                     为什么需要函数？

                                1、复用代码

                                2、隐藏实现细节

                                3、提高可维护性

                                4、提高可读性便于调试

                        函数的创建      def   函数名([输入参数]):

                                                        函数体

                                                        return xxx

def calc(a,b):    # 函数的创建
    c=a+b
    return c

result=calc(10,20)   # 函数的调用
print(result)

2、函数的参数传递

                    函数调用的参数传递：

                                     位置实参：根据形参对应的位置进行实参传递

                                     关键字实参：根据形参名称进行实参传递

# 位置实参
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) # 通关关键字a,b来赋值
print(res)

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

               

# 函数调用参数的传递 ，如果是不可变对象，在函数体的修改不会影响实参的值  arg1的修改为100，不影响n1的值
# 如果是可变对象，在函数体的修改会影响到实参的值 arg2的值为[22,33,44]
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)

3、函数的返回值

                     函数返回多个值时，结果为元组

# 函数的返回值
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,45,46,67,55]
print(fun(lst))

'''
 函数的返回值
 （1）如果函数没有返回值，函数执行完毕之后，不需要给调用处提供数据，return可以省略不写
 （2）函数的返回值，如果是1个，直接返回类型
 （3）函数的返回值，如果是多个，返回的结果为元组
 函数在定义时，是否需要返回值，视情况而定
'''
def fun1():
    print('hello')
    # return

fun1()



def fun2():
    return 'hello'

res=fun2()
print(res)

def fun3():
    return 'hello','world'
print(fun3())

4、函数的参数定义

                     函数定义默认值参数

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

def fun(a,b=10):  # b称为默认值参数
    print(a,b)
    
# 函数的调用
fun(100)
fun(20,30)

print('hello',end='\t')
print('world')

                 个数可变的位置参数： 使用*

                                          定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的                                            位置参数

                                           使用*定义个数可变的位置形参

                                           结果为一个元组

                 个数可变的关键字形参： 使用**

                                           定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的                                               关键字形参

                                            使用**定义个数可变的关键字形参

                                            结果为一个字典

# 个数可变的位置参数
def fun(*args): # 定义函数时，可变的位置参数
    print(args)
    print(args[0])

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

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

fun1(a=10)
fun1(a=10,b=20,c=30)

'''
def dun2(*args,*a):
    pass
    以上代码程序会报错，个数可变的位置参数，只能是一个
def dun2(**args,**a):
    pass
    以上代码程序会报错，个数可变的关键字参数，只能是一个
def dun3(**arg1,*arg2):
    pass
    在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求，个数可变的位置新参，放在这个个数可变关键字之前
'''

                                              

5、变量的作用域

                   程序代码能访问该变量的区域

                   根据变量的有效范围可分为：

                                     局部变量：在函数内定义并使用，只在函数内部有效，局部变量使用                                               global声明，这个变量就成全局变量

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

# 局部变量
def fun(a,b):
    c=a+b
    print(c)

#print(c)  # 因为a和c超出了起作用的范围
#print(a)

# 全局变量
name='杨老师'
print(name)
def fun2():
    print(name)
#调用函数
fun2()

def fun3():
    global age # 函数内部定义的变量，局部变量，局部变量使用global声明，这个变量实际上就变成了全局变量
    age=20
    print(age)
fun3()
print(age)

6、递归函数

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

          递归的组成部分：递归调用与递归终止条件

          递归的调用过程：1、每递归调用一次函数，都会在栈内存分配一个栈帧

                                       2、每执行完一次函数，都会释放相应的空间

         递归的优缺点：

                                 缺点：占用内存多，效率低下

                                 优点：思路和代码简单

# 递归函数
def fac(n):
    if n==1:
        return 1
    else:
        res=n*fac(n-1)
        return res
print(fac(6))

# 斐波那契函数
def fib(n):
    if n==1:
        return 1
    elif n==2:
        return 1
    else:
        return fib(n-1)+fib(n-2)

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