python11闭包和迭代器

函数名的应用

1.函数名就是一个变量，但他是一个特殊的变量，与括号配合可以执行函数的变量。

def fun（）：

    print（“你吃了吗？”）

print（fun）# <function func at 0x0000003fe18>

 a = func

print（a）# <function func at 0x0000003fe18>

func（）#你吃了吗？

a()         #你吃了吗？

2.

def fun（）：

    print（“你吃了吗？”）

def a（）：

    print（“我吃了”）

func = a

func（） #我吃了

3.

def f1（）：

    print（“我是马玉”）

def f2（）：

    print（“我是马化腾”）

def f3（）：

    print（“我是马赛克”）

lst = [f1,f2,f3,f4]

for el in lst:

    el()

print(lst)  #打印的是4个内存地址

如果lst = [f1(),f2(),f3(),f4()]

print(lst),那么打印的结果是：

我是马玉

我是马化腾

我是马赛克

[None,None,None,None]

4

可以作为函数的参数

def func（fn）：

    fn（）

def gn（）：

   print（“我是火锅”）

func（gn）   #可以把函数作为参数，传递给另一个函数

 

5

def func（）：

    def inner（）：

          print("火锅不让吃了，吃了上火”)

      return inner

ret = func（） #func执行之后获取到的是inner函数

ret（）   #这里是让inner函数执行

闭包

闭包就是内层函数对外层变量的引用

python的基制决定的：闭包的最大作用，让一个局部变量常驻内存。

def func（）：

    name = “alex”   #常驻内存

    def inner（）：

            print（name）  #在内层函数中调用了外层函数中的变量，叫闭包

     return inner

ret = func（）

ret（）# alex

1.变量写成全局变量是不安全的

name = “wusir”
def abc（）：

    global name

    name = “呵呵”

abc（）

#这样那么被abc函数修改成了呵呵

2.写成闭包后的效果

def func（）：

    name=“alex”

    def inner（）：

       print（name）

    def inner2（）：

        nonlocal name

        name = “wusir”

    return inner

#这样只能在func函数中修改name变量，别人无法修改

3.闭包的好处

举例：爬虫网站

from urlib.request import urlopen

def but():

    content = urlopen("http://www.xiaohua100.cn/index.html").read()

    def get_content():

        return content

    return get_content

fn = but()  #这个时候就开始加载校花100的内容，后面需要用到这里的内容就不需要在执行非常耗时的网络连接操作了

content = fn（）#获取内容

print（content）

content2=fn（）#重新获取内容

print（content2）

 

 

迭代器

可迭代对象： str，list，tuple，set，file，dict，这里面只有file是迭代器

所有的以上数据类型中都有一个函数:__iter__()，那么所有包含__iter__()的数据类型都是可迭代的数据类型。Iterable

s = “北京欢迎您”

for i in s：

    print（i）

for i in 123：

    print（i）  #   int object is not iterable  
 

2, lst = [“皇阿玛”，“皇额娘”，“紫薇”]

it = lst.__iter__()   #__iter__()的作用：获取迭代器

print(it.__next__())  #使用迭代器进行迭代，获取第一个元素，皇阿玛

print(it.__next__())  #皇额娘

print(it.__next__())  #紫薇

print(it.__next__())  #迭代到最后一个元素之后，在进行迭代就报错了。stopiteration

3.lst = [“皇阿玛”，“皇额娘”，“紫薇”]

it = lst.__iter()__

while True:

    try:

           name = it.__next__()

           print(name)

     except StopIteration:

           break

4.

迭代器和可迭代对象是两回事

迭代器里面也有__iter__()函数,还有一个函数__next__()，所以说迭代器是可迭代对象

 

lst=【1,2,3】

print（“__iter__” in dir(lst)）#True，确定是一个可迭代的

print（“__next__” in dir(lst)）#False,确定不是一个迭代器

 

isinstance（对象，类型），判断xx对象是否是xxx类型

from collections import Iterable  #可迭代的

from collections import Iterator  #迭代器

print（isinstance（lst，Iterable）） #确定是否是一个可迭代的  True

print（isinstance（lst，Iterator）） #确定是否是一个迭代器   False

5.

it = lst.__iter__() #这个时候it是个迭代器

print(isinstance(it,Iterable))  #判断是否是可迭代的 迭代器一定是可迭代的。True

print（isinstance（it，Iterator））#迭代器里面一定有__next__(),__iter__()

 

一个对象，如果是可迭代的，那么他不一定是迭代器；如果他是迭代器，那么一定是可迭代的,因为迭代器里面有__iter__()

迭代器的特点：

1.节省内存

2.惰性机制

3.不能反复，只能向下执行

 

可迭代对象（Iterable）：内部含有__iter__();str list dict set tuple

迭代器（Iterator）:内部含有__iter__()和__next__() ;  f  range