# 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__)

# 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 urlopendef func():# 闭包. content会常驻内存content = urlopen("http://www.xiaohuar.com/").read()def inner():return contentreturn innerprint("加载中...")
g = func() # 网络请求
print("加载完毕")
print(g())
print(g())
print(g())

# 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__())