目录

1. 函数名的使用

其实函数名也是一个变量,但它是一个比较特殊的变量,与小括号配合可以执行函数的变量:

SRE实战 互联网时代守护先锋,助力企业售后服务体系运筹帷幄!一键直达领取阿里云限量特价优惠。
  • 函数名其实和内存一样,也可以使用print查看它的内存地址:
In[22]: def func1():
   ...:     pass
   ...: 
In[23]: print(func1)
<function func1 at 0x000002A24830C488>
  • 函数名赋值给其他变量
In[24]: def func2():
   ...:     print('呵呵')
   ...:     
In[25]: a = func2
In[26]: a()
呵呵
  • 函数也能当作容器类的元素:
In[27]: print(func2)
<function func2 at 0x000002A24830B048>
In[28]: lis = [func2, func2, func2]
In[29]: print(lis)
[<function func2 at 0x000002A24830B048>, <function func2 at 0x000002A24830B048>, <function func2 at 0x000002A24830B048>]
  • 函数名也能当作函数的参数:
In[30]: def func3():
   ...:     print('i\'m func3')
   ...:     
In[31]: def func4(fn):
   ...:     fn()
   ...:     
In[32]: func4(func3)        # 把函数名func3作为参数传递给func4
i'm func3
  • 函数名也可以作为函数的返回值:
In[33]: def func5():
   ...:     def func6():
   ...:         print('this is sub function')
   ...:     return func6        # 这里直接把函数名func6作为返回值返回给调用者
   ...: 
In[34]: fn = func5()            # 这里的fn就是func6了
In[35]: fn()                    # 加()执行函数
this is sub function

2. 闭包

闭包是指在内层函数中对外层函数(非全局)的引用

In[36]: def func6():
   ...:     x = 24
   ...:     def func7():
   ...:         print(x)                # 闭包
   ...:     func7()
   ...:     print(func7.__closure__)    # 使⽤__closure__来检测函数是否是闭包. 
   ...:                                 # 使⽤函数名.__closure__返回cell就是闭包. 返回None就不是闭包
     
In[37]: func6()
24
(<cell at 0x000002A2482F8EE8: int object at 0x000000005BA86F00>,)

那么我们要怎么能在函数外面调用内部函数呢,其实很简单,把内部函数作为返回值返回给调用者即可:

In[38]: def func8():
   ...:     x = 24
   ...:     def func9():
   ...:         print(x)
   ...:     print(func9.__closure__)
   ...:     return func9    
   ...: 
In[39]: fn = func8()
(<cell at 0x000002A2482F8DF8: int object at 0x000000005BA86F00>,)
In[40]: fn()                            # 这样就可以在函数外面使用了
24

那么闭包有什么用呢,我们再来看一个例子:

In[2]: def func1():
  ...:     x = 23
  ...:     def func2():
  ...:         nonlocal x
  ...:         x += 1
  ...:         return x
  ...:     return func2
  ...: 
In[3]: fn = func1()
In[5]: fn()
Out[5]: 24
In[6]: fn()
Out[6]: 25
In[7]: fn()
Out[7]: 26
In[8]: fn()
Out[8]: 27
In[9]: x
Traceback (most recent call last):
  File "D:\Environment\python-virtualenv\jupyter\lib\site-packages\IPython\core\interactiveshell.py", line 3265, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-9-6fcf9dfbd479>", line 1, in <module>
    x
NameError: name 'x' is not defined

从上面我们可以看出,x作为一个局部命名空间的变量,在使用是看起来更像是使用全局变量一样,但是最后的报错是证明了x并不是一个全局变量。这个现象就是闭包造成的,它可以把函数中的变量在外部使用,并且能让它常驻于内存。

3. 迭代器

我们之前使用for循环变量一个容器类的对象是,都有提要遍历的对象一定是要可迭代的,先看下可迭代对象里面都有什么:

In[15]: dir(list)
Out[15]: 
['__add__',
 '__class__',
...
...
 '__imul__',
 '__init__',
 '__init_subclass__',
 '__iter__',            # 列表这里有个__iter__方法,代表这个是一个可迭代的对象
 '__le__',
 '__len__',
 '__lt__',
 '__mul__',
...
...
In[16]: dir(str)
Out[16]: 
['__add__',
 '__class__',
 ...
 ...
 '__init__',
 '__init_subclass__',
 '__iter__',            # 字符串也是有__iter__方法
 '__le__',
 '__len__',
 ...
 ...

如果自己尝试过的话会发现列表、字典、字符串和集合都会有这个方法,因为他们都是可迭代对象。

这是查看⼀个对象是否是可迭代对象的第⼀种办法. 我们还可以通过isinstence()函数来查看⼀个对象是什么类型的

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__()来获取到⼀个迭代器中的元素. 那么我们之前讲的for的⼯作原理到底是什么? 继续看代码

In[17]: s = 'zzc'
In[18]: s_iter = s.__iter__()       # 使用字符串的__iter__()方法
In[19]: s_iter.__next__()
Out[19]: 'z'
In[20]: s_iter.__next__()
Out[20]: 'z'
In[21]: s_iter.__next__()
Out[21]: 'c'
In[22]: s_iter.__next__()
Traceback (most recent call last):
  File "D:\Environment\python-virtualenv\jupyter\lib\site-packages\IPython\core\interactiveshell.py", line 3265, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-22-b111e2554a10>", line 1, in <module>
    s_iter.__next__()
StopIteration

从上可以看出,只要一个对象有__iter__方法,那么我们认为这个对象遵守了可迭代协议,就可以获取到相应的迭代器(s_iter),然后后我们可以使用迭代器中的__netx__方法来获取下一个迭代器中的元素,直到抛出`StopIteration``异常时退出,

for循环的机制:

In[24]: l1 = ['zzc', '牛奶', 'PDD', '55开']
In[25]: for i in l1:
   ...:     print(i)
   ...:     
zzc
牛奶
PDD
55开

用while实现的for循环:

lis = ['zzc', '牛奶', 'PDD', '55开']
iter = lis.__iter__()
while 1:
    try:                        # try/excpet是捕获异常的语句
        ele = iter.__next__()
        print(ele)
    except StopIteration:       # 当捕获到StopIteration异常时退出
        break

总结:

  • Iterable: 可迭代对象. 内部包含__iter__()函数
  • Iterator: 迭代器. 内部包含__iter__() 同时包含__next__().
  • 迭代器的特点:
    1. 节省内存.
    2. 惰性机制
    3. 不能反复, 只能向下执⾏.
扫码关注我们
微信号:SRE实战
拒绝背锅 运筹帷幄