1，python中，名称空间分三种：
全局命名空间
局部命名空间（临时命名空间）
内置名称空间
2，作用域（两种）：
1，全局作用域 包含：全局名称空间 内置名称空间
2，局部作用域 包含：局部命名空间
2.1，取值顺序：
就近原则：局部名称空间 --> 全局名称空间 --> 内置名称空间 单向从小到大范围
2.2， 加载顺序：
内置名称空间 --> 全局名称空间（当程序执行时） -- > 局部名称空间（当函数调用的时候）
3，函数的嵌套：
def func1():
print(111)
def func2():
print(222)
func1()
print(333)
print(666)
func2()
print(555)
例子1
def func1():
print(222)
def func2():
print(333)
print(111)
func2()
print(666)
func1() # 执行结果：
222 111 333 666
例子2
4，global nonlocal
局部名称空间对全局名称空间的变量可以引用，但是不能改变。
count = 1
def func1():
count = 2
print(count)
func1()
count = 1
def func1():
# count = 3
count = count + 1 # local variable 'count' referenced before assignment
print(count)
func1()
报错
报错原因： 如果你在局部名称空间 对一个变量进行修改，那么解释器会认为你的这个变量在局部中已经定义了，但是对于上面的例题，局部中没有定义，所以他会报错，
global
1，在局部名称空间声明一个全局变量。
声明
2，在局部名称空间声明可以对全局变量进行修改。
count = 1
def func1():
global count
count = count + 1
print(count)
func1()
print(count)
修改
nonlocal
1，子函数对父函数的变量进行修改。
2，此变量不能是全局变量
3，在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，并且引用的哪层，从那层及以下此变量全部发生改变。
def func1():
count = 666
def inner():
print(count)
def func2():
nonlocal count
count += 1
print("func2",count)
func2()
print("inner",count)
inner()
print("funcl",count)
func1() # 运行结果：
666
func2 667
inner 667
funcl 667
global
5,函数的应用
1，函数名就是函数的内存地址。
def func():
pass
print(func) # <function func at 0x05958660>
2，函数名可以作为变量。
def func1():
print(666)
f1 = func1
f2 = f1
f2()
3，函数名可以作为函数的参数。
def func():
print(666)
def func1():
func()
def func2(x):
x()
func2(func1)
4，函数名可以当作函数的返回值。
def wraaper():
def inner():
print("inner")
return inner
ret = wraaper()
ret()
5，函数名可以当作为容器类类型的元素。
def func1():
print("in func1")
def func2():
print("in func2")
def func3():
print("in func3")
def func4():
print("in func4")
l1 = [func1,func2,func3,func4]
for i in l1:
i()
向上面的函数名这种，第一个类对象。
6，globals() locals()
1,globals() 返回全局变量的一个字典。
2,locals() 返回当前位置的局部变量的字典。
def funcl():
a = 2
b = 3
# print(globals())
# print(locals())
def inner():
c = 5
d = 6
print(globals())
print(locals())
inner()
print(globals())
print(locals())
funcl()
7，闭包
--内层函数对外层函数的变量（非全局变量）的引用，并返回。这样就形成了闭包。
1，迭代器的条件：
1，必须要有函数嵌套。
2，内层函数必须要引用外层函数中的变量（不能是全局变量）。
3，外层函数必须返回内部中的函数名（引用）。def wraaper():
n = 1
def inner():
nonlocal n
n += 1
return n
# inner()
return inner
f = wraaper()
print(f())
print(f())
闭包
2，闭包的作用：
当程序执行时，遇到了函数执行，他会在内存开辟一个空间，局部名称空间，
如果这个函数内部形成了闭包，
那么他就不会随着函数的结束而消失。
# 1，写装饰器的时候用。
# 2，写爬虫的时候用。 from urllib.request import urlopen def index():
url = "http://www.xiaohua100.cn/index.html"
def get():
return urlopen(url).read()
return get xiaohua = index() # get
content = xiaohua() # get()
content = xiaohua() # get()
print(content.decode('utf-8'))
作用
8，迭代器
1，可迭代对象
对象内部含有__iter__方法的就是可迭代对象。
可迭代对象满足可迭代协议。
2，判断是否是可迭代对象。
dic = {"name":"alex"}
print('__iter__' in dir(dic))
方法一
from collections import Iterable
from collections import Iterator
print(isinstance("alex",Iterable))
print(isinstance('alex',Iterator))
print(isinstance("alex",str))
方法二
3，可迭代对象 vs 迭代器
可迭代对象不能取值，迭代器是可以取值的。
可迭代对象 可以转化成迭代器。
lis = [1,2,3] # 可迭代对象
itet = lis.__iter__() #迭代器
itet = iter(lis) # 迭代器
print(itet)
可迭代器如何取值？
next一次，取值一次
1，可迭代对象不能取值，迭代器是可以取值的。
2，迭代器非常节省内存。
3，迭代器每次只会取一个值。
4，迭代器是单向的从上至下地取值，一条路走到头。
1，迭代器原理
1，将可迭代对象转化成迭代器。
2，调用__next__方法取值。
3，利用异常处理停止报错。
s1 = "asdfg"
iter1 = s1.__iter__()
while 1:
try:
print(iter1.__next__())
except StopIteration:
break
s1 = "asdfg" # l1 = [i for i in range(100)]
# print(11) ret = (i for i in range(10000))
print(ret.__next__())
print(ret.__next__())
print(ret.__next__())
9, 生成器
--就是自己python用代码写的迭代器，生成器的本质就是迭代器。
1，构建一个生成器的两种方式:
1,通过生成器函数。
2，生成器表达式。
生成器函数：
def func1(x):
x += 1
return x
func1(5) # 函数的执行命令，并且接受函数的返回值
print(func1(5))
函数
def func1(x):
x += 1
print(111)
print(111)
print(111)
yield x
x += 2
print(222)
yield "alex"
x += 3
g_obj = func1(5) # 生成器函数对象
# print(g_obj)
# print(g_obj.__next__())
print(g_obj.__next__())
生成器函数
一个 naxt 对应一个 yield
yield 将值返回给生成器对象 .__next__()
yield 和 return区别
return 结束函数，给函数的执行者返回值
yield 不会结束函数，一个next 对应一个yield，给生成器对.__next__()返回值。
生成器函数 和 迭代器 区别
1，自定制的区别
# li = [1,2,3,4,5]
# li.__iter__() def func1(x):
x += 1
yield x
x += 3
yield x
x += 5
yield x
g1 = func1(5)
print(g1.__next__())
print(g1.__next__())
print(g1.__next__())
区别1
2，内存级别的区别
迭代器是需要可迭代对象进行转化。可迭代对象非常占内存。
生成器直接创建，不需要转化，从本质就节省内存。
def func1():
for i in range(10000):
yield i g1 = func1()
for i in range(50):
print(g1.__next__()) # ————————————————————————
def func1():
print(1)
count = yield 6
print(count)
print(2)
count1 = yield 7
print(count1)
print(3)
yield 8 g = func1()
next(g)
g.send("alex")
# g.send("太白")
print(g.__next__())
区别二
send 与 naxt 区别
send与next一样，也是对生成器取值（执行一个yield）的方法。
send可以给上一个yield传值。
第一次取值永远都是next。
最后一个yield永远也得不到send传的值。
# 函数
def cloth1(n):
for i in range(n+1):
print("衣服%s号" % i)
cloth1(1000)
# --------------------------------
# 生成器函数
def cloth1(n):
for i in range(1,n+1):
yield ("衣服%s号" % i)
g = cloth1(1000)
for i in range(50):
print(g.__next__())
# for i in range(50):
# print(g.__next__())
函数 vs 生成器
列表推导式：
-- 一行代码几乎搞定你需要的任何的列表。
优点：一行解决，方便
缺点：容易着迷，不易排错，不能超过三次循环。
列表推导式不能解决所有列表问题，所以不要太刻意用。
循环模式 [变量（加工后的变量）for 变量 initerable]
l = [i for i in range(1,101)]
print(l) l2 = print(["python%s期" % i for i in range(1,11)]) print([i*i for i in range(1,11)])
循环模式
筛选模式 [变量（加工后的变量）in iterable if 条件]
l3 = [i for i in range(1,31) if i % 2 == 0]
print(l3) print([i for i in range(1,31) if i % 3 == 0]) print([i**2 for i in range(1,31) if i % 3 == 0]) names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
# 请选出名字中带两个e的 print([j for i in names for j in i if j.count("e") == 2])
筛选模式
生成器表达式： 将列表推导式的 [ ] 换成 ( ) 即可。
g = (i for i in range(100000))
print(g)
print(g.__next__())
print(g.__next__())
for i in range(20): # 循环取取值
print(g.__next__())
生成器表达式
mcase = {"a":10,"b":34}
mcase_frequency = {mcase[k]: k for k in mcase} # 将键值对反转
print(mcase_frequency)
元组表达式
squared = {x**2 for x in [1,-1,2]} # 将集合去重
print(squared)
集合表达式