10函数进阶

函数进阶

• 函数的参数

# 1.位置参数和关键字参数
"""
实参按照传递方式的不同分为位置参数和关键字参数两种
1) 位置参数
调用函数的时候让实参和形参一一对应（第一个实参给第一个形参赋值，第二个实参给第二个形参赋值...）
格式：数据1,数据2,数据3...

2) 关键字参数
让实参和形参通过关键字（形参名）对应
格式：形参名1=数据1，形参名2=数据2...

3) 关键参数的位置参数混用
混用的时候位置参数必须在关键字参数前面
"""
def func1(x, y, z):
    print(f'x:{x}, y:{y}, z:{z}')

# 位置参数
func1(10,20,30)
# 关键字参数
func1(z=30,y=20,x=10)
# func1(x=10,y=20,y=30) 报错
# 混用
func1(10,z=30,y=20)
# func1(x=20,20,z=30) 报错 位置参数必须在关键字参数前面

# 2.参数默认值
"""
定义函数的时候可以给参数赋默认值（以'形参名=数据'的形式），调用函数的时候有默认值的参数可以不赋值
注意：有默认值得参数必须在没有默认值参数的后面
"""
def func2(x=1,y=10,z=100):
    print(f'x:{x},y:{y},z:{z}')

func2(1,2,3) # x:1,y:2,z:3
func2(10,20) # x:10,y:20,z:100
func2(10) # x:10,y:10,z:100
func2() # x:1,y:10,z:100
func2(y=100) # x:1,y:100,z:100

# 3.参数类型的说明
"""
定义函数的时候，可以对参数类型进行说明
1) 赋默认值，默认值是什么类型，参数类型说明就是什么类型
2) 形参名:数据类型
"""
def func3(x=''):
    pass

def func4(x:list) -> None:
    x.append('100')

func4([])

# 4.不定长参数
"""
在形参前加*或者加**，就可以让这个参数变成不定长参数。不定长参数的形参可以同时接受多个实参
1) 带*的不定长参数
带*的参数会变成一个元组，元组中的元素就是对应的实参

注意：a.一个函数可以同时存在带*和不带*的参数，如果不带*的在带*的后面，不带*的参数必须使用关键字参数
     b.带*的参数必须使用位置参数

2) 带**的不定长参数
带**的不定长参数会变成一个字典，调用的时候用关键字参数传参，每个关键字就是字典的key，关键字后面的数据就是字典的value

注意：a.定义的时候定长参数必须放在**不定长参数的前面
     b.带*和带**的不定长参数可以同时存在，但是*必须在**前面（如果同时存在可以溶函数在调用的时候更加灵活）
"""
def func5(*x):
    print(f'x:{x}')

func5() # x:()
func5(10) # x:(10,)
func5(10,20) # x:(10, 20)
func5(1,2,3,4,5) # x:(1, 2, 3, 4, 5)

# 练习：定义一个函数，可以求多个数的和
# sum1(10,20) sum1(10,20,30)
def sum1(*num):
    sum2=0
    for x in num:
        sum2 += x
    print(sum2)
sum1(10,20)
sum1(10,20,30)

def func6(x,*y):
    print(f'x:{x},y:{y}')

func6(10) # x:10,y:()

def func7(*x,y):
    print(f'x:{x},y:{y}')

func7(1,2,3,y=4)

def func8(**num):
    print(num)

func8() # {}
func8(a=10,b=20) # {'a': 10, 'b': 20}
func8(x=100,y=200,z=300,m=0) # {'x': 100, 'y': 200, 'z': 300, 'm': 0}

def func9(x, **y):
    print(f'x:{x},y:{y}')

func9(10,a=20,c=30,d=40)

def func10(*x, **y):
    pass

• 函数的返回值

# 1.返回值
"""
1) 什么是返回值
返回值就是从函数内部传递到函数外部的数据。（如果实现函数的功能，产生了新的数据一般都需要将这个新的数据通过返回值返回）
2) 怎么确定函数返回值
在函数体中通过return关键字来返回返回值：return 数据
注意：同一个函数中，只有一个return有效。（因为执行函数体的时候只要遇到return，函数直接结束）
     如果要在一个函数中返回多个数据，用能够保持多个数据的容器。常用元组：return 数据1,数据2...
3) 怎么函数外部获取函数返回值
获取函数调用表达式的值就是获取函数的返回值。（返回值对应的数据能做的，函数调用表达式都可以做）
"""

def func1():
    print('111')
    return # 相当于return None
    print('222')
func1()

def func2():
    return 100
print(func2())

# 练习：删除指定列表中所有指定元素
def func3(list:list,item):
    return [x for x in list if x != item]
print(func3([1,23,4,5,1,34,2,1], 1))

• 全局变量和局部变量

# 根据变量的作用域不同，将变量分为全局变量和局部变量两种
# 1.全局变量
"""
定义在函数和类外面的变量都是全局变量
全局变量的作用域：从定义开始到程序结束的任何地方都可以用
"""
a = 10

for b in range(3):
    c = 10

for _ in range(3):
    print(f'循环里面a:{a}')

def func1():
    print(f'函数里面a:{a},b:{b},c:{c}')

func1()
print(f'外部a:{a}')

# 2.局部变量
"""
定义在函数里面的变量就是局部变量
作用域：从定义开始到函数结束

局部变量产生的原因：调用函数时，系统会自动为被调用的函数在栈区间开辟一块独立的内存空间，专门用来保存在
                这个函数中定义的变量，当函数调用结束后，这块内存空间会自动销毁
"""

def func4(m=10):
    x = 'abc'
    print(f'函数内部x:{x},m:{m}')

func4()
# print(f'函数外部的x:{x}') 报错
# print(f'函数外部的m:{m}') 报错

# 3.global和nonlocal
# global和nonlocal是函数体中的关键字，只能在函数体中使用
"""
1) global
global的作用：在函数中定义或者修改全局变量
用法：
global 变量名
变量名 = 值

2) *nonlocal
作用：在局部的局部中修改一个局部变量的值
nonlocal 变量名
变量名 = 值
"""
def func5():
    # 使用global在函数中定义全局变量
    global z
    z = 100

func5()
print(f'外部z:{z}')

name = '张三'
def func6():
    # 使用global修改全局变量的值（直接在函数内容给全局变量赋值，不会修改值，而是产生一个新的局部变量）
    global name
    name = '李四'
    print(f'函数内部name:{name}')

func6()
print(f'函数外部name:{name}')

def func7():
    age = 18

    def func8():
        nonlocal age
        age = 20
        print(f'局部变量的局部age:{age}')

    func8()
    print(f'局部变量的age:{age}')

func7()

• 匿名函数

# 1.什么是匿名函数
"""
匿名函数的本质还是函数:但是匿名函数只能通过一条语句来实现函数的功能
1)语法：
lambda 形参列表：返回值

相当于：
def 函数名(形参列表):
    return 返回值
"""
# 求两个数的和
# def sum1(num1,num2):
#     return num1+num2
sum1 = lambda num1,num2=3:num1+num2
print(sum1(10,20))
print(sum1(num2=100,num1=200))
print(sum1(2))

# 写一个匿名函数func2,功能是打印一个数的平方
func2 = lambda num:print(num**2)
func2(3)

# 练习：写一个匿名函数，判断指定的年是否是闰年
func3 = lambda year:print('闰年') if year % 400 == 0 or (year % 100 != 0 and year % 4 == 0) else print('平年')
func3(2021)

• 递归函数

# 1.什么是递归函数
# 在函数中调用函数本身的函数就是递归
# 作用：循环能做的额，递归都可以做（指导思想：能用循环解决的问题就不要递归）
# 递归控制次数：控制递归函数在指定次数后结束
count = 5
def func1():
    global count
    count -= 1
    print('===')
    if count == 0:
        return
    func1()
func1()
# 2.使用递归解决问题步骤
"""
第一步：定义普通函数一样定义函数
第二步：找临界值（找函数结束的条件）
第三步：找关系（找f(n)和f(n-1)的关系 - 找上次循环和本次循环之间的关系）
第四步：假设函数的功能已经实现，通过关系用f(n-1)实现f(n)的功能
"""
# 用递归 1+2+3+...+N
# f(n) = 1+2+3..+n-1+n
# f(n-1) = 1+2+3..+n-1
# 关系：f(n) = f(n-1)+n
def sum1(n):
#     1.找临界值
    if n == 1:
        return 1
#     2.找关系
    return sum1(n-1)+n
print(sum1(100))

def print_star(n):
    if n == 1:
        print('*')
        return
    print_star(n-1)
    print('*'*n)

print_star(5)