Работа с массивами python 3: NumPy, часть 2: базовые операции над массивами

Python работа с массивами двумерными и многомерными — создание, поиск, добавление, сортировка и другие

Массивом в языке Python называется упорядоченная структура данных, которая используется для хранения однотипных объектов. По своему функциональному назначению они схожи со списками, однако обладают некоторыми ограничениями на тип входных данных, а также их размер. Несмотря на такую особенность, массивы являются достаточно функциональным инструментом по работе с наборами данных в языке программирования Python.

Создание и заполнение

Перед тем как добавить (создать) новый массив в Python 3, необходимо произвести импорт библиотеки, отвечающей за работу с таким объектом. Для этого потребуется добавить строку from array import * в файл программы. Как уже было сказано ранее, массивы ориентированы на взаимодействие с одним постоянным типом данных, вследствие чего все их ячейки имеют одинаковый размер. Воспользовавшись функцией array, можно создать новый набор данных. В следующем примере демонстрируется заполнение массива Python — запись целых чисел при помощи метода, предложенного выше.

from array import *
data = array('i', [2, 5, 4, 0, 8])

Как можно заметить, функция array принимает два аргумента, первым из которых становится тип создаваемого массива, а на месте второго стоит начальный список его значений. В данном случае i представляет собой целое знаковое число, занимающее 2 байта памяти. Вместо него можно использовать и другие примитивы, такие как 1-байтовый символ (c) или 4-байтовое число с плавающей точкой (f).

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

Обратиться к элементу можно при помощи квадратных скобок, к примеру, data[2].

Добавление элемента

Чтобы добавить новый элемент в массив Python необходимо воспользоваться методом insert. Для этого потребуется вызвать его через созданный ранее объект и ввести в качестве аргументов два значения. Первое (4) отвечает за индекс нового элемента в массиве, то есть место, куда его следует поместить, а второе (3) представляет собой само значение.

from array import *
data = array('i', [2, 5, 4, 0, 8])
data.insert(4, 3)

Стоит помнить, что добавить в массив можно только данные того типа, к которому относится ранее созданный объект. При выполнении подобной операции количество доступных ячеек увеличивается согласно текущим потребностям программы.

Удаление элемента

В Python удалить ненужные элементы из массива можно при помощи метода pop, аргументом которого является индекс ячейки (3). Как и в случае с добавлением нового элемента, метод необходимо вызвать через ранее созданный объект, как это показано в примере.

from array import *
data = array('i', [2, 5, 4, 0, 8])
data.pop(3)

После выполнения данной операции содержимое массива сдвигается так, чтобы количество доступных ячеек памяти совпадало с текущим количеством элементов.

Вывод

При работе с любыми данными в программе время от времени возникает необходимость в их проверке, что можно легко осуществить с помощью вывода на экран. Выполнить подобное действие поможет функция под названием print. Она принимает в качестве аргумента один из элементов созданного и заполненного ранее массива. В следующем примере его обработка производится при помощи цикла for, где каждый элемент массива data получает временный идентификатор i для передачи в упомянутый ранее метод print.

from array import *
data = array('i', [2, 5, 4, 0, 8])
for i in data:
    print(i)

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

Получение размера

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

Чтобы отобразить в Python количество элементов массива на экране стоит воспользоваться методом print.

from array import *
data = array('i', [2, 5, 4, 0, 8])
print(len(data))

Как видно из представленного выше кода, функция print получает в качестве аргумента результат выполнения len, что позволяет ей вывести числовое значение в консоль.

Двумерный массив

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

d1 = []
for j in range(5):
    d2 = []
    for i in range(5):
        d2.append(0)
    d1.append(d2)

Здесь можно увидеть, что основная идея реализации двумерного набора данных заключается в создании нескольких списков d2 внутри одного большого списка d1. При помощи двух циклов for происходит автоматическое заполнение нулями матрицы с размерностью 5×5. С этой задачей помогают справляться методы append и range, первый из которых добавляет новый элемент в список (0), а второй позволяет устанавливать его величину (5). Нельзя не отметить, что для каждого нового цикла for используется собственная временная переменная, выполняющая представление текущего элемента внешнего (j) или внутренних (i) списков. Обратиться к нужной ячейке многомерного списка можно при помощи указания ее координат в квадратных скобках, ориентируясь на строки и столбцы: d1[1][2].

Многомерный массив

Как и в случае с двумерным массивом, представленным в виде сложного списка, многомерный массив реализуется по принципу «списков внутри списка». Следующий пример наглядно демонстрирует создание трехмерного списка, который заполняется нулевыми элементами при помощи трех циклов for. Таким образом, программа создает матрицу с размерностью 5×5×5.

d1 = []
for k in range(5):
    d2 = []
    for j in range(5):
        d3 = []
        for i in range(5):
            d3. append(0)
        d2.append(d3)
    d1.append(d3)

Аналогично двумерному массиву, обратиться к ячейке построенного выше объекта можно с помощью индексов в квадратных скобках, например, d1[4][2][3].

Заключение

Для взаимодействия с наборами данных одного типа в языке программирования Python, как правило, используются массивы. Стандартная библиотека платформы позволяет достаточно эффективно работать с подобной структурой, предоставляя возможность манипулировать ее содержимым при помощи соответствующих функций. Кроме того, в Python поддерживается многомерное представление списков без ограничений на количество уровней.

Изучаем массивы в питоне

2022-04-24 0 ∞ 3

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

• Изучаем массивы в питоне — условия
• Структуры данных Python
• Массивы в Python
• Списки в Python
• Заметили, что вам не нужно импортировать модуль array?

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

Рассматриваемые в этой статье принципы могут быть применены в любом языке программирования. Я буду демонстрировать примеры на Python. Это простой для изучения язык предоставляет превосходную платформу для понимания того, что происходит. В дополнение к этому существует отличный онлайн-интерпретатор Python.

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

Возможно, вы слышали о линейных типах данных (элементы последовательны):

• Массив;
• Матрица;
• Таблица поиска.

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

• Связный список;
• Двойной связный список;
• Список массивов или динамический массив.

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

Python массивы и списки представляют собой простой набор связанных значений, которые называются элементами. Обычно это любой тип данных, включая объекты или другие списки! При работе с массивами все данные должны быть одинаковыми — нельзя хранить вместе строки и целые числа. Вам почти всегда придется указывать, сколько элементов нужно хранить. Динамические массивы существуют, но проще начать с массивов фиксированной длиной.

Python несколько усложняет ситуацию. Он не всегда придерживается строгих определений структур данных. Большинство объектов в Python обычно являются списками, поэтому создавая массив, вы проделываете больше работы. Вот начальный код:

from array import array
numbers = array('i', [2, 4, 6, 8])
print numbers[0]

Первая строка импортирует модуль array, необходимый для работы с массивами. Вторая строка создает новый массив numbers и инициализирует его значениями 2, 4, 6 и 8. Каждому элементу присваивается целочисленное значение, называемое ключом или индексом. Ключи начинаются с нуля, поэтому [0] будет обращаться к первому элементу (2):

Вам наверно интересно, для чего используется «i». Это typecode, который сообщает Python, что массив будет хранить целые числа. Обычно подобные вещи в Python не нужны. Причина этого проста. Массивы в Python основаны на базовых C-массивах операционной системы. Это означает, что они быстрые и стабильные, но не всегда могут придерживаться синтаксиса Python.

Нельзя хранить элементы разных типов в этих массивах. Допустим, вы захотели сохранить строку «makeuseof. com»:

numbers = array('i', [2, 4, 6, "makeuseof.com"])

Это вызовет исключение при работе с Python массивом строк:

Вот как можно вывести все элементы:

print numbers

Этот метод доступа к элементам массива работает хорошо, и идеально подходит для решения задачи. Плохо то, что это — доступ ко всему массиву.

Каждый язык программирования реализует цикл, который идеально подходит для итерации (циклизации) над элементами списка.

Наиболее распространенные циклы while и for. Python делает это еще проще, предоставляя цикл for in:

for number in numbers:
    print number

Обратите внимание на то, что вам не нужно обращаться к элементам по их ключу. Это лучший способ работы с массивом. Альтернативный способ перебора списка — это цикл for:

for i in range(len(numbers)):
    print numbers[i]

Этот пример делает то же самое, что и предыдущий. Но в нем нужно указать количество элементов в массиве (len (cars)), а также передать i в качестве ключа. Это почти тот же код, который выполняется в цикле for in. Этот способ обеспечивает большую гибкость и выполняется немного быстрее (хотя цикла for in в большинстве случаев более чем достаточно).

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

Список — это особый тип массива. Различие состоит в том, что списки могут содержать смешанные типы данных. Помните, массивы должны содержать элементы одного типа. Списки в Python просты:

cars = ['Ford', 'Austin', 'Lancia']

Этот синтаксис объявляет список под названием cars. В квадратных скобках объявляется каждый элемент списка. Каждый элемент является строкой, поэтому их объявляют внутри кавычек. Python знает, что это объект, поэтому оператор print выводит содержимое списка:

print cars

Как и в случае с массивом, можно осуществлять Python сортировку массива с помощью циклов:

for car in cars:
    print car

Настоящий фокус со списками — их смешанный тип. Добавьте дополнительные данные:

cars = ['Ford', 'Austin', 'Lancia', 1, 0.56]

Это даже не вызвало исключения:

Также просто добавить новые элементы в список (что невозможно с массивами):

cars = ['Ford', 'Austin']
print cars
cars.append('Lancia')
print cars

Можно объединить два списка в один:

cars = ['Ford', 'Austin']
print cars
other_cars = ['Lotus', 'Lancia']
cars.extend(other_cars)
print cars

Также легко удалить элементы Python ассоциативного массива, используя синтаксис remove:

cars = ['Ford', 'Austin', 'Lotus', 'Lancia']
print cars
cars.remove('Ford')
print cars

Вы узнали что-нибудь новое? Поделитесь с нами своими мыслями в комментариях!

ВЛВиктория Лебедеваавтор-переводчик статьи «How Arrays and Lists Work in Python»

Пожалуйста, оставляйте ваши комментарии по текущей теме материала. Мы крайне благодарны вам за ваши комментарии, подписки, отклики, лайки, дизлайки!

массивов в Python: что такое массивы Python и как их использовать?

Массивы в Python — это структуры данных, которые могут содержать несколько значений одного типа. Часто их ошибочно принимают за списки или массивы Numpy. Технически массивы в Python отличаются от них обоих. Итак, давайте продолжим и посмотрим, что такое массивы в Python и как реализовать .

Вот обзор тем, который объясняет все аспекты, связанные с массивами:

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

Массивы в Python | Операции с массивами Python | Edureka

Это видео поможет вам прочно усвоить все основы языка программирования Python.

Зачем использовать массивы в Python?

Комбинация массивов вместе с Python может сэкономить вам много времени. Как упоминалось ранее, массивы помогают уменьшить общий размер кода, а Python помогает избавиться от проблемного синтаксиса, в отличие от других языков.
Например, : Если вам нужно хранить целые числа от 1 до 100, вы не сможете явно запомнить 100 имен переменных, поэтому вы можете легко сохранить их, используя массив.

 

Теперь, когда вы знаете о важности массивов в Python, давайте изучим их подробнее.

Что такое массив в Python?

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

Пример :

a=arr.array('d',[1.2,1.3,2.3])
 

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

Всегда возникает вопрос, который приходит нам на ум —

Является ли список Python таким же, как массив?

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

Python также предоставляет массивы Numpy, которые представляют собой сетку значений, используемых в науке о данных. Вы можете изучить Numpy Arrays vs Lists, чтобы узнать больше.

Создание массива в Python:

Массивы в Python могут быть созданы после импорта модуля массива следующим образом: первый — это тип данных сохраняемого значения, а второй — список значений. Тип данных может быть любым, например, int, float, double и т. д. Обратите внимание, что arr — это псевдоним, предназначенный для простоты использования. Вы также можете импортировать без псевдонима. Есть еще один способ импортировать модуль массива —

→         импорт из массива *

Это означает, что вы хотите импортировать все функции из модуля массива.

Для создания массива используется следующий синтаксис.

Синтаксис:

a=arr.array(тип данных,список значений) #при импорте с использованием псевдонима arr
 

ИЛИ

a=массив(тип данных,список значений) #при импорте с помощью *
 

Пример : a=arr.array( ‘d’ , [1.1 , 2.1 ,3.1] )

Здесь первым параметром является «d», который является типом данных, т. е. числом с плавающей запятой, а значения указываются в качестве следующего параметра.

Примечание :

Все указанные значения имеют тип float. Мы не можем указывать значения разных типов данных в одном массиве.

В следующей таблице показаны различные типы данных и их коды.

9012 4

Код типа	Тип данных Python	Размер в байтах
i	целое число	2
I	целое число	2
u	символ Юникода	2
h	целое число	2
H	внутр.	2
l	внутр.	4
L	внутр.	4
f	поплавок	4
d	float	8

Доступ к элементам массива в Python :

Чтобы получить доступ к элементам массива, вам нужно указать значения индекса. Индексация начинается с 0, а не с 1. Следовательно, номер индекса всегда на 1 меньше длины массива.

Синтаксис :

Имя_массива[значение индекса]

Пример :

a=arr.array('d', [1.1, 2.1, 3.1])
а[1]
 

Вывод –

 2.1 

Возвращаемый вывод – это значение, присутствующее на втором месте в нашем массиве, равное 2.1.

Теперь давайте рассмотрим некоторые основные операции с массивами.

Базовые операции с массивами :

Существует множество операций, которые можно выполнять с массивами, а именно: в массиве. Вы можете использовать len() для достижения этой цели. Функция len() возвращает целочисленное значение, равное количеству элементов, присутствующих в этом массиве.

Синтаксис :

→ len(имя_массива)

Пример :

a=arr.array('d', [1.1, 2.1, 3.1])
Лена)
 

Вывод –  3

Это возвращает значение 3, равное количеству элементов массива.

Добавление/изменение элементов массива:

Мы можем добавить значение в массив, используя функции append() , extend() и insert (i,x) .

Функция append() используется, когда нам нужно добавить один элемент в конец массива.

Пример :

a=arr.array('d', [1.1, 2.1, 3.1])
а. добавить (3.4)
печать (а)
 

Выходные данные –

массив(‘d’, [1.1, 2.1, 3.1, 3. 4])

Результирующий массив является фактическим массивом с добавленным в конце новым значением. Чтобы добавить более одного элемента, вы можете использовать функцию extend(). Эта функция принимает список элементов в качестве параметра. Содержимое этого списка — это элементы, которые нужно добавить в массив.

Пример :

a=arr.array('d', [1.1, 2.1, 3.1])
а.продлить([4.5,6.3,6.8])
печать (а)
 

Выходные данные –

массив(‘d’, [1.1, 2.1, 3.1, 4.5, 6.3, 6.8])

Результирующий массив будет содержать все 3 новых элемента, добавленных в конец массива.

Однако, когда вам нужно добавить определенный элемент в определенную позицию в массиве, можно использовать функцию вставки (i,x). Эта функция вставляет элемент по соответствующему индексу в массиве. Он принимает 2 параметра, где первый параметр — это индекс, в который нужно вставить элемент, а второй — значение.

Пример :

a=arr. array('d', [1.1, 2.1, 3.1])
а.вставить(2,3.8)
печать (а)
 

Вывод –

массив(‘d’, [1.1, 2.1, 3.8, 3.1])

Результирующий массив содержит значение 3.8 на 3-й позиции в массиве.

Массивы также можно объединять, выполняя конкатенацию массивов.

Объединение массивов :

Любые два массива могут быть объединены с помощью символа +.

  Пример  : 

a=arr.array('d',[1.1, 2.1,3.1,2.6,7.8])
b=массив.массив('d',[3.7,8.6])
c=arr.массив('d')
с=а+б
печать("Массив с = ",с)
 

Вывод –

Массив c= array(‘d’, [1.1, 2.1, 3.1, 2.6, 7.8, 3.7, 8.6])

Результирующий массив c содержит конкатенированные элементы массивов a и b.

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

Узнайте о нашем обучении Python в лучших городах/странах

Удаление/удаление элементов массива :

Элементы массива могут быть удалены с помощью метода pop() или remove() . Разница между этими двумя функциями заключается в том, что первая возвращает удаленное значение, а вторая — нет.

Функция pop() либо не принимает никаких параметров, либо принимает в качестве параметра значение индекса. Когда параметр не указан, эта функция извлекает () последний элемент и возвращает его. Когда вы явно указываете значение индекса, функция pop() извлекает требуемые элементы и возвращает их.

Пример :

a=arr.array('d', [1.1, 2.2, 3.8, 3.1, 3.7, 1.2, 4.6])
печать (а.поп())
печать (a.pop (3))
 

Выход –

 4,6
3.1 

Первая функция pop() удаляет последнее значение 4.6 и возвращает то же самое, а вторая извлекает значение на 4-й позиции, равное 3.1, и возвращает то же самое.

Функция remove(), с другой стороны, используется для удаления значения, когда нам не нужно возвращать удаленное значение. Эта функция принимает само значение элемента в качестве параметра. Если вы укажете значение индекса в слоте параметра, это вызовет ошибку.

Пример :

a=arr.array('d',[1.1, 2.1,3.1])
а.удалить(1.1)
печать (а)
 

Вывод –

array(‘d’, [2.1,3.1])

Вывод – массив, содержащий все элементы, кроме 1.1.

Если вам нужен определенный диапазон значений из массива, вы можете разрезать массив, чтобы вернуть то же самое, как показано ниже.

Разрезание массива :

Массив можно разрезать с помощью символа :. Это возвращает диапазон элементов, которые мы указали по номерам индексов.

Пример :

a=arr.array('d',[1.1, 2.1,3.1,2.6,7.8])
печать (а [0: 3])
 

Выходные данные –

массив(‘d’, [1.1, 2.1, 3.1])

Результатом будут элементы, находящиеся на 1-й, 2-й и 3-й позициях в массиве.

Перебор массива:

Используя цикл for, мы можем перебирать массив.

  Пример  : 

a=arr. array('d', [1.1, 2.2, 3.8, 3.1, 3.7, 1.2, 4.6])
распечатать("Все значения")
для х в:
печать (х)
print("конкретные значения")
для х в a[1:3]:
печать (х)
 

Выход –

Все значения

1,1
2,2
3,8
3,1
3,7
1,2
4,6
специфические значения
2,2
3,8

 

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

 

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

Есть к нам вопрос? Пожалуйста, укажите это в разделе комментариев этого блога «Массивы в Python», и мы свяжемся с вами как можно скорее или присоединимся к нашему мастер-курсу Python.

Чтобы получить более глубокие знания о Python и его различных приложениях, вы можете зарегистрироваться на live Онлайн-обучение Python  с круглосуточной поддержкой и пожизненным доступом.

array — Эффективные массивы числовых значений — Документация по Python 3.11.3

---

Этот модуль определяет тип объекта, который может компактно представлять массив основные значения: символы, целые числа, числа с плавающей запятой. Массивы являются последовательностями типы и ведут себя очень похоже на списки, за исключением того, что типы объектов, хранящихся в их сдерживает. Тип указывается во время создания объекта с помощью введите код , который является одним символом. Следующие коды типов определено:

Код типа	Тип С	Тип Python	Минимальный размер в байтах	Примечания
'б'	знаковый символ	ряд	1
"Б"	беззнаковый символ	внутр.	1
'у'	wchar_t	Символ Юникода	2	(1)
'ч'	короткое со знаком	внутр.	2
"Н"	короткий без знака	внутр.	2
«и»	подписанный номер	внутр.	2
«Я»	целое число без знака	внутр.	2
л	длинный подписанный	внутр.	4
"Г"	длинное без знака	внутр.	4
"к"	подписанный длинный длинный	внутр.	8
'Q'	без знака длинный длинный	внутр.	8
'ж'	поплавок	поплавок	4
'д'	двойной	поплавок	8

Примечания:

1. Это может быть 16 или 32 бита в зависимости от платформы.

   Изменено в версии 3.9: array('u') теперь использует wchar_t как тип C вместо устаревшего Py_UNICODE . Это изменение не влияет на его поведение, потому что Py_UNICODE — это псевдоним wchar_t , начиная с Python 3. 3.

   Устарело, начиная с версии 3.3, будет удалено в версии 4.0.

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

Модуль определяет следующий элемент:

array.typecodes

Строка со всеми доступными кодами типов.

Модуль определяет следующий тип:

класс массив.массив( код типа [ инициализатор ])

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

Если задан список или строка, инициализатор передается в новый массив fromlist() , frombytes() или fromunicode() метод (см. ниже) чтобы добавить начальные элементы в массив. В противном случае итерируемый инициализатор перешел на метод extend() .

Объекты массива поддерживают обычные последовательные операции индексации, нарезки, конкатенация и умножение. При использовании назначения среза назначенный value должен быть объектом массива с тем же кодом типа; во всех остальных случаях, Возникает TypeError . Объекты массива также реализуют интерфейс буфера, и может использоваться везде, где поддерживаются байтоподобные объекты.

Вызывает массив событий аудита .__new__ с аргументами код типа , инициализатор .

код типа

Символ типа, используемый для создания массива.

размер элемента

Длина в байтах одного элемента массива во внутреннем представлении.

добавить( x )

Добавить новый элемент со значением x в конец массива.

буфер_информация ()

Вернуть кортеж (адрес, длина) с текущим адресом памяти и длина в элементах буфера, используемого для хранения содержимого массива. Размер буфер памяти в байтах можно вычислить как array.buffer_info()[1] * массив.элементразмер . Иногда это бывает полезно при работе с низкоуровневыми (и изначально небезопасные) интерфейсы ввода-вывода, требующие адресов памяти, такие как определенные ioctl() операций. Возвращаемые числа действительны, пока массив существует и к нему не применяются никакие операции по изменению длины.

Примечание

При использовании объектов массива из кода, написанного на C или C++ (единственный способ эффективно использовать эту информацию), имеет смысл использовать буфер интерфейс, поддерживаемый объектами массива. Этот метод поддерживается для обратных совместимости и их следует избегать в новом коде. Интерфейс буфера задокументировано в протоколе буфера.

обмен байтами()

«Поменять местами» все элементы массива. Это поддерживается только для значений, которые размером 1, 2, 4 или 8 байт; для других типов значений RuntimeError — это поднятый. Это полезно при чтении данных из файла, записанного на машине с другой порядок байтов.

количество( х )

Возвращает количество вхождений x в массиве.

расширить ( повторяемый )

Добавить элементы из итерируемых в конец массива. Если iterable — это другое массив, он должен иметь ровно однотипный код; если нет, TypeError будет быть поднятым. Если iterable не является массивом, он должен быть итерируемым, а его элементы должен быть правильным типом для добавления к массиву.

из байтов ( с )

Добавляет элементы из строки, интерпретируя строку как массив машинных данных. значений (как если бы они были прочитаны из файла с использованием метода fromfile()).

Новое в версии 3.2: fromstring() переименован в frombytes() для ясности.

из файла ( f , n )

Чтение n элементов (в виде машинных значений) из файлового объекта f и добавление их в конец массива. Если доступно менее n элементов, EOFError возникает, но элементы, которые были доступны, по-прежнему вставлен в массив.

из списка( список )

Добавление элементов из списка. Это эквивалентно для x в списке: a.append(x) , за исключением того, что в случае ошибки типа массив не изменяется.

из юникода ( с )

Дополняет этот массив данными из заданной строки Юникода. Массив должен быть массивом типа 'u' ; в противном случае возникает ошибка ValueError . Использовать array.frombytes(unicodestring.encode(enc)) для добавления данных Unicode в массив другого типа.

индекс( x [ старт [ стоп ]])

Возвращает наименьшее число i , такое что i является индексом первого вхождения x в массиве. Необязательные аргументы start и stop могут быть указано для поиска x в подразделе массива. Поднимать ValueError , если x не найдено.

Изменено в версии 3.10: Добавлен необязательный запуск и остановка параметров.

вставка ( я , х )

Вставить новый элемент со значением x в массив перед позицией i . Отрицательный значения рассматриваются как относительные к концу массива.

поп([ я ])

Удаляет элемент с индексом и из массива и возвращает его. Необязательный аргумент по умолчанию равен -1 , так что по умолчанию удаляется последний элемент и вернулся.

удалить( х )

Удалить первое вхождение x из массива.

реверс()

Обратный порядок элементов в массиве.

тобайты()

Преобразование массива в массив машинных значений и возврат байтов представление (та же самая последовательность байтов, которая была бы записана в файл tofile() метод.)

Новое в версии 3.2: tostring() для ясности переименован в tobytes() .

файл( f )

Записать все элементы (как машинные значения) в файловый объект f .

список()

Преобразование массива в обычный список с теми же элементами.

tounicode()

Преобразование массива в строку Unicode. Массив должен быть типа 'у' массив; в противном случае возникает ошибка ValueError . Используйте array.tobytes().decode(enc) для получить строку юникода из массива другого типа.

Когда объект массива печатается или преобразуется в строку, он представляется как массив (код типа, инициализатор) . Инициализатор опускается, если массив пусто, в противном случае это строка, если код типа равен 'u' , иначе это строка список номеров. Строка гарантированно может быть преобразована обратно в массив с тем же типом и значением, используя eval() , пока Массив Класс был импортирован с использованием из массива импорта массива . Примеры:

 массив ('л')
массив('и', 'привет \u2641')
массив('l', [1, 2, 3, 4, 5])
массив('d', [1.0, 2.0, 3.14])
 

См. также

Модуль struct

Упаковка и распаковка разнородных двоичных данных.

No related posts.