Массивы в Python
В Python нет встроенного типа «массив», но вместо него можно использовать встроенный тип «список» (list). Также при использовании библиотеки NumPy можно создавать объект типа «массив» (Ndarray). Далее о каждом из этих двух вариантов подробнее.
Списки (list)
Список представляет собой тип, который может хранить любое количество элементов разных типов. Создать список в Python можно несколькими способами:
Создание
- Создание пустого списка:
names = []
names = list()
- Создание списка с элементами:
names = ['Иван', 'Женя', 'Ольга']
- Создание списка на основе другого списка:
names = ['Иван', 'Женя', 'Ольга'] new_names = list(names)
- Создание списка повторением какого-либо элемента или другого списка:
names = ['Иван', 'Женя', 'Ольга'] new_names = names * 2
- Создание списка с помощью конструкции range():
numbers = list(range(10))
Функция range(10) возвращает числа от 0 до 9, на основе которых создаётся новый список.
Обращение к элементу
Обращение к элементу списка производится по индексу элемента:
names[0]
Индексы элементов начинаются с нулевого, то есть первый элемент списка имеет индекс «0», а второй — «1».
Обход элементов
Элементы списка можно обходить циклами for и while:
for name in names: print(name)
Сравнение
Списки можно сравнивать между собой. Для того, чтобы два списка считались равными, они должны иметь одинаковый состав. К примеру, следующие два списка будут равны, не смотря на разные способы их создания:
list1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] list2 = list(range(10))
Размерность
Список в Python может быть как одномерным, так и многомерным. Выше были приведены примеры одномерных списков. Чтобы список был многомерным, например, двухмерным, каждый элемент списка должен представлять собой другой список:
names = [['Иван', 19], ['Женя', 20], ['Ольга', 21]]
В данном примере список состоит из трёх списков, каждый из которых содержит имя и возраст. Аналогично можно создавать списки с большим количеством измерений — с большим количеством уровней вложенности.
Для получения элемента многомерного списка, нужно указывать столько индексов, сколько измерений необходимо использовать для описания элемента:
names = [['Иван', 19], ['Женя', 20], ['Ольга', 21]] names[1][0]
Преобразование
Двумерный список можно преобразовать в словарь с парами «ключ-значение»:
names = [['Иван', 19], ['Женя', 20], ['Ольга', 21]] new_dict = dict(names)
Матрицы
Двумерный список является матрицей, которую визуально можно представить в следующем виде:
В данном примере переменная А содержит двумерный список, т.е. список списков, каждый из которых состоит из трёх элементов. Тип list в Python не поддерживает работу со списками как с матрицами, но, тем не менее, позволяет матрицы хранить.
Массивы NumPy (Ndarray)
Создание
Для использования класса Ndarray предварительно необходимо импортировать библиотеку numpy:
import numpy as np
Для создания массива используется функция модуля numpy — array():
import numpy as np new_array = np.array(['Иван', 'Женя', 'Ольга'])
В первый параметр функции array() передаётся список, поэтому способов создания столько же, сколько способов создания списков. При передаче в параметр многомерного списка будет создан многомерный массив:
import numpy as np new_array = np.array([['Иван', 19], ['Женя', 20], ['Ольга', 21]])
Тип значения элементов
В данном примере элементы массива были приведены к строковому типу, так как каждый список главного списка содержал строковое значение. Тип значения элементов массива можно переопределять при создании массива, указывая его вторым параметром функции array():
import numpy as np new_array = np.array([['Иван', 19], ['Женя', 20], ['Ольга', 21]], dtype=np.str)
Обращение к элементам
Обращение к элементам массива Ndarray производится аналогично получение элемента в многомерном списке.
Атрибуты класса Ndarray
Далее рассмотрим атрибуты класса Ndarray:
- ndim — число измерений (осей) массива;
- shape — размерность массива. Это tuple, содержащий натуральные числа (n, m) — длины массива по каждой оси (n — высота, m — ширина). Число элементов кортежа shape равно ndim.
- size — количество элементов в массиве, равно произведению всех элементов атрибута shape;
- dtype — тип элементов массива. NumPy предоставляет возможность использовать как встроенные типы, например: bool_, character, int8, int16, int32, int64, float8, float16, float32, float64, complex64, object_, так и собственные типы данных, в том числе и составные;
- itemsize — размер каждого элемента массива в байтах;
- data — буфер, содержащий фактические элементы массива. Обычно не нужно использовать этот атрибут, так как обращаться к элементам массива проще всего с помощью индексов.
Изменение размерности
Размерность массива darray в Python можно изменять методом reshape():
import numpy as np new_array = np.array([['Иван', 19], ['Женя', 20], ['Ольга', 21]], dtype=np.str) new_array.reshape(2, 3)
При этом количество элементов должно позволять это сделать, т.е. произведение элементов атрибута shape до и после изменения размера должно быть одинаковым. К примеру, нельзя изменить размерность массива с (3, 4) на (2, 5), но можно изменить её на (2, 6).
Как записывать в массив python
В качестве шаблонов также могут выступать массивы. Подобным шаблоны также могут содержать либо конкретные значения, либо переменные, которые передаются элементы массивов, либо символ прочерка _, если элемент массива не важен:
def print_people(people): match people: case ["Tom", "Sam", "Bob"]: print("default people") case ["Tom", second, _]: print(f"Second Person: ") case [first, second, third]: print(f", , ") print_people(["Tom", "Sam", "Bob"]) # default people print_people(["Tom", "Mike", "Bob"]) # Second Person: Mike print_people(["Alice", "Bill", "Kate"]) # Alice, Bill, Kate print_people(["Tom", "Kate"]) # несоответствует ни одному из шаблонов
В данном случае функция print_people принимает массив, который, как предполагается, состоит из трех элементов.
Первый шаблон предполагает, что элементы массива имеют определенные значения:
case ["Tom", "Sam", "Bob"]: print("default people")
В данном случае первый элемент массива должен представлять строку «Tom», второй — строку «Sam» и третий — строку «Bob».
Второй шаблон предполагает, что первый элемент массива должен быть равне строке «Tom», остальные два элемента могут иметь произвольные значения:
case ["Tom", second, _]: print(f"Second Person: ")
При этом значение второго элемента передается в переменную second, а значение третьего элемента не важно, поэтому вместо него применяется прочерк.
Третий шаблон соответствует любому массиву из трех элементов. При этом его элементы передаются в переменные first, second и third:
case [first, second, third]: print(f", , ")
В данном случае для соответствия любому из шаблонов массив должен был иметь три элемента. Но также можно определять шаблоны для массивов разной длины:
def print_people(people): match people: case [_]: print("Массив из одного элемента") case [_, _]: print("Массив из двух элементов") case [_, _, _]: print("Массив из трех элементов") case _: print("Непонятно") print_people(["Tom"]) # Массив из одного элемента print_people(["Tom", "Sam"]) # Массив из двух элементов print_people(["Tom", "Sam", "Bob"]) # Массив из трех элементов print_people("Tom") # Непонятно
Массивы неопределенной длины
Если необходимо сравнивать выражение с массивом неопределенной длины, то можно определить значения/переменные только для обязательных элементов массива, а на необязательные ссылаться с помощью символа * (звездочки):
def print_people(people): match people: case [first, *other]: print(f"First: Other: ") print_people(["Tom"]) # First: Tom Other: [] print_people(["Tom", "Sam"]) # First: Tom Other: ["Sam"] print_people(["Tom", "Sam", "Bob"]) # First: Tom Other: ["Sam", "Bob"]
В примере выше применяется параметр *other , который соответствует всем остальным элементам. То есть шаблон [first, *other] соответствует любому массиву, который имеет как минимум один элемент, и этот элемент будет помещаться в параметр first. Все остальные элементы помещаются в параметр other, который представляет массив значений.
Если нам параметр с символом * (other) не важен, но мы по прежнему хотим, чтобы шаблон соответствовал массиву с одним и большим количеством элементов, мы можем использовать подшаблон *_ :
def print_people(people): match people: case [first, *_]: print(f"First: ") print_people(["Tom"]) # First: Tom print_people(["Sam", "Tom"]) # First: Sam print_people(["Bob", "Sam", "Tom"]) # First: Bob
Альтернативные значения
Если необходимо, чтобы элемент массива соответствовал набору значений, то эти значения можно перечислить через вертикальную черту:
def print_people(people): match people: case ["Tom" | "Tomas" | "Tommy", "Sam", "Bob"]: print("default people") case [first, second, third]: print(f", , ") print_people(["Tom", "Sam", "Bob"]) # default people print_people(["Tomas", "Sam", "Bob"]) # default people print_people(["Alice", "Bill", "Kate"]) # Alice, Bill, Kate
В данном случае первый шаблон соответствует массиву из трех элементов, где первый элемент равен или «Tom», или «Tomas», или «Tommy».
Также можно задать альтернативные значения для отдельных элементов, но и альтернативные массивы:
def print_people(people): match people: case ["Tom", "Sam", "Bob"] | ["Tomas", "Sam", "Bob"]: print("Tom/Tomas, Sam, Bob") case [first, second, third]: print(f", , ") print_people(["Tom", "Sam", "Bob"]) # Tom/Tomas, Sam, Bob print_people(["Tomas", "Sam", "Bob"]) # Tom/Tomas, Sam, Bob print_people(["Alice", "Bill", "Kate"]) # Alice, Bill, Kate
В данном случае первый шаблон будет соответствовать двум массивам: [«Tom», «Sam», «Bob»] и [«Tomas», «Sam», «Bob»]
Запись/чтение массива array() в/из файл(а)
Содержимое массива array.array() может быть записано и прочитано из файлов с использованием встроенных методов.
Пример:
Этот пример иллюстрирует чтение данных непосредственно из двоичного файла. Удобно то, что не нужно преобразовать прочитанные байты в соответствующие типы.
import array import binascii import tempfile a = array.array('i', range(5)) print('A1:', a) # Записать массив чисел во временный файл output = tempfile.NamedTemporaryFile() a.tofile(output.file) output.flush() # Чтение необработанных данных with open(output.name, 'rb') as input: raw_data = input.read() print('Raw Contents:', binascii.hexlify(raw_data)) # Считать данные в массив input.seek(0) a2 = array.array('i') a2.fromfile(input, len(a)) print('A2:', a2) # A1: array('i', [0, 1, 2, 3, 4]) # Raw Contents: b'0000000001000000020000000300000004000000' # A2: array('i', [0, 1, 2, 3, 4])
Метод array.tofile() использует array.tobytes() для форматирования данных, а метод array.fromfile() использует array.frombytes() для преобразования его обратно в экземпляр массива. И array.tobytes() и array.frombytes() работают со строками байтов, а не со строками Unicode.
import array import binascii a = array.array('i', range(5)) print('A1:', a) as_bytes = a.tobytes() print('Bytes:', binascii.hexlify(as_bytes)) a2 = array.array('i') a2.frombytes(as_bytes) print('A2:', a2) # A1: array('i', [0, 1, 2, 3, 4]) # Bytes: b'0000000001000000020000000300000004000000' # A2: array('i', [0, 1, 2, 3, 4])
- КРАТКИЙ ОБЗОР МАТЕРИАЛА.
- Типы данных массива array(), модуль array
- Методы и элементы данных класса array()
- Массив array(), извлечение и сохранение в файл
- Операции c объектом array() модуля array
№18 Массивы / Уроки по Python для начинающих
Примечание: Python не имеет встроенной поддержки массивов, но вместо этого можно использовать списки (list) Python.
Массивы используются для хранения нескольких значений в одной переменной:
cars = ["Ford", "Volvo", "BMW"] Что такое массив?
Массив — это специальная переменная, которая может содержать более чем одно значение.
Если у вас есть список предметов (например, список марок авто), то хранение автомобилей в отдельных переменных может выглядеть так:
car1 = "Ford"; car2 = "Volvo"; car3 = "BMW"; Однако, что, если вы хотите проскочить через все машины и найти конкретную? А что, если у вас было бы не 3 автомобиля а 300?
Решение представляет собой массив!
Массив может содержать много значений под одним именем, и вы так же можете получить доступ к значениям по индексу.
Доступ к элементам массива
Вы ссылаетесь на элемент массива, ссылаясь на индекс.
Получим значение первого элемента массива:
x = cars[0] Изменим значение первого элемента массива:
cars[0] = "Toyota" Длина массива
Используйте метод len() чтобы вернуть длину массива (число элементов массива).
Выведем число элементов в массиве cars :
x = len(cars) Примечание: Длина массива всегда больше, чем индекс последнего элемента.
Циклы элементов массива
Вы можете использовать цикл for для прохода по всем элементам массива.
Выведем каждый элемент из цикла cars :
for x in cars: print(x) Ford Volvo BMW Добавление элементов массива
Вы можете использовать метод append() для добавления элементов в массив.
Добавим еще один элемент в массив cars :
cars.append("Honda") Удаление элементов массива
Используйте метод pop() для того, чтобы удалить элементы из массива.
Удалим второй элемент из массива cars :
cars.pop(1) Так же вы можете использовать метод remove() для того, чтобы убрать элемент массива.
Удалим элемент со значением “Volvo”:
cars.remove("Volvo") Примечание: Метод remove() удаляет только первое вхождение указанного значения.
Методы массива
В Python есть набор встроенных методов, которые вы можете использовать при работе с lists/arrays.
| Метод | Значение |
|---|---|
| append() | Добавляет элементы в конец списка |
| clear() | Удаляет все элементы в списке |
| copy() | Возвращает копию списка |
| count() | Возвращает число элементов с определенным значением |
| extend() | Добавляет элементы списка в конец текущего списка |
| index() | Возвращает индекс первого элемента с определенным значением |
| insert() | Добавляет элемент в определенную позицию |
| pop() | Удаляет элемент по индексу |
| remove() | Убирает элементы по значению |
| reverse() | Разворачивает порядок в списке |
| sort() | Сортирует список |
Примечание: В Python нет встроенной поддержки для массивов, вместо этого можно использовать Python List.
- ТЕГИ
- Уроки Python для начинающих