Неочевидные ловушки Python для новичка

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

На первых порах всё кажется интуитивно понятным. Вы создаете список, добавляете в него элементы, сравниваете значения, делаете копии… Но в какой-то момент код начинает вести себя не так, как вы ожидаете. И в данном случае самое сложное — это понять, что ошибка не в логике, а в том, как Python интерпретирует код.

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

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

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

Вы ожидали, что result будет содержать обновленный список [1, 2, 3, 4]. Но вместо этого result стал None, а исходный список тайно изменился. Причем код выполнился, но не так, как вы задумали.

Это связано с тем, что в Python есть два типа методов. Их различие в том, как они работают с данными. Их называют мутирующими и немутирующими. Типы методов:

Для предотвращения такой ошибки надо точно знать, что метод работает на месте (in-place) и просто не сохранять результат лишний раз.

Взгляните на этот код:

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

А вот еще один сюрприз:

По аналогии с предыдущим примером, тут результат должен быть False, но мы видим True. Это может выглядит, как крайнее несоответствие, но этому есть объяснение.

Перед тем, как объяснить причины таких противоречивых результатов, стоит напомнить то, как работает память в Python.

Во многих языках переменная — это контейнер, в котором лежит значение. В Python же переменная — это ссылка, которая ссылается на объект в памяти.

Итак, в данном примере Python создает объект 42 где-то в памяти и присваивает х его адрес. После Python не копирует объект 42 еще раз, а просто берет уже готовый адрес в х и копирует его в у. Следовательно, х и у ссылаются на один и тот же объект и имеют одинаковый адрес.

Также существуют изменяемые и неизменяемые типы данных:

Вернемся к операторам is и ==.

А с числом 256 происходит некоторый фокус. Для оптимизации Python кеширует малые целые числа от -5 до 256. Поэтому x и y ссылаются на один и тот же объект в памяти.

Все довольно просто, оператор is предпочтительней использовать для сравнения с None, True, False и проверки на один и тот же объект.

А оператор == использовать для сравнения содержимого:

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

Ожидалось, что original останется нетронутым, ведь зачем еще нужны копии, если не для защиты оригинала? Но в итоге оригинал все таки изменился. Может вы вспомнили или нашли еще один способ копирования списков:

Но проблема была только частично решена. Число 1 не изменилось, но внутренний список [3, 4] всё равно поменялся.

Как уже ранее было рассмотрено, в Python переменные — это ссылки на объекты в памяти.

Когда вы пишете copy = original — вы копируете ссылку, а не объект. Обе переменные указывают на один и тот же список в памяти. Поэтому при изменении любой переменной список измениться для обоих.

При применении [:] или list() создаётся поверхностная копию (shallow copy). Новый контейнер в памяти создается, но внутрь кладутся те же самые значения и ссылки на объекты, что и в оригинале.

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

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

Но при наличии вложенных структур надо создавать глубокую копию. Для этого применяется метод deepcopy из библиотеки copy. Кстати одноименный метод в этой библиотеке можно применять для плоских списков. Вот как применяется deepcopy:

Для словарей и множеств применяется такой же принцип, как и для списков.

Рассмотрим некоторые математические несоответствия, с которыми можно столкнуться в Python:

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

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

Очевидно, что по правилам округления 2.675 ≈ 2.68, но мы получаем не тот результат.

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

При записи 1/3 в десятичной системе получится 0.3333… или 0.(3). Компьютер вынужден обрезать это периодическое значение, отсюда и погрешность.

0.1 при переводе в двоичную систему примерно равно 0.000110011… или 0.(00011). Компьютер хранит не точное значение, а приближенное. И понятно, что при применении арифметических действий с приближенными значениями будет неточный результат.

С округлением происходит та же проблема. Число 2.675 тоже не хранится точно. На самом деле оно хранится как примерно 2.67499999999999982236. При округлении до двух знаков получается 2.67, а не 2.68.

Есть разные варианты для обхода этой проблемы в разных ситуациях. Например для сравнения можно применять метод isclose из библиотеки math. Применение метода:

Для точных рассчетов можно применять метод Decimal из одноименной библиотеки. Важно отметить, что для данного метода надо передавать значения строкой, иначе float передаст неточное число еще до попадения в сам метод. Применение метода:

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

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