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


546

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?



7
Une «liste vide» ( []), par définition, ne contient aucun élément. Ce que vous voulez apparemment est une liste de valeurs comme falsy None, 0ou ''.
dan04

Pour générer une liste de 0à 9vous devez réellement utiliser for i in range(0, 10), ce qui signifie for (int i = 0, i < 10, i++).
Atcold

Réponses:


833

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]

17
Que voulez-vous dire par "Vous ne pouvez pas attribuer à une liste comme lst [i] = quelque chose" - bien sûr, vous pouvez! Ce que vous ne pouvez pas faire, c'est attribuer à un élément inexistant au-delà de la longueur de la liste actuelle
Sergey

5
"à moins que la liste ne soit déjà initialisée avec au moins i + 1 éléments" ....
MrR

5
vous pouvez le faire:a = [0 for _ in range(10)]
Kamiar

Est-il possible de le faire en utilisant la fonction list ()?
Raul Chiarella

126

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

2
L'autre grande chose à ce sujet est que vous pouvez initialiser une liste avec des valeurs par défaut. lst = [''] * 10oulst = [0] * 10
Anthony Manning-Franklin

2
Une variante de l'exemple de compréhension. Si tous les éléments de la nécessité de tableau à vide à l' initialisation, utilisez: arr = [None for _ in range(10)].
Doug R.

86

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

19
J'ai entendu dire que l'utilisation appendtrès souvent est inférieure à la compréhension des listes. Vous pouvez créer votre liste de listes via [ [] for _ in range(10)].
M.Herzkamp

10
J'ai voté parce que je devenais fou parce que j'avais un tableau multidimensionnel avec les mêmes données répétées plusieurs fois et je ne pouvais pas comprendre ce qui se passait avant de finalement trouver cette réponse. ^^ Je ne comprends pas pourquoi c'est si bas ici.
Bregalad

19

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.


16

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

Notez qu'en Python3, vous devrez utiliser à la list(range(n))place, car range()ne renvoie pas de liste mais est un itérateur, et ce n'est pas plus rapide que [None] * n.
Skillmon aime topanswers.xyz le

10

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

7
La différence la plus importante entre faire ce qui précède et faire x = [[]] * 10est que dans ce dernier, chaque élément de la liste pointe vers l'objet de liste SAME . Donc, sauf si vous voulez simplement 10 copies du même objet, utilisez la rangevariante basée car elle crée 10 nouveaux objets. J'ai trouvé cette distinction très importante.
Mandeep Sandhu

6

(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.


4

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

3

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

1
Un peu curieux de savoir pourquoi quelqu'un commente encore celui-ci ... Je suis un noob en python et moi celui-ci ressemble à la voie à suivre, mais personne ne dit rien. Peut-être que la fonction de gamme pourrait être chère ou quelque chose?
AFP_555

3
Ce problème est que cette réponse ne crée pas une liste vide selon la question, vous vous retrouverez avec [0, 1, 2, 3, 4, 5, 6, 7, 8], ce que fait la fonction range (9) . Supposer qu'il est utile d'instancier une liste de Nones plutôt que de la remplir immédiatement
Spcogg le 2

Pourquoi envelopper le range(9)dans list()? Ne range(9)renvoie pas déjà une liste?
Zyl

2
@Zyl rangen'est pas une liste, ni un générateur. C'est une sous-classe immuable intégrée de Sequence.
Nuno André

1
@ AFP_555 Je pense que la vraie question est de savoir pourquoi il n'est pas moins voté, car il ne répond pas vraiment à la question et pourrait avoir de mauvaises conséquences involontaires.
Eric

1

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

0

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}, {}, {}]
>>> 

-2

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.


-2

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

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


-3

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)

3
Bienvenue chez SO. Votre réponse ne répond pas vraiment à la question en particulier. Jetez un œil à stackoverflow.com/help/how-to-answer
Nick
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.