functools и lru_cache [Часть 1]

🔍Модуль functools в Python предоставляет инструменты для работы с функциями высшего порядка, то есть функциями, которые действуют на другие функции или возвращают их в качестве результатов. Этот модуль помогает сократить код и улучшить его читаемость.

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

from functools import lru_cache

@lru_cache(maxsize=32)
def expensive_func(num):
⠀⠀print(f"Вычисляется для: {num}")
⠀⠀return num * num  # Просто пример, представьте здесь дорогое вычисление

🔗 Использование lru_cache идеально подходит для функций с дорогими вычислениями и повторяющимися входными данными. maxsize определяет, сколько последних вызовов будет сохранено. Если maxsize установлено как None, кэш будет неограниченным. Однако помните, что это может привести к значительному использованию памяти.

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

🔝 PyBytes Media | ✉️ Telegram / 📷 Instagram / 📈Mentor Service

5 команд Python, которые упростят вашу жизнь [Спецвыпуск]

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

🔍 dir() - показывает все методы и атрибуты объекта. Отличный способ исследовать неизвестные библиотеки или объекты.

🔖 help() - предоставляет справку по модулям, функциям, классам. Неоценимый инструмент для изучения и отладки.

🥶globals() - возвращает словарь текущего глобального символьного пространства. Это помогает понять, какие глобальные переменные активны в вашем коде.

📦locals() - аналогично globals(), но для локального пространства имен. Используйте его, чтобы увидеть переменные внутри функции или области видимости.

〰️zip() - объединяет элементы из нескольких итераторов (списков, кортежей). Создает пары или группы элементов, которые можно использовать в циклах.


🔝 PyBytes Media | ✉️ Telegram / 📷 Instagram / 📈Mentor Service

functools: reduce и partial [Часть 2]

🔄 Функция reduce из модуля functools применяется для свертки итерируемого объекта в одно значение, выполняя указанную функцию последовательно. Это мощный инструмент для агрегации данных.

☹️ Рассмотрим пример, где мы используем reduce для вычисления факториала числа:

from functools import reduce

def multiply(x, y):
⠀⠀return x * y

factorial = reduce(multiply, range(1, 6))  # Вычисляем 5!
print(factorial)  # Выведет 120

💃 Теперь давайте введем partial из того же модуля. partial помогает создать новую версию функции с одним или несколькими аргументами, уже "префиксированными". Это полезно для создания новых функций на основе существующих, но с заранее заданными параметрами.

🔍 Используем partial, чтобы создать функцию для умножения любого числа на 5:

from functools import partial

multiply_by_five = partial(multiply, 5)  # Первый аргумент функции multiply теперь всегда 5
print(multiply_by_five(10))  # Выведет 50

🎤 Объединение reduce и partial в одном примере может показаться неочевидным, но оба они служат уникальным целям: reduce для агрегации значений, а partial для создания новых функций с фиксированными параметрами. Вместе они могут сильно упростить и оптимизировать ваш код.

🔝 PyBytes Media | ✉️ Telegram / 📷 Instagram / 📈Mentor Service

functools: wraps и cache [Часть 3]

🔗 Декоратор wraps из модуля functools используется в создании собственных декораторов. Он помогает сохранить метаданные декорируемой функции, такие как имя, документация и список параметров. Это важно для поддержания читаемости и правильного функционирования инструментов, основанных на этих метаданных.

from functools import wraps

def my_decorator(f):
    @wraps(f)
    def wrapper(*args, **kwargs):
⠀⠀        print("Что-то происходит перед вызовом функции.")
⠀⠀        result = f(*args, **kwargs)
⠀⠀        print("Что-то происходит после вызова функции.")
⠀⠀        return result
    return wrapper

@my_decorator
def example():
⠀⠀print("Пример функции.")

📀 Другой полезный инструмент — cache, похож на lru_cache, но без ограничений на размер кеша. Это удобно для кеширования результатов функций с неограниченным количеством уникальных вызовов.

from functools import cache

@cache
def expensive_calculation(num):
⠀⠀print(f"Вычисляется для: {num}")
⠀⠀return num * num  # Пример дорогого вычисления

🛠 Использование wraps и cache значительно улучшает удобство и эффективность написания декораторов и работы с кешированием в Python. Эти инструменты делают код более читабельным, понятным и производительным.

🔝 PyBytes Media | ✉️ Telegram / 📷 Instagram / 📈Mentor Service

Различие между Iterable и Iterator

😎В Python, Iterable и Iterator играют ключевые роли в итерации, но они выполняют разные функции.

- Iterable - это объект, который можно превратить в итератор. Это могут быть списки, словари, кортежи и т.д. Они поддерживают итерацию, но не сохраняют состояние итерации. Главное - наличие метода iter.

- Iterator - это продвинутый объект, сохраняющий состояние итерации и позволяющий перебирать элементы один за другим. Он имеет методы iter и next.

import collections
print(issubclass(list, collections.Iterator))  # False

Этот код демонстрирует, что список (list) не является итератором, так как не проходит проверку на подкласс Iterator.

🔄 Для преобразования iterable в iterator используется функция iter(). Iterator можно итерировать только один раз.

numbers = [1, 2, 3]
numbers_iter = iter(numbers)

print(next(numbers_iter))  # 1
print(next(numbers_iter))  # 2
print(next(numbers_iter))  # 3
try:
⠀⠀print(next(numbers_iter))  # Вызовет исключение StopIteration
except StopIteration:
⠀⠀print("Итерация завершена.")

💡 Это ключевой момент, указывающий на одноразовое использование итераторов. После завершения обхода всех элементов, итератор становится пустым, и для новой итерации нужно создавать новый итератор.

🔝 PyBytes Media | ✉️ Telegram / 📷 Instagram / 📈Mentor Service

TypeVar: Основы и определение [Часть 1]

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

from typing import TypeVar

T = TypeVar('T')  # Объявление TypeVar

🔍Использование TypeVar позволяет функциям принимать параметры разных типов, сохраняя при этом строгую типизацию. Это особенно полезно в обобщенных функциях и классах.

def identity(value: T) -> T:
⠀⠀return value

📈В этом примере функция identity может принимать и возвращать значение любого типа, сохраняя его тип между входом и выходом. Это позволяет использовать одну и ту же функцию с различными типами данных, не теряя при этом информации о типе (которая сохраняется в статистическом анализаторе, на пример PyCharm или MyPy)

😎Использование TypeVar в Python делает код более гибким и понятным, а также помогает избежать ошибок, связанных с типизацией. Это ключевая особенность для создания эффективных и безопасных обобщенных типов.

🔝 PyBytes Media | ✉️ Telegram / 📷 Instagram / 📈Mentor Service

TypeVar: Ограничения [Часть 2]

🍤В Python, TypeVar может быть ограничен, что позволяет указать, какие типы могут быть использованы. Это делает код более безопасным и предсказуемым, ограничивая типы, которые могут быть переданы в функцию или класс.

from typing import TypeVar

T = TypeVar('T', int, float)  # Ограничение TypeVar значениями типов int и float

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

def sum_numbers(a: T, b: T) -> T:
⠀⠀return a + b

📊В этом примере функция sum_numbers может принимать только целые числа или числа с плавающей точкой. Попытка передать значения других типов приведет к ошибке типизации.

🛠Ограничения TypeVar полезны для создания API, где важно контролировать типы входных и выходных данных. Это помогает обеспечить корректность работы программы и упрощает отладку.

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


🔝 PyBytes Media | ✉️ Telegram / 📷 Instagram / 📈Mentor Service

Как Python создает объекты [Часть 1]

🚀Понимание процесса создания объектов в Python критически важно для глубокого освоения языка и разработки эффективного кода. Объекты - это основа ООП (Объектно-Ориентированного Программирования), а Python - язык с динамической типизацией, где все является объектом.

🔍 При создании объекта Python сначала вызывает метод new класса. Этот метод отвечает за выделение памяти для объекта. Он возвращает новый, еще не инициализированный объект указанного класса. Этот этап важен, поскольку позволяет контролировать процесс выделения памяти, что может быть полезно в более сложных сценариях создания объектов.

class MyClass:
⠀⠀def __new__(cls):
⠀⠀⠀⠀print("Создание объекта")
⠀⠀⠀⠀return super().__new__(cls)

🛠 Затем Python вызывает метод init этого объекта, который отвечает за инициализацию нового объекта. В этом методе происходит настройка объекта, например, присвоение начальных значений атрибутам.

class MyClass:
⠀⠀def __init__(self):
⠀⠀⠀⠀print("Инициализация объекта")
⠀⠀⠀⠀self.attribute = "Значение"

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

🔝 PyBytes Media | ✉️ Telegram / 📷 Instagram / 📈Mentor Service

Создание обобщенных классов в Python [Часть 1]

ℹ️ Обобщенные классы в Python — это фундамент для создания гибких и типобезопасных структур данных. Их использование критически важно в крупных проектах для обеспечения читаемости и поддерживаемости кода.

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

Пример простого обобщенного класса:

from typing import Generic, TypeVar

T = TypeVar('T')
class Box(Generic[T]):
⠀⠀def __init__(self, item: T):
⠀⠀⠀⠀self.item = item

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

🔝 PyBytes Media | ✉️ Telegram / 📷 Instagram / 📈Mentor Service

Метаклассы в Python [Часть 1]

🔍Метаклассы - это "классы классов". Они определяют правила и поведение для классов так же, как обычные классы определяют поведение для своих экземпляров. Это может показаться запутанным, но на самом деле метаклассы играют важную роль в Python, позволяя нам контролировать создание классов на более глубоком уровне.

☕️ Зачем они нужны? Прежде всего, метаклассы используются для создания API, которые могут интерактивно модифицировать или расширять поведение классов. Например, они могут добавлять новые методы или атрибуты, а также вмешиваться в процесс наследования классов.

class Meta(type):
⠀⠀pass

class MyClass(metaclass=Meta):
⠀⠀pass

🛠 В этом базовом примере Meta является метаклассом для MyClass. Пока Meta не добавляет никакой функциональности, он служит хорошим стартом для понимания структуры метаклассов.

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

🔝 PyBytes Media | ✉️ Telegram / 📷 Instagram / 📈Mentor Service

🛠 Новый проект: 👉 КЛИК


➡️ next.js
➡️ tailwind
➡️ effector
➡️ python
➡️ sqlalchemy
➡️ postgres
➡️ typing
➡️ pydantic
➡️ fastapi


🔝 PyBytes Media | ✉️ Telegram / 📷 Instagram / 📈Mentor Service

Метаклассы в Python [Часть 2]

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

🫡 Процесс создания класса: Обычно, когда вы определяете класс, Python следует трём шагам:
1. Он определяет все атрибуты класса.
2. Он создает пространство имен для этих атрибутов.
3. Он связывает имя класса с этим пространством имен.

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

class Meta(type):
⠀⠀def __new__(cls, name, bases, dct):
⠀⠀⠀⠀# Добавляем новый метод к классу
⠀⠀⠀⠀dct['new_method'] = lambda self: 'Hello'
⠀⠀⠀⠀return super().__new__(cls, name, bases, dct)
⠀⠀
class MyClass(metaclass=Meta):
⠀⠀pass
⠀⠀
# MyClass теперь имеет new_method
print(MyClass().new_method())  # Выведет 'Hello'

🛠 Этот пример показывает, как метакласс Meta добавляет метод new_method ко всем классам, для которых он используется как метакласс. Это демонстрирует, как метаклассы могут модифицировать или расширять классы в Python.

☝️ В прикрепленной картинке вы найдете часто встречающийся пример использования метаклассов - паттерн Singleton.

🔝 PyBytes Media | ✉️ Telegram / 📷 Instagram / 📈Mentor Service

Logging в Python [Часть 1]

😈 Мы все любим использовать print для отладки и понимания того, что происходит в нашем коде. Это как оставлять себе небольшие записки, чтобы не забыть, как работает наша программа. Однако, постоянное добавление и удаление этих print может превратиться в хаос, особенно когда проект растет.

📌 Когда дело доходит до серьезной разработки, использование print становится плохой практикой. Оно не предлагает уровней гранулярности или гибкости, которые предоставляет logging. С logging вы можете устанавливать уровни сообщений, фильтровать их и направлять в различные места, не изменяя код.

import logging
logging.basicConfig(level=logging.INFO)
logging.info("This is an info message")

🔄 Заменить print на logging не только улучшит читаемость кода, но и позволит вам контролировать, какие сообщения отображаются, когда и где. Это особенно важно для больших проектов или при работе в команде.

🛠 Попробуйте использовать разные уровни логирования, такие как DEBUG, INFO, WARNING, ERROR, и CRITICAL, для более эффективного управления выводом вашего кода. Таким образом, вы сможете легко отличить важные сообщения от обычных уведомлений.

🔝 PyBytes Media | ✉️ Telegram / 📷 Instagram / 📈Mentor Service

Введение в асинхронное программирование в Python [Часть 1]

🔍 Асинхронное программирование в Python начало набирать популярность с введением модуля asyncio. Это парадигма, позволяющая программам выполнять множество задач одновременно, что особенно полезно для I/O задач, таких как веб-запросы, чтение и запись файлов.

🔄 Традиционное синхронное программирование предполагает выполнение кода построчно, одну задачу за другой. Это может приводить к неэффективному использованию ресурсов, когда процесс ждет завершения операции ввода/вывода.

import time
⠀⠀
def count():
⠀⠀print("Один")
⠀⠀time.sleep(1)  # Имитация длительной операции
⠀⠀print("Два")
⠀⠀
def main():
⠀⠀for _ in range(3):
⠀⠀⠀⠀count()
⠀⠀
main()

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

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

🔝 PyBytes Media | ✉️ Telegram / 📷 Instagram / 📈Mentor Service

Основы `asyncio`: Event loop и корутины [Часть 2]

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

💡Корутины - это особые функции, выполнение которых можно приостановить и возобновить в любой момент. Они определяются с помощью синтаксиса async def и предназначены для использования с await, который приостанавливает выполнение корутины, позволяя Event loop обрабатывать другие задачи.

import asyncio
⠀⠀
async def hello():
⠀⠀print('Hello')
⠀⠀await asyncio.sleep(1)
⠀⠀print('World')

➡️Важно понимать, что корутины сами по себе не выполняются автоматически. Для их выполнения они должны быть переданы в Event loop с помощью функций asyncio.run(), loop.create_task() или через ожидание с await.

asyncio.run(hello())

💫 Понимание этих основ является ключевым для глубокого изучения асинхронного программирования в Python. В следующих частях мы рассмотрим, как работать с асинхронными функциями и управлять асинхронными задачами.

🔝 PyBytes Media | ✉️ Telegram / 📷 Instagram / 📈Mentor Service

Работа с асинхронными функциями: `await`, `async with`, `async for` [Часть 3]


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

async def fetch_data():
⠀⠀# Представим, что это асинхронный запрос к базе данных
⠀⠀await asyncio.sleep(2)  # Задержка имитирует время ожидания данных
⠀⠀return {'data': 1}

async def main():
⠀⠀data = await fetch_data()
⠀⠀print(data)

🔓Асинхронный контекстный менеджер async with используется для гарантии корректного управления асинхронными ресурсами, такими как открытие и закрытие файлов или соединений с базой данных.

async def read_file():
⠀⠀async with aiofiles.open('filename', 'r') as f:
⠀⠀⠀⠀content = await f.read()
⠀⠀⠀⠀print(content)

🔄Асинхронный итератор async for используется для итерации по асинхронно генерируемым последовательностям, например, при постепенном получении данных из веб-сервиса.

async def get_data():
⠀⠀for i in range(5):
⠀⠀⠀⠀await asyncio.sleep(1)
⠀⠀⠀⠀yield i

async def main():
⠀⠀async for item in get_data():
⠀⠀⠀⠀print(item)

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

🔝 PyBytes Media | ✉️ Telegram / 📷 Instagram / 📈Mentor Service

Создание и управление задачами в "asyncio" [Часть 4]

❤️В асинхронном программировании под задачами понимаются запущенные корутины, которые управляются event loop. С помощью asyncio, можно не только запускать корутины, но и создавать задачи, которые позволяют более гибко управлять асинхронными операциями.

async def count():
⠀⠀print("One")
⠀⠀await asyncio.sleep(1)
⠀⠀print("Two")

🚀Чтобы запустить корутину как задачу, используйте asyncio.create_task(). Это позволит вашей программе продолжать выполнение, не дожидаясь окончания корутины.

async def main():
⠀⠀# Создание задачи
⠀⠀task = asyncio.create_task(count())
⠀⠀print("Counting...")
⠀⠀# Дождемся выполнения задачи
⠀⠀await task

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

async def main():
⠀⠀task = asyncio.create_task(count())
⠀⠀await asyncio.sleep(0.5)
⠀⠀task.cancel()
⠀⠀try:
⠀⠀⠀⠀await task
⠀⠀except asyncio.CancelledError:
⠀⠀⠀⠀print("Task was cancelled!")

❤️‍🔥Создание задач в asyncio открывает новые возможности для более эффективного и гибкого управления асинхронными операциями. В следующей части мы рассмотрим примеры реального использования asyncio и распространенные паттерны.

🔝 PyBytes Media | ✉️ Telegram / 📷 Instagram / 📈Mentor Service