小学生都能学会的python(闭包和迭代器)

小学生都能学会的python(闭包和迭代器)

1. 函数名第一类对象
函数名其实就是变量名
1). 可以像变量一样互相赋值.
2). 可以作为函数的参数,进行传递
3). 可以作为返回值返回
4). 可以作为集合的元素进行存储

# def chi():
#     print("吃月饼")
# print(chi)
# fn = chi # 函数名可以进行赋值
# a = 10
# b = a
# chi()
# fn()
# 函数名可以像变量名一样进行使用


# def func1():
#     print("我是一个单纯的函数")
#
# def func2(abc): # abc接收到的是一个函数的内存地址
#     abc()  # 执行func1, func1()
#     print("我是func2", abc)
#
# # a = "苹果"
#
# func2(func1) # func1是函数的内存地址, 函数名可以像变量一样进行参数的传递


# def outer():
#     def inner():
#         print("我是里面")
#     return inner
#
# outer()() # ()表示的是执行
# ret = outer() # outer得到的结果是inner
# ret() # 执行的是inner函数

# a = "周润发"
# b = "蓝洁瑛"
# c = "春三十娘"
# d = "简直了"
#
# lst = [a, b, c, d]
# for el in lst:
#     print(el)

# def chi():
#     print("吃饭")
# def he():
#     print("喝饮料")
# def du():
#     print("赌是不好的")
# def chou():
#     print("少抽点烟")
#
# lst = [chi, he, du, chou]
# for el in lst:
#     el()

# a = 10
# print(a + 20)

# 错误的
# def a():
#     pass
# print(a + 10)
#
# def panpan():
#     print("我是潘潘. 我喜欢毒丈夫 ")
#
# def xiaoping():
#     print("我是小萍萍. 我喜欢毒丈夫 ")
#
# def xiaohua():
#     print("我是小花花. 我喜欢毒丈夫 ")
#
# def daguanren():
#     print("大官人喜欢xxxx")
#
# def wangpo(nv, nan): # 核心业务逻辑
#     nv()
#     nan()
#
# wangpo(xiaohua, daguanren) # 王婆代理了大官人和潘潘


# def chi():
#     print("我是吃")
#
# a = chi
# haha = a
# hehe = haha
# bilibili= hehe
#
# bilibili()
# print(bilibili.__name__) # 函数名

def play(wanjv1, wanjv2, wanjv3):
    '''
        玩儿函数
        :param wanjv1: 玩具1
        :param wanjv2: 玩具2
        :param wanjv3: 玩具3
        :return: 开心
    '''
    print("我要玩儿荡秋千")
    return "开心"


# play("独木桥", "独轮车", "独眼龙")
print(play.__doc__) #  document
print(str.join.__doc__)

　　

2. 闭包(函数的嵌套. 返回函数名)
作用:
1). 保护变量
2). 常驻内存
基本写法
def outer():
a = 10
def inner():
return a
return inner

# def func():
#     a = 10
#     print(a)
# func()
# print(a) # 在外面你是访问不到局部变量的, 局部变量是安全的


# 全局变量可能会被修改, 全局变量是不安全的. 可能会被其他函数所更改
# a = 10
# def func():
#     global a
#     a = 20
#     print(a)
# func()
# print(a)

# 用闭包可以保护我们的变量
# 写法: 在外层函数中声明一个变量. 在内层函数使用或者返回这个变量.
# 这个结构叫闭包
# 1.可以保护我的变量
# 2.可以让一个变量常驻内存

# def outer():
#     a = 10 # 常驻内存
#     def inner():
#         print(a) # 在内部使用的外面的变量
#     return inner # 返回了内部函数
#
#
# # ret是inner的地址. ret就是inner
# ret = outer()
# # ret() # 这里执行inner()
# # print("哈哈")
# # print("哈哈")
# # print("哈哈")
# # ret() # inner的执行时间是不确定的
# # print("哈哈")
# # print("哈哈")
# # print("哈哈")
# # ret() # inner的执行时间是不确定的
#
# # def haha():
# #     pass
# # print(ret.__closure__) # 有东西, 就是闭包. None就不是闭包

# 闭包的应用.保护变量, 常驻内存
from urllib.request import urlopen

def func():
    # 闭包. content会常驻内存
    content = urlopen("http://www.xiaohuar.com/").read()
    def inner():
        return content
    return inner

print("加载中...")
g = func() # 网络请求
print("加载完毕")
print(g())
print(g())
print(g())

　　

3. 迭代器(用)
1. Iterable: 可迭代的.里面有__iter__()
2. Iterator: 迭代器. 里面有__iter__() 还有 __next__()

特点:
1. 节省内存(欠)
2. 惰性机制(只有执行__next__()才会取值)
3. 只能向前. 不能反复

dir() 查看数据可以执行的方法
isinstance() 判断xxx对象是否是xxx类型

for循环的内部用的是迭代器
lst = [1, 2, 3]
it = lst.__iter__().__next__()
while 1:
try:
it.__next__()
except StopIteration:
break

# for c in 123:
#     print(c)


# iterable 可迭代的, str, list. tuple, dict, set, open(), range()
# dir() 可以查看某数据类型中可以执行的方法
# s = "alex"
# print(dir(s)) # 在字符串中发现了__iter__. 没有__next__
# a = 123
# print(dir(a)) # 在int中没有__iter__ 没有__next__
# lst = [1, 2, 3,]
# print(dir(lst)) # 在list中也有__iter__

# 所有包含了__iter__的东西都可以使用for循环. 都可以进行迭代
# 迭代器, 在for循环内部. 调用了__iter__(), 访问__iter__()可以得到迭代器
# lst = [1, 2, 3, 4, 5, 6]
#
# it = lst.__iter__()  # iterator 迭代器
# while 1:
#     try:
#         print(it.__next__())
#     except StopIteration:
#         print("结束了")
#         break

# for el in lst:
#     print(el)
# else:
#     print("结束了")


# 迭代器给所有的数据类型提供了一种统一的遍历的方式(可迭代协议), Iterable, __iter__()
# lst = [1, 2, 3, 4, 5]
# # print("__iter__" in dir(lst))
# # print("__next__" in dir(lst))
#
# it = lst.__iter__()
# # print("__iter__" in dir(it)) #  迭代器里面是有__iter__的.  迭代器一定是可迭代的
# # print("__next__" in dir(it))
#
# for el in it: # 迭代器可以使用for循环
#     print(el)

# 小总结
# Iterable: 可迭代对象. 里面包含了__iter__(),可以使用for循环
# Iterator: 迭代器. 里面包含了__iter__() 和 __next__(), 也可以使用for循环

# from collections import Iterable # 可迭代的
# from collections import Iterator # 迭代器
#
# lst = ["周润发","麻花藤","刘伟"]
# print(isinstance(lst, Iterable)) # instance  实例, 对象
# print(isinstance(lst, Iterator)) # instance  实例, 对象
#
# it = lst.__iter__()
# print(isinstance(it, Iterable)) # instance  实例, 对象
# print(isinstance(it, Iterator)) # instance  实例, 对象

#  总结
#  特点:
#   1. 节省内存
#   2. 惰性机制
#   3. 只能向前. 不能反复

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

# 重新拿一个迭代器
it = lst.__iter__()
print(it.__next__())
print(it.__next__())