迭代器闭包

一,函数名的应用

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

函数名的内存地址

def func():
    print("呵呵")  #不会执行呵呵因为没有调用
print(func)
结果:
<function func at 0x1101e4ea0>

b ,函数名可以赋值给其他变量

def func():
    print("呵呵")
print(func)
a = func   #把函数当做一个变量赋值给其他变量
a()          #相当于函数的调用

c , 函数名可以当做容器内的元素

def func1():
print("呵呵")
def func2():
print("呵呵")
def func3():
print("呵呵")
def func4():
print("呵呵")
lst = [func1, func2, func3]
for i in lst:
i()   #可以直接调用函数了

d, 函数名可以当做函数的参数

def func1():
    print("这里是函数一")
def func2(a):
    print("你好")
    a()  #参数函数名func1传过来之后,加上括号变成调用,执行func
    print("你镇好")
func2(func1)

e, 函数名可以作为函数的返回值

def func1():
    print("小美女")
    def func2():
        print("小仙女")
    return func2
ret = func1()   #得到的结果是小美女和func2函数名的内存地址
print(ret)

def func1():
    print("小美女")
    def func2():
        print("小仙女")
    return func2
ret = func1()  # 得到的结果是小仙女 小美女  None
print(ret())

二闭包

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

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

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

扫描二维码关注公众号，回复： 2675114 查看本文章

def func1():
name = "alex"
def func2():
print(name) # 闭包
func2()
print(func2.__closure__) # (<cell at 0x10c2e20a8: str object at
0x10c3fc650>,)
func1()

问题, 如何在函数外边调⽤用内部函数呢? 那如果多层嵌套呢? 很简单, 只需要一层

一层的往外层返回就行了

def func1():
　　def func2():
　　　　def func3():
　　　　　　print("嘿嘿")
　　　　return func3
　　return func2
func1()()()                #得到嘿嘿

闭包的好处闭包可以让变量常驻内存,保护变量不被侵害

三迭代器

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

我们可以利用dir函数来查看勒种定义好的所有方法

s = "我的哈哈哈"
print(dir(s)) # 可以打印对象中的⽅方法和函数
print(dir(str)) # 也可以打印类中声明的⽅方法和函数

在打印结果中. 寻找__iter__ 如果能找到. 那么这个类的对象就是⼀一个可迭代对象

['__add__', '__class__', '__contains__', '__delattr__', '__dir__',
'__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
'__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__',
'__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__',
'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__',
'__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode',
'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index',
'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower',
'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join',
'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind',
'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines',
'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

我们发现只要是能够迭代(可for循环)的都有该方法

我们还可以利用isinstence()方法进行查询

l = [1,2,3]
i.iter = l.__iter__()
from collections  import Iterable
from  collections import Iterator
print (isinstance(i,Iterable))#true
print(isinstance(i_iter,Iterator))    #返回true
print (isinstance(i,Iterator))#false
print(isinstance(i_iter,Iterable))    #返回true

综上. 我们可以确定. 如果对象中有__iter__函数. 那么我们认为这个对象遵守了了可迭代协议.
就可以获取到相应的迭代器. 这⾥里里的__iter__是帮助我们获取到对象的迭代器. 我们使⽤用迭代
器中的__next__()来获取到⼀一个迭代器中的元素. 那么我们之前讲的for的⼯工作原理理到底是什什
么? 继续看代码

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循环的机制

or 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

总结:
Iterable: 可迭代对象. 内部包含__iter__()函数
Iterator: 迭代器. 内部包含__iter__() 同时包含__next__().
迭代器的特点:
1. 节省内存.
2. 惰性机制
3. 不能反复, 只能向下执行.
我们可以把要迭代的内容当成子弹. 然后呢. 获取到迭代器__iter__(), 就把⼦子弹都装在弹夹
中. 然后发射就是__next__()把每一个子弹(元素)打出来. 也就是说, for循环的时候. 一开始的
时候是__iter__()来获取迭代器. 后⾯面每次获取元素都是通过__next__()来完成的. 当程序遇到
StopIteration将结束循

迭代器 闭包

猜你喜欢