¿Cómo declaro una matriz en Python ?

No puedo encontrar ninguna referencia a las matrices en la documentación.

variable = []

Ahora se variablerefiere a una lista vacía ^* .

Por supuesto, esta es una tarea, no una declaración. No hay forma de decir en Python "esta variable nunca debe referirse a otra cosa que no sea una lista", ya que Python se escribe dinámicamente.

^* El tipo de Python incorporado predeterminado se llama una lista , no una matriz. Es un contenedor ordenado de longitud arbitraria que puede contener una colección heterogénea de objetos (sus tipos no importan y se pueden mezclar libremente). Esto no debe confundirse con el arraymódulo , que ofrece un tipo más cercano al arraytipo C ; los contenidos deben ser homogéneos (todos del mismo tipo), pero la longitud sigue siendo dinámica.

Este es un tema sorprendentemente complejo en Python.

Respuesta práctica

Las matrices están representadas por clase list(ver referencia y no mezclarlas con generadores ).

Vea ejemplos de uso:

# empty array
arr = [] 

# init with values (can contain mixed types)
arr = [1, "eels"]

# get item by index (can be negative to access end of array)
arr = [1, 2, 3, 4, 5, 6]
arr[0]  # 1
arr[-1] # 6

# get length
length = len(arr)

# supports append and insert
arr.append(8)
arr.insert(6, 7)

Respuesta teórica

Debajo del capó, Python listes un contenedor para una matriz real que contiene referencias a elementos. Además, la matriz subyacente se crea con algo de espacio extra.

Las consecuencias de esto son:

• el acceso aleatorio es realmente barato ( arr[6653]es igual a arr[0])
• append la operación es 'gratis' mientras hay espacio extra
• insert la operación es costosa

Consulte esta increíble tabla de complejidad de operaciones .

Además, vea esta imagen, donde he tratado de mostrar las diferencias más importantes entre la matriz, la matriz de referencias y la lista vinculada:

En realidad no declaras cosas, pero así es como creas una matriz en Python:

from array import array
intarray = array('i')

Para obtener más información, consulte el módulo de matriz: http://docs.python.org/library/array.html

Ahora es posible que no desee una matriz, sino una lista, pero otros ya han respondido eso. :)

Creo que querías una lista con las primeras 30 celdas ya rellenas. Entonces

   f = []

   for i in range(30):
       f.append(0)

Un ejemplo de dónde podría usarse esto es en la secuencia de Fibonacci. Ver problema 2 en el Proyecto Euler

Así es como:

my_array = [1, 'rebecca', 'allard', 15]

Para los cálculos, use matrices numpy como esta:

import numpy as np

a = np.ones((3,2))        # a 2D array with 3 rows, 2 columns, filled with ones
b = np.array([1,2,3])     # a 1D array initialised using a list [1,2,3]
c = np.linspace(2,3,100)  # an array with 100 points beteen (and including) 2 and 3

print(a*1.5)  # all elements of a times 1.5
print(a.T+b)  # b added to the transpose of a

Estas matrices numpy se pueden guardar y cargar desde el disco (incluso comprimido) y los cálculos complejos con grandes cantidades de elementos son rápidos como C.

Muy utilizado en entornos científicos. Mira aquí para más.

El comentario de JohnMachin debería ser la verdadera respuesta. ¡Todas las otras respuestas son solo soluciones en mi opinión! Entonces:

array=[0]*element_count

Un par de contribuciones sugirieron que las matrices en Python están representadas por listas. Esto es incorrecto. Python tiene una implementación independiente array()en el módulo de biblioteca estándar array " array.array()" por lo tanto, es incorrecto confundir los dos. Las listas son listas en python, así que tenga cuidado con la nomenclatura utilizada.

list_01 = [4, 6.2, 7-2j, 'flo', 'cro']

list_01
Out[85]: [4, 6.2, (7-2j), 'flo', 'cro']

Hay una diferencia muy importante entre list y array.array(). Si bien ambos objetos son secuencias ordenadas, array.array () es una secuencia homogénea ordenada, mientras que una lista es una secuencia no homogénea.

No declaras nada en Python. Solo lo usas. Te recomiendo que comiences con algo como http://diveintopython.net .

Normalmente haría lo a = [1,2,3]que en realidad es, listpero para arraysver esta definición formal

Para agregar a la respuesta de Lennart, se puede crear una matriz como esta:

from array import array
float_array = array("f",values)

donde los valores pueden tomar la forma de una tupla, lista o np.array, pero no una matriz:

values = [1,2,3]
values = (1,2,3)
values = np.array([1,2,3],'f')
# 'i' will work here too, but if array is 'i' then values have to be int
wrong_values = array('f',[1,2,3])
# TypeError: 'array.array' object is not callable

y la salida seguirá siendo la misma:

print(float_array)
print(float_array[1])
print(isinstance(float_array[1],float))

# array('f', [1.0, 2.0, 3.0])
# 2.0
# True

La mayoría de los métodos para la lista también funcionan con la matriz, los más comunes son pop (), extend () y append ().

A juzgar por las respuestas y comentarios, parece que la estructura de datos de la matriz no es tan popular. Sin embargo, me gusta, de la misma manera que uno preferiría una tupla a una lista.

La estructura de la matriz tiene reglas más estrictas que una lista o np.array, y esto puede reducir los errores y facilitar la depuración, especialmente cuando se trabaja con datos numéricos.

Los intentos de insertar / agregar un flotante a una matriz int arrojarán un TypeError:

values = [1,2,3]
int_array = array("i",values)
int_array.append(float(1))
# or int_array.extend([float(1)])

# TypeError: integer argument expected, got float

Por lo tanto, mantener los valores que están destinados a ser enteros (p. Ej., Lista de índices) en la forma de matriz puede evitar un "TypeError: los índices de lista deben ser enteros, no flotantes", ya que las matrices se pueden repetir, de forma similar a np.array y lists:

int_array = array('i',[1,2,3])
data = [11,22,33,44,55]
sample = []
for i in int_array:
    sample.append(data[i])

De manera molesta, agregar un int a una matriz flotante hará que int se convierta en flotante, sin lanzar una excepción.

np.array retiene el mismo tipo de datos para sus entradas también, pero en lugar de dar un error, cambiará su tipo de datos para que se ajusten a las nuevas entradas (generalmente a doble o str):

import numpy as np
numpy_int_array = np.array([1,2,3],'i')
for i in numpy_int_array:
    print(type(i))
    # <class 'numpy.int32'>
numpy_int_array_2 = np.append(numpy_int_array,int(1))
# still <class 'numpy.int32'>
numpy_float_array = np.append(numpy_int_array,float(1))
# <class 'numpy.float64'> for all values
numpy_str_array = np.append(numpy_int_array,"1")
# <class 'numpy.str_'> for all values
data = [11,22,33,44,55]
sample = []
for i in numpy_int_array_2:
    sample.append(data[i])
    # no problem here, but TypeError for the other two

Esto también es cierto durante la asignación. Si se especifica el tipo de datos, np.array, siempre que sea posible, transformará las entradas a ese tipo de datos:

int_numpy_array = np.array([1,2,float(3)],'i')
# 3 becomes an int
int_numpy_array_2 = np.array([1,2,3.9],'i')
# 3.9 gets truncated to 3 (same as int(3.9))
invalid_array = np.array([1,2,"string"],'i')
# ValueError: invalid literal for int() with base 10: 'string'
# Same error as int('string')
str_numpy_array = np.array([1,2,3],'str')
print(str_numpy_array)
print([type(i) for i in str_numpy_array])
# ['1' '2' '3']
# <class 'numpy.str_'>

o, en esencia:

data = [1.2,3.4,5.6]
list_1 = np.array(data,'i').tolist()
list_2 = [int(i) for i in data]
print(list_1 == list_2)
# True

mientras que array simplemente dará:

invalid_array = array([1,2,3.9],'i')
# TypeError: integer argument expected, got float

Debido a esto, no es una buena idea usar np.array para comandos específicos de tipo. La estructura de la matriz es útil aquí. La lista conserva el tipo de datos de los valores.

Y para algo que encuentro bastante molesto: el tipo de datos se especifica como el primer argumento en array (), pero (generalmente) el segundo en np.array (). : |

Aquí se hace referencia a la relación con C: Python List vs. Array: ¿cuándo usarla?

Diviértete explorando!

Nota: La naturaleza tipificada y bastante estricta de la matriz se inclina más hacia C en lugar de Python, y por diseño Python no tiene muchas restricciones específicas de tipo en sus funciones. Su impopularidad también crea una retroalimentación positiva en el trabajo colaborativo, y su reemplazo implica principalmente un [int (x) para x en el archivo]. Por lo tanto, es completamente viable y razonable ignorar la existencia de una matriz. No debería obstaculizar a la mayoría de nosotros de ninguna manera. :RE

Qué tal esto...

>>> a = range(12)
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
>>> a[7]
6

Python los llama listas . Puede escribir una lista literal con corchetes y comas:

>>> [6,28,496,8128]
[6, 28, 496, 8128]

Siguiendo a Lennart, también hay numpy que implementa matrices multidimensionales homogéneas.

Tenía una serie de cadenas y necesitaba una matriz de la misma longitud de booleanos iniciados en True. Esto es lo que hice

strs = ["Hi","Bye"] 
bools = [ True for s in strs ]

Puede crear listas y convertirlas en matrices o puede crear una matriz utilizando el módulo numpy. A continuación hay algunos ejemplos para ilustrar lo mismo. Numpy también facilita el trabajo con matrices multidimensionales.

import numpy as np
a = np.array([1, 2, 3, 4])

#For custom inputs
a = np.array([int(x) for x in input().split()])

También puede remodelar esta matriz en una matriz de 2X2 utilizando la función de remodelación que toma la entrada como las dimensiones de la matriz.

mat = a.reshape(2, 2)