Python уже давно пользуется популярностью среди разработчиков, но для этого почтенного языка программирования, похоже, наступил момент. После многих лет игры в качестве второй скрипки Java, некоторые источники оценивают Python как самый популярный язык программирования в мире.
Фактически, Python в некоторых рейтингах даже превосходит C, C ++ и Java! И этому есть несколько причин: во-первых, поскольку современные микроконтроллеры продолжают набирать силу, у них есть возможность разместить интерпретатор Python, что позволяет включить Python в список встроенных языков, расширяя его охват. Во-вторых, Python может воспользоваться снижением использования R, что еще больше укрепит доминирующее положение Python в обработке статистики и приложениях с большими данными.
Гибкость Python FTW
Среди основных причин популярности Python - его относительная простота и невероятная гибкость. Немногие языки программирования могут сравниться со способностью Python соответствовать вашему конкретному стилю кодирования, вместо того, чтобы заставлять вас кодировать определенным образом.
Хотя Python требует, чтобы вы придерживались определенных соглашений, таких как использование пробелов (см. руководство по стилю Pep-8), чтобы его было легко читать и понимать, он по-прежнему сохраняет гибкость, позволяя разработчикам кодировать таким образом, который кажется естественным им. Такой уровень комфорта может значительно повысить эффективность разработчика и снизить вероятность ошибок.
Эта гибкость имеет еще одно ключевое преимущество: вместо того, чтобы принудительно использовать определенный стиль кодирования, он позволяет более продвинутым разработчикам использовать стиль, который, по их мнению, лучше всего подходит для решения конкретной проблемы.
Существует четыре основных стиля программирования Python: императивный, функциональный, объектно-ориентированный и процедурный. (Некоторые люди сочетают императивные и функциональные стили кодирования, в то время как другие рассматривают их как полностью отдельные стили). Вы можете согласиться или не согласиться с тем, что все четыре формы действительны или даже полезны, но тем не менее Python делает их все доступными. Давайте посмотрим на плюсы и минусы каждого подхода, а также на несколько примеров.
Краткий обзор четырех стилей кодирования Python
Функциональный: каждый оператор обрабатывается как математическое уравнение, и любые формы состояния или изменяемых данных избегаются. Основное преимущество этого подхода заключается в том, что он хорошо подходит для параллельной обработки, потому что нет состояния, которое нужно учитывать. Многие разработчики предпочитают этот стиль кодирования для рекурсии и лямбда-исчисления (Обратите внимание, что реализация функционального программирования в Python отличается от стандарта. Если вам нужна реализация чисто функционального программирования, Haskell может быть лучшим выбором).
Императив: вычисление выполняется как прямое изменение состояния программы. Этот стиль особенно полезен при манипулировании структурами данных и создает элегантный, но простой код. Python полностью реализует эту парадигму.
Объектно-ориентированный: полагается на поля данных, которые рассматриваются как объекты и управляются только с помощью предписанных методов. Python не полностью поддерживает эту парадигму, потому что он не может реализовать такие функции, как скрытие данных (инкапсуляция), что, по мнению многих, является основным требованием парадигмы объектно-ориентированного программирования. Этот стиль кодирования также способствует повторному использованию кода.
Процедурный: задачи рассматриваются как пошаговые итерации, когда общие задачи помещаются в функции, которые вызываются по мере необходимости. Этот стиль кодирования поддерживает итерацию, последовательность, выбор и модуляризацию. Python преуспевает в реализации этой конкретной парадигмы.

Четыре стиля, один пример
Обычно вы выбираете определенный стиль кодирования для удовлетворения конкретной потребности, но использование общей проблемы в качестве примера упрощает сравнение различных стилей. Наш пример предназначен для вычисления суммы следующего списка:
my_list = [1, 2, 3, 4, 5]
1. Использование функционального стиля кодирования
Функциональный стиль кодирования рассматривает все как математическое уравнение. Двумя наиболее распространенными способами вычисления суммы my_list было бы использование локальной функции или лямбда-выражения. Вот как это сделать с помощью локальной функции в Python 3.6:
import functools
my_list = [1, 2, 3, 4, 5]
def add_it(x, y):
return (x + y)
sum = functools.reduce(add_it, my_list)
print(sum)

Пакет functools предоставляет доступ к функциям высшего порядка для управления данными. Однако вы не всегда используете его для функционального программирования на Python. Вот простой пример использования my_list с лямбда-функцией:
square = lambda x: x**2
double = lambda x: x + x

print(list(map(square, my_list)))
print(list(map(double, my_list)))

Как видите, лямбда-выражение проще (или, по крайней мере, короче), чем аналогичный процедурный подход. Вот версия лямбда-функции вызова functools.reduce ():
import functools
my_list = [1, 2, 3, 4, 5]
sum = functools.reduce(lambda x, y: x + y, my_list)
print(sum)

2. Использование императивного стиля кодирования
В императивном программировании вы сосредотачиваетесь на том, как работает программа. Программы изменяют информацию о состоянии по мере необходимости для достижения цели. Вот пример использования my_list:
sum = 0
for x in my_list:
sum += x
print(sum)

В отличие от предыдущих примеров, значение суммы изменяется с каждой итерацией цикла. В результате у суммы есть состояние. Когда переменная имеет состояние, что-то должно поддерживать это состояние, что означает, что переменная привязана к определенному процессору. Императивное кодирование работает в простых приложениях, но код выполняется слишком медленно для получения оптимальных результатов в сложных приложениях для обработки данных.
3. Использование объектно-ориентированного стиля кодирования.
Объектно-ориентированное кодирование - это повышение способности приложения повторно использовать код и облегчение его понимания. Инкапсуляция позволяет разработчикам рассматривать код как черный ящик. Использование объектно-ориентированных функций, таких как наследование, упрощает расширение функциональности существующего кода. Вот пример my_list в объектно-ориентированной форме:
class ChangeList(object):
def __init__(self, any_list):
self.any_list = any_list
def do_add(self):
self.sum = sum(self.any_list)
create_sum = ChangeList(my_list)
create_sum.do_add()
print(create_sum.sum)

В этом случае create_sum является экземпляром ChangeList. Внутреннее устройство ChangeList не имеет значения для человека, который его использует. Все, что действительно имеет значение, это то, что вы можете создать экземпляр, используя список, а затем вызвать метод do_add () для вывода суммы элементов списка. Поскольку внутренняя работа скрыта, приложение в целом легче понять.
4. Использование процедурного стиля кодирования
Процедурный стиль основан на вызовах процедур для создания модульного кода. Такой подход упрощает код вашего приложения, разбивая его на небольшие части, которые разработчик может легко просмотреть. Несмотря на то, что процедурное кодирование - более старая форма разработки приложений, это все еще жизнеспособный подход для задач, которые поддаются пошаговому выполнению. Вот пример процедурного стиля кодирования с использованием my_list:
def do_add(any_list):
sum = 0
for x in any_list:
sum += x
return sum
print(do_add(my_list))

В этом случае использование функции do_add () упрощает общий код. Выполнение по-прежнему систематическое, но код легче понять, потому что он разбит на фрагменты. Однако этот код страдает теми же проблемами, что и императивная парадигма, в том смысле, что использование параметров выполнения ограничивает состояние, что означает, что этот подход может неэффективно использовать оборудование при решении сложных проблем.
Выбор стиля кодирования
Разработчики различаются стилями кодирования - у каждого свое мнение о том, какой стиль лучше.
В Python замечательно то, что он позволяет выбрать парадигму программирования, которая лучше всего подходит для вас в данной ситуации. Можно даже смешивать и сопоставлять парадигмы, если вы не забываете ограничивать пакеты входными и выходными данными (сохраняя модульный код). Нет правил, запрещающих комбинировать стили по мере необходимости. Python не останавливается на середине интерпретации вашего приложения и не отображает ошибку, когда вы смешиваете стили.
Если вы не уверены, какой стиль кодирования лучше всего подойдет для данной задачи, попробуйте несколько стилей, чтобы определить, какой из них поможет вам решить проблему быстрее всего и с наименее запутанным кодом. Опять же, вы можете обнаружить, что один стиль на самом деле не решает проблему, и вы захотите включить несколько стилей в одно приложение.
Наконец, когда вы найдете эффективное решение проблемы, обязательно четко задокументируйте его, чтобы вы - или другой программист - могли поработать над ним позже, не изобретая велосипед. Это особенно важно при смешивании стилей программирования, потому что повышение гибкости иногда может снизить ясность.
Если все сделано правильно, решенная сегодня проблема может стать завтра шаблоном, который экономит время с точки зрения выбора правильного стиля программирования Python.