10 советов и приемов для написания чистого кода на Python

Произведите впечатление на своих коллег чистым и лаконичным кодом.

Изучите 10 замечательных «трюков» программирования на Python, удобных для начинающих, с подробными объяснениями.

Следующий список находится в произвольном порядке.

Я надеюсь, вам понравится это!

1. Поменять местами две переменные без третьей

В Python можно поменять местами две переменные без третьей:

a = 1
b = 2
a, b = b, a

Объяснение

Приведенный выше «трюк» с заменой двух переменных вовсе не является трюком.

Он использует деструктурирование (распаковку), который является широко используемым подходом к распаковке последовательностей элементов в отдельные переменные.

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

Вот простой пример нескольких присваиваний в одной строке:

x, y = 10, 20

Теперь x равно 10, а y равно 20.

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

x, y = 10, 20, 30

Выход:

ValueError: too many values to unpack (expected 2)

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

В приведенном выше примере:

x, y = 10, 20

Мы распаковываем компоненты кортежа из (10, 20) в две отдельные переменные.

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

x, y = (10, 20)

Итак, теперь вы понимаете, как работает распаковка кортежей в Python.

Это означает, что теперь вы можете понять, как работает «трюк» замены двух переменных без третьей.

a = 1
b = 2
a, b = b, a

Все, что вам нужно сделать, это создать кортеж в обратном порядке (b, a) и распаковать его в отдельные переменные a и b.

Наконец, полезно понимать, что распаковка не ограничивается только кортежами. Вы также можете использовать его со списками.

Например:

coords = [1, 5, 3]
x, y, z = coords
print(x, y, z)

Выход:

1 5 3

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

a = 1
b = 2
a, b = [b, a]

2. Дублирование строк без циклов

Подобно тому, как вы можете умножать числа, вы можете умножать строки с помощью оператора * в Python.

Например:

name = “Banana”
print(name * 4)

Выход:

BananaBananaBananaBanana

Объяснение

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

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

Всякий раз, когда вы умножаете строку, вы за кулисами вызываете специальный метод __mul__.

Например, это:

name = “Banana”
print(name * 4)

Эквивалентно этому:

name = “Banana”
print(name.__mul__(4))

Неудивительно, что по умолчанию классы Python не поддерживают умножение.

Например, давайте создадим класс Fruit и умножим объект Fruit:

Выход:

TypeError: unsupported operand type(s) for *: ‘Fruit’ and ‘int’

Однако вы можете заставить любой класс Python поддерживать умножение, реализовав специальный метод под названием __mul__.

Например, давайте сделаем так, чтобы класс Fruit поддерживал умножение таким образом, чтобы его имя умножалось на коэффициент n:

Это приводит к следующему результату:

BananaBananaBananaBanana

Обратите внимание, что вызов:

f * 4

Является сокращением для вызова метода __mul__, который вы только что реализовали:

f.__mul__(4)

Но зачем я показал вам все это?

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

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

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

3. Перевернуть строку с помощью [::-1]

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

Выход:

tset a tsuj si sihT

Объяснение

Обращение строки (или любого другого итерируемого Python) с помощью [::-1] включает в себя понимание индексации, отрицательной индексации и нарезки. Подробное объяснение см. в этой статье.

Итерируемые объекты Python, такие как списки и строки, поддерживают нарезку.

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

Например, давайте возьмем первые 4 символа из предложения:

string = “This is a test”
part = string[0:4:1]
print(part)

Выход:

This

В этом фрагменте кода string[0:4:1] означает получение части строки, которая:

• Начинается с первого символа (индекс 0).
• Заканчивается перед 5-м символом (индекс 4).
• Выполняет шаги размером 1, то есть возвращает каждый символ из этого диапазона.

Как правило, нарезка следует следующему синтаксису:

iterable[start:end:stepsize]

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

Например, чтобы получить первые 4 символа, вы можете сделать это:

string = “This is a test”
part = string[:4:1]
print(part)

Выход:

This

То же самое применимо, когда вы останавливаетесь в самом конце итерации. Вам не нужно указывать параметр stop.

Например, чтобы разрезать строку, чтобы получить всю строку обратно:

string = “This is a test”
part = string[::1]
print(part)

Выход:

This is a test

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

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

string = “This is a test”
part = string[::-1]
print(part)

Выход:

tset a si sihT

Поскольку размер шага равен -1, нарезка начинается с параметра stop и останавливается на параметре start. Но ни один из этих параметров не указан. Таким образом, он автоматически начинает нарезку с последнего элемента и заканчивает на первом.

4. Объедините список строк

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

Например:

words = [“This”, “is”, “a”, “Test”]
combined = “ “.join(words)
print(combined)

Выход:

This is a Test

Объяснение

Строковый тип Python str имеет встроенный метод join(). Этот метод объединяет последовательность строк с помощью строки-разделителя. Другими словами, вы можете использовать метод join() для объединения последовательности строк в одну длинную строку.

Синтаксис метода join() следующий:

separator.join(iterable)

Где строка separator добавляется между каждым элементом в iterable.

Например, давайте соединим список строк:

words = [“This”, “is”, “a”, “Test”]
combined = “ “.join(words)
print(combined)

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

This is a Test

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

words = (“This”, “is”, “a”, “Test”)
combined = “ “.join(words)
print(combined)

Выход:

This is a Test

В Python строка также является итерируемым типом, состоящим из последовательности символов.

Это означает, что вы также можете вызывать join() со строковым аргументом.

Например, давайте разделим символы строки тире:

dashed = “-”.join(“Test”)
print(dashed)

Выход:

T-e-s-t

5. Цепочки математических сравнений

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

Например:

x = 100
res = 1 < x < 200
print(res)

Выход:

True

Объяснение

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

Например, если вы хотите, чтобы температура T находилась в диапазоне от 40 до 50 градусов по Фаренгейту, вы можете обозначить ее следующим образом:

40 < T < 50

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

• Т меньше 50
• Т больше 40.

Затем вы можете комбинировать их с оператором and для конкретного языка.

В Python это будет означать такое выражение:

T > 40 and T < 50

Недостатком этого выражения является то, что требуется секунда, чтобы понять, что оно означает 40 ‹ T ‹ 50. Кроме того, для его написания требуется на секунду больше времени, а также требуются дополнительные символы.

К счастью, в Python возможно сравнение по цепочке. Другими словами, вы можете написать:

40 < T < 50

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

6. Найдите наиболее часто встречающийся элемент в списке

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

Например:

numbers = [6, 2, 2, 3, 4, 2, 2, 90, 2, 41]
most_frequent = max(set(numbers), key = numbers.count)
print(most_frequent)

Выход:

2

Объяснение

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

Лучшим подходом для поиска наиболее часто встречающегося элемента будет использование модуля статистика.

Например:

Выход:

2

В любом случае, давайте посмотрим, как работает трюк с поиском наиболее часто встречающегося элемента.

Прежде всего, вам не нужно преобразовывать список в набор. Этот фрагмент кода также выполнит свою работу:

max(numbers, key = numbers.count)

Но как это работает?

Когда вы вызываете функцию max() в Python, по умолчанию она находит самый большой элемент. Однако иногда это не то, что вы хотите. Например, может быть, вы хотите найти самую длинную строку в списке.

Чтобы изменить значение максимального значения, укажите в вызове параметр key. Этот ключ представляет собой функцию, которую функция max() вызывает для каждого элемента, прежде чем выбрать максимальный элемент.

Чтобы найти наиболее часто встречающийся элемент в списке numbers, key указывается как функция numbers.count().

Это означает, что numbers.count(n) вызывается для каждого числа n в списке numbers. Это создает список чисел, которые представляют, сколько раз каждое число встречается в списке. Затем функция max() выбирает элемент с наибольшим количеством вхождений на основе этого списка.

Но почему вы преобразовали список в набор в оригинальной версии фокуса?

max(set(numbers), key = numbers.count)

list.count() — это операция O(n). Кроме того, это выполняется для каждого элемента списка. Это означает, что трюк представляет собой операцию O(n2), что означает довольно низкую производительность.

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

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

Однако операция по-прежнему выполняется O(n2), а это означает, что она работает плохо даже с этим небольшим улучшением.

7. Извлечь список в переменные

Вы можете распаковывать элементы списка в переменные, если количество переменных остается таким же, как количество элементов в списке.

Например:

arr = [1, 2, 3]
a, b, c = arr
print(a, b, c)

Выход:

1 2 3

Объяснение

Объяснение этого «трюка» такое же, как и объяснение трюка с заменой двух переменных местами.

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

Для этого вам нужно иметь такое же количество переменных в правой части, как и значения в итерации в левой части.

Чтобы увидеть больше деталей, не стесняйтесь вернуться к объяснению первого трюка в этой статье.

8. Однострочные операторы If-Else

В Python вы можете заменить оператор if-else однострочным сокращением.

Например:

age = 30
age_group = “Adult” if age > 18 else “Child”
print(age_group)

Выход:

Adult

Объяснение

Если вы знаете другие языки программирования, такие как JavaScript или C, вы можете быть знакомы с тернарным оператором. Его можно использовать для замены оператора if-else оператором с вопросительным знаком и двоеточием, например:

condition ? true_expr : false_expr

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

Однако Python поддерживает условный оператор (иногда также называемый тернарным оператором). Это очень похожий синтаксис, который позволяет писать однострочные операторы if-else.

Вот синтаксис использования условного оператора в Python:

true_expression if condition else false_expression

Это может быть удобно, если у вас есть простой оператор if-else, который вы хотите сделать короче.

Например, обычно вы делаете:

Но с помощью условного оператора вы можете заменить оператор if-else более кратким сокращением:

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

Но если вы хотите сохранить несколько строк кода, обязательно используйте условный оператор только с простыми операторами if-else.

Вот плохой пример использования условного оператора в Python:

Как видите, читать эту кашу невозможно! Но если вы напишете его как обычный if-else, сразу станет понятно, что делает код:

Используйте условные операторы с умом!

Обязательно прочитайте мое полное руководство по однострочным операторам if-else в Python!

9. Однострочник для циклов

В Python можно писать циклы for как однострочники.

Например, возведем в квадрат список чисел:

numbers = [1, 2, 3, 4, 5]
squared_numbers = [num * num for num in numbers]
print(squared_numbers)

Выход:

[1, 4, 9, 16, 25]

Объяснение

Однострочник для цикла, который вы видели выше, называется пониманием списка. Это сокращение для перебора списков в Python.

Понимание списка работает с существующим списком значений и создает новый.

Как правило, понимание списка использует следующий синтаксис:

newlist = [expression for item in iterable if condition]

Как и в обычном цикле for, понимание списка:

• Берет список предметов.
• Работает над каждым элементом (если выполняется условие).
• Помещает результат в новый список.
• Возвращает новый список.

Например, возведем в квадрат четные числа списка чисел.

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

Выход:

[4, 16, 36, 64]

Затем давайте сократим цикл for до однострочного с пониманием списка:

Выход:

[4, 16, 36, 64]

Это делает код короче и сохраняет удобочитаемость. И, кстати, он тоже чуть быстрее обычного цикла for.

Как и в случае с однострочным оператором if-else, не злоупотребляйте списковыми включениями в Python! Это может пожертвовать читабельностью кода. Например, можно написать вложенные циклы for в виде вложенных списков, но это редко приносит пользу. Несмотря на то, что понимание немного быстрее, чем цикл for, его не стоит использовать только для повышения производительности.

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

И последнее, но не менее важное: приятно знать, что Python поддерживает понимание и для других итерируемых типов. Всего Python поддерживает четыре различных типа понимания:

1. Понимание списка
2. Понимание словаря
3. Установить понимание
4. Понимание генератора (также известное как выражение генератора)

Чтобы узнать больше об этом, пожалуйста, взгляните на эту статью.

10. Упростите операторы if

Вместо этого довольно многословного сравнения:

if n == 0 or n == 1 or n == 2 or n == 3 or n == 4 or n == 5:

Вы можете сделать это:

if n in [0, 1, 2, 3, 4, 5]

Объяснение

В Python вы можете проверить выполнение нескольких условий с помощью оператора или.

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

Чтобы проверить, существует ли значение в списке в Python, используйте оператор in. Он проходит через итерацию и проверяет, найдено ли целевое значение. Этот подход возвращает True, если значение найдено, и False, если нет.

Например:

Заключение

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

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

Удачного кодирования!

Дальнейшее чтение

Больше контента на plainenglish.io