一，昨天的复习

"""
1.函数的概念
函数是实现某一特定功能的代码段的封装

2.函数的声明/定义
def 函数名(形参列表):
函数体

形参: 可以看成是声明在函数中的变量； 作用是将函数外部的数据传递到函数内部
函数体: 函数说明文档，实现函数功能的代码段，return语句(如果函数没有，就相当于是一个return None)

(重点!)声明函数的时候不会执行函数体

3.函数的调用
函数名(实参列表)

(重点！)函数的调用过程:
先回到函数声明的位置
传参(用实参给形参赋值) - 保证每个参数都有值
执行函数体
结束后，确定返回值 - 自然死亡(None) / 遇到return
返回函数调用的位置 - 这个时候函数调用表达式的值才是之前确定返回值

4.函数的参数
位置参数 和 关键字参数(有默认值才使用)
参数默认值
参数类型说明
不定长参数:形参前加* -> 将形参变成元祖， 形参前加** -> 将形参变成字典

5.函数的返回值 - 将函数内部传递到函数的外面
a.怎么确定函数的返回值
看执行函数的时候会不会遇到return，遇到了return 后面的值就是返回值。没有遇到返回值就是None

b.怎么获取函数的返回值
通过获取获取函数调用表达式的值来获取返回值
普通数据能做的时候返回值都可以做

注意: 每次调用函数，都会重新获取返回值
"""

def func(num: int):
    return [1, 2] * num


print(func(3))  # [1, 2, 1, 2, 1, 2]
result = func(2)
print(func(3)[0])  # 1
print(func(3)[:3])  # [1, 2, 1]
for x in func(2):
    print(x)
list1 = [func(3), 100]
list1[0].append(100)
print(list1)  # [[1, 2, 1, 2, 1, 2, 100], 100]

print('================')
def func1(x):
    print(x)


def func2(n):
    return  n * 2


def func3(x):
    # x = 3
    # return func2(4)  func2又是函数，所以去第二个函数
    return func2(x+1)


func1(func2(2))  # 4
print(func3(3))  # 8

二 Lambda（匿名函数）

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

与函数做下对比：
def 函数名(形参列表)：
函数体

2.匿名函数的声明
a.语法
变量名 = lambda 形参列表 :返回值
b.说明
变量名 - 相当于函数名
lambda - 声明匿名函数的关键字
形参列表 - 和普通函数的形参列表一样
: - 固定写法
返回值 - 就相当于普通函数中只有一条return语句的函数体，不用写return，：号后面有个隐形的return

3.匿名函数的调用
和普通函数一样
"""

# 1.匿名函数的参数也可以设置默认值（不会有类型提示）
# 2.匿名函数不能通过添加:类型名来说明参数类型
func1 = lambda x, y=0: 100
print(func1(18, 20))  # 100 因为:号后面相当于一个return 直接返回:号后面的值

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


print(func1(18, 20))  # 100  和匿名函数一样的只是匿名比较简便

# 3.匿名函数可以设置不定长参数
func2 = lambda *nums: sum(nums)
print(func2(1, 2, 3, 4, 5))  # 15

func3 = lambda x: print(x)
print(func3(100))  # 100 和 None  因为print(print(x)) 就相当于None 所有函数都有返回值

三 scope(作用域)

"""
1.什么是变量的作用域
就是变量能够使用的范围

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

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

总结:当我们调用函数的时候系统会自动在栈区间专门为这个函数开辟一个独立的内容空间，
用来保存在函数中声明的变量(形参也是属于声明在函数中的变量)。
当函数调用结束后，这个栈区间会自动销毁 ---(函数调用过程是一个压栈的过程)
参数相当于函数的入口，返回值就是函数的出口
"""

# 1.全局变量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 会报错 因为num1是局部变量，不能在函数外面使用

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


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

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

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


func5()
print(aa)

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

bb = 111  # 全局变量
def func6():
    global bb  # 将bb变为全局变量
    bb = 222  # 没有global之前它是局部变量
    print('函数里:', bb)


func6()  # 222
print(bb)  # 222

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

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

    def func22():
         # abc = 333  如果打开就是 func11 123  func22 333
        print('func22', abc)
    func22()

func11()  # func11 123  func22 123
# func22()  # 会报错，因为第一个函数区域已经在上一步销毁了，但func22()可以再第一个函数的内部使用


def func11():
    abc = 123


    def func22():
        nonlocal abc  # 修改它上一步函数里的值
        abc = 333
        print('func22', abc)
    func22()
    print('func11', abc)
func11()  # func22 333  func11 333

list1 = []
for i in range(5):
    list1.append(lambda x: x*i)

print(list1[0](3))  # 12
# lambda x: x* i   x = 3 return 3*4
print(list1[3](3))  # 12
# lambda x: x* i   x = 3 return 3*4  因为函数在声明的时候不会调用函数
"""
12怎么来的 下面是执行过程
list1 = []
i = 0  list[lambda x: x*i]
i = 1  list[lambda x: x*i] list[lambda x: x*i]
i = 2  list[lambda x: x*i] list[lambda x: x*i] list[lambda x: x*i]
i = 3  list[lambda x: x*i] list[lambda x: x*i] list[lambda x: x*i] list[lambda x: x*i]
i = 4  list[lambda x: x*i] list[lambda x: x*i] list[lambda x: x*i] list[lambda x: x*i] list[lambda x: x*i]
"""


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

三 Function Variable函数作为变量

"""
python中声明函数其实就是声明一个类型是function的变量，函数名就是变量名
"""
"""
函数名 -- 类型是function的变量
函数名() -- 调用函数并且获取函数返回值
普通变量能做的事情函数变量都能做!
1.给别的变量辅助
"""

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

# 声明一个列表变量func1
def func1():
    return  10

# 使用列表变量给另外一个变量list2赋值，
list2 = list1
# 赋值后list2就可以当列表来使用

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

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

# 普通变量
a = 10
nums = [a, 100, 100]
print(nums)
print(nums[0] - 10)

# 函数变量
def func3(x):
    print('abc', x)
    return 10


list3 = [func3, func3(10), 100]
print(list3)  # [<function func3 at 0x01E15228>, 10, 100]
print(list3[0](1))

"""
3.变量作为函数的实参
函数1作为函数2的实参 -- 函数2就是一个高阶函数
"""

a = 10


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


func4(a)  # 19

def func5(x):
    print(x)


func5(func4)  # <function func4 at 0x00535270>

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

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

all_student = [
    {'name': '张三', 'age': 19, 'score': 90},
    {'name': 'stu1', 'age': 30, 'score': 89},
    {'name': 'xiaoming', 'age': 12, 'score': 87},
    {'name': '李四', 'age': 29, 'score': 59},
]
def func(item):  # 必须要有参数 这儿的item是需要排序的列表的元素
    return item['age']

all_student.sort(key= func)
print(all_student)  # 年龄从小到大排序了

# 也可以用匿名函数
all_student.sort(key=lambda item: item['score'])  # 按成绩从小到大排序  item是指需要排序的列表的元素
print(all_student)
all_student.sort(key=lambda item: item['age'], reverse=True)  # 按年龄从大到小排序
print(all_student)

tuple1 =(
    (10, 20),
    (30, 90),
    (5, 80)
)
new_tuple = sorted(tuple1,key=lambda item: sum(item))
print(new_tuple)  # 小到大排序了 [(10, 20), (5, 80), (30, 90)]

练习:平均分从大到小排序

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': '李四', '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)

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

def operation(char):
    if char == '+':
        def func1(*nums):
            return sum(nums)
        # 将函数作为函数的返回值
        return func1
    elif char == '-':
        def func1(*nums):
            # 如果没有传参
            if not nums:
                return 0
            sum1 = nums[0]  # 要让它有个数才能减，所以下面遍历也要少一位从1开始，而不是0
            for index in range(1, len(nums)):  # 通过下标遍历的range
                sum1 -= nums[index]
            return sum1
        return func1()


print(operation('+'))  # <function operation.<locals>.func1 at 0x02175390>
print(operation('+')(1, 2, 3, 4))  # 10