1.匿名函数

1.普通函数:
def 函数名(参数列表):
函数体

2.匿名函数:
函数名 = lambda 参数列表:返回值

说明：
函数名 -> 变量名
lambda -> 关键字
参数列表 -> 参数名1, 参数名2...
: -> 固定的
返回值 -> 相当于只有一个return语句的函数体

匿名函数的调用和普通函数一样：函数名(实参列表),也支持位置参数、关键字参数、参数设置默认值、不定长参数

写一个匿名函数，功能是求两个数的和

sum1 = lambda num1=10, num2=3: num1+num2

print(sum1(10, 20))
print(sum1(num1=100, num2=200))
print(sum1())

相当于上面的匿名函数

def sum1(num1, num2):
    return num1+num2

练习：求1+2+3+...+n的和

sum2 = lambda n: sum(range(n+1))
print(sum2(100))

练习：读程序

funcs = []
for item in range(1, 5):
    funcs.append(lambda x: x*item)
print(item)

print(funcs[0](2))  # 2*4   8
print(funcs[1](2))  # 2*4   8
"""
item = 1 ~ 4
item = 1  [lambda x: x*item]
item = 2  [lambda x: x*item, lambda x: x*item]
item = 3  [lambda x: x*item, lambda x: x*item, lambda x: x*item]
item = 4  [lambda x: x*item, lambda x: x*item, lambda x: x*item, lambda x: x*item]
"""

2.变量的作用域

1.变量的作用域
变量的作用域指的是变量能够使用的范围

2.全局变量
全局变量:声明在函数和类的外面的变量都是全局变量；作用域是从声明开始，到整个py文件结束（任何地方都可以使用）

3.局部变量
声明在函数和类中的变量都是局部变量。声明在函数的局部变量，作用域是从声明开始到整个函数结束

4.global关键字
在函数中说明一个变量是全局变量
注意：只能在函数中使用

5.nonlocal关键字
想要在局部的局部中修改局部变量的值

def func3():
    abc = 100
    def func4():
        nonlocal abc
        abc = 200
        print('f4:', abc)
    func4()
    print('f3:', abc)

func3()

3.函数作为变量

声明函数就是声明一个类型是function的变量, 函数名实质就是变量名。

1.变量可以给其他变量赋值

func1 = lambda x: print(x)
func2 = func1
func2(10)

# 声明一个变量func11，类型是function
def func11():
    print('我是函数')
# 用一个函数给变量a赋值，a也是一个函数
a = func11
a()
print(a)

# 将函数func11的返回值给b，b的值是None
b = func11()
print(b)

2.函数作为列表的元素

a = 10
list1 = [1, a]
print(list1, list1[1]+100)

def func22():
    print('我又是函数')
    return 10

list2 = [1, func22, func22()]
print(list2)

3.将函数作为参数
应用：sort的使用
列表.sort(key=None, reverse=False)
使用sort的时候,可以通过给key赋一个函数变量，来规定列表中的元素按照什么标准来排序。
这儿的函数变量要求要有一个参数和一个返回值。参数代表列表中的元素，返回值代表按照那个标准排序

list1 = [1, 45, 8, 89]
list1.sort()
print(list1)

list2 = [
    {'name': '张三', 'age': 20, 'score': 90},
    {'name': '李四', 'age': 28, 'score': 70},
    {'name': '王五', 'age': 18, 'score': 89}
]
# 根据成绩排序
def get_age(item):
    return item['score']
list2.sort(key=get_age)
list2.sort(key=lambda item: item['score'])
print(list2)

4.将函数作为返回值

根据运算符号，返回对应的功能

def operation(operator: str):
    if operator == '+':
        def add(*args, **kwargs):
            """求和"""
            sum1 = 0
            for item in args:
                sum1 += item
            for key in kwargs:
                sum1 += kwargs[key]
            return sum1
        return add

    elif operator == '*':
        def func2(*args, **kwargs):
            """求乘积"""
            sum1 = 1
            for item in args:
                sum1 *= item
            for key in kwargs:
                sum1 *= kwargs[key]
            return sum1
        return func2


f1 = operation('+')   # f1就是有两个不定长参数，功能是求和的函数
re = f1(10, 20, a=2, b=3)
print(re)


print(operation('+')(10, 20, a=2, b=3))
print(operation('*')(1, 2, 3, 4))

4.递归函数

1.什么是递归函数
递归函数：函数中调用函数本身，这样的函数就是递归函数(自己调自己)

循环能做的事情递归都可以做，但是实际上循环能解决的问题绝对不选递归

2.怎么写递归函数
第一步：确定临界值(循环结束的条件), 让函数结束
第二步：找关系,假设函数的功能已经实现，找f(n)和f(n-1)的关系
第三步：根据关系，用f(n-1)实现f(n)的功能

yt_sum(5) n=5 5!=1 return yt_sum(4)+5
yt_sum(4) n=4 4!=1 return yt_sum(3) + 4
yt_sum(3) n=3 3!=1 return yt_sum(2) + 3
yt_sum(2) n=2 2!=1 return yt_sum(1) + 2
yt_sum(1) n=1 1==1 return 1

写一个递归函数，实现：1+2+3+...n

def yt_sum(n):
    # 1.找临界值
    if n == 1:
        return 1

    # 2.找关系
    """
    yt_sum(n) = 1+2+3+...+n
    yt_sum(n-1) = 1+2+3+...+n-1
    yt_sum(n) = yt_sum(n-1)+n
    """
    # 3.用f(n-1)实现f(n)的功能
    return yt_sum(n-1) + n


print(yt_sum(5))

用递归实现以下功能

n = 3

---

**

n = 4

---

---

**

f(n)和f(n-1)的关系：
先打印n颗星
f(n-1)

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

    print('*'*n)
    print_star(n-1)


print_star(5)

总结：递归，能不用就不用！！