迭代器

1.函数名

　　一.函数名的运用

　　函数名是一个变量,但它是一个特殊的变量,与括号配合可以执行函数的变量

　　1.函数名的内存地址

def func():
    print("呵呵")

print(func)

结果:
<function func at 0x1101e4ea0>

　　2.函数名可以赋值给其他变量

def func():
    print("呵呵")


print(func())

a = func    #把函数当成一个变量赋值给另一个变量
a()          #函数调用 func()

　　3.函数名可以当作容器类的元素

def func1():
    print("呵呵")


def func2():
    print("呵呵")


def func3():
    print("呵呵")


def func4():
    print("呵呵")


lst = [func1, func2, func3]
for i in lst:
    i()

　　4.函数名可以当作函数的参数

def func():
    print("吃了吗")


def func2(fn):
    print("我是func2")
    fn()     #执行传递过来的fn
    print("我是func2")


func2(func)            #把函数func当成参数传递给func2的参数fn

　　5.函数名可以作为函数的返回值

def func_1():
    print("这里是函数1")

    def func_2():
        print("这里是函数2")

    print("这里是函数1")
    return func_2()


ret = func_1()   #执行函数1,函数1返回的是函数2,这时ret指向的就是上面函数2
ret()        #执行上面返回的函数
                

2.闭包

　　　什么就是闭包?闭包就是内层函数,对外层函数(非全局)的变量的引用.叫闭包

def func1():
        name = "alex"

        def func2():
                print(name) # 闭包

        func2()


func1()

结果:
alex

　　　我们可以使用__closure__来检测函数是否是闭包.使用函数名.__closure__返回cell就是闭包,返回None就不是闭包

def func1():
        name = "alex"

        def func2():
            print(name)   #闭包

        func2()
        print(func2.__closure__)  #(<cell at 0x0000019E0E3164C8: str object at 0x0000019E0E3A8148>,)



func1()

　　问题,如何在函数外边调用内部函数

def outer():
    name = "alex"

    # 内部函数
    def inner():
        print(name)

    return inner


ret = outer()            #访问外部函数,获取到内部函数的函数地址
ret()                #访问内部函数
                

那如果多层嵌套呢?很简单,只需要一层一层的往外返回就行了

def func1():
    def func2():
        def func3():
            print("嘿嘿")

        return func3

    return func2


func1()()()

好处:

　　保护变量

　　常驻内存

3.迭代器

# 对的
s = "abc"
for c in s:
    print(c)




# 错的
for i in 123:
    print(i)



结果:
Traceback (most recent call last):
  File "F:/py/lianxi.py", line 26, in <module>
    for i in 123:
TypeError: 'int' object is not iterable

　　注意看报错信息中有这样一句话:int object is not iterable 翻译就是整数类对象是不可迭代的iterable表示迭代的,表示可迭代协议.可通过dir函数查看类中定义好的所有方法

s = "红红火火恍恍惚惚"
print(dir(s))         #可以打印对象中的方法和函数
print(dir(str))        #也可以打印类中声明的方法和函数

　　通过dir看所有方法中有__iter__函数,这些都还可以进行for循环

　　还可以通过isinstence()函数来查看一个对象是什么类型的

l = [1, 2, 3]
l_iter = l.__iter__()
from collections import Iterable
from collections import Iterator

print(isinstance(l, Iterable))
print(isinstance(l, Iterator))
print(isinstance(l_iter, Iterator))
print(isinstance(l_iter, Iterable))

　　如果有__iter__函数的话,就是可迭代的,就可以获得相对应的迭代器,我们使用迭代器中的__next__()来获取

s = "北京欢迎你"
c = s.__iter__()     #获取迭代器
print(c.__next__())   #使用迭代器进行迭代. 获取一个元素   北
print(c.__next__())      #京
print(c.__next__())     #欢
print(c.__next__())     #迎
print(c.__next__())     #你
print(c.__next__())    #StopIteration

for循环的机制:

for i in range(5):
        print(i)

lst = [1,2,3,4,5]
it = lst.__iter__()
while 1:
    try:
        i = it.__next__()
    excpet  StopIteration:
            break

小总结:

　　Iterable:可迭代对象.内部包含__iter__()函数

　　Iterator:迭代器.内部包含__iter__()同时包含__next__().

　　迭代器的特点:

　　　　1.节省内存

　　　　2.惰性机制

　　　　3.只能向前,(像时间)