|
|
Класс array. Методы класса array
Курс по стандартной библиотеке: https://stepik.org/a/259466?utm_source=proproprogs
Стандартная
библиотека языка Python содержит класс array для реализации
еще одной известной структуры данных – динамического массива. Не вдаваясь в
детали, динамический массив – это обычный массив, но переменной длины, т.е. в
него можно добавлять новые элементы и удалять существующие. В некотором
приближении обычный список list языка Python можно отнести к
динамическим массивам, т.к. его длина зависит от количества записанных в него
данных. Однако массив array, в отличие от классического списка list, позволяет
хранить данные только одного определенного типа, и благодаря этому такие массивы
занимают меньше памяти и обеспечивают лучшую производительность при работе с
большими объемами однотипных данных.
Создание массивов array
Чтобы создать
массив array вначале
необходимо импортировать стандартный модуль с таким же названием:
А, затем, с
помощью класса array создать объект массива такого типа,
например, так:
ar = array.array('i', [1, 2, 3]) # 'i' – int (32 бита)
Здесь 'i' – это тип
данных элементов, которые может хранить массив ar. В частности 'i' означает
целочисленный знаковый тип размером 32 бита (4 байта). И каждый элемент массива
ar будет занимать
ровно 4 байта в памяти устройства. Причем этот тип можно посмотреть через
атрибут typecode следующим образом:
А размер одного
элемента массива в байтах хранится в атрибуте:
Конечно, менять
значения этих атрибутов нельзя, т.к. они играют информационную роль.
Вот еще
несколько команд создания массивов array:
a1 = array.array('b') # 'b' – Signed Char (8 бит), пустой массив
a2 = array.array('B', (255, 254, 0)) # 'B' – Unsigned Char (8 бит)
a3 = array.array('u', "abcd") # 'u' – Unicode Character (16/32 бит)
А вот примеры неверных
объявлений массивов:
e1 = array.array('b', "abcd") # TypeError
e2 = array.array('h', 123) # TypeError; 'h' – Short Integer (16 бит)
То есть, типы
добавляемых данных должны соответствовать указанному типу и в качестве второго
аргумента следует указывать итерируемую последовательность.
Допустимые типы элементов массива array
Как мы видим,
чтобы создать объект массива array необходимо указать тип его элементов.
Соответственно, нужно знать их обозначения и расшифровку. Ниже приведен список
типов данных для класса array:
|
Тип
|
Описание
|
Размер
|
|
'b'
|
Signed
Char (байтовый целочисленный)
|
8
бит
|
|
'B'
|
Unsigned
Char (байтовый целочисленный)
|
8
бит
|
|
'w'
|
Unicode
Character
|
32 бит
|
|
'h'
|
Short
Integer (короткое целое)
|
16
бит
|
|
'H'
|
Unsigned
Short Integer
|
16
бит
|
|
'i'
|
Integer
(обычное целое)
|
32
бит
|
|
'I'
|
Unsigned
Integer (беззнаковое целое)
|
32
бит
|
|
'l'
|
Long
Integer (длинное целое)
|
32
или 64 бит
|
|
'L'
|
Unsigned
Long Integer
|
32
или 64 бит
|
|
'q'
|
Long
Long Integer (очень большое целое)
|
64
бит
|
|
'Q'
|
Unsigned
Long Long Integer
|
64
бит
|
|
'f'
|
Float
(вещественное, одинарная точность)
|
32
бит
|
|
'd'
|
Double
(вещественное, двойная точность)
|
64
бит
|
Те из вас, кто
знаком с языком программирования C/C++, сразу
заметят встроенные типы данных этого языка. И это не удивительно, т.к.,
во-первых, сам язык Python реализован на Си и, во-вторых, эти типы хорошо
согласуются с архитектурой процессора и памяти устройства.
Стандартные операции над массивами array
После того, как
массив array создан:
ar = array.array('i', [1, 2, 3]) # 'i' – int (32 бита)
с ним можно
выполнять следующие простые операции:
len(ar) # 3 – число элементов массива (длина массива)
ar[1] # 2 – обращение по индексу
ar[-1] # 3 – допустимы отрицательные индексы
ar[0] = 5 # array('i', [5, 2, 3]) – изменение значения массива
b = ar * 2 # array('i', [5, 2, 3, 5, 2, 3])
Также допустимы
стандартные операции срезов:
res1 = ar[:2] # array('i', [5, 2])
res2 = ar[::-1] # array('i', [3, 2, 5])
res3 = ar[0::2] # array('i', [5, 3])
b = ar[:] # полный срез
Обратите
внимание, что при всех операциях срезов формируется новая копия массива array. Прежний массив
ar никак не
меняется.
Так как массив ar – это
итерируемый объект языка Python, то все его элементы можно
перебирать с помощью цикла for:
for x in ar:
print(x, end=" ")
Далее, если у
нас имеется два массива array:
a = array.array('b', (100, 99, 4))
b = array.array('b', (-1, -2, -3, -4))
то на их основе
можно создать третий массив, как объединение этих двух:
c = a + b # array('b', [100, 99, 4, -1, -2, -3, -4])
Но так можно
делать только с массивами одинаковых типов. Если типы не совпадают, например:
bi = array.array('i', (-1, -2, -3, -4))
то операция
объединения приведет к ошибке.
Методы массива array
Класс array содержит также
набор весьма полезных методов для работы с ним. Основные из них следующие:
|
Метод
|
Описание
|
|
append(item)
|
добавляет
новый элемент в конец массива
|
|
extend(iterable)
|
расширяет
массив переданными значениями
|
|
insert(i,
item)
|
вставляет
элемент по указанному индексу i
|
|
pop([i])
|
удаляет
и возвращает элемент по индексу i (если индекс не указан, удаляется последний
элемент)
|
|
remove(item)
|
удаляет
первое вхождение указанного элемента
|
|
index(item[,
start[, stop]])
|
возвращает
индекс первого вхождения элемента между позициями start и stop включительно
|
|
count(item)
|
подсчитывает
количество указанных элементов
|
|
clear()
|
удаляет
все элементы из массива
|
|
reverse()
|
меняет
порядок следования элементов на противоположный
|
|
tolist()
|
преобразует
массив обратно в стандартный список
|
|
frombytes(s)
|
заполняет
массив байтами из строки s
|
Многие из них
вам уже знакомы, т.к. совпадают с методами списков (list) языка Python. Применяются
они аналогичным образом. Например:
ar = array.array('i', {5, 5, 3, 2, -1}) # array('i', [2, 3, 5, -1])
ar.append(1000) # array('i', [2, 3, 5, -1, 1000])
ar.extend([1024, 2048, 4096]) # array('i', [2, 3, 5, -1, 1000, 1024, 2048, 4096])
ar.pop() # 4096, массив: array('i', [2, 3, 5, -1, 1000, 1024, 2048])
ar.pop(0) # 2, массив: array('i', [3, 5, -1, 1000, 1024, 2048])
ar.remove(5) # array('i', [3, -1, 1000, 1024, 2048])
ar.reverse() # array('i', [2048, 1024, 1000, -1, 3])
ar.tolist() # [2048, 1024, 1000, -1, 3]
Как видите, все
достаточно просто и очевидно.
Итоги
Подытоживая
материал этого занятия, можно заключить, что массивы array имеют следующие
преимущества перед обычными списками языка Python:
- Более
эффективная работа с памятью.
- Быстрая
обработка больших объемов данных одного типа.
- Оптимизация
скорости вычислений.
Но и имеют
очевидные ограничения:
- Нельзя хранить
разнотипные данные.
- Нет
динамического изменения размера типа данных внутри массива.
Таким образом,
массивы типа array целесообразно
применять в задачах:
- Если нужен
контейнер для большого количества одинаковых данных (например, числовой ряд).
- Для экономии
ресурсов памяти и ускорения обработки данных.
То есть, массивы
array полезны там, где
важна высокая скорость и компактность данных. Но если необходима гибкость, то лучше
воспользоваться стандартными списками языка Python.
Курс по стандартной библиотеке: https://stepik.org/a/259466?utm_source=proproprogs
|