Jakie są typowe zastosowania dekoratorów Python? [Zamknięte]

Chociaż lubię myśleć o sobie jako o dość kompetentnym kodzie Pythona, jednym z aspektów języka, którego nigdy nie byłem w stanie zrozumieć, są dekoratorzy.

Wiem, czym one są (powierzchownie), przeczytałem samouczki, przykłady, pytania na temat przepełnienia stosu i rozumiem składnię, mogę pisać własne, czasami używam @classmethod i @staticmethod, ale nigdy nie przychodzi mi do głowy, aby użyć dekorator, aby rozwiązać problem we własnym kodzie Python. Nigdy nie spotykam problemu, w którym myślę: „Hmm… to wygląda jak praca dla dekoratora!”

Zastanawiam się, czy moglibyście podać przykłady zastosowania dekoratorów we własnych programach i mam nadzieję, że będę miał „A-ha!” chwila i zdobądź je.

Używam dekoratorów głównie do pomiaru czasu

def time_dec(func):

  def wrapper(*arg):
      t = time.clock()
      res = func(*arg)
      print func.func_name, time.clock()-t
      return res

  return wrapper


@time_dec
def myFunction(n):
    ...

Użyłem ich do synchronizacji.

import functools

def synchronized(lock):
    """ Synchronization decorator """
    def wrap(f):
        @functools.wraps(f)
        def newFunction(*args, **kw):
            lock.acquire()
            try:
                return f(*args, **kw)
            finally:
                lock.release()
        return newFunction
    return wrap

Jak wskazano w komentarzach, od Python 2.5 można używać withinstrukcji w połączeniu z threading.Lock (lub multiprocessing.Lockod wersji 2.6), aby uprościć implementację dekoratora do:

import functools

def synchronized(lock):
    """ Synchronization decorator """
    def wrap(f):
        @functools.wraps(f)
        def newFunction(*args, **kw):
            with lock:
                return f(*args, **kw)
        return newFunction
    return wrap

Niezależnie od tego używasz go w następujący sposób:

import threading
lock = threading.Lock()

@synchronized(lock)
def do_something():
  # etc

@synchronzied(lock)
def do_something_else():
  # etc

Zasadniczo po prostu umieszcza lock.acquire()/ lock.release()po obu stronach wywołania funkcji.

Korzystam z dekoratorów do sprawdzania parametrów, które są przekazywane do moich metod Python za pośrednictwem niektórych RMI. Zamiast więc powtarzać liczenie tego samego parametru, mumbo-jumbo podnoszące wyjątki raz po raz.

Na przykład zamiast:

def myMethod(ID, name):
    if not (myIsType(ID, 'uint') and myIsType(name, 'utf8string')):
        raise BlaBlaException() ...

Po prostu deklaruję:

@accepts(uint, utf8string)
def myMethod(ID, name):
    ...

i accepts()wykonuje całą pracę dla mnie.

Dekoratory służą do wszystkiego, co chcesz transparentnie „zawinąć” z dodatkową funkcjonalnością.

Django używa ich do pakowania funkcji „wymagane logowanie” do funkcji przeglądania , a także do rejestrowania funkcji filtrów .

Do dodawania nazwanych dzienników do klas można użyć dekoratorów klas .

Każda wystarczająco ogólna funkcjonalność, którą można „przyczepić” do istniejącego zachowania klasy lub funkcji, jest uczciwą grą dla dekoracji.

W grupie dyskusyjnej Python-Dev omawia się także przypadki użycia, na które wskazuje PEP 318 - Dekoratorzy funkcji i metod .

W przypadku testów nosa możesz napisać dekorator, który udostępnia funkcję lub metodę testu jednostkowego z kilkoma zestawami parametrów:

@parameters(
   (2, 4, 6),
   (5, 6, 11),
)
def test_add(a, b, expected):
    assert a + b == expected

Biblioteka Twisted używa dekoratorów w połączeniu z generatorami, aby dać złudzenie, że funkcja asynchroniczna jest synchroniczna. Na przykład:

@inlineCallbacks
def asyncf():
    doStuff()
    yield someAsynchronousCall()
    doStuff()
    yield someAsynchronousCall()
    doStuff()

Korzystając z tego, kod, który zostałby rozbity na mnóstwo małych funkcji zwrotnych, można napisać całkiem naturalnie jako pojedynczy blok, co znacznie ułatwia jego zrozumienie i utrzymanie.

Jednym z oczywistych zastosowań jest oczywiście logowanie:

import functools

def log(logger, level='info'):
    def log_decorator(fn):
        @functools.wraps(fn)
        def wrapper(*a, **kwa):
            getattr(logger, level)(fn.__name__)
            return fn(*a, **kwa)
        return wrapper
    return log_decorator

# later that day ...
@log(logging.getLogger('main'), level='warning')
def potentially_dangerous_function(times):
    for _ in xrange(times): rockets.get_rocket(NUCLEAR=True).fire()

Używam ich głównie do debugowania (owijania wokół funkcji, która wypisuje jej argumenty i wyniki) i weryfikacji (np. Do sprawdzania, czy argument jest poprawnego typu lub, w przypadku aplikacji internetowej, czy użytkownik ma wystarczające uprawnienia do wywołania określonego metoda).

Korzystam z następującego dekoratora do tworzenia funkcji wątkowo bezpiecznej. Dzięki temu kod jest bardziej czytelny. Jest prawie podobny do zaproponowanego przez Johna Fouhy, ale różnica polega na tym, że działa się na jednej funkcji i nie ma potrzeby jawnego tworzenia obiektu blokady.

def threadsafe_function(fn):
    """decorator making sure that the decorated function is thread safe"""
    lock = threading.Lock()
    def new(*args, **kwargs):
        lock.acquire()
        try:
            r = fn(*args, **kwargs)
        except Exception as e:
            raise e
        finally:
            lock.release()
        return r
    return new

class X:
    var = 0

    @threadsafe_function     
    def inc_var(self):
        X.var += 1    
        return X.var

Dekoratory są używane albo do zdefiniowania właściwości funkcji, albo jako płyta zmieniająca ją; jest możliwe, ale sprzeczne z intuicją, aby zwracały zupełnie inne funkcje. Patrząc na inne odpowiedzi tutaj, wydaje się, że jednym z najczęstszych zastosowań jest ograniczenie zakresu innego procesu - rejestrowania, profilowania, kontroli bezpieczeństwa itp.

CherryPy używa wysyłania obiektów, aby dopasować adresy URL do obiektów i, ostatecznie, metod. Dekoratorzy na tych metod sygnalizować czy CherryPy jest nawet dopuszczone do stosowania tych metod. Na przykład adaptacja z samouczka :

class HelloWorld:

    ...

    def secret(self):
        return "You shouldn't be here."

    @cherrypy.expose
    def index(self):
        return "Hello world!"

cherrypy.quickstart(HelloWorld())

Ostatnio ich używałem, pracując nad aplikacją sieci społecznościowych. W przypadku społeczności / grup miałem upoważnić członka do utworzenia nowej dyskusji i odpowiedzi na wiadomość, że musisz być członkiem tej konkretnej grupy. Napisałem dekoratora @membership_requiredi umieściłem go tam, gdzie tego wymagałem.

Używam tego dekoratora do naprawy parametru

def fill_it(arg):
    if isinstance(arg, int):
        return "wan" + str(arg)
    else:
        try:
            # number present as string
            if str(int(arg)) == arg:
                return "wan" + arg
            else:
                # This should never happened
                raise Exception("I dont know this " + arg)
                print "What arg?"
        except ValueError, e:
            return arg

def fill_wanname(func):
    def wrapper(arg):
        filled = fill_it(arg)
        return func(filled)
    return wrapper

@fill_wanname
def get_iface_of(wanname):
    global __iface_config__
    return __iface_config__[wanname]['iface']

to napisane, gdy refaktoryzuję, niektóre funkcje muszą przekazać argument „wanN”, ale w moich starych kodach przekazałem tylko N lub „N”

Dekorator może być używany do łatwego tworzenia zmiennych metod funkcji.

def static_var(varname, value):
    '''
    Decorator to create a static variable for the specified function
    @param varname: static variable name
    @param value: initial value for the variable
    '''
    def decorate(func):
        setattr(func, varname, value)
        return func
    return decorate

@static_var("count", 0)
def mainCallCount():
    mainCallCount.count += 1