day11笔记

locals 和 globals (了解)

locals 获取当前作用域中的所有内容

locals 如果在函数外,调用locals(),获取的是打印之前的所有变量,返回字典,全局空间作用域
locals 如果在函数内,调用locals(),获取的是调用之前的所有变量,返回字典,局部空间作用域

# 例子1
"""
a = 1
b = 2
res = locals()
c = 3
print(res)
d = 4
"""

# 例子2
"""
a = 1
def func():
	b = 2
	res = locals()
	c = 3
	print(res)
	d = 4
func()
"""

globals 获取全局作用域的所有内容

globals 如果在函数外,调用globals(),获取的是打印之前的所有变量,返回字典,全局空间作用域
globals 如果在函数内,调用globals(),获取的是调用之前的所有变量,返回字典,全局空间作用域

# 例子3
"""
a = 5
b = 6
res = globals()
c = 7
print(res)

"""
# 例子4
a =10
def func():
	b = 11
	c = 12
	res = globals()
	d= 13
	print(res)
ff = 30
func()
zz = 50


# ### globals 返回的是系统的字典

# 1. 正常方式定义变量
zhangsan = "112233"

# 2. 通过系统的全局字典添加键值对,可以动态创建全局变量
dic = globals()
print(dic)
# 传递字符串,创建一个变量
k = "wangwen"
dic[k] = "英俊潇洒的人"
print(wangwen)

# 3.批量创建全局变量,在函数中
def func():
	dic = globals()
	for i in range(1,6):
		dic["p%d" % (i)] = i

func()
print(p1)
print(p2)
print(p3)
print(p4)
print(p5)

函数的嵌套

函数的嵌套
嵌套在函数的外边叫做外函数
嵌套在函数的里面叫做内函数

def outer():
	# inner() error
	def inner():
		print("我是inner 函数")
	
	inner()
	
outer()	

(1)内部函数可以直接在函数外部调用么 不可以!
(2)调用外部函数后,内部函数可以在函数外部调用吗 不可以!
(3)内部函数可以在函数内部调用吗 可以
(4)内部函数在函数内部调用时,是否有先后顺序 有(必须先定义在调用)

最外层是outer , 中间层是inner , 最里层是smaller ,调用smaller ,执行里面的代码


def outer():
	
	def inner():
		
		def smaller():
			
			print(id)
			print("我是smaller函数")
		smaller()
	inner()
outer()	

LEGB 原则 (即就近找变量的原则)

找寻变量的调用顺序采用LEGB原则(即就近原则)
"""
B —— Builtin(Python)；Python内置模块的命名空间      (内建作用域)
G —— Global(module)； 函数外部所在的命名空间        (全局作用域)
E —— Enclosing function locals；外部嵌套函数的作用域(嵌套作用域)
L —— Local(function)；当前函数内的作用域            (局部作用域)
依据就近原则,从下往上 从里向外 依次寻找
"""

nonlocal 关键字 用来修改[局部变量]

nonlocal 遵循 LEGB
(1) nonlocal 专门用来修改当前作用域上一级的局部变量
(2) 如果上一级找不到,那么继续向上寻找
(3) 全都找不到,直接报错.

(1) nonlocal 专门用来修改当前作用域上一级的局部变量

def outer():
	a = 10
	def inner():
		nonlocal a
		a = 20
		
	inner()
	print(a)
outer()

(2)如果上一级找不到,那么继续向上寻找

"""nonlocal 只能修改局部变量"""
def outer():
	a = 41
	def inner():
		
		def smaller():
			nonlocal a
			a = 42
			print(a)
		smaller()
		print(a) # 41 or 42?
	inner()
	print(a)
	
outer()

(3) 全都找不到,直接报错.

a = 41
def outer():

	def inner():
		
		def smaller():
			nonlocal a
			a = 42
			print(a)
		smaller()
		print(a) # 41 or 42?
	inner()
	print(a)
	
outer()

(4) 不使用nonlocal 是否可以修改局部变量呢?

def outer():
	lst = [1,2,42]
	def inner():
		lst[-1] = 52
	inner()
	print(lst)
outer()

闭包函数

闭包函数:
内函数使用了外函数的局部变量
外函数将内函数返回出来的过程,叫做闭包
里面的内函数叫做闭包函数

(1) 闭包函数用法

def wz_family():
	father = "王健林"
	def wzj_hobby():
		print("先定一个小目标,比如赚他一个亿,这是爸爸{}说的".format(father))
	return wzj_hobby
	
# res = wzj_hobby <=> res()  = wzj_hobby()
res = wz_family()
print(res)
res()

(2) 升级

def weifuqiang_family():
	father = "马云"
	jiejie = "马蓉"
	meimei = "马诺"
	money = 1000
	
	def jiejie_hobby():
		nonlocal money
		money -= 700
		print("爱包包,爱手表,爱经纪人,把家里的钱都败光了,还剩下%s元" % (money))

	def meimei_hobby():
		nonlocal money
		money -= 200
		print("我宁愿在宝马里面哭,在不愿意在自行车上面撒欢,家里的钱还剩下%s元" % (money))

	def big_master():
		return [jiejie_hobby,meimei_hobby]


	return big_master
func = weifuqiang_family()
print(func)
lst = func()
# [<function weifuqiang_family.<locals>.jiejie_hobby at 0x000001DFB2F037B8>, <function weifuqiang_family.<locals>.meimei_hobby at 0x000001DFB2F03840>]
print(lst)

# 获取姐姐这个函数
jiejie = lst[0]
# 获取妹妹这个函数
meimei = lst[1]
jiejie()
meimei()

# ### 获取闭包函数使用的变量  __closure__ , cell_contents(了解)
tup = func.__closure__
print(tup)
# cell_contents 功能: 获取单元格对象里面的内容
jiejie = tup[0].cell_contents
meimei = tup[1].cell_contents
print(jiejie)
jiejie()
meimei()

闭包的特点

"""
内函数使用了外函数的局部变量,该局部变量与内函数发生绑定,延长该变量的生命周期
"""

# 函数的定义处
def outer(val):
	def inner(num):
		return num + val
	return inner
	
# 函数的调用处
func = outer(5)
res = func(4)
print(res) 

"""
代码解析:
1.实参5  和 形参val 一一对应,进行接收 val = 5
因为内函数inner 和 val 进行绑定, 延长了val变量的生命周期,不释放

func = outer(5)  < == >  func = inner

2.实参4  和 形参num 一一对应,进行接收 num = 4
return num + val  < == > 4 + 5 = 9 
res = func(4)  <==> return 9
res = 9
"""



# ### 闭包的意义
"""
闭包可以优先使用外函数的局部变量
局部变量在函数外部不能被直接使用
对局部变量实现了保护的作用,外部无法访问;
"""
# 模拟鼠标点击操作

# 方法一
click_num = 0
def click_func():
	global click_num
	click_num += 1
	print(click_num)

click_func() # 1
click_func() # 2
click_func() # 3
click_num = 100
click_func()

# 方法二
def outer():
	click_num = 0
	def inner():
		nonlocal click_num
		click_num += 1
		print(click_num)
		
	return inner
	
# click_func = inner
# click_func = outer()
# click_func()
# click_func()
# click_func()
# click_num = 100
# click_func()

outer()()
outer()()
outer()()

匿名函数 (lambda 表达式)

"""用一句话来表达只有返回值的函数 , 特点: 简洁 , 高效 ,方便"""
"""
语法结构:
	lambda 参数 : 返回值
"""

# (1) 无参的lambda 表达式
def func():
	return "我是个诗人"

# 改写lambda 
func = lambda  : "我是个诗人"
res =   func()
print(res)

# (2) 有参的lambda 表达式
def func(n):
	return type(n)
	
func = lambda n : type(n)
res = func(18)
print(res)

# (3) 带有判断条件的lambda 表达式
def func(n):
	if n % 2 == 0:
		return "偶数"
	else:
		return "奇数"


# ### 三目(元)运算符
"""
真值 if 条件表达式 else 假值
如果条件表达式成立,为真,返回真值'
如果条件表达式不成立,为假,返回假值
"""
n = 20
res = "偶数" if n % 2 == 0 else "奇数"
print(res)

# 改写lambda 
func = lambda n : "偶数" if n % 2 == 0 else "奇数"
res = func(21)
print(res)


# 练习: 比较两个数当中的最大值进行返回
def func(x,y):
	if x>y:
		return x
	else:
		return y


func = lambda x,y : x if x>y else y
res = func(2,-100)
print(res)