1.什么是匿名函数

匿名函数还是函数，只是声明的格式和普通函数不一样。只适用于函数功能比较简单的函数

def 函数名(形参列表)：
函数体

2.匿名函数的声明

a.语法
变量名 = lambda 形参列表：返回值

b.说明
变量名 - 相当于函数名
lambda - 声明匿名函数的关键字
形参列表 - 和普通函数的形参列表一样
： - 固定写法
返回值 - 相当于普通函数中只有一条return语句的函数体

3.匿名函数的调用

和普通函数一样

1.匿名函数的参数也可以设置默认值(不会有类型提示)
2.匿名函数不能通过添加 ：类型名 来说明参数类型

func1 = lambda x, y: x + y
print(func1(10, 20))


# 这个函数和上面的匿名函数一模一样！
def func1(x, y):
    return x + y


print(func1(10, 20))

3.匿名函数可以设置不定长参数

func2 = lambda *nums: sum(nums)
print(func2(10, 20, 200))

func3 = lambda x: print(x)
print(func3(100))

---

1.什么是变量的作用域

就是变量能够使用的范围

2.全局变量和局部变量

a.全局变量 - 没有声明在函数或者类中的变量都是全局变量
全局变量的作用域是从声明开始，到整个文件结束

b.局部变量 - 声明在函数或者类中的变量就是局部变量
局部变量的作用域是从声明开始，到函数结束

总结：当我们调用函数的时候，系统会自动在栈区间专门为这个函数开辟一块独立的内存空间，用来保存在函数中声明的变量(形参也是属于声明在函数中的变量)。当函数调用结束后，
这个函数对应的栈区间会自动销毁 --- (函数调用过程是一个压栈的过程)*

1.全局变量

# 变量a是全局变量
a = 100

print(a)
for x in range(5):
    print('循环里:', a)


def func1():
    print('函数中:', a)


func1()

2.全局变量

# 这儿的y也是全局变量
for y in range(3):
    print(y)

print('外面：', y)


def func2():
    print('函数里：', y)


func2()

3.局部变量
a.函数的形参就相当于声明在函数中的变量，所以是局部变量

# num1是局部变量
def func3(num1):
    print(num1)
    for x in range(3):
        print(num1)


func3(10)
# 局部变量不能在函数外面使用
# print(num1)    # NameError: name 'num1' is not defined


# 函数中的nums, max1和item都是局部变量
def func4(*nums):
    max1 = nums[0]
    for item in nums:
        if item > max1:
            max1 = item
    print(max1)


func4(1, 89, 9, 887, 0)

4.如果全局变量和局部变量同名，那么在局部变量的作用域中使用的是局部变量；外部使用的是全局变量

# 全局变量
aa = 100


def func5():
    # 局部变量
    aa = 200
    print('函数里：', aa)


func5()
print('外部：', aa)

3.global - 在函数中声明一个全局变量(只能在函数中使用)

在函数中：
global 变量名
变量名 = 值

bb = 111


def func6():
    global bb
    bb = 222
    print('函数里:', bb)

    global aa
    aa = 100
    print(aa)


func6()
print('外部：', bb)
print(aa)

4.nonlocal - 想要在局部的局部中去修改局部变量的值，就使用nonlocal对变量进行说明

nonlocal 局部变量
局部变量 = 值

def func11():
    abc = 123
    print('func11', abc)

    def func22():
        nonlocal abc
        abc = 333
        print('func22', abc)
    func22()

    print('func11', abc)


func11()

"""
list1 = []
i = 0   [lambda x: x*i]
i = 1   [lambda x: x*i, lambda x: x*i]
i = 2   [lambda x: x*i, lambda x: x*i, lambda x: x*i]
i = 3   [lambda x: x*i, lambda x: x*i, lambda x: x*i, lambda x: x*i]
i = 4   [lambda x: x*i, lambda x: x*i, lambda x: x*i, lambda x: x*i, lambda x: x*i]
"""
list1 = []
for i in range(5):
    list1.append(lambda x: x*i)
print(list1)

print(list1[0](3))  # 12
print(list1[3](3))  # 12

# list1 = [lambda x:x*2]
# print(list1[0](1))

---

python中声明函数，其实就是声明一个类型是function的变量，函数名就是变量名

函数名 -- 类型是function的变量
函数名() -- 调用函数并且获取函数的返回值
普通变量能做的事情函数变量都能做！

1.给别的变量赋值

# 声明了一个列表变量list1
list1 = [1, 2, 3]


# 声明一个函数变量func1
def func1():
    print('我是一个函数！')
    return 10


# 使用列表变量给另外一个变量list2赋值
list2 = list1
# 赋值后list2就可以当成列表来用
print(list2[0])
print(list2[::-1])
list2.append(100)
print(list2)


# 使用函数变量给另外一个变量func2赋值
func2 = func1
# 赋值后func2就可以当成函数来使用
func2()
print(func2())

2.变量作为容器类数据的元素

a = 10
nums = [a, 100, 1000]
print(nums)
print(nums[0] - 10)


def func3(x):
    print('abc', x)
    return 10


list2 = [func3, func3(10), 100]
print(list2)
print(list2[0](1))

3.变量作为函数的实参

函数1作为函数2的实参 -- 函数2就是一个高阶函数

a = 10


def func4(n: int):
    print(n + n - 1)


func4(a)


def func5(x):
    print(x)
    x(111)


func5(func4)
func5(lambda x: x*2)

函数作为参数的应用：sort函数
列表.sort(key=None, reverse=False)
参数key - 要求是一个带有一个参数，并且返回值是比较对象。这儿的参数指向的是列表中的元素。确定按照元素的什么值进行排序

list1 = [1, 23, 9, 90]
list1.sort(reverse=True)
print(list1)

all_students = [
    {'name': '张三', 'age': 19, 'score': 90},
    {'name': 'stu1', 'age': 30, 'score': 89},
    {'name': '李四', 'age': 12, 'score': 50},
    {'name': '小花', 'age': 59, 'score': 60}
]


# 这儿的item是需要排序的列表的元素
# def func(item):
#     return item['score']
#
#
# all_students.sort(key=func, reverse=True)

all_students.sort(key=lambda item: item['score'])   # 按成绩从小到大排序
all_students.sort(key=lambda item: item['age'], reverse=True)  # 按年龄从大到小排序
print(all_students)

练习：按学生的平均分从小到大排序

all_students = [
    {'name': '张三', 'age': 19, 'score': {'c': 78, 'm': 90, 'e': 40}},
    {'name': 'stu1', 'age': 30, 'score': {'c': 58, 'm': 50, 'e': 46}},
    {'name': '李四', 'age': 12, 'score': {'c': 99, 'm': 95, 'e': 80}},
    {'name': '小花', 'age': 59, 'score': {'c': 53, 'm': 88, 'e': 52}}
]

all_students.sort(key=lambda x: (x['score']['c'] + x['score']['m'] + x['score']['m'])/len(x['score']))
print(all_students)

#  =============排序原理(了解)=============
# def yt_sorted(iterable, key=None, reverse=False):
#     list1 = list(iterable)
#     if key:
#         for x in range(len(iterable) - 1):
#             for y in range(x + 1, len(iterable)):
#                 item1 = list1[x]
#                 item2 = list1[y]
#                 if key(item1) > key(item2):
#                     list1[x], list1[y] = list1[y], list1[x]
#     else:
#         # 快速排序
#         for x in range(len(iterable) - 1):
#             for y in range(x + 1, len(iterable)):
#                 if list1[y] < list1[x]:
#                     list1[x], list1[y] = list1[y], list1[x]
#     if not reverse:
#         # 从小到大
#         return list1
#
#     else:
#         # 从大到小
#         return list1[::-1]
#
#
# print(yt_sorted([1, 20, 9, 10]))
# # print(sorted(all_student, key=lambda x: x['age']))
# print(yt_sorted(all_student, key=lambda x: x['age'], reverse=True))

4.变量作为函数的返回值

函数1作为函数2的返回值 - 函数2是返回值高阶函数

def operation(char):
    if char == '+':
        def func1(*nums):
            return sum(nums)
        # 将函数作为函数的返回值
        return func1
    elif char == '-':
        def func2(*nums):
            # 如果没有传参
            if not nums:
                return 0
            sum1 = nums[0]
            for index in range(1, len(nums)):
                sum1 -= nums[index]
            return sum1
        return func2


print(operation('+')(1, 2, 3, 4))
print(operation('-')(10, 3, 4))