Атрибути функції Python - використання та зловживання [закрито]

Не багато хто знає про цю особливість, але функції (та методи) Python можуть мати атрибути . Ось:

>>> def foo(x):
...     pass
...     
>>> foo.score = 10
>>> dir(foo)
['__call__', '__class__', '__delattr__', '__dict__', '__doc__', '__get__', '__getattribute__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name', 'score']
>>> foo.score
10
>>> foo.score += 1
>>> foo.score
11

Які можливі способи використання та зловживання цією функцією в Python? Мені добре відомо, що PLY використовує docstring для асоціації синтаксичного правила з методом. А як щодо користувацьких атрибутів? Чи є вагомі причини використовувати їх?

Зазвичай я використовую атрибути функції як сховище для анотацій. Припустимо, я хочу писати у стилі C # (із зазначенням, що певний метод повинен бути частиною інтерфейсу веб-сервісу)

class Foo(WebService):
    @webmethod
    def bar(self, arg1, arg2):
         ...

то я можу визначити

def webmethod(func):
    func.is_webmethod = True
    return func

Потім, коли надходить виклик веб-сервісу, я шукаю метод, перевіряю, чи є в базовій функції атрибут is_webmethod (фактичне значення не має значення), і відмовляюся від послуги, якщо метод відсутній або не призначений для виклику через Інтернет.

Я використовував їх як статичні змінні для функції. Наприклад, наведений наступний код C:

int fn(int i)
{
    static f = 1;
    f += i;
    return f;
}

Я можу реалізувати функцію аналогічно в Python:

def fn(i):
    fn.f += i
    return fn.f
fn.f = 1

Це, безумовно, потрапить у кінець спектру "зловживань".

Ви можете робити об’єкти способом JavaScript ... Не має сенсу, але він працює;)

>>> def FakeObject():
...   def test():
...     print "foo"
...   FakeObject.test = test
...   return FakeObject
>>> x = FakeObject()
>>> x.test()
foo

Я використовую їх економно, але вони можуть бути досить зручними:

def log(msg):
   log.logfile.write(msg)

Тепер я можу використовувати logвесь модуль і перенаправляти вихід просто, встановивши log.logfile. Існує безліч інших способів досягти цього, але легкий і бруд цей простий. І хоча це було смішно пахне, коли я це зробив, я вважаю, що він пахне краще, ніж глобальна logfileзмінна.

Атрибути функції можуть бути використані для запису невеликих закриттів, які обгортають код та пов'язані з ними дані:

#!/usr/bin/env python

SW_DELTA = 0
SW_MARK  = 1
SW_BASE  = 2

def stopwatch():
   import time

   def _sw( action = SW_DELTA ):

      if action == SW_DELTA:
         return time.time() - _sw._time

      elif action == SW_MARK:
         _sw._time = time.time()
         return _sw._time

      elif action == SW_BASE:
         return _sw._time

      else:
         raise NotImplementedError

   _sw._time = time.time() # time of creation

   return _sw

# test code
sw=stopwatch()
sw2=stopwatch()
import os
os.system("sleep 1")
print sw() # defaults to "SW_DELTA"
sw( SW_MARK )
os.system("sleep 2")
print sw()
print sw2()

1.00934004784

2.00644397736

3.01593494415

Я створив цей помічник декоратора, щоб легко встановити атрибути функції:

def with_attrs(**func_attrs):
    """Set attributes in the decorated function, at definition time.
    Only accepts keyword arguments.
    E.g.:
        @with_attrs(counter=0, something='boing')
        def count_it():
            count_it.counter += 1
        print count_it.counter
        print count_it.something
        # Out:
        # >>> 0
        # >>> 'boing'
    """
    def attr_decorator(fn):
        @wraps(fn)
        def wrapper(*args, **kwargs):
            return fn(*args, **kwargs)

        for attr, value in func_attrs.iteritems():
            setattr(wrapper, attr, value)

        return wrapper

    return attr_decorator

Випадок використання - створити колекцію заводів і запитувати тип даних, який вони можуть створювати на мета-рівні функції.
Наприклад (дуже німий):

@with_attrs(datatype=list)
def factory1():
    return [1, 2, 3]

@with_attrs(datatype=SomeClass)
def factory2():
    return SomeClass()

factories = [factory1, factory2]

def create(datatype):
    for f in factories:
        if f.datatype == datatype:
            return f()
    return None

Іноді я використовую атрибут функції для кешування вже обчислених значень. Ви також можете мати загальний декоратор, який узагальнює такий підхід. Будьте в курсі проблем одночасності та побічних ефектів таких функцій!

Я завжди був припущенням, що єдиною причиною цього було можливо, тому було логічним місцем розмістити doc-string або інші подібні речі. Я знаю, якби я використовував його для будь-якого виробничого коду, він бентежить більшість тих, хто читає його.