python--有参装饰器、迭代器

import time
import random
from functools import wraps

def timmer(func):
    @wraps(func)
    def wrapper():
        # wrapper.__doc__=func.__doc__
        start_time = time.time()
        func()
        stop_time=time.time()
        print(‘run time is %s‘ %(stop_time-start_time))

# wrapper.__doc__=func.__doc__
    return wrapper

@timmer
def index():
    ‘index function‘
    time.sleep(3)
    print(‘welecome to index page‘)

print(index.__doc__)
# index()
# print(index.__doc__)

# def foo():
#     ‘foo function------------>‘
#     pass
#
# print(help(foo))

# def foo():
#     ‘foo fuction‘
#     print(foo.__doc__)
#     foo.__doc__=‘asdfasdfasdfasdfsadfasdfasdfsadfasdfasfas‘
#     pass

# print(help(foo))

# print(foo.__doc__)
# foo.__doc__=‘abcdefg‘
# print(foo.__doc__)
# print(help(foo))
#
# foo()
# print(foo.__doc__)

有参装饰器

db_path=r‘C:\Users\Administrator\PycharmProjects\python5期\day8\db.txt‘

login_dic={
    ‘user‘:None,
    ‘status‘:False,
}
# def deco(auth_type=‘file‘):
#     def auth(func):
#         def wrapper(*args,**kwargs):
#             if auth_type == ‘file‘:
#                 if login_dic[‘user‘] and login_dic[‘status‘]:
#                     res = func(*args, **kwargs)
#                     return res
#
#                 name=input(‘your name: ‘)
#                 password=input(‘your password: ‘)
#                 with open(db_path,‘r‘,encoding=‘utf-8‘) as f:
#                     user_dic=eval(f.read())
#
#                 if name in user_dic and password == user_dic[name]:
#                         print(‘login ok‘)
#                         login_dic[‘user‘]=name
#                         login_dic[‘status‘]=True
#                         res=func(*args,**kwargs)
#                         return res
#                 else:
#                     print(‘login err‘)
#             elif auth_type == ‘ldap‘:
#                 print(‘ldap认证方式‘)
#             elif auth_type == ‘mysql‘:
#                 print(‘mysql认证方式‘)
#             else:
#                 print(‘不知到的认证方式‘)
#         return wrapper
#     return auth
#
# @deco(auth_type=‘abc‘) #@auth #index=auth(index)
# def index():
#     print(‘welecome to index‘)
#
# @deco(auth_type=‘ldap‘)
# def home(name):
#     print(‘welecome %s to home page‘ %name)
#
#
# index()
#
# home(‘egon‘)

def deco(auth_type=‘file‘):
    def auth(func):
        def wrapper(*args,**kwargs):
            if auth_type == ‘file‘:
                print(‘文件的认证方式‘)
            elif auth_type == ‘ldap‘:
                print(‘ldap认证方式‘)
            elif auth_type == ‘mysql‘:
                print(‘mysql认证方式‘)
            else:
                print(‘不知到的认证方式‘)
        return wrapper
    return auth

@deco(auth_type=‘abc‘) #@auth #index=auth(index)
def index():
    print(‘welecome to index‘)

@deco(auth_type=‘ldap‘)
def home(name):
    print(‘welecome %s to home page‘ %name)

index()

home(‘egon‘)

#缓存多个不同网站的内容:
#思路:hash每个url,用得到的值做成文件名,一个网站一个文件名,
# 然后每次根据传进来的url进行hash得到的结果去寻找文件

迭代器

  • 迭代:

    1. 重复
    2. 下一次重复是基于上一次的结果

‘‘‘
python为了提供一种不依赖于索引的迭代方式,
python会为一些对象内置__iter__方法
obj.__iter__称为可迭代的对象
‘‘‘

obj.__iter__() 得到的结果就是迭代器

得到的迭代器:既有__iter__又有一个__next__方法

# d={‘a‘:1,‘b‘:2,‘c‘:3}
#
# i=d.__iter__() #i叫迭代器
# print(i)
# print(i.__next__())
# print(i.__next__())
# print(i.__next__())
# print(i.__next__()) #StopIteration

迭代器的优点:

  • 1:提供了一种不依赖于索引的取值方式
  • 2:惰性计算。节省内存

迭代器的缺点:

  • 1:取值不如按照索引取值方便
  • 2:一次性的。只能往后走不能往前退
  • 3:无法获取长度

# for item in l: #i=l.__iter__()
#     print(item)

时间: 2024-07-30 23:55:46

python--有参装饰器、迭代器的相关文章

Python基础day-8[装饰器补充,迭代器(未完)]

wraps模块: 让函数保留原来的说明信息. 在闭包函数上面 @wraps 可以把原代码的解释,引用到装饰器中,让用户彻底无法感知装饰器的存在 使用 func.__doc__ 和 print(help(func))来查看函数的注释信息 from functools import wraps import time def coutime(func): @wraps(func) #调用wraps模块 def wrapper(*args,**kwargs): # 'a1231231231231232

python函数、装饰器、迭代器、生成器

5月21日,请假结婚,然后性格惰性来了,不怎么想看视频和笔记,性格中的弱点开始出现,开始做的不错,渐渐开始松懈,直至放弃--- 函数补充进阶 函数对象 函数的嵌套 名称空间与作用域 闭包函数 函数之装饰器 函数之迭代器 函数之生成器 内置函数 一.函数补充进阶 1.函数对象:  函数是第一类对象,即函数可以当作数据传递,它的应用形式也被称为高阶函数,函数的特性如下: a. 可以被引用 1 # def foo(): 2 # print('from foo') 3 # 4 # func = foo

python中的无参装饰器和有参装饰器

python中的无参装饰器和有参装饰器 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 装饰器特点: 1>.开放封闭原则,即对扩展是开放的,对修改时封闭的: 2>.装饰器本质可以是任意可调用的对象,被装饰的对象也可以是任意可调用对象: 3>.装饰器的功能是在不修改被装饰器对象源代码以及被装饰器对象的调用方式的前提下为其扩展新功能: 4>.装饰器本质是函数,(即装饰其他函数)就是为其他函数添加附加功能. 一.典型装饰器案例 1 #!/usr/bin/env pyth

python基础学习-有参装饰器

一.有参装饰器: 1.知识储备 由于语法糖@的限制,outter函数只能有一个参数,并且该才是只用来接收被装饰对象的内存地址 def outter(func): ? #func = 函数的内存地址 ? def wrapper(*args,**kwargs): res=func(*args,**kwargs) return res return wrapper ? @outter # index=outter(index) # index=>wrapper @outter # outter(ind

Day4 装饰器——迭代器——生成器

一 装饰器 1.1 函数对象 一 函数是第一类对象,即函数可以当作数据传递 #1 可以被引用 #2 可以当作参数传递 #3 返回值可以是函数 #3 可以当作容器类型的元素 二 利用该特性,优雅的取代多分支的if def foo(): print('foo') def bar(): print('bar') dic={ 'foo':foo, 'bar':bar, } while True: choice=input('>>: ').strip() if choice in dic: dic[ch

python_day04 函数嵌套 名称空间和作用域 闭包 装饰器 迭代器 生成器 列表解析 三元表达式 生成器表达式

本节课重要知识点内容如下: 函数嵌套 名称空间和作用域 闭包 装饰器 迭代器 生成器 列表解析 三元表达式 生成器表达式 1.函数嵌套 函数的嵌套调用:在调用一个函数的过程中,又调用了其他函数函数的嵌套定义:在一个函数的内部,又定义另外一个函数 def bar(): print('from nbar')def foo(): print('from foo') bar()foo()def max2(x,y): if x > y: return x else: return ydef max4(a,

python_装饰器——迭代器——生成器

一.装饰器 1.什么是装饰器? 器=>工具,装饰=>增加功能 1.不修改源代码 2.不修改调用方式 装饰器是在遵循1和2原则的基础上为被装饰对象增加功能的工具 2.实现无参装饰器 1.无参装饰器的模板 def outter(func): def wrapper(*args,**kwargs): res=func(*args,**kwargs) return res return wrapper 2.使用:在被装饰对象正上方单独一行 @无参装饰器名 def foo(): pass 3.实现有参装

函数嵌套 ,名称空间与作用域 ,闭包函数 ,装饰器 ,迭代器, 生成器 三元表达式,列表解析,生成器表达式 递归与二分法, 内置函数

函数嵌套名称空间与作用域闭包函数装饰器迭代器生成器三元表达式,列表解析,生成器表达式递归与二分法内置函数--------------------------------------------函数的嵌套调用:在调用一个函数的过程中,又调用了其他函数函数的嵌套定义:在一个函数的内部,又定义另外一个函数def max(x,y): if x>y: return x else: return ydef max1(a,b,c,d): res=max(a,b) res2=max(res,c) res3=ma

Python之路-装饰器

一.装饰器前置知识要点 1.名称空间 存放名字与变量绑定关系的地方 名称空间的分类: 内置名称空间:Python解释器启动时,存放自带的名字的地方.(比如内置函数) 全局名称空间:在执行文件时,文件级别名字存放的地方 局部名称空间:在执行文件过程中,如果调用函数,用来存放函数内定名称的地方,调用时生效,调用结束后失效 加载顺序:内置-------->全局---------->局部 查找顺序:局部-------->全局---------->内置 2.作用域 作用域:作用的范围 (1)