Como declaro uma matriz em Python ?

Não consigo encontrar nenhuma referência a matrizes na documentação.

variable = []

Agora variablese refere a uma lista vazia ^* .

Claro que isso é uma tarefa, não uma declaração. Não há como dizer no Python "essa variável nunca deve se referir a nada além de uma lista", pois o Python é digitado dinamicamente.

^* O tipo Python interno padrão é chamado de lista , não uma matriz. É um contêiner ordenado de comprimento arbitrário que pode conter uma coleção heterogênea de objetos (seus tipos não importam e podem ser livremente misturados). Isso não deve ser confundido com o arraymódulo , que oferece um tipo mais próximo do arraytipo C ; o conteúdo deve ser homogêneo (do mesmo tipo), mas o comprimento ainda é dinâmico.

Este é um tópico surpreendentemente complexo em Python.

Resposta prática

Matrizes são representadas por classe list(consulte a referência e não as misture com geradores ).

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

Resposta teórica

Sob o capô, o Python's listé um invólucro para uma matriz real que contém referências a itens. Além disso, a matriz subjacente é criada com algum espaço extra.

As consequências disso são:

• acesso aleatório é muito barato ( arr[6653]é o mesmo que arr[0])
• append operação é "de graça", enquanto algum espaço extra
• insert operação é cara

Verifique esta impressionante tabela de complexidade de operações .

Além disso, veja esta imagem, onde tentei mostrar as diferenças mais importantes entre matriz, matriz de referências e lista vinculada:

Na verdade, você não declara as coisas, mas é assim que você cria uma matriz no Python:

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

Para mais informações, consulte o módulo de matriz: http://docs.python.org/library/array.html

Agora é possível que você não queira uma matriz, mas uma lista, mas outras pessoas já responderam isso. :)

Eu acho que você quer dizer uma lista com as 30 primeiras células já preenchidas. assim

   f = []

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

Um exemplo de onde isso poderia ser usado está na sequência de Fibonacci. Veja o problema 2 no Projeto Euler

É assim:

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

Para cálculos, use matrizes numpy como este:

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

essas matrizes numpy podem ser salvas e carregadas do disco (mesmo compactadas) e cálculos complexos com grandes quantidades de elementos são rápidos como C.

Muito usado em ambientes científicos. Veja aqui para mais.

O comentário de JohnMachin deve ser a resposta real. Todas as outras respostas são apenas soluções alternativas na minha opinião! Assim:

array=[0]*element_count

Algumas contribuições sugeriram que matrizes em python são representadas por listas. Isto está incorreto. O Python possui uma implementação independente array()no array " array.array()" módulo de biblioteca padrão, portanto, é incorreto confundir os dois. As listas são listas em python, portanto, tenha cuidado com a nomenclatura usada.

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

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

Há uma diferença muito importante entre lista e array.array(). Enquanto esses dois objetos são seqüências ordenadas, array.array () é uma sequência homogênea ordenada, enquanto uma lista é uma sequência não homogênea.

Você não declara nada no Python. Você apenas usa. Eu recomendo que você comece com algo como http://diveintopython.net .

Normalmente, eu faria apenas o a = [1,2,3]que é realmente um, listmas arraysolhe para esta definição formal

Para adicionar à resposta de Lennart, uma matriz pode ser criada assim:

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

onde os valores podem assumir a forma de uma tupla, lista ou np.array, mas não uma 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

e a saída ainda será a mesma:

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

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

A maioria dos métodos de lista também funciona com array, sendo os comuns pop (), extend () e append ().

A julgar pelas respostas e comentários, parece que a estrutura de dados da matriz não é tão popular. Eu gosto, porém, da mesma maneira que se pode preferir uma tupla a uma lista.

A estrutura da matriz possui regras mais rígidas que uma lista ou np.array, e isso pode reduzir erros e facilitar a depuração, especialmente ao trabalhar com dados numéricos.

Tentativas de inserir / acrescentar um ponto flutuante a uma matriz int lançarão um 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

Manter valores que devem ser números inteiros (por exemplo, lista de índices) no formato de matriz pode, portanto, impedir um "TypeError: os índices de lista devem ser números inteiros, não flutuantes", pois as matrizes podem ser iteradas, semelhante a np.array e lists:

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

Irritantemente, anexar um int a uma matriz flutuante fará com que o int se torne um flutuante, sem gerar uma exceção.

O np.array também retém o mesmo tipo de dados para suas entradas, mas em vez de dar um erro, ele mudará seu tipo de dados para ajustar novas entradas (geralmente para double ou 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

Isso também ocorre durante a atribuição. Se o tipo de dados for especificado, o np.array, sempre que possível, transformará as entradas nesse tipo de dados:

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_'>

ou, em essência:

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

enquanto array simplesmente dará:

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

Por esse motivo, não é uma boa ideia usar o np.array para comandos específicos de tipo. A estrutura da matriz é útil aqui. lista preserva o tipo de dados dos valores.

E para algo que eu acho bastante incômodo: o tipo de dados é especificado como o primeiro argumento em array (), mas (geralmente) o segundo em np.array (). : |

A relação com C é referida aqui: Lista Python vs. Matriz - quando usar?

Divirta-se explorando!

Nota: A natureza tipificada e estrita da matriz se inclina mais para C do que para Python, e por design o Python não possui muitas restrições específicas de tipo em suas funções. Sua impopularidade também cria um feedback positivo no trabalho colaborativo, e sua substituição envolve principalmente um [int (x) adicional para x no arquivo]. Portanto, é inteiramente viável e razoável ignorar a existência de matriz. Isso não deve atrapalhar a maioria de nós de forma alguma. : D

Que tal agora...

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

Python os chama de listas . Você pode escrever uma lista literal entre colchetes e vírgulas:

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

Na sequência do Lennart, há também numpy que implementa homogêneos matrizes multi-dimensionais.

Eu tinha uma matriz de seqüências de caracteres e precisava de uma matriz do mesmo comprimento de booleanos iniciados em True. Foi o que eu fiz

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

Você pode criar listas e convertê-las em matrizes ou criar matriz usando o módulo numpy. Abaixo estão alguns exemplos para ilustrar o mesmo. O Numpy também facilita o trabalho com matrizes multidimensionais.

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

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

Você também pode remodelar essa matriz em uma matriz 2X2 usando a função remodelar, que recebe entradas como as dimensões da matriz.

mat = a.reshape(2, 2)