python第七节（函数）

函数

函数参数

'''
函数：封装一个特定功能的代码块
避免重复造轮子，提高代码的复用性
函数如果不进行调用，只会载入内存
只有当函数调用时，才会执行函数体内的代码
'''
def multi_table():
    print("九九乘法表")
multi_table()
"""函数参数"""
def test(b):    # 形参(小号)
    a = 100   # 不可变对象参数，相当于重新赋值
    print('111',a)
a = 1
test(a)  # 实参
print('222',a)
def test1(li):
    li.extend([1,11])       # 可变对象参数传入，改变原有的值
    print('123',li)
li = [1,2,3]
test1(li)
print('234',li)
'''利用函数完成两个数值相加'''
def sum_nums(a,b):
    result = a+b
    print('a',a)
    print('b',b)
    print("{}+{}={}".format(a,b,result))
num1 = int(input("请输入num1："))
num2 = int(input("请输入num2："))
sum_nums(num2,num1)    # 位置参数 一一对应
# sum_nums(num1=num1,num2=num2)  # 关键字参数 不受位置影响，只与形参对应有关
def test2(a,b=3):   # 默认值参数 不传为默认值，传了则覆盖
    a = a + b
    print(a,b)
a = 1
# test2(a)
test2(a,10)
# range(1,10).index()会报错
'''*args --> 可传可不传，但是要传-->元组
**kwargs --> 可传可不传，但是要传-->dict字典'''
def test4(*args):
    print(args)  # 传的元组
test4(1,2,3)

def test5(**kwargs):
    print(kwargs)
test5(a=1,b=2,c=3)      # {'a': 1, 'b': 2, 'c': 3}
def test6(a,b,c):
    print(a,b,c)
tu = (1,2,3)
test6(*tu)
a,b,c = (1,2,3)   # 解包

返回值

'''
函数的返回值
return 返回值
当有多个return时，执行不会报错，但是只执行第一个
因为程序在遇到函数体内第一个return 就返回出去了
今天距离20号还有13天
20号距离春节 5天
'''
def holiday():
    dis_holiday = 13
    print("距离放假还有：{}".format(dis_holiday))
    return dis_holiday
def spring_fes(dis_holiday):
    dis_spr_fes = dis_holiday + 5
    print("距离春节还有：{}".format(dis_spr_fes))
res = holiday()
print(res)
spring_fes(res)
def test6():
    a,b,c =1,2,3
    return a
    return b
    return c
a,b,c = test6()   # (a,b,c)
print(a)

作用域

'''
函数作用域
'''
# if True:
#     a = 5
# print(a)   # 不影响
# for i in range(3):
#     print("hello")
# print(i)
# def test():
#     b = 5   # 局部变量  # 会报错
# print(b)
# test()
a = 100
def test1():
    print(f'a={a}')  # 当局部没有该变量时，去全部中找该变量
def tset2():
    a = 200
    print(f'a={a}')  # 当局部存在该变量时，则优先局部的
test1()
tset2()
'''
局部变量-->全局变量
global 局部变量名'''
# count = 10
# def test3():
#     print(count)   # 会报错
#     count = 5
# test3()
count = 10
def test3():
    global count
    print(count)
    count = 5
    print(count)
test3()
'''
LEGB
local --> 局部作用域
enclosing--> 夹在函数中间的作用域
global --> 全局作用域
built-in -->内建作用域
1.先从自己所在层级找，如果没有就向外层找
2.只要在某个层内找到，就停止寻找，即使外面有同名的'''
a = int(2.14)  # built-in int()
c = 11  # global
def outer():
    d = 5   # enclosing
    def inner():
        f = 6   # local

函数嵌套

'''
函数的调用
代码读写  从上至下
函数执行完毕会返回到函数调用处  '''
# def test():
#     print('5')
# def test2():
#     print(3)
#     test()
#     print(4)
# def test3():
#     print(1)
#     test2()
#     print(2)
# test3()
def multi_table():
    print("九九乘法表")
def print_tables():
    # i = 0
    # while i < 10:
    #     multi_table()
    #     i += 1	# 十个九九乘法表
    for i in range(10):
        multi_table()
        print(i)
print_tables()   # 十个九九乘法表

递归

'''
递归
5! -->5*4*3*2*1
4! -->4*3*2*1
'''
# i = 1
# res = 1
# while i <= 4:
#     res = res*i
#     i += 1
# print(res)
'''
1.调用自身函数
2.还没有自带的结束条件(设置结束条件)
3.凡是递归可以做到的，循环也可以做
4.递归效率低于循环
'''
def get_nums(num):
    print(num)  # 6*5
    if num >1:
        return num*get_nums(num-1)  # 6*5*4*3*2*1
    else:
        return 1
res = get_nums(6)
print(res)