¿Cómo crear una matriz de enteros en Python?

Question

No debería ser tan difícil. Me refiero a C,

int a[10]; 

es todo lo que necesita. Cómo crear una matriz de todos los ceros para un tamaño aleatorio. Sé que la función de ceros() funciona en NumPy, pero debe haber una manera fácil incorporada, no otro módulo.

Answer 1

Si no está satisfecho con las listas (ya que pueden contener cualquier cosa y tomar demasiada memoria) se puede utilizar matriz eficiente de los números enteros:

import array 
array.array('i') 

Ver here

Si necesita inicializar que,

a = array.array('i',(0 for i in range(0,10))) 

Answer 2

>>> a = [0] * 10 
>>> a 
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0] 

Answer 3

a = 10 * [0] 

le da una matriz de longitud 10, llena de ceros.

Answer 4

de dos maneras:

x = [0] * 10 
x = [0 for i in xrange(10)] 

Editar: range reemplazados por xrange para evitar crear otra lista.

También: como muchos otros han notado incluyendo Pi y Ben James, esto crea un list, no una matriz de Python. Si bien una lista es, en muchos casos, suficiente y fácil, para usos críticos para el rendimiento (por ejemplo, cuando se duplica en miles de objetos), podría examinar las matrices de python. Busque el módulo array, como se explica en las otras respuestas de este hilo.

Answer 5

utilizar el módulo matriz. Con él puede almacenar colecciones del mismo tipo de manera eficiente.

>>> import array 
>>> import itertools 
>>> a = array_of_signed_ints = array.array("i", itertools.repeat(0, 10)) 

Para obtener más información, por ejemplo, diferentes tipos, mira the documentation of the array module. Para hasta 1 millón de entradas esto debería sentirse muy rápido. Para 10 millones de entradas, mi máquina local piensa durante 1,5 segundos.

El segundo parámetro a array.array es un generador , que construye la secuencia definida como que se lee. De esta forma, el módulo de matriz puede consumir los ceros uno por uno, pero el generador solo usa memoria constante. Este generador no se agranda (en cuanto a la memoria) si la secuencia se alarga. La matriz crecerá, por supuesto, pero eso debería ser obvio.

Se utiliza como una lista:

>>> a.append(1) 
>>> a.extend([1, 2, 3]) 
>>> a[-4:] 
array('i', [1, 1, 2, 3]) 
>>> len(a) 
14 

... o simplemente convertir a una lista:

>>> l = list(a) 
>>> len(l) 
14 

Sorprendentemente

>>> a = [0] * 10000000 

es más rápido en la construcción de el método de matriz. ¡Imagínate!:)

Answer 6

import random 

def random_zeroes(max_size): 
    "Create a list of zeros for a random size (up to max_size)." 
    a = [] 
    for i in xrange(random.randrange(max_size)): 
    a += [0] 

Uso range su lugar si está utilizando Python 3.x

Answer 7

Si necesita inicializar una matriz rápidamente, puede hacerlo por bloques en lugar de con un inicializador de generador, y va a ser mucho más rápido. Crear una lista por [0]*count es igual de rápido, aún.

import array 

def zerofill(arr, count): 
    count *= arr.itemsize 
    blocksize = 1024 
    blocks, rest = divmod(count, blocksize) 
    for _ in xrange(blocks): 
     arr.fromstring("\x00"*blocksize) 
    arr.fromstring("\x00"*rest) 

def test_zerofill(count): 
    iarr = array.array('i') 
    zerofill(iarr, count) 
    assert len(iarr) == count 

def test_generator(count): 
    iarr = array.array('i', (0 for _ in xrange(count))) 
    assert len(iarr) == count 

def test_list(count): 
    L = [0]*count 
    assert len(L) == count 

if __name__ == '__main__': 
    import timeit 
    c = 100000 
    n = 10 
    print timeit.Timer("test(c)", "from __main__ import c, test_zerofill as test").repeat(number=n) 
    print timeit.Timer("test(c)", "from __main__ import c, test_generator as test").repeat(number=n) 
    print timeit.Timer("test(c)", "from __main__ import c, test_list as test").repeat(number=n) 

Resultados:

(array in blocks) [0.022809982299804688, 0.014942169189453125, 0.014089107513427734] 
(array with generator) [1.1884641647338867, 1.1728270053863525, 1.1622772216796875] 
(list) [0.023866891860961914, 0.035660028457641602, 0.023386955261230469]