Erstellen Sie eine leere Liste mit bestimmter Größe in Python

Versuchen Sie es stattdessen:

lst = [None] * 10

Daraufhin wird eine Liste der Größe 10 erstellt, in der jede Position mit None initialisiert wird. Danach können Sie Elemente hinzufügen:

lst = [None] * 10
for i in range(10):
    lst[i] = i

Zugegeben, das ist nicht der pythonische Weg, Dinge zu tun. Besser machen Sie das:

lst = []
for i in range(10):
    lst.append(i)

Oder noch besser , benutze Listenverständnisse wie folgt:

[i for i in range(10)]

varunls derzeit akzeptierte Antwort

 >>> l = [None] * 10
 >>> l
 [None, None, None, None, None, None, None, None, None, None]

Funktioniert gut für Nichtreferenztypen wie Zahlen. Wenn Sie eine Liste von Listen erstellen möchten, werden Sie leider auf Verweisungsfehler stoßen. Beispiel in Python 2.7.6:

>>> a = [[]]*10
>>> a
[[], [], [], [], [], [], [], [], [], []]
>>> a[0].append(0)
>>> a
[[0], [0], [0], [0], [0], [0], [0], [0], [0], [0]]
>>> 

Wie Sie sehen, zeigt jedes Element auf dasselbe Listenobjekt. Um dies zu umgehen, können Sie eine Methode erstellen, die jede Position mit einer anderen Objektreferenz initialisiert.

def init_list_of_objects(size):
    list_of_objects = list()
    for i in range(0,size):
        list_of_objects.append( list() ) #different object reference each time
    return list_of_objects


>>> a = init_list_of_objects(10)
>>> a
[[], [], [], [], [], [], [], [], [], []]
>>> a[0].append(0)
>>> a
[[0], [], [], [], [], [], [], [], [], []]
>>> 

Es gibt wahrscheinlich eine standardmäßige, integrierte Python-Methode, um dies zu tun (anstatt eine Funktion zu schreiben), aber ich bin mir nicht sicher, was es ist. Würde mich freuen, korrigiert zu werden! 

Edit: Es ist [ [] for _ in range(10)]

Beispiel: 

>>> [ [random.random() for _ in range(2) ] for _ in range(5)]
>>> [[0.7528051908943816, 0.4325669600055032], [0.510983236521753, 0.7789949902294716], [0.09475179523690558, 0.30216475640534635], [0.3996890132468158, 0.6374322093017013], [0.3374204010027543, 0.4514925173253973]]

Sie können .append(element) zur Liste hinzufügen, z. B. s1.append(i). Sie versuchen derzeit, auf ein Element (s1[i]) zuzugreifen, das nicht vorhanden ist.

Es gibt zwei "schnelle" Methoden:

x = length_of_your_list
a = [None]*x
# or
a = [None for _ in xrange(x)]

Es scheint, dass [None]*x schneller ist:

>>> from timeit import timeit
>>> timeit("[None]*100",number=10000)
0.023542165756225586
>>> timeit("[None for _ in xrange(100)]",number=10000)
0.07616496086120605

Wenn Sie jedoch mit einem Bereich zufrieden sind (z. B. [0,1,2,3,...,x-1]), ist range(x) möglicherweise am schnellsten:

>>> timeit("range(100)",number=10000)
0.012513160705566406

(Dies wurde basierend auf der Originalversion der Frage geschrieben.)

Ich möchte eine leere Liste erstellen (oder was auch immer der beste Weg ist), die 10 Elemente enthalten kann.

Alle Listen können so viele Elemente enthalten, wie Sie möchten, wobei nur der verfügbare Speicherplatz begrenzt ist. Die einzige "Größe" einer Liste, die zählt, ist die Anzahl der Elemente derzeit darin.

aber wenn ich es laufen lasse, ist das Ergebnis []

print display s1 ist keine gültige Syntax; Ich gehe davon aus, dass Sie auf der Grundlage Ihrer Beschreibung von was Sie sehen, display(s1) und dann print s1. Dazu müssen Sie zuvor einen globalen s1 definiert haben, der an die Funktion übergeben werden kann.

Durch den Aufruf von display wird die von Ihnen übergebene Liste nicht geändert. Ihr Code sagt, "s1 ist ein Name für alles, was an die Funktion übergeben wurde. Okay, jetzt vergessen wir das Ding vollständig und lassen s1 beginnen, stattdessen auf ein neu erstelltes list zu verweisen. ll ändere diese list ". Dies hat keinen Einfluss auf den eingegebenen Wert.

Es gibt keinen Grund, hier einen Wert anzugeben. (Es gibt auch keinen wirklichen Grund, eine Funktion zu erstellen, aber das ist nicht der Punkt.) Sie möchten etwas "erstellen", also ist dies die Ausgabe Ihrer Funktion. Es sind keine Informationen erforderlich, um das von Ihnen beschriebene Objekt zu erstellen. Geben Sie also keine Informationen weiter. Um Informationen abzurufen, return.

Das würde Ihnen so etwas geben:

def display():
    s1 = list();
    for i in range(0, 9):
        s1[i] = i
    return s1

Das nächste Problem, das Sie beachten werden, ist, dass Ihre Liste tatsächlich nur 9 Elemente enthält, da der Endpunkt von der range-Funktion übersprungen wird. (Als Randbemerkungen funktioniert [] genauso gut wie list(), das Semikolon ist nicht erforderlich, s1 ist ein schlechter Name für die Variable, und für range ist nur ein Parameter erforderlich, wenn Sie mit 0 beginnen.) Dann kommen Sie zu

def create_list():
    result = list()
    for i in range(10):
        result[i] = i
    return result

Dies fehlt jedoch immer noch die Markierung; range ist kein magisches Schlüsselwort, das Teil der Sprache ist, wie for und def, sondern eine Funktion. Und raten Sie mal, was diese Funktion zurückgibt? Das ist richtig - eine Liste dieser ganzen Zahlen. So bricht die gesamte Funktion zusammen 

def create_list():
    return range(10)

und jetzt sehen Sie, warum wir selbst keine Funktion schreiben müssen; range ist bereits die Funktion, nach der wir suchen. Auch wenn es keine Notwendigkeit oder keinen Grund gibt, die Liste vorabzuverlegen.

Ich bin überrascht, dass niemand diesen einfachen Ansatz zum Erstellen einer Liste leerer Listen vorschlägt. Dies ist ein alter Thread, der jedoch nur der Vollständigkeit halber hinzugefügt wird. Dadurch wird eine Liste mit 10 leeren Listen erstellt

x = [[] for i in range(10)]

Zu den erstaunlichen Antworten oben hinzugefügt,

Um einfach eine leere Liste zu erstellen, die angeblich mit "Nullen" verwendet wird,

lst=[0]*size

Hier ist mein Code für die 2D-Liste in Python. von Zeilen aus der Eingabe:

empty = []
row = int(input())

for i in range(row):
    temp = list(map(int, input().split()))
    empty.append(temp)

for i in empty:
    for j in i:
        print(j, end=' ')
    print('')

Ich bin etwas überrascht, dass die einfachste Möglichkeit, eine initialisierte Liste zu erstellen, in keiner dieser Antworten enthalten ist. Verwenden Sie einfach einen Generator in der list-Funktion:

list(range(9))

Eine einfache Möglichkeit, eine 2D-Matrix der Größe n mithilfe von verschachtelten Listenverständnissen zu erstellen:

m = [[None for _ in range(n)] for _ in range(n)]

Dieser Code generiert ein Array mit 10 Zufallszahlen. 

import random
numrand=[]
for i in range(0,10):
   a = random.randint(1,50)
   numrand.append(a)
   print(a,i)
print(numrand)

Ich bin auf diese SO - Frage gestoßen, als ich nach einem ähnlichen Problem suchte. Ich musste ein 2D-Array erstellen und dann einige Elemente jeder Liste (im 2D-Array) durch Elemente aus einem Diktat ersetzen. Ich kam dann über this SO - eine Frage, die mir half, vielleicht hilft dies anderen Anfängern, herumzukommen ... Der Schlüsseltrick war, das 2D-Array als numpy-Array zu initialisieren und dann Verwenden von array[i,j] anstelle von array[i][j].

Dies ist der Code, bei dem ich Folgendes verwenden musste:

nd_array = []
for i in range(30):
    nd_array.append(np.zeros(shape = (32,1)))
new_array = []
for i in range(len(lines)):
    new_array.append(nd_array)
new_array = np.asarray(new_array)
for i in range(len(lines)):
    splits = lines[i].split(' ')
    for j in range(len(splits)):
        #print(new_array[i][j])
        new_array[i,j] = final_embeddings[dictionary[str(splits[j])]-1].reshape(32,1)

Jetzt weiß ich, dass wir Listenverständnis verwenden können, aber der Einfachheit halber verwende ich eine verschachtelte for-Schleife. Hoffe, das hilft anderen, die auf diesen Beitrag stoßen.

Machen Sie es als Funktion wiederverwendbar.

def createEmptyList(length,fill=None):
    '''
    return a (empty) list of a given length
    Example:
        print createEmptyList(3,-1)
        >> [-1, -1, -1]
        print createEmptyList(4)
        >> [None, None, None, None]
    '''
    return [fill] * length