day11总结-匿名函数、实参高阶函数及变量作用域

匿名函数

1.什么是匿名函数

没有函数名的函数就是匿名函数

2.语法

变量名 = lambda 形参列表：返回值 --根据实际情况，前面的'变量名='可以不要（并非省略）

3.说明

lambda：关键字，固定写法

形参列表：可以设置默认值，不可以通过'冒号+类型名'的方式来说明参数类型（因为和后面的冒号冲突），只能用默认值来设定参数类型，其他和普通函数的形参列表一样。

":" ：固定写法

返回值：相当于普通函数中return后面的语句，只能有一条语句（不能是带有return的语句），因此有多行代码的普通函数，匿名函数无法实现

def func(n1,n2):
    return n1+n2

lambda n1,n2=0:n1+n2
lambda:print('hello world')   #参数可以为空

4.调用

变量名（实参列表）：前面的变量名不一定要指定，可以是通过任何方式获取到的类型是function的值

在声明时也可以同时调用：

(lambda n:n+1)(3)

Python中，声明函数可以是看成声明类型名为function的变量；匿名函数可以看成是function类型的数据（类似100是int类型的数据）

a = lambda:print('hello world')    #a为变量，可以出现在列表，字典以及各种语句中
print(type(a))    #<class 'function'>
b = ['abc',1,2,'c',a]
print(b[-1])    #结果为<function <lambda> at 0x00665228>

c = ['abc',1,2,lambda x,y:x+y]
print(c[-1](10,20))    #30

d = (lambda n:n+1)(3)
print(d)    #4

函数作为变量

python中，声明函数其实就是在声明一个类型是function的变量，函数名就是变量名。所以普通变量能做的事，函数都能做。

如下函数，func1是类型为function的变量，它里面存的数据是一个函数

def func1(n):
    return n*n
#也可以写为：
func1 = lambda n:n*n

print(func1,type(func1),func1(10))

普通变量能做的函数都能做：

给其他变量赋值

a = lambda n:n*2
b = a

可以作为列表，元祖的元素，字典的value，不能作为key及集合的元素，因为function可变

def a(n):
    return n*2
b = [ 1,2,3,a]
print(b[-1](3))  #6

作为其他函数的实参（实参高阶函数或闭包）

def x(y):
    y('abc')

x(print)    #结果显示：'abc'（print打印出来的，函数调用值为None）

实参高阶函数应用：sort方法的使用

列表.sort(key)：key需要传一个类型是function的值（函数），要求这个函数有一个参数和一个返回值；

参数指向的是列表中的每个元素，返回值是排序的时候的比较对象。

nums = ['19','90','78','9','87']
nums.sort()
print(nums)     #['19', '78', '87', '9', '90']，按字符串大小排序
#若要按数字大小比较排序：
print(nums.sort(key=lambda x:int(x))) #['9', '19', '78', '87', '90']

类似的还有max()，min()。

nums = ['14', '40', '73', '9', '85']


def fn1(x):
    return x[0]   # 返回值决定列表中的元素按什么进行排序


nums.sort(key=fn1)
print(nums)    # ['14', '40', '73', '85', '9']
nums.sort(key=lambda item: int(item))
print(nums)   # ['9', '14', '40', '73', '85']


students = [
    {'name': 'xiaoming', 'age': 23, 'score': 90},
    {'name': 'huahu', 'age': 30, 'score': 70},
    {'name': 'zhangsan', 'age': 19, 'score': 100},
]
students.sort(key=lambda item: item['age'])
print(students)

students.sort(key=lambda item: item['score'])
print(students)

students.sort(key=lambda item: item['name'][-1])
print(students)

print(max(['10', '30', '8'], key=lambda x: int(x)))
print(max(students, key=lambda x: x['score']))
"""
['14', '40', '73', '85', '9']
['9', '14', '40', '73', '85']
[{'name': 'zhangsan', 'age': 19, 'score': 100}, {'name': 'xiaoming', 'age': 23, 'score': 90}, {'name': 'huahu', 'age': 30, 'score': 70}]
[{'name': 'huahu', 'age': 30, 'score': 70}, {'name': 'xiaoming', 'age': 23, 'score': 90}, {'name': 'zhangsan', 'age': 19, 'score': 100}]
[{'name': 'xiaoming', 'age': 23, 'score': 90}, {'name': 'zhangsan', 'age': 19, 'score': 100}, {'name': 'huahu', 'age': 30, 'score': 70}]
30
{'name': 'zhangsan', 'age': 19, 'score': 100}
"""

# =================自定义sort函数(模拟系统的)-了解============
def yt_sort(list1, key=None, reverse=False):
    """"""

    length = len(list1)
    if reverse:
        # 降序排列
        for x in range(0, length-1):
            for y in range(x+1, length):
                if key:
                    if key(list1[y]) > key(list1[x]):
                        list1[x], list1[y] = list1[y], list1[x]
                else:
                    if list1[y] > list1[x]:
                        list1[x], list1[y] = list1[y], list1[x]

    else:

        for x in range(0, length-1):
            for y in range(x+1, length):
                if key:
                    if key(list1[y]) < key(list1[x]):
                        list1[x], list1[y] = list1[y], list1[x]
                else:
                    if list1[y] < list1[x]:
                        list1[x], list1[y] = list1[y], list1[x]



nums = ['1', '60', '27', '9']
yt_sort(nums, key=lambda x: x[-1])
print(nums)

nums = [1, 90, 89, 9]
yt_sort(nums, reverse=True)
print(nums)

作为函数的返回值

def oper(char):
    if char == '+':
        def zy_sum(*num):
            sum1 = 0
            for i in num:
                sum1 += i
            return sum1
        return zy_sum
    else:
        return None
    
print(oper('+')(1,2,3,4,5,6))    #21

思考

list1 = []
for i in range(4):
    list1.append(lambda x:x*i)
#求值
list1[0](3)
list1[1](3)
list1[2](3)    #结果都是9

注意：函数在声明时，函数体不会执行，直接跳过，直到被调用时，因此即使函数体有错误，如果不被调用则不会报错

作用域

作用域：变量的使用范围，分为全局变量和局部变量

全局变量

Python中除了在函数中或者类中声明的变量，都是全局变量。全局变量的作用域是从声明开始到文件结束的任何位置都可以使用

局部变量

在函数中声明的变量就是局部变量，从声明开始到函数结束都可以用

函数声明时的形参是局部变量

不能在函数中直接修改一个全局变量的值，其结果是在函数中重新声明一个新的变量

a = 10
def func():
    a = 22
    return a
print(a)     #10
print(func())   #22

global和nonlocal

global：若想要在一个函数中修改全局变量的值，或者想要在函数中声明一个全局变量，使用global

语法：

global 变量名1，变量名2，...

变量名1=值1

变量名2=值2

...

注意：在函数中声明全局变量时，不能在声明全局变量前又声明它为局部变量。声明全局变量后，之后在函数中调用的此变量都视为全局变量

a=1
def func():
    a = 111      #不能在声明全局变量前又声明为局部变量
    global a
    a = 11
    return a
print(a)    
print(func()) #直接报错

nonlocal：想要在局部的局部中修改一个局部变量的值，使用nonlocal

语法：

nonlocal 变量1，变量2，...