🦆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

✈️ В Python trafilatura — это мощная библиотека для извлечения основного текста из веб-страниц. Она эффективно обрабатывает HTML, XML и другие форматы, удаляя ненужные элементы, такие как навигация, реклама и боковые панели, оставляя только основной контент статьи или публикации.

➡️ Применение trafilatura широко распространено в веб-скрапинге, анализе текста, создании датасетов для машинного обучения и других задачах, где требуется чистый текст из веб-источников. Библиотека предоставляет гибкие настройки для обработки различных типов веб-страниц и поддерживает извлечение метаданных, таких как заголовок, автор и дата публикации.

➡️ Вот пример использования trafilatura для извлечения текста из веб-страницы:

from trafilatura import extract

downloaded_html = """
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Example Page</title>
</head>
<body>
    <h1>This is a heading</h1>
    <p>This is some text in a paragraph.</p>
    <aside>This is some text in a sidebar.</aside>
    <p>This is more text in another paragraph.</p>
    <footer>This is a footer.</footer>
</body>
</html>
"""

extracted_text = extract(downloaded_html)

print(extracted_text)

# Вывод:
# This is a heading
# This is some text in a paragraph.
# This is more text in another paragraph.

from trafilatura import fetch_url

url = "https://www.example.com" #  Замените на реальный URL

try:
    extracted_text = fetch_url(url)
    if extracted_text:
        print(extracted_text)
    else:
        print("Не удалось извлечь текст с URL")
except Exception as e:
    print(f"Произошла ошибка: {e}")


from trafilatura import bare_extraction

extracted_text_with_metadata = bare_extraction(downloaded_html, include_comments=False, include_tables=True, deduplicate=True)
print(extracted_text_with_metadata)

# Пример вывода (может варьироваться в зависимости от контента страницы):
# {'title': 'Example Page', 'text': 'This is a heading\nThis is some text in a paragraph.\nThis is more text in another paragraph.', 'author': None, 'url': None, 'hostname': None, 'description': None, 'date': None}

⬆️ В этом примере демонстрируется использование функций extract и fetch_url из библиотеки trafilatura. Функция extract извлекает текст из предоставленного HTML-кода, а fetch_url загружает и обрабатывает веб-страницу по указанному URL. Также приведен пример использования bare_extraction для получения текста вместе с метаданными. Обратите внимание, что для работы с fetch_url требуется активное интернет-соединение и корректный URL. Пример с bare_extraction показывает, как получить дополнительные данные, такие как заголовок страницы.

🐍 Pythoner

✈️ В Python asyncpg — это высокопроизводительная библиотека для асинхронного доступа к базам данных PostgreSQL. Она построена на базе asyncio и предоставляет низкоуровневый интерфейс для взаимодействия с PostgreSQL, обеспечивая высокую скорость и эффективность.

➡️ Применение asyncpg особенно актуально в высоконагруженных веб-приложениях и сервисах, где требуется максимальная производительность при работе с базой данных. asyncpg позволяет выполнять запросы к базе данных асинхронно, не блокируя основной поток приложения, что повышает общую отзывчивость и пропускную способность. Библиотека также поддерживает продвинутые возможности PostgreSQL, такие как JSON, hstore и уведомления.

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

import asyncio
import asyncpg


async def run():
    conn = await asyncpg.connect(user="user", password="password", database="database", host="127.0.0.1") # Подставьте свои учетные данные

    try:
        # Выполнение запроса на создание таблицы (если она не существует)
        await conn.execute('''
            CREATE TABLE IF NOT EXISTS users (
                id SERIAL PRIMARY KEY,
                name TEXT
            )
        ''')

        # Выполнение запроса на вставку данных
        await conn.execute("INSERT INTO users (name) VALUES ($1)", "Alice")

        # Выполнение запроса на выборку данных
        result = await conn.fetch("SELECT * FROM users")
        print(result) # Вывод: [<Record id=1 name='Alice'>]

        # Выполнение параметризованного запроса на выборку данных
        user_name = "Alice"
        user = await conn.fetchrow("SELECT * FROM users WHERE name = $1", user_name)
        print(user) # Вывод: <Record id=1 name='Alice'>

        # Транзакции
        async with conn.transaction():
            await conn.execute("UPDATE users SET name = $1 WHERE id = $2", "Bob", 1)


        # Обработка ошибок
        try:
            await conn.execute("SELECT * FROM non_existent_table")  # Несуществующая таблица
        except asyncpg.exceptions.UndefinedTableError as e:
            print(f"Ошибка: {e}")



    finally:
        await conn.close()


if __name__ == "__main__":
    asyncio.run(run())

⬆️ В этом примере демонстрируется подключение к базе данных PostgreSQL, выполнение различных SQL-запросов (создание таблицы, вставка, выборка данных), использование параметризованных запросов, обработка транзакций и пример обработки исключения UndefinedTableError. Для запуска примера необходимо установить asyncpg (pip install asyncpg) и иметь работающий сервер PostgreSQL с указанными учетными данными. Не забудьте заменить user, password, database, и host на ваши реальные данные. Помните, что asyncpg работает асинхронно, поэтому необходимо использовать asyncio.run() для запуска кода.

🐍 Pythoner

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

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

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

# неформатированный код
def very_important_function(template: str, *variables, engine: str = "jinja2"):
    """Applies `variables` to the `template` using the `engine`."""
    if engine == "jinja2":
        return template.render(*variables)
    elif engine == 'f-strings':
        return eval(f"f'{template}'")
    return template.format(*variables)

# установка black: pip install black
# запуск black: black имя_файла.py

# отформатированный код после Black
def very_important_function(
    template: str, *variables, engine: str = "jinja2"
):
    """Applies `variables` to the `template` using the `engine`."""
    if engine == "jinja2":
        return template.render(*variables)
    elif engine == "f-strings":
        return eval(f"f'{template}'")
    return template.format(*variables)

⬆️В этом примере показан фрагмент кода до и после форматирования Black. Black автоматически изменил отступы, переводы строк и расположение скобок, приведя код к единому стилю. Обратите внимание, что Black не изменяет логику кода, а только его форматирование. Для использования Black необходимо установить его с помощью pip install black и запустить из командной строки, указав имя файла или директории, которую нужно отформатировать: black имя_файла.py или black . для форматирования всех файлов в текущей директории.

🐍 Pythoner