Оптимизации, используемые в Python: список и кортеж
В Python, есть два похожих типа — список (list) и кортеж (tuple). Самая известная разница между ними состоит в том, что кортежи неизменяемы.
Вы не можете изменить объекты в tuple:
Но вы можете модифицировать изменяемые объекты внутри кортежа:
Внутри CPython (стандартного интерпретатора), список и кортеж реализованы как лист из указателей (ссылок) на Python объекты, т.е. физически они не хранят объекты рядом с друг другом. Когда вы удаляете объект из списка происходит удаление ссылки на этот объект. Если на объект ещё кто-то ссылается, то он продолжит находиться в памяти.
Кортежи
Несмотря на тот факт, что кортежи намного реже встречаются в коде и не так популярны, это очень фундаментальный тип, который Python постоянно использует для внутренних целей.
Вы можете не замечать, но вы используете кортежи когда:
- работаете с аргументами или параметрами (они хранятся как кортежи)
- возвращаете две или более переменных из функции
- итерируете ключи-значения в словаре
- используете форматирование строк
Пустые списки vs пустые кортежи
Пустой кортеж работает как синглтон, т.е. в памяти запущенного Python скрипта всегда находится только один пустой кортеж. Все пустые кортежи просто ссылаются на один и тот же объект, это возможно благодаря тому, что кортежи неизменяемы. Такой подход сохраняет много памяти и ускоряет процесс работы с пустыми кортежами.
Но это не работает со списками, ведь они могут быть изменены:
Оптимизация выделения памяти для кортежей
Для того, чтобы снизить фрагментацию памяти и ускорить создание кортежей, Python переиспользует старые кортежи, которые были удалены. Если кортеж состоит из менее чем 20 элементов и больше не используется, то вместо удаления Python помещает его в специальный список, в котором хранятся свободные для повторного использования кортежи.
Этот список разделен на 20 групп, где каждая группа представляет из себя список кортежей размера n, где n от 0 до 20. Каждая группа может хранить до 2 000 свободных кортежей. Первая группа хранит только один элемент и представляет из себя список из одного пустого кортежа.
В примере выше, мы можем видеть, что a и b имеют одинаковый адрес в памяти. Это происходит из-за того, что мы мгновенно заняли свободный кортеж такого же размера.
Оптимизация выделения памяти для списков
Так как списки могут изменяться, такую же оптимизацию как в случае с кортежами провернуть уже не получится. Несмотря на это, для списков используется похожая оптимизация нацеленная на пустые списки. Если пустой список удаляется, то он так же может быть переиспользован в дальнейшем.
Изменение размера списка
Чтобы избежать накладные расходы на постоянное изменение размера списков, Python не изменяет его размер каждый раз, как только это требуется. Вместо этого, в каждом списке есть набор дополнительных ячеек, которые скрыты для пользователя, но в дальнейшем могут быть использованы для новых элементов. Как только скрытые ячейки заканчиваются, Python добавляет дополнительное место под новые элементы. Причём делает это с хорошим запасом, количество скрытых ячеек выбирается на основе текущего размера списка — чем он больше, тем больше дополнительных скрытых слотов под новые элементы.
Эта оптимизация особенно выручает, когда вы пытайтесь добавлять множество элементов в цикле.
Паттерн роста размера списка выглядит примерно так: 0, 4, 8, 16, 25, 35, 46, 58, 72, 88,…
Для примера, если вы хотите добавить новый элемент в список с 8 элементами, то свободных ячеек в нём уже не будет и Python сразу расширит его размер до 16 ячеек, где 9 из них будут заняты и видны пользователю.
Формула выбора размера написанная на Python:
Скорость
Если сравнивать эти два типа по скорости, то в среднем по больнице, кортежи слегка быстрее списков. У Raymond Hettinger есть отличное объяснение разницы в скорости на stackoverflow.
Python для начинающих: какая разница между tuple, list и set?
Язык программирования Python предоставляет четыре встроенных типа данных для хранения коллекций из объектов. Все они наделены различными свойствами и характеристиками: list (список), tuple (кортеж), set (множество) и dictionary (словарь).
В статье обсудим различия между списками, кортежами, множествами и словарями, а также поразмышляем, когда лучше использовать каждый из встроенных типов последовательностей Python.
Примечание: поскольку словарь связывает соответствующие значения с ключами, а это совсем другой сценарий использования по сравнению со списками, множествами и кортежами (которые просто содержат значения), словарь не участвует в обсуждении.
Зачем вообще выбирать?
По большей части любая из последовательностей Python применяется на практике без особых проблем, в любом приложении. Однако представьте, что перед вами поставлена легендарная задача найти иголку в стоге сена: какой тип данных Python эффективнее всего справится с такой задачей с точки зрения скорости и памяти?
Может стог сена — это список? Как насчет кортежа? Почему бы не использовать множества всегда? На какие предостережения следует обратить внимание?
Отличия между списком, кортежем и множеством
- Отличие 1: дубликаты.
Говоря проще, List и Tuple в Python как двойняшки разного пола, а тип данных Set для них как двоюродный брат. В отличие от списков или кортежей, множество не содержит дубликатов. Другими словами, элементы множества всегда уникальны. Получается, что множество удобно удаляет дубликаты, словно создано именно для этого.
- Отличие 2: упорядоченность.
Наверняка вы слышали утверждение “множества и словари в Python не упорядочены”, но на сегодняшний день — это лишь половина правды в зависимости от того, какой версией Python вы пользуетесь. До Python версии 3.6 словари и множества действительно не сохраняли порядок элементов, но начиная с Python 3.7, dictionary и set официально упорядочены по времени добавления элементов. А вот list и tuple — это всегда упорядоченные последовательности объектов.
- Отличие 3: индексация.
Что списки, что кортежи — оба поддерживают индексацию и срезы, а вот множества — нет.
Когда выбирать список, а когда — кортеж?
Как упоминалось в руководстве ранее, кортеж — неизменяемый тип данных, тогда как список — изменяемый. Кроме того, размер кортежа фиксированный, а вот размер списка — динамический.
- Список подходит, если:
- Последовательность планируется изменять.
- Планируется постепенно добавлять новые элементы в последовательность или удалять старые.
- Кортеж подходит, если:
- Последовательность НЕ планируется изменять.
- Все, что нужно от последовательности — это возможность поочередно перебирать постоянный набор элементов.
- Нужна последовательность элементов для ее назначения в качестве ключа словаря. Поскольку списки — это изменяемый тип данных, их нельзя применять в качестве ключей словаря.
- Важна скорость выполнения операций с последовательностью: из-за отсутствия возможности изменения, кортежи работают куда быстрее списков.
Когда выбирать множества?
Базовая структура типа данных “множество” — это хеш-таблица (Hash Table). Поэтому множества очень быстро справляются с проверкой элементов на вхождение, например содержится ли объект x в последовательности a_set .
Идея заключается в том, что поиск элемента в хэш-таблице — это операция O(1), то есть операция с постоянным временем выполнения.
Получается, всегда надо использовать множество?
По сути, если не нужно хранить дубликаты, то множество будет лучшим выбором, чем список.
Выводы
“Преждевременная оптимизация — корень всех зол”.
Итак, самое главное, что вам стоит запомнить по поводу списков, кортежей и множеств.
- Если необходимо хранить дубликаты, то выбирайте список или кортеж.
- Если НЕ планируется изменять последовательность после ее создания, то выбирайте кортеж, а не список.
- Если НЕ нужно хранить дубликаты, то воспользуйтесь множеством, так как они значительно быстрее определяют наличие объекта в последовательности.
В конечном итоге, по большей части не стоит слишком сильно задумываться о том, какого же типа данных последовательностью воспользоваться.
Главное — помнить о похожих чертах и особенностях встроенных типов данных Python.
Последовательности: списки, кортежи и строки#
Все встроенные коллекции, перечисленные ниже, являются последовательностями (sequence types):
bytearray и bytes — изменяемый и неизменяемый массивы байтов.
Коллекция является последовательностью, если элементы этой коллекции упорядоченны. Следствием этого свойства является возможность индексации последовательности по порядковому номеру элемента (по смещению, по целочисленному индексу), т.е. у любой последовательности можно спросить её \(i\) -й элемент.
Более формально это значит, что если s — объект-последовательность, i , j и k — индексы (целые числа), то доступные следующие операции.
i -й элемент последовательности s .
Срез s от i включительно до j не включительно.
Срез s от i включительно до j не включительно c шагом k .
Нас пока интересует только первая строка этой таблицы. Про срезы речь пойдет позже.
При этом индексация последовательностей в python всегда начинается с 0 (sero based).
Общие для последовательностей операции#
Следующие операции можно совершать почти над любыми последовательностями (некоторые из них не поддерживаются range ).
True , если в s есть элемент равный x . False иначе.
Отрицание x in s .
Конкатенация s и t . Новый объект.
Эквивалентно добавлению s к самому себе n раз. Новый объект.
Наименьший элемент в s .
Наибольший элемент в s .
s.index(x[, start[, end]])
Индекс первого совпадения x с элементом в s . Бросает ошибку, если элемента нет в x . (В срезе s[start:end] , если метод вызван с start и/или end , но возвращаемое значение все равно отсчитывается от начала s , а не от start ).
Количество раз x встречается в s .
Принадлежность контейнеру#
Т.к. все последовательности являются контейнерами (обратное неверно), то у любой последовательности sequence можно выяснять, содержит ли она объект x следующим синтаксисом.
Вычисление этого выражение должно вернуть значение True , если x содержится в sequence , и значение False иначе.
Код в ячейке ниже удостоверяет, что символ "a" присутствует в строке "abc" , а символ "x" — нет.
Для строк операция проверки на принадлежность работает несколько шире, чем для остальных контейнеров: можно проверять наличие сразу подстроки.
Вместо того чтобы отрицать результат проверки на принадлежность, можно проверять на непринадлежность сразу.
У последовательностей можно спрашивать более содержательные вопросы, чем просто факт наличия элемента в контейнере. Например, методом index можно узнать индекс первого вхождения элемента x в последовательность s .
Методом count можно посчитать количество вхождений элемента x в последовательность s .
Сложение и умножение последовательностей#
Последовательности одного вида (кроме range ) можно конкатенировать знаком плюс.
Умножение последовательности s (кроме range ) на целое число n эквивалентно конкатенации s с самой собой n раз.
Упорядочивание элементов последовательности#
Операции в этом подразделе поддерживаются, вообще говоря, всеми итерируемыми объектами, т.е. контейнерами, по элементам которого можно пробежаться в каком-то порядке. Все последовательности являются итерируемыми объектами, т.к. по их элементам можно пробежаться хотя бы в порядке, в котором они пронумерованы.
Если элементы итерируемого объекта однородны, т.е. их можно сравнить друг с другом на предмет большинства и равенства, то их можно сортировать, искать минимальное и максимальное значение в них.
Например, строки в python упорядочиваются в лексикографическом порядке (как в словаре).
Встроенные функции min и max находят минимальный и максимальный элементы итерируемого объекта соответственно.
Код в ячейке удостоверяет, что буква "h" идет раньше всех в алфавите среди всех букв слова "python" , а буква "y" — последней.
Встроенная функция sorted принимает на вход итерируемый объект и возвращает список его элементов в отсортированном порядке.
Опциональный именованный параметр reverse позволяет сортировать в обратном порядке.
На самом деле python упорядочивает символы согласно их unicode кодам. В таблицу символов unicode входят, в том числе и emoji, что позволяет средствами python ответить на извечный вопрос: “Что появилось раньше, яйцо или курица?”.
Здесь встроенная функция chr делает символ из его unicode кода, который в примере выше задаётся в шестнадцатеричной системе счисления, чем и объясняется наличие префикса 0x и цифр abcdef в числе. Встроенная функция ord совершает обратную операцию, т.е. принимает на вход символ и возвращает его код.
Списки. list #
Под капотом списки реализованы в виде динамического массива (т.е. похожего на std::vector массива, размер которого может изменяться) указателей на его элементы. Ссылки могут вести на объекты произвольных типов, как и в случае обычных имён в программе.
Ниже создаётся список и схематично приводится его устройство.
Создать список можно несколькими способами:
Парой квадратных скобок, чтобы создать пустой список: [] ;
Перечислив элементы списка явно внутри пары квадратных скобок и используя запятую как разделитель элементов: [a] , [a, b, c] ;
Используя конструктор list, чтобы создать пустой список или список из элементов итерируемого объекта iterable : list() или list(iterable) ;
Используя списковые включения ( list comprehensions ): [x for x in iterable]
List comprehensions — очень мощный инструмент для работы создания списков и будет обсуждаться позже в разделе “ Основы списковых включений ”.
Создание списков с помощью умножения#
Выражение [expression] * n может быть использовано для того, чтобы создавать не пустой список, а список из n одинаковых элементов — результатов вычисления выражения expression внутри квадратных скобок. В качестве примера создадим нулевой n мерный вектор.
Но необходимо проявлять бдительность. Выражение expression вычисляется один раз, что может привести к неожиданному поведению, если expression изменяемого типа. Попробуем создать нулевую матрицу из 3 строк и 2 столбцов и поменять один элемент. Будем хранить матрицу в виде списка, элементами которого являются строки матрицы. Выражение [0] * 2 создаст одну нулевую строку матрицы. Может показаться, что выражение [[0] * 2] * 3 создаст нулевую матрицу из трех таких строк.
Теперь изменим один элемент матрицы и снова напечатаем матрицу.
Результат объясняется тем, что выражение [0] * 2 было вычислено единожды и создало один список [0, 0] , на который ссылаются все указатели списка m .
Методы списка.#
В таблице ниже перечислены основные методы списков.
Изменяет i -й элемент на x .
Срез с i по j заменяется элементами из t .
То же самое, что и l[i:j] = [] .
Элементы среза с i по j с шагом k заменяются на элементы из t , но len(t) должно быть равно len(l[i]) .
Удаляет элементы этого среза из списка.
Добавляет элемент в конец (аналог push_back для std::vector ).
Удаляет все элементы из списка. Эквивалентно del l[:] .
Создаёт копию списка. Эквивалентно l[:] .
l.extend(t) или l += t
Расширяет список, добавляя все элементы итерируемого объекта в конце списка.
То же, что и l = l * n , но не создаёт новый список, а расширяет существующий.
Вставляет элемент по заданной позиции. Первый аргумент — индекс элемента, перед которым нужно вставить элемент (второй аргумент). l.insert(0, x) вставляет x в самое начало списка, l.insert(len(l), x) эквивалентно l.append(x) .
l.pop() удаляет из списка последний элемент и возвращает его. l.pop(i) делает то же самое, но не с последним, а с i -м элементом.
Удаляет первый элемент списка, который равен x . Если такого элемента нет, то бросает ошибку.
Обращает список на месте.
Сортирует список на месте.
Все эти методы доступны также и для других изменяемых последовательностей ( mutable sequence types ), кроме метода l.sort() .
В python изменяющие объекты на месте методы обычно ничего не возвращают. Например, в итоге вычисления выражения l = l.sort() имя l будет указывать на None .
Кортежи. tuple #
Кортеж — неизменяемый ( immutable ) аналог списка.
Создаётся кортеж практически также, как и список, но вместо квадратных скобок “ [] ” используются круглые “ () ” или скобки вообще опускаются. Чтобы создать кортеж из одного элемента, необходимо поставить хвостовую запятую, иначе python интерпретирует это значение или как сам элемент, если скобки круглые скобки не поставлены, или в качестве повышения приоритета, если скобки поставлены. Итого, кортеж создаётся:
Парой круглых скобок, чтобы обозначить пустой кортеж: () ;
Используя хвостовую запятую с круглыми скобками или без, чтобы обозначить кортеж из одного элемента: a, или (a, ) ;
Разделяя элементы кортежа запятыми (опционально внутри круглых скобок): a, b, c или (a, b, c) ;
Используя конструктор типа: tuple() или tuple(iterable) ;
Неизменяемость кортежей#
Кортеж под капотом является константным массивом указателей на его элементы. В отличие от списка ни размер ни содержимое этого массива менять нельзя.
Попытка изменить содержимое кортежа вызвало ошибку. Более точно, попытка изменить ссылку, на которую ссылается кортеж вызвало ошибку. Если объект по этой ссылке изменяемый ( mutable ), то изменить этот объект можно.
Т.е. кортеж не даёт гарантии, что его элементы не изменятся, а гарантирует лишь то, что его элементы останутся теми же самыми объектами.
Кортежи vs списки#
Изучив свойства кортежей может возникнуть вопрос: в чем смысл использовать кортежи, если у них урезанный функционал (по сравнению со списками), а их отличительная особенность (неизменяемость) не гарантирует неизменность его элементов?
У кортежей есть два основных преимущества на фоне списков, оба из которых обусловлены их неизменяемостью:
Они работают быстрее;
От них можно вычислять hash . Будет обсуждаться позже.
И списки и кортежи позволяют хранить произвольное количество элементов произвольного типа, но в документации рекомендуют использовать списки для хранения однородных ( homogeneous ) объектов, а кортежи для хранения разнородных ( heterogeneous ) объектов.
Имеется ввиду, что в список обычно помещают элементы, которые в некотором контексте могут обрабатываться одним и тем же кодом, в предельном случае объекты одного типа. Например, если выстраивается конструкция, в которой элементы контейнера однообразно обрабатываются в цикле, то в качестве контейнера плохо подходит кортеж. Кортежи нередко используются в качестве записей. Элемента кортежа при таком подходе
Распаковка кортежей#
Очень часто кортежи используются для того, чтобы упаковать несколько объектов, передать их как единое целое и затем распаковать эти объекты обратно.
Это позволяет очень выразительно писать функции, как бы возвращающие несколько значений. В качестве примера напишем функцию, решающую приведенное квадратное уравнение
решением которого являются значения
Для простоты будем считать, что даже если дискриминант \(D\) нулевой и существует единственный корень кратности два, что существует два одинаковых корня.
Сравнительно наивная (численно не устойчивая) реализация этого алгоритма выглядит следующим образом.
Обратим внимание на то, как возвращаются значения из этой функции:
в случае двух действительных корней и
в случае двух комплексных корней.
В обоях случаях справа от ключевого слова return указаны два отделенных запятой значения, что приводит к созданию кортежа из них, который и возвращается вызывающему коду. Вызывающий код в свою очередь может сразу при вызове функции и распаковать элементы этого кортежа по двум именам.
В качестве примера решим уравнение этой функцией \(x^2 — 5x + 6 = (x-2)(x-3) = 0\) и сразу распакуем два корня по разным переменным.
Функция divmod — пример встроенной возвращающей 2 значения функции.
Распаковывать можно и списки, но это кроме того, что вынуждает писать дополнительные скобочки, ещё и работает медленнее.
Кортежи в качестве записей#
Кортежи нередко использую в качестве записей, т.е. таких структур данных с полями.
Например, если в рамках программы планеты описываются названиями, количество спутников и их массой относительно массы земли, то для их описания можно использовать кортежи из трех элементов.
Заметим, что список planets хранит однородные объекты — кортежи из трех элементов, описывающие планеты, а каждый из кортежей состоит из разнородных объектов, т.к. они представляют собой разные свойства планеты: имя (строка), количество планет (целое число) и масса (действительное число).
Элементы списка planets удобно обрабатывать одним и тем же кодом, так как все они имеют одинаковую структуру. Каждую запись о планете легко распаковать по переменным согласно полям этой записи.
Строки. str #
Строки — неизменяемые последовательности ( immutable sequence type ), предназначенные для работы с текстовыми данными в кодировке unicode. То, что python из коробки поддерживает unicode , значительно упрощает работу с текстом в общем случае, и написание web -ориентированных приложений в частности. Кроме того, что в unicode помещается английский язык и все спецсимволы, в него также помещаются русский, китайский, арабский и многие другие языки. Ещё в него помещаются emoji.
Так как при решении физических и математических задач работа с текстом встречается сравнительно редко, то тут будет приведен поверхностный обзор возможностей python , не затрагивающий кодировок и не покрывающий огромное множество методов обработки.
Можно считать, что строка — это константный массив, который содержит в себе unicode коды символов в этой строке. В python нет отдельного типа данных под один символ, т.е. символ представляет собой строку длинны 1.
Строки — последовательности, а значит можно обратившись по индексу получить символ (строку из одного символа), но последовательности неизменяемые, т.е. изменить любой символ нельзя. Чтобы изменить строку, нужно создать новую.
Создать строки можно огромным количеством способом. Рассмотрим самые основные из них.
Можно задавать строки в одинарных (апострофы) и двойных кавычках:
Это может пригодиться, если вы хотите поместить внутрь строки символы кавычек первого или второго типа. Например, апостроф можно поместить внутри двойных кавычек, а двойные кавычки внутри одинарных:
Можно задавать строки, допускающие перенос строки внутри, с помощью троекратных одинарных или двойных кавычек:
Очень часто используется для документации функций. Например, ниже приводится пример из исходного кода функции complex .
Также существует огромное количество функций и методов, которые позволяют создавать строки из уже существующих строк и объектов других видов.
Самый простой пример — конструктор класса str. Она преобразует объект в читабельную строку (если объект допускает это) и всегда неявно вызывается, если объект подаётся на вход функции print .
Строковые методы#
У строковых объектов есть огромное количество методов, которые обычно возвращают отредактированную тем или иным образом строку (всегда новую, т.к. строки неизменяемы). С полным списком методов можно ознакомиться по ссылке, а здесь будут упомянуты самые необходимые.
Метод strip удаляет переданные ему в качестве параметра символы по обоим краям строки. По умолчанию удаляет пробелы. Существуют аналогичные методы lstrip и rstrip, которые делают то же самое, но только с левого конца и с правого конца соответственно.
Метод replace принимает два обязательных параметра old и new и заменяет все вхождения old в строке на new . Передавая в качестве new пустую строку, можно использовать этот метод для удаления.
Методы ljust, rjust и center расширяют строку до нужной строки пробелами, но с разным выравниванием исходной строки внутри результирующей:
ljust выравнивает по левому краю, т.е. добивает строку пробелами до нужной длины с правого края;
rjust выравнивает по правому краю, т.е. добивает строку пробелами до нужной длины с правого края;
center выравнивает по центру, т.е. добивает строку пробелами до нужной длины с обоих краёв симметрично.
Метод split режет строку на части, используя переданный в качестве параметра разделитель (по умолчанию пробел). Возвращает список строк.
Метод join является по сути дела обратным к методу split. Он объединяет список переданных ему строк в качестве обязательного параметру в одну, используя в качестве разделителя строку, от которой этот метод был вызван.
Форматирование строк#
В python есть минимум четыре способа форматирования строк.
Первым, и пожалуй самым неправильным, является склеивание строки вручную.
Вторым подходом является форматирование в стиле C , который опирается на перегруженность оператора "%" для строк. Полные возможности такого подхода описаны по ссылке.
Третьим подходом является использование метода строковых объектов format, полные возможности которого описаны по ссылке.
Четвертым и самым новым подходом является использование f-строк ( f-strings ), которым и отдаёт предпочтение автор. f-строки позволяют использовать выражения python прямо внутри строки, за счет чего нередко предлагают самый наглядный способ форматирования строк.
Какой из них выбрать — по большей части дело вкуса.
Форматирование в стиле C было введено в python вместе с самой первой версией языка и гарантированно будет работать на более старых версиях python . Из-за схожести с форматированием в языке C , а также из-за того, что раньше этот способ был единственным, некоторым программистам легче воспринимать код, форматирующий строки в таком стиле в силу привычки.
Метод format более наглядный и допускает более гибкое форматирование, чем форматирование в стиле C . Они оба позволяют переиспользовать одну и ту же шаблонную строку для многократного форматирования, но методом format это делать естественнее. Это может быть очень эффективно, если в вашей программе необходимо регулярно подставлять какие-то значения в определенные позиции одного и того же шаблона. Никакими другими перечисленными здесь методами такого эффекта не достичь, но в ряде ситуация оправданным будет использовать для таких целей класс Template из модуля string.
f-строки введены сравнительно недавно и наверное представляют собой самый наглядный способ форматирования строк на сегодня, хотя и не все с этим согласны. Переиспользовать многократно одну и ту же f-строку не выйдет: она вычисляется на лету каждый раз. Ниже будут коротко описаны самые основы этого способа.
f-строки .#
Чтобы писать f -строки, необходимо ставить перед строкой символ f или F . Далее в самом простом варианте внутри одинарных фигурных скобок “ <> ” можно указывать python выражение, результат вычисления которого появится вместо фигурных скобок в результирующей строке.
В чем отличие списка от кортежа python
Еще одна важная функция кортежей: их можно использовать как ключи словаря. Ведь ключи словаря должны быть неизменяемыми. Словари мы проходили как раз на предыдущем уроке. Сегодня узнаем, как еще можно быстро создать словарь.
Давайте создадим словарь с примерным автопарком Владимира Путина: это его личные автомобили из декларации и еще те, на которых он ездит.
Так как мы удалили предыдущий словарь, можем создать новый с таким же названием. Создаем список с автомобилями. И «сшиваем» с помощью функции-молнии — zip() — кортеж и список в словарь (можно было так соединить и два списка):
Словарь готов! Запомните эту функцию-молнию, она очень полезная.
Множества (Sets)
Множества — это неупорядоченный список, то есть элементы внутри него располагаются в случайном порядке. Как списки и словари, множество относится к изменяемым типам данных. Но при этом невозможен поиск по индексу, так как элементы в случайном порядке. Зато множества дают высокую скорость поиска по ним. Например, это удобно, когда порядок вам не важен, а нужно просто быстро искать нужные элементы.
Создать пустое множество можно с помощью функции set(). А если с элементами, то с помощью их перечисления в фигурных скобках, как у словаря:
Все элементы множества всегда уникальные. Это полезное свойство множеств пригождается, когда вам нужно почистить ваш список и убрать дубли:
Получаем множество с уникальными элементами. Вернем его обратно в список с помощью функции list():
С множествами можно делать множество операций (избитая фраза, но все равно самая точная).
От самых простых таких, как добавление элемента и удаления:
Проверки наличия элемента в множестве:
До более сложных. Например, можно посмотреть пересечения множеств: то есть какие элементы входят в оба множества с помощью функции intersection():
Можем объединить два множества и получить третье, в котором останутся только уникальные элементы, использовав union():
А с помощью функции difference() узнаем разницy множеств: set1.difference(set2) даст нам ответ, какие элементы первого множества отсутствуют во втором множестве.
Если же хотим симметричную разницу между множествами: то есть все элементы, которые у них различны, а не общие. Применяем функцию symmetric_difference():
Все операции, доступные для множеств, можно посмотреть здесь.
Закончим на множестве, которое не изменяется, как и кортеж. Это frozenset. Преобразовываем свое множество во frozenset. И все: из него уже нельзя ничего удалить.