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

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

Danach möchte ich Werte in dieser Liste zuweisen, zum Beispiel soll dies 0 bis 9 anzeigen:

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

print  s1

Wenn ich diesen Code ausführe, wird ein Fehler generiert oder in einem anderen Fall nur angezeigt [](leer).

Kann jemand erklären warum?

Sie können einer Liste wie nicht zuweisen lst[i] = something, es sei denn, die Liste ist bereits mit mindestens i+1Elementen initialisiert . Sie müssen append verwenden, um Elemente am Ende der Liste hinzuzufügen. lst.append(something).

(Sie könnten die Zuweisungsnotation verwenden, wenn Sie ein Wörterbuch verwenden).

Leere Liste erstellen:

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

Zuweisen eines Werts zu einem vorhandenen Element der obigen Liste:

>>> l[1] = 5
>>> l
[None, 5, None, None, None, None, None, None, None, None]

Denken Sie daran, dass so etwas l[15] = 5immer noch fehlschlagen würde, da unsere Liste nur 10 Elemente enthält.

range (x) erstellt eine Liste aus [0, 1, 2, ... x-1]

# 2.X only. Use list(range(10)) in 3.X.
>>> l = range(10)
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Verwenden einer Funktion zum Erstellen einer Liste:

>>> def display():
...     s1 = []
...     for i in range(9): # This is just to tell you how to create a list.
...         s1.append(i)
...     return s1
... 
>>> print display()
[0, 1, 2, 3, 4, 5, 6, 7, 8]

Listenverständnis (Verwenden Sie die Quadrate, da Sie für die Reichweite nicht alles tun müssen, sondern einfach zurückkehren können range(0,9)):

>>> def display():
...     return [x**2 for x in range(9)]
... 
>>> print display()
[0, 1, 4, 9, 16, 25, 36, 49, 64]

Versuchen Sie stattdessen Folgendes:

lst = [None] * 10

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

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

Zugegeben, das ist nicht die pythonische Art, Dinge zu tun. Mach das besser:

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

Oder noch einfacher : In Python 2.x können Sie eine Liste mit Werten von 0 bis 9 initialisieren:

lst = range(10)

Und in Python 3.x:

lst = list(range(10))

Die derzeit akzeptierte Antwort von varunl

 >>> 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 mit Listen erstellen möchten, treten leider Referenzierungsfehler auf. 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 können, zeigt jedes Element auf dasselbe Listenobjekt. Um dies zu umgehen, können Sie eine Methode erstellen, mit der jede Position mit einer anderen Objektreferenz initialisiert wird.

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 (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, zB : 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]*xdas schneller ist:

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

Aber wenn Sie mit einer Reichweite (z. B. [0,1,2,3,...,x-1]) einverstanden sind , ist dies range(x)möglicherweise die schnellste:

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

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

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

(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 beliebig viele Elemente enthalten, vorbehaltlich der Begrenzung des verfügbaren Speichers. Die einzige "Größe" einer Liste, die zählt, ist die Anzahl der aktuell darin enthaltenen Elemente .

aber wenn ich es starte, ist das Ergebnis []

print display s1ist keine gültige Syntax; Basierend auf Ihrer Beschreibung dessen, was Sie sehen, gehe ich davon aus, dass Sie es gemeint haben display(s1)und dann print s1. Damit dies ausgeführt werden kann, müssen Sie zuvor ein globales Element definiert haben s1, das an die Funktion übergeben werden soll.

Durch displaydas Anrufen wird die Liste, die Sie übergeben, nicht wie geschrieben geändert. Ihr Code sagt " s1ist ein Name für alles, was an die Funktion übergeben wurde; ok, jetzt vergessen wir das Ding zuerst vollständig und s1verweisen stattdessen auf ein neu erstelltes list. Jetzt ändern wir das list". Dies hat keine Auswirkung auf den übergebenen Wert.

Es gibt hier keinen Grund, einen Wert einzugeben. (Es gibt auch keinen wirklichen Grund, eine Funktion zu erstellen, aber das ist nebensächlich.) 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 daher keine Informationen weiter return.

Das würde dir so etwas geben wie:

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

Das nächste Problem, das Sie feststellen werden, ist, dass Ihre Liste tatsächlich nur 9 Elemente enthält, da der Endpunkt von der rangeFunktion übersprungen wird . (Als Randnotiz []funktioniert es genauso gut list(), das Semikolon ist unnötig, s1ist ein schlechter Name für die Variable und es wird nur ein Parameter benötigt, rangewenn Sie von vorne beginnen 0.) Dann haben Sie also

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

Dies fehlt jedoch immer noch die Marke; rangeist kein magisches Schlüsselwort, das Teil der Sprache ist forund defist, sondern eine Funktion. Und raten Sie mal, was diese Funktion zurückgibt? Das ist richtig - eine Liste dieser ganzen Zahlen. Die gesamte Funktion bricht also zusammen

def create_list():
    return range(10)

und jetzt sehen Sie, warum wir überhaupt keine Funktion selbst schreiben müssen; rangeist bereits die Funktion, die wir suchen. Auch hier besteht keine Notwendigkeit oder kein Grund, die Liste vorab zu dimensionieren.

Ich bin ein bisschen überrascht, dass der einfachste Weg, eine initialisierte Liste zu erstellen, in keiner dieser Antworten liegt. Verwenden Sie einfach einen Generator in der listFunktion:

list(range(9))

Eine einfache Möglichkeit, eine 2D-Matrix mit Größe nmithilfe verschachtelter Listen zu erstellen :

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

Hier ist mein Code für die 2D-Liste in Python, die nein lauten würde. 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 auf diese SO-Frage gestoßen, als ich nach einem ähnlichen Problem gesucht habe. Ich musste ein 2D-Array erstellen und dann einige Elemente jeder Liste (im 2D-Array) durch Elemente aus einem Diktat ersetzen. Ich bin dann auf diese SO-Frage gestoßen, die mir geholfen hat, vielleicht hilft dies anderen Anfängern, sich fortzubewegen. Der Schlüsseltrick bestand darin, das 2D-Array als Numpy-Array zu initialisieren und dann array[i,j]anstelle von zu verwenden array[i][j].

Als Referenz ist dies der Code, in 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 das 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 wiederverwendbarer.

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

s1 = []
for i in range(11):
   s1.append(i)

print s1

Verwenden Sie zum Erstellen einer Liste einfach die folgenden Klammern: "[]"

Verwenden Sie list.append (), um einer Liste etwas hinzuzufügen.

Dieser Code generiert ein Array, das 10 Zufallszahlen enthält.

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