函数名,函数的闭包和迭代器

#1函数名
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():
        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迭代器

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__())
print(it.__next__())