`staticmethod` e` abc.abstractmethod`: si fonderanno?

Nella mia app Python voglio creare un metodo che sia sia un staticmethodche un abc.abstractmethod. Come faccio a fare questo?

Ho provato ad applicare entrambi i decoratori, ma non funziona. Se lo faccio:

import abc

class C(object):
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    @staticmethod    
    def my_function(): pass

Ottengo un'eccezione * e se lo faccio:

class C(object):
    __metaclass__ = abc.ABCMeta

    @staticmethod    
    @abc.abstractmethod
    def my_function(): pass

Il metodo astratto non viene applicato.

Come posso creare un metodo statico astratto?

*L'eccezione:

File "c:\Python26\Lib\abc.py", line 29, in abstractmethod
 funcobj.__isabstractmethod__ = True
AttributeError: 'staticmethod' object has no attribute '__isabstractmethod__'

class abstractstatic(staticmethod):
    __slots__ = ()
    def __init__(self, function):
        super(abstractstatic, self).__init__(function)
        function.__isabstractmethod__ = True
    __isabstractmethod__ = True

class A(object):
    __metaclass__ = abc.ABCMeta
    @abstractstatic
    def test():
        print 5

A partire da Python 3.3 , è possibile combinare @staticmethod e @abstractmethod, quindi nessuno degli altri suggerimenti è più necessario:

@staticmethod
@abstractmethod
def my_abstract_staticmethod(...):

Questo lo farà:

  >>> import abc
  >>> abstractstaticmethod = abc.abstractmethod
  >>>
  >>> class A(object):
  ...     __metaclass__ = abc.ABCMeta
  ...     @abstractstaticmethod
  ...     def themethod():
  ...          pass
  ... 
  >>> a = A()
  >>> Traceback (most recent call last):
  File "asm.py", line 16, in <module>
    a = A()
  TypeError: Can't instantiate abstract class A with abstract methods test

Vai "Eh? Rinomina solo @abstractmethod", e questo è completamente corretto. Perché qualsiasi sottoclasse di quanto sopra dovrà includere comunque il decoratore @staticmethod. Non ne hai bisogno qui, tranne come documentazione durante la lettura del codice. Una sottoclasse dovrebbe essere simile a questa:

  >>> class B(A):
  ...     @staticmethod
  ...     def themethod():
  ...         print "Do whatevs"

Per avere una funzione che ti costringa a rendere questo metodo un metodo statico dovresti sottoclassare ABCmeta per verificarlo e applicarlo. È un sacco di lavoro senza un vero ritorno. (Se qualcuno dimentica il decoratore @staticmethod riceverà comunque un chiaro errore, semplicemente non menzionerà i metodi statici.

Quindi in effetti funziona altrettanto bene:

  >>> import abc
  >>>
  >>> class A(object):
  ...     __metaclass__ = abc.ABCMeta
  ...     @abc.abstractmethod
  ...     def themethod():
  ...         """Subclasses must implement this as a @staticmethod"""
  ...          pass

Aggiornamento - Un altro modo per spiegarlo:

Il fatto che un metodo sia statico controlla come viene chiamato. Un metodo astratto non viene mai chiamato. E il metodo statico astratto è quindi un concetto piuttosto inutile, tranne che per scopi di documentazione.

Questo non è attualmente possibile in Python 2.X, che imporrà solo che il metodo sia astratto o statico, ma non entrambi.

In Python 3.2+, i nuovi decoratori abc.abstractclassmethodeabc.abstractstaticmethod sono stati aggiunti per combinare la loro applicazione di essere astratti e statici o astratti e un metodo di classe.

Vedi Python Issue 5867