Jak zadeklarować tablicę w Pythonie ?

Nie mogę znaleźć żadnego odniesienia do tablic w dokumentacji.

variable = []

Teraz variableodnosi się do pustej listy ^* .

Oczywiście jest to zadanie, a nie deklaracja. W Pythonie nie można powiedzieć „ta zmienna nigdy nie powinna odnosić się do niczego innego niż listy”, ponieważ Python jest dynamicznie wpisywany.

^* Domyślny wbudowany typ Pythona nazywa się listą , a nie tablicą. Jest to uporządkowany pojemnik o dowolnej długości, który może pomieścić heterogeniczny zbiór obiektów (ich typy nie mają znaczenia i można je dowolnie mieszać). Nie należy tego mylić z arraymodułem , który oferuje typ bliższy arraytypowi C ; zawartość musi być jednorodna (wszystkie tego samego typu), ale długość jest wciąż dynamiczna.

Jest to zaskakująco złożony temat w Pythonie.

Praktyczna odpowiedź

Tablice są reprezentowane przez klasy list(patrz odnośnik i nie mieszaj ich z generatorami ).

Sprawdź przykłady użycia:

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

Teoretyczna odpowiedź

Pod maską Python's listjest opakowaniem dla prawdziwej tablicy, która zawiera odniesienia do przedmiotów. Ponadto tworzona jest podstawowa tablica z dodatkową przestrzenią.

Konsekwencjami tego są:

• losowy dostęp jest naprawdę tani ( arr[6653]to samo co arr[0])
• append operacja jest „za darmo”, podczas gdy jest trochę miejsca
• insert operacja jest droga

Sprawdź tę niesamowitą złożoność operacji .

Zobacz także to zdjęcie, na którym próbowałem pokazać najważniejsze różnice między tablicą, tablicą referencji i połączoną listą:

W rzeczywistości nie deklarujesz rzeczy, ale w ten sposób tworzysz tablicę w Pythonie:

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

Aby uzyskać więcej informacji, zobacz moduł macierzy: http://docs.python.org/library/array.html

Możliwe, że nie chcesz tablicy, ale listy, ale inni już na to odpowiedzieli. :)

Myślę, że (miałeś na myśli) chcesz listę z 30 pierwszymi komórkami już wypełnionymi. Więc

   f = []

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

Przykładem tego może być sekwencja Fibonacciego. Zobacz problem 2 w Project Euler

Oto jak:

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

Do obliczeń użyj tablic numpy takich jak to:

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

te tablice numpy mogą być zapisywane i ładowane z dysku (nawet skompresowane), a złożone obliczenia z dużą ilością elementów są szybko podobne do C.

Często stosowany w środowiskach naukowych. Zobacz tutaj po więcej.

Komentarz JohnMachin powinien być prawdziwą odpowiedzią. Moim zdaniem wszystkie pozostałe odpowiedzi są tylko obejściami! Więc:

array=[0]*element_count

Kilka wypowiedzi sugerowało, że tablice w pythonie są reprezentowane przez listy. To jest niepoprawne. Python posiada niezależne wdrożenia array()w standardowym module biblioteki array „ array.array()” więc jest nieprawidłowe mylić dwóch. Listy są listami w pythonie, więc bądź ostrożny z zastosowaną nomenklaturą.

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

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

Jest jedna bardzo ważna różnica między listą a array.array(). Podczas gdy oba te obiekty są sekwencjami uporządkowanymi, array.array () jest uporządkowanymi sekwencjami homogenicznymi, podczas gdy lista jest sekwencją niejednorodną.

Nic nie deklarujesz w Pythonie. Po prostu go użyj. Polecam zacząć od czegoś takiego jak http://diveintopython.net .

Zazwyczaj robiłbym to, a = [1,2,3]co właściwie jest listtylko arraysspojrzeniem na tę formalną definicję

Aby dodać do odpowiedzi Lennarta, można utworzyć tablicę w następujący sposób:

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

gdzie wartości mogą przyjąć postać krotki, listy lub np.array, ale nie tablicy:

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

a wynik pozostanie taki sam:

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

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

Większość metod list działa również z tablicą, najczęściej są to pop (), ext () i append ().

Sądząc z odpowiedzi i komentarzy, wydaje się, że struktura danych tablicowych nie jest tak popularna. Podoba mi się to tak samo, jak ktoś wolałby krotkę niż listę.

Struktura tablicy ma bardziej rygorystyczne reguły niż lista lub tablica np., Co może zmniejszyć liczbę błędów i ułatwić debugowanie, szczególnie podczas pracy z danymi numerycznymi.

Próby wstawienia / dołączenia liczby zmiennoprzecinkowej do tablicy int spowodują błąd 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

Zachowanie wartości, które mają być liczbami całkowitymi (np. Lista indeksów) w formie tablicy, może zatem zapobiec „Typowi błędu: indeksy list muszą być liczbami całkowitymi, a nie zmiennoprzecinkowymi”, ponieważ tablice można iterować, podobnie jak np. Tablica i listy:

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

Irytujące dodanie int do tablicy zmiennoprzecinkowej spowoduje, że int stanie się zmiennoprzecinkową, bez zgłaszania wyjątku.

np.array zachowuje również ten sam typ danych dla swoich wpisów, ale zamiast dawać błąd, zmieni typ danych, aby pasował do nowych wpisów (zwykle podwoić lub 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

Dotyczy to również zadania. Jeśli zostanie określony typ danych, np.array, w miarę możliwości, przekształci wpisy do tego typu danych:

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

lub w istocie:

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

podczas gdy tablica da po prostu:

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

Z tego powodu nie warto używać np.array do poleceń specyficznych dla typu. Przydaje się tutaj struktura tablic. lista zachowuje typ danych wartości.

A dla czegoś uważam raczej za nieznośne: typ danych jest określony jako pierwszy argument w tablicy (), ale (zwykle) drugi w np.array (). : |

Relacja do C jest przywołana tutaj: Python List vs. Array - kiedy używać?

Miłej zabawy podczas odkrywania!

Uwaga: Typowa i raczej ścisła natura tablicy bardziej opiera się na C niż na Pythonie, a z założenia Python nie ma wielu specyficznych dla typu ograniczeń w swoich funkcjach. Jego niepopularność powoduje również pozytywne opinie we współpracy, a zastąpienie go wiąże się głównie z dodatkowym [int (x) dla x w pliku]. Dlatego ignorowanie istnienia tablicy jest całkowicie wykonalne i rozsądne. Nie powinno to w żaden sposób utrudniać większości z nas. :RE

Co powiesz na to...

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

Python nazywa je listami . Możesz napisać literał listy za pomocą nawiasów kwadratowych i przecinków:

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

Kontynuując od Lennarta, istnieje również numpy, które implementuje jednorodne tablice wielowymiarowe.

Miałem tablicę ciągów i potrzebowałem tablicy o tej samej długości booleanów zainicjowanych na True. Oto co zrobiłem

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

Możesz tworzyć listy i konwertować je na tablice lub tworzyć tablice za pomocą modułu numpy. Poniżej kilka przykładów ilustrujących to samo. Numpy ułatwia także pracę z tablicami wielowymiarowymi.

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

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

Możesz także przekształcić tę tablicę w macierz 2X2, używając funkcji zmiany kształtu, która pobiera dane wejściowe jako wymiary macierzy.

mat = a.reshape(2, 2)