Python для рабочего кода: comprehensions, распаковка и современные операторы

Comprehensions: списки, словари, множества и генераторы

Вы уже пишете рабочий Python-код (условия, циклы, функции, списки, словари). Дальше часто встречается стиль, который делает код короче, быстрее и выразительнее: comprehensions и generator expressions.

Официальная документация:

List comprehensions в учебнике Python

List/Set/Dict displays (формальный синтаксис comprehensions)

Generator (термин из глоссария)

Что такое comprehension и зачем он нужен

Comprehension — это компактная запись создания коллекции (списка, множества, словаря) на основе другой коллекции или любого итерируемого объекта.

Идея:

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

откуда взять исходные элементы (через for)

и, при необходимости, как отфильтровать элементы (через if)

Comprehension почти всегда можно переписать в обычный for-цикл. В рабочем коде это полезно потому что:

проще читать типовые преобразования данных

меньше “шумного” кода (инициализация списка, append, и т.д.)

часто быстрее, чем эквивалентный Python-цикл

Базовый list comprehension

Общий шаблон:

Где:

итерируемое — то, по чему можно пройти в цикле for (например, список, строка, range, файл)

переменная — текущий элемент

выражение — что положить в результат

if условие — фильтр: пропускаем только элементы, для которых условие истинно

Пример: получить квадраты чётных чисел.

Обычный цикл:

То же самое comprehension:

Важно: if в конце — это фильтр

Этот if убирает элементы, а не подставляет альтернативное значение.

Условное выражение внутри comprehension

Если вам нужно оставить все элементы, но одни преобразовать так, а другие иначе — используйте условное выражение (тернарное): A if cond else B.

Сравните:

[... for x in xs if cond] — фильтруем, уменьшаем количество элементов

[(... if cond else ...) for x in xs] — преобразуем, количество элементов сохраняется

Два for (вложенные циклы)

Comprehension поддерживает несколько for — это соответствует вложенным циклам слева направо.

Эквивалент обычному коду:

Фильтр можно добавлять на любом уровне:

Рекомендация по читаемости

Comprehension хорош, когда:

помещается в 1 строку или читаемо переносится

выражение простое

нет сложной ветвящейся логики

Если вы начинаете “программировать внутри comprehension” — чаще лучше вернуться к обычному for.

Dict comprehension (словари)

Шаблон:

Пример: привести строки к целым числам и построить словарь имя -> длина.

Пример: отфильтровать словарь.

Здесь используется prices.items(), который отдаёт пары (ключ, значение).

Частый кейс: инвертировать словарь

Ограничение: если значения повторяются, при инвертировании останется только последнее.

Set comprehension (множества)

Множество — коллекция уникальных элементов.

Шаблон:

Пример: получить уникальные домены из email-адресов.

Здесь set comprehension удобен тем, что дедупликация происходит автоматически.

Generator expression (генераторное выражение)

List/set/dict comprehension сразу создают результат целиком в памяти.

Generator expression создаёт генератор — объект, который выдаёт элементы по одному, “по требованию”. Это называется ленивые вычисления.

Синтаксис похож, но используются круглые скобки:

Пример: посчитать сумму квадратов без создания промежуточного списка.

Если бы вы написали sum([x * x for x in range(1_000_000)]), то сначала создали бы огромный список, а потом посчитали сумму.

!Схема разницы: “сразу в память” против “по одному элементу”.

Где генераторы особенно полезны

большие объёмы данных

чтение файлов построчно

конвейерная обработка (несколько стадий фильтра/преобразования)

Пример: взять числа из файла, отфильтровать и посчитать среднее.

Здесь nums и positives не хранят все числа в памяти.

Важное свойство генератора: он одноразовый

Генератор “расходуется” при итерации.

Если вам нужно многократно проходить по данным — используйте список или создавайте генератор заново.

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

Область видимости переменной в comprehension

В Python 3 переменная цикла внутри list/set/dict comprehension не “протекает” наружу.

Это полезно: comprehension не портит переменные снаружи.

Скобки вокруг generator expression

Если generator expression — единственный аргумент функции, внешние скобки можно опустить:

Но если аргументов несколько — скобки нужны:

Побочные эффекты и comprehension

Comprehension — инструмент для создания коллекций. Не стоит использовать его для “выполнить действие много раз”. Например, так делать не надо:

Правильно — обычный цикл:

Как понимать comprehensions в чужом коде

Практический алгоритм чтения:

Найдите, какой тип результата создаётся:

- [...] — список - {...} с key: value — словарь - {...} без : — множество - (...) — генератор

Прочитайте справа налево “откуда берём данные”:

- for x in ...

Затем фильтры if ...

И только потом вернитесь к началу и разберите “что кладём в результат” (выражение слева)

Итоги и связь с курсом

Вы научились:

писать и читать list/dict/set comprehensions

отличать фильтр if от условного выражения A if cond else B

использовать generator expressions для экономии памяти

понимать ограничения (читаемость, одноразовость генератора)

В следующих статьях курса мы расширим “рабочий синтаксис”:

распаковка ( и *) в выражениях и вызовах функций

тернарный оператор как инструмент читаемости

современные операторы: моржовый оператор :=, объединение словарей | и обновление |=

Тернарный оператор и короткие логические выражения

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

условное выражение (его обычно называют тернарным оператором)

короткие логические выражения на and и or (и что такое short-circuit)

Официальная документация:

Conditional expressions (тернарный оператор)

Boolean operations (and, or, not)

Truth Value Testing (что считается истинным и ложным)

Тернарный оператор в Python: A if cond else B

В Python тернарный оператор называется условным выражением и выглядит так:

Смысл:

если condition истинно, результат — a

иначе результат — b

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

Сравнение с обычным if/else

Обычная форма:

С тернарным оператором:

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

Тернарный оператор внутри comprehension

В предыдущей статье вы уже видели важное отличие:

if в конце comprehension — фильтр, он выбрасывает элементы

A if cond else B внутри выражения — преобразование, оно сохраняет количество элементов

Пример: пометить числа как "even" или "odd", не удаляя ничего из результата.

Если бы вы написали фильтр if x % 2 == 0, то нечётные числа просто исчезли бы.

Вложенные тернарные операторы

Иногда в коде встречается такая запись:

Так можно, но читаемость быстро падает. Обычно лучше переписать на обычный if/elif/else, особенно если веток больше двух.

Истина и ложь в Python: почему or “возвращает значение”, а не True/False

Чтобы понимать “короткие” выражения, нужно помнить правило: в Python практически любой объект можно использовать в условии.

Ложными (falsy) считаются:

False

None

0, 0.0

"" (пустая строка)

[], {}, set() (пустые коллекции)

Почти всё остальное — истинное (truthy).

Важно: операции and и or возвращают один из операндов, а не обязательно True или False.

and и or: short-circuit и практические шаблоны

Short-circuit: вычисляем только то, что нужно

Python вычисляет логические выражения слева направо и может остановиться раньше:

A and B

- если A ложное, B не вычисляется - результат — A (ложный операнд)

A or B

- если A истинное, B не вычисляется - результат — A (истинный операнд)

Это поведение называется short-circuit evaluation.

!Блок-схема показывает, когда вычисление останавливается и почему правый операнд иногда не выполняется

Шаблон x or default (значение по умолчанию)

Очень частый рабочий шаблон:

Если user_input пустая строка, то она falsy, и возьмётся "Anonymous".

Но здесь есть тонкость: or заменит любое falsy значение, включая 0.

Если config_timeout = 0 (и это осознанное значение), код ошибочно подставит 30. В таких местах часто нужно проверять именно на None:

Шаблон cond and expr (условное выполнение)

Иногда встречается:

Это работает из-за short-circuit: если is_debug ложное, правая часть не выполнится.

Практическое правило:

для побочных эффектов (логирование, вызовы) чаще пишут обычный if

and-шаблон встречается, но может ухудшать читаемость, особенно для новичков в команде

Предпочтительнее так:

“Плохой тернарный оператор” через and/or

В старом коде можно встретить попытку написать тернарный оператор так:

Проблема: если a само по себе falsy (например, "" или 0), выражение вернёт b, даже если cond истинно.

Надёжно пишется так:

Приоритет операторов: когда нужны скобки

Условное выражение A if cond else B имеет низкий приоритет. Это означает, что рядом с and/or и другими операторами легко получить не то, что вы “прочитали глазами”.

Пример:

Из-за приоритета операторов это читается как:

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

Как выбирать между if/else, тернарным оператором и and/or

Практичные правила, которые помогают писать “рабочий” код:

Тернарный оператор используйте, когда:

- обе ветки короткие - вы присваиваете значение или передаёте аргумент - условие простое

Обычный if/else используйте, когда:

- в ветках несколько строк - есть побочные эффекты - важна максимальная ясность для команды

x or default используйте осознанно:

- подходит, когда вы хотите заменить любые falsy значения - не подходит, если 0, "", [] являются валидными значениями и их нельзя заменять

Итоги и связь с курсом

Теперь вы умеете читать и писать:

тернарный оператор A if cond else B и отличать его от if-фильтра в comprehensions

короткие логические выражения на and/or и понимать short-circuit

безопасно применять x or default и понимать, когда нужна проверка на None

Дальше в курсе этот навык напрямую пригодится, когда мы будем разбирать распаковку и * и современные операторы: в реальном коде они часто комбинируются с тернарными выражениями и “короткой” логикой.

Распаковка: , *, множественное присваивание и параметры функций

В предыдущих статьях курса мы разобрали comprehensions и короткие условные выражения. Следующий большой “шаг к рабочему коду” — уверенно читать и писать распаковку.

Распаковка встречается повсюду:

в присваиваниях (множества значений “раскладываются” по переменным)

в циклах for (когда элемент — это пара/кортеж)

в вызовах функций (передача позиционных/именованных аргументов из коллекций)

в создании новых списков/словарй из частей ([a, b], {d1, d2})

Официальная документация:

Assignment statements (распаковка при присваивании)

Calls (распаковка в вызовах функций)

Function definitions (параметры, и *)

PEP 448 (обобщённая распаковка в литералах)

Что такое распаковка

Распаковка — это использование или *, чтобы “развернуть” коллекцию в набор элементов.

работает с итерируемыми* объектами (списки, кортежи, строки, генераторы) и разворачивает их в последовательность позиционных элементов

* работает со словарй-подобными объектами (mapping) и разворачивает пары ключ → значение* в именованные аргументы или пары для нового словаря

Важно: распаковка — это не “магия”, а способ сказать Python: “возьми содержимое и подставь как отдельные элементы”.

Множественное присваивание и распаковка последовательностей

Базовый случай: одинаковое количество элементов

Если количество переменных и элементов не совпадает — будет ValueError.

Частый рабочий шаблон: обмен значений без временной переменной

Это читается как “справа сформируй кортеж, слева распакуй его”.

Распаковка “с хвостом”: звёздочка в присваивании

Можно “собрать остаток” в список через * слева.

Правила:

переменная со получает список* (даже если справа кортеж)

*-переменная может быть только одна в левой части

“Не хочу это значение”: соглашение про _

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

_ — это просто имя переменной по договорённости: “значение игнорируем”.

Распаковка в циклах и работе со словарями

Распаковка пар в for

Если вы итерируетесь по элементам вида (a, b), то можно сразу разложить их по переменным.

Это постоянно встречается со словарями через .items():

Связь с comprehensions

Распаковка часто “склеивается” с comprehension:

Обратите внимание: здесь (name, price) берутся из .items() и распаковываются прямо в заголовке цикла comprehension.

и * при вызове функций

*args: распаковка позиционных аргументов

Если функция ожидает несколько позиционных аргументов, а у вас они лежат в списке/кортеже, используйте *.

**kwargs: распаковка именованных аргументов

Если у вас есть словарь с параметрами, используйте **.

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

Смешивание обычных аргументов и распаковки

Часто встречается комбинация:

Практическое правило порядка (полезно для чтения чужого кода):

позиционные аргументы

затем *something (позиционная распаковка)

затем именованные аргументы name=value

затем **something (именованная распаковка)

Если перепутать — получите SyntaxError.

!Диаграмма, показывающая как и * преобразуют коллекции в аргументы функции

args и *kwargs в определении функций

Распаковка важна не только при вызове, но и при приёме аргументов.

*args: собрать лишние позиционные аргументы

Здесь rest — кортеж.

**kwargs: собрать лишние именованные аргументы

Разделитель *: сделать параметры только именованными

Очень “рабочая” деталь: одиночная * в списке параметров означает, что всё после неё можно передавать только по имени.

Это помогает:

сделать вызовы самодокументируемыми (timeout=... видно явно)

защититься от ошибок, когда кто-то перепутал порядок аргументов

Разделитель /: позиционные-only параметры

В современном Python (3.8+) можно встретить / — это значит, что параметры до / нельзя передать по имени, только позиционно.

Это реже нужно в прикладном коде, но полезно для чтения библиотек и API, где авторы хотят “заморозить” имена параметров.

Распаковка при создании новых коллекций

Начиная с Python 3.5+ распаковку можно использовать прямо в литералах коллекций.

Списки и кортежи: [a, b]

Это особенно удобно, когда вы собираете результат из нескольких источников и не хотите писать extend.

Множества: {a, b}

Словари: {d1, d2} и приоритет ключей

Правило: если ключ повторяется, побеждает тот словарь, который стоит правее.

Это напрямую связано со следующим шагом курса: в современном коде также встречается оператор объединения словарей |, но базовая идея (что при конфликте “правый выигрывает”) здесь уже видна.

Типичные ошибки и как их распознавать

ValueError при распаковке в присваивании

Причина: количество элементов “не сошлось”. Лечится либо корректным количеством переменных, либо использованием *rest.

TypeError при передаче **kwargs

Частые причины:

ключи словаря не строки

ключи не являются допустимыми именами параметров

вы передали один и тот же именованный аргумент дважды

Читаемость

Распаковка делает код короче, но её легко “перегнуть”. Практичный ориентир:

если /* убирают шум и делают намерение яснее — используйте

если приходится долго разбирать, что куда попадает — лучше обычный код (явное присваивание, явная сборка словаря)

Итоги и связь с курсом

Теперь вы умеете читать “рабочие” конструкции с распаковкой:

множественное присваивание, включая *rest и обмен значений

распаковку элементов в for и в comprehensions

args/*kwargs в вызовах функций и в определениях

разделители параметров * (keyword-only) и / (positional-only)

распаковку в литералах списков, множеств и словарей

Дальше эти навыки будут напрямую использоваться в теме “современные операторы”: моржовый оператор :=, объединение словарей | и обновление |= часто встречаются рядом с /* и short-circuit логикой.

Современные операторы: моржовый, объединение словарей и полезные идиомы

Вы уже умеете читать и писать “рабочие” конструкции: comprehensions, тернарный оператор, короткие and/or выражения и распаковку /*. Следующий шаг — синтаксис, который часто встречается в современном коде на Python 3.8+:

моржовый оператор := (assignment expression)

объединение словарей через | и обновление через |=

несколько практичных идиом, где эти вещи сочетаются с темами курса

Официальные источники:

Assignment expressions (Python Reference)

PEP 572 — Assignment Expressions

Dictionary merge and update operators (PEP 584)

dict (встроенный тип, Python Library)

Моржовый оператор :=

:= позволяет присвоить значение переменной прямо внутри выражения и тут же использовать это значение.

Обычное присваивание = — это инструкция (statement), а := — выражение (expression). Поэтому := можно использовать там, где ожидается значение: в if, while, в comprehensions и т.д.

Базовая идея

Вместо “сначала вычисли, потом отдельно присвой”:

Можно написать “вычисли и сохрани в переменную по пути”:

Плюсы в рабочем коде:

меньше дублирования (не вычисляете одно и то же дважды)

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

удобно в циклах чтения/парсинга

Типовой пример: цикл while с чтением

Классический “читай, пока есть данные”:

С := это становится компактнее:

Практическая ремарка: если вы читаете текстовый файл построчно, чаще пишут просто for line in f: — но для некоторых источников данных (socket.recv, queue.get_nowait с обработкой, чтение блоками) паттерн while (chunk := ...) встречается постоянно.

:= в if: один вызов вместо двух

Частая “рабочая” ситуация: вам нужно получить значение, затем проверить, что оно есть.

Важно: это работает корректно, если вы действительно хотите трактовать “пустого” пользователя как ложь. Если различие “нет значения” и “пустое значение” критично — проверяйте явно is None.

:= в comprehensions и генераторах

С := удобно избегать повторного вычисления в выражении и в фильтре.

Пример: есть список строк, нужно взять только те, которые после очистки не пустые, и сохранить уже очищенный вариант.

Без := часто получается дублирование .strip():

С := делаем вычисление один раз:

То же самое работает и в generator expression:

Здесь важно, что n присваивается только если фильтр дошёл до вычисления правой части.

!Блок-схема показывает, что вычисление, присваивание и проверка происходят в одном выражении

Приоритет операторов и скобки

У := низкий приоритет. В спорных местах ставьте скобки — в рабочем коде это повышает читаемость.

Хорошо:

Плохо (тяжело читать и легко ошибиться):

Во втором примере в n попадёт результат сравнения len(items) > 10, то есть True/False, а не длина.

Когда := не стоит использовать

если выражение становится “головоломкой”

если переменная живёт слишком долго и путает область ответственности

если присваивание в условии ухудшает ясность (команде проще читать явные строки)

Правило на практике простое: := хорош, когда он убирает дублирование и локализует значение рядом с проверкой.

Объединение словарей: | и |=

Начиная с Python 3.9, у словарей есть оператор объединения:

d3 = d1 | d2 создаёт новый словарь

d1 |= d2 обновляет существующий словарь d1 (in-place)

Это концептуально похоже на {d1, d2}, который вы уже видели в теме распаковки.

d1 | d2: новый словарь

Правило конфликта ключей:

если ключ повторяется, побеждает правый словарь

d1 |= d2: обновление существующего

Это по смыслу близко к config.update(override), но операторная форма часто лучше читается в коде, где много “слоёв конфигурации”.

Сравнение способов “склеить словари”

| Задача | Рекомендуемый вариант | Комментарий | |---|---|---| | Создать новый словарь из двух | d1 | d2 | Python 3.9+ | | Обновить существующий словарь | d1 |= d2 | Python 3.9+ | | Создать новый словарь (универсально) | {d1, d2} | Python 3.5+ | | Обновить существующий словарь | d1.update(d2) | Всегда работает |

Практический кейс: конфиг с приоритетами

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

Такой код легко читать: чем правее источник, тем выше приоритет.

Важная граница: | работает именно для словарей

| для словарей — не то же самое, что | для множеств.

для set это объединение множеств

для dict это объединение ключей с правилом “правый выигрывает”

Полезные идиомы, которые часто встречаются в рабочем коде

Ниже — несколько паттернов, которые связывают все темы курса: comprehensions, and/or, тернарный оператор, распаковку и современные операторы.

“Вычисли один раз и используй”: фильтр + значение

Идея: в p сохраняем уже “нормализованный” объект Path, чтобы не создавать его повторно.

“Проверка и разбор” в одном if

Здесь используется short-circuit из темы про and: если split вернул пустое (редко, но как идея), дальше не идём.

Если читать тяжело — лучше разнести на строки. Рабочий код ценит ясность.

Сбор аргументов для функции: | и **

Здесь вместе работают:

| как способ собрать итоговый словарь параметров

** как способ передать словарь как именованные аргументы

keyword-only параметры (звёздочка в определении) из темы про распаковку

:= и тернарный оператор

Иногда удобно вычислить значение и выбрать формат:

Но это пример на грани читаемости. Если команда будет читать это с трудом — лучше так:

Итоги

Вы научились распознавать и применять конструкции, которые часто встречаются в современном рабочем Python-коде:

:= как способ присвоить значение внутри выражения и убрать дублирование

правила приоритета и необходимость скобок для :=

d1 | d2 и d1 |= d2 для объединения и обновления словарей

практичные идиомы, где современные операторы сочетаются с распаковкой, comprehensions и short-circuit логикой

Как читать рабочий код: паттерны, типичные ошибки и рефакторинг

Вы уже познакомились с синтаксисом, который постоянно встречается в реальном Python-коде: comprehensions, тернарный оператор, короткие выражения на and/or, распаковка /*, моржовый оператор := и объединение словарей |.

Эта статья — про следующий уровень: как всё это читать в чужом коде, как распознавать типичные ловушки и как аккуратно рефакторить “слишком умные” выражения в понятный рабочий код.

Полезные источники:

The Python Tutorial — Data Structures (list comprehensions)

Python Reference — Expressions (conditional, boolean, assignment expressions)

PEP 8 — Style Guide for Python Code

PEP 572 — Assignment Expressions

PEP 584 — Dictionary Merge and Update Operators

Модель чтения рабочего кода

Рабочий код часто “сжат”: одна строка делает то, что в учебниках растягивают на 6–10 строк. Задача при чтении — разжать его обратно в голове.

Быстрый алгоритм разбора выражений

Определите что возвращает выражение:

- [...] создаёт список - {...} создаёт словарь или множество (у словаря есть key: value) - (...) часто означает генераторное выражение или просто скобки для приоритета

Найдите “источник данных”:

- for x in ... - .items(), .values(), .split(), range(...), чтение файла

Найдите фильтрацию:

- if в конце comprehension - and/or как “короткие” условия

Найдите преобразование:

- выражение слева в comprehension - A if cond else B - распаковку /*

Проверьте подводные камни:

- приоритет операторов (:=, тернарный оператор, and/or) - falsy значения (0, "", []) в or default - одноразовость генератора

!Шпаргалка: в каком порядке разбирать “сжатый” код

Когда “коротко” — это нормально

Короткие выражения читаются хорошо, если:

нет скрытых побочных эффектов

нет вложенных тернарных операторов

нет трёх уровней скобок и пяти операторов в одной строке

смысл можно пересказать простым предложением

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

Паттерны, которые стоит узнавать с первого взгляда

Ниже — конструкции, которые часто встречаются вместе и выглядят “сложно”, пока не начнёшь видеть шаблон.

Очистка и фильтрация строк: strip() + фильтр

Что происходит:

.strip() удаляет пробелы по краям

фильтр if s.strip() выкидывает пустые после очистки

Проблема: .strip() вызывается дважды.

Улучшение через :=:

Здесь t получает очищенную строку, и она же используется как условие.

“Значение по умолчанию”: x or default

Это означает: если provided_name пустое (falsy), взять запасное.

Условие “falsy” включает 0, "", [], {}, None. Поэтому если 0 — валидное значение, пишут проверку на None:

Сбор конфигурации слоями: | для словарей

Правило чтения: правее — приоритетнее (правый словарь перезаписывает ключи).

Передача параметров через ** после сборки

Как это читать:

base | override собирает итоговый словарь

**(...) разворачивает словарь в именованные аргументы

* в параметрах send делает аргументы только именованными

“Сначала посчитай, потом используй” без дублей: := в if

Это компактная версия:

Скобки вокруг (m := ...) почти всегда повышают читаемость и защищают от ошибок приоритета.

Типичные ошибки и как их быстро распознавать

Путаница: фильтр if в comprehension против тернарного оператора

Фильтр удаляет элементы:

Тернарный оператор сохраняет количество элементов, но меняет значения:

Частая ошибка чтения: увидеть if и подумать, что это “иначе подставь другое”. В comprehension “иначе” не существует, если это именно фильтр.

Опасный or default, когда 0 — валидное значение

Если user_limit = 0, вы получите 100, хотя пользователь явно выбрал ноль.

Надёжнее:

Моржовый оператор и приоритет: где нужны скобки

Ошибка:

Это присваивает в n результат сравнения len(items) > 10 (то есть True/False).

Правильно:

Генератор “исчез”: одноразовость generator expression

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

Если нужно пройти дважды, материализуйте список один раз:

Распаковка и “лишние значения”: ValueError

Либо исправляйте количество переменных, либо используйте *rest:

Дубли аргументов при **kwargs

Это ошибка, потому что x уже передали позиционно (10) и ещё раз через kwargs.

Рефакторинг: как превратить “умную строку” в рабочий код

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

Приёмы рефакторинга, которые реально используют

Разбивайте выражение на именованные промежуточные значения

Выносите “шаг преобразования” в маленькую функцию

Заменяйте вложенные тернарные операторы на if/elif/else

Делайте приоритет явным скобками, особенно рядом с := и тернарным оператором

Не используйте comprehension ради побочных эффектов (лучше for)

Пример: comprehension стал слишком сложным

Было:

Проблемы:

.strip() вызывается дважды

условие тяжело читать

не очевидно, где “валидация”, а где “преобразование”

Вариант с := (всё ещё компактно, но уже лучше):

Вариант максимально ясный (часто лучший для команды):

Практическое правило: если условие в comprehension превращается в “мини-программу”, цикл часто читается лучше.

Пример: цепочка and/or скрывает смысл

Было:

Проблема: если f"len=..." вдруг может стать falsy (редко, но в общем случае), логика ломается. И читать это тяжелее.

Надёжнее через тернарный оператор:

Пример: сбор словаря из источников

Было:

В современном Python это можно сделать читабельнее оператором |:

А если нужно обновить существующий словарь:

Мини-чеклист: пишем так, чтобы это читали на работе

Предпочитайте ясность “умности”

Используйте :=, когда он убирает дублирование и остаётся понятным

Используйте | для словарей, когда собираете конфигурацию слоями

Ставьте скобки, если есть хоть малейший риск неверного прочтения

Разделяйте “получение данных”, “проверку”, “преобразование” по строкам, если выражение стало плотным

Сверяйтесь со стилем команды и общими рекомендациями из PEP 8 — Style Guide for Python Code

Итоги

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

алгоритм “разжатия” коротких выражений

узнаваемые паттерны, которые комбинируют темы курса

типовые ошибки: фильтр против тернарного, or default, приоритет :=, одноразовые генераторы, проблемы распаковки

способы рефакторинга: промежуточные переменные, скобки, переход к явному for, замена and/or на тернарный оператор, использование | для словарей