Реальный Python
@python_real
3.81K subscribers
805 photos
10 videos
7 files
852 links
Все о пайтон, новости, подборки на русском и английском. По всем вопросам @evgenycarter
Download Telegram
About
Blog
Apps
Platform
Join
Реальный Python
3.81K subscribers
Реальный Python
Улучшаем логирование в Python с Loguru

Встроенный модуль logging в Python мощный, но довольно многословный и требует много шаблонного кода. Библиотека Loguru упрощает логирование, предлагая удобный и мощный API. Основные особенности и как начать использовать Loguru.

🔹Установка


pip install loguru


🔹Простой пример


from loguru import logger

logger.debug("Отладочное сообщение")
logger.info("Информационное сообщение")
logger.success("Сообщение об успешной операции")
logger.warning("Предупреждение")
logger.error("Ошибка")
logger.critical("Критическая ошибка")


Loguru автоматически добавляет:

* временную метку,
* уровень лога,
* путь к файлу и номер строки,
* и форматирует вывод по умолчанию.

🔹Удаление стандартного логгера

По умолчанию Loguru добавляет логгер в sys.stderr. Можно удалить его и добавить свой:


logger.remove()
logger.add("file.log", rotation="1 MB", compression="zip")


Здесь:

* rotation — лог будет разбит на части при достижении 1 МБ,
* compression — старые логи будут архивироваться в zip.

🔹Форматирование логов

Loguru позволяет настраивать формат:


logger.add("log.txt", format="{time} {level} {message}", level="INFO")


Можно использовать кастомные форматеры и сериализацию в JSON.

🔹Перехват исключений

Loguru умеет автоматически логировать исключения:


@logger.catch
def divide(a, b):
    return a / b

divide(1, 0)


Это логирует traceback без необходимости писать try/except.

🔹Интеграция со стандартным логированием

Можно перенаправить стандартный logging в Loguru:


import logging
from loguru import logger

class InterceptHandler(logging.Handler):
    def emit(self, record):
        logger_opt = logger.opt(depth=6, exception=record.exc_info)
        logger_opt.log(record.levelname, record.getMessage())

logging.basicConfig(handlers=[InterceptHandler()], level=0)


🔹Заключение

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


https://realpython.com/python-loguru/

#python

👉 @python_real
Please open Telegram to view this post
VIEW IN TELEGRAM
👍5❤1
924 views
Реальный Python
📊 Группировка данных в Polars с помощью `groupby`

Polars — это высокопроизводительная библиотека для анализа данных на Python. Она особенно хороша при работе с большими объемами данных, благодаря своей колонко-ориентированной архитектуре и использованию Rust под капотом.

Одним из ключевых инструментов для агрегации и анализа данных является метод .groupby().

Основы .groupby()

Пример базовой группировки:


import polars as pl

df = pl.DataFrame({
    "city": ["London", "London", "Oslo", "Oslo", "Berlin", "Berlin"],
    "year": [2020, 2021, 2020, 2021, 2020, 2021],
    "value": [100, 150, 200, 220, 50, 80],
})

result = df.groupby("city").agg([
    pl.col("value").mean().alias("average_value")
])
print(result)


Группировка по нескольким колонкам

Можно сгруппировать по нескольким признакам:


df.groupby(["city", "year"]).agg([
    pl.col("value").sum().alias("total_value")
])


Использование выражений

Polars поддерживает ленивое выполнение (lazy evaluation) и мощную систему выражений:


df.groupby("city").agg([
    (pl.col("value") * 2).mean().alias("double_avg")
])


Методы .groupby() в ленивом API

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


df_lazy = df.lazy()
result = df_lazy.groupby("city").agg([
    pl.col("value").sum().alias("total")
])


Для запуска вычислений используется .collect():


result.collect()


Применение .groupby_dynamic() и .groupby_rolling()

Эти методы полезны при работе с временными рядами:

* groupby_dynamic: для агрегирования по фиксированным временным интервалам (например, по дням, неделям).
* groupby_rolling: для скользящего окна (например, скользящее среднее за 7 дней).

Пример:


df = pl.DataFrame({
    "timestamp": pl.date_range(low=datetime(2022,1,1), high=datetime(2022,1,10), interval="1d"),
    "value": range(10)
})

df.groupby_rolling(index_column="timestamp", period="3d").agg([
    pl.col("value").mean().alias("rolling_avg")
])


https://realpython.com/polars-groupby/

#python

👉 @python_real
👍3
842 views
Реальный Python
Вложенные циклы в Python

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

Начало работы с вложенными циклами

В Python есть два основных типа циклов — for и while.

* for -цикл проходит по элементам последовательности (списка, диапазона и т. д.), когда количество итераций известно заранее.
* while -цикл выполняется, пока истинно заданное условие, и полезен, когда число итераций заранее не определено.

Вложенный цикл создаётся размещением одного цикла внутри другого:


for outer_variable in outer_iterable:
    for inner_variable in inner_iterable:
        <body>


Для каждой итерации внешнего цикла внутренний выполняется полностью.

Аналогия: часовая и минутная стрелки часов. Часовая проходит круг за 12 часов, минутная — за 1 час, но работают они совместно.


for hour in range(24):
    for minute in range(60):
        print(f"{hour:02d}:{minute:02d}")


Практические примеры

Печать шаблонов


height = 6
sail_patterns = "*#-x+o"
for row in range(height):
    pattern = ""
    spacing = " " * (height - row)
    for symbol in sail_patterns:
        pattern += symbol * row + spacing
    print(pattern)


Таблица умножения


for multiplicant in range(1, 11):
    for multiplier in range(1, 4):
        expression = f"{multiplicant:>2d} × {multiplier}"
        product = multiplicant * multiplier
        print(f"{expression} = {product:>2d}", end="\t")
    print()


Суммирование элементов во вложенных списках


resource_donators = [
    [8, 6, 3],
    [9, 2, 7],
    [4, 1, 5]
]
total_resources = 0
for planet in resource_donators:
    for resource in planet:
        total_resources += resource
print(total_resources)  # 45


Парные комбинации без самих себя


players = ["Bonnie", "Mike", "Raj", "Adah"]
for player1 in players:
    for player2 in players:
        if player1 != player2:
            print(f"{player1} vs {player2}")


Вложенный while


while True:
    word = input("Введите слово (exit — для выхода): ")
    if word == "exit":
        break
    for letter in word:
        print(letter)


Частые проблемы вложенных циклов

* Область видимости переменных. Не используйте одинаковые имена во внешнем и внутреннем циклах.
* Читаемость. Глубокая вложенность усложняет понимание кода.
* Производительность. Каждый дополнительный уровень увеличивает временную сложность (часто до O(n²) и выше).

Оптимизация

* break и continue позволяют досрочно завершать цикл или пропускать ненужные итерации.
* List Comprehension делает выражения компактнее, хотя не всегда улучшает производительность.


# Поиск "bacon" с break
for layer in blt_sandwich:
    for ingredient in layer:
        if ingredient == target:
            print("Found bacon!")
            break
    if target in layer:
        break


Вывод

Вложенные циклы — мощный инструмент для работы с многомерными данными и повторяющимися задачами. Однако злоупотребление ими ухудшает читаемость и скорость. Используйте их осознанно, оптимизируйте при помощи break, continue и list comprehension, и никогда не забывайте о сложности алгоритма.

https://realpython.com/nested-loops-python/

#python

👉 @python_real
👍4❤2
1.02K views
Реальный Python
Как найти абсолютное значение в Python

В Python для чисел, массивов и собственных объектов используется встроенная функция abs(). В этом кратком руководстве вы узнаете:

* Как реализовать абсолютную функцию вручную.
* Как работает abs() с разными типами данных.
* Как расширить abs() для NumPy, pandas и своих классов.


1. Самостоятельная реализация


def absolute_value(x):
    return x if x >= 0 else -x


Или через max:


def absolute_value(x):
    return max(x, -x)


Через корень:


def absolute_value(x):
    return (x**2) ** 0.5  # возвращает float


Но проще и эффективнее пользоваться abs().


2. Встроенная функция abs()

🔸Для целых и вещественных чисел сохраняет тип:


  abs(-5)    # 5
  abs(-5.2)  # 5.2

🔸Для комплексных чисел возвращает модуль:


  z = 3 + 4j
  abs(z)     # 5.0

🔸Для Fraction и Decimal тоже работает «из коробки»:


  from fractions import Fraction
  abs(Fraction(-3, 4))      # Fraction(3, 4)

  from decimal import Decimal
  abs(Decimal("-0.75"))     # Decimal('0.75')



3. Применение к коллекциям

Если у вас список чисел, используйте списковое включение или map:


temps = [1, -5, 3, -2]
[abs(x) for x in temps]        # [1, 5, 3, 2]
list(map(abs, temps))          # [1, 5, 3, 2]



4. NumPy и pandas

🔸NumPy:


  import numpy as np
  arr = np.array([-1, -4, 0, 7])
  abs(arr)                      # array([1, 4, 0, 7])

🔸pandas:


  import pandas as pd
  data = pd.Series([-2, 5, -3])
  abs(data)                     # Series([2, 5, 3])



5. Собственные классы

Чтобы abs() работал для объектов вашего класса, определите метод .__abs__():


import math

class Vector:
    def __init__(self, *coords):
        self.coords = coords

    def __abs__(self):
        return math.hypot(*self.coords)

v = Vector(3, 4)
abs(v)                          # 5.0



Вывод:

🔸Для чисел abs() – оптимальный выбор.
🔸Для списков применяйте map или генератор списка.
🔸NumPy и pandas позволяют вызывать abs() прямо на массивах и DataFrame.
🔸Для собственных типов реализуйте .__abs__().

https://realpython.com/python-absolute-value/

#python

👉 @python_real
❤3👍3
897 views
Реальный Python
Определение собственной функции в Python

Функции — это фундаментальный строительный блок в Python. Они позволяют организовать код, переиспользовать его и сделать программу более читаемой. Создание собственной функции — это важный шаг на пути к более эффективной разработке.

Основы: def и имя функции

Функции в Python определяются с помощью ключевого слова def, за которым следует имя функции, круглые скобки (в которых можно указать параметры), и двоеточие:


def greet():
    print("Привет!")


Теперь ты можешь вызвать функцию:


greet()


Аргументы и параметры

Ты можешь передавать данные в функцию через параметры:


def greet(name):
    print(f"Привет, {name}!")


Вызов:


greet("Oleg")


Возврат значения

С помощью ключевого слова return можно вернуть результат из функции:


def add(a, b):
    return a + b



result = add(3, 4)
print(result)  # 7


Аргументы по умолчанию

Функции могут иметь параметры с значениями по умолчанию:


def greet(name="друг"):
    print(f"Привет, {name}!")



greet()           # Привет, друг!
greet("Oleg")     # Привет, Oleg!


Именованные аргументы

Можно передавать аргументы явно по имени:


def describe_pet(animal, name):
    print(f"У меня есть {animal}, его зовут {name}.")



describe_pet(animal="кот", name="Барсик")


Возвращение нескольких значений

Функции могут возвращать несколько значений с помощью кортежей:


def get_point():
    return (3, 4)

x, y = get_point()



https://realpython.com/defining-your-own-python-function/

#python

👉 @python_real
👍3
1.05K views
Реальный Python
Python 3.14. T-строки в Python: новый способ работы со строками?

Python предлагает множество способов создания строк — от обычных строк до f-строк и raw-строк. Но начиная с Python 3.12, появляется новый способ: t-строки. Это экспериментальный синтаксис, предлагаемый для улучшения интернационализации (i18n) строк.

В этом посте мы кратко рассмотрим:

🔘 Что такое t-строки?
🔘Зачем они нужны?
🔘Как их использовать?

Что такое t-строки?

t"..." — это новый синтаксис строк, похожий на f-строки, но предназначенный для упрощения перевода строк. Они позволяют использовать интерполяцию переменных и одновременно автоматически отмечать строку как подлежащую переводу.


name = "Алиса"
print(t"Привет, {name}!")


Такой синтаксис эквивалентен:


from gettext import gettext as _
name = "Алиса"
print(_("Привет, {name}!").format(name=name))


Зачем это нужно?

В больших проектах часто нужно поддерживать несколько языков. В Python это обычно делается через gettext, где строки передаются в функцию _() и затем интерполируются вручную:


print(_("Привет, {name}!").format(name=name))


Но такой подход:

- неявный,
- подвержен ошибкам (особенно при интерполяции),
- не всегда дружелюбен к линтерам и инструментам сборки переводов.

t-строки делают этот процесс более чистым и читаемым.

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

t-строки являются экспериментальной функцией в Python 3.12, и для их использования нужно включить feature flag:


from __future__ import tstrings


Полный пример:


from __future__ import tstrings

name = "Алиса"
print(t"Привет, {name}!")


Это даст тот же результат, что и с gettext, но с более читаемым и лаконичным синтаксисом.

Совместимость и текущее состояние

Пока t-строки находятся в стадии эксперимента. Они могут измениться или быть удалены в будущих релизах. Если вы работаете с интернационализацией и переводами — следите за этой фичей. Она может значительно упростить жизнь в будущем.

https://realpython.com/python-t-strings/

#python

👉 @python_real
Please open Telegram to view this post
VIEW IN TELEGRAM
👍3
1.19K views
Реальный Python
Async IO в Python: что это и как с этим работать

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

Ключевые понятия

* Сопрограммы (coroutines) — функции, которые можно приостанавливать и возобновлять.
* Событийный цикл (event loop) — механизм, управляющий выполнением асинхронных задач.
* await — оператор, который приостанавливает выполнение до завершения асинхронной операции.

Пример кода:


import asyncio

async def main():
    print("Начало")
    await asyncio.sleep(1)
    print("Конец")

asyncio.run(main())


Когда использовать async?

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

Когда не стоит использовать?

* Для вычислительно тяжелых задач (лучше использовать multiprocessing).

Асинхронность в Python строится вокруг asyncio, но есть и дополнительные библиотеки (например, aiohttp для асинхронных HTTP-запросов).

https://realpython.com/async-io-python/

#python

👉 @python_real
👍4❤1
807 views
Реальный Python
Python Mixins: мощный инструмент для повторного использования кода

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


Основная идея Mixin

Mixin — это способ «влить» функциональность в класс, комбинируя его с другими классами через множественное наследование.
Например, если у нас есть класс LoggerMixin, он может добавлять возможность логирования в любой класс, который его наследует.


class LoggerMixin:
    def log(self, message):
        print(f"[LOG]: {message}")

class User(LoggerMixin):
    def __init__(self, name):
        self.name = name

user = User("Alice")
user.log("Пользователь создан")  # [LOG]: Пользователь создан



Принципы проектирования Mixin-классов

1. Изолированная функциональность — Mixin должен решать только одну конкретную задачу.
2. Не самостоятельный — Mixin не предназначен для создания экземпляров напрямую.
3. Малые зависимости — Mixin не должен жёстко зависеть от конкретной реализации других классов.
4. Имя — принято добавлять суффикс Mixin в название.


Зачем использовать Mixin

- Повторное использование кода без дублирования.
- Упрощение кода и снижение связности.
- Гибкость при расширении функционала.


Пример: добавление сериализации в JSON


import json

class ToJSONMixin:
    def to_json(self):
        return json.dumps(self.__dict__)

class Point(ToJSONMixin):
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(4, 5)
print(p.to_json())  # {"x": 4, "y": 5}



Когда Mixin лучше не использовать

- Когда поведение может быть реализовано через композицию.
- Если множественное наследование приведёт к сложной и запутанной иерархии.
- Когда Mixin начинает выполнять слишком много функций.


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

https://realpython.com/python-mixin/

#python

👉 @python_real
❤3👍2
549 views
Реальный Python
📂 Как получить список всех файлов в директории на Python

Статья о том, как с помощью Python получать список файлов в директориях. Рассмотрены различные способы, включая использование модулей os, os.path, glob и более современного pathlib.

Особое внимание уделено:
- Фильтрации файлов по расширению.
- Рекурсивному поиску в подпапках.
- Преимуществам каждого подхода.

https://realpython.com/get-all-files-in-directory-python/

#python

👉 @python_real
👍3
441 views
Реальный Python
Getters и Setters в Python — это мощный инструмент для управления доступом к атрибутам объекта.

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

Основные моменты:
- Объяснение, почему в Python прямой доступ к атрибутам предпочтительнее, но геттеры и сеттеры остаются важными.
- Использование декоратора @property для создания свойства с геттером и сеттером.
- Примеры, как эти механизмы помогают улучшить читаемость и безопасность кода.

https://realpython.com/python-getter-setter/

#python

👉 @python_real
👍3
370 views
Реальный Python
Как использовать pyproject.toml в Python

Рассматриваются основные аспекты работы с этим файлом, его структура и как он помогает в управлении зависимостями, настройке инструментов и организации проектов.

Краткий обзор:
- pyproject.toml появился в PEP 518 и стал стандартом для описания конфигурации Python-проектов.
- Позволяет определять сборщики (build backends), такие как setuptools или poetry.
- Упрощает настройку инструментов вроде black, mypy и pytest.
- Дает возможность управлять зависимостями и версиями пакетов.

Использование pyproject.toml делает проекты более структурированными и гибкими, особенно при работе с различными инструментами и системами сборки.

https://realpython.com/python-pyproject-toml/

#python

👉 @python_real
👍2
293 views