01-05function

一：匿名函数

1.什么是匿名函数

匿名函数还是函数，只是声明的格式和普通函数不一样。只适用于函数功能比较简单的函数。
def 函数名（形参列表）：
函数体

2.匿名函数的声明

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

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

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

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

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

func2 = lambda *y: sum(y)
func2(10,20)
func3 = lambda *y: print(y)
print(func3(100))    #None
print(print('1'))   # 1 ,None

二：变量作用域

1.什么是变量作用域

就是变量能够使用的范围

2.全局变量和局部变量

a.全局变量 - 没有声明在函数或者类中的变量都是全局变量
全局变量的作用域从声明开始，到整个文件结束
b.局部变量 - 声明在函数或者类中的变量就是局部变量
局部变量的作用域是从声明开始，到函数结束。
总结：当我们调用函数的时候，系统会自动在栈区间专门为这个函数开辟一块独立的内容空间， 用来保存在函数中声明的变量（形参也是属于声明在函数中的变量）。当函数调用结果后 这个栈区间会自动销毁。----（函数调用过程是一个压栈的过程）

1.全局变量1

a = 100  #变量a是全局变量
def func1():
    print(a)  # 全局变量在函数里也可以用。
func1()

变量a是全局变量 2.全局变量

for y in range(3):
    print(y)  # y也是全局变量
print('外面', y)

3. 局部变量

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

def func3(num1):
    print(num1)
func3(2)
print(num1)    # num1是函数中的局部变量，不能在函数外面使用

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

aa = 100
def func5():
    # 局部变量aa
    aa = 200
    print('函数里', aa)
func5()
print('函数外：', aa)  # 这里aa是100的全局变量

3.global - 在函数中声明一个全局变量

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

ss = 100
def func5():
    global ss  # 全局变量ss，重新赋值
    ss = 200  # ss的值是200
    print('函数里', ss)
func5()
print('函数外：', ss)

4.nonlocal - 想要在局部的局部中去修改局部变量的值

nonlocal 局部变量
局部变量 = 值

def fuc4():
    asd = 123
    print(asd)
    def fuc5():
        nonlocal asd
        asd = 333
        print(asd)
    fuc5()
fuc4()

5.练习

list1 = []
for i in range(5):
    list1.append(lambda x: x*i)  #for in结束后x=4.后面调用函数时是4*3
    #错误：list1里写入的是lambda x: x*0 ，lambda x: x*1 ， lambda x: x*2，……
    #正确：lambda没调用，是整体写入list1[lambda x: x*i……]。for in运行完，写入5次。
    #    最后i被赋值4保存.i = 4是一个全局变量
print(list1[0](3))   #12
#lambda x:x*i  x=3 i=4

print(list1[3](3))   #12
print(list1)
#print(list1())   #list1[]() 这才是调用函数正确方式
#print(list1(2))  #list1[]() 这才是调用函数正确方式
#<function <lambda> at 0x01E05348>
#  类型       对象          地址

三：函数就是一个类型是function的变量

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

1. 函数名 -- 类型是function的变量

2.函数名（） -- 调用函数并且获取函数的返回值

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

1.给别的变量赋值

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

def func1():   #声明一个函数变量func1
    print('=======')
    return 20
func1()
list2 = list1 #变量给变量赋值
func2 = func1 #使用函数变量给另一个变量赋值
#赋值后func2就可以当成函数来使用
func2()

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

a = 6
nums = [a,12,43]
print(nums)
print(nums[0] - 3)
def func3():
    print('哈哈哈')
    return 10
list2 = [func3, func3(),100]
print(list2)
#print(list2[0](1))   

3.变量作为函数的实参

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

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

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

all_student = [
    {'龙云':'洪江','age':32},
    {'龙云': '洪龙', 'age': 22},
{'龙云': '洪龙', 'age': 24},
]
# 这儿的m是需要排序的列表的元素
# def func3(m):
#     return m['age']
# all_student.sort(key=func3)    #年龄从小到大排
all_student.sort(key=lambda m:m['age'])   ##年龄从小到大排
all_student.sort(key=lambda m:m['age'], reverse=True)  ##年龄从大到小排
print(all_student)

tuple = 1,2,42,12,4
sorted(tuple)
tuple2 = (
    (23,54),
    (7,4),
    (12,89)
)
new_tuple = sorted(tuple2,key=lambda item:sum(item))

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]
            for index in range(1,len(nums)):
                sum1 -= nums[index]
            return  sum1
        return func1
print(operation('+')(1,4,2,3))