variable = []

Agora variable refere-se a uma lista vazia^*.

^*o tipo de Python embutido por omissão é chamado de list , não um array. É um contêiner ordenado de comprimento arbitrário que pode conter uma coleção heterogênea de objetos (seus tipos não importam e pode ser misturado livremente). Isto não deve ser confundido com o array módulo, que oferece um tipo mais perto do C array tipo; o conteúdo deve ser homogênea (todos do mesmo tipo), mas o comprimento ainda é dinâmico.

Você realmente não declara coisas, mas é assim que você cria um array em Python:

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

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

Resposta prática

As matrizes são representadas pela classe list (ver referência e não as misture com geradores ).

Veja exemplos de Utilização:

# 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 hood Python's list está uma embalagem para um array real que contém referências a itens. Além disso, a matriz subjacente é criada com algum espaço extra.

Consequências disto são:

• o acesso aleatório é realmente barato ({[3] } é o mesmo para arr[0])
• append a operação é 'gratuita' enquanto que algum espaço extra
• insert a operação é cara

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

Também, por favor veja esta imagem, onde eu tentei mostrar as diferenças mais importantes entre array, array de referências e lista ligada:

   f = []

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

Um exemplo para onde isto pode ser usado é na sequência de Fibonacci. Ver o problema 2 em projecto Euler

É assim que:

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

Para cálculos, utilizar matrizes 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 matrizes numpy podem ser gravadas e carregadas a partir do disco (mesmo comprimidas) e cálculos complexos com grandes quantidades de elementos são rápidos. Muito usado em ambientes científicos. Veja aqui para mais...

Eu normalmente faria {[[0]} o que é realmente um list mas para arrays olha para esta definição formal

Algumas contribuições sugeriram que as matrizes em python são representadas por listas. Talvez teoricamente / sob o capô que é correto no entanto, uma grande distinção entre os dois é o fato de que listas aceitam tipos de dados mistos e tipos numéricos mistos, por outro lado array requer um tipo-código restringindo todos os elementos ao tipo determinado:

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

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

Isto não é possível usando array ().

Para adicionar à resposta de Lennart, um array pode ser criado assim:

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

Onde Os valores {[14] } podem assumir a forma de uma tupla, lista ou np.array, mas não array:

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 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 para a lista também funciona com array, comum ones being pop (), extend (), and append ().

A estrutura da matriz tem regras mais rigorosas do que uma lista ou np.array, e isto pode reduzir os erros e tornar a depuração mais fácil, especialmente quando se trabalha com números dado.

As tentativas de inserir/adicionar um 'float' a um ' int ' irão criar um erro tipográfico:

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 se destinam a ser inteiros (por exemplo, lista de índices) na matriz o formulário pode, portanto, impedir um "erro tipográfico: os índices da lista devem ser inteiros, não flutuantes", uma vez que os arrays podem ser iterados, semelhante ao np.lista e listas:

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

Np.array retain the same data type for its entries too, but instead of giving an error it will change its data type to fit new entries (usually to double or 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

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 o array vai simplesmente dar:

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

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

A a relação com C é referida aqui: lista Python vs. Array - quando usar?

Nota: a natureza tipada e bastante estrita de array inclina-se mais para C em vez de Python, e pelo design Python não tem muitas restrições específicas de tipo em suas funções. Sua impopularidade também cria um feedback positivo no trabalho colaborativo, e substituí-lo envolve principalmente um adicional [int(x) para x em arquivo]. Por conseguinte, é inteiramente viável e razoável ignore a existência do array. Não deve impedir a maioria de nós. : D

O Python chama-os listas . Você pode escrever uma lista literal com parêntesis rectos e vírgulas:

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

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

Eu tinha uma série de cordas e precisava de uma matriz do mesmo comprimento dos booleanos iniciada para True. Foi isto que fiz.

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

Você pode criar listas e convertê-las em arrays ou você pode criar array usando o módulo numpy. Abaixo estão alguns exemplos para ilustrar o mesmo. Numpy também torna mais fácil trabalhar 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 este array em uma matriz 2X2 usando uma função de remodelação que toma em entrada como as dimensões da matriz.

mat = a.reshape(2, 2)

O Comentário de JohnMachin deve ser a verdadeira resposta. Na minha opinião, todas as outras respostas são meros resultados! Então ...

array=[0]*element_count