day10Function

            lambda  匿名函数

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

2.匿名函数: - 还是函数，只是声明的格式和普通函数不一样 ；只能适用于简单的函数

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

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

匿名函数和普通函数调用一样：函数名（实参列表） 也支持位置参数，关键字参数，参数默认值，不定长参数
匿名函数不能通过添加：类型名来说明参数类型

位置参数 和 关键字参数 参数默认值

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

不定长参数

func2 = lambda *nums: sum(nums)
print(func2(1,2,3,5,8))


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

def func3(x):
    # x = 100
    return print(x)  # 100

print(func3(100))

# 100

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

1.什么是作用域
作为变量使用的范围

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

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

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

变量a就是全局变量

a = 100
print(a)

1. 全局变量
   这的y也是全局变量

for y in range(3):
    print(y)
print('外面：',y)

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

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

def func3(num1):
    print(num1)
func3(10)

print(num1) 局部变量不能再函数外面使用

函数中的nums，max1和item都是局部变量

def func4(*nums):
    max1 = nums[0]
    for item in nums:
        if item > max1:
            max1 = item
    print(max1)
    return 10
# func4(1,2,3,85,6,4,22)
print(func4(1,2,3,85,6,4,22))
# print(item)

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

3. global关键字
   在函数中说明一个变量是全局变量
   global 变量名
   变量名 = 值

注意：只能在函数中使用

bb = 111

def func4():
    global bb   # 在函数中声明一个全局变量
    bb = 222
    print(bb)
func4()
print(bb)

4. nonlocal
   想要在局部中的局部中 修改 局部变量的值 (一般不用)
   nonlocal 局部变量名
   局部变量名 = 值

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

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

    print('func11',abc)

func11()
# print(func11())

list1 = []
for i in range(5):
    list1.append(lambda x:x*i)
# print(list1)
print(list1[0](3))  #  12  i = 4
print(list1[3](3))   #  12

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

4.变量作为函数的返回值
函数1作为函数2的返回值 - 函数2是返回值高阶函数

def operation(char):
    # char = '-'
    if char == '+':
        def func1(*nums):
            return sum(nums)
        # 将函数作为函数的返回值
        return func1
    elif char == '-':
        def func2(*nums):
            # (10, 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('+')(1, 2, 3, 4))
print(operation('-')(10, 3, 4))

========排序原理===========

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))