Créer une liste vide en python avec une certaine taille

Je veux créer une liste vide (ou quelle que soit la meilleure façon) pouvant contenir 10 éléments.

Après cela, je veux attribuer des valeurs dans cette liste, par exemple, cela est censé afficher 0 à 9:

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

print  s1

Mais lorsque j'exécute ce code, il génère une erreur ou dans un autre cas, il affiche simplement [](vide).

Quelqu'un peut-il expliquer pourquoi?

Vous ne pouvez pas attribuer à une liste comme lst[i] = something, sauf si la liste est déjà initialisée avec au moins des i+1éléments. Vous devez utiliser append pour ajouter des éléments à la fin de la liste. lst.append(something).

(Vous pouvez utiliser la notation d'affectation si vous utilisez un dictionnaire).

Création d'une liste vide:

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

Attribution d'une valeur à un élément existant de la liste ci-dessus:

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

Gardez à l'esprit que quelque chose comme ça l[15] = 5échouerait encore, car notre liste ne contient que 10 éléments.

range (x) crée une liste à partir de [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]

Utilisation d'une fonction pour créer une 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]

Compréhension de la liste (en utilisant les carrés parce que pour la portée, vous n'avez pas besoin de faire tout cela, vous pouvez simplement revenir range(0,9)):

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

Essayez plutôt ceci:

lst = [None] * 10

Ce qui précède créera une liste de taille 10, où chaque position est initialisée à None. Après cela, vous pouvez y ajouter des éléments:

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

Certes, ce n'est pas la façon Pythonique de faire les choses. Mieux vaut faire ceci:

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

Ou encore plus simple , dans Python 2.x, vous pouvez le faire pour initialiser une liste avec des valeurs de 0 à 9:

lst = range(10)

Et en Python 3.x:

lst = list(range(10))

réponse actuellement acceptée par varunl

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

Fonctionne bien pour les types non référencés comme les nombres. Malheureusement, si vous souhaitez créer une liste de listes, vous rencontrerez des erreurs de référencement. Exemple en Python 2.7.6:

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

Comme vous pouvez le voir, chaque élément pointe vers le même objet liste. Pour contourner cela, vous pouvez créer une méthode qui initialisera chaque position à une référence d'objet différente.

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], [], [], [], [], [], [], [], [], []]
>>> 

Il y a probablement une façon par défaut de python intégrée de faire cela (au lieu d'écrire une fonction), mais je ne suis pas sûr de ce que c'est. Serait heureux d'être corrigé!

Modifier: c'est [ [] for _ in range(10)]

Exemple :

>>> [ [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]]

Vous pouvez .append(element)à la liste, par exemple: s1.append(i). Ce que vous essayez actuellement de faire, c'est d'accéder à un élément ( s1[i]) qui n'existe pas.

Il existe deux méthodes "rapides":

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

Il semble que [None]*xc'est plus rapide:

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

Mais si vous êtes d'accord avec une plage (par exemple [0,1,2,3,...,x-1]), alors cela range(x)pourrait être le plus rapide:

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

Je suis surpris que personne ne propose cette approche simple pour créer une liste de listes vides. Ceci est un vieux fil, mais juste en l'ajoutant pour être complet. Cela va créer une liste de 10 listes vides

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

(Ceci a été écrit sur la base de la version originale de la question.)

Je veux créer une liste vide (ou quelle que soit la meilleure façon) peut contenir 10 éléments.

Toutes les listes peuvent contenir autant d'éléments que vous le souhaitez, sous réserve uniquement de la limite de mémoire disponible. La seule "taille" d'une liste qui compte est le nombre d'éléments qu'elle contient actuellement .

mais quand je l'exécute, le résultat est []

print display s1n'est pas une syntaxe valide; sur la base de votre description de ce que vous voyez, je suppose que vous vouliez dire display(s1)et ensuite print s1. Pour que cela fonctionne, vous devez avoir préalablement défini un global s1à passer dans la fonction.

L'appel displayne modifie pas la liste que vous transmettez, comme écrit. Votre code dit " s1est un nom pour tout ce qui a été transmis à la fonction; ok, maintenant la première chose que nous ferons est d'oublier complètement cette chose, et commençons à s1faire référence à la place à une nouvellement créée list. Maintenant, nous allons la modifier list". Cela n'a aucun effet sur la valeur que vous avez transmise.

Il n'y a aucune raison de saisir une valeur ici. (Il n'y a pas non plus de raison réelle de créer une fonction, mais c'est à côté du point.) Vous voulez "créer" quelque chose, c'est donc la sortie de votre fonction. Aucune information n'est requise pour créer la chose que vous décrivez, alors ne transmettez aucune information. Pour obtenir des informations, returnil.

Cela vous donnerait quelque chose comme:

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

Le prochain problème que vous remarquerez est que votre liste n'aura en fait que 9 éléments, car le point final est ignoré par la rangefonction. (Comme notes secondaires, []fonctionne aussi bien que list(), le point-virgule n'est pas nécessaire, s1est un mauvais nom pour la variable, et un seul paramètre est nécessaire rangesi vous partez de 0.) Donc, vous vous retrouvez avec

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

Cependant, cela manque toujours la marque; rangen'est pas un mot - clé magique qui fait partie de la langue la voie foret defsont, mais il est une fonction. Et devinez ce que cette fonction renvoie? C'est vrai - une liste de ces entiers. Donc, la fonction entière s'effondre pour

def create_list():
    return range(10)

et maintenant vous voyez pourquoi nous n'avons pas du tout besoin d'écrire une fonction; rangeest déjà la fonction que nous recherchons. Bien que, encore une fois, il n'y ait ni besoin ni raison de «redimensionner» la liste.

Une façon simple de créer une matrice 2D de taille à l' naide de compréhensions de listes imbriquées:

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

Je suis un peu surpris que le moyen le plus simple de créer une liste initialisée ne se trouve dans aucune de ces réponses. Utilisez simplement un générateur dans la listfonction:

list(range(9))

Voici mon code pour la liste 2D en python qui se lirait non. de lignes de l'entrée:

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('')

La réponse acceptée a quelques pièges. Par exemple:

>>> a = [{}] * 3
>>> a
[{}, {}, {}]
>>> a[0]['hello'] = 5
>>> a
[{'hello': 5}, {'hello': 5}, {'hello': 5}]
>>> 

Ainsi, chaque dictionnaire fait référence au même objet. Il en va de même si vous initialisez avec des tableaux ou des objets.

Vous pouvez le faire à la place:

>>> b = [{} for i in range(0, 3)]
>>> b
[{}, {}, {}]
>>> b[0]['hello'] = 6
>>> b
[{'hello': 6}, {}, {}]
>>> 

Je suis tombé sur cette question SO alors que je cherchais un problème similaire. J'ai dû construire un tableau 2D, puis remplacer certains éléments de chaque liste (dans un tableau 2D) par des éléments d'un dict. Je suis ensuite tombé sur cette question SO qui m'a aidé, peut-être que cela aidera d'autres débutants à se déplacer. L'astuce clé était d'initialiser le tableau 2D en tant que tableau numpy, puis d'utiliser à la array[i,j]place de array[i][j].

Pour référence, c'est le morceau de code où j'ai dû utiliser ceci:

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)

Maintenant, je sais que nous pouvons utiliser la compréhension de liste, mais pour des raisons de simplicité, j'utilise une boucle imbriquée pour. J'espère que cela aide les autres qui rencontrent ce message.

Rendez-le plus réutilisable en tant que fonction.

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

Pour créer une liste, utilisez simplement ces crochets: "[]"

Pour ajouter quelque chose à une liste, utilisez list.append ()

Ce code génère un tableau qui contient 10 nombres aléatoires.

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