variable = []

Acum variabil se referă la o listă goală*.

Desigur, aceasta este o misiune, nu o declarație. Nu's nici o modalitate de a spune în Python "această variabilă nu ar trebui să se refere la altceva decât o listă", deoarece Python este dinamic tastat.

implicit built-in Python tip este numit un lista*, nu o matrice. Acesta este un a ordonat recipient de lungime arbitrară, care poate deține un eterogene colecție de obiecte (tipurile lor nu contează și poate fi amestecat în mod liber). Acest lucru nu trebuie confundat cu "matrice" modul](https://docs.python.org/2/library/array.html), care oferă un tip mai aproape de C "matrice" de tip; conținutul trebuie să fie omogene (toate de același tip), dar lungimea este mai dinamic.

Acest lucru este surprinzator de complex subiect în Python.

Raspuns practic

Tablouri sunt reprezentate de clasa "listă" (a se vedea referință și nu le amesteca cu generatoarele).

Check out exemple de utilizare:

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

Răspuns teoretic

Sub capota Python's "listă" este un înveliș pentru o adevărată matrice care conține referințe către obiecte. De asemenea, de fond al sistemului matrice este creat cu un spațiu suplimentar.

Consecințele acestui lucru sunt:

• acces aleator este foarte ieftin (arr[6653] este același cu arr[0])
• append operațiunea este 'gratuit' în timp ce un spațiu suplimentar
• "insert" operațiunea este scump

Verifica acest lucru minunat masă de operații de complexitate.

De asemenea, vă rugăm să consultați această imagine, în cazul în care nu'am încercat să arăt cele mai importante diferențe între matrice, matrice de referințe și lista inlantuita:

Nu't de fapt declare lucruri, dar acest lucru este modul în care creați o matrice în Python:

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

Pentru mai multe informatii vezi matrice module: http://docs.python.org/library/array.html

Acum este posibil nu't doresc o matrice, dar o listă, dar alții au răspuns deja. :)

Cred că (însemnat)vreau o lista cu primele 30 de celule deja umplut. Deci

   f = []

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

Un exemplu în cazul în care acest lucru ar putea fi utilizată este în secvența lui Fibonacci. Vezi problema 2 în Project Euler

Acesta este modul:

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

Câteva contribuții sugerat că matrice în python sunt reprezentate de liste. Acest lucru este incorect. Python are un independent implementarea de matrice()în biblioteca standard modulul "matrice" "matrice.array()`", prin urmare, este incorect să se confunde cele două. Listele sunt liste în python astfel încât să fie atent cu nomenclatura utilizată.

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

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

Există o diferență foarte importantă între listă și matrice.array()`. În timp ce ambele aceste obiecte sunt ordonate în secvențe, matrice.array() este un a ordonat omogen secvențe întrucât lista este un non-omogen secvență.

Nu't declare nimic în Python. Doar-l utilizați. Iti recomand sa incepi cu ceva de genul http://diveintopython.net.

Pentru calcularea, utilizarea numpy matrice astfel:

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

aceste numpy tablouri pot fi salvate și încărcate de pe disc (chiar si comprimat) și calcule complexe cu cantități mari de elemente sunt C-ca rapid.

Mult folosit în mediile științifice. A se vedea aici pentru mai multe.

În mod normal, aș face doar a = [1,2,3] care este de fapt o "lista" dar de tablouri uită-te la acest formale definiție

Pentru a adăuga la Lennart's a răspunde, un tablou poate fi creat astfel:

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

unde valori poate lua forma unui tuplu, listă, sau np.matrice, dar nu matrice:

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

și rezultatul va fi același:

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

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

Cele mai multe metode pentru lista lucra cu matrice, precum și, comun fiind pop(), extend(), și append().

Judecând după răspunsurile și comentariile, se pare ca matrice structura de date e't atât de popular. Îmi place, deși, la fel cum ca s-ar putea prefera un tuplu pe o listă.

Matricea de structură a unor norme mai stricte decât o listă sau np.matrice, și acest lucru poate reduce erorile și de a face depanare mai ușor, mai ales atunci când se lucrează cu numerică date.

Încercările de a introduce/adăuga un flotor pentru o matrice int va arunca o 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

Păstrarea valorilor care sunt menite să fie numere întregi (de exemplu, lista de indici) în matrice forma, prin urmare, poate preveni un "TypeError: lista indicilor trebuie să fie întregi, nu float", deoarece vectorii pot fi reiterat peste, similar cu np.matrice și liste:

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

Enervant, adăugarea la o int float matrice va provoca int pentru a deveni un float, fără a arunca o excepție.

np.matrice păstra același tip de date pentru intrările sale, dar în loc de a da o eroare se va schimba tipul de date pentru a se potrivi noilor intrări (de obicei, pentru a dubla sau str):

import numpy as np
numpy_int_array = np.array([1,2,3],'i')
for i in numpy_int_array:
    print(type(i))
    # 
numpy_int_array_2 = np.append(numpy_int_array,int(1))
# still 
numpy_float_array = np.append(numpy_int_array,float(1))
#  for all values
numpy_str_array = np.append(numpy_int_array,"1")
#  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

Acest lucru este adevărat în misiune la fel de bine. Dacă tipul de date este specificat, np.matrice va, ori de câte ori este posibil, transforma intrarile la acest tip de date:

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']
# 

sau, în esenta:

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

în timp ce matricea se va da pur și simplu:

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

Din aceasta cauza, nu este o idee bună să utilizați np.matrice de tip comenzi specifice. Matrice structura este util aici. lista păstrează tip de date de valori.

Și pentru ceva ce mi se pare destul de plictisitor: tipul de date este specificat ca prim argument în matrice(), dar (de obicei) cel de-al doilea în np.array(). :|

În ceea ce privește C este menționată aici: https://stackoverflow.com/questions/176011/python-list-vs-array-when-to-use

Distreaza-te explorarea!

Notă: scris și mai degrabă de natură strict de matrice înclină mai mult spre C, mai degrabă decât Python, și de design Python nu au multe de tip constrângeri specifice în funcțiile sale. Lipsa de popularitate, de asemenea, creează un feedback pozitiv în munca în colaborare, și înlocuind-o cu cea mai mare implică o suplimentare [int(x) pentru x în fișier]. Prin urmare, este în întregime viabilă și rezonabile pentru a ignora existența unei matrice. Nu ar trebui't să împiedice cele mai multe dintre noi în nici un fel. :D

Ce zici de asta...

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

JohnMachin's comentariu ar trebui să fie răspunsul real. Toate celelalte răspunsuri sunt doar soluții temporare, în opinia mea! Deci:

array=[0]*element_count

Python le spune liste. Puteți scrie o listă literal cu paranteze și virgule:

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

În urma Lennart, acolo's, de asemenea, numpy, care pune în aplicare omogenă matrice multi-dimensionale.

Am avut-o matrice de siruri de caractere și avea nevoie de o matrice de aceeași lungime de booleans inițiat cu Adevărat. Aceasta este ceea ce am făcut

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

Puteți crea liste și de a le converti în tablouri sau puteți crea matrice folosind numpy module. Mai jos sunt câteva exemple pentru a ilustra aceeași. Numpy, de asemenea, face mai ușor de a lucra cu matrice multi-dimensionale.

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

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

Puteți, de asemenea, remodela această matrice într-o matrice 2X2, folosind remodela funcție care are la intrare ca dimensiunile matricei.

mat = a.reshape(2, 2)