====== 匿名函数 ======

1.什么是匿名函数

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

2.匿名函数的声明

a.语法

变量名 = lambda 形参列表：返回值

b.说明

变量名 —— 相当于函数名

lambda —— 声明匿名函数的关键字

形参列表 —— 和普通函数的形参列表一样

： —— 固定写法

返回值 —— 就相当于普通函数中只有一条return语句的函数体

3.匿名函数的调用

和普通函数一样

匿名函数的参数也可以设置默认值（不会有类型提示）

匿名函数不通过添加，类型名来说明参数类型

func1 = lambda x, y : x+y
print(func1(10, 20))  # 30
# 匿名函数的参数设置默认值
func1 = lambda x, y=0 : x+y
print(func1(10))  # 10


# 普通函数方式
def func1(x, y) :
    return x+y


print(func1(10, 20))  # 30

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

func2 = lambda *nums: sum(nums)
print(func2(1, 2, 3, 4, 5))  # 15


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

# 展开
def func3(x) :
    return print(x)

====== 变量的作用域 ======

1.什么是变量的作用域

就是变量能够使用的范围

2.全局变量和局部变量

a.全局变量 —— 没有声明在函数或者类中的变量都是 全局变量

全局变量的作用域是从声明开始，到 整个文件 结束

b.局部变量 —— 声明在函数或者类中的变量就是 局部变量

局部变量的作用域是从声明开始，到 函数 结束

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

a.全局变量

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

print('外面：', a)

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

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

b.全局变量

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

print('外面：', y)


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

func2()

3.局部变量

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

# num1是局部变量
def func3(num1) :
    print(num1)
func3(10)  # 10
# print(num1)  # num1是局部变量，不能再函数外面使用，提示没有被定义NameError: name 'num1' is not defined

def func4(*nums) :
    # nums =
    max1 = nums[0]
    for item in nums :
        if item > max1 :
            max1 = item
    print(max1)


func4(1, 89, 9, 887, 0)  # 887
# print(item)  # NameError: name 'item' is not defined

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

# 全局变量
aa = 100

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


func5()  # 函数里： 200

print('外部：', aa)  # 外部： 100

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

在函数中：

global 变量名

变量名 = 值

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

    global aaa
    aaa = 100
    print(aaa)    # 100

====== 函数作为变量 ======

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

a = 10
str1 = 'abc'
list1 = [1, 34, 'ahjs']
dict1 = {'a': 10, 'b': 100}
func1 = lambda x: x
def func2():
    print('asbc')


print(type(dict1), id(dict1))
print(type(func1), id(func1))
print(type(func2), id(func2))
print(dict1)
print(func1, func2)

函数名 —— 类型是function的变量

函数名（） —— 调用函数并且获取函数的返回值

普通变量能做的事情函数变量都能做！★

1.给别的变量赋值

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

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

a.使用列表变量给另外一个变量list2赋值

list2 = list1
# 赋值后list2就可以当成列表来用
print(list2[0])  # 1
print(list2[::-1])  # [3, 2, 1]
list2.append(100)
print(list2)  # [1, 2, 3, 100]

b.使用函数变量给另外一个变量func2赋值

func2 = func1
#赋值后func2就可以当成函数来使用
func2()  # 我是一个函数！
print(func2())  # 我是一个函数！ 10

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

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


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

list2 = [func3, func3(10), 100]  # [<function func3 at 0x0211BA50>, 10, 100]
print(list2)    # <function func3 at 0x0211BA50>
print(list2[0])    # abc 1
print(list2[0](1))  # 10

3.变量作为函数的实参

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

a = 10
def func4(n: int) :
    print(n + n - 1)

func4(a)  # 19

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

func5(func4)  # <function func4 at 0x0072BA98>  221
func5(lambda x: x*2)  # <function <lambda> at 0x0062BA50>

函数作为参数的应用：sort函数

列表.sort(key=None, reverse=False)

参数key —— 要求是一个带有一个参数，并且返回值是比较对象，这儿的参数指向的是列表中元素，确定按照元素的什么值进行排序

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

all_student = [
    {'name': '张三', 'age': 19, 'score': 90},
    {'name': 'stu1', 'age': 30, 'score': 79},
    {'name': 'xiaoming', 'age': 12, 'score': 87},
    {'name': 'stu22', 'age': 29, 'score': 99}
]


# 这儿的item是需要排序的列表的元素
# def func(item):
#     return item['score']
# all_student.sort(key=func, reverse=True)
all_student.sort(key=lambda item: item['score'])   # 按成绩从小到大排序
all_student.sort(key=lambda item: item['age'], reverse=True)   # 按年龄从大到小排序
print(all_student)


tuple1 = (
    (10, 20),
    (5, 80),
    (30, 90)
)
new_tuple = sorted(tuple1, key=lambda item: sum(item))
print(new_tuple)

print('=============')

练习: 按学生的平均分排序

all_student = [
    {'name': '张三', 'age': 19, 'score': {'c': 78, 'm': 90, 'e': 40}},
    {'name': 'stu1', 'age': 30, 'score': {'c': 89, 'm': 60, 'e': 98}},
    {'name': 'xiaoming', 'age': 12, 'score': {'c': 78, 'm': 67, 'e': 86}},
    {'name': 'stu22', 'age': 29, 'score': {'c': 34, 'm': 99, 'e': 50}}
]
def average(student):
    scores = student['score']
    sum1 = 0
    for key in scores:
        sum1 += scores[key]
    return sum1/3


all_student.sort(key=average)
print('~~~~~~~~~~~')
print(all_student)

=============排序原理(了解)=============

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) :
            # (10, 2, 3, 4)
            # 如果没有传参
            if not nums :
                return 0

            sum1 = nums[0]
            for index in range(1, len(nums)) :
                sum1 -= nums[index]
            return sum1

        return func2

print(operation('+'))  # 函数的地址 <function operation.<locals>.func1 at 0x01E6BAE0>
print(operation('+')(1, 2, 3, 4))  # 10
print(operation('-')(10, 3, 4))  # 3