Créer une liste vide en python avec une certaine taille
Je veux créer une liste vide (ou quelle que soit la meilleure méthode) pouvant contenir 10 éléments.
Après cela, je veux assigner des valeurs à cette liste, par exemple ceci est supposé afficher 0 à 9:
s1 = list();
for i in range(0,9):
s1[i] = i
print s1
Mais lorsque je lance 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 affecter de liste telle que lst[i] = something, à moins que la liste ne soit déjà initialisée avec au moins 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'assignation si vous utilisiez un dictionnaire).
Créer une liste vide:
>>> l = [None] * 10
>>> l
[None, None, None, None, None, None, None, None, None, None]
Assigner 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]
N'oubliez pas que quelque chose comme l[15] = 5 échouerait quand même, car notre liste ne contient que 10 éléments.
range (x) crée une liste 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]
Utiliser 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 (Utilisation des carrés car pour la plage, vous n'avez pas besoin de faire tout cela, vous pouvez simplement renvoyer 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 ceci à la place:
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 manière pythonique de faire les choses. Mieux vaut faire ceci:
lst = []
for i in range(10):
lst.append(i)
Ou encore mieux , utilisez des listes telles que celles-ci:
[i for i in range(10)]
la 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 constater, chaque élément pointe vers le même objet de liste. Pour contourner ce problème, vous pouvez créer une méthode qui initialisera chaque position sur 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 existe probablement une méthode python intégrée par défaut (au lieu d'écrire une fonction), mais je ne suis pas sûr de ce que c'est. Serait heureux d'être corrigé!
Edit: 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 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]*x 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 range(x) pourrait être le plus rapide:
>>> timeit("range(100)",number=10000)
0.012513160705566406
(Ceci a été écrit sur la base de la version originale de la question.)
Je veux créer une liste vide (ou quel que soit le meilleur moyen) pouvant contenir 10 éléments.
Toutes les listes peuvent contenir autant d'éléments que vous le souhaitez, dans la limite de la mémoire disponible. La seule "taille" d'une liste qui compte est le nombre d'éléments actuellement qu'il contient.
mais quand je le lance, le résultat est []
print display s1 n'est pas une syntaxe valide; sur la base de votre description de ce que vous voyez, je suppose que vous vouliez dire display(s1) puis print s1. Pour que cela fonctionne, vous devez avoir préalablement défini un s1 global à transmettre à la fonction.
L'appel de display ne modifie pas la liste que vous transmettez, telle que rédigée. Votre code indique "s1 est le nom de tout ce qui a été passé dans la fonction; d'accord, la première chose à faire est de l'oublier complètement et de laisser s1 commencer à faire référence à la nouvelle list créée. Maintenant, nous ' ll modifier cette list ". Cela n'a aucun effet sur la valeur que vous avez transmise.
Il n'y a aucune raison de transmettre une valeur ici. (Il n'y a pas de vraie raison de créer une fonction non plus, mais c'est à côté de la question.) Vous voulez "créer" quelque chose, c'est donc le résultat de votre fonction. Aucune information n'est requise pour créer le document que vous décrivez. Ne transmettez donc aucune information. Pour obtenir des informations, return.
Cela vous donnerait quelque chose comme:
def display():
s1 = list();
for i in range(0, 9):
s1[i] = i
return s1
Le problème suivant que vous remarquerez est que votre liste ne comportera en réalité que 9 éléments, car le point de fin est ignoré par la fonction range. (Comme notes de côté, [] fonctionne aussi bien que list(), le point-virgule est inutile, s1 est un mauvais nom pour la variable et un seul paramètre est nécessaire pour range si vous débutez à partir de 0.) Vous vous retrouvez alors avec
def create_list():
result = list()
for i in range(10):
result[i] = i
return result
Cependant, cela manque toujours la marque; range n'est pas un mot clé magique faisant partie du langage comme le sont for et def, mais c'est plutôt une fonction. Et devinez quoi cette fonction retourne? C'est vrai - une liste de ces entiers. Donc, toute la fonction se réduit à
def create_list():
return range(10)
et maintenant vous voyez pourquoi nous n'avons pas besoin d'écrire une fonction nous-mêmes; range est déjà la fonction que nous recherchons. Encore une fois, il n’est ni besoin ni raison de "pré-dimensionner" la liste.
Je suis surpris que personne ne suggère cette approche simple pour créer une liste de listes vides. C'est un vieux fil, mais je ne fais que l'ajouter pour des raisons de complétude. Cela va créer une liste de 10 listes vides
x = [[] for i in range(10)]
Ajoutant aux réponses étonnantes écrites ci-dessus,
Pour créer simplement une liste vide, supposément avec "zéros", utilisez
lst=[0]*size
Voici mon code pour la liste 2D en python qui lirait non. des 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('')
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 fonction list:
list(range(9))
Un moyen simple de créer une matrice 2D de taille n en utilisant des compréhensions de liste imbriquées:
m = [[None for _ in range(n)] for _ in range(n)]
Ce code génère un tableau contenant 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)
Je suis tombé sur cette question SO en cherchant un problème similaire. Je devais 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 SO question qui m'a aidé, peut-être que cela aidera d'autres débutants à se déplacer . en utilisant array[i,j] au lieu de array[i][j].
Pour référence c'est le morceau de code où je devais 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 par souci de simplicité, j'utilise une boucle for imbriquée. J'espère que cela aide les autres qui rencontrent ce post.
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