Encontré esta pregunta SO mientras buscaba un problema similar. Tuve que construir una matriz 2D y luego reemplazar algunos elementos de cada lista (en una matriz 2D) con elementos de un dictado. Luego encontré esta pregunta SO que me ayudó, tal vez esto ayude a otros principiantes a moverse. El truco clave fue inicializar la matriz 2D como una matriz numpy y luego usar array[i,j] en lugar de array[i][j] .

Como referencia, este es el fragmento de código donde tuve que usar esto:

 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)

Ahora sé que podemos usar la comprensión de listas, pero por simplicidad, estoy usando un bucle for anidado. Espero que esto ayude a otros que se encuentren con esta publicación.

Estoy un poco sorprendido de que la forma más fácil de crear una lista inicializada no se encuentre en ninguna de estas respuestas. Simplemente use un generador en la función de list :

 list(range(9))

Técnicamente no es una lista pero es similar a una lista en términos de funcionalidad y tiene una longitud fija

 from collections import deque my_deque_size_10 = deque(maxlen=10)

Si está lleno, es decir, tiene 10 artículos y luego agregar otro artículo da como resultado que el artículo @index 0 se descarte. FIFO ... pero también puede agregar en cualquier dirección. Usado en decir

• un promedio móvil de estadísticas
• canalizar una lista a través de ella, también conocida como deslizar una ventana sobre una lista hasta que obtenga una coincidencia con otro objeto deque.

Si necesita una lista, cuando esté llena, simplemente use la lista (objeto deque)

La respuesta aceptada tiene algunas trampas. Por ejemplo:

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

Entonces cada diccionario se refiere al mismo objeto. Lo mismo es cierto si inicializa con matrices u objetos.

Podrías hacer esto en su lugar:

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

Una forma sencilla de crear una matriz 2D de tamaño n usando comprensiones de listas anidadas:

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

Otra opción es usar numpy para matrices de tamaño fijo (de punteros):

> pip install numpy

 import numpy as np a = np.empty(10, dtype=np.object) a[1] = 2 a[5] = "john" a[3] = []

Si solo quieres números, puedes hacerlo con numpy:

 a = np.arange(10)

Hay dos métodos "rápidos":

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

Parece que [None]*x es más rápido:

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

Pero si está de acuerdo con un rango (por ejemplo [0,1,2,3,...,x-1] ), entonces el range(x) podría ser el más rápido:

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

respuesta actualmente aceptada de varunl

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

Funciona bien para tipos que no son de referencia, como números. Desafortunadamente, si desea crear una lista de listas, se encontrará con errores de referencia. Ejemplo en Python 2.7.6:

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

Como puede ver, cada elemento apunta al mismo objeto de lista. Para evitar esto, puede crear un método que inicialice cada posición en una referencia de objeto diferente.

 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 probable que haya una forma predeterminada de Python integrada para hacer esto (en lugar de escribir una función), pero no estoy seguro de qué es. ¡Estaría feliz de ser corregido!

Editar: es [ [] for _ in range(10)]

Ejemplo :

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

Este código genera una matriz que contiene 10 números aleatorios.

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

Hazlo más reutilizable como una función.

 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

Para crear una lista, simplemente use estos corchetes: "[]"

Para agregar algo a una lista, use list.append()

Aquí está mi código para la lista 2D en python que diría no. de filas de la entrada:

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

Me sorprende que nadie sugiera este enfoque simple para crear una lista de listas vacías. Este es un hilo antiguo, pero solo agrego esto para completar. Esto creará una lista de 10 listas vacías

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

Puede .append(element) a la lista, por ejemplo: s1.append(i) . Lo que está tratando de hacer actualmente es acceder a un elemento ( s1[i] ) que no existe.

Prueba esto en su lugar:

 lst = [None] * 10

Lo anterior creará una lista de tamaño 10, donde cada posición se inicializa en None . Después de eso, puedes agregarle elementos:

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

Es cierto que esa no es la forma Pythonic de hacer las cosas. Mejor haz esto:

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

O incluso más simple , en Python 2.x puede hacer esto para inicializar una lista con valores del 0 al 9:

 lst = range(10)

Y en Python 3.x:

 lst = list(range(10))

No puede asignar a una lista como lst[i] = something , a menos que la lista ya esté inicializada con al menos i+1 elementos. Debe usar append para agregar elementos al final de la lista. lst.append(something) .

(Podría usar la notación de asignación si estuviera usando un diccionario).

Crear una lista vacía:

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

Asignar un valor a un elemento existente de la lista anterior:

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

Tenga en cuenta que algo como l[15] = 5 aún fallaría, ya que nuestra lista tiene solo 10 elementos.

range(x) crea una lista 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]

Usando una función para crear una lista:

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

Lista de comprensión (usando los cuadrados porque para el rango no necesita hacer todo esto, solo puede devolver el range(0,9) ):

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

(Esto fue escrito en base a la versión original de la pregunta).

Quiero crear una lista vacía (o la mejor manera) que pueda contener 10 elementos.

Todas las listas pueden contener tantos elementos como desee, sujeto únicamente al límite de memoria disponible. El único "tamaño" de una lista que importa es la cantidad de elementos que contiene actualmente .

pero cuando lo ejecuto, el resultado es []

print display s1 no es una sintaxis válida; según su descripción de lo que está viendo, asumo que quiso decir display(s1) y luego print s1 . Para que se ejecute, debe haber definido previamente un s1 global para pasar a la función.

La display llamadas no modifica la lista que pasa, tal como está escrita. Su código dice " s1 es un nombre para cualquier cosa que se haya pasado a la función; bien, ahora lo primero que haremos es olvidarnos de esa cosa por completo, y dejar que s1 comience a referirse en su lugar a una list recién creada. Ahora vamos a modificaré esa list ". Esto no tiene ningún efecto en el valor que pasó.

No hay razón para pasar un valor aquí. (Tampoco hay una razón real para crear una función, pero eso no viene al caso). Desea "crear" algo, de modo que esa sea la salida de su función. No se requiere información para crear lo que describe, así que no pase ninguna información. Para obtener información, return .

Eso te daría algo como:

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

El siguiente problema que notará es que su lista en realidad tendrá solo 9 elementos, porque la función de range omite el punto final. (Como notas al margen, [] funciona tan bien como list() , el punto y coma no es necesario, s1 es un nombre deficiente para la variable y solo se necesita un parámetro para el range si comienza desde 0 ). Entonces, terminar con

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

Sin embargo, esto todavía no da en el blanco; range no es una palabra clave mágica que forma parte del lenguaje como for y def are, sino que es una función. ¿Y adivina qué devuelve esa función? Así es, una lista de esos números enteros. Entonces toda la función colapsa para

 def create_list(): return range(10)

y ahora ve por qué no necesitamos escribir una función nosotros mismos; range ya es la función que estamos buscando. Aunque, de nuevo, no hay necesidad ni razón para "pre-dimensionar" la lista.