Python задать массив: Массивы в Python — урок. Информатика, 11 класс.

Массивы

Содержание

• Массив как структура данных
• Массив в Python
• Создание массива
  • Литерал массива
  • Создание массива заданной длины, склеивание массивов
• Элементы массива: доступ и изменение
  • Доступ по индексу
  • Изменение элементов
  • Доступ в цикле while
  • Доступ в цикле for
• Печать массива
• Ремарка о строках
• Работа с двумерными массивами
• Контест №5
• Массивы в Python, часть 2
• Создание массива
  • Списковые включения
  • Функция list
• Изменение массива
  • Добавление элемента в конец list.append
  • Удаление элемента с конца list.pop
  • Вставка элемента в список
  • Удаление элемента из списка
  • Асимптотики методов
• Соединение и копирование массивов
• Питонизмы

Массив (англ. array) — структура данных, хранящая набор значений.

Каждое значение из набора индексируется, т.е. значения имеют номера (индексы).

Простейший массив имеет следующий интерфейс

1. создать(A, N) -> массив A длины N — создание массива A размера N.
2. записать(A, i, x) — записывает значение x в i-ый элемент массива A.
3. считать(A, i) -> элемент массива A с индексом i — взятие элемента по индексу (чтение).
4. удалить(A) — удаление массива А.

Обычно индексами массива являются целые положительные числа, причём в непрерывном диапазоне. Например, 0, 1, 2,... N-2, N-1

, где N — размер массива. В таком случае массив упорядочен по индексу и можно говорить, что массив также является последовательностью.

Для массива операции чтения и записи выполняются за O(1), т.е. время этих операций не зависит от количества элементов в массиве.

Массив в Python

упорядоченная изменяемая последовательность…

массив хранит множество элементов, которые образуют последовательность. При этом можно изменять как сами элементы массива, так и сам массив: пополнять массив новыми элементами или удалять их.

…объектов произвольных типов

элементами массива являются Python-объекты. При этом допускается, чтобы в одном массиве хранились объекты разных типов.

Массивы в Python также называют списками или листами (англ. list). Терминология в других языках программирования, а также в теории алгоритмов может быть другая.

Список Python является гибким в использовании объектом. Как инструмент, программист может использовать списки, например, для создания элементов линейной алгебры: точек, векторов, матриц, тензоров. Или, например, для таблицы с некоторыми данными.

Важно заметить, что <class 'list'>, питоновский список, является универсальной структурой данных.

В том числе, ей можно пользоваться как массивом (что мы и будем делать)! То есть, у этого объекта есть интерфейс, описанный в предыдущем разделе, причём с теми же асимптотиками, хотя возможности выходят гораздо за пределы простейшего массива.

Литерал массива

Массив можно создать при помощи литералов. Литерал — это код, который используется для создания объекта «вручную» (задания константы). Например, некоторые литералы уже изученных ранее объектов:

• int: 5, -23
• float: 5. , 5.0, -10.81, -1.081e1
• str: 'ABCdef', "ABCdef"

В случае массива литералом являются квадратные скобки [], внутри которых через запятую , перечисляются элементы массива:

>>> []
[]
>>> [0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]
>>> ['sapere', 'aude']
['sapere', 'aude']
>>> ['Gravitational acceleration', 9. -2']
>>> type([0, 1, 2, 3, 4])
<class 'list'>

Создание массива заданной длины, склеивание массивов

Чтобы создать массив наперёд заданной длины, нужно задать инициализируещее значение и длину. Ниже создаётся массив, содержащий 10 нулей.

>>> A = [0] * 10
>>> A
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
>>> type(A)
<class 'list'>

С похожим синтаксисом мы сталкивались при работе со строками. Массивы в Python можно «склеивать» с помощью знака сложения:

>>> A = [0] * 3  # [0, 0, 0]
>>> B = [1] * 3  # [1, 1, 1]
>>> C = [2] * 3  # [2, 2, 2]
>>> D = A + B + C
>>> D
[0, 0, 0, 1, 1, 1, 2, 2, 2]

На самом деле, умножение массива на целое число M это создание нового массива путём M «склеиваний» исходного массива с самим собой:

>>> [0, 1] * 3
[0, 1, 0, 1, 0, 1]
>>> [0, 1] + [0, 1] + [0, 1]
[0, 1, 0, 1, 0, 1]

Выше мы убедились, что массив это множество объектов различных типов, теперь убедимся, что это упорядоченная последовательность изменяемых объектов. -2′ >>> l = [10, 20, 30] >>> l[0] 10 >>> l[1] 20 >>> l[2] 30

Нумерация элементов массива начинается с нуля.

При запросе элемента по несуществующему индексу, Python вызовет ошибку IndexError:

>>> l
[10, 20, 30]
>>> l[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Поэтому всегда нужно быть уверенным, что индексация не выходит за пределы длины массива. Получить её можно с помощью функции len():

>>> l
[10, 20, 30]
>>> len(l)
3
>>> l[len(l) - 1]
30

Последняя конструкция встречается нередко, поэтому в Python существует возможность взять элемент по отрицательному индексу:

>>> l
[10, 20, 30]
>>> l[-1]
30
>>> l[-2]
20
>>> l[-3]
10
>>> l[-4]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Таким образом для индекса n ≥ 0,

l[-n] эвивалентно l[len(l) - n].

Изменение элементов

Изменение элементов осуществляется с помощью присваивания:

>>> l = [10, 20, 30]
>>> l
[10, 20, 30]
>>> l[0] = 0
>>> l
[0, 20, 30]
>>> l[2] = 55
>>> l
[0, 20, 55]

Доступ в цикле while

>>> l
[0, 20, 55]
>>> i = 0
>>> while i < len(l):
...     print(i, l[i])
...     i += 1
...
0 0
1 20
2 55
>>>

Доступ в цикле for

Наиболее универсальный способ это использование генератора range:

>>> l
[0, 20, 55]
>>> for i in range(len(l)):
...     print(i, l[i])
...
0 0
1 20
2 55

Чтобы распечатать элементы массива в столбец, воспользуйтесь циклом for, как в разделе выше.

Если нужно распечатать массив в строку, то воспользуйтесь функцией print:

>>> A = [0, 1, 2, 3]
>>> print(*A)
0 1 2 3

Здесь знак * это операция развёртывания коллекции по аргументам функции. Функция print принимает на вход сколько угодно аргументов и действие выше эквиваленто следующему:

>>> print(A[0], A[1], A[2], A[3])
0 1 2 3

На самом деле, мы уже ранее сталкивались с массивами в предудыщих лабораторных, когда использовали строковый метод str.split:

>>> s = "ab cd ef1 2 301"
>>> s.split()
['ab', 'cd', 'ef1', '2', '301']

Т.е. str.split, по умолчанию, разбивает строку по символам пустого пространства (пробел, табуляция) и создаёт массив из получившихся «слов».

Загляните в help(str.split), чтобы узнать, как изменить такое поведение, и разбивать строку, например, по запятым, что является стандартом для представления таблиц в файлах csv (comma separated values).

Методом, являющимся обратным к операции

str.split является str.join. Он «собирает» строку из массива строк:

>>> s
'ab cd ef1 2 301'
>>> l = s. split()
>>> l
['ab', 'cd', 'ef1', '2', '301']
>>> l[-1] = '430'
>>> l
['ab', 'cd', 'ef1', '2', '430']
>>> ','.join(l)
'ab,cd,ef1,2,430'
>>> ' -- '.join(l)
'ab -- cd -- ef1 -- 2 -- 430'

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

N у нас будет храниться другой массив размера M. Таким образом мы можем построить таблицу или матрицу размера N x M.

Создание двумерного массива (матрицы) размера N x M в питоне:

a = []
for _ in range(n):
  a.append([0] * m)

или

a = [[0] * m for _ in range(n)]

Обращение к элементами двумерного массива:

a[i][j] = 5

Ссылки на контесты

• Начинающие (участвовать)
• Основные (участвовать)
• Продвинутые (участвовать)

Списковые включения

Зачастую требуется создать массив, хранящий значения некоторой функции, например, квадратов чисел или арифметическую последовательность. В Python есть возможность сделать это «на лету».

Для этого можно воспользоваться синтаксическим сахаром Python — списковое включение (list comprehension):

>>> arithm = [ x for x in range(10) ]
>>> squares = [ x**2 for x in range(10) ]
>>> arithm
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Списковое включение может содержать и более одного цикла, а также фильтрующее условие

>>> A = [ i * j for i in range(1, 5) for j in range(1, 5)]
>>> A
[1, 2, 3, 4, 2, 4, 6, 8, 3, 6, 9, 12, 4, 8, 12, 16]
>>> odd_squares = [ i**2 for i in range(10) if i % 2 == 1 ]  # массив из квадратов нечётных чисел
>>> odd_squares
[1, 9, 25, 49, 81]

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

>>> A = [int(input()) for i in range(5)]  # считывание массива размера 5 с клавиатуры
9
0
-100
2
74
>>> A
[9, 0, -100, 2, 74]

Однако злоупотреблять списковыми включениями не стоит — если заполнение происходит по сложным правилам, лучше избежать использования включения в пользу читаемости кода.

Функция list

Аналогично функциям преобразования типов int(), float(), str() существует функция list(), создающая список из итерируемого объекта.

Её можно использовать, например, для создания массива символов из строки:

>>> list("sapere aude")
['s', 'a', 'p', 'e', 'r', 'e', ' ', 'a', 'u', 'd', 'e']
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Типичный пример использования — при чтении массива чисел из строки

>>> s = input()
1 2 -1 93 100
>>> s
'1 2 -1 93 100'
>>> A = list(map(int, s.split()))
>>> A
[1, 2, -1, 93, 100]

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

Добавление элемента в конец list.append

В примере ниже инициализируется пустой массив fibs, а затем заполняется элементами:

>>> fibs = []
>>> fibs. append(1)
>>> fibs
[1]
>>> fibs.append(1)
>>> fibs
[1, 1]
>>> fibs.append(2)
>>> fibs
[1, 1, 2]
>>> fibs.append(3)
>>> fibs
[1, 1, 2, 3]

Удаление элемента с конца list.pop

>>> fibs = [1, 1, 2, 3]
>>> fibs
[1, 1, 2, 3]
>>> fibs.pop()
3
>>> fibs
[1, 1, 2]
>>> fibs.pop()
2
>>> fibs
[1, 1]

Вставка элемента в список

Метод list.insert(i, x) вставляет элемент x на позицию i в списке

>>> A = [1, 9, 10, 3, -1]
>>> A
[1, 9, 10, 3, -1]
>>> A.insert(0, 'i')
>>> A
['i', 1, 9, 10, 3, -1]
>>> A.insert(5, 'i2')
>>> A
['i', 1, 9, 10, 3, 'i2', -1]

Удаление элемента из списка

Метод list.pop(i) удаляет из списка элемент с индексом i.

>>> B = ['popme', 1, 0, 'popme2', 3, -100]
>>> B.pop(0)
'popme'
>>> B
[1, 0, 'popme2', 3, -100]
>>> B.pop(2)
'popme2'
>>> B
[1, 0, 3, -100]

Асимптотики методов

Здесь A — некоторый список.

Метод списков	Асимптотика метода
A.append(x)	O(1)
A.pop()	O(1)
A.insert(i, x)	O(len(A))
A.pop(i)	O(len(A))

Массивы можно соединять in place, т.е. перезаписывая, с помощью метода list.extend:

>>> A = [0, 1, 2]
>>> B = [3, 4, 5]
>>> id(A)
4337064576
>>> A.extend(B)
>>> id(A)
4337064576
>>> A
[0, 1, 2, 3, 4, 5]
>>> B
[3, 4, 5]

Заметим, что оператор + для списков создаёт новый список.

С копированием массивов нужно быть осторожным. Python никогда не осуществляет копирование явно:

>>> A = [0, 1, 2]
>>> B = A
>>> B[1] = 'take_care!'
>>> A
[0, 'take_care!', 2]
>>> B
[0, 'take_care!', 2]
>>> A is B
True

В строчке B = A лишь создаётся ещё одна ссылка на объект [0, 1, 2], которая присваивается переменной B. В итоге A и B будут указывать на один и тот же объект.

Чтобы создать копию, необходимо поэлементно создать новый массив из исходного. Например, с помощью функции list() или метода list.copy:

>>> A = [0, 1, 2]
>>> B = list(A)
>>> C = A.copy()
>>> A is B
False
>>> A is C
False
>>> B is C
False
>>> A
[0, 1, 2]
>>> B
[0, 1, 2]
>>> C
[0, 1, 2]

Приведённые способы копирования работают для списков, содержащих неизменяемые объекты. Если же вы работаете с двумерным массивом или чем-то более сложным, то функцию явного копирования стоит написать самому, либо воспользоваться функцией copy.deepcopy из библиотеки copy.

Конструкции с использованием while и for, изложенные в первой части лабораторной, имеют аналоги практически во всех языках программирования. Они универсальны, стандартны, переносимы из языка в язык.

Этот раздел относится только к особенностям языка Python.

Не злоупотребляйте питонизмами, наша цель — освоить алгоритмы и структуры данных, а не Python.

В языке Python цикл for на самом деле является синтаксическим сахаром, поддерживающим концепцию итерируемого объекта. Его обобщённый синтаксис выглядит примерно так:

for item in any_iterable:
    # тело цикла

Здесь item это выбранное программистом имя переменной итерирования, которая доступна в теле цикла. В начале каждой итерации в эту переменную помещается значение из any_iterable. Под any_iterable может стоять любой итерируемый объект.

Знакомые нам примеры итерируемых объектов:

• range — генератор арифметической последовательности, for «просит» новые значения у генератора, пока те не закончатся
• str — строковый тип, итерирование происходит по символам
• list — список, итерирование происходит по элементам

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

>>> l
[0, 20, 55]
>>> for elem in l:
. ..     print(elem)
...
0
20
55

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

Под подобные мелкие задачи существует множество «питонизмов» — специфических для языка Python инструментов.

Один из примеров — enumerate — позволяет программисту получить в цикле индекс итерации (!) (а не индекс элемента) и сам элемент.

При таком использовании номер итерации совпадает с индексом элемента:

>>> l
[0, 20, 55]
>>> for i, elem in enumerate(l):
...     print(i, elem)
...
0 0
1 20
2 55

Код приведённый для enumerate выше, аналогичен универсальным:

>>> l
[0, 20, 55]
>>> for i in range(len(l)):
...     elem = l[i]
...     print(i, elem)
...
0 0
1 20
2 55

>>> l
[0, 20, 55]
>>> i = 0
>>> while i < len(l):
...     elem = l[i]
...     print(i, elem)
...     i += 1
...
0 0
1 20
2 55

Массивы в Python

Основное введение в массивы

Массив — это структура данных, в которой хранятся значения одного типа. В Python это основное различие между массивами и списками.

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

Если вы новичок в Python, начните со статьи Введение в Python.

Для использования массивов в языке Python, вам нужно импортировать стандартный array модуль. Это потому , что массив не является основным типом данных , как строки, целое число и т.д. Вот как вы можете импортировать array модуля в Python:

from array import *

После того, как вы импортировали array модуль, вы можете объявить массив. Вот как вы это делаете:

arrayIdentifierName = array(typecode, [Initializers])

В приведенном выше объявлении, arrayIdentifierName этого имя массива, typecode позволяет питону знать тип массива и Initializers являются значением , с которыми массив инициализируется.

Typecodes — это коды, которые используются для определения типа значений массива или типа массива. Таблица в разделе параметров показывает возможные значения, которые вы можете использовать при объявлении массива, и его тип.

Вот реальный пример объявления массива python:

 my_array = array('i',[1,2,3,4])

В приведенном выше примере, используется TypeCode i.Этот тип-тип представляет целое число со знаком, размер которого составляет 2 байта.

Вот простой пример массива, содержащего 5 целых чисел

Доступ к отдельным элементам через индексы

Отдельные элементы могут быть доступны через индексы. Массивы Python индексируются нулем. Вот пример:

Добавить любое значение в массив с помощью метода append()

Заметим , что значение 6 был приложен к существующим значениям массива.

Вставить значение в массив с помощью метода insert()

Мы можем использовать insert() метод , чтобы вставить значение в любом индекса массива. Вот пример:

В приведенном выше примере значение 0 было вставлено в индекс 0. Обратите внимание, что первый аргумент является индексом, а второй аргумент является значением.

Расширение массива python с помощью метода extend()

Массив Python может быть расширен с более чем одно значение с помощью extend() метод. Вот пример:

Мы видим , что my_array массив был расширен со значениями из my_extnd_array .

Добавить элементы из списка в массив, используя метод fromlist()

Вот пример:

Итак , мы видим , что значения 11,12 и 13 были добавлены из списка c к my_array .

Удалите любой элемент массива, используя метод remove()

Вот пример:

Мы видим, что элемент 4 был удален из массива.

Удалить последний элемент массива методом pop()

pop удаляет последний элемент из массива. Вот пример:

Итак , мы видим , что последний элемент ( 5 ) был выскочили из массива.

Получить любой элемент через его индекс с помощью метода index()

index() возвращает первый индекс значения соответствия. Помните, что массивы с нулевой индексацией.

Обратите внимание, что во втором примере был возвращен только один индекс, хотя в массиве значение существует дважды

Обратный массив Python, используя метод reverse()

reverse() метод делает то , что название говорит , что это будет делать — изменяет массив. Вот пример:

Этот метод предоставляет вам начальный адрес буфера массива в памяти и количество элементов в массиве. Вот пример:

my_array = array('i', [1,2,3,4,5])
my_array.buffer_info()
#(33881712, 5) 

Проверьте количество вхождений элемента с помощью метода count()

count() — count() возвращает число раз , и представляется , что элемент в массиве. В следующем примере мы видим , что значение 3 происходит дважды.

my_array = array('i', [1,2,3,3,5])
my_array.count(3)
# 2 

Преобразовать массив в строку, используя метод tounicode()

tounicode() преобразует юникод массив в строку.

my_char_array = array('u', ['g','e','e','k'])
# array('u', 'geek')
print(my_char_array.tounicode())
# geek 

Преобразовать массив в список Python с теми же элементами, используя метод tolist()

Когда вам нужен Python list объектов, вы можете использовать tolist() метод , чтобы преобразовать ваш массив в список.

my_array = array('i', [1,2,3,4,5])
c = my_array.tolist()
# [1, 2, 3, 4, 5] 

Потренируйте самостоятельно

Поздравляем! Тепереь вы можете работать с массивами в Python.

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

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

 из массива импортировать массив
float_array = массив ("f", значения)
 

, где значений могут принимать форму кортежа, списка или np.array, но не массива:

 значения = [1,2,3]
значения = (1,2,3)
значения = np.array([1,2,3],'f')
# 'i' здесь тоже будет работать, но если массив равен 'i', тогда значения должны быть int
неверные_значения = массив ('f', [1,2,3])
# Ошибка типа: объект 'array. array' не вызывается
 

, а вывод останется тем же:

 print(float_array)
печать (плавающий_массив [1])
печать (экземпляр (float_array [1], float))
# массив('f', [1.0, 2.0, 3.0])
# 2.0
# Истинный
 

Большинство методов работы со списком работают и с массивом, общий это pop(), extend() и append().

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

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

Попытки вставить/добавить число с плавающей запятой в массив int вызовут ошибку типа:

 значения = [1,2,3]
int_array = массив ("i", значения)
int_array.append (с плавающей запятой (1))
# или int_array.extend([float(1)])
# TypeError: ожидается целочисленный аргумент, получено число с плавающей запятой
 

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

 int_array = массив ('i', [1,2,3])
данные = [11,22,33,44,55]
образец = []
для я в int_array:
    sample.append (данные [я])
 

Досадно, что добавление целого числа к массиву с плавающей запятой приведет к тому, что целое станет числом с плавающей запятой, без создания исключения.

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

 import numpy as np
numpy_int_array = np.массив ([1,2,3], 'я')
для я в numpy_int_array:
    печать (тип (я))
    # <класс 'numpy.int32'>
numpy_int_array_2 = np.append (numpy_int_array, int (1))
# все еще <класс 'numpy.int32'>
numpy_float_array = np.append (numpy_int_array, float (1))
#  для всех значений
numpy_str_array = np.append (numpy_int_array, "1")
#  для всех значений
данные = [11,22,33,44,55]
образец = []
для я в numpy_int_array_2:
    sample. append (данные [я])
    # здесь нет проблем, но TypeError для двух других
 

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

 int_numpy_array = np.array([1,2,float(3)],'i')
# 3 становится int
int_numpy_array_2 = np.array([1,2,3.9],'i')
# 3.9 усекается до 3 (так же, как int(3.9))
invalid_array = np.array([1,2,"строка"],'i')
# ValueError: неверный литерал для int() с основанием 10: 'string'
# Та же ошибка, что и int('string')
str_numpy_array = np.array([1,2,3],'str')
печать (str_numpy_array)
print([type(i) для i в str_numpy_array])
# ['1' '2' '3']
# <класс 'numpy.str_'>
 

или, по существу:

 данные = [1.2,3.4,5.6]
list_1 = np.array(данные, 'i').tolist()
list_2 = [int(i) для i в данных]
печать (список_1 == список_2)
# Истинный
 

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

 invalid_array = array([1,2,3.9],'i')
# TypeError: ожидается целочисленный аргумент, получено число с плавающей запятой
 

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

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

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

Получайте удовольствие от исследования!

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

python — Numpy: установить элемент массива в другой массив

спросил 6 лет, 10 месяцев назад

Изменено 6 лет, 10 месяцев назад

Просмотрено 7к раз

Я пытаюсь сделать элемент массива Numpy другим массивом Numpy. Я не уверен, как это сделать, так как каждый раз, когда я пытаюсь, я получаю ValueError: установка элемента массива с последовательностью.

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

Это пример того, что я пытаюсь сделать:

 импортировать numpy как np
finalArray = np.zeros(3)
окончательный список = []
a = np.arange(128).reshape(32,4)
b = np.arange(124).reshape(31,4)
c = np.arange(120).reshape(30,4)
# Это работает
finalList.append(a)
finalList.append(b)
finalList.append(c)
# Это не работает
окончательный массив [0] = а
окончательный массив [1] = б
окончательный массив [2] = с
 

Есть идеи, как это сделать?

• питон
• массивы
• numpy

3

Массивы Numpy не могут быть заполнены произвольными типами. Они больше похожи на массивы C или Java. Чтобы создать двумерный массив, передайте двумерный список в функцию np. array. Например,

 x = np.array([[0,0,0],[0,0,0],[0,0,0]])
 

создает двумерный массив 3×3, заполненный нулями.

1

Я думаю, вы ищете numpy.concatenate :

 В [11]: np.concatenate((a, b, c))
Выход[11]:
массив([[ 0, 1, 2, 3],
       [4, 5, 6, 7],
       [8, 9, 10, 11],
       [12, 13, 14, 15],
       [16, 17, 18, 19],
       ...
 

Это создает один массив 93 x 4 numpy:

 В [12]: np.concatenate((a, b, c)).shape
Аут[12]: (93, 4)
 

Будет работать, если

 finalArray = np.zeros(3, dtype=объект)
окончательный массив [0] = а
 

Затем finalArray принимает точки объекта как список.

Но я не решаюсь предложить это, потому что новички злоупотребляют или неправильно используют эту функцию.

https://stackoverflow.com/a/37597524/901925 — мой ответ на другой вопрос о глубокой копии массива массивов.

Ответ concatenate является единственной альтернативой, которая имеет смысл, учитывая размеры ваших массивов.