Python dekoratörleri için bazı yaygın kullanımlar nelerdir? [kapalı]

Kendimi makul derecede yetkin bir Python kodlayıcı olarak düşünmek isterken, hiç bilmediğim dilin bir yönü dekoratörler.

Ne olduklarını biliyorum (yüzeysel olarak), Yığın Taşması ile ilgili öğreticiler, örnekler, sorular okudum ve sözdizimini anlıyorum, kendim yazabiliyorum, bazen @classmethod ve @staticmethod kullanıyorum, ama asla bir Dekoratör kendi Python kodumdaki bir sorunu çözmek için. Asla "Hmm ... bu bir dekoratör için bir iş gibi görünüyor!"

Bu yüzden, dekoratörleri kendi programlarınızda nerede kullandığınıza dair bazı örnekler sunup sunamayacağınızı merak ediyorum ve umarım bir "A-ha!" an ve almak onları.

Dekoratörleri çoğunlukla zamanlama amacıyla kullanıyorum

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):
    ...

Onları senkronizasyon için kullandım.

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

Yorumlarda belirtildiği gibi, Python 2.5'ten beri, dekoratörün uygulamasını basitleştirmek için withbir threading.Lock(veya multiprocessing.Lock2.6 sürümünden beri) nesnesiyle birlikte bir ifade kullanabilirsiniz :

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

Ne olursa olsun, o zaman böyle kullanın:

import threading
lock = threading.Lock()

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

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

Temelde sadece fonksiyon çağrısının her iki tarafına lock.acquire()/ koyar lock.release().

Bazı RMI aracılığıyla Python yöntemlerime geçirilen tip kontrol parametreleri için dekoratörler kullanıyorum. Bu nedenle, aynı parametre sayımını tekrarlamak yerine, istisna oluşturan mumbo-jumbo tekrar tekrar.

Örneğin:

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

Sadece beyan ederim:

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

ve accepts()tüm işleri benim için yapıyor.

Dekoratörler, ek işlevlerle şeffaf bir şekilde "sarmak" istediğiniz herhangi bir şey için kullanılır.

Django bunları görüntüleme işlevlerinde "oturum açma gerekli" işlevselliğini kaydırmak ve filtre işlevlerini kaydetmek için kullanır .

Sınıflara adlandırılmış günlükler eklemek için sınıf dekoratörleri kullanabilirsiniz .

Mevcut bir sınıfa veya işlevin davranışına "yapışabileceğiniz" yeterince genel işlevler, dekorasyon için adil bir oyundur.

PEPhon-Dev haber grubunda PEP 318 - Fonksiyonlar ve Yöntemler için Dekoratörler tarafından işaret edilen kullanım örneklerinin bir tartışması da var .

Nosetestler için, birkaç parametre setiyle birim test fonksiyonu veya yöntemi sağlayan bir dekoratör yazabilirsiniz:

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

Twisted kütüphanesi, eşzamansız bir işlevin eşzamanlı olduğu yanılsamasını vermek için jeneratörlerle birlikte dekoratörleri kullanır. Örneğin:

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

Bunu kullanarak, bir ton küçük geri arama fonksiyonuna bölünmüş olan kod, doğal olarak tek bir blok olarak yazılabilir, bu da anlaşılmasını ve bakımını kolaylaştırır.

Bariz bir kullanım elbette günlüğe kaydetme içindir:

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()

Bunları çoğunlukla hata ayıklama (argümanlarını ve sonucunu yazdıran bir fonksiyonun etrafındaki sarmalayıcı) ve doğrulama (örneğin, bir argümanın doğru tipte olup olmadığını kontrol etmek için veya web uygulaması durumunda, kullanıcının belirli bir numarayı aramak için yeterli ayrıcalığa sahip olup olmadığını kontrol etmek için kullanıyorum. yöntem).

Bir iş parçacığı güvenli yapmak için aşağıdaki dekoratör kullanıyorum. Kodu daha okunaklı hale getirir. John Fouhy tarafından önerilene neredeyse benzer, ancak fark, tek bir işlev üzerinde çalışmak ve açık bir şekilde bir kilit nesnesi oluşturmaya gerek olmamasıdır.

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

Dekoratörler ya bir işlevin özelliklerini tanımlamak için ya da onu değiştiren ortak plaka olarak kullanılır; tamamen farklı fonksiyonları geri getirmeleri mümkün ancak karşı sezgiseldir. Buradaki diğer yanıtlara bakıldığında, en yaygın kullanımlardan biri, günlüğe kaydetme, profil oluşturma, güvenlik kontrolleri vb.Gibi diğer bazı işlemlerin kapsamını sınırlamak gibi görünüyor.

CherryPy, URL'leri nesnelerle ve sonunda yöntemlerle eşleştirmek için nesne dağıtımı kullanır. Bu yöntemler üzerindeki dekoratörler CherryPy'nin bu yöntemleri kullanmasına izin verilip verilmediğini gösterir. Örneğin , öğreticiden uyarlanmıştır :

class HelloWorld:

    ...

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

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

cherrypy.quickstart(HelloWorld())

Sosyal ağ web uygulaması üzerinde çalışırken son zamanlarda kullandım. Topluluk / Gruplar için, yeni tartışma oluşturmak ve o grubun üyesi olmanız gereken bir mesajı yanıtlamak için üyelik yetkisi vermem gerekiyordu. Böylece, bir dekoratör yazdım @membership_requiredve bence gerekli olan yere koydum.

Bu dekoratörü parametreyi düzeltmek için kullanıyorum

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']

Bu, bazı fonksiyonların "wanN" argümanını geçmesi gerektiğinde yeniden yazdığımda yazdı, ancak eski kodlarımda sadece N veya 'N' yi geçtim

Dekoratör, işlev yöntemi değişkenlerini kolayca oluşturmak için kullanılabilir.

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