Initialiser automatiquement les variables d'instance ?

Question

J'ai une classe python qui ressemble à ceci :

class Process:
    def __init__(self, PID, PPID, cmd, FDs, reachable, user):

suivi par :

        self.PID=PID
        self.PPID=PPID
        self.cmd=cmd
        ...

Existe-t-il un moyen d'auto-initialiser ces variables d'instance, comme la liste d'initialisation du C++ ? Cela permettrait d'éviter beaucoup de code redondant.

Answer 1

Vous pouvez utiliser un décorateur :

from functools import wraps
import inspect

def initializer(func):
    """
    Automatically assigns the parameters.

    >>> class process:
    ...     @initializer
    ...     def __init__(self, cmd, reachable=False, user='root'):
    ...         pass
    >>> p = process('halt', True)
    >>> p.cmd, p.reachable, p.user
    ('halt', True, 'root')
    """
    names, varargs, keywords, defaults = inspect.getargspec(func)

    @wraps(func)
    def wrapper(self, *args, **kargs):
        for name, arg in list(zip(names[1:], args)) + list(kargs.items()):
            setattr(self, name, arg)

        for name, default in zip(reversed(names), reversed(defaults)):
            if not hasattr(self, name):
                setattr(self, name, default)

        func(self, *args, **kargs)

    return wrapper

Utilisez-le pour décorer le __init__ método:

class process:
    @initializer
    def __init__(self, PID, PPID, cmd, FDs, reachable, user):
        pass

Sortie :

>>> c = process(1, 2, 3, 4, 5, 6)
>>> c.PID
1
>>> dir(c)
['FDs', 'PID', 'PPID', '__doc__', '__init__', '__module__', 'cmd', 'reachable', 'user'

Answer 2

Si vous utilisez Python 2.6 ou supérieur, vous pouvez utiliser collections.namedtuple :

>>> from collections import namedtuple
>>> Process = namedtuple('Process', 'PID PPID cmd')
>>> proc = Process(1, 2, 3)
>>> proc.PID
1
>>> proc.PPID
2

Ceci est particulièrement approprié lorsque votre classe n'est en fait qu'un grand sac de valeurs.

Answer 3

En citant le Zen du python ,

L'explicite est préférable à l'implicite.

Answer 4

Une autre chose que vous pouvez faire :

class X(object):
    def __init__(self, a,b,c,d):
        vars = locals() # dict of local names
        self.__dict__.update(vars) # __dict__ holds and object's attributes
        del self.__dict__["self"] # don't need `self`

Mais la seule solution que je recommande, en plus de l'épeler, est de "faire une macro dans votre éditeur" ;-p

Answer 5

Vous pourriez le faire facilement avec les arguments des mots-clés, par exemple comme ceci :

>>> class D:
    def __init__(self, **kwargs):
        for k, v in kwargs.items():
            setattr(self, k, v)

>>> D(test='d').test
'd'

Une implémentation similaire pour les arguments positionnels serait :

>> class C:
    def __init__(self, *args):
        self.t, self.d = args

>>> C('abc', 'def').t
'abc'
>>> C('abc', 'def').d
'def'

ce qui, pour moi, ne semble pas résoudre votre problème.