函数名闭包和迭代器

1.函数名：

函数名本质上就是函数的内存地址。

#函数名可以做为变量

def func1():
    print(666)
f1 = func1
f2 = f1
f2()

#函数名可以作为函数的参数

def func():
    print(666)
def func1():
    func()
def func2(x):
    x()
func2(func1)

#函数名可以当作函数的返回值

def wrapper():
    def inner():
        print('inner    ')
    return inner
ret = wrapper()
ret()

#函数名可以作为容器类类型的元素

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()

第一类对象：

#可在运行期创建

#可用作函数参数返回值

#可存入变量的实体

2.globals()   locals():

globals:返回全局变量的一个字典。

locals：返回当前位置的局部变量的字典

def func1():
    a = 2
    b = 3
    print(globals())
    print(locals())
    def inner():
        c = 5
        d = 6
        print(globals())
        print(locals())
    inner()
print(globals())
print(locals())
func1()

3.闭包：

内层函数对外层函数的变量（非全局变量）的引用，并返回这样形成了闭包。

def wrapper():
    name ='alex'
    def inner():
        print(name)
    print(inner.__closure__)
    inner()
    return inner
wrapper()

name = 'alex'
def wraaper(n):
    # n = 'alex'
    def inner():
        print(n)
    print(inner.__closure__)
    inner()
    return inner
wraaper(name)

闭包的作用：

当程序执行时，遇到了函数执行，他会在内存中开辟一个空间，局部名称空间，

如果这个函数内部形成了闭包，

那么他不会随着函数的结束而消失。

4.迭代器

可迭代对象：str、list、dict、tuple、set、range()

#对象内部含有__liter__方法就是可迭代对象。

#可迭代对象满足可迭代协议。

判断一个对象是否是可迭代对象：

第一个方法：

s1 = 'asdasdas'
dic = {'name':'alex'}
print('__iter__' in dir(s1))
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))

对象内部含有__iter__方法且含有__next__方法就是迭代器。

with open('list',encoding='uft-8')as f1:

　　print('__iter__ ' in dir(f1))

　　print('__next__' in dir(f1))

可迭代对象VS迭代器

可迭代对象不能取值，迭代器是可以取值的。

可迭代对象——————＞（转化成）迭代器

lis = [1,2,3]#可迭代对象
itel = lis.__iter__()
ite1 = iter(lis)

迭代器取值：next 一次，取一个值。

print(itel.__next__())

迭代器的好处：

1.可迭代对象不能取值，迭代器是可以取值的。

2.迭代器非常节省内存。

3.迭代器每次只会取一个值。

4.迭代器单向的，一条路走到头。