函数名本质
函数名本质上就是函数的内存地址。
1.可以被引用
def func():
print('in func')
f = func
print(f)
2.可以当作函数的参数和返回值
def f1():
print('f1')
def func1(argv):
argv()
return argv
f = func1(f1)
f()
3.可以被当作容器类型的元素
def f1():
print('f1')
def f2():
print('f2')
def f3():
print('f3')
l = [f1,f2,f3]
d = {'f1':f1,'f2':f2,'f3':f3}
#调用
l[0]()
d['f2']()
第一类对象
第一类对象（first-class object）指
1.可在运行期创建
2.可用作函数参数或返回值
3.可存入变量的实体。
不明白？那就记住一句话，就当普通变量用
闭包
def func():
name = 'hyg'
def inner():
print(name)
闭包函数：
内部函数包含对外部作用域而非全剧作用域变量的引用，该内部函数称为闭包函数
函数内部定义的函数称为内部函数
由于有了作用域的关系，我们就不能拿到函数内部的变量和函数了。如果我们就是想拿怎么办呢？返回呀！
我们都知道函数内的变量我们要想在函数外部用，可以直接返回这个变量，那么如果我们想在函数外部调用函数内部的函数呢？
是不是直接就把这个函数的名字返回就好了？
这才是闭包函数最常用的用法
def func():
name = 'eva'
def inner():
print(name)
return inner
f = func()
f()
判断闭包函数的方法__closure__(有问题，有待进一步却认)
def func():
name = 'eva'
def inner():
print(name)
print(inner.__closure__)
return inner
f = func()
f()
#输出的__closure__为None ：不是闭包函数
name = 'egon'
def func2():
def inner():
print(name)
print(inner.__closure__)
return inner
f2 = func2()
f2()
闭包嵌套
def wrapper():
money = 1000
def func():
name = 'eva'
def inner():
print(name,money)
return inner
return func
f = wrapper()
i = f()
i()
闭包函数获取网络应用
from urllib.request import urlopen
def index():
url = "http://www.xiaohua100.cn/index.html"
def get():
return urlopen(url).read()
return get
xiaohua = index()
content = xiaohua()
print(content)
迭代器
什么是可迭代对象？
字符串、列表、元组、字典、集合都可以被for循环，说明他们都是可迭代的。
我们怎么来证明这一点呢?
from collections import Iterable
l = [1,2,3,4]
t = (1,2,3,4)
d = {1:2,3:4}
s = {1,2,3,4}
print(isinstance(l,Iterable))
print(isinstance(t,Iterable))
print(isinstance(d,Iterable))
print(isinstance(s,Iterable))
可迭代协议
我们现在是从结果分析原因，能被for循环的就是“可迭代的”，但是如果正着想，for怎么知道谁是可迭代的呢？
假如我们自己写了一个数据类型，希望这个数据类型里的东西也可以使用for被一个一个的取出来，那我们就必须满足for的要求。这个要求就叫做“协议”。
可迭代协议的定义非常简单，就是内部实现了__iter__方法。
接下来我们就来验证一下：
print(dir([1,2]))
print(dir((2,3)))
print(dir({1:2}))
print(dir({1,2}))
#显示结果中都含有 __iter__
总结一下我们现在所知道的：可以被for循环的都是可迭代的，要想可迭代，内部必须有一个__iter__方法。
接着分析，__iter__方法做了什么事情呢？
可迭代的：内部必须含有一个__iter__方法。
迭代器
什么叫做迭代器？迭代器英文意思是iterator。
l = [1,2,3,4]
l_iter = l.__iter__() # 将可迭代的转化成迭代器
item = l_iter.__next__()
print(item)
item = l_iter.__next__()
print(item)
item = l_iter.__next__()
print(item)
item = l_iter.__next__()
print(item)
item = l_iter.__next__()
print(item)
迭代器遵循迭代器协议：必须拥有__iter__方法和__next__方法。
for循环，能遍历一个可迭代对象，他的内部到底进行了什么？
将可迭代对象转化成迭代器。（可迭代对象.__iter__()）
内部使用__next__方法，一个一个取值。
加了异常处理功能，取值到底后自动停止。
用while循环模拟for循环：
l = [1,2,3,4]
l_iter = l.__iter__()
while True:
try:
item = l_iter.__next__()
print(item)
except StopIteration:
break
为什么要有for循环？
基于上面讲的列表这一大堆遍历方式，聪明的你立马看除了端倪，于是你不知死活大声喊道，你这不逗我玩呢么，有了下标的访问方式，我可以这样遍历一个列表啊!
=[1,2,3]
index=0
while index < len(l):
print(l[index])
index+=1
#要毛线for循环，要毛线可迭代，要毛线迭代器
没错，序列类型字符串，列表，元组都有下标，你用上述的方式访问，perfect！但是你可曾想过非序列类型像字典，集合，文件对象的感受，for循环就是基于迭代器协议提供了一个统一的可以遍历所有对象的方法，即在遍历之前，先调用对象的__iter__方法将其转换成一个迭代器，然后使用迭代器协议去实现循环访问，这样所有的对象就都可以通过for循环来遍历了，而且你看到的效果也确实如此，这就是无所不能的for循环，最重要的一点，转化成迭代器，在循环时，同一时刻在内存中只出现一条数据，极大限度的节省了内存。