Стек и очередь

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

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

В программировании очередь работает аналогично. Очередь в программировании — это коллекция элементов, которые обрабатываются по принципу «первый зашел — первый вышел» (FIFO).

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

Стек работает по-другому. Стек – это тоже коллекция элементов, но работает он по принципу «последним зашел — первым вышел» (LIFO)

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

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

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

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

Что выведет этот фрагмент кода? Ниже квиз

try, except, finally и оператор return в Python: как работает finally при наличии return

Python предоставляет механизм обработки исключений с помощью операторов try, except и finally. Когда внутри блока try возникает исключение, оно может быть перехвачено и обработано в блоке except. Кроме того, блок finally позволяет выполнять нужные вам действия независимо от того, произошло исключение или нет.

Но если внутри блока finally использовать оператор return, как в примере выше, возникает особенность.

Вот ещё раз пример кода из опроса:

def try_with_returns():
try:
return 'try clause'
except:
return 'exception clause'
finally:
return 'final clause'

print(try_with_returns())

Можно ожидать, что будет выведено 'try clause' и 'final clause', но фактически выводится только 'final clause'. Почему?

Документация Python объясняет такое поведение. При наличии блока finally, код внутри него должен быть выполнен в любом случае. Поэтому если блок finally содержит return, то возвращаемое значение будет именно то, которое указано внутри finally, а не внутри try, иначе до finally поток исполнения просто не дойдет.

Вот еще один пример для лучшего понимания:

def bool_return():
try:
return True
finally:
return False

print(bool_return())

В этом случае можно ожидать, что будет выведено True, но выводится False. Это снова происходит из-за оператора return в блоке finally, который прерывает выполнение блока try и возвращает значение False.

Итак, при использовании оператора return внутри try/except/finally следует иметь в виду, что возвращаемое значение будет определено блоком finally. И если finally содержит оператор return, то его значение будет возвращено вместо значения из блоков выше.

Дока: https://docs.python.org/3/tutorial/errors.html?highlight=try%20finally#defining-clean-up-actions

Вопрос от студента: как использовать в map функцию с параметром?

Все, кто сталкивался с map(), знают, как использовать её, если параметры не нужны. Например, с map() можно привести числа в списке к абсолютным значениям

numbers = [-1, 2, -3, 4, -5]
absolute_values = list(map(abs, numbers))
print(absolute_values)
# [1, 2, 3, 4, 5]

Или преобразовать все строки в верхнему регистру

names = ["alice", "bob", "charlie", "david"]
print(list(map(str.upper, names)))
# ["ALICE", "BOB", "CHARLIE", "DAVID"]

А что делать в случае, если map нуждается в параметре? Например, есть список

numbers = [0, 0.333, 0.667, 1]

и требуется округлить все числа до 1 знака после запятой, то есть, получить

[0, 0.3, 0.7, 1]

В какое место надо написать параметр при использовании map()?

Отвечаем. Просто так это сделать не получится! Для этого понадобятся lambda-функции.

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

a = [0, 0.333, 0.667, 1]
result = list(map(lambda x: round(x, 1), a))

Здесь lambda x: round(x, 1) создает анонимную функцию, которая принимает аргумент x и вызывает функцию round() с параметром 1 для округления числа x до 1 знака после запятой. Затем map() применяет эту анонимную функцию ко всем элементам списка.

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

[0, 0.3, 0.7, 1]

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

Генератор кортежей

Генераторы списков — это конструкции вида

[x for x in range(5)]
# [0, 1, 2, 3, 4]

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

{n: n**2 for n in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

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

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

*(x for x in range(5)),
# (0, 1, 2, 3, 4)

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

Вау, в Python будет можно по желанию отключить GIL. В мейн буквально пару часов назад вмержили эту настройку

https://github.com/python/cpython/pull/116338

GIL (Global Interpreter Lock) — это механизм в CPython, который предотвращает одновременное выполнение нескольких потоков.

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

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

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

Вы, наверное, знаете, что из-за того, что числа в памяти представлены в двоичной форме, в Python есть ошибка вида

print(0.1 + 0.2)
# 0.30000000000000004

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

А вот кто скажет, почему возникает разница в примерах ниже?

1️⃣

from decimal import Decimal

a = Decimal(0.1)
b = Decimal(0.2)
print(a + b)
# 0.3000000000000000166533453694

2️⃣

a = Decimal('0.1')
b = Decimal('0.2')
print(a + b)
# 0.3

Жду ваши ответы в комментариях!