chap10 (python全栈开发教程)

2022.11.7~2022.11.8

1.函数的创建和调用

# 1.函数的创建和调用
def calc(a, b):  # a，b成为形式参数，建成形参  形参的位置是在函数的定义处
    c = a+b
    return c   # return意思是结束，同时将结果提交，提交给函数的调用处

result=calc(10,20)   # 调用   位置实参   10,20称为实际参数的值，简称实参，实参的位置是函数的调用处
print(result)

res=calc(b=10, a=20)   # 关键字实参  等号左侧变量的名称称为关键字参数  b--形参名称  a--实参值
print(res)

2.函数的参数传递

# 2.函数的参数传递
def fun(arg1, arg2):
    print('arg1', arg1)
    print('arg2', arg2)
    arg1=100
    arg2.append(10)
    print('arg1', arg1)
    print('arg2', arg2)   # 为什么没有return？ 因为函数的执行过程中没有迭代回来任何结果，return可以省略不写，也可以在下一行直接写return
    # return

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的值
取决于是否是可变对象'''

3.函数的返回值

# 3.函数的返回值
print(bool(0))   # False
print(bool(8))   # 非0的布尔值为True

def fun(num):
    odd=[]    # 存奇数
    even=[]   # 存偶数
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even      #  return结束，同时返回奇数的列表、偶数的列表

'''函数的调用'''
lst=[10, 29, 34, 23, 44, 53, 55]
print(fun(lst))     # ([29, 23, 53, 55], [10, 34, 44])
'''函数的返回值
①如果函数没有返回值（函数执行完毕之后，不需要给调用处提供数据），return可以省略不写
②函数的返回值，如果是1个，直接返回原类型
③函数的返回值，如果是多个，返回的结果为元组
'''

def fun1():
    print('hello')
    # return
fun1()

def fun2():
    return'hello'
res=fun2()
print(res)   # hello

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

'''函数在定义时，是否需要返回值，视情况而定'''

4.函数的参数定义

# 函数的参数定义
'''①函数定义默认值参数'''


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


# 函数的调用
fun(100)  # 100 10
fun(20, 30)  # 20 30

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

'''②个数可变的位置参数'''


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


fun(10)
fun(10, 30)
fun(30, 405, 50)

print('hello', 'world', 'java')

'''③个数可变的关键字形参'''


def fun1(**args):
    print(args)


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

'''def fun2(*args,*a)
    pass
    以上代码，程序会报错，个数可变的位置参数（形参），只能是1个
    def fun2(**args,**a):
    pass
    以上代码，程序会报错，个数可变的位置参数（形参），只能是1个    '''


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


'''def fun3(**args1,*args2):
    pass
    在一个函数的定义过程中，既有个数可变的关键字形参，又有个数可变的位置形参，要求：个数可变的位置形参放在个数可变的关键字形参之前'''


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


# 函数的调用
fun(10, 20, 30)  # 函数调用时的参数数传递，称为位置传参
lst = [11, 2, 33]
fun(*lst)  # *--在函数调用时，将列表中的每个元素都转换为位置实参传入  (否则列表是一个整体)

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


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


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函数
fun4(10,20,30,40)   # 位置实参传递
fun4(a=10,b=20,c=30,d=40)  # 关键字实参传递
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=10,b=20,c=30,d=40)
fun4(10,20,c=30,d=40)

'''函数定义时的形参顺序问题'''
def fun5(a,b,*,c,d,**args):
    pass

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

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

5.变量的作用域

# 变量的作用域
def fun(a,b):
    c=a+b     # c就称为局部变量，因为c是在函数体内进行定义的变量，a、b是函数的形参，作用范围也是函数内部，相当于局部变量
    print(c)

# print(c)  因为a、c超出了起作用的范围（超出了作用域）
# print(a)

name='杨老师'   # name的作用范围为函数内部和外部都可以使用-->称为全局变量
print(name)
def fun2():
    print(name)
# 调用函数
fun2()

def fun3():
    global age
    age=20
    print(age)

fun3()
print(age)

6.递归函数

# 递归函数
'''计算阶乘'''
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):   # 斐波那契数列前6位上的数字
    print(fib(i))