学习Python第十二天-CSDN博客

# 加载装饰器就是将原函数名偷梁换柱成了装饰器最内层那个wrapper函数

# 在加载完毕后，调用原函数其实就是在调用wrapper函数

# 当一个被装饰的对象同时叠加多个装饰器时

# 装饰器的加载顺序是：自上而下

‘ ' '

import time

def timmer (func: # func=wrapper2的内存地址

def wrapper1 (* args, **kwargs):

print('=======================>wrapper1运行了’）

start=time,time()

res=func (*args , **kwargs) #==================跳到wrapper2 去执行了

stop=time, time()

print ('run time is %s' % (stop- start))

return res

return wrapper1

def auth(engie='file');

def xxx (func) : # func=最原始那个index的内存地址

def wrapper2 (* args, **kwargs):

print('==================>wrapper运行‘）

name=input('username>>>:') , strip()

pwd = input('passward>>>:') , strip

if engine == 'file':

print(’基于文件的认证‘）

if name == 'egon' and pwd == '123':

print('login' successfull')

res= func(*args; **kwards)

return res

elif engine == ' mysq1' :

print (' 基于mysql的认证’）

elif endine == 'ldap' :

print('基于的认证原‘）

return wrapper2

return xxx

@ timmer # index=timmer(wrapper的内存地址） #idex= wrappe1的内存地址

@ auth(engine='file') # @xxx # index=xxx(最原始那个index的内存地址） #index=wrapper2的内存地址

def index():

print ('welcome to index page')

indx() # wrapper1 的内存地址（）

’ ‘ ’

import time

def timmer (func): # func=wrpper2的内存地址

def wrapper1 (*args, **kwargd):

print('===================>wrapper1运行了‘）

start=time,time()

res = func (*args ;**kwargs) #===============> 跳到wrapper2去执行了。

atop = time . time()

print('run time is % (stop - start))

return res

return wrapper1

def auth a9engine='file'):

def xxx (func): # func= 最原始那个index的内存地址

def wrapper2(* args, **kwargs):

print ('==============================>wrapper2运行了，

name =input('usernme>>>:') .strio()

pwd= input(password>>>; ’) , strip()

if engine == 'file' ;

print ('基于文件的认证‘）

if name == 'egon' and pwd == '123':

return res

elif engine == 'mysql' :

print('基于mysql的认证’）

elif engine == 'ldap' :

print ('基于ldap的认证‘）

else :

print('错误的认证原’）

retrn wrappe2

return xxx

@ auth(engine='file)

@ timmer

def indwx():

print('welcome to index page')

time , sleep(2)

index() #wrapper1 的内存地址（）

‘ ’ ‘

1，什么是迭代器

迭代指的是一个重复的过程，每一次重复都是基于上一次的结果而来的

li=['a','b,'c'.'d'.'e']

li=('a','b','c,'d','e')

li='hello'

i=0

while i <len(li):

print(li[i])

i+=1

迭代器指的说迭代取值的工具，该工具的特点是可以不依赖于索引取指

2，为何要用迭代器

为了找出一种通用的&可以不依赖于索引的迭代取值方式

3. 如何要用迭代器

可迭代的对象：但凡内置有，—— iter__方法的对象都称之为可迭代的对象

迭代器对象：—-inter__方法，又内置有——next__方法

关于————iter——方法：

调用可迭代对象的——iter——会的到一个迭代器对象

调用迭代器对象的——-iter————会的到迭代器本身

4，总结迭代器的优点缺点：

优点：

1，提供了通用的&可以不依赖于索引的迭代取值方法

2，同一时刻在内存中只有一个值，更加节省内存

缺点：

1，取值定值不如索引灵活，并且迭代器是一次性的

2，无法预知迭代器数据的个数

’ ‘ ’

# 可迭代的对象：str,list,tupie,dict,set,文件对象

# 迭代器对象：文件对象

# 可迭代的对象====》迭代器对象：调用可迭代器对象：调用迭代对象内置的——iter_方法会有一个反回值，该返回值就是对的迭代对象

dic ={'x':1,'y':2,'z':3}

#iter--dic=dic,iteri_-()

# # print(iter--dic)

# resl=itr_dic,__next()

# print(resl)

# re2=iter-dic,__next__()

# print(ren20

# rs3=iter_dic,__net--()

# print(res3)

# res4=iter_dic,__next--（）

# print(res4)

# print(diciter__(),__next())

# print(dic,__ite__(),__next__()

# dic={'x,':l','y',:2,'z':3}

# 3 dic=['a','b','c']

# ite_dic=dic,__iter_-iter__()

# # iter_dic=open(r'D:\qq.com\qwe,py'rt',encoding='utf-8')

#
#while true；

# try：

# print(iter_dic,_next----（））

# excep stopiteration:

# break

# for准确地说应该是迭代器循环，for——循环的原理如下：

# 1，先调用in 后面那个值的---iter--方法，得到迭代器对象

# 2，执行迭代器---net--()方法得到一个返回值，然后，赋值给一个变量k，运行循环体代码

# 3，循环往复，值到迭代器取值完毕抛出异常然后捕捉异常自动结束循环

dic={'x':1'y':2';z';:3}

iter_dic,__itter__()

print(iter_dic)

print(iter-dic_iter__())

# for kk in dic: # i ter- dic=dic,__iter()

# print(k）

# with open (r'D:\qwe\rn.py'',mode [=rt''''''''''',rncoding='utf-8')

as f:

# for line in f: # iter_f=f,__iter_()

# print(line)

转载于:https://www.cnblogs.com/hui2002/p/9721620.html