5 дополнительных важных концепций Python, которые необходимо знать

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

# Введение

Python покоряет мир. С момента своего появления более 35 лет назад Python успешно завоевал сердца программистов по всему миру. Python — это мощный универсальный язык программирования с простым синтаксисом, обширным сообществом пользователей и огромным количеством вспомогательных библиотек в своей экосистеме. Это помогло ему стать одним из самых востребованных языков в области анализа данных, машинного обучения и искусственного интеллекта. Более того, начать работу с Python (относительно) несложно . Однако не стоит заблуждаться; вы можете потратить годы на совершенствование своих навыков и освоение основных механизмов языка. Именно поэтому мы сегодня здесь.

В предыдущей статье мы рассмотрели пять основных концепций Python, которые необходимо знать: списковые выражения и генераторы; декораторы; менеджеры контекста (с операторами); освоение *args и **kwargs; и методы с двойным знаком (магические методы). Теперь давайте рассмотрим еще пять фундаментальных концепций, которые должен иметь в своем арсенале каждый разработчик Python.

# 1. Подсказки типов и MyPy

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

// Неуклюжий способ

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

def process_user_profile(user_info): # Какие ключи находятся в user_info? age — это целое число или строка? name = user_info.get(«name», «Guest») age = user_info.get(«age», 0) tags = user_info.get(«tags», []) # Подвержен ошибке выполнения, если tags не является итерируемым объектом строк return f»{name} is {age} years old and tagged with: {', '.join(tags)}» # Сбой во время выполнения, если мы передадим числа в список тегов print(process_user_profile({«name»: «Alice», «age»: «twenty», «tags»: [1, 2]}))

Выход:

Трассировка стека (самый последний вызов): Файл «./testing.py», строка 11, в print(process_user_profile({«name»: «Alice», «age»: «twenty», «tags»: [1, 2]})) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Файл «./testing.py», строка 8, в process_user_profile return f»{name} is {age} years old and tagged with: {', '.join(tags)}» ^^^^^^^^^^^^^^^ TypeError: sequence item 0: expected str instance, int found

// По-питоновски

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

from typing import TypedDict class UserProfile(TypedDict): name: str age: int tags: list[str] def process_user_profile(user_info: UserProfile) -> str: name = user_info.get(«name», «Guest») age = user_info.get(«age», 0) tags = user_info.get(«tags», []) return f»{name} is {age} years old and tagged with: {', '.join(tags)}» # Правильный вызов, соответствующий схеме TypedDict print(process_user_profile({«name»: «Alice», «age»: 28, «tags»: [«Pythonist», «Engineer»]})) # Неправильный вызов, который будет обнаружен статическим анализом process_user_profile({«name»: «Bob», «age»: «thirty», «tags»: [10, 20]})

Результат выполнения статического анализа MyPy через mypy :

testing.py:18: ошибка: Несовместимые типы (выражение имеет тип «str», элемент TypedDict «age» имеет тип «int») [typeddict-item] testing.py:18: ошибка: Элемент списка 0 имеет несовместимый тип «int»; ожидался «str» [list-item] testing.py:18: ошибка: Элемент списка 1 имеет несовместимый тип «int»; ожидался «str» [list-item] Обнаружено 3 ошибки в 1 файле (проверен 1 исходный файл)

Использование аннотаций типов делает ваш код самодокументируемым, позволяя IDE обеспечивать безупречное автозавершение кода и мгновенно выделять ошибки. Интеграция MyPy в ваш конвейер CI/CD гарантирует блокировку несоответствий типов до того, как ваш код приблизится к стадии разработки.

# 2. Инструменты функционального программирования

Хотя Python в основном является объектно-ориентированным языком, он обладает мощными возможностями функционального программирования. Освоение таких инструментов, как map(), filter() и модуль itertools из стандартной библиотеки, позволяет элегантно, высокоэффективно и с минимальным потреблением памяти обрабатывать большие наборы данных.

// Неуклюжий способ

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

transactions = [ {«dept»: «IT», «amount»: 100}, {«dept»: «HR», «amount»: 50}, {«dept»: «IT», «amount»: 200}, {«dept»: «HR», «amount»: 150}, ] # Ручная группировка и суммирование grouped_data = {} for t in transactions: dept = t[«dept»] if dept not in grouped_data: grouped_data[dept] = 0 grouped_data[dept] += t[«amount»] print(grouped_data)

// По-питоновски

Используя функциональные инструменты, мы можем сортировать, группировать и вычислять итоговые значения в чистом конвейере. Мы также будем использовать itertools.chain для преобразования вложенных итерируемых объектов в плоскую структуру без накладных расходов на копирование:

from itertools import groupby, chain from operator import itemgetter transactions = [ {«dept»: «IT», «amount»: 100}, {«dept»: «HR», «amount»: 50}, {«dept»: «IT», «amount»: 200}, {«dept»: «HR», «amount»: 150}, ] # Для работы groupby требуется предварительная сортировка списка по ключу группировки sorted_tx = sorted(transactions, key=itemgetter(«dept»)) # Элегантная группировка и суммирование в одном генераторе списков department_totals = { dept: sum(t[«amount»] for t in group) for dept, group in groupby(sorted_tx, key=itemgetter(«dept»)) } print(department_totals) # Важный нюанс: мгновенное сглаживание списков с помощью itertools.chain nested_ids = [[101, 102], [201, 202], [301]] flat_ids = list(chain.from_iterable(nested_ids)) print(f»Flattened: {flat_ids}»)

Выход:

{'HR': 200, 'IT': 300} {'HR': 200, 'IT': 300} Сглажено: [101, 102, 201, 202, 301]

Функциональные конвейеры не только чище, но и часто быстрее, поскольку итерации переносятся в высокооптимизированные внутренние механизмы на уровне C. Кроме того, такие инструменты, как цепочки процессов, обрабатывают элементы лениво, сводя к минимуму накладные расходы на память.

# 3. Классы и наследование

Python поддерживает множественное наследование, позволяя классу наследовать от нескольких родительских классов. Однако это приводит к классической проблеме «ромба», когда Python должен определить, метод какого родительского класса следует выполнить первым. Для управления таким кооперативным наследованием Python использует алгоритм, называемый линеаризацией C3, для вычисления порядка разрешения методов (MRO).

// Неуклюжий способ

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

class Base: def __init__(self): print(«Base Init») class A(Base): def __init__(self): Base.__init__(self) print(«A Init») class B(Base): def __init__(self): Base.__init__(self) print(«B Init») class C(A, B): def __init__(self): A.__init__(self) B.__init__(self) print(«C Init») # Инициализация Base будет выполнена дважды c = C()

Выход:

Базовая инициализация A Инициализация Базовая инициализация B Инициализация C Инициализация

// По-питоновски

Использование кооперативного наследования с помощью super() гарантирует, что каждый конструктор в цепочке наследования будет вызван ровно один раз, с соблюдением вычисленного списка MRO:

class Base: def __init__(self): print(«Base Init») class A(Base): def __init__(self): super().__init__() print(«A Init») class B(Base): def __init__(self): super().__init__() print(«B Init») class C(A, B): def __init__(self): super().__init__() print(«C Init») # Инициализация Base выполняется ровно один раз c = C() # Проверка порядка разрешения методов (MRO) print(«nПорядок разрешения методов:») for cls in C.__mro__: print(f» -> {cls}»)

Выход:

Базовая инициализация B Инициализация A Инициализация C Порядок разрешения методов инициализации: -> -> -> -> ->

Обратите внимание, что при кооперативном наследовании метод super().__init__() внутри класса A фактически вызывает конструктор класса B, а не класса Base. Это связано с тем, что super() ищет следующий класс в вычисленном MRO, что делает динамическое множественное наследование предсказуемым и надежным.

# 4. Сопоставление структурных шаблонов

В течение многих лет разработчики на Python полагались на многочисленные блоки if-elif-else для маршрутизации логики в зависимости от структуры данных. Хотя это и работает, это приводит к многословному и трудноподдерживаемому коду при работе со сложными вложенными структурами, такими как JSON-данные или разобранные синтаксические деревья. В Python 3.10 было введено структурное сопоставление с шаблонами с помощью match/case. Это далеко не просто оператор switch, а мощный инструмент деконструкции, который сопоставляет как значения, так и структуру ваших данных.

// Неуклюжий способ

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

def handle_event(event): if not isinstance(event, dict): return «Неверный формат события» event_type = event.get(«type») if event_type == «login»: user = event.get(«user») if user: return f»Пользователь {user} вошел в систему» elif event_type == «payment»: amount = event.get(«amount») currency = event.get(«currency», «USD») if isinstance(amount, (int, float)): return f»Обработан платеж в размере {amount} {currency}» elif event_type == «logout»: return «Пользователь вышел из системы» return «Неизвестное или некорректное событие»

// По-питоновски

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

def handle_event(event: dict) -> str: match event: case {«type»: «login», «user»: str(user)}: return f»Пользователь {user} вошел в систему» case {«type»: «payment», «amount»: int(amt) | float(amt), «currency»: str(curr)}: return f»Обработан платеж в размере {amt} {curr}» case {«type»: «payment», «amount»: int(amt) | float(amt)}: # Резервный вариант оплаты, если валюта отсутствует (по умолчанию USD) return «Оплачено в размере {amt} USD» case {«type»: «logout»}: return «Пользователь вышел из системы» case _: return «Неизвестное или некорректное событие» print(handle_event({«type»: «payment», «amount»: 250, «currency»: «EUR»})) print(handle_event({«type»: «login», «user»: «Alice»})) print(handle_event({«type»: «payment», «amount»: «invalid»}))

Выход:

Платеж в размере 250 евро обработан. Пользователь Alice авторизован. Неизвестное или некорректное событие.

Структурное сопоставление с образцом связывает переменные (например, user или amt) на лету только в том случае, если шаблон успешно совпадает, исключая шаблонную логику извлечения и проверки. Это особенно полезно при создании компиляторов, конечных автоматов и сложных конвейеров обработки данных.

# 5. Виртуальные среды и управление зависимостями

Каждый разработчик на Python начинает с глобальной установки пакетов с помощью команды `pip install package_name`. Со временем разные проекты требуют конфликтующих версий библиотек, что приводит к «ада зависимостей». Хотя стандартные виртуальные среды и базовые файлы requirements.txt обеспечивают элементарную изоляцию, им не хватает файлов блокировки, гарантирующих полную детерминированность транзитивных (под)зависимостей в разных средах. Для создания надежных и воспроизводимых систем следует перейти на современные инструменты управления, такие как Poetry или Conda.

// Современный стандарт применения (поэзия)

Poetry объединяет конфигурацию, упаковку и зависимости в один чистый файл pyproject.toml и поддерживает строгий файл poetry.lock, который фиксирует все дерево окружения вплоть до контрольных сумм каждого подпакета:

[tool.poetry.dependencies] python = «^3.10» requests = «^2.31.0» pandas = «^2.1.0»

А вот команды для создания, блокировки и запуска сред:

$ poetry init $ poetry install $ poetry run python main.py

// Современный стандарт науки о данных (Conda)

Для современных задач обработки данных пакеты часто зависят от бинарных файлов, отличных от Python (например, библиотек C++, драйверов CUDA или наборов линейной алгебры BLAS). Conda — это среда и менеджер пакетов, предназначенный для беспрепятственной изоляции и развертывания этих бинарных файлов. Внутри файла environment.yaml:

имя: ml_env каналы: — conda-forge зависимости: — python=3.10 — numpy=1.24 — pytorch-gpu

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

$ conda env create -f environment.yml $ conda activate ml_env

Пример выходных данных (при запуске poetry):

Разрешение зависимостей… Запись файла блокировки… Успешно заблокировано 24 зависимости.

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

# Завершение

Освоение этих пяти концепций знаменует переход от написания скриптов к созданию программного обеспечения. Используя подсказки типов для обеспечения безопасности кода, выбирая правильные модели параллельного выполнения для повышения скорости, применяя функциональные инструменты для элегантных потоков данных, соблюдая принцип MRO (Multiple Reduction of Objective-Resource) в объектно-ориентированных структурах и используя современные системы среды для обеспечения воспроизводимости, вы поднимаете свой инструментарий Python до профессиональных инженерных стандартов.

Мэтью Мэйо ( @mattmayo13 ) имеет степень магистра компьютерных наук и диплом специалиста по анализу данных. Будучи главным редактором KDnuggets & Statology и внештатным редактором Machine Learning Mastery, Мэтью стремится сделать сложные концепции науки о данных доступными для всех. В сферу его профессиональных интересов входят обработка естественного языка, языковые модели, алгоритмы машинного обучения и изучение новых технологий искусственного интеллекта. Его движет стремление демократизировать знания в сообществе специалистов по науке о данных. Мэтью занимается программированием с 6 лет.

Источник: www.kdnuggets.com