Python-Liste sollte leer sein, auf die Klasse-Instanz-Initialisierung, aber das ist es nicht. Warum?

Möchte ich Sie zum erstellen von Instanzen einer Klasse enthält ein Liste ist standardmäßig leer; statt der später die Einstellung in dieser Liste die endgültige Liste möchte ich sukzessive Elemente hinzufügen. Hier ein Stück Beispielcode illustriert dies:

#!/usr/bin/python

class test:
    def __init__(self, lst=[], intg=0):
        self.lista   = lst
        self.integer = intg

name_dict = {}
counter   = 0

for name in ('Anne', 'Leo', 'Suzy'):
    counter += 1

    name_dict[name] = test()
    name_dict[name].integer += 1
    name_dict[name].lista.append(counter)

    print name, name_dict[name].integer, name_dict[name].lista

Bei mir lief das Programm erwartet, dass ich bekommen

Anne 1 [1]

Leo 1 [2]

Suzy 1 [3]

als ich angenommen lista immer initialisiert werden, um eine leere Liste.

Was ich bekam, war vielmehr dies:

Anne 1 [1]

Leo 1 [1, 2]

Suzy 1 [1, 2, 3]

Wenn ich ersetzen self.lista = lst durch self.lista = [] es funktioniert gut, genau wie wenn ich die Zeile hinzufügen name_dict[name].lista = [] zu der for-Schleife.

Warum ist es, dass die Inhalte der bisherigen Objekte, Listen beibehalten werden, aber Ihre Werte integer nicht? Ich bin ziemlich neu in Python, also wäre es toll, wenn jemand darauf hinweisen könnte, wo mir meine Gedanken/Annahmen in die Irre gegangen.

Vielen Dank im Voraus für Ihre Antworten.

InformationsquelleAutor canavanin | 2010-12-26
  1. 12

    Es ist eine sehr schlechte Idee, ein veränderliches Objekt als default-Wert, wie Sie hier tun:

    def __init__(self, lst=[], intg=0):
     # ...

    Ändern Sie diese:

    def __init__(self, lst=None, intg=0):
     if lst is None:
         lst = []
     # ...

    Dem Grund, dass Ihre version nicht funktioniert, ist, dass die leere Liste erstellt wird, nur einmal, wenn die Funktion definiert ist, nicht jedes mal die Funktion aufgerufen wird.

    In einigen Python-Implementierungen können Sie den Wert des default-Werte der Funktion, indem Sie den Wert von func_defaults:

    print test.__init__.func_defaults
name_dict[name] = test()
# ...

    Ausgabe:

    ([],) 
Anne 1 [1] 
([1],) 
Leo 1 [1, 2] 
([1, 2],) 
Suzy 1 [1, 2, 3]
    • Ich mag es zu erklären wie diese: lst = lst oder []
    • Das ist nicht ganz das gleiche. Wenn der Benutzer eine leere Liste Ihre version wird nicht verwenden Sie die Liste, aber anstatt einen neuen zu erstellen, weil eine leere Liste ist "falsy".
    • Guter Punkt, hatte ich nicht betrachtet, der Fall.
    InformationsquelleAutor Mark Byers
  2. 4

    Das problem liegt in dieser Zeile:

    def __init__(self, lst=[], intg=0):

    Sollten Sie nicht verwenden Sie eine Liste als Standard-argument. Das erste mal __init__ aufgerufen, ohne lst angegeben, ist der Python-interpreter definieren wird eine leere Liste []. Nachfolgende Aufrufe der Funktion funktionieren auf der gleichen Liste, wenn lst ist nicht angegeben, ohne die Deklaration einer neuen Liste. Dies verursacht seltsame Probleme.

    Sollten Sie stattdessen ein default-Wert von None und fügen Sie einen Scheck an den Anfang der Funktion:

    def __init__(self, lst=None, intg=0):
    if lst is None:
        lst = []

    Sehen dieser Beitrag für weitere details. Zitat aus dem post:

    Default-Argumente werden bewertet
    definition einer Funktion der Zeit, also Sie sind
    persistent über mehrere Aufrufe hinweg. Dies hat einige
    interessant (und verwirrend) Seite
    Effekte. Ein Beispiel:

    >>> def foo(d=[]):
...     d.append('a')
...     return d

    Wenn
    Sie haben nicht versucht, diese vor, Sie
    wahrscheinlich erwarten, dass foo immer wieder
    ['a']: sollte es beginnen, mit einem leeren
    Liste Anhängen 'a' auf und zurückgeben.
    Hier ist, was es tatsächlich tut:

    >>> foo() ['a']
>>> foo() ['a', 'a']
>>> foo() ['a', 'a', 'a']

    Dies ist, weil der Standardwert für d ist
    zugewiesen, wenn die Funktion
    erstellt, nicht, wenn es aufgerufen wird. Jeder
    mal die Funktion aufgerufen wird, wird der Wert
    noch hanging around aus dem letzten
    nennen. Dieser wird noch seltsamer, wenn Sie
    werfen threads in den mix. Wenn zwei
    verschiedene threads die
    Funktion zur gleichen Zeit, und einer
    ändert sich ein Standard-argument, Sie
    beide sehen die änderung.

    Natürlich, all dies ist nur wahr, wenn
    das Standard-argument Wert ist
    veränderbarer Typ. Wenn wir das ändern foo werden
    definiert als

    >>> def foo2(d=0):
...     d += 1
...     return d

    dann wird es immer 1 zurück.
    (Der Unterschied hier ist, dass in foo2,
    die variable d ist, zugewiesen wird,
    während in foo sein Wert war
    geändert.)

    InformationsquelleAutor marcog
  3. 1

    Liegt das problem mit dem default-Konstruktor-argument. Sollten Sie diese Frage finden Sie Antwort auf Ihre Frage: "Least Astonishment" in Python: Die Veränderliche Default-Argument

    InformationsquelleAutor Utku Zihnioglu
  4. 0

    Python wertet die Standard-Argumente einmal auf Funktion definition:

    def init_a():
    """Initialize a."""
    print("init_a")
    return 1


def test(a_parameter=init_a()):
    """A test function."""
    print("Execute test")

print("whatever")
test()
test()

    gibt

    init_a
whatever
Execute test
Execute test

    Also deine Liste wird einmal definiert. Verwenden Sie die gleiche Liste wie zuvor. Dies ist, warum Sie verwenden sollten Sie das Muster

    def a_function(a_parameter=None):  # Create 'None' once
    if a_parameter is None:
        a_parameter = []  # Create a new list - each time
    InformationsquelleAutor Martin Thoma
Schreibe einen Kommentar