Работа со списками (list) в python

Функция reduce():

Функция reduce(), как можно понять из названия, применяет переданную функцию к итерируемому объекту и возвращает одно значение.

Синтаксис:

reduce(function, iterables)

Здесь функция определяет, какое выражение необходимо применить к итерируемому объекту. Эту функцию необходимо импортировать из модуля functools.

Пример:

from functools import reduce
reduce(lambda a, b: a + b, )

Результат:

187

В приведенном выше примере функция reduce последовательно суммирует каждый элемент из списка и возвращает одно выходное значение.

Функции map(), filter() и reduce() в Python могут использоваться вместе друг с другом.

3. Как преобразовать список в другие структуры данных в Python?

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

Как преобразовать список в строку

Преобразовать список в строку можно при помощи функции . Данная операция склеит все элементы нашего списка вместе и вернет строку. Более подробно об этом можно прочитать в .

# Преобразование списка строк в строку
listOfStrings = 
strOfStrings = ''.join(listOfStrings)
print(strOfStrings)

# Преобразование списка чисел в строку
listOfNumbers = 
strOfNumbers = ''.join(str(n) for n in listOfNumbers)
print(strOfNumbers)

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

Для преобразования целого числа в строковое значение мы проходим циклом по всему массиву чисел.

Как преобразовать список в кортеж

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

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

Как преобразовать список в множество

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

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

Как преобразовать список в словарь

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

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

В результате получим:

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

Теперь передадим функцию в функцию , которая будет воспринимать элемент как ключ, а элемент как значение. Сходным образом, будет интерпретирован как ключ, а — как значение.

# Преобразуем в словарь
helloWorldDictionary = dict(zip(helloWorld, helloWorld))

# Выводим результат на экран
print(helloWorldDictionary)

В результате получится следующий словарь:

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

a = 

# Создаем итератор списка
i = iter(a)

# Создаем и выводим на экран словарь
print(dict(zip(i, i)))

Результат:

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

Python NumPy

NumPy IntroNumPy Getting StartedNumPy Creating ArraysNumPy Array IndexingNumPy Array SlicingNumPy Data TypesNumPy Copy vs ViewNumPy Array ShapeNumPy Array ReshapeNumPy Array IteratingNumPy Array JoinNumPy Array SplitNumPy Array SearchNumPy Array SortNumPy Array FilterNumPy Random
Random Intro
Data Distribution
Random Permutation
Seaborn Module
Normal Distribution
Binomial Distribution
Poisson Distribution
Uniform Distribution
Logistic Distribution
Multinomial Distribution
Exponential Distribution
Chi Square Distribution
Rayleigh Distribution
Pareto Distribution
Zipf Distribution

NumPy ufunc
ufunc Intro
ufunc Create Function
ufunc Simple Arithmetic
ufunc Rounding Decimals
ufunc Logs
ufunc Summations
ufunc Products
ufunc Differences
ufunc Finding LCM
ufunc Finding GCD
ufunc Trigonometric
ufunc Hyperbolic
ufunc Set Operations

Операция присваивания на месте += и списки list.

Списки в Python невероятно хороши. Можно выполнять разные вещи, такие как:

• объединение нескольких списков с помощью оператора ;
• создание повторяющегося списка с помощью оператора ;
• объединение и назначение списков с помощью оператора .

Рассмотрим пример того, как оператор работает с объектом .

>>> lst = 3, 4, 5, 6, 7
>>> lst_copy = lst
>>> lst = lst + 8, 9
>>> lst
# 
>>> lst_copy
# Out: 

Что произошло: создали список под названием , затем создали новый список с именем , указав его на . Затем изменили , добавив к нему . Как и ожидалось, оператор расширил список создав новую последовательность, тогда как остался прежним.

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

Итак, перепишем пример c использованием оператора присваивания на месте :

>>> lst = 3, 4, 5, 6, 7
>>> lst_copy = lst
>>> lst += 8, 9
>>> lst
# 
>>> lst_copy
# 

# Да ладно... Не может быть...

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

Так почему же был изменен список ? Потому что это не фактическая копия (), а указатель на ячейку в памяти. То есть для списка (изменяемых последовательностей) оператор изменяет ее, как говорится «на месте» — в памяти и не создает новую (итоговую) последовательность как с оператором .

>>> lst = 3, 4, 5, 6, 7
>>> lst_copy = lst
>>> lst.extend()
>>> lst
# 
>>> lst_copy
# 

Предварительные сведения

Списки в Python это на редкость популярная тема как для начинающих свой путь программировании, так и для опытных экспертов в языке Python. Если верить Google Trends, то интерес к этой теме растет из года в год.

Если вы регулярно посещаете форумы, где можно задать вопросы по программированию на Python, например Stack Overflow, Quora или Reddit, то наверняка понимаете причину такой популярности этой темы.

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

В данной статье мы кратко пройдемся по самым распространенным вопросам на тему списков в языке Python.

Метод list.insert()

Аргументы метода list.insert(i,x):

• i – индекс, который нужно присвоить новому элементу.
• x – новый элемент, который нужно вставить в список.

В аквариуме появилась ещё одна рыба (например, anchovy)

Обратите внимание: на данный момент элементы списка fish указаны в алфавитном порядке. Потому элемент ‘anchovy’ нужно добавить не в конец, а в начало списка

Предыдущий метод не подходит – он добавляет элементы только в конец списка. Используйте метод list.insert():

Теперь индексы всех элементов обновятся (‘anchovy’ – 0, ‘barracuda’ – 1, ‘flounder’ – 5).

Попробуйте добавить в список ещё один элемент, damselfish. Соблюдая алфавитный порядок, добавить элемент нужно под индексом 3.

Как перебрать значения списка в Python?

Python позволяет использовать цикла for со списками:

Индекс текущего элемента в цикле можно получить используя функцию enumerate:

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

Ранее отмечалось, что списки являются изменяемой (или иммютабельной, от англ. immutable) структурой данных. Это означает, что если изменить список во время итерации, мы можем получить неожиданные результаты, например:

В примере мы удалили первый элемент на первой итерации изменив список, что привело к пропуску bar. На второй итерации, baz стал вторым элементом списка.

Методы и функции списков

Метод — это то же самое, что и функция, за исключением того, что он «вызывается» для значения. Например, если значение списка было сохранено в spam, вы бы вызвали метод списка index() (который я объясню далее) в этом списке следующим образом: spam.index(‘hello’). Часть метода идет после значения, разделенного точкой. Каждый тип данных имеет свой собственный набор методов. Например, тип data имеет несколько полезных методов для поиска, добавления, удаления и других манипуляций со значениями в списке.

Поиск значения в списке с помощью метода index ()

У значений списка есть метод index(), которому можно передать значение, и, если это значение существует в списке, возвращается индекс значения. Если значение отсутствует в списке, то Python выдаст ошибку ValueError.

При наличии дубликатов значения в списке возвращается индекс его первого появления

Обратите внимание, что index() возвращает 1, а не 3

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

Чтобы добавить новые значения в список, используйте методы append() и insert().

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

Удаление значений из списка с помощью метода remove ()

Метод remove() передает значение, которое будет удалено из списка, к которому он обращен.

Если значение появляется в списке несколько раз, будет удален только первый экземпляр значения.Оператор del хорошо использовать, когда вы знаете индекс значения, которое хотите удалить из списка. Метод remove() хорош, когда вы знаете значение, которое хотите удалить из списка.

Сортировка с помощью метода sort()

Списки числовых значений или списки строк могут быть отсортированы с помощью метода sort().

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

Есть три вещи, которые вы должны знать о методе sort(). Во-первых, метод sort() сортирует список по месту; поэтому не пытайтесь получить возвращаемое значение, написав такой код, как spam = spam.sort().Во-вторых, вы не можете сортировать списки, в которых есть как числовые, так и строковые значения, поскольку Python не знает, как сравнивать эти значения.

В-третьих, sort() использует «ASCII порядок», а не фактический алфавитный порядок для сортировки строк. Это означает, что заглавные буквы идут перед строчными. Поэтому строчная буква a сортируется так, чтобы она шла после заглавной буквы Z.

Если вам нужно отсортировать значения в обычном алфавитном порядке, передайте str.lower для ключевого аргумента в вызове метода sort().

Это заставляет функцию sort() обрабатывать все элементы в списке, как если бы они были строчными, без фактического изменения значений в списке.

Строки и кортежи

Списки не являются единственными типами данных, которые представляют упорядоченные последовательности значений. Например, строки и списки на самом деле похожи, если считать строку «list» однотекстовых символов. Многое из того, что вы можете сделать со списками, также может быть сделано со строками: индексы; срезы; и используя их с for, с len() и с операторами in и not in.

Изменяемые и неизменяемые типы

Списки и строки важны по-разному. Значение списка является изменяемым типом данных: оно может иметь значения, добавленные, удаленные или измененные. Однако строка является неизменной: ее нельзя изменить. Попытка переназначить один символ в строке приводит к ошибке TypeError.Правильный способ сделать строку изменяемой — это использовать срез и конкатенацию для построения новой строки путем копирования из частей старой строки.

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

Обратите внимание, что исходная строка «Кошку звать Муся» не изменяется, потому что строки являются неизменяемыми. Хотя значение списка является изменяемым, вторая строка в следующем коде не изменяет список в eggs

Значение списка в eggs здесь не изменяется; новое и другое значение списка () перезаписывает старое значение списка (). Если вы хотите изменить исходный список в eggs, чтобы он содержал , вам нужно будет сделать что-то вроде этого:

Где находится автозамена в ворде

Проверка принадлежности – множества

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

Однако, если в вашем приложении механика проверки принадлежности встречается достаточно часто, то следует рассмотреть возможность использования множеств (set) вместо списков. Множества – это еще один важный тип контейнера в Python. Отличительная особенность множества в том, что все элементы в нем уникальные и хэшируемые. Требование к хэшируемости выполняется поскольку под капотом Python реализует множества в виде хэш-таблиц. Одним из наиболее существенных преимуществ использования хэш-таблиц является реализация механизма константного времени поиска конкретных элементов.

Давайте проведем простое сравнение и посмотрим, насколько множества обойдут списки в производительности, когда речь зайдет о миллионах элементов в контейнерах:

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

5.5. Dictionaries¶

Another useful data type built into Python is the dictionary (see
). Dictionaries are sometimes found in other languages as
“associative memories” or “associative arrays”. Unlike sequences, which are
indexed by a range of numbers, dictionaries are indexed by keys, which can be
any immutable type; strings and numbers can always be keys. Tuples can be used
as keys if they contain only strings, numbers, or tuples; if a tuple contains
any mutable object either directly or indirectly, it cannot be used as a key.
You can’t use lists as keys, since lists can be modified in place using index
assignments, slice assignments, or methods like and
.

It is best to think of a dictionary as a set of key: value pairs,
with the requirement that the keys are unique (within one dictionary). A pair of
braces creates an empty dictionary: . Placing a comma-separated list of
key:value pairs within the braces adds initial key:value pairs to the
dictionary; this is also the way dictionaries are written on output.

The main operations on a dictionary are storing a value with some key and
extracting the value given the key. It is also possible to delete a key:value
pair with . If you store using a key that is already in use, the old
value associated with that key is forgotten. It is an error to extract a value
using a non-existent key.

Performing on a dictionary returns a list of all the keys
used in the dictionary, in insertion order (if you want it sorted, just use
instead). To check whether a single key is in the
dictionary, use the keyword.

Here is a small example using a dictionary:

>>> tel = {'jack' 4098, 'sape' 4139}
>>> tel'guido' = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel'jack'
4098
>>> del tel'sape'
>>> tel'irv' = 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel)

>>> sorted(tel)

>>> 'guido' in tel
True
>>> 'jack' not in tel
False

The constructor builds dictionaries directly from sequences of
key-value pairs:

>>> dict()
{'sape': 4139, 'guido': 4127, 'jack': 4098}

In addition, dict comprehensions can be used to create dictionaries from
arbitrary key and value expressions:

>>> {x x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

When the keys are simple strings, it is sometimes easier to specify pairs using
keyword arguments:

Классификация люстр и критерии выбора

Как создаются списки в Python

Существует несколько способов создания списков в Python. Чтобы лучше понять компромиссы связанные с использованием list comprehension, давайте сначала рассмотрим способы создания списков с помощью этих подходов.

Использование цикла for

Наиболее распространенным типом цикла является цикл for. Использование цикла for можно разбить на три этапа:

1. Создание пустого списка.
2. Цикл по итерируемому объекту или диапазону элементов range.
3. Добавляем каждый элемент в конец списка.

Допустим на надо создать список squares, то эти шаги будут в трех строках кода:

>>> squares = []
>>> for i in range(10):
...     squares.append(i * i)
>>> squares

Здесь мы создаем пустой список squares. Затем используем цикл for для перебора range(10). Наконец умножаем каждое число отдельно и добавляете результат в конец списка.

Использование объектов map()

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

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

>>> txns = 
>>> TAX_RATE = .08

>>> def get_price_with_tax(txn):
...     return txn * (1 + TAX_RATE)

>>> final_prices = map(get_price_with_tax, txns)
>>> list(final_prices)

Здесь у вас есть итерируемый объект txns (в нашем случае простой список) и функция get_price_with_tax(). Мы передаем оба этих аргумента в map() и сохраняем полученный объект в final_prices. Мы можем легко преобразовать этот объект map в список, используя list().

Использование List Comprehensions

List comprehensions — это третий способ составления списков. При таком элегантном подходе мы можем переписать цикл for из первого примера всего в одну строку кода:

>>> squares = 
>>> squares

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

new_list = 

Каждое представление списков в Python включает три элемента:

1.  какое либо вычисление, вызов метода или любое другое допустимое выражение, которое возвращает значение. В приведенном выше примере выражение i * i является квадратом значения члена.
2.  является объектом или значением в списке или итерируемым объекте (iterable). В приведенном выше примере значением элемента является i.
3.  список, множество, последовательность, генератор или любой другой объект, который может возвращать свои элементы по одному. В приведенном выше примере iterable является range(10).

Поскольку требования к expression (выражению) настолько гибки, представление списков хорошо работает во многих местах, где вы будете использовать map(). Вы так же можем переписать пример ценообразования:

>>> txns = 
>>> TAX_RATE = .08

>>> def get_price_with_tax(txn):
...     return txn * (1 + TAX_RATE)

>>> final_prices = 
>>> final_prices

Единственное различие между этой реализацией и map() состоит в том, что list comprehension возвращает список, а не объект map.

Преимущества использования представления списков

Представление списков часто описываются как более Pythonic, чем циклы или map(). Но вместо того, чтобы слепо принимать эту оценку, стоит понять преимущества использования list comprehension по сравнению с альтернативами. Позже вы узнаете о нескольких сценариях, в которых альтернативы являются лучшим выбором.

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

Это основная причина, почему list comprehension считаются Pythonic, поскольку Python включает в себя простые и мощные инструменты, которые вы можете использовать в самых разных ситуациях. Дополнительным преимуществом является то, что всякий раз, когда вы используете представления списков, вам не нужно запоминать правильный порядок аргументов, как при вызове map().

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

Как получить значение списка по индексу?

У каждого элемента списка есть свой уникальный номер. Этот номер называется индексом. Списки в Python имеют нулевую индексацию, как у массивов в других языках. Это означает, что первый элемент списка имеет индекс 0, второй элемент — индекс 1, третий — 2 и т. д.

Если запросить элемент по индексу за пределами списка, Python выкинет исключение .

Отрицательные индексы интерпретируются как подсчёт с конца списка.

То же действие можно воспроизвести следующим образом:

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

Слайсингом можно развернуть список в обратную сторону:

Использование отрицательного шага эквивалентно следующему коду:

В чем разница между методами append() и extend()?

Давайте возьмемся за этот вопрос, вернувшись к концепции итерируемости, которую мы объяснили в начале нашей статьи.

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

Совет: чтобы проверить, является ли переменная итерируемой, воспользуйтесь методом __iter__. Вот пример такого кода:

# Эта ваш список
list = 
# Проверим, итерируемый он или нет
list.__iter__

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

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

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

На примере следующего кода очень легко увидеть и понять разницу в работе этих методов:

# Добавляем список  в список `shortList`
shortList.append()
# Используем метод print() для вывода shortList на экран
print(shortList)
# Расширяем `longerList` при помощи списка 
longerList.extend()
# Используем метод print() для вывода longerList на экран
print(longerList)

Результат:

Создает строку из списка строк.

Описание:

Метод возвращает строку, которая является конкатенацией (объединением) всех элементов строк итерируемого объекта .

В итоговой строке элементы объединяются между собой при помощи строки-разделителя .

Если в последовательности есть какие-либо НЕ строковые значения, включая байтовые строки , то поднимается исключение .

Примеры создания строки из списка строк.

>>> x = 'возвращает',  'строку',  'которая', 
         'является', 'конкатенацией'

# объединение списка строк с разделителем "пробел"
>>> line =  ' '.join(x)
>>> line
# 'возвращает строку которая является конкатенацией'

# в качестве разделителя символ новой строки '\n'
>>> line = '\n'.join(x)
>>> line
# 'возвращает\nстроку\nкоторая\nявляется\nконкатенацией'
>>> print(line)
# возвращает
# строку
# которая
# является
# конкатенацией

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

В примере будем использовать словарь из двух списков — (для ошибок) и (для итогового сообщения):

# здесь поступают какие то данные, пускай 
# num - должно быть целым числом
# name - имя, которое должно быть не менее 3-х букв

content = {'message' [], 'error' []}
# далее идет код проверок например:
if num
    if type(num) is int
        content'message'.append(f'  - Введено число {num}')
    else
        content'error'.append(f'  - {num} - это не целое число')
else
    content'error'.append('  - Вы не ввели число')

if name
    if len(name) > 3
        content'message'.append(f'  - Введено имя: {name}')
    else
        content'error'.append('  - Имя не должно быть короче 3-х букв')
else
    content'error'.append('  - Вы не ввели имя')

# в конце кода итоговые проверки и вывод сообщения
if content'error']:
    # если есть какие-то ошибки
    content'error'.insert(, 'При вводе данных возникли ошибки:\n')
    result_message = '\n'.join(content'error'])
else
    # если все хорошо.
    content'message'.insert(, 'Результаты ввода данных:\n')
    result_message = '\n'.join(content'message'])

print(result_message)

Как добавить/соединить существующую строку со списком строк.

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

# начальная строка
>>> line = 'Состав корзины покупателя:'
# список строк, которые нужно добавить
>>> lst_line = '- картошка', '- морковь', '- лук', '- чеснок', '- свекла'
# вставляем начальную строку по индексу 0 в список
>>> lst_line.insert(, line)
# объединяем список строк по разделителю '\n'
>>> rez = '\n'.join(lst_line)
>>> print(rez)
# Состав корзины покупателя:
# - картошка
# - морковь
# - лук
# - чеснок
# - свекла

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

First-In-First-Out – двусторонняя очередь

Бывают ситуации, когда нужно часто добавлять элементы с одной, а удалять с другой стороны последовательности. То есть подразумевается порядок обработки элементов FIFO (First-in-first-out). Другими словами, первый добавленный элемент будет обработан первым. На списках мы можем реализовать эту конструкцию с помощью функции pop(0). Однако ее выполнение требует больших временных затрат, поскольку элементы должны сдвигаться, что по сложности будет соответствовать O(n).

Тип данных deque, напротив, является двусторонней очередью, которая предназначена для быстрого добавления и удаления элементов с обоих концов последовательности. Чтобы выполнить операцию FIFO, Python может непосредственно удалить элемент в начале очереди без необходимости сдвигать все элементы. Значит, операция FIFO будет выполнена быстро. Обратимся к сравнению ниже: