函数参数的定义（个数可变的位置形参）

【个数可变的位置参数】
    1）自定义函数时，可能无法事先确定传递的位置实参的个数时（需要根据实际情况来），
这种情况就需要使用可变的位置参数。
    （2）使用 * 定义个数可变的位置形参
    3）返回值结果为一个元组

# 函数定义时 可变的位置参数 只能是1个参数
def fun(*args):
    print(args)

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

函数参数的定义（个数可变的关键字形参）

【个数可变的关键字形参】
    1）自定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参。
    2）使用 ** 定义个数可变的关键字形参。
    3）返回值结果为一个字典

# 可变的关键字参数 只能是1个参数
def fun1(**args):
    print(args)

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

def fun2(*agrs1,**args2):
    pass
'''
def fun3(**args1,*args2):
    pass
在一个函数的定义过程中，既有个数可变的位置形参，又有个数可变的关键字形参:【个数可变的位置形参必须放在个数可变的关键字形参前定义】
'''

函数的参数详解

# 自定义列表数据
lst = [11,22,33]
# 直接调用函数传递列表 TypeError: fun() missing 2 required positional arguments: 'b' and 'c' 函数缺少2个必须的位置参数
# fun(lst)
# * 表示在函数调用时,将列表中的每个元素都转换为位置实参传入
fun(*lst)
# 关键字实参调用函数
fun(a=100,b=300,c=200)
# 自定义字典数据
dic= {'a':111,'b':222,'c':333}
# 直接调用传参 TypeError: fun() missing 2 required positional arguments: 'b' and 'c' Fun()缺少2个必需的位置参数:'b'和'c'
# fun(dic)
fun(**dic)

# 自定义函数 【c,d两个参数只能采用关键字实参传递】
def fun(a,b,*,c,d):
    print('a=',a,'\t','b=',b,'\t','c=',c,'\t','d=',d)

# TypeError: fun() takes 2 positional arguments but 4 were given 【fun()接受2个位置参数，但给出了4个】
# fun(10,20,30,40)
fun(10,20,c=30,d=40)

# 函数定义时的形参的顺序
def fun(a,b,*,c,d,**args):
    pass

def fun(*args,**args1):
    pass

def fun(a,b=10,*args,**args1):
    pass

变量的作用域

1）程序代码能够访问该变量的区域称为变量的作用域；
2）根据变量的有效范围划分：
     a）局部变量：在函数内定义并使用的变量，只在函数内部有效；局部变量使用 global 声明，
 这个变量就会变成全局变量。
     b）全局变量：函数体外定义的变量，可作用于函数内外

# 自定义函数  【函数体内定义的变量c称为局部变量;a,b函数的形参，作用范围也是函数内部，相当于局部变量】
def fun(a,b):
    c = a+b
    print(c)

# 函数体内定义的变量值 使用global声明，就变成了全局变量
def fun3():
    global age
    age = 18
    print('函数体内输出变量值:',age)
fun3()
print('函数体外输出变量值:',age)

# 函数体外直接调用局部变量 【NameError: name 'a' is not defined 提示:变量'a'没有定义】
# print(a)

# 自定义一个全局变量（函数内部和外部都可以使用）
name = '张三'
print('自定义原始变量值:',name)
def fun1():
    print('函数体内输出自定义的全局变量:',name)
fun1()

递归函数

【什么是递归函数？】
    在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数。
【递归函数的组成部分】
    递归调用与递归终止条件
【递归的调用过程】
    每递归调用一次函数，都会在栈内存分配一个栈帧；
    每执行完一次函数，程序都会释放对应的空间。
【递归的优缺点】
    缺点：内存再用多，效率低
    优点：代码简单    

使用递归计算阶乘

# 自定义函数计算阶乘
def fac(n):
    if n == 1:
        return 1
    else:
        return n*fac(n-1)

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('求第N位上的斐波那契数列值:',fib(6))
# 输出斐波那契数列前N位的值
for i in range(1,7):
    print('输出斐波那契数列前N位的值',fib(i))