参数为Python装饰

Question

因此具有以下...

def makeBold(fn): 
     def wrapped(): 
      return '<b>'+fn()+'</b>' 
     return wrapped 

    @makeBold 
    def produceElement(): 
     return 'hello' 

结果是

<b>hello</b> 

我愿做这样的事情......

@makeBold(attrib=val, attrib=val) 
    def produceElement(): 
     return 'hello' 

和有结果就像...

<b attrib=val, attrib=val>hello<b/> 

任何建议将是伟大的！

Answer 1

与其他功能总结你的函数：

import functools 
def makeBold(**kwargs): 
    attribstrings = str(kwargs) # figure out what to do with the dict yourself 
    def actualdecorator(fn): 
     @functools.wraps(fn) 
     def wrapped(): 
      return '<b'+attribstrings+'>'+fn()+'</b>' 
     return wrapped 
    return actualdecorator 

我离开工作了如何构建字符串作为练习留给读者。

请注意，装饰器表达式的结构是@ <callable object of one parameter, w> <declaration of callable object, f>。它的效果是f = w(f)。相应地，w（装饰者）必须返回与f相同类型的可召唤物品。

在@makebold(foo)def bar(x):pass，表达makebold(foo)是装饰 - 也就是说，装饰的最终效果是bar = makebold(foo)(bar)，等等bar结束保持wrapped。

functools.wraps的目的是修复装饰函数的属性，以便将元数据（如name和docstring）从参数函数复制到包装函数，以便整个包装过程是透明的。

Answer 2

为了做这样的事情，你需要一个返回装饰函数的函数。因此，在这种情况下（假设你要接受任意属性），你会写

def format_attribs(kwargs): 
    """Properly formats HTML attributes from a dictionary""" 
    return ' '.join('{}="{}"'.format(key, val) for key,val in kwargs.iteritems()) 

def makeBold(**kwargs): 
    attribs = format_attribs(kwargs) 
    def _makeBold(fn): 
     def wrapped(): 
      return '<b ' + attribs + '>' + fn() + '</b>' 
     return wrapped 
    return _makeBold 

为了使这个makeBold功能多一点一般情况下，你要通过传递参数给fn并保持其他信息，如使用functools.wraps函数名称：

import functools 
def makeBold(**kwargs): 
    attribs = format_attribs(kwargs) 
    def _makeBold(fn): 
     @wraps(fn) 
     def wrapped(*args, **kwargs): 
      return '<b ' + attribs + '>' + fn(*args, **kwargs) + '</b>' 
     return wrapped 
    return _makeBold 

Answer 3

我也许怀疑这是一个很好的使用案例装饰，但这里：

import string 

SelfClosing = object() 

def escapeAttr(attr): 
    # WARNING: example only, security not guaranteed for any of these functions 
    return attr.replace('"', '\\"') 

def tag(name, content='', **attributes): 
    # prepare attributes 
    for attr,value in attributes.items(): 
     assert all(c.isalnum() for c in attr) # probably want to check xml spec 
    attrString = ' '.join('{}="{}"'.format(k,escapeAttr(v)) for k,v in attributes.items()) 

    if not content==SelfClosing: 
     return '<{name} {attrs}>{content}</{name}>'.format(
      name = name, 
      attrs = attrString, 
      content = content 
     ) 
    else: # self-closing tag 
     return '<{name} {attrs}/>' 

实施例：

def makeBoldWrapper(**attributes): 
    def wrapWithBold(origFunc): 
     def composed(*args, **kw): 
      result = origFunc(*args, **kw) 
      postprocessed = tag('b', content=result, **attributes) 
      return postprocessed 
     return composed 
    return wrapWithBold 

演示：

@makeBoldWrapper(attr1='1', attr2='2') 
def helloWorld(text): 
    return text 

>>> print(helloWorld('Hello, world!')) 
<b attr2="2" attr1="1">Hello, world!</b> 

与装饰常见的误解是，参数(attr1=...)是参数给装饰@myDecorator;事实并非如此。函数调用myDecoratorFactory(attr1=...)的结果计算为someresult，并成为匿名装饰器@someresult。因此'带有参数的装饰器'实际上是装饰器工厂，它需要返回一个装饰器作为一个值。