Как мне объявить массив в Python ?

Я не могу найти ссылки на массивы в документации.

variable = []

Теперь variableотносится к пустому списку ^* .

Конечно, это задание, а не декларация. В Python нет никакого способа сказать «эта переменная никогда не должна ссылаться ни на что, кроме списка», поскольку Python динамически типизирован.

^* Встроенный тип Python по умолчанию называется списком , а не массивом. Это упорядоченный контейнер произвольной длины, который может содержать гетерогенную коллекцию объектов (их типы не имеют значения и могут свободно смешиваться). Это не следует путать с arrayмодулем , который предлагает тип ближе к arrayтипу C ; содержимое должно быть однородным (все одного типа), но длина по-прежнему динамична.

Это удивительно сложная тема в Python.

Практический ответ

Массивы представлены классом list(см. Ссылку и не смешивайте их с генераторами ).

Посмотрите примеры использования:

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

Теоретический ответ

Под капотом Python listнаходится обертка для реального массива, который содержит ссылки на элементы. Кроме того, базовый массив создается с дополнительным пространством.

Последствия этого:

• произвольный доступ действительно дешево (то arr[6653]же самое arr[0])
• append операция «бесплатно», в то время как дополнительное пространство
• insert операция дорогая

Проверьте эту удивительную таблицу сложности операций .

Также, пожалуйста, посмотрите на эту картинку, где я попытался показать наиболее важные различия между массивом, массивом ссылок и связанным списком:

Вы на самом деле не объявляете вещи, но вот как вы создаете массив в Python:

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

Для получения дополнительной информации см. Модуль массива: http://docs.python.org/library/array.html.

Теперь возможно, вы не хотите массив, но список, но другие уже ответили на это. :)

Я думаю, что вы (имели в виду) хотите список с уже заполненными первыми 30 ячейками. Так

   f = []

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

Примером того, где это можно использовать, является последовательность Фибоначчи. Смотрите проблему 2 в Project Euler

Вот как:

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

Для расчетов используйте массивы numpy :

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

эти массивы могут быть сохранены и загружены с диска (даже сжаты), а сложные вычисления с большим количеством элементов выполняются быстро, как C.

Многое используется в научной среде. Смотрите здесь для получения дополнительной информации.

Комментарий Джона Мачина должен быть реальным ответом. Все остальные ответы - просто обходные пути, на мой взгляд! Так:

array=[0]*element_count

В нескольких предложениях предполагается, что массивы в python представлены списками. Это неверно Python имеет независимую реализацию array()в стандартном библиотечном модуле array " array.array()", поэтому неправильно путать их. Списки - это списки в Python, поэтому будьте осторожны с используемой номенклатурой.

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

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

Есть одно очень важное различие между списком и array.array(). Хотя оба этих объекта являются упорядоченными последовательностями, array.array () является упорядоченной однородной последовательностью, тогда как список является неоднородной последовательностью.

Вы ничего не объявляете в Python. Вы просто используете это. Я рекомендую вам начать с чего-то вроде http://diveintopython.net .

Я обычно просто делаю, a = [1,2,3]что на самом деле, listно для arraysвзгляда на это формальное определение

Чтобы добавить к ответу Леннарта, массив может быть создан следующим образом:

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

где значения могут принимать форму кортежа, списка или np.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

и результат будет все тот же:

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

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

Большинство методов для работы со списком также работают с массивом, распространенными из которых являются pop (), exte () и append ().

Судя по ответам и комментариям, кажется, что структура данных массива не так популярна. Хотя мне это нравится, так же, как можно предпочесть кортеж списку.

Структура массива имеет более строгие правила, чем список или np.array, и это может уменьшить количество ошибок и упростить отладку, особенно при работе с числовыми данными.

Попытки вставить / добавить float в массив int приведут к возникновению ошибки 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

Хранение значений, которые должны быть целыми числами (например, список индексов) в форме массива, может поэтому предотвратить «TypeError: индексы списка должны быть целыми числами, а не с плавающей точкой», так как массивы могут быть перебраны, подобно np.array и lists:

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

Досадно, что добавление int в массив float приведет к тому, что int станет float, не вызывая исключения.

np.array также сохраняет тот же тип данных для своих записей, но вместо сообщения об ошибке он изменит свой тип данных, чтобы соответствовать новым записям (обычно удваивается или 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

Это верно и во время выполнения задания. Если указан тип данных, np.array, по возможности, преобразует записи в этот тип данных:

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

или, по сути:

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

в то время как массив просто даст:

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

Из-за этого не рекомендуется использовать np.array для команд, зависящих от типа. Структура массива здесь полезна. list сохраняет тип данных значений.

И для чего-то я нахожу довольно противным: тип данных указывается в качестве первого аргумента в array (), но (обычно) в качестве аргумента в np.array (). : |

Отношение к C упоминается здесь: список Python против массива - когда использовать?

Веселитесь, исследуя!

Примечание: типизированный и довольно строгий характер массива больше склоняется к C, а не к Python, и в своем дизайне Python не имеет многих специфичных для типа ограничений в своих функциях. Его непопулярность также создает положительную обратную связь в совместной работе, и замена его в основном включает дополнительный [int (x) для x в файле]. Поэтому вполне целесообразно и разумно игнорировать существование массива. Это не должно мешать большинству из нас. : D

Как насчет этого...

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

Python называет их списками . Вы можете написать список литералов в квадратных скобках и запятых:

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

Вслед за Леннартом есть еще numpy, который реализует однородные многомерные массивы.

У меня был массив строк, и мне требовался массив логических значений той же длины, инициализированный как True. Это то что я сделал

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

Вы можете создавать списки и конвертировать их в массивы или создавать массивы с помощью модуля numpy. Ниже приведено несколько примеров, иллюстрирующих то же самое. Numpy также облегчает работу с многомерными массивами.

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

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

Вы также можете преобразовать этот массив в матрицу 2X2, используя функцию изменения формы, которая принимает входные данные в качестве размеров матрицы.

mat = a.reshape(2, 2)