函数名的应用,闭包,迭代器

1, 函数名的应用,第一类对象
函数名可以像变量一样进行使用
1.赋值
2.作为list元素
3.作为参数
4.作为返回值

def func():
    print("你吃了么?")

# print(func)
# a = func    # 函数名就是一个变量
# print(a)
# func()
# a() # 就是一个函数的调用

def a():
    print("我吃了")

func = a
func()

a = 8
b = 7
c = 1
d = 3
lst = [a, b , c, d]
print(lst)

def f1():
    print("我是马化腾")
def f2():
    print("我是马云")
def f3():
    print("我是马赛克")
def f4():
    print("我是马蔚华")

lst = [f1(), f2(), f3(), f4()]
print(lst)


还可以作为函数的参数
def func(food):
    print("吃", food)

a = "火锅"
func(a)


def func(fn):
    fn()

def gn():
    print("我是火锅, 刚才有人要吃我")
func(gn)    # 可以把函数作为参数, 传递给另一个函数


def func():
    def inner():
        print("火锅不让吃了. 吃了上火")
    return inner
ret = func()    # 这里func()执行之后获取到的是inner函数
ret()   # 这里是让inner函数执行

综上. 函数就是一个变量

　　

2, 闭包
内部函数访问外部函数的局部变量.
好处:
1.安全
2.常驻内存. 提高效率
3, 迭代器
可迭代对象(Iterable):内部包含__iter__().
迭代器(Iterator): 内部含有__iter__() __next__()
str, list, tuple, set, dict
f, range

name = "wusir"  # 变量写在全局是不安全的

def abc():
    global name
    name ="呵呵"
abc()

def func():
    name = "alex"   # 常驻内存  防止其他程序改变这个变量
    def inner():
        print(name) # 在内层函数中调用了外层函数的变量,叫闭包, 可以让一个局部变量常驻内存
    return inner


ret = func()
ret() # 执行的是inner()
ret()
ret()
ret()
ret()

# 闭包的好处
from urllib.request import urlopen
def but():
    content = urlopen("http://www.h3c.com/cn/").read()
    def inner():
        print("你好啊")
         # return content # 在函数内部使用了外部的变量 . 闭包
    print(inner.__closure__)    # 查看inner是否是闭包, 如果有东西就是闭包, 没东西就不是闭包
    return inner
print("加载中........")
fn = but()  # 这个时候就开始加载校花100 的内容
# 后⾯需要⽤到这⾥⾯的内容就不需要在执⾏⾮常耗时的⽹络连接操作了
content = fn()   # 获取内容
print(content)
content2 = fn()  # 重新获取内容
print(content2)

　　

迭代器的特点:
1.省内存
2.惰性机制
3.只能向前.

s = "北京欢迎您"
for c in s:
    print(c)

for i in 123:
    print(i)
可迭代对象: str, list, tuple, set, f, dict
所有的以上数据类型中都有一个函数__iter__(), 所有包含了__iter__()的数据类型都是可迭代的数据类型 Iterable
dir()来查看一个对象,数据类型中包含了哪些东西
lst = [1,2,3]   # list
# print(dir(lst))
s = "王尼玛"
print("__iter__" in dir(s))
print("__iter__" in dir(lst))
print("__iter__" in dir(123))

list是一个Iterable.可迭代的
lst = ["皇阿玛", "皇额娘", "容嬷嬷", "紫薇"]
获取迭代器
it = lst.__iter__()
# 迭代器往外拿元素. __next__()
print(it.__next__())    # 皇阿玛
print(it.__next__())    # 皇额娘
print(it.__next__())    # 容嬷嬷
print(it.__next__())    # 紫薇
print(it.__next__())    # 迭代到最后一个元素之后. 再进行迭代就报错了

lst = ["皇阿玛", "皇额娘", "容嬷嬷", "紫薇"]
# 模拟for循环
it = lst.__iter__()
while True:
    try:
        name = it.__next__()
        print(name)
    except StopIteration: # 拿完了
        break

lst = [1, 2, 3]
from collections import Iterable    # 可迭代的
from collections import Iterator    # 迭代器

# isinstence(对象, 类型) 判断xx对象是否是xxx类型的
# print(isinstance(lst, Iterable))
# print(isinstance(lst, Iterator))

# it = lst.__iter__()
# print(isinstance(it, Iterable)) # 判断是否是可迭代的 迭代器一定是可迭代的
# print(isinstance(it, Iterator)) # 迭代器里面一定有__next__(), __iter__()

# print("__iter__" in dir(lst))   # 确定是一个可迭代的
# print("__next__" in dir(lst))   # 确定不是一个迭代器

# f = open("01 今日内容大纲",mode="r", encoding="utf-8")
# print(isinstance(f, Iterable))
# print(isinstance(f, Iterator))

# 迭代器的特点:
#   1. 节省内存
#   2. 惰性机制
#   3. 只能往前拿. 不能反着拿
lst = ["哈哈", "呵呵"]
it = lst.__iter__()
it.__next__()
print(it.__next__())
print("我要吃黄瓜")
print(it.__next__(