第一类对象

函数名的使用及第一类对象：

查看函数的内存地址   print(函数名)
函数可以当做值,赋值给变量
函数可以参数,传递个函数的形参 函数当参数的时候不能加括号
函数可以当返回值 当返回值的时候不括号
函数名可以元素存在容器里

def func1():
    print("念阳枭")
def func2():
    print("李星云")
def func3():
    print("百里登风")
def func4():
    print("李大白")
lst=[func1,func2,func3,func4]
#lst[0]()
for el in lst: # el是裂变中的每一项
    el()        # 拿到函数，执行函数

   可以把函数放到容器里：

def func1():
    print("念阳枭")
def func2():
    print("李星云")
def func3():
    print("百里登风")
def func4():
    print("李大白")
lst=[func1(),func2(),func3(),func4()]  # 函数加上()就是调用函数，由于之前的函数没有return值，所以打印列表中，装的是None，这样没有任何作用！
print(lst)

函数名可以像返回值一样返回：

def wrapper():
    def inner():
        print("锅包肉")
    return inner  # 函数名可以像返回值一样返回
ret=wrapper()
ret()             # 在函数外面访问了函数内部的函数

函数可以传参：

def func1():
    print("念阳枭")
def func2():
    print("李星云")
def func3():
    print("百里登风")
def func4():
    print("李大白")
# 代理，装饰器的雏形
def proxy(a):    # a就是变量，形参       函数可以传参
    print("我是代理")
    a()
    print("代理执行完毕")
proxy(func1)
proxy(func2)
proxy(func3)

闭包：

嵌套函数,在嵌套函数内,内部函数使用外部变量(非全局变量) 就是一个闭包 闭包可以多层

好处,
保护变量不会被外界修改
函数内使用到的变量会生命周期延长
节省开辟空间和销毁空间的时间

迭代器：

可迭代对象:  遵守可迭代对象的协议  具有__iter__()方法
除去整型和布尔值剩下现已知都是

迭代器: 遵守迭代器的协议  具有__iter__()方法和__next__()方法
创建一个迭代器 == 可迭代对象.__iter__()
使用迭代器 == 迭代器.__next__()

lst=["张飞","亚索","吕布","雅典娜"]
it=lst.__iter__()       #拿到的是迭代器
print(it.__next__())    #下一个
print(it.__next__())    #下一个
print(it.__next__())    #下一个
print(it.__next__())    #下一个

it=lst.__iter__()       # 用此语句重新获取迭代器，迭代器只能一次过

只能向下执行，不能反复
结束的时候会给我们扔出来一个错误， StopIteration

用while模拟for循环 for el in lst：

lst=["王者荣耀","英雄联盟","QQ飞车","穿越火线"]
it=lst.__iter__()               # 获取迭代器0
while 1:                        #循环
    try:                        #尝试
        el=it.__next__()        # 拿数据
        print(el)
    except StopIteration:       # 出了错误，except解决，数据拿完
        break                   # 结束循环

迭代器机制:
不能回退
惰性机制
一次性的

查看是迭代器是否是可迭代对象:

from collections import Iterator,Iterable
print(isinstance('查看的内容',Iterable))   # 查看是否是可迭代的
print(isinstance('查看的内容',Iterator))   # 查看是否是迭代器

迭代器一定是可迭代的,但是可迭代的不一定是迭代器