Come posso dichiarare un array in Python ?

Non riesco a trovare alcun riferimento agli array nella documentazione.

variable = []

Ora variablefa riferimento a un elenco vuoto ^* .

Naturalmente questo è un incarico, non una dichiarazione. In Python non c'è modo di dire "questa variabile non dovrebbe mai fare riferimento a nient'altro che a un elenco", poiché Python è digitato in modo dinamico.

^* Il tipo predefinito di Python incorporato è chiamato un elenco , non un array. È un contenitore ordinato di lunghezza arbitraria che può contenere una raccolta eterogenea di oggetti (i loro tipi non contano e possono essere mescolati liberamente). Questo non deve essere confuso con il arraymodulo , che offre un tipo più vicino al arraytipo C ; i contenuti devono essere omogenei (tutti dello stesso tipo), ma la lunghezza è ancora dinamica.

Questo è un argomento sorprendentemente complesso in Python.

Risposta pratica

Le matrici sono rappresentate per classe list(vedi riferimento e non mescolarle con generatori ).

Dai un'occhiata agli esempi di utilizzo:

# 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)

Risposta teorica

Python's listè un involucro per un array reale che contiene riferimenti ad elementi. Inoltre, l'array sottostante viene creato con dello spazio aggiuntivo.

Le conseguenze di questo sono:

• l'accesso casuale è davvero economico ( arr[6653]è uguale a arr[0])
• append l'operazione è "gratuita" pur con un po 'di spazio in più
• insert l'operazione è costosa

Dai un'occhiata a questa fantastica tabella delle complessità operative .

Inoltre, vedi questa immagine, dove ho provato a mostrare le differenze più importanti tra array, array di riferimenti ed elenco collegato:

In realtà non dichiari cose, ma è così che crei un array in Python:

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

Per ulteriori informazioni, consultare il modulo array: http://docs.python.org/library/array.html

Ora possibile non vuoi un array, ma un elenco, ma altri hanno già risposto. :)

Penso che tu volessi dire un elenco con le prime 30 celle già riempite. Così

   f = []

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

Un esempio di dove questo potrebbe essere usato è nella sequenza di Fibonacci. Vedi problema 2 in Project Euler

Questo è come:

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

Per i calcoli, utilizzare matrici intorpidite in questo modo:

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

questi array intorpiditi possono essere salvati e caricati dal disco (anche compressi) e calcoli complessi con grandi quantità di elementi sono veloci come C.

Molto usato in ambienti scientifici. Vedi qui per di più.

Il commento di JohnMachin dovrebbe essere la vera risposta. Tutte le altre risposte sono solo soluzioni alternative secondo me! Così:

array=[0]*element_count

Un paio di contributi hanno suggerito che le matrici in Python sono rappresentate da liste. Questo non è corretto Python ha un'implementazione indipendente array()nel modulo di libreria standard array " array.array()", quindi non è corretto confondere i due. Gli elenchi sono elenchi in Python, quindi fai attenzione alla nomenclatura utilizzata.

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

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

C'è una differenza molto importante tra list e array.array(). Mentre entrambi questi oggetti sono sequenze ordinate, array.array () è una sequenza ordinata omogenea mentre un elenco è una sequenza non omogenea.

Non dichiari nulla in Python. Lo usi e basta. Ti consiglio di iniziare con qualcosa come http://diveintopython.net .

Io normalmente solo fare a = [1,2,3]che in realtà è una list, ma per arraysdare un'occhiata a questo formale definizione

Per aggiungere alla risposta di Lennart, un array può essere creato in questo modo:

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

dove i valori possono assumere la forma di una tupla, elenco o np.array, ma non 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 l'output sarà sempre lo stesso:

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 maggior parte dei metodi per la lista funziona anche con array, quelli comuni sono pop (), extend () e append ().

A giudicare dalle risposte e dai commenti, sembra che la struttura dei dati dell'array non sia così popolare. Mi piace però, allo stesso modo in cui si potrebbe preferire una tupla a una lista.

La struttura dell'array ha regole più rigide rispetto a un elenco o np.array, e questo può ridurre gli errori e rendere più facile il debug, specialmente quando si lavora con dati numerici.

I tentativi di inserire / aggiungere un float a un array int genereranno 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

Mantenere valori che si intendono essere numeri interi (ad es. Elenco di indici) nella forma di array può quindi impedire un "TypeError: gli indici di elenco devono essere numeri interi, non float", poiché gli array possono essere ripetuti, in modo simile 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])

In modo fastidioso, l'aggiunta di un int a un array float farà sì che l'int diventi un float, senza generare un'eccezione.

np.array mantiene lo stesso tipo di dati anche per le sue voci, ma invece di dare un errore cambierà il suo tipo di dati per adattarlo alle nuove voci (solitamente raddoppiare 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

Questo vale anche durante il compito. Se viene specificato il tipo di dati, np.array, ove possibile, trasformerà le voci in quel tipo di dati:

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, in sostanza:

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

mentre array fornirà semplicemente:

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

Per questo motivo, non è una buona idea usare np.array per comandi specifici del tipo. La struttura dell'array è utile qui. list conserva il tipo di dati dei valori.

E per qualcosa che trovo piuttosto fastidioso: il tipo di dati è specificato come primo argomento in array (), ma (di solito) il secondo in np.array (). : |

La relazione con C è indicata qui: Python List vs. Array - quando usare?

Divertiti a esplorare!

Nota: la natura tipizzata e piuttosto rigorosa dell'array tende più verso C piuttosto che su Python e, in base alla progettazione, Python non ha molti vincoli specifici del tipo nelle sue funzioni. La sua impopolarità crea anche un feedback positivo nel lavoro collaborativo e la sua sostituzione comporta principalmente un ulteriore [int (x) per x nel file]. È quindi del tutto fattibile e ragionevole ignorare l'esistenza dell'array. Non dovrebbe ostacolare la maggior parte di noi in alcun modo. : D

Cosa ne pensi di questo...

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

Python li chiama elenchi . Puoi scrivere un elenco letterale con parentesi quadre e virgole:

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

In seguito a Lennart, c'è anche l' intorpidimento che implementa array multidimensionali omogenei.

Avevo una serie di stringhe e avevo bisogno di una matrice della stessa lunghezza di booleani avviata su True. Questo è quello che ho fatto

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

È possibile creare elenchi e convertirli in array oppure è possibile creare array utilizzando il modulo numpy. Di seguito sono riportati alcuni esempi per illustrare lo stesso. Numpy semplifica anche il lavoro con array multidimensionali.

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

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

Puoi anche rimodellare questo array in una matrice 2X2 usando la funzione reshape che accetta input come dimensioni della matrice.

mat = a.reshape(2, 2)