อะไรคือการใช้งานทั่วไปสำหรับผู้ตกแต่ง Python [ปิด]

ในขณะที่ฉันชอบคิดว่าตัวเองเป็น coder Python ที่มีความสามารถพอสมควร แต่อีกด้านหนึ่งของภาษาที่ฉันไม่เคยคิดเลยก็คือนักตกแต่ง

ฉันรู้ว่าพวกเขาคืออะไร (เผินๆ) ฉันได้อ่านบทช่วยสอนตัวอย่างคำถามเกี่ยวกับ Stack Overflow และฉันเข้าใจไวยากรณ์สามารถเขียนของตัวเองได้บางครั้งใช้ @classmethod และ @staticmethod แต่ฉันไม่เคยใช้ มัณฑนากรเพื่อแก้ปัญหาในรหัส Python ของฉันเอง ฉันไม่เคยเจอปัญหาที่ฉันคิดว่า "อืม ... นี่มันดูเหมือนงานสำหรับมัณฑนากร!"

ดังนั้นฉันจึงสงสัยว่าพวกคุณจะเสนอตัวอย่างที่คุณใช้ตกแต่งภายในในโปรแกรมของคุณเองหรือไม่และหวังว่าฉันจะมี "A-ha!" ช่วงเวลาและรับพวกเขา

ฉันใช้มัณฑนากรเป็นหลักในการกำหนดเวลา

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

ฉันใช้มันเพื่อการซิงโครไนซ์

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

ตามที่ระบุไว้ในความคิดเห็นตั้งแต่ Python 2.5 คุณสามารถใช้withคำสั่งร่วมกับวัตถุ threading.Lock(หรือmultiprocessing.Lockตั้งแต่รุ่น 2.6) เพื่อทำให้การใช้งานของ decorator ง่ายขึ้นเพียง:

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

ไม่ว่าคุณจะใช้มันในลักษณะนี้:

import threading
lock = threading.Lock()

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

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

โดยพื้นฐานแล้วมันแค่วางlock.acquire()/ lock.release()ที่ทั้งสองด้านของการเรียกใช้ฟังก์ชัน

ฉันใช้มัณฑนากรเพื่อตรวจสอบค่าพารามิเตอร์ซึ่งส่งผ่านไปยังวิธี Python ผ่าน RMI ดังนั้นแทนที่จะทำซ้ำการนับพารามิเตอร์เดียวกันซ้ำซาก mumbo-jumbo อีกครั้งและอีกครั้ง

ตัวอย่างเช่นแทนที่จะเป็น:

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

ฉันเพิ่งประกาศ:

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

และaccepts()ทำงานทั้งหมดให้ฉัน

มัณฑนากรใช้สำหรับทุกสิ่งที่คุณต้องการ "ตัด" อย่างโปร่งใสด้วยฟังก์ชันเพิ่มเติม

Django ใช้เพื่อห่อฟังก์ชั่น "จำเป็นต้องเข้าสู่ระบบ" ในฟังก์ชั่นการดูเช่นเดียวกับการลงทะเบียนฟังก์ชั่นตัวกรองลงทะเบียนฟังก์ชั่นกรอง

คุณสามารถใช้ตัวตกแต่งคลาสเพื่อเพิ่มบันทึกที่มีชื่อในคลาสการเพิ่มบันทึกชื่อในชั้นเรียน

ฟังก์ชั่นทั่วไปที่เพียงพอที่คุณสามารถ "ยึดติด" กับคลาสที่มีอยู่หรือพฤติกรรมของฟังก์ชั่นเป็นเกมที่ยุติธรรมสำหรับการตกแต่ง

นอกจากนี้ยังมีการอภิปรายของกรณีการใช้งานในกลุ่มข่าวสารหลาม-Devชี้ไปตามPEP 318 - ตกแต่งสำหรับฟังก์ชั่นและวิธีการ

สำหรับ nosetests คุณสามารถเขียนมัณฑนากรที่จัดหาฟังก์ชั่นการทดสอบหน่วยหรือวิธีการที่มีพารามิเตอร์หลายชุด:

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

ห้องสมุด Twisted ใช้มัณฑนากรรวมกับเครื่องกำเนิดไฟฟ้าเพื่อให้ภาพลวงตาว่าฟังก์ชั่นอะซิงโครนัสเป็นแบบซิงโครนัส ตัวอย่างเช่น:

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

เมื่อใช้สิ่งนี้โค้ดที่จะถูกแบ่งออกเป็นฟังก์ชั่นการโทรกลับจำนวนเล็กน้อยสามารถเขียนได้ค่อนข้างเป็นธรรมชาติในบล็อกเดียวทำให้ง่ายต่อการเข้าใจและบำรุงรักษา

การใช้งานที่ชัดเจนอย่างหนึ่งสำหรับการบันทึกคือ:

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

ฉันใช้พวกเขาเป็นหลักสำหรับการแก้ไขข้อบกพร่อง (wrapper รอบฟังก์ชั่นที่พิมพ์ข้อโต้แย้งและผลของมัน) และการตรวจสอบ (เช่นเพื่อตรวจสอบว่าอาร์กิวเมนต์เป็นประเภทที่ถูกต้องหรือในกรณีของเว็บแอปพลิเคชันถ้าผู้ใช้มีสิทธิ์เพียงพอ วิธี).

ฉันใช้มัณฑนากรต่อไปนี้เพื่อสร้างฟังก์ชัน threadsafe ทำให้โค้ดอ่านง่ายขึ้น มันเกือบจะคล้ายกับที่เสนอโดย John Fouhy แต่ความแตกต่างคือการทำงานในฟังก์ชั่นเดียวและไม่จำเป็นต้องสร้างวัตถุล็อคอย่างชัดเจน

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

มัณฑนากรถูกนำมาใช้เพื่อกำหนดคุณสมบัติของฟังก์ชั่นหรือเป็นสำเร็จรูปที่เปลี่ยนแปลงมัน; เป็นไปได้ แต่ตอบโต้ง่ายสำหรับพวกเขาที่จะกลับมาทำงานที่แตกต่างอย่างสิ้นเชิง ดูคำตอบอื่น ๆ ที่นี่ดูเหมือนว่าหนึ่งในการใช้งานที่พบบ่อยที่สุดคือการ จำกัด ขอบเขตของกระบวนการอื่น ๆ ไม่ว่าจะเป็นการบันทึกการทำโปรไฟล์การตรวจสอบความปลอดภัย ฯลฯ

CherryPy ใช้การส่งวัตถุเพื่อจับคู่ URL กับวัตถุและในที่สุดวิธีการ ผู้ตกแต่งในวิธีการเหล่านั้นส่งสัญญาณว่า CherryPy ได้รับอนุญาตให้ใช้วิธีการเหล่านั้นได้หรือไม่ ตัวอย่างเช่นดัดแปลงมาจากบทช่วยสอน :

class HelloWorld:

    ...

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

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

cherrypy.quickstart(HelloWorld())

ฉันใช้มันเมื่อเร็ว ๆ นี้ในขณะที่ทำงานกับเว็บแอปพลิเคชันเครือข่ายสังคม สำหรับชุมชน / กลุ่มฉันควรให้สิทธิ์การเป็นสมาชิกเพื่อสร้างการสนทนาใหม่และตอบกลับข้อความที่คุณต้องเป็นสมาชิกของกลุ่มนั้น ดังนั้นฉันจึงเขียนมัณฑนากร@membership_requiredและวางสิ่งที่ฉันต้องการในมุมมองของฉัน

ฉันใช้มัณฑนากรนี้เพื่อแก้ไขพารามิเตอร์

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

สิ่งนี้เขียนเมื่อฉัน refactor ฟังก์ชั่นบางอย่างจำเป็นต้องผ่านการโต้แย้ง "wanN" แต่ในรหัสเก่าของฉันฉันผ่าน N หรือ 'N' เท่านั้น

มัณฑนากรสามารถใช้สร้างตัวแปรวิธีการทำงานได้อย่างง่ายดาย

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