迭代器

一.函数名的运用.

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

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 
fn = func_1()   # 执⾏函数1.  函数1返回的是函数2, 这时fn指向的就是上面函数2 
fn()                 # 执行上⾯面返回的函数

二. 闭包

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

闭包的作用

　　1.可以保护你的变量不受侵害.

　　2.可以让一个变量常驻内存.

def func1():    
    name = "alex"    
    def func2():        
        print(name)     # 闭包    
    func2() 
func1() 
    结果: 
        alex   　

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

def func1():
    name = "alex"
    def func2():
        print(name)     # 闭包    "alex"

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

func1()

   问题, 如何在函数外边调⽤内部函数呢? 

def outer():
    name = "alex"    # 内部函数
    def inner():
        print(name)
    return inner 
fn = outer()   # 访问外部函数, 获取到内部函数的函数地址 
fn()               # 访问内部函数 

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

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

关于爬⾍的代码: 

from urllib.request import urlopen 
def but():
 　　content=urlopen("http://www.xiaohua100.cn/index.html").read()    
 4　　　 def get_content():
        return content
    return get_content
fn = but()  # 这个时候就开始加载校花100的内容 # 后⾯面需要⽤用到这⾥里里⾯面的内容就不不需要在执⾏行行⾮非常耗时的⽹网络连接操作了了 
content = fn()  # 获取内容 
print(content) 
content2 = fn()  # 重新获取内容 
print(content2)

三. 迭代器 

 str, list, tuple, dict, set. 那为什什么我们可以称他们为可迭代对象呢? 因为他们都遵循了可 迭代协议.

# 对的 
s = "abc" 
for c in s:
    print(c) 
# 错的 
for i in 123:    
print(i) 
结果: Traceback (most recent call last):  
     　　　　File "/Users/sylar/PycharmProjects/oldboy/iterator.py", line 8, in <module>
     　　　　for i in 123: 
 　　　　 TypeError: 'int' object is not iterable
  

　　 'int' object is not iterable . 翻译过来就是整数类型对象 是不可迭代的. iterable表⽰示可迭代的. 表示可迭代协议. 那么如何进⾏验证你的数据类型是否 符合可迭代协议. 我们可以通过dir函数来查看类中定义好的所有⽅方法. 

l = [1,2,3] 
l_iter = l.__iter__() 
from collections import Iterable 
from collections import Iterator 
print(isinstance(l,Iterable))    #True 
print(isinstance(l,Iterator))    #False 
print(isinstance(l_iter,Iterator))    #True 
print(isinstance(l_iter,Iterable))    #True 

　　如果对象中有__iter__函数. 那么我们认为这个对象遵守了可迭代协议. 就可以获取到相应的迭代器. 这里的__iter__是帮助我们获取到对象的迭代器. 我们使⽤迭代 器中的__next__()来获取到⼀个迭代器中的元素. 

s = "我爱北京天安门" 
c = s.__iter__()    # 获取迭代器
print(c.__next__())     # 使用迭代器进行迭代. 获取一个元素    我 
print(c.__next__())     # 爱 
print(c.__next__())     # 北 
print(c.__next__())     # 京 
print(c.__next__())     # 天 
print(c.__next__())     # 安 
print(c.__next__())     # ⻔
print(c.__next__())     # StopIteration

 for循环的机制: 

for i in [1,2,3]:
    print(i)

使⽤while循环+迭代器来模拟for循环

lst = [1,2,3] 
lst_iter = lst.__iter__() 
while True:
    try:
        i = lst_iter.__next__()
        print(i)
    except StopIteration:
        break
 

　　dri()    dri查看什么类型的数据可以执行哪些方法

       所有的带__iter__可以使用for循环,可迭代对象.

　　可迭代对象可以使用__iter__()来获取到迭代器

　　迭代器里面有__next__()

 总结:

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

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

迭代器的特点:

             1. 节省内存

.            2. 惰性机制 

             3. 不能反复, 只能向下执⾏行行.