第一类对象 闭包 迭代器

第一类对象-> 函数名 -> 变量名
1.函数对象可以像变量一样进行赋值
2.还可以作为列表的元素进行使用
3.可以作为返回值返回
4.可以作为参数进行传递

def fn():
    print("我叫fn")

fn()
print(fn)  # <function fn at 0x0000000001D12E18>
fn()
gn = fn # 函数名可以进行赋值
print(gn)
gn()

fn = 666
print(fn) # 666




def func1():
    print("朱祁镇")

def func2():
    print("徐阶")

def func3():
    print("王阳明")

def func4():
    print("魏忠贤")

lst = [func1, func2, func3, func4] # 函数+() 就是调用.
print(lst)

# lst[0]()
# for el in lst: #  el是列表中的每一项.
#     el() # 拿到函数. 执行函数,函数名可以像列表元素一样进行迭代




a = 10
b = 20
c = 30
lst = [a, b, c]
print(lst)


def wrapper():
    def inner():
        print("我的天, 还可以扎样写")
    print(inner) # <function wrapper.<locals>.inner at 0x00000000028989D8>
    inner()
    return inner

ret = wrapper() # <function wrapper.<locals>.inner at 0x00000000028989D8>
print(ret)
ret()    ##函数名像变量一样进行赋值操作




def wrapper():
    def inner():
        print("哈哈哈")
    return inner  # 函数名可以像返回值一样返回

ret = wrapper()
ret() # 在函数外面访问了函数内部的函数
ret()
ret()


def func1():
    a = 10
    return a
print(func1())

函数可以作为参数进行传递

def func1():
    print("谢晋")

def func2():
    print('杨士奇')

def func3():
    print('徐渭')

def func4():
    print("柳如是")

# 代理. 装饰器的雏形
def proxy(a): # a就是变量. 形参   这里的函数名作为形参进行了传递
    print("我是代理")
    a()
    print("代理执行完毕")

proxy(func1)
proxy(func3)
proxy(func4)

闭包

闭包就是函数的嵌套
函数嵌套中,内层函数对外层函数中的变量的使用

好处:
1. 保护变量不被侵害
2. 让一个变量常驻内存

如何通过代码查看一个闭包
__closure__: 有东西就是闭包. 没东西就不是闭包

def wrapper():
    a = "哈哈" # 不安全的一种写法
    name = "周杰伦"
    def inner():
        print(name) # 在内层函数中使用了外层函数的局部变量,这里就是一个闭包
        print(a)
    def ok():
        nonlocal a
        a = 108
        print(a)
    return inner  # 返回函数名

ret = wrapper()
ret()

def ok():
    global a  #引入了全局变量,不安全
    a = 20
    print(a )

局部变量常驻于内存

def wrapper():
    name = "周杰伦" # 局部变量常驻与内存
    def inner():
        print(name) # 在内层函数中使用了外层函数的局部变量
    return inner  # 返回函数名
    # inner()

ret = wrapper() # ret是一个内层函数
ret() # ret是inner, 执行的时机是不确定的, 必须保证里面的name必须存在

超级简易版爬虫

超级简易版爬虫
from urllib.request import urlopen # 导入一个模块
# 干掉数字签名
import ssl
ssl._create_default_https_context = ssl._create_unverified_context


def func():
    # 获取到网页中的内容, 当网速很慢的时候. 反复的去打开这个网站. 很慢
    content = urlopen("https://www.dytt8.net/").read()

    def inner():
        return content.decode("gbk") # 网页内容
    return inner

print("开始网络请求")
ret = func() # 网络请求已经完毕  如果一开始是全局变量,重复爬去网站就很慢,因为没有缓存到内存地址
print("网络请求完毕")
print("第一次", ret()[5])
print("第二次", ret()[5]) #

查看是否是闭包

def wrapper():
    name = "alex"
    def inner():
        print("胡辣汤")
    print(inner.__closure__) # 查看是否是闭包. 有内容就是闭包, 没有内容就不是闭包
    inner()      ##__closure__ # 查看是否是闭包

wrapper()

迭代器和迭代

一个数据类型中包含了__iter__函数表示这个数据是可迭代的
dir(数据): 返回这个数据可以执行的所有操作

迭代器的作用

特征:
1. 省内存(生成器)
2. 惰性机制
3. 只能向前. 不能后退

作用:统一了各种数据类型的遍历

# dir() 可以帮我们查看xxx数据能够执行的操作
# print(dir(str)) # __iter__
# print(dir(int)) # 没有__iter__

#print(dir(list)) # 有__iter__
# print(dir(dict)) # 有__iter__
# print(dir(bool)) # 没有__iter__

共性:所有带有__iter__的东西都可以进行for循环, 带有__iter__的东西就是可迭代对象

判断迭代器和可迭代对象的方案(野路子)
__iter__ 可迭代的,拿到迭代器
__iter__ __next__ 迭代器

lst = ["贾樟柯", "李安", "杨德昌", "王家卫"]

# 1. 只能向下执行, 不能反复
# 2. 结束的时候会给我们扔出来一个错误 StopIteration
# 3. 整合所有的数据类型进行遍历(int,bool除外)

# print("__iter__" in dir(lst))
it = lst.__iter__()  # 拿到的是迭代器 <list_iterator object at 0x0000000001DCC160>

print(it.__next__()) # 下一个
print(it.__next__()) # 下一个
print(it.__next__()) # 下一个
print(it.__next__()) # 下一个
# print(it.__next__()) # 下一个 # StopIteration 停止迭代
# 想回去
it = lst.__iter__() # 只能重新获取迭代器

迭代和迭代器   
s = {"张无忌", "贾樟柯", "宝宝", "风扇哥", "门神"}
it = s.__iter__()#获取迭代器
print(it.__next__())#利用迭代器进行迭代
print(it.__next__())
print(it.__next__())
print(it.__next__())
print(it.__next__())

##整合所有的数据类型进行遍历(int,bool除外)

模拟for循环
lst = ["海尔兄弟", "阿童木", "葫芦娃", "舒克贝塔", "大风车"]
# 模拟for循环 for el in lst:
it = lst.__iter__() # 获取到迭代器0
while 1: # 循环
    try: # 尝试
        el = it.__next__() # 那数据
        print(el)
    except StopIteration: # 出了错误, 意味着数据拿完了
        break # 结束循环

官方通过代码判断是否是迭代器
借助于两个模块 Iterator迭代器, Iterable可迭代的
from collections import Iterable, Iterator

lst = [1,2,3]
# print(lst.__next__())

print(isinstance(lst, Iterable)) # xxx是否是xxx类型的. True
print(isinstance(lst, Iterator)) # False

it = lst.__iter__()  # 迭代器一定可迭代,  可迭代的东西不一定是迭代器

print(isinstance(it, Iterable)) # xxx是否是xxx类型的. True
print(isinstance(it, Iterator)) # True

for el in it:
    print(el)

特征:
1. 省内存(生成器)
2. 惰性机制
3. 只能向前. 不能后退

作用:统一了各种数据类型的遍历