学习Python第十二天

标签：page   mysql   ati   mysq   并且   原函数   赋值   run   ===   

# 加载装饰器就是将原函数名偷梁换柱成了装饰器最内层那个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

              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)

学习Python第十二天

标签：page   mysql   ati   mysq   并且   原函数   赋值   run   ===   

原文地址：https://www.cnblogs.com/hui2002/p/9721620.html