小结
# 8.12
# 闭包函数
# 函数传参的方法一
# def inner(x):
# print(x)
# inner(1) # 1
# 函数传参方法二（闭包函数，把变量和函数一起包起来，下次要用直接调用）
# def outter(x):
# # def inner():
# # print(x)
# # return inner
# # inner = outter(2) # inner # f = inner
# # inner() # 2
# # f = outter(2)
# # f() # 2
# 爬虫爬网页
# import requests
# def get_res(url):
# res = requests.get(url)
# print(res.txt)
# get_res("https://www.baidu.com/")
# get.res("https://www.baidu.com/")
# 用闭包思想
# def func(url):
# def get_res():
# res = requests.get(url)
# print(res.text)
# return get_res
# baidu_spider = func("https://www.baidu.com") # baidu_spider = get_res()
# 装潢器
## 装潢器：装潢的工具（函数），这个函数有装潢的作用
# 装潢器实质就是一个函数（A)，装潢的对象也是一个函数(B)，用函数A去装潢函数B
# 装潢原则：以下
# 1.不转变函数B的调用方法
# 2.不转变函数B的源代码
# def A():
# """装潢器"""
# pass
# def B():
# """被装潢的对象"""
# pass
# B()
# def index():
# """被装潢的函数"""
# print("hello,index")
#
# index()
# 1.打印函数运行的时光
# 1.1 转变了函数体代码，没转变调用方法
# import time
#
# def index():
# start = time.time()
# print("hello index")
# time.sleep(1)
# end = time.time()
# print(end - start)
# index()
# 1.1 没转变调用方法，也没有转变源代码，但是不同用
# import time
# def index():
# """被装潢的函数"""
# print("hello,index")
#
# def index1():
# print("hello,index1")
#
# start = time.time()
# index()
# time.sleep(1)
# end = time.time()
# print(end - start)
#
# start = time.time()
# index1()
# time.sleep(1)
# end = time.time()
# print(end - start)
# 装潢器方法
# import time
# def deco(func): # func = index
# """装潢器函数"""
# def inner():
# start = time.time()
# func()
# time.sleep(1)
# end = time.time()
# print(end-start)
# return inner
#
# def index():
# """被装潢的函数"""
# print("hello,index")
#
# index = deco(index) # index = inner
# index()
import time
def index():
print("hello,index")
time.sleep(1)
# 检测index的运行的时光，但是不能转变index的调用方法，一级源代码
#首先写一个装潢器函数
# def deco(func): # func是真实的index
# """装潢器函数"""
# def f1():
# start = time.time()
# func() # 真实的index
# end = time.time()
# print(end - start)
# return f1
# index(重新创立的index) = deco(index)#(真实的index)
# aaa = deco(index) # index = f1 = aaa
# index() #f1 / aaa
# import time
# # # def deco(func):
# # # def f1(*args,**kwargs):
# # # print(args)
# # # print(kwargs)
# # # start = time.time()
# # # #*args = *(10) 10
# # # res = func(*args,**kwargs) # 真实的index()
# # # end = time.time()
# # # print(end - start)
# # # return res
# # # return f1
# # # @deco # 语法糖（更精简的代码） index = deco(index)
# # # def index(x,a = 1):
# # # print(x)
# # # print(a)
# # # print("hello,index")
# # # time.sieep(1)
# # # return 123
# # # # 重新创立的index = deco（index真实的index)
# # # index = deco(index) # index= f1
# # # index(10)
# 装潢器模板
# def login(func):
# def inner(*args,**kwargs):
# # 登录功效
# username = input("username")
# pwd = input("pwd")
# if username == "nick" and pwd == "123":
# print("登录胜利")
# res = func(*args,**kwargs)
# return res
# else:
# print("登录失败")
# return inner
#
# def time_count(func):
# def inner(*args,**kwargs):
# start = time.time()
# res = func(*args,**kwargs)
# end = time.time()
# print(end-start)
# return res
# return inner
#
# def outter(func):
# def inner(*args,**kwargs):
# # 加功效
# res = func(*args,**kwargs)
# return inner
#
# @time_count
# @login
# @outter
# def shopping():
# print("shopping")
# shopping()
# 三层装潢器：给双层装潢器加参数
# 断定账号密码来自于哪一个处所
# def auth(engine):
# def login(func):
# def inner(*args, **kwargs):
# # 登录功效
# if engine == "file":
# username = input("usrename:")
# pwd = input("pwd:")
# if username == "nick" and pwd == "123":
# print("登录胜利")
# res = func(*args, **kwargs) # shopping()
# return res
# else:
# print("登录失败")
#
# elif engine == "db":
# print("账号密码来自于数据库,非法要求")
#
# return inner
# return login
#
# @auth("db")
# def shopping():
# print("shopping")
# login = auth("db") # login = login
# shopping = login(shopping) # shopping = inner
# shopping() # inner()
# 装潢器模板
## 双层装潢器模板
# def outter(func):
# def wrapper(*args,**kwargs): # wrapper是未来要运行的函数
# # 加功效
# res = func(*args,**kwargs) # func是被装潢的函数
# return res
# return wrapper
# @outter
# def shopping():
# print("shopping")
#
# #三层装潢器：给双层装潢器加参数
# def sanceng(engine):
# def outtr(func):
# def wrapper(*args,**kwargs): # wrapper是未来要运行的函数
# # 加功效
# print(engine)
# res = func(*args,**kwargs) #func是被装潢的函数
# return res
# return wrapper
# return outter
# @sanceng("file")
# def shopping():
# print("shopping")
# 迭代器对象
#迭代就是更新换代，反复，基于上一次成果推出下一次的成果
# 怎样表现能迭代
#可迭代（具有__iter__办法）
# x = 1 # 不可迭代对象
#
# s = "nick" # 可迭代对象
# s.__iter__()
# lt = [1, 2, 3] # 可迭代对象
# dic = {"a": 1, "b": 2} # 可迭代对象
# tup = (1,) # 元组只有一个元素必需得加逗号# 可迭代对象
# se = {1, 2, 3} # 可迭代对象
# f = open("time.py") # 可迭代对象
#小结： 字符串、列表、字典、元组（元组只有一个元素必需得加逗号表现）、聚集、文件等都是可迭代对象，数字类型和函数不是可迭代对象
# s = "nick"
# s_iter = s.__iter__()
# print(s_iter.__next__())
# print(s_iter.__next__())
# print(s_iter.__next__())
# print(s_iter.__next__())
# 基于索引（基于上一次成果）通过__next__进行迭代
# dic = {"a":1,"b":2} # 可迭代对象
# dic["a"]
# dic_iter = dic.__iter__() #不依附索引取值#迭代器对象
# print(dic_iter.__next__())
# print(dic_iter.__next__())
# print(dic_iter.__next__())
#s = "nick" # 可迭代对象,不属于迭代器对象
# s.__iter__()
# lt = [1, 2, 3] # 可迭代对象,不属于迭代器对象
# dic = {"a": 1, "b": 2} # 可迭代对象,不属于迭代器对象
# tup = (1,) # 元组只有一个元素必需得加逗号# 可迭代对象,不属于迭代器对象
# se = {1, 2, 3} # 可迭代对象,不属于迭代器对象
# f = open("time.py") # 可迭代对象,迭代器对象 迭代器对象：具有__iter__和__next__办法的叫做迭代器对象
# 只有文件是迭代器对象
# for重复原理 迭代重复
# lt = [1,2,3]
# lt_iter = lt.__iter__()
# while 1:
# try:
# print(lt_iter.__next__())
# except StopIteration:
# break # for重复原理
# 可迭代对象；迭代器对象 # 不依附索引取值，而是迭代取值
# for重复
# 1.首先应用iter把lt变成迭代器对象；对文件也要应用iter办法把文件再一次iter下
# 2.然后应用next办法进行迭代取值
# 3. 断定StopIteration异常，遇到异常终止
# f = open("time.py")
# f_iter = f.__iter__()
# print(id(f_iter))
# f_iter_iter = f_iter.__iter__()
# print(id(f_iter_iter))
#小结
# 可迭代对象：具有__iter__办法的对象就是可迭代对象，除数字类型和函数外都是可迭代对象
# 迭代器对象：具有__iter__和__next__办法的都是迭代器对象，只有文件
# for重复 == 迭代重复
dic ={"a":1,"b":2}
for i in dic:
print(i)
# 1. 把lt(可迭代对象/迭代器对象)用__iter__办法转换成迭代器对象
# 2. 应用__next__取出迭代器里的所有值
# 3. 应用__next__办法取尽迭代器中的所有值,必定会报错,通过异常捕捉退出while重复
# 解决了不依附索引取值# 8.12
# 闭包函数
# 函数传参的方法一
# def inner(x):
# 
