2. Как лучше выбирать элементы из списка?
Если вы хотите продуктивно работать со списками, то должны уметь получать доступ к данным, хранящимся в них.
Обычно мы получаем доступ к элементам списков, чтобы изменять определенные значения, обновлять или удалять их, или выполнять какие-либо другие операции с ними. Мы получаем доступ к элементам списков и, собственно, ко всем другим типам последовательностей, при помощи оператора индекса . Внутри него мы помещаем целое число.
# Выбираем первый элемент списка oneZooAnimal = biggerZoo # Выводим на экран переменную `oneZooAnimal` print(oneZooAnimal)
Запустите данный код и убедитесь, что вы получите первый элемент списка, сохраненного в переменную . Это может быть поначалу несколько непривычно, но нумерация начинается с числа , а не .
Как получить последний элемент списка?
Ответ на этот вопрос является дополнением к объяснению в предыдущем разделе.
Попробуйте ввести отрицательное значение, например, или , в оператор индекса, чтобы получить последние элементы нашего списка !
# Вставляем -1 monkeys = biggerZoo print(monkeys) # А теперь -2 zebra = biggerZoo print(zebra)
Не правда ли, не слишком сложно?
Что означает ошибка «Index Out Of Range»?
Эта ошибка одна из тех, которые вы будете видеть достаточно часто, особенно если вы новичок в программировании.
Лучший способ понять эту ошибку — попробовать ее получить самостоятельно.
Возьмите ваш список и передайте в оператор индекса либо очень маленькое отрицательное число, либо очень большое положительное число.
Как видите, вы можете получить ошибку «Индекс вне диапазона» в случаях, когда вы передаете в оператор индекса целочисленное значение, не попадающее в диапазон значений индекса списка. Это означает, что вы присваиваете значение или ссылаетесь на (пока) несуществующий индекс.
Срезы в списках
Если вы новичок в программировании и в Python, этот вопрос может показаться одним из наиболее запутанных.
Обычно нотация срезов используется, когда мы хотим выбрать более одного элемента списка одновременно. Как и при выборе одного элемента из списка, мы используем двойные скобки. Отличие же состоит в том, что теперь мы еще используем внутри скобок двоеточие. Это выглядит следующим образом:
# Используем нотацию срезов someZooAnimals = biggerZoo # Выводим на экран то, что мы выбрали print(someZooAnimals) # Теперь поменяем местами 2 и двоеточие otherZooAnimals = biggerZoo # Выводим на экран полученный результат print(otherZooAnimals)
Вы можете видеть, что в первом случае мы выводим на экран список начиная с его элемента , который имеет индекс . Иными словами, мы начинаем с индекса и идем до конца списка, так как другой индекс не указан.
Что же происходит во втором случае, когда мы поменяли местами индекс и двоеточие? Вы можете видеть, что мы получаем список из двух элементов, и . В данном случае мы стартуем с индекса и доходим до индекса (не включая его). Как вы можете видеть, результат не будет включать элемент .
В общем, подводя итоги:
# элементы берутся от start до end (но элемент под номером end не входит в диапазон!) a # элементы берутся начиная со start и до конца a # элементы берутся с начала до end (но элемент под номером end не входит в диапазон!) a
Совет: передавая в оператор индекса только двоеточие, мы создаем копию списка.
В дополнение к простой нотации срезов, мы еще можем задать значение шага, с которым будут выбираться значения. В обобщенном виде нотация будет иметь следующий вид:
# Начиная со start, не доходя до end, с шагом step a
Так что же по сути дает значение шага?
Ну, это позволяет вам буквально шагать по списку и выбирать только те элементы, которые включает в себя значение вашего шага. Вот пример:
Обратите внимание, что если вы не указали какое-либо значение шага, оно будет просто установлено в значение. При проходе по списку ни один элемент пропущен не будет
Также всегда помните, что ваш результат не включает индекс конечного значения, который вы указали в записи среза!
Как случайным образом выбрать элемент из списка?
Для этого мы используем пакет .
# Импортируем функцию `choice` из библиотеки `random` from random import choice # Создадим список из первых четырех букв алфавита list = # Выведем на экран случайный элемент списка print(choice(list))
Если мы хотим выбрать случайный элемент из списка по индексу, то можем использовать метод из той же библиотеки .
# Импортируем функцию `randrange` из библиотеки `random` from random import randrange # Создадим список из первых четырех букв алфавита randomLetters = # Выбираем случайный индекс нашего списка randomIndex = randrange(0,len(randomLetters)) # Выводим случайный элемент на экран print(randomLetters)
Совет: обратите внимание на библиотеку , она может вам пригодиться во многих случаях при программировании на Python
Преобразование типов данных
Одна и та же переменная в процессе выполнения кода может ссылаться на объекты с различными типами данных. Например, после выполнения двух инструкций:
Переменная х_1 сначала ссылается на тип str, затем — на тип float. Для определения последнего типа данных, на который ссылается переменная, служит функция type (имя переменной).
Итак, тип данных — это характеристика объекта, а не переменной. Переменная содержит только ссылки на объект.
Для каждого конкретного типа данных существует строго определенный набор операций, которые могут выполняться над ним. Например, для данных типа int и float можно выполнять арифметические операции. Попытка выполнить, например, операцию сложения целого числа и строки, приведет к выводу сообщения о синтаксической ошибке:
Для преобразования одного типа данных на другой в языке Python применяются специальные функции. Рассмотрим основные функции преобразования одного типа данных на другой.
- bool () — преобразование объекта на логический тип. Функция bool возвращает значение False в случае, если объект равен нулю или пустой, иначе — значение True.
- int (]) — преобразование объекта в целое число. Система счисления, в которой подается объект, может быть десятичной, восьмеричной, шестнадцатеричной. По умолчанию — десятичная система.
- float (целое число или строка) — преобразование целого числа или строки в число вещественного типа.
- str (объект) — преобразование объекта в строку.
- list (последовательность) — преобразование элементов последовательности в список.
Генераторы списков
Генератором списка называется способ построения списка с применением выражения к каждому элементу, входящему в последовательность. Есть схожесть генератора списка и цикла . На этом примере мы рассмотрим простейший генератор списков:
Таким образом мы получили отдельно взятые утроенные буквы слова, введённого в кавычки. Есть множество вариантов применения генератора списков.
Пример генератора списка:
Пример посложнее:
Это усложнённая конструкция генератора списков, в которой мы сделали все возможные наборы сочетаний букв из введённых слов. Буквы-исключения видны по циклу, где стоит знак != для одной переменной и другой.
Сборщик мусора
Всякий раз, когда вы создаете любые объекты, под них выделяется память. Если неиспользуемые объекты не чистить, память закончится и произойдет сбой программы.
В C и C++ проблему обычно приходится решать вручную. Другие языки программирования, вроде Python и Java, делают это автоматически. Процесс называется автоматической сборкой мусора – существует несколько методов ее выполнения.
В CPython счетчик ссылок на объект увеличивается всякий раз, когда на него ссылаются и уменьшается при разыменовании. Когда счетчик равен нулю, CPython автоматически вызывает функцию освобождения памяти для объекта, но есть один нюанс. Когда количество ссылок большого дерева объектов становится равным нулю, все связанные объекты освобождаются. Возможна длинная пауза, во время которой программа простаивает. Есть также вариант, при котором подсчет ссылок не сработает. Рассмотрим следующий код:
class A(object):
pass
a = A()
a.some_property = a
del a
В приведенном коде определяется новый класс, создается экземпляр, его свойству присваивается ссылка на себя, а экземпляр удаляется.
В этот момент экземпляр уже недоступен, однако подсчет ссылок не удаляет его из памяти, поскольку есть ссылка на себя, и счетчик не равен нулю. Такая ситуация называется циклом ссылок, и она не решается с помощью их подсчета.
В этом случае CPython использует другой инструмент – циклический сборщик мусора. Он пробегает по всем объектам в памяти, идентифицирует доступные и освобождает недостижимые, поскольку они больше не активны. Это исправляет проблему с циклом ссылок, однако могут появиться заметные паузы, когда в памяти находится большое количество объектов.
PyPy использует только второй метод. Он периодически ходит по «живым» объектам, начиная с корня. Это дает ему преимущество перед CPython, делая меньше затраченное на управление памятью время. Вместо того, чтобы делать все за один подход, PyPy разбивает работу на части. Такой подход добавляет всего несколько миллисекунд после каждой коллекции, а не сотни, как в CPython.
Сборка мусора является сложной задачей и содержит гораздо больше деталей, которые выходят за рамки данного материала. Более подробную информацию о ней можно найти в документации.
Добавление элементов в список
Python предоставляет функцию append(), которая используется для добавления элемента в список. Однако функция append() может добавлять значение только в конец списка.
Рассмотрим следующий пример, в котором мы берем элементы списка у пользователя и выводим список на консоль.
#Declaring the empty list
l =[]
#Number of elements will be entered by the user
n = int(input("Enter the number of elements in the list:"))
# for loop to take the input
for i in range(0,n):
# The input is taken from the user and added to the list as the item
l.append(input("Enter the item:"))
print("printing the list items..")
# traversal loop to print the list items
for i in l:
print(i, end = " ")
Выход:
Enter the number of elements in the list:5 Enter the item:25 Enter the item:46 Enter the item:12 Enter the item:75 Enter the item:42 printing the list items 25 46 12 75 42
Что делает python медленным?
Python использовался для научных вычислений в течение длительного периода времени. Хотя Python-отличный язык для прототипирования, python barebone не имеет передовых технологий для выполнения таких огромных вычислений. Что делает python по своей сути медленным, так это, по иронии судьбы, функции, которые делают Python таким популярным как язык. Давайте рассмотрим их один за другим:
- Динамически типизированный : Python-это динамически типизированный язык, т. е. пользователям не нужно указывать тип данных, связанный с переменной. Хотя это значительно упрощает работу на верхней поверхности, внутренние механизмы усложняются многими складками, поскольку интерпретатору необходимо проверять тип данных и связанное с ними преобразование каждый раз, когда выполняется операция. Эти увеличенные и сложные инструкции в основном отвечают за скорость python.
- Накладные расходы на память : Из-за гибкой природы Python для каждого небольшого объекта, такого как int в списке, необходимо выделять отдельную память (в отличие от C, который занимает непрерывный кусок памяти для массива). Это означает, что объекты в списке не помещаются рядом друг с другом в памяти, что влияет на затраты времени для каждой операции выборки.
- Некомпилированные : Компиляторы, такие как LLVM, GCC могут заглянуть в программу и выполнить некоторые высокоуровневые оптимизации, что экономит как память, так и скорость. Интерпретатор Python, с другой стороны, не знает о следующей строке выполнения, поэтому он не применяет никаких оптимизаций, экономящих время.
- GILLock : Глобальная блокировка интерпретатора(GIL) не позволяет многопоточность . Это гарантирует, что только один поток выполняет байтовый код Python. Это упрощает реализацию CPython, делая объектную модель неявно безопасной от параллельного доступа.
В этой статье мы увидим, как numba преодолевает эти трудности и как ее можно использовать для ускорения нашего кода до уровня C/C++ и FORTRAN.
Математические операторы Python 3
Оператор – это символ, которая обозначает операцию. Например, в математике знак плюса или + – это оператор сложения.
Мы рассмотрим схожие операторы, которые перешли в Python из математики. Но другие операторы специфичны именно для программирования.
Ниже представлена таблица с кратким обзором математических операторов, доступных в Python.
| Операция | Возвращаемое значение |
| x + y | Сумма x и y. |
| x — y | Разность x и y. |
| -x | Изменение знака x. |
| +x | Тождественность x. |
| x * y | Произведение x и y. |
| x / y | Частное от деления x на y. |
| x // y | Частное от целочисленного деления x на y. |
| x % y | Остаток от деления x / y. |
| x ** y | x в степени y. |
Доступ к элементам списка
На элемент списка можно ссылаться по его индексу. Индексы являются целыми числами и начинаются от до где — количество элементов:
В Python индексы заключаются в квадратные скобки:
Например, для доступа ко второму элементу списка вы должны использовать:
Если вы ссылаетесь на несуществующий индекс, исключение :
Для доступа к элементам во вложенном списке используйте несколько индексов:
Python также позволяет вам получать доступ к элементам списка, используя отрицательные индексы. Последний элемент обозначается как , второй последний элемент — как и так далее:
Например, чтобы получить доступ ко второму элементу с конца, вы должны использовать:
5. Как в Python работают представления списков?
Представление списков это, в сущности, просто элегантный способ конструирования списков в Python. Особенно этот способ понравится тем, кто любит математику. Судите сами:
Результат:
Итак, что же произошло? Мы взяли все целые числа от 0 до 10 (исключая 10) и каждое число возвели в квадрат.
Согласитесь, не очень сложно. Теперь давайте поднимем планку.
Давайте получим такой же список, но будем брать только четные числа, то есть те, которые нацело делятся на . Это также очень просто сделать при помощи представления списков.
Результат:
Мы просто добавили при помощи инструкции условие в наше первоначальное выражение. Если это условие выполняется, то число возводится в квадрат и добавляется в результирующий список, а если нет, то пропускается. В нашем случае это условие делимости на без остатка.
Итак, в более общем смысле, вы также можете использовать представление списков для преобразования ваших списков в другие списки, что звучит немного сложнее, не так ли?
Рассмотрим следующий пример:
Результат:
В данном примере у нас уже есть список , который мы преобразуем при помощи представления списков. Вы опять можете видеть, что выражение обеспечивает выполнение некоторых операций для всех элементов списка .
Теперь обратите внимание на выражение. Для простоты, вы должны просто знать, что лямбда-функции — это анонимные функции, которые создаются во время выполнения
Учитывая это, вы можете просто сосредоточиться на выражении .
Отсюда видно, что эта функция просто принимает один элемент и умножает его на самого себя, то есть возводит в квадрат. Это анонимная функция, поэтому вам нужно передать ей свой элемент списка, чтобы убедиться, что лямбда-функция принимает его в качестве входных данных. Поэтому мы видим такое выражение: .
Для лучшего понимания вторую строку кода можно переписать следующим образом:
Здесь мы просто определяем лямбда-функцию заранее.
Стоит отметить, что помимо представления списков существуют также представления словарей и представления множеств.
Оператор модуля
Оператор модуля Python – это встроенный оператор, который возвращает оставшиеся числа путем деления первого числа на второе. Он также известен как Python modulo. В Python символ модуля представлен в виде символа процента(%). И называется он оператором остатка.
Ниже приведен синтаксис для получения остатка путем деления первого числа на второе.
Rem = X % Y
Здесь X и Y – два целых числа, а модуль(%) используется между ними, чтобы получить остаток, где первое число(X) делится на второе число(Y).
Например, у нас есть два числа, 24 и 5. И мы можем получить остаток, используя модуль или оператор по модулю между числами 24% 5. Здесь 24 делится на 5, что возвращает 4 в качестве остатка и 4 в качестве частного. Когда первое число полностью делится на другое число, не оставляя остатка, результатом будет 0.
Операторы присваивания Python
Оператор «=» присваивает значение, расположенное справа, переменной слева. Например, v = 23 присваивает значение числа 23 переменной v.
В программировании часто используют составные операторы присваивания. Они соединяют арифметический оператор с оператором «=». Поэтому для сложения мы используем оператор «+» с оператором «=», чтобы получить составной оператор «+=». Пример:
w = 5 w += 1 print(w)
Вывод
6
Сначала мы задаём переменной значение . Затем используем составной оператор присваивания , чтобы прибавить число справа, к переменной, расположенной слева, и присвоить результат переменной .
Составные операторы присваивания часто используются в циклах for:
for x in range (0, 7): x *= 2 print(x)
Вывод
0 2 4 6 8 10 12
При помощи for можно автоматизировать процесс использования оператора «. Он умножает переменную на число , а затем присваивает полученный результат переменной для следующей итерации цикла.
В Python предусмотрен составной оператор присваивания для каждой арифметической операции:
y += 1 # добавить число и присвоить результат y -= 1 # отнять число и присвоить результат y *= 2 # умножить на число и присвоить результат y /= 3 # разделить на число и присвоить результат y // = 5 # разделить без остатка на число и присвоить результат y **= 2 # возвести в степень и присвоить результат y %= 3 # вернуть остаток от деления и присвоить результат
Составные операторы присваивания полезны в тех случаях, когда переменная должна увеличиваться или уменьшаться с помощью инкремента. А также когда необходимо автоматизировать некоторый процесс в создаваемой программе.
Получение остатка двух целых чисел с помощью цикла while
Давайте напишем программу для получения остатка от двух чисел, используя цикл while и оператор модуля(%) в Python.
Get_rem.py
while True: # if the while condition is true if block is executed
a = input('Do you want to continue or not(Y / N)? ')
if a.upper() != 'Y': # If the user pass 'Y', the following statement is executed.
break
a = int(input(' First number is: ')) # first number
b = int(input(' Second number is: ')) # second number
print(a, ' % ', b, ' = ', a % b) # perform a % b
print(b, ' % ', a, ' = ', b % a) # perform b % a
Выход:
Do you want to continue or not(Y / N)? Y First number is: 37 Second number is: 5 37 % 5 = 2 5 % 37 = 5 Do you want to continue or not(Y / N)? Y First number is: 37 Second number is: 5 24 % 5 = 4 5 % 24 = 5 Do you want to continue or not(Y / N)? Y First number is: 37 Second number is: 5 28 % 5 = 3 5 % 28 = 5
Почему нет ++ оператора в Python?
Если вы хотите понять это более подробно, вам нужно иметь какой-то опыт на дизайне языка программирования.
Опция не включать Оператор в Python – это Решение дизайна Отказ Люди, которые несут ответственность за создание функций на языке Python, считали, что нет необходимости вводить оператор приращения в стиле CPP.
Когда интерпретатор Python разбирается в Символ с нашего ввода, он интерпретируется следующим образом:
Так как двоичный + Оператор является оператором дополнения, A ++ будет рассматриваться как А , + и + Отказ Но Python ожидает номер после первого + оператор. Поэтому он даст синтаксическую ошибку на A ++ , так как второй + не число.
Точно так же предварительное увеличение , будет относиться так:
- Унарный Оператор в Python относится к оператору идентичности. Это просто возвращает целое число после этого. Вот почему это Операция идентичности на целое число
- Например, значение просто и за это Отказ Это унарный оператор, который работает на реальных числах
- будет проанализирован как + и , но второй снова лечится как , который просто
- Поэтому просто оценивает Отказ
Так что, хотя мы хотели увеличить ценность К одному, мы не можем достичь этого, используя Символы, поскольку этот вид оператора не существует.
Поэтому мы должны использовать Оператор, чтобы сделать этот вид приращения.
a += 1 a -= 1
То же самое логику верно для операции по снижению.
Метод 4: Python One-Liner Solution
Я люблю Python One-listers (Вот почему я написал книга о них ). Можем ли мы решить множественную задачу замены в одной строке? Да, конечно!
lst = repl = indices = # Method 4: Python One-Liner lst = if i in indices else lst for i in range(len(lst))] print(lst) #
- Мы используем Понимание списка Чтобы повторить все индексы от 0 до Длина списка Отказ
- Мы используем Тернарный оператор Чтобы проверить, является ли этот индекс, который должен быть заменен.
- Если индекс не должен быть заменен, верните исходный элемент, иначе верните замену элемента.
- Мы используем Способ выяснить индекс элемента для замены элемента исходного списка.
Не очень красиво, не так ли? Если вы все еще хотите узнать, как работают одноклассники, ознакомьтесь с моей книгой:
Сумма в питоне и разность в питоне
В Python операторы суммы и разности выполняют те же операции, что и в математике. Поэтому вы можете использовать этот язык программирования как калькулятор.
Рассмотрим некоторые примеры. Начнём с целых чисел:
print(1 + 5)
Вывод
6
Вместо передачи целых чисел напрямую в функцию мы можем инициализировать переменные для этих значений:
a = 88 b = 103 print(a + b)
Вывод
191
Целые числа могут быть как положительными, так и отрицательными. Поэтому можно добавлять отрицательные числа к положительным:
c = -36 d = 25 print(c + d)
Вывод
-11
Прибавление работает аналогично и с числами с плавающей запятой:
e = 5.5 f = 2.5 print(e + f)
Вывод
8.0
Синтаксис разности тот же, что и для прибавления, за исключением того, что вместо оператора сложения () необходимо использовать оператор вычитания ():
g = 75.67 h = 32 print(g - h)
Вывод
43.67
В этом примере мы вычитаем целое число из числа с плавающей точкой. Python возвратит число с плавающей точкой, если хотя бы одно из чисел выражения является числом с плавающей точкой.
Числа: целые, вещественные, комплексные
Числа в Python 3: целые, вещественные, комплексные. Работа с числами и операции над ними.
Целые числа (int)
Числа в Python 3 ничем не отличаются от обычных чисел. Они поддерживают набор самых обычных математических операций:
| x + y | Сложение |
| x — y | Вычитание |
| x * y | Умножение |
| x / y | Деление |
| x // y | Получение целой части от деления |
| x % y | Остаток от деления |
| -x | Смена знака числа |
| abs(x) | Модуль числа |
| divmod(x, y) | Пара (x // y, x % y) |
| x ** y | Возведение в степень |
| pow(x, y) | x y по модулю (если модуль задан) |
Также нужно отметить, что целые числа в python 3, в отличие от многих других языков, поддерживают длинную арифметику (однако, это требует больше памяти).
Битовые операции
Над целыми числами также можно производить битовые операции
| x | y | Побитовое или |
| x ^ y | Побитовое исключающее или |
| x & y | Побитовое и |
| x > y | Битовый сдвиг вправо |
x
Инверсия битов
Дополнительные методы
int.bit_length() — количество бит, необходимых для представления числа в двоичном виде, без учёта знака и лидирующих нулей.
int.to_bytes(length, byteorder, *, signed=False) — возвращает строку байтов, представляющих это число.
classmethod int.from_bytes(bytes, byteorder, *, signed=False) — возвращает число из данной строки байтов.
Системы счисления
Те, у кого в школе была информатика, знают, что числа могут быть представлены не только в десятичной системе счисления. К примеру, в компьютере используется двоичный код, и, к примеру, число 19 в двоичной системе счисления будет выглядеть как 10011. Также иногда нужно переводить числа из одной системы счисления в другую. Python для этого предоставляет несколько функций:
- int(, ) — преобразование к целому числу в десятичной системе счисления. По умолчанию система счисления десятичная, но можно задать любое основание от 2 до 36 включительно.
- bin(x) — преобразование целого числа в двоичную строку.
- hex(х) — преобразование целого числа в шестнадцатеричную строку.
- oct(х) — преобразование целого числа в восьмеричную строку.
Вещественные числа (float)
Вещественные числа поддерживают те же операции, что и целые. Однако (из-за представления чисел в компьютере) вещественные числа неточны, и это может привести к ошибкам:
Для высокой точности используют другие объекты (например Decimal и Fraction)).
Также вещественные числа не поддерживают длинную арифметику:
Простенькие примеры работы с числами:
Дополнительные методы
float.as_integer_ratio() — пара целых чисел, чьё отношение равно этому числу.
float.is_integer() — является ли значение целым числом.
float.hex() — переводит float в hex (шестнадцатеричную систему счисления).
classmethod float.fromhex(s) — float из шестнадцатеричной строки.
Помимо стандартных выражений для работы с числами (а в Python их не так уж и много), в составе Python есть несколько полезных модулей.
Модуль math предоставляет более сложные математические функции.
Модуль random реализует генератор случайных чисел и функции случайного выбора.
Также для работы с комплексными числами используется также модуль cmath.
Индексация списков в Python
Вы заметили, что элемент oatmeal cookies идет в списке третьим, но чтобы его заменить, мы использовали индекс ? Дело в том, что индексация начинается с нуля. В Python индекс — это по сути отступ от начала списка.
Первый элемент имеет индекс (нет никакого отступа, элемент в самом начале списка). Второй элемент имеет индекс . И так далее. В общем, если в списке элементов, последний из них будет иметь индекс .
Попытавшись обратиться к элементу по несуществующему индексу, мы получим ошибку — IndexError.
В нашем примере у нас есть список покупок из 6 элементов (диапазон индексов 0-5). Как показано в коде ниже, если мы попытаемся обратиться к элементу под индексом 6, мы получим ошибку, потому что элемента с таким индексом просто нет.
print(shopping_list) # Вывод >> -------------------------------------------------------------------------- IndexError Traceback (most recent call last) <ipython-input-21-a9f3b9517136> in <module>() ----> 1 shopping_list IndexError: list index out of range
С другой стороны, мы можем использовать отрицательные индексы. Последний элемент списка имеет индекс , предпоследний — и так далее.
print(shopping_list) # Вывод >> paint
Так же, как список покупок может содержать любые товары (фрукты, овощи, сладости и т. п.), список в Python может содержать элементы любого типа.
Таким образом, список вполне может содержать в себе другие списки в качестве элементов. Это называется вложенностью, а подобные списки — вложенными.
Вот пример вложенного списка покупок, содержащего два списка поменьше:
