day11

day11
一.locals 和 globals
1.locals 获取当前作用域中的所有内容
如果在函数外,调用locals(),获取的是打印之前的所有变量,返回字典,全局空间作用域
如果在函数内,调用locals(),获取的是调用之前的所有变量,返回字典,局部空间作用域
a = 1
def func():
b = 2
e = 5
res = locals() ###这个locals在函数内,获取的是局部空间内之前的变量,这里返回{‘b’:2,‘e’:5}
print(res)
d = 4
func()
m = 1
res1 = locals()###这个locals在函数外,获取的是全局空间内打印打印之前的所有变量,返回字典,n=2不打印
print(res1)
n = 2
2.globals 获取全局作用域的所有内容
如果在函数外,调用globals(),获取的是打印之前的所有变量,返回字典,全局空间作用域
如果在函数内,调用globals(),获取的是调用之前的所有变量,返回字典,全局空间作用域

a =10
def func():
b = 11
c = 12
res = globals()###在函数内部,打印的是调用前的变量,a:10,func: ff:30
d= 13
print(res)
ff = 30
func()
pp = 11
res1 = globals() ###在函数外部,打印的是的打印之前的变量,print(res1)之后的不打印
print(res1)
zz = 50

globals 返回的是系统的字典

1. 正常方式定义变量
   a = “1231”
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,p2,p3,p4,p5)

二.函数的嵌套
函数的嵌套
嵌套在函数的外边叫做外函数
嵌套在函数的里面叫做内函数
(1)内部函数不可以直接在函数外部调用
(2)调用外部函数后,内部函数不可以在函数外部调用
(3)内部函数可以在函数内部调用
(4)内部函数在函数内部调用时,必须先定义在调用
遵循原则:
LEGB 原则 (即就近找变量的原则)
B —— Builtin(Python)；Python内置模块的命名空间 (内建作用域)
G —— Global(module)； 函数外部所在的命名空间 (全局作用域)
E —— Enclosing function locals；外部嵌套函数的作用域(嵌套作用域)
L —— Local(function)；当前函数内的作用域 (局部作用域)
依据就近原则,从下往上 从里向外 依次寻找,找不到报错

三. nonlocal 关键字 用来修改[局部变量]
nonlocal 遵循 LEGB
(1) nonlocal 专门用来修改当前作用域上一级的局部变量
(2) 如果上一级找不到,那么继续向上寻找
(3) 全都找不到,直接报错.
def outer():
a = 41
def inner():
a = 0
def smaller():
nonlocal a
a = 42
print(a)
smaller()
print(a)
inner()
print(a)
outer()
打印结果42,42,41
(4) 不使用nonlocal也可以可以修改局部变量
def outer():
lst = [1,2,42]
def inner():
lst[-1] = 52
inner()
print(lst)
outer()
四.闭包函数
闭包函数:
内函数使用了外函数的局部变量
外函数将内函数返回出来的过程,叫做闭包
里面的内函数叫做闭包函数
def weifuqiang_family():
father = “A”
jiejie = “B”
meimei = “C”
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()
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
闭包的意义:
闭包可以优先使用外函数的局部变量
局部变量在函数外部不能被直接使用
对局部变量实现了保护的作用,外部无法访问;
六. 匿名函数 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)