Apa kegunaan umum untuk dekorator Python? [Tutup]

Sementara saya suka menganggap diri saya sebagai pembuat kode Python yang cukup kompeten, salah satu aspek dari bahasa yang saya tidak pernah bisa grok adalah dekorator.

Saya tahu apa itu (secara dangkal), saya sudah membaca tutorial, contoh, pertanyaan tentang Stack Overflow, dan saya mengerti sintaksnya, bisa menulis sendiri, kadang-kadang menggunakan @classmethod dan @staticmethod, tetapi tidak pernah terpikir oleh saya untuk menggunakan dekorator untuk memecahkan masalah dalam kode Python saya sendiri. Saya tidak pernah menemukan masalah di mana saya berpikir, "Hmm ... ini terlihat seperti pekerjaan untuk dekorator!"

Jadi, saya bertanya-tanya apakah kalian mungkin menawarkan beberapa contoh di mana Anda telah menggunakan dekorator dalam program Anda sendiri, dan mudah-mudahan saya akan memiliki "A-ha!" saat dan mendapatkannya .

Saya menggunakan dekorator terutama untuk tujuan pengaturan waktu

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

Saya telah menggunakannya untuk sinkronisasi.

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

Seperti yang ditunjukkan dalam komentar, karena Python 2.5 Anda dapat menggunakan withpernyataan bersamaan dengan objek threading.Lock(atau multiprocessing.Locksejak versi 2.6) untuk menyederhanakan implementasi dekorator menjadi hanya:

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

Apapun, Anda kemudian menggunakannya seperti ini:

import threading
lock = threading.Lock()

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

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

Pada dasarnya itu hanya menempatkan lock.acquire()/ lock.release()di kedua sisi panggilan fungsi.

Saya menggunakan dekorator untuk memeriksa parameter yang diteruskan ke metode Python saya melalui beberapa RMI. Jadi alih-alih mengulangi penghitungan parameter yang sama, pengecualian-meningkatkan mumbo-jumbo lagi dan lagi.

Misalnya, alih-alih:

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

Saya hanya menyatakan:

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

dan accepts()melakukan semua pekerjaan untuk saya.

Dekorator digunakan untuk apa pun yang Anda ingin "bungkus" transparan dengan fungsionalitas tambahan.

Django menggunakannya untuk membungkus fungsionalitas "diperlukan masuk" pada fungsi tampilan , serta untuk mendaftarkan fungsi filter .

Anda bisa menggunakan dekorator kelas untuk menambahkan log bernama ke kelas .

Fungsionalitas generik apa pun yang dapat Anda "tempel" ke kelas yang ada atau perilaku fungsi adalah permainan yang adil untuk dekorasi.

Ada juga diskusi tentang kasus penggunaan pada newsgroup Python-Dev yang ditunjuk oleh PEP 318 - Dekorator untuk Fungsi dan Metode .

Untuk ujian ulang, Anda dapat menulis dekorator yang memasok fungsi atau metode uji unit dengan beberapa set parameter:

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

Perpustakaan Twisted menggunakan dekorator yang dikombinasikan dengan generator untuk memberikan ilusi bahwa fungsi asinkron bersifat sinkron. Sebagai contoh:

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

Dengan menggunakan ini, kode yang akan dipecah menjadi satu ton fungsi callback kecil dapat ditulis secara alami sebagai satu blok, sehingga jauh lebih mudah untuk dipahami dan dipelihara.

Satu penggunaan yang jelas adalah untuk logging, tentu saja:

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

Saya menggunakannya terutama untuk debugging (membungkus fungsi yang mencetak argumen dan hasilnya) dan verifikasi (misalnya untuk memeriksa apakah argumen adalah tipe yang benar atau, dalam kasus aplikasi web, jika pengguna memiliki hak yang cukup untuk memanggil tertentu metode).

Saya menggunakan dekorator berikut untuk membuat fungsi threadsafe. Itu membuat kode lebih mudah dibaca. Ini hampir mirip dengan yang diusulkan oleh John Fouhy tetapi perbedaannya adalah bahwa seseorang bekerja pada fungsi tunggal dan bahwa tidak perlu membuat objek kunci secara eksplisit.

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

Dekorator digunakan untuk mendefinisikan properti fungsi atau sebagai pelat yang mengubahnya; itu mungkin tetapi kontra-intuitif bagi mereka untuk mengembalikan fungsi yang sama sekali berbeda. Melihat respons lain di sini, sepertinya salah satu kegunaan yang paling umum adalah membatasi ruang lingkup beberapa proses lainnya - baik itu pencatatan, profil, pemeriksaan keamanan, dll.

CherryPy menggunakan pengiriman objek untuk mencocokkan URL dengan objek dan, akhirnya, metode. Dekorator pada metode-metode tersebut memberi sinyal apakah CherryPy bahkan diperbolehkan menggunakan metode tersebut. Misalnya, diadaptasi dari tutorial :

class HelloWorld:

    ...

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

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

cherrypy.quickstart(HelloWorld())

Saya menggunakannya baru-baru ini, ketika bekerja pada aplikasi web jejaring sosial. Untuk Komunitas / Grup, saya seharusnya memberikan otorisasi keanggotaan untuk membuat diskusi baru dan membalas pesan Anda harus menjadi anggota grup tersebut. Jadi, saya menulis dekorator @membership_requireddan meletakkannya di tempat yang saya inginkan dalam pandangan saya.

Saya menggunakan dekorator ini untuk memperbaiki parameter

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

ini ditulis ketika saya refactor beberapa fungsi perlu melewati argumen "ingin" tetapi dalam kode lama saya, saya melewati N atau 'N' saja

Dekorator dapat digunakan untuk dengan mudah membuat variabel metode fungsi.

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