✈️Казалось бы, куда еще проще, но есть один интересный пакет JMESpath, который позволяет декларативно указать, как извлекать элементы из документа JSON.

➡️Основные примеры использования:

import jmespath

jmespath.search('foo.bar', {'foo': {'bar': 'baz'}})
# output: 'baz'

jmespath.search('foo.*.name', {'foo': {'bar': {'name': 'one'}, 'baz':
{'name': 'two'}}})
# output: ['one', 'two']

⬆️Тут нет ничего сложного. Метод search принимает паттерн, по которому требуется извлечь данные, а также словарь (который в общем-то похож на JSON).

➡️Возможностей у пакета достаточно, поэтому он достоен изучения и применения в проектах. Подробнее можно почитать в документации.

🐍Pythoner

✈️Сегодня поговорим о мощном инструменте, который может превратить вас в настоящего код-волшебника – Abstract Syntax Trees (AST). Если вы когда-нибудь задумывались, как работают линтеры, компиляторы или автоматические рефакторинг-инструменты, то добро пожаловать в увлекательный мир синтаксических деревьев!

🔎Представьте, что ваш код – это книга, а AST – её подробное содержание, где каждая глава, параграф и предложение аккуратно структурированы в древовидную форму. Каждый узел такого дерева представляет собой конструкцию вашего кода: функции, классы, операторы и даже отдельные переменные.

➡️В Python работа с AST стала намного проще благодаря встроенному модулю ast. Давайте разберем несколько практических примеров:

💬Базовый анализ кода:

import ast

code = """
def calculate_sum(a, b):
    result = a + b
    print(f"Sum: {result}")
    return result
"""

# Создаем AST
tree = ast.parse(code)

# Анализируем структуру
for node in ast.walk(tree):
    if isinstance(node, ast.FunctionDef):
        print(f"Найдена функция: {node.name}")
    elif isinstance(node, ast.Name):
        print(f"Найдена переменная: {node.id}")

⬆️Этот простой пример показывает, как мы можем "гулять" по дереву AST и находить различные элементы кода. Это базовый строительный блок для создания более сложных анализаторов.

💬Трансформация кода:

class DebugTransformer(ast.NodeTransformer):
    def visit_FunctionDef(self, node):
        # Добавляем отладочный print в начало каждой функции
        debug_print = ast.Expr(
            value=ast.Call(
                func=ast.Name(id='print', ctx=ast.Load()),
                args=[ast.Constant(value=f"Вызов функции {node.name}")],
                keywords=[]
            )
        )
        node.body.insert(0, debug_print)
        return node

# Применяем трансформацию
transformed = DebugTransformer().visit(tree)

⬆️Этот трансформер автоматически добавляет отладочный вывод в начало каждой функции. Представьте, насколько это удобно при отладке большого проекта!

💬Оптимизация кода:

class StringOptimizer(ast.NodeTransformer):
    def visit_BinOp(self, node):
        # Оптимизация конкатенации строк
        if isinstance(node.op, ast.Add):
            if isinstance(node.left, ast.Constant) and isinstance(node.right, ast.Constant):
                if isinstance(node.left.value, str) and isinstance(node.right.value, str):
                    return ast.Constant(value=node.left.value + node.right.value)
        return node

⬆️Этот оптимизатор находит конкатенацию строковых литералов и объединяет их на этапе компиляции, что улучшает производительность.

➡️Вот несколько интересных применений AST в реальных проектах:

- Статический анализ безопасности: поиск потенциальных уязвимостей в коде
- Автоматическая документация: генерация документации на основе структуры кода
- Миграция кода: автоматическое обновление устаревших конструкций
- Оптимизация производительности: автоматический поиск неэффективных паттернов

➡️Продвинутый пример: Давайте создадим анализатор сложности кода:

class ComplexityAnalyzer(ast.NodeVisitor):
    def __init__(self):
        self.complexity = 0
        
    def visit_If(self, node):
        self.complexity += 1
        self.generic_visit(node)
        
    def visit_For(self, node):
        self.complexity += 2
        self.generic_visit(node)
        
    def visit_While(self, node):
        self.complexity += 2
        self.generic_visit(node)

# Использование
analyzer = ComplexityAnalyzer()
analyzer.visit(tree)
print(f"Сложность кода: {analyzer.complexity}")

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

- Работа с типами данных и аннотациями через AST
- Создание собственных декораторов с помощью трансформации AST
- Оптимизация циклов и условных конструкций
- Анализ потока данных в программе

🐍Pythoner

✈️Serverless архитектура — это модель вычислений в облаке, где разработчики пишут код, а провайдер облачных услуг управляет серверами. Это позволяет сосредоточиться на разработке, не думая о серверной инфраструктуре.

👀Преимущества Serverless Архитектуры:
- Снижение затрат: Платите только за фактическое использование ресурсов, что часто приводит к экономии средств.
- Масштабируемость: Автоматическое масштабирование помогает справляться с любыми нагрузками без необходимости в ручном управлении.
- Упрощение DevOps: Нет необходимости управлять серверами и их конфигурацией.

⭐️Недостатки Serverless Архитектуры:
- Холодный старт: Время, необходимое для инициализации функции, может быть значительным и влиять на производительность.
- Ограничения исполнения: Функции могут иметь ограничения по времени выполнения и памяти, что может быть проблематично для более сложных задач.
- Зависимость от провайдера: Использование специфичных для провайдера технологий может привести к привязке к одному облаку.

➡️Заключение

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

🐍Pythoner

🦆Duck typing — это концепция, позволяющая использовать объекты независимо от их типа, базируясь на их свойствах и методах. Основная идея — не проверять тип объекта напрямую, а пытаться использовать его так, как нам нужно.

👀Преимущества:
—Нет необходимости привязываться к конкретным классам и типам.
—Код становится более гибким и менее связанным.
—Легче расширять и изменять код, добавляя новые типы.
—Упрощает полиморфизм.

➡️Пример кода:

class Bird:
    def fly(self):
        return "I can fly!"

class Duck(Bird):
    def quack(self):
        return "Quack!"

class Airplane:
    def fly(self):
        return "I can also fly!"

def make_it_fly(flyable_thing):
    print(flyable_thing.fly())

# Создаем объекты
duck = Duck()
airplane = Airplane()

# Используем их, не смотря на разные типы
make_it_fly(duck)      # Выведет: I can fly!
make_it_fly(airplane)  # Выведет: I can also fly!

⬆️В этом примере функция make_it_fly принимает любой объект, который имеет метод fly(). Если объект соответствует этому интерфейсу, он будет выполнен, независимо от того, является ли объект уткой, самолетом или чем-то еще.

🔎Duck typing позволяет создавать более гибкий и динамичный код, так как вы можете использовать объекты, которые соответствуют необходимым интерфейсам, не заботясь о их конкретных классах.

🐍Pythoner

✈️Whylogs - это библиотека для логирования и анализа данных в Python. Она предназначена для легкого отслеживания метрик данных, которые могут помочь в мониторинге и улучшении производительности моделей машинного обучения. Почему это важно? Потому что понимание ваших данных и способов их изменений со временем может существенно повлиять на качество моделей.

➡️Основные функции Whylogs:
—Автоматическое извлечение метрик: Библиотека собирает метрики, такие как распределения, статистики и т.д.
—Поддержка различных форматов данных: Логирование можно выполнять для различных источников данных, включая Pandas DataFrames и потоковые данные.
—Интеграция с другими инструментами: Whylogs легко интегрируется с другими библиотеками и фреймворками.

➡️Пример использования Whylogs:

import whylogs as why
import pandas as pd

# Создание примера данных
data = {
    "age": [25, 30, 35, 40, 45],
    "income": [50000, 60000, 70000, 80000, 90000]
}
df = pd.DataFrame(data)

# Инициализация логгера
logger = why.logger()

# Логируем данные
logger.log_dataframe(df)

# Генерируем отчет
report = logger.report()

# Сохраняем отчет
report.save("report.whylog")

# Выводим на экран
print(report)

⬆️В этом примере мы создаем DataFrame с двумя колонками: age и income. Затем мы инициализируем Whylogs логгер, логируем наш DataFrame, генерируем и сохраняем отчет.

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

🐍Pythoner

✈️Конструкция raise используется для генерации исключений. Когда в коде происходит что-то непредвиденное или некорректное — можно сгенерировать исключение командой raise.

➡️Основные моменты конструкции raise:
—Возбуждение существующих исключений: Вы можете использовать raise без каких-либо параметров в блоке except, чтобы повторно вызвать текущее исключение.
—Создание собственных исключений: Вы можете создать или вызвать собственное исключение, создав объект исключения и передав его в raise.

➡️Пример использования raise:

def divide(a, b):
    if b == 0:
        raise ValueError("Деление на ноль невозможно.")
    return a / b

try:
    result = divide(10, 0)
except ValueError as e:
    print(f"Ошибка: {e}")

⬆️В этом примере функция divide вызывает исключение ValueError, если второй аргумент равен нулю. В блоке try мы пытаемся выполнить деление, и если возникает ошибка, мы перехватываем её и выводим сообщение об ошибке.

🐍Pythoner

✈️Сегодня поговорим о крутой фиче Python, которая может значительно сократить потребление памяти вашими объектами. Речь пойдёт об атрибуте slots!

➡️Для начала давайте разберемся, почему вообще возникла необходимость в slots. По умолчанию Python хранит атрибуты объектов в специальном словаре dict. Это удобно и гибко – можно добавлять новые атрибуты на лету. Но у такой роскоши есть цена: дополнительные накладные расходы на память.

🔎Представьте, что у вас миллион объектов класса User с парой атрибутов. Каждый такой объект тащит за собой словарь dict, а это прожорливая структура данных. И тут на сцену выходит наш герой – slots!

# Без slots
class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# Со slots
class OptimizedUser:
    __slots__ = ['name', 'age']
    
    def __init__(self, name, age):
        self.name = name
        self.age = age

➡️Что даёт нам slots? Вместо создания словаря Python выделяет фиксированный массив в памяти под указанные атрибуты. Это как переход от просторного лофта к компактной студии – места меньше, зато экономия налицо!

➡️Реальные цифры? На практике использование slots может сократить потребление памяти на 30-50% для простых объектов. А при работе с миллионами инстансов экономия становится более чем существенной.

➡️Где это реально пригодится:
—В больших датасетах, где у вас тысячи/миллионы однотипных объектов
—В микросервисах, где важна оптимизация памяти
—В системах реального времени, где каждый байт на счету
—В долгоживущих процессах, обрабатывающих потоки данных

➡️Подводные камни:
—Нельзя добавлять новые атрибуты после определения класса
—Наследование работает не так прозрачно, как с обычными классами
—Некоторые метаклассы могут конфликтовать со slots

➡️Пример реального применения:

class DataPoint:
    __slots__ = ['timestamp', 'value', 'sensor_id']
    
    def __init__(self, timestamp, value, sensor_id):
        self.timestamp = timestamp
        self.value = value
        self.sensor_id = sensor_id

# Представьте, что таких объектов у вас миллионы
data_points = [DataPoint(time.time(), random.random(), i) for i in range(1_000_000)]

🔎Про что стоит помнить: slots – это не волшебная таблетка. Используйте его там, где действительно важна оптимизация памяти и где вы уверены в неизменном наборе атрибутов.

🐍Pythoner

✈️Конструкция if __name__ == '__main__' используется для того, чтобы определить, запущен ли файл модуля напрямую или импортирован из другого модуля.

➡️Простой пример:

def main():

# Точка входа в программу 
if __name__ == '__main__':
    main()

➡️Эта конструкция позволяет запустить какой-нибудь код только при прямом вызове модуля, так как name будет равно 'main' только если модуль запущен напрямую.

➡️Это позволяет запускать программу полностью только когда она основная, а не импортируется в качестве модуля.

🐍Pythoner

✈️Оператор pass в Python, возможно, является одним из наиболее непонятных для новичков. Этот оператор не делает абсолютно ничего. Но почему же он тогда нужен?

➡️Плейсхолдер для будущего кода

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

➡️Минимальные классы и функции

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

➡️Управление потоком программы

Оператор pass также может быть использован для управления потоком программы. Иногда в условной конструкции if/elif/else или в цикле for/while может не быть необходимости выполнять какое-либо действие. В этих случаях можно использовать оператор pass для обозначения пустого блока.

🐍Pythoner

✈️Сегодня поговорим о настоящей магии в мире Python – метапрограммировании и динамическом создании функций.

➡️Начнем с простого примера. Помните eval() и exec()? Это базовые инструменты метапрограммирования, но использовать их нужно с осторожностью – как острый нож в руках повара. Гораздо интереснее копнуть глубже!

def create_power_function(power):
    def power_func(x):
        return x ** power
    return power_func

# Создаём функции на лету
square = create_power_function(2)
cube = create_power_function(3)

⬆️Но это только верхушка айсберга! Настоящее веселье начинается, когда мы подключаем модуль types и функцию exec с собственным словарем namespace. Это как собирать конструктор, только вместо деталей – части функции.

🔎А вы знали, что можно создавать функции с динамическим количеством аргументов? Или генерировать методы классов на лету? Это как будто у вас есть 3D-принтер для кода!

import types

def create_dynamic_function(func_name, args, body):
    namespace = {}
    func_code = f"def {func_name}({', '.join(args)}):\n{body}"
    exec(func_code, globals(), namespace)
    return namespace[func_name]

# Магия в действии
greet = create_dynamic_function(
    "greet",
    ["name"],
    "    return f'Привет, {name}!'"
)

➡️Но помните – с большой силой приходит большая ответственность! Метапрограммирование может сделать код сложным для понимания. Используйте его мудро, когда выгода очевидна:
—При создании API с повторяющимися паттернами
—Для автоматизации рутинных задач
—При разработке фреймворков и библиотек

➡️Отдельного внимания заслуживают декораторы – это ведь тоже метапрограммирование! Они как умные обёртки для функций, которые могут изменять их поведение. И да, их тоже можно создавать динамически!

🐍Pythoner

✈️Сегодня поговорим о том, как сделать работу с путями в Python более элегантной и современной. Если вы всё ещё используете os.path, то пора двигаться вперёд!

➡️Модуль pathlib появился в Python 3.4 и полностью изменил правила игры. Это как пересесть с древнего велосипеда на Tesla – всё те же базовые принципы, но сильно удобнее!

🔎Почему стоит перейти на pathlib?
—Объектно-ориентированный подход вместо строковых операций
—Кроссплатформенность из коробки
—Цепочки методов, которые читаются как поэзия
—Меньше кода, больше смысла

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

# Старый подход с os.path
import os.path
file_path = os.path.join('data', 'users', 'config.json')
parent_dir = os.path.dirname(file_path)
file_name = os.path.basename(file_path)

# Новый подход с pathlib
from pathlib import Path
file_path = Path('data') / 'users' / 'config.json'
parent_dir = file_path.parent
file_name = file_path.name

👀Крутые фишки pathlib, о которых вы могли не знать:

➡️Проверка существования файла:

path = Path('config.json')
if path.exists():
    print('Файл существует!')

➡️Создание директорий одной командой:

Path('nested/directories/structure').mkdir(parents=True, exist_ok=True)

➡️Поиск файлов по маске (glob):

# Найти все .py файлы в текущей директории
python_files = list(Path('.').glob('*.py'))

➡️Работа с суффиксами и расширениями:

path = Path('document.pdf')
print(path.suffix)  # .pdf
print(path.stem)    # document

➡️А теперь самое вкусное – цепочки методов:

config_path = (Path.home() / 'projects' / 'app' / 'config.json')
if config_path.exists():
    data = json.loads(config_path.read_text())

➡️Pro-tip: pathlib отлично работает с контекстными менеджерами:

with Path('log.txt').open('w') as f:
    f.write('Logging started')

🔎Когда стоит использовать os.path? Практически никогда! Разве что при работе с легаси-кодом или если вам нужны какие-то очень специфические операции с путями.

⚡️В заключение: pathlib – это не просто альтернатива os.path, это следующий эволюционный шаг в работе с файловой системой в Python. Он делает код чище, понятнее и приятнее в поддержке. Если вы ещё не перешли на pathlib, самое время начать!

🐍Pythoner

✈️Тернарный оператор — это оператор, позволяющий записать условную конструкцию if-else в одну строку.

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

➡️Простой пример:

a = 3
b = 10

print('a больше b') if a > b else print('a меньше b')

result = 'Четное' if a % 2 == 0 else 'Нечетное'
print(result)

# Результат:
# a меньше b
# Нечетное 

⬆️В данном примере тернарный оператор используется:
—Для вывода одной из двух фраз в зависимости от условия a > b.
—Для присваивания переменной result одного из двух значений в зависимости от четности a.

🐍Pythoner

✈️Humanize — это библиотека для Python, которая помогает преобразовывать текстовые представления чисел, дат и других значений в более удобочитаемый человекообразный формат. Она используется для упрощения визуализации данных и улучшения пользовательского интерфейса.

➡️Humanize полезен в приложениях, где нужно отображать данные в интерфейсе:
—Веб-приложения для отображения статистики.
—Информационные табло и панели мониторинга.
—Системы аналитики для визуализации данных.
—CLI-интерфейсы для вывода данных пользователю.

➡️Несколько примеров:

💬Человеко-читаемые временные метки:

import humanize
import datetime

# Пример: время, прошедшее с 24 сентября 2023 года
dt = datetime.datetime(2023, 9, 24)
print(humanize.naturaltime(dt))  # Вывод: "1 месяц назад" (на момент текущей даты)

💬Форматирование чисел:

import humanize

number = 1500
print(humanize.intcomma(number))  # Вывод: "1,500"
print(humanize.intword(number))    # Вывод: "1.5 k"

💬Представление длительности:

import humanize

duration = 3661  # время в секундах
print(humanize.precisedelta(datetime.timedelta(seconds=duration))) 
# Вывод: "1 час, 1 минутa, 1 секунда"

🔎Использование Humanize позволяет сделать отображение данных более естественным и понятным для человека. Это улучшает user experience приложения.

🐍Pythoner

✈️rename() — это функция из модуля os, которая позволяет переименовывать файлы и директории. Синтаксис функции:

os.rename(old_name, new_name)

➡️Пример использования:

import os

# Переименуем файл 'старый_файл.txt' в 'новый_файл.txt'
old_name = 'старый_файл.txt'
new_name = 'новый_файл.txt'

# Проверяем, существует ли старый файл
if os.path.exists(old_name):
    os.rename(old_name, new_name)
    print(f'Файл переименован в {new_name}')
else:
    print(f'Файл {old_name} не найден')

⬆️Обратите внимание:
—Если файл с new_name уже существует, функция вызовет ошибку.
—Убедитесь, что у вас есть необходимые права для выполнения этой операции.

🐍Pythoner

✈️Метод tell() используется для получения текущей позиции (смещения) при работе с файлами и файлоподобными объектами.

➡️Это позволяет:
—Узнать размер файла, сравнив позицию после чтения с начальной.
—Вернуться к определенной позиции с помощью seek().
—Отслеживать прогресс обработки больших файлов.
—Получить позицию в строковых буферах и потоках байтов.

➡️Вот пример, который демонстрирует использование tell():

# Открываем файл для записи
with open('example.txt', 'w') as f:
    f.write('Hello, World!')
    # Получаем текущую позицию курсора
    position = f.tell()
    print(f'Current position after writing: {position}')  # Вывод: 13, т.к. длина строки "Hello, World!" = 13

# Открываем файл для чтения
with open('example.txt', 'r') as f:
    content = f.read(5)  # Читаем первые 5 символов
    position = f.tell()
    print(f'Content read: {content}')  # Вывод: Hello
    print(f'Current position after reading: {position}')  # Вывод: 5

⬆️В этом примере:
1. Мы открываем файл example.txt для записи и записываем в него строку "Hello, World!".
2. Используем tell(), чтобы получить позицию курсора после записи, что будет равно 13 (длина строки).
3. Затем открываем файл для чтения и читаем первые 5 символов.
4. Снова используем tell(), чтобы получить новую позицию курсора, которая будет равна 5 после чтения.

🐍Pythoner

✈️В Python деструкторы — это специальные методы, которые вызываются, когда объект собирается с мусором (т.е., когда он больше не нужен и память, занимаемая объектом, освобождается). Деструкторы позволяют выполнить некоторые завершающие действия перед уничтожением объекта, например, освободить ресурсы или завершить соединения.

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

➡️Вот пример класса с деструктором:

class MyClass:
    def __init__(self, name):
        self.name = name
        print(f"Объект {self.name} создан.")

    def __del__(self):
        print(f"Объект {self.name} уничтожен.")

# Создаем объект класса
obj = MyClass("TestObject")

# Удаляем объект
del obj

# Если вы хотите избежать автоматического освобождения памяти,
# можете использовать осмысленное завершение программы, например:
import time
time.sleep(1)  # daем немного времени, чтобы увидеть сообщение деструктора

⬆️В этом примере создается объект MyClass, после чего его деструктор будет вызван при удалении объекта с помощью команды del obj. Таким образом, в консоль будет выведено сообщение о создании объекта, а затем сообщение о его уничтожении.

🐍Pythoner

✈️ Модуль rich в Python предоставляет мощные возможности для улучшения визуального оформления терминальных приложений. С помощью rich можно создавать цветные тексты, таблицы, деревья, прогресс-бары и даже подсвечивать код.

➡️ Вот несколько практических примеров применения rich:
1. Цветной текст и стили

from rich import print  

# Выводим текст с цветами и стилями
print("[bold red]Ошибка:[/] Неверный ввод!")  
print("[green]Успех:[/] Данные сохранены.")  
print("Это [italic cyan]пример[/italic cyan] текста с [underline magenta]разными[/underline magenta] стилями.")  

⬆️ Этот пример показывает, как легко добавлять стили и цвета в текст. Используются такие стили, как жирный, курсив и подчёркнутый.

2. Форматирование JSON

from rich.console import Console  
from rich.json import JSON  

console = Console()

# Пример JSON-данных
data = '{"name": "Python3", "type": "Programming Language", "year": 2008}'  

# Форматированный вывод JSON
console.print(JSON(data))

⬆️ Удобно для визуализации JSON-данных с автоматической подсветкой синтаксиса.

3. Создание таблиц

from rich.table import Table  
from rich.console import Console  

console = Console()

table = Table(title="Сравнение языков программирования")

table.add_column("Язык", style="bold", justify="left")  
table.add_column("Скорость", justify="right")  
table.add_column("Простота", justify="right")  

table.add_row("Python", "Средняя", "Высокая")  
table.add_row("Rust", "Высокая", "Средняя")  
table.add_row("C++", "Высокая", "Низкая")  

console.print(table)

⬆️ Таблицы помогают организовать данные, делая их читабельными и визуально привлекательными.

4. Прогресс-бар

from time import sleep  
from rich.progress import Progress  

with Progress() as progress:  
    task = progress.add_task("[cyan]Обработка данных...", total=100)  
    
    for i in range(100):  
        sleep(0.05)  
        progress.update(task, advance=1)  

⬆️ Прогресс-бары полезны для отображения выполнения долгих операций.

5. Дерево файлов

from rich.tree import Tree  
from rich.console import Console  

console = Console()

tree = Tree("Проект")  
src = tree.add("src")  
src.add("main.py")  
src.add("utils.py")  
tree.add("README.md")  
tree.add("requirements.txt")  

console.print(tree)

⬆️ Этот пример создаёт визуализацию структуры проекта в виде дерева.

6. Подсветка синтаксиса

from rich.console import Console  
from rich.syntax import Syntax  

console = Console()

code = '''
def greet(name: str) -> str:
    return f"Hello, {name}!"
'''

# Подсвечиваем код
syntax = Syntax(code, "python", theme="monokai", line_numbers=True)  
console.print(syntax)

⬆️ Подсветка синтаксиса помогает отображать исходный код красиво и читаемо.

7. Журналирование

from rich.logging import RichHandler  
import logging  

logging.basicConfig(  
    level=logging.INFO,  
    format="%(message)s",  
    handlers=[RichHandler()]  
)  

log = logging.getLogger("rich")  

log.info("Это [bold green]информация[/bold green].")  
log.warning("Это [bold yellow]предупреждение[/bold yellow].")  
log.error("Это [bold red]ошибка[/bold red].")  

⬆️ Логирование с rich выглядит намного приятнее, чем стандартный вывод.

🐍 Pythoner

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

➡️ Применение "plotly" широко распространено в области анализа данных, научных исследований, бизнес-аналитики и визуализации данных в веб-приложениях. Библиотека предоставляет удобный интерфейс для создания высококачественных, интерактивных графиков, которые помогают лучше понимать данные и извлекать из них ценную информацию. "Plotly" поддерживает различные фреймворки, такие как "Dash" и "Flask", что делает его мощным инструментом для создания динамических веб-приложений с интерактивными визуализациями. Кроме того, "plotly" можно использовать для создания автономных HTML-файлов с графиками, которые можно легко распространять и публиковать.

➡️ Вот пример использования "plotly" для построения интерактивного линейного графика:

import plotly.graph_objects as go

# Создаем данные для графика
x = [1, 2, 3, 4, 5]
y1 = [10, 11, 12, 13, 14]
y2 = [8, 9, 10, 11, 12]

# Создаем объект Figure
fig = go.Figure()

# Добавляем первый линейный график
fig.add_trace(go.Scatter(x=x, y=y1, mode="lines+markers", name="Линия 1"))

# Добавляем второй линейный график
fig.add_trace(go.Scatter(x=x, y=y2, mode="lines+markers", name="Линия 2"))

# Настраиваем заголовок и подписи осей
fig.update_layout(title="Интерактивный линейный график",
                  xaxis_title="X",
                  yaxis_title="Y")

# Отображаем график
fig.show()

# Сохраняем график в HTML-файл
# fig.write_html("my_plotly_chart.html")

⬆️ В этом примере создается интерактивный линейный график с двумя линиями, отображающими зависимость "Y" от "X". Пользователь может взаимодействовать с графиком, масштабируя, панорамируя и просматривая значения данных при наведении курсора на точки. Кроме того, в примере показано, как сохранить график в HTML-файл для последующего использования и публикации.


🐍 Pythoner

✈️ В Python httpx — это современная HTTP-клиентская библиотека, которая предоставляет полный набор функций для работы с HTTP/1.1 и HTTP/2. httpx позволяют разработчикам легко и эффективно взаимодействовать с веб-серверами, отправляя запросы и получая ответы.

➡️ Применение httpx.

httpx широко используется в различных сценариях, включая:
- Веб-скрейпинг: Извлечение данных с веб-страниц.
- API-интеграции: Взаимодействие с RESTful API.
- Тестирование: Автоматизация тестирования веб-сервисов.
- Микросервисы: Обмен данными между микросервисами.

➡️ Вот пример использования httpx:

import httpx

# Отправка GET-запроса
response = httpx.get("https://api.github.com")

# Проверка статуса ответа
if response.status_code == 200:
    print("Успешный запрос!")
    print("Содержимое ответа:", response.text)
else:
    print("Ошибка:", response.status_code)

# Отправка POST-запроса
data = {"key1": "value1", "key2": "value2"}
response = httpx.post("https://httpbin.org/post", data=data)

# Проверка статуса ответа
if response.status_code == 200:
    print("Успешный POST-запрос!")
    print("Содержимое ответа:", response.json())
else:
    print("Ошибка:", response.status_code)

⬆️ В этом примере создается HTTP-клиент с использованием httpx, который отправляет GET и POST запросы на указанные URL.

🐍 Pythoner

✈️ В Python абстрактные классы (ABC) — это классы, которые предназначены для того, чтобы быть базовыми для других классов, и не предполагают создания собственных экземпляров. Абстрактные классы позволяют определить общий интерфейс для группы подклассов, обеспечивая, что все они реализуют определенные методы.

➡️ Применение абстрактных классов способствует созданию более структурированного и поддерживаемого кода, повышает его читаемость и позволяет применять полиморфизм более эффективно. Они особенно полезны при разработке библиотек и фреймворков, где необходимо обеспечить определенный набор функциональности в классах-наследниках. Использование ABC помогает предотвратить ошибки, связанные с отсутствием реализации обязательных методов в подклассах, которые могли бы проявиться только во время выполнения.

➡️ Вот пример абстрактного класса и его использования:

from abc import ABC, abstractmethod

class Animal(ABC):  # Animal - абстрактный базовый класс

    @abstractmethod
    def make_sound(self):
        pass

    @abstractmethod
    def move(self):
        pass


class Dog(Animal):
    def make_sound(self):
        return "Woof!"

    def move(self):
        return "Runs"


class Cat(Animal):
    def make_sound(self):
        return "Meow!"

    def move(self):
        return "Walks"


dog = Dog()
print(dog.make_sound())  # Вывод: Woof!
print(dog.move()) # Вывод: Runs

cat = Cat()
print(cat.make_sound()) # Вывод: Meow!
print(cat.move()) # Вывод: Walks



try:
    animal = Animal() # Попытка создать экземпляр абстрактного класса
except TypeError as e:
    print(e) # Вывод: Can't instantiate abstract class Animal with abstract methods make_sound, move


animals = [Dog(), Cat()]
for animal in animals:
    print(animal.make_sound()) #  Полиморфизм: вызов метода make_sound для разных животных


class Fish(Animal):
    def make_sound(self):
        return "Blub!"


    # Забыли реализовать метод move


try:
    fish = Fish() #  Попытка создать экземпляр класса с нереализованным абстрактным методом
except TypeError as e:
    print(e) # Вывод: Can't instantiate abstract class Fish with abstract methods move

⬆️ В этом примере создается абстрактный класс Animal с абстрактными методами make_sound и move. Классы Dog и Cat наследуют от Animal и реализуют эти методы. Попытка создать экземпляр самого абстрактного класса Animal приводит к ошибке TypeError. Демонстрируется полиморфизм: один и тот же код animal.make_sound() работает с объектами разных классов, производных от Animal, и выдает специфичный для каждого класса результат. Также показан пример ошибки, возникающей при попытке создания экземпляра класса Fish, который не реализует все абстрактные методы базового класса.

🐍 Pythoner