命名空间

名称空间是存放变量名和赋值绑定关系的地方

名称空间共 3 种:

• locals: 是函数内的名称空间，包括局部变量和形参
• globals: 全局变量，函数定义所在模块的名称空间
• builtins: 内置模块的名称空间

不同变量的作用域不同是由这个变量所在的命名空间决定的
作用域范围：

• 全局变量：全局有效，全局存活
• 局部变量：局部有效，局部存活

查看作用域的方法：globals(), locals()
作用域的查找规则：LEGB

闭包

闭包：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层的作用域

def func():
    name = 'jack'

  def inner():
        print('函数变量:', name)

    return inner

f = func()

f()
# 返回结果: 函数变量：jack

生成器

列表生成式

# 将列表中的每一个值都进行自乘
# 可以通过列表生成式来完成
>>> a = list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a = [i*i for i in a]
>>> a
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 以上就是通过简单的列表生成式来实现的

生成器：
通过列表生成式，可以直接创建一个列表，但是受到内存限制，列表的容量是有限的。
列表元素通过某种算法，再循环中不断推算出后续的元素，这种一边循环一边计算的机制，称为生成器：generator

# 要创建一个 generator 很简单，就是将列表生成式中的 [] 改成 ()
>>> l = [i*i for i in range(10)]
>>> l
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x*x for x in range(10))
>>> g
<generator object <genexpr> at 0x7f77ffd6cdb0>

# 创建 l 和 g 的区别就是最外层的[] 和 (), l 是一个list，而 g 是 generator，可以直接打印获取 list 所有元素，但 generator 需要通过 next() 一个一个获取
>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
# 直到最后获取不到抛出 StopIteration 错误
# 但用上面 next(g) 获取太麻烦，可以通过 for 循环
>>> g = (x*x for x in range(10))
>>> for n in g:
...   print(n)
... 
0
1
4
9
16
25
36
49
64
81
# 而且这样也不会报错

著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数可由前两个数相加所得
斐波拉契数列通过列表生成式无法写出来，但是可以通过函数打印出来

def fin(max):
    n, a, b = 0, 0, 1
    
    while n < max:
        print b
        a, b = b, a+b
        
        n += 1
    return 'done'

data = fin(5)
print(data)
# 执行结果为
1
1
2
3
5

# 上面 fin 函数实际上是定义了斐波拉契数列的推算规则，可以从第一个元素推算出后续任意的元素
# 要讲上面函数变成 generator，只需要把 print b 改为 yield b
def fin(max):
    n, a, b = 0, 0, 1
    
    while n < max:
        # print b
        yield b
        a, b = b, a+b
        
        n += 1
    return 'done'

data = fin(5)
print(data)
# 执行结果：<generator object fib at 0x00000232F05DEF68>

# 这是函数中定义 generator 的一种方法，如果一个函数内包含 yield 字段，那么这个函数就不再是一个普通函数，而是一个 generator

# generator执行过程和函数是不同的，函数执行是顺序执行，需要 return语句或者最后一行语句返回，而 generator函数，则是每次调用 next() 的时候执行，遇到 yield语句返回，如没有next()，函数执行到 yield 是就停止不再继续执行了，再次被 next() 调用时从上次返回的 yield 语句继续执行下，在次遇到 yield 语句返回并停止

迭代器

• 可迭代对象
  可以直接作用于 for 循环的对象称为可迭代对象：Iterable
  可直接作用于 for 循环的数据类型有以下几类：
  一类是集合数据类型：list ,tuple, dict, set, str 等
  一类是 generator，包括生成器和带 yield 的generator functions
  可以使用 isinstance() 判断一个对象是否是 Iterable（可迭代）对象

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance((), Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance(123, Iterable)  # 整数就不是可迭代对象
False

而生成器不但可以作用于 for 循环，还可以被 next() 函数不断的调用并返回下一个值，直到最后抛出 Stoplteration 错误并返回

• 迭代器
  可以被 next() 函数调用并不断返回下一个值的对象称为 迭代器：Iterator
  可以用 isinstance()判断一个对象是否是 Iterator(迭代)对象：

>>> isinstance((i for i in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance('abc', Iterator)
False

# 生成器都是 Iterator(迭代器)对象，但 list，str, dict 虽然是 Iterable(可迭代对象), 但不是 Iterator(迭代器)

可以通过 iter() 函数把 Iterable 变成 Iterator

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

Python 中 Iterator 对象表示的是一个数据流，Iterator 对象可以被 next() 函数调用并不断返回下一个数据，直到没有数据抛出 StopIteration 错误，可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

• 总结

凡是可作用于 for 循环的对象都是 Iterable 类型
凡是可作用于 next() 函数的对象都是 Iterator 类型，它们表示一个惰性计算的序列
集合类型如 list，dict，str等都是 Iterable，但不是 Iterator, 但是可以通过 iter() 函数获得一个 Iterator 对象
python3 的 for 循环本质上就是通过不断调用 next() 函数实现的