零基础学习python第十课笔记

匿名函数lambda

list_2 = [1, 2, 5, 6, 7, 9]
def apple(x):    #定义函数

    return x > 5  #返回值

num_1 = list(filter(apple, list1))#filter 过滤筛选，用列表查看数据

print(num_1)  #打印结果



list_1 = [i for i in range(10)] #for循环生成列表
num = list(filter(lambda x:x>5,list_1)) #匿名函数,和定义函数不一样的是，它需要先去传值。
print(num) #打印结果
[6, 7, 9]
[6, 7, 8, 9]

语法规则

lambda 参数:表达式
例
num = lambda x, y: x+y  # x,y是参数，x+y是表达式
print(s(1, 2))  # 打印1(x)+2(y)
3			# 打印结果

# 其运行结果可以用变量接收

# lambda是不可迭代的

运用场景

简单函数：简单的函数， 可以不使用def定义一个函数，使用匿名函数即可

函数调用：类似 filter， map 等函数里面，可以使用匿名函数使用

函数作用域

外部不能访问函数内部变量

def func(): #定义函数

    x = 1  # 内部变量

    return x # 返回值

print(x)  #打印
报错结果：NameError: name 'x' is not defined (NameError：名称“ x”未定义)
    
    # 这里是指函数内部的变量不能直接被函数外部直接访问。

函数里面不能修改函数外部变量

def func(): # 定义函数
    
    a = 3   # 内部变量
    
    print(f'函数内部{a}') # f''声明是作用
    
func()  # 调用函数

print(a) # 打印

打印结果
3

函数里面和函数外部变量名相同.id不同

a = ['1'] # 函数外部变量a

print(id(a)) # 函数外部变量a打印id地址

def func():  # 定义函数
    
    a = ['1']   # 函数外部变量a

    print(id(a)) # 函数内部变量a打印id地址

func() # 调用函数

打印结果
2816860312072
2816860312584

全局变量global

a = [1]     # 外部变量a

def func():  # 定义函数
    
    global a # 这里是申明a是全局变量，表示变量a，函数外部和函数内部都可以相互被调用。
    
    a = [5]    # 内部变量a
    
    print(a) # 打印内部变量a
   
    return a #返回值

def apple(): # 定义函数
    
    a = 1  # 内部函数变量a
    
    print(a)# 调用函数
    
    return a # 返回值

func() # 调用函数

apple() # 调用函数

print(a) # 打印函数外部变量


打印结果
[5]
1    
[5] 

局部变量nonlocal

def func(): # 定义函数
    
    x = 1  # 变量 x
    
    def demo(): # 嵌套定义函数
        
        nonlocal x  # 申明局部变量，不声明报错

        x = x +1 # 嵌套定义函数 变量x 
        
        print(x)  # 打印嵌套变量
    
    demo() #调用嵌套定义函数
    
    print(x) # 打印定义函数变量x

func() # 调用定义函数


打印结果
1     
2     



# 嵌套定义函数可以访问定义函数，但不能改变它，如果需要改变要用nonlocal

闭包

嵌套函数------内嵌函数

案例1
def func(): # 定义函数
    
    a = 1  # 变量a
    
    print(a)  # 打印函数变量a
    
    def demo(a): # 嵌套定义函数
        
        print(a) # 打印变量a
        
	demo() # 调用函数
        
func()   # 调用函数


打印结果
1
1


案例2
def func(): # 定义函数
    
    def demo(): # 嵌套函数
        
        print(1) # 打印
        
	demo()       # 调用函数
    
func()  #调用函数

打印结果
1


案例3：
def func(): # 定义函数
    
    def demo(): # 嵌套函数
        
        print(1) # 打印
        
    return demo() # 返回值到定义函数func

func()  # 调用函数

打印结果
1

闭包-----外层函数调用里层函数

函数调用的特殊方法

1.闭包是函数里面的嵌套函数，外层函数返回里面层函数，这种称之为闭包

2.闭包是概念，不是函数类型，和递归类似，是一种特殊的函数调用

3.闭包可以得到外层函数的局部变量，是函数内部与外部沟通的桥梁
def func():  # 定义函数

    def demo(a):  # 定义内嵌函数

        print(a)  # 打印参数

    def apple():  # 定义内嵌函数

        print('苹果')  # 打印

    return demo, apple  # 返回

banana, orange = func()  # 拆包函数
 
banana(1)    # 调用函数
 
orange()     # 调用函数

递归函数

函数自己调用自己，根据条件限制次数

def func(x):  # 调用函数

    if x == 0:  # 条件判断

        return '啧啧啧'  # 条件判断成立时返回值


    return func(x - 1)  # 这里是指当x等多少时满足if条件，不满足就一直递减，直到满足

print(func(5))
啧啧啧

阶乘

def func(x):  # 调用函数

    if x == 1:  # 条件判断

        return x  # 条件判断成立时返回值


    return x * func(x - 1)  # 依次阶乘，满足if条件时停止
			5*func(5-1)
    			5*4 *func(4-1)
					5*4*3*func(3-2)
						5*4*3*2*func(2-1)
                			5*4*3*2*1



print(func(5)) # 打印

打印结果
120

回调函数

自身是一个函数，只是被传入另一个函数中，供其使用

回调函数不一定会被调用，是否调用以及有被传入。函数的内部逻辑决定

def func(callback, chrs): # 定义函数
    
    if chrs == 1:   # 条件判断
        callback() # 条件成立，即执行调用函数demo
        
    else:
        print('ok') # 上诉条件不成立时执行
        
def demo():
    print('play调用') # 打印
    
func(demo, 1)   # 调用函数 

打印结果
play调用