Wie vermeide ich das "self.x = x; self.y = y; self.z = z "Muster in __init__?

Dekorateur Lösung, die hält die Signatur:

import decorator
import inspect
import sys


@decorator.decorator
def simple_init(func, self, *args, **kws):
    """
    @simple_init
    def __init__(self,a,b,...,z)
        dosomething()

    behaves like

    def __init__(self,a,b,...,z)
        self.a = a
        self.b = b
        ...
        self.z = z
        dosomething()
    """

    #init_argumentnames_without_self = ['a','b',...,'z']
    if sys.version_info.major == 2:
        init_argumentnames_without_self = inspect.getargspec(func).args[1:]
    else:
        init_argumentnames_without_self = tuple(inspect.signature(func).parameters.keys())[1:]

    positional_values = args
    keyword_values_in_correct_order = tuple(kws[key] for key in init_argumentnames_without_self if key in kws)
    attribute_values = positional_values + keyword_values_in_correct_order

    for attribute_name,attribute_value in zip(init_argumentnames_without_self,attribute_values):
        setattr(self,attribute_name,attribute_value)

    # call the original __init__
    func(self, *args, **kws)


class Test():
    @simple_init
    def __init__(self,a,b,c,d=4):
        print(self.a,self.b,self.c,self.d)

#prints 1 3 2 4
t = Test(1,c=2,b=3)
#keeps signature
#prints ['self', 'a', 'b', 'c', 'd']
if sys.version_info.major == 2:
    print(inspect.getargspec(Test.__init__).args)
else:
    print(inspect.signature(Test.__init__))

InformationsquelleAutor der Antwort Siphor

Wie andere erwähnt haben, die Wiederholung ist nicht schlecht, aber in einigen Fällen namedtuple kann eine gute Passform für diese Art von Problem. Dies vermeidet die Verwendung von locals() oder kwargs, die in der Regel eine schlechte Idee.

from collections import namedtuple
# declare a new object type with three properties; x y z
# the first arg of namedtuple is a typename
# the second arg is comma-separated or space-separated property names
XYZ = namedtuple("XYZ", "x, y, z")

# create an object of type XYZ. properties are in order
abc = XYZ("one", "two", 3)
print abc.x
print abc.y
print abc.z

Habe ich begrenzt, aber Sie können die Erben eine namedtuple, wie mit jedem anderen Objekt (Beispiel, Fortsetzung):

class MySuperXYZ(XYZ):
    """ I add a helper function which returns the original properties """
    def properties(self):
        return self.x, self.y, self.z

abc2 = MySuperXYZ(4, "five", "six")
print abc2.x
print abc2.y
print abc2.z
print abc2.properties()

InformationsquelleAutor der Antwort A Small Shell Script

Erweitern gruszczys Antwort, die ich verwendet habe ein Muster wie:

class X:
    x = None
    y = None
    z = None
    def __init__(self, **kwargs):
        for (k, v) in kwargs.items():
            if hasattr(self, k):
                setattr(self, k, v)
            else:
                raise TypeError('Unknown keyword argument: {:s}'.format(k))

Ich mag diese Methode, weil es:

• vermeidet Wiederholung
• ist resistent gegen Tippfehler bei der Konstruktion eines Objekts
• funktioniert gut mit Unterklassen (kann nur super().__init(...))
• ermöglicht die Dokumentation der Attribute der Klasse-Niveau (wo Sie hingehören), anstatt in X.__init__

Vor Python-3.6, dies gibt keine Kontrolle über die Reihenfolge, in der die Attribute sind gesetzt, das könnte ein problem werden, wenn einige Attribute sind Eigenschaften, die mit Set-Methoden, die den Zugriff auf andere Attribute.

Könnte es wahrscheinlich besser noch ein bisschen, aber ich bin der einzige Benutzer an meinem eigenen code, so bin ich nicht besorgt über jede form von input-Hygiene. Vielleicht ein AttributeError wäre passender.

InformationsquelleAutor der Antwort gerrit

Dies ist eine Lösung, die ohne zusätzliche Importe.

Hilfsfunktion

Eine kleine helper-Funktion macht es bequemer und wiederverwendbar:

def auto_init(local_name_space):
    """Set instance attributes from arguments.
    """
    self = local_name_space.pop('self')
    for name, value in local_name_space.items():
        setattr(self, name, value)

Anwendung

Müssen Sie rufen es mit locals():

class A:
    def __init__(self, x, y, z):
        auto_init(locals())

Test

a = A(1, 2, 3)
print(a.__dict__)

Ausgabe:

{'y': 2, 'z': 3, 'x': 1}

Ohne änderung locals()

Wenn Sie nicht mögen, zu ändern locals() verwenden Sie diese version:

def auto_init(local_name_space):
    """Set instance attributes from arguments.
    """
    for name, value in local_name_space.items():
        if name != 'self': 
            setattr(local_name_space['self'], name, value)

InformationsquelleAutor der Antwort Mike Müller

Eine interessante Bibliothek, die dies erledigt (und vermeidet eine Menge von anderen vorformulierten) ist attrs. Dein Beispiel, zum Beispiel, könnte reduziert werden, um diese (angenommen, die Klasse genannt wird MyClass):

import attr

@attr.s
class MyClass:
    x = attr.ib()
    y = attr.ib()
    z = attr.ib()

Brauchen Sie nicht einmal eine __init__ Methode mehr, es sei denn, er tut andere Dinge als gut. Hier ist eine schöne Einleitung durch die Glyphe Lefkowitz.

InformationsquelleAutor der Antwort RafG

Python 3.7 ab

In Python 3.7, können Sie (ab -) Nutzung der dataclass Dekorateur, erhältlich von der dataclasses Modul. Aus der Dokumentation:

Dieses Modul bietet einen Dekorator und Funktionen zum automatischen hinzufügen von generierten spezielle Methoden wie __init__() und __repr__() zu benutzerdefinierten Klassen. Es war ursprünglich beschrieben in PEP 557.

Den member-Variablen zu verwenden, in diese generierten Methoden definiert, mit PEP 526 Typ-Annotationen. Zum Beispiel dieser code:

@dataclass
class InventoryItem:
    '''Class for keeping track of an item in inventory.'''
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost(self) -> float:
        return self.unit_price * self.quantity_on_hand

Hinzufügen, unter anderem, eine __init__() wie das aussieht:

def __init__(self, name: str, unit_price: float, quantity_on_hand: int=0):
      self.name = name
      self.unit_price = unit_price
      self.quantity_on_hand = quantity_on_hand

Beachten Sie, dass diese Methode, wird automatisch die Klasse: es ist nicht direkt angegeben in dem InventoryItem definition oben gezeigt.

Wenn Ihre Klasse ist groß und Komplex, es kann unangemessen zu verwenden dataclass. Ich Schreibe dies am Tag des release von Python 3.7.0, so Nutzungsmuster sind noch nicht etabliert.

InformationsquelleAutor der Antwort gerrit