Массивы в Python

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

Определение понятия

Под массивом подразумевается переменная, которая может содержать несколько значений. Такая переменная состоит из нескольких других. Например, если мы имеем перечень объектов (например, марок автомобилей), то чтобы хранить их в отдельных переменных очень неудобно. Даже три машины занимают немало места, в то время как в коде каждая строчка имеет значение. 

car1 = "Ford";  

car2 = "Volvo";  

car3 = "BMW";

А что если машин будет больше 300? В этом случае удобно использовать массив. Его фишка в том, что он может содержать большое количество значений под одним именем. А чтобы получить доступ к значениям, можно воспользоваться их индексом или ключом (в зависимости от типа массива).

А теперь давайте рассмотрим основные типы массивов в Python.

Список

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

z = [3, 7, 4, 2]  # Создание списка

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

# Создание списка с разными типам данных 

heterogenousElements = [3, True, 'Витя', 2.0]

Каждый элемент списка имеет свой индекс, с помощью которого можно найти его и совершить с ним некоторые операции, такие как удаление или изменение.

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

Предположим, у нас есть такая программа. 

z = [3, 7, 4, 2]  # создаем список 

# обращение к первому элементу списка с индексом 0

print(z[0]) 

# элемент с индексом 0 -> 3

Если в функции print() использовать индекс 1, то тогда будет напечатано число 7, и так далее.

Также возможна отрицательная индексация. Если использовать индекс -1, то тогда получаем доступ к последнему элементу.  

# выведите последний элемент списка 

>>> print(z[-1])

2

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

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

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

>>> print(z[3])

2

Срезы списка

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

# Создайте список

z = [3, 7, 4, 2]

# Вывод элементов с индексом от 0 до 2 (не включая 2)

print(z[0:2]) 

# вывод: [3, 7]

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

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

# Все, кроме индекса 3

>>> print(z[:3])

[3, 7, 4]

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

# Все, кроме индекса 3

>>> print(z[:3])

[3, 7, 4]

Изменение содержимого списка

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

z = [3, 7, 4, 2]  # Создание списка

# Изменяем элемент с индексом 1 на строку 'fish'

z[1] = 'fish'

print(z)

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

Кортеж

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

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

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

>>> a = (10, 2.13, "square", 89, 'C')

>>> a

(10, 2.13, 'square', 89, 'C')

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

>>> a[3]

89

>>> a[1:3]

(2.13, 'square')

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

>>> a[0] = 11

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: 'tuple' object does not 

support item assignment

Видим, что интерпретатор Python ругается на то, что это неподдерживаемое действие.

Поскольку tuple (а именно так еще называется кортеж) – это неизменяемый объект, он не содержит методов, предназначенных для добавления элементов или удаления их.

В некоторых случаях использование кортежа целесообразно, поскольку данные иногда надо защищать от редактирования. Если же необходимо внести какие-то изменения, всегда можно превратить кортеж в обычный список с помощью функции list(), указав имя переменной, которой был присвоен кортеж, в качестве аргумента. 

>>> a = (10, 2.13, "square", 89, 'C')

>>> b = [1, 2, 3]

>>> c = list(a)

>>> d = tuple(b)

>>> c

[10, 2.13, 'square', 89, 'C']

>>> d

(1, 2, 3)

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

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

nested = (1, “do”, [“param”, 10, 20])

Появляется резонный вопрос: если в кортежах ничего нельзя изменять, то почему внезапно в списке это стало возможным? Ведь он – составляющая часть кортежа! Все просто, на самом деле. Причина кроется в том, что список находится отдельно, а элемент кортежа с определенным индексом просто ссылается на него. 

Пример изменения элемента списка внутри кортежа. 

>>> nested[2][1] = 15

>>> nested

(1, 'do', ['param', 15, 20])

Обратите внимание на другой характер индексации в этом примере. Сначала идет индекс, который имеет список внутри кортежа, а потом – номер элемента в самом этом списке. Все потому, что необходимо как-то разграничивать обычный и итерируемый объекты. 

Словарь

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

Приведем пример для наглядности. 

dictionary = {'персона': 'человек',

              'марафон': 'гонка бегунов длиной около 26 миль',

              'противостоять': 'оставаться сильным, несмотря на давление',

              'бежать': 'двигаться со скоростью'}

Этот словарь очень наглядно показывает, как работает он в Python. Действительно, очень похоже. Роль термина играет ключ, а определения – значение. 

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

dictionary = {(1, 2.0): 'кортежи могут быть ключами',

              1: 'целые числа могут быть ключами',

              'бежать': 'строки тоже', 

              ['носок', 1, 2.0]: 'а списки не могут'}

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

# берём значение с ключом "марафон"

dictionary['марафон']

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

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

Множества

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

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

>>> a = {'a', 'b', 'c', 'd'}

>>> a

{'b', 'c', 'a', 'd'}

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

>>> a = {}  # А так нельзя!

>>> type(a)

<class 'dict'>

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

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

Добавить комментарий

;-) :| :x :twisted: :smile: :shock: :sad: :roll: :razz: :oops: :o :mrgreen: :lol: :idea: :grin: :evil: :cry: :cool: :arrow: :???: :?: :!:

4 × пять =

Adblock
detector