Python işlevi nitelikleri - kullanır ve kötüye kullanır [kapalı]

Pek çoğu bu özelliğin farkında değildir, ancak Python'un işlevlerinin (ve yöntemlerinin) öznitelikleri olabilir . Seyretmek:

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

Python'da bu özelliğin olası kullanımları ve kötüye kullanımları nelerdir? Bildiğim biri iyi kullanımıdır kat bir yöntem bir sözdizimi kuralı ilişkilendirmek için docstringe arasında 'ın kullanımı. Peki ya özel özellikler? Bunları kullanmak için iyi nedenler var mı?

Ek açıklamalarda genellikle depolama alanı olarak işlev niteliklerini kullanırım. C # tarzında yazmak istediğimi varsayalım (belirli bir yöntemin web hizmeti arayüzünün bir parçası olması gerektiğini gösterir)

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

o zaman tanımlayabilirim

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

Daha sonra, bir webservis çağrısı geldiğinde, yönteme bakarım, temel fonksiyonun is_webmethod özniteliğine sahip olup olmadığını kontrol edin (gerçek değer alakasızdır) ve yöntem web üzerinden çağrılmayacak veya çağrılmayacaksa hizmeti reddeder.

Bunları bir işlev için statik değişkenler olarak kullandım. Örneğin, aşağıdaki C kodu verildiğinde:

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

Bu işlevi Python'da benzer şekilde uygulayabilirim:

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

Bu kesinlikle spektrumun "suistimalleri" sonuna düşecektir.

Nesneleri JavaScript yolu ile yapabilirsiniz ... Mantıklı değil ama işe yarıyor;)

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

Onları idareli kullanıyorum, ancak oldukça uygun olabilirler:

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

Şimdi modülüm logboyunca kullanabilir ve çıkışı ayarlayarak yönlendirebilirim log.logfile. Bunu başarmak için birçok yol var, ama bu hafif ve kir basit. İlk yaptığımda komik kokuyor olsa da, küresel bir logfiledeğişkene sahip olmaktan daha iyi koktuğuna inanmaya başladım .

İşlev öznitelikleri, kodu ve ilişkili verileri bir araya getiren hafif kapaklar yazmak için kullanılabilir:

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

İşlev yardımcılarını kolayca ayarlamak için bu yardımcı dekoratörü oluşturdum:

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

Kullanım durumu, bir fabrika koleksiyonu oluşturmak ve işlev meta düzeyinde oluşturabilecekleri veri türünü sorgulamaktır.
Örneğin (çok aptal olan):

@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

Bazen zaten hesaplanmış değerleri önbelleğe almak için bir işlev özniteliği kullanın. Bu yaklaşımı genelleştiren genel bir dekoratör de olabilir. Eşzamanlılık sorunlarının ve bu işlevlerin yan etkilerinin farkında olun!

Her zaman bunun mümkün olmasının tek nedeni, bir doc-string veya benzeri şeyler koymak için mantıklı bir yer olduğu varsayımıydım. Herhangi bir üretim kodu için kullandıysam, okuyanların çoğunun kafasını karıştıracağını biliyorum.