五、匿名函数

普通函数：
def 函数名（参数列表）：
函数体

匿名函数：
函数名= lambda 参数列表：返回值

说明:
函数名——》实质是变量名
lambda——》关键字
参数列表——》参数名1，参数名2，...
返回值——》相当于函数体只有return，无其他代码段；
匿名函数的调用和普通函数一样；

写一个匿名函数，求两个数之和

sum1=lambda x,y:x+y
print(sum1('abc','123'))  #abc123

练习:求1+2+...n之和

sum1=lambda n:sum(range(n+1))
print(sum1(100))   #5050

练习：读程序

funcs = []
for item in range(1, 5):
    funcs.append(lambda x: x*item)
print(item)
=========过程分析=========
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]
=================过程分析===========
print(funcs[0](2))  # 2 *4     8
print(funcs[1](2))  # 2 *4     8

六、变量的作用域

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

1、全局变量

全局变量：声明在函数和类外面的变量都是全局变量，作用域是从该变量声明开始，到整个py文件结束。
（该范围内任何地方都可以使用，不管是否在循环语句或分支语句内外均可使用）

2、局部变量

局部变量：声明在函数或者类里面的变量都是局部变量，作用域是从该变量声明开始，到整个函数或者类结束。

3、global关键字

在函数中说明一个变量是全局变量
注意：只能在函数中使用

aa=100
def sum_n(n):
    #global bb     #可在bb变量声明之前 使用此步骤，定义变量bb是全局变量；（只能用于函数中，不能用于类）
    bb=99
    sum_n=0
    for x in range(1,n+1):
        sum_n += x
        print(aa)   #aa为全局变量  可以在此时用  a=100
    print(sum_n)  #3
sum_n(2)
###### print(bb)   #NameError: name 'bb' is not defined  bb为局部变量，无法在函数外使用
###### global 变量名     意义：定义一个变量为全局变量，注意必须在声明变量前定义

4、 nonlocal关键字

想要在局部的局部中修改局部变量的值

def func3():

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

七、函数作为变量

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

1、函数可以给其他变量赋值

a = 10
b = a
print(b*10)

list1 = [1, 2]
list2 = list1
list2.append(100)
print(list2)

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)
# list2[1]取到一个函数, 通过后面加()调用函数
print(list2[1]())

# list2[2]取到的是整数10
print(list2[2]+100)

3、函数作为参数

a = 10
def func1(n):

    print(n)
func1(a)
=====================
def func11(n):

    # n = func12
    n()  # func12()
===================
def func12():

    print('hello world')
re = func11(func12)

应用：sort的使用

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

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

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

    return item['score']
list2.sort(key=get_age)
方法2
list2.sort(key=lambda item: item['score'])
print(list2)

===========

list3 = [
    ('a', 20),
    (10, 3),
    ('b', 90)
]
方法1
def second(item):

    return item[1]
list3.sort(key=second, reverse=True)
print(list3)
方法2
list3.sort(key=lambda item: item[1])
print(list3)

4、函数作为返回值

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

def operation(operator: str):

    if operator == '+':
        def add(*args, **kwargs):
            """求和"""
            """
            args=(10, 20)
            kwargs = {'a':2, 'b':3}
            """
            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

八、函数的调用

1、Python中的函数可以有多个返回值

求多个数的和以及平均值

def jsj_sum(*nums):

    sum1=sum(nums)
    average=sum(nums)/len(nums)
    return sum1,average   #返回值为元祖
aaa=jsj_sum(1,2,3,4,5,56,67,7)
print(aaa)   #(145, 18.125)
print(aaa[0],aaa[1])###145 18.125

2、函数的调用过程是一个压栈的过程

每次调用函数的时候，系统都会在内存中（栈）开辟空间来存储函数执行过程
中产生的数据（函数声明的变量），当函数调用完成后，这块内存会自动销毁。

九、递归函数

1、递归函数：函数中调用函数本身，这样的函数就是递归函数（自己调用自己）
循环能做的事情递归函数都能做到，但实际上循环能做的绝不用递归函数做
2、怎么写递归函数
第一步：确定临界值（循环结束的条件），让函数结束
第二步：找关系，假设函数的功能已经实现，找f（n）和f（n-1）的关系
第三步：根据关系，用f（n-1）实现f（n）的功能

def star(n):

    if n==1:
        print("*")
        return

    print("*"*n)
    star(n-1)
star(5)