Atribut fungsi Python - menggunakan dan menyalahgunakan [ditutup]

Tidak banyak yang mengetahui fitur ini, tetapi fungsi (dan metode) Python dapat memiliki atribut . Melihat:

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

Apa kegunaan dan penyalahgunaan yang mungkin dari fitur ini di Python? Satu kegunaan yang baik yang saya ketahui adalah penggunaan dokumen oleh PLY untuk mengaitkan aturan sintaksis dengan suatu metode. Tetapi bagaimana dengan atribut khusus? Apakah ada alasan bagus untuk menggunakannya?

Saya biasanya menggunakan atribut fungsi sebagai penyimpanan untuk anotasi. Misalkan saya ingin menulis, dengan gaya C # (menunjukkan bahwa metode tertentu harus menjadi bagian dari antarmuka layanan web)

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

maka saya bisa mendefinisikan

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

Kemudian, ketika panggilan layanan web tiba, saya mencari metode, memeriksa apakah fungsi yang mendasari memiliki atribut is_webmethod (nilai sebenarnya tidak relevan), dan menolak layanan jika metode tersebut tidak ada atau tidak dimaksudkan untuk dipanggil melalui web.

Saya telah menggunakannya sebagai variabel statis untuk suatu fungsi. Misalnya, diberi kode C berikut:

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

Saya dapat mengimplementasikan fungsi serupa di Python:

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

Ini pasti akan jatuh ke ujung "penyalahgunaan" spektrum.

Anda dapat melakukan objek dengan cara JavaScript ... Tidak masuk akal tetapi berfungsi;)

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

Saya menggunakannya dengan hemat, tetapi mereka bisa sangat nyaman:

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

Sekarang saya dapat menggunakan logseluruh modul saya, dan mengarahkan ulang output hanya dengan mengatur log.logfile. Ada banyak dan banyak cara lain untuk mencapai itu, tetapi yang ini ringan dan sederhana. Dan walaupun baunya lucu ketika pertama kali melakukannya, saya mulai percaya bahwa baunya lebih enak daripada memiliki logfilevariabel global .

Atribut fungsi dapat digunakan untuk menulis penutupan ringan yang membungkus kode dan data terkait:

#!/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

Saya telah membuat dekorator pembantu ini untuk dengan mudah mengatur atribut fungsi:

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

Use case adalah untuk membuat kumpulan pabrik dan menanyakan tipe data yang dapat mereka buat pada tingkat meta fungsi.
Misalnya (sangat bodoh):

@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

Terkadang saya menggunakan atribut fungsi untuk caching nilai yang sudah dihitung. Anda juga dapat memiliki dekorator generik yang menggeneralisasikan pendekatan ini. Waspadai masalah konkurensi dan efek samping dari fungsi-fungsi tersebut!

Saya selalu berasumsi bahwa satu-satunya alasan ini mungkin adalah karena itu ada tempat yang logis untuk meletakkan doc-string atau hal-hal semacam itu. Saya tahu jika saya menggunakannya untuk kode produksi apa pun itu akan membingungkan kebanyakan orang yang membacanya.