第十节课

第十节课，函数进阶 讲课老师：风陨老师

2021/4/14

一、匿名函数

1、lambda 即不再使用def语句这样标准的形式定义一个函数

列：
list1 = [1, 2, 3, 4, 5, 6 ]

def anonymous(x):       #定义函数

    return x > 3       #返回条件


a = list(filter(anonymous, list1))    #筛选后赋值


print(a)                           结果为[4, 5, 6]                              

                                  #打印筛选后的list1

# 运用匿名函数lambda   

print(list(filter(lambda x:x>3, list1)))  
                                   结果为[4, 5, 6]

语法规则：lambda参数：表达式 结果可以变量接收
b = (list(filter(lambda x:x>3, list1)))
print(b)                           结果为[4, 5, 6]

应用场景：
简化函数    ：不再使用def语句这样标准的形式定义一个函数
函数内部调用 ：filter ，map，等都可以使用 匿名函数lambda

二、函数的作用域

1、外部不能访问内部变量

a = 3


def func():
	a = 1
print(a)                 结果为3	
	return a             内部的函数变量没有被打印


func()                        

2、函数内部可以反问函数外部的变量

a = 3


def func():
	print(a)         结果为3	  
	                 函数外部的变量被打印
	
func()

3、函数内部不能修改函数外部的变量

a = 3


def func():
    a = 1
	print(a)         结果为1	  
	                 内部重新赋值后
	
func()
print(a)             结果为3
                     内部重新赋值后，外部没有发生改变

4、函数内部和外部变量名相同，但是ID不同

a = 3


def func():
    a = 5
    print(id(a))                       140710779911360


func()
print(id(a))                           140710779911296

三、全局变量与局部变量

1、global 全局变量：实现改变函数外部的变量

a = 3


def func():
    global a  # 声明a为全局变量
    a = 1
    print(a)               结果为1

    return a


func()
print(a)                   结果为1




def func():
    global a 
    a = 1


    return a


def dome():
    #global a 			#内部在次声明则能改变      
    a = 2

    return a


func()
dome()
print(a)              结果都是1

2、nonlocal 局部变量：

def func():
	a = 1
	def dome():      #函数嵌套
		
		a = a+1      #不可改变
		print(a)	 #结果报错
	
	
	dome()


func()

nonlocal 局部变量：
def func():			 #定义函数
	a = 1
	def dome():      #函数嵌套
		nonlocal a   #声明a为局部变量
		a = a+1      #可改变
		print(a)	 #结果为2
	
	
	dome()			 #调用内部函数


func()               #调用函数

四、闭包与递归Closure and recursion

1、Closure 闭包 外层函数调用内层函数 函数调用的特殊方法

(1)、闭包
def dome():
    def func(a):
        print(a)         #结果被打印 为2
    
    return func          #不加括号就是闭包
    
    

  b = dome()
  b(2)	


    
(2)、嵌套函数 内嵌函数
def dome():
    def func():
        print(1)

    return func()           #加括号就是内嵌函数


dome()


(3)、闭包升级版
def dome():
    def func(a):
        print(a)        
    
    def good():
        print('老师讲很好')
        
    return func, good          
    
    

func, good = dome()
func(1)

good()


小结：
①.闭包是函数里面的嵌套函数，外层函数返回里面层函数，这种称之为闭包
  闭包调用时不加括号

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

③.闭包可以得到外层函数的局部变量，实现内外层沟通

2、recursion 递归 函数本身调用本身 根据条件限制次数

def func(a):
    """
    传值为5执行5次
    第一次a = 5不满足条件a =1 继续执行
    5*func(5-1)
    第二次a = 4不满足条件a = 1继续执行
    5*4*func(4-1)
    第三次a = 3不满足条件a = 1继续执行
    5*4*3*func(3-1
    第四次a = 2 不满足条件a = 1继续执行
    5*4*3*2*func(2-1)
    第五次a = 1 满足条件  a = 1传值1
    5*4*3*2*1
    结果为120

    :param a: 参数
    :return: 返回值
    """
    
    if a == 1:
        return a

    return a*func(a - 1)


print(func(5))                            结果为120

五、Callback 回调函数

def func(returns, z):
    if z == 1:
        returns()				#demo被调用
    else:
        print('ok')


def dome():
    print('你被调用了')


func(dome, 1)					#调用加括号

小结;
1、自身是一个函数，只是被传入另一个函数中，供其使用
2、回调函数有没有会被调用，是否被调用以及有没有被传入，由函数内部逻辑决定

                                                  The  end