Pythoner

✈️Сегодня поговорим о вечном противостоянии в мире тестирования. Знаете, как в споре "табы или пробелы", у нас есть другая горячая тема: unit-тесты против property-based тестирования. Давайте разберёмся без занудства, но с конкретикой! ➡️Unit-тестирование - это как стрельба по мишеням. Мы точно знаем, какой результат хотим получить, и проверяем конкретные случаи. Например:

def test_sum():
    assert sum([1, 2, 3]) == 6
    assert sum([-1, 1]) == 0

✅Плюсы unit-тестов: —Понятны даже джуниору —Легко дебажить —Отлично подходят для документирования кода —Быстро выполняются ❌Минусы: —Покрывают только те кейсы, о которых мы подумали —Часто пропускаем edge-cases —Может быть много копипасты ➡️А вот property-based тестирование - это как игра в рулетку, только с гарантированным выигрышем! Вместо конкретных значений мы определяем свойства, которым должна соответствовать наша функция. Библиотека (например, hypothesis) сама генерирует тестовые данные:

from hypothesis import given
import hypothesis.strategies as st

@given(st.lists(st.integers()))
def test_sum_properties(numbers):
    assert sum(numbers) == sum(reversed(numbers))
    assert sum(numbers + [0]) == sum(numbers)

✅Преимущества property-testing: —Находит неочевидные баги —Меньше кода, больше покрытие —Заставляет думать о свойствах функций, а не о конкретных значениях ❌Недостатки: —Сложнее придумывать правильные свойства —Медленнее выполняются —Может быть сложно понять, почему тест упал 💡Не выбирайте что-то одно! Используйте unit-тесты для очевидных кейсов и документирования, а property-based - для поиска краевых случаев и сложной логики. Особенно это актуально для математических функций, парсеров и сериализаторов. 📍В идеальном мире ваши тесты должны быть как хороший детектив - проверять очевидное и раскрывать неожиданное. И помните: лучший тест - тот, который ловит баги до прода! 🐍 Pythoner

Хочешь узнать все самые интересные фишки в DevOps? Подписывайся на Telegram-канал DevOps Bootcamp от учебного центра Слёрм и забирай подарок! Для тех, кто собирается в DevOps ы разработали свой Roadmap на основе опыта спикеров Слёрма. Он сделан с учётом российских реалий, разбит на уровни, фокусирует внимание на том, что в первую очередь понвдобится для старта и роста в профессии, и содержит ссылки на дополнительные источники. Подписаться #реклама 16+ slurm.io О рекламодателе

✈️ В Python pypy3 — это альтернативная реализация интерпретатора Python, использующая JIT-компиляцию (Just-In-Time). Это означает, что pypy3 динамически компилирует Python-код в машинный код во время выполнения, что часто приводит к значительному увеличению скорости работы программ. ➡️ Применение pypy3 особенно эффективно для CPU-bound задач, где основное время выполнения тратится на вычисления. В таких случаях pypy3 может значительно превзойти стандартный интерпретатор CPython. Однако, pypy3 не всегда является оптимальным выбором, особенно для программ, интенсивно использующих C-расширения, которые могут работать медленнее или вообще не работать с pypy3. ➡️ Вот пример, демонстрирующий разницу в производительности между CPython и pypy3:

import time

def compute_intensive_task(n):
    result = 0
    for i in range(n):
        result += i * i
    return result

start_time = time.time()
result = compute_intensive_task(10000000)  #  CPU-bound задача
end_time = time.time()

print(f"Результат: {result}")
print(f"Время выполнения: {end_time - start_time} секунд")


#  Для запуска с pypy3: pypy3 example.py

⬆️ В этом примере выполняется вычислительно интенсивная задача. Запустив этот код сначала с помощью стандартного интерпретатора CPython, а затем с помощью pypy3, можно заметить существенную разницу во времени выполнения. pypy3, вероятно, выполнит задачу значительно быстрее благодаря JIT-компиляции. Важно помнить, что результаты могут варьироваться в зависимости от конкретной задачи и аппаратного обеспечения. Этот пример демонстрирует преимущества pypy3 для CPU-bound задач. Для I/O-bound задач, где основное время тратится на ожидание ввода/вывода (например, сетевые запросы), разница в производительности может быть менее заметной. 🐍 Pythoner

Помощь в трудоустройстве в IT-сфере! В России из-за дефицита айтишников запустили бесплатную программу по обучению IT-специалистов. Теперь любой желающий может попробовать себя в IT с полного нуля и начать обучение бесплатно! Узнайте про дальнейшее трудоустройство в ведущие IT-компании для восполнения кадрового дефицита. Для этого нужно: - Перейти по ссылке - Заполнить анкету и ответить на вопросы (занимает менее 3 минут) - На основании ваших ответов вы сразу узнаете, подходит ли вам сфера IT и сможете ли вы в ней работать Перейти на сайт #реклама 16+ urban-university.ru О рекламодателе

✈️ В Python NumPy — это фундаментальная библиотека для научных вычислений. Она предоставляет мощный N-мерный массив (ndarray), а также широкий набор функций для работы с этими массивами. NumPy является основой для многих других библиотек, таких как SciPy, Pandas и Matplotlib. ➡️ Применение NumPy крайне разнообразно и включает в себя математические операции, линейную алгебру, обработку сигналов, работу с изображениями, машинное обучение и многое другое. Благодаря векторизованным операциям и эффективной работе с памятью, NumPy обеспечивает высокую производительность при работе с большими объемами данных. ➡️ Вот пример использования NumPy:

import numpy as np

# Создание массивов:
a = np.array([1, 2, 3])  # Одномерный массив
b = np.array([[1, 2, 3], [4, 5, 6]])  # Двумерный массив
c = np.zeros((2, 3))  # Массив из нулей
d = np.ones((3, 2))  # Массив из единиц
e = np.arange(10)  # Массив с числами от 0 до 9
f = np.linspace(0, 1, 5)  # Массив из 5 чисел, равномерно распределенных от 0 до 1
g = np.random.rand(2, 2)  # Массив случайных чисел от 0 до 1

print("a:", a)
print("b:", b)
print("c:", c)
print("d:", d)
print("e:", e)
print("f:", f)
print("g:", g)



# Математические операции:
print("a + 2:", a + 2)
print("a * 3:", a * 3)
print("a.sum():", a.sum())  # Сумма элементов массива
print("b.mean():", b.mean()) # Среднее значение элементов массива

print("a.dot(a): ", a.dot(a)) # Скалярное произведение векторов



# Индексация и срезы:
print("a[0]:", a[0])
print("b[1, 2]:", b[1, 2])
print("e[1:4]:", e[1:4])



# Изменение формы массива:
print("b.reshape(3, 2):", b.reshape(3, 2))
print("a.T:", a.T) # Транспонирование массива


# Линейная алгебра:
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print("A.dot(B):", A.dot(B)) # Умножение матриц
print("np.linalg.inv(A):", np.linalg.inv(A)) # Обратная матрица

⬆️ В этом примере демонстрируются различные способы создания массивов NumPy, выполнение математических операций с массивами, индексация и срезы массивов, изменение формы массивов, а также базовые операции линейной алгебры, такие как умножение матриц и вычисление обратной матрицы. NumPy предоставляет множество других функций для работы с массивами, включая функции для работы с файлами, статистические функции, функции для обработки изображений и сигналов, и многое другое. 🐍 Pythoner

✈️ В Python shutil (shell utilities) — это высокоуровневая библиотека, предоставляющая функции для работы с файлами и директориями. Она расширяет возможности модуля os и упрощает выполнение распространенных операций, таких как копирование, перемещение, удаление, архивирование и работа с файловыми путями. ➡️ Применение shutil позволяет писать более чистый и понятный код при работе с файловой системой. Библиотека предоставляет удобные функции для выполнения сложных операций, например, рекурсивного копирования директорий или создания архивов различных форматов. ➡️ Вот пример использования shutil:

import shutil
import os

# Копирование файла:
shutil.copy("source_file.txt", "destination_folder/") # Копирование в директорию
shutil.copy("source_file.txt", "destination_file.txt") # Копирование с новым именем

# Копирование директории (рекурсивно):
shutil.copytree("source_folder", "destination_folder")

# Перемещение файла или директории:
shutil.move("source_file.txt", "destination_folder/")
shutil.move("source_folder", "destination_folder")

# Удаление файла:
os.remove("file_to_delete.txt")

# Удаление директории (рекурсивно):
shutil.rmtree("directory_to_delete")


# Создание архива:

shutil.make_archive("archive_name", "zip", "folder_to_archive") # ZIP архив
shutil.make_archive("archive_name", "gztar", "folder_to_archive") # tar.gz архив
shutil.make_archive("archive_name", "bztar", "folder_to_archive") # tar.bz2 архив
shutil.make_archive("archive_name", "xztar", "folder_to_archive") # tar.xz архив



# Работа с файловыми путями (некоторые примеры):

print(shutil.which("python")) #  Путь к исполняемому файлу python


#  Проверка дискового пространства

total, used, free = shutil.disk_usage("/")  #  Получение информации о дисковом пространстве (корневой раздел)
print(f"Total: {total // (2**30)} GiB")
print(f"Used: {used // (2**30)} GiB")
print(f"Free: {free // (2**30)} GiB")

⬆️ В этом примере демонстрируются функции shutil для копирования файлов и директорий, перемещения, удаления, создания архивов различных форматов, а также примеры работы с файловыми путями и проверки дискового пространства. Обратите внимание, что операции с файлами и директориями могут привести к безвозвратной потере данных, поэтому будьте осторожны при их использовании. Перед выполнением операций на реальных данных рекомендуется протестировать код на тестовых файлах и директориях. Также показан пример использования shutil.which для определения пути к исполняемому файлу и shutil.disk_usage для получения информации о дисковом пространстве. 🐍 Pythoner

IT-аутстаффинг Ежедневно публикуем запросы на аутстаффинг разработчиков Java, Python, Flutter, C#, 1С и других ИТ-специалистов. Есть свой резерв, готовый прямо сейчас влиться в ваш проект. Посмотрите в канале наших свободных разработчиков. Подписаться #реклама О рекламодателе

✈️Сегодня поговорим о том, как создавать крутые CLI-приложения с помощью Click. Если вам надоело писать бесконечные if'ы для обработки аргументов командной строки, то этот пост определенно для вас! ➡️Начнем с того, почему вообще стоит использовать Click, а не встроенный argparse: —Декораторный подход, который выглядит элегантно и интуитивно понятен —Автоматическая генерация справки и сообщений об ошибках —Вложенные команды из коробки —Поддержка автодополнения в shell ➡️Давайте посмотрим на простой, но реальный пример. Представим, что мы делаем утилиту для работы с файлами:

import click

@click.group()
def cli():
    """Утилита для работы с файлами"""
    pass

@cli.command()
@click.argument('path')
@click.option('--lines', '-l', is_flag=True, help='Показать количество строк')
def analyze(path, lines):
    """Анализирует файл и выводит статистику"""
    try:
        with open(path) as f:
            content = f.readlines()
            if lines:
                click.echo(f'Количество строк: {len(content)}')
    except FileNotFoundError:
        click.secho('Файл не найден! 😱', fg='red')

if __name__ == '__main__':
    cli()

Крутая штука в Click – это то, как легко добавлять новые команды. Хотите добавить подкоманду? Просто навешиваете еще один декоратор! ➡️А теперь лайфхак, который многие упускают: Click умеет создавать красивые прогресс-бары:

@cli.command()
@click.argument('path')
def process(path):
    """Обрабатывает файлы с прогресс-баром"""
    files = os.listdir(path)
    with click.progressbar(files, label='Обработка файлов') as bar:
        for f in bar:
            # что-то делаем с файлом
            time.sleep(0.1)

➡️Про что еще стоит знать? Click отлично работает с цветным выводом. Хотите привлечь внимание пользователя? Используйте click.secho():

click.secho('Внимание! 🚨', fg='yellow', bold=True)
click.secho('Ошибка! ❌', fg='red')
click.secho('Успех! ✅', fg='green')

➡️И напоследок, трюк – создание интерактивных подтверждений:

if click.confirm('Уверены, что хотите удалить все файлы? 🤔'):
    click.echo('Поехали! 🚀')

📂Документация 🐍 Pythoner

✈️ В Python модуль `concurrent.futures` предоставляет высокоуровневый интерфейс для асинхронного выполнения вызовов функций, используя пул потоков или процессов. Он упрощает распараллеливание задач и позволяет эффективно использовать многоядерные процессоры для ускорения выполнения программ. ➡️ Применение concurrent.futures особенно полезно при работе с I/O-bound задачами, такими как сетевые запросы, чтение/запись файлов, взаимодействие с базами данных. Он также может быть эффективен для CPU-bound задач, если они могут быть разделены на независимые подзадачи. ➡️ Вот пример использования concurrent.futures с ThreadPoolExecutor:

import concurrent.futures
import time
import requests

URLS = [
    "https://www.example.com",
    "https://www.google.com",
    "https://www.python.org",
    "https://www.wikipedia.org",
]

def load_url(url, timeout):
    try:
        response = requests.get(url, timeout=timeout)
        return f"{url}: {len(response.content)} bytes"
    except requests.exceptions.RequestException as e:
        return f"{url}: Error: {e}"


start_time = time.time()

# Последовательное выполнение:
for url in URLS:
    print(load_url(url, timeout=60))


end_time = time.time()
print(f"Последовательное выполнение заняло: {end_time - start_time} секунд")





start_time = time.time()

# Асинхронное выполнение с ThreadPoolExecutor:
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    # map() возвращает результаты в порядке URLS
    future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}
    for future in concurrent.futures.as_completed(future_to_url):
        url = future_to_url[future]
        try:
            data = future.result()
        except Exception as exc:
            print(f"{url}: generated an exception: {exc}")
        else:
            print(data)

end_time = time.time()
print(f"Асинхронное выполнение заняло: {end_time - start_time} секунд")

⬆️ В этом примере демонстрируется загрузка содержимого нескольких URL-адресов сначала последовательно, а затем асинхронно с использованием ThreadPoolExecutor. Функция load_url загружает данные по указанному URL. ThreadPoolExecutor создает пул потоков, которые выполняют загрузку URL-адресов параллельно. as_completed позволяет обрабатывать результаты по мере их готовности, не дожидаясь завершения всех задач. Сравнение времени выполнения показывает преимущество асинхронного подхода, особенно при работе с сетевыми запросами. 🐍 Pythoner

Подпишитесь на наш Telegram-канал! В Telegram-канале VK Рекламы мы делимся: - успешными кейсами таргетологов и предпринимателей; - пошаговыми инструкциями по настройке кампаний; - бесплатными обучающими курсами и вебинарами; - рекламными форматами и инструментами, которые помогут повысить эффективность кампаний. 📅 А ещё анонсируем бесплатные марафоны и офлайн-конференции для разных сфер бизнеса! Подписывайтесь! У нас тут много обучающего контента, который научит любого грамотно пользоваться кабинетом VK Рекламы и настраивать эффективные рекламные кампании. Подписаться #реклама 16+ О рекламодателе

✈️ В Python модуль `difflib` — это мощный инструмент для сравнения последовательностей, таких как строки, списки и другие итерируемые объекты. Он предоставляет классы и функции для вычисления различий между последовательностями, что позволяет эффективно находить и отображать изменения, например, в текстовых файлах или других данных. ➡️ Применение difflib разнообразно: от сравнения версий файлов и поиска плагиата до создания патчей и слияния изменений в системах контроля версий. Он также может быть полезен для анализа текстовых данных, например, для выявления изменений в документах или сравнения ответов пользователей. ➡️ Вот пример использования difflib для сравнения двух строк:

import difflib

text1 = """
This is the first line.
This is the second line.
This is the third line.
"""

text2 = """
This is the first line.
This is the modified second line.
This is the fourth line.
"""

diff = difflib.ndiff(text1.splitlines(), text2.splitlines())


print("\n".join(diff))

# Вывод:
#   This is the first line.
# - This is the second line.
# + This is the modified second line.
# ?            +++++++++
# 
# - This is the third line.
# ?               ---
# 
# + This is the fourth line.
# ?             ++++
#           ^



# Более наглядное сравнение:

diff = difflib.unified_diff(text1.splitlines(), text2.splitlines(), fromfile='file1.txt', tofile='file2.txt')
print("\n".join(diff))



# Вывод:
# --- file1.txt
# +++ file2.txt
# @@ -1,4 +1,4 @@
# 
#  This is the first line.
# -This is the second line.
# +This is the modified second line.
# -This is the third line.
# +This is the fourth line.



#  Сравнение HTML:
from difflib import HtmlDiff

html_diff = HtmlDiff()
table = html_diff.make_table(text1.splitlines(), text2.splitlines(), fromdesc='file1.txt', todesc='file2.txt')

with open('diff.html', 'w') as f:
    f.write(table) #  Сохранение результата в HTML файл

⬆️ В этом примере демонстрируется использование функций ndiff и unified_diff для сравнения двух строк построчно. ndiff показывает различия с помощью специальных символов: - для удаленных строк, + для добавленных и ? для изменений внутри строки. unified_diff предоставляет более компактный вывод, похожий на формат патчей. Также показан пример использования HtmlDiff для создания HTML-таблицы с различиями, что удобно для визуального сравнения. 🐍 Pythoner

Миграция в облако? Это легко! Собственная инфраструктура устарела или не справляется с нагрузками? Используйте облачные ресурсы! Эксперты Yandex Cloud помогут перейти в облако быстро, легко и безопасно. ✅ Мы полностью сопровождаем процесс. ✅ От вас — только инженер с доступом к инфраструктуре. ✅ Архитектура под ваши задачи, миграция и поддержка на каждом шагу — всё включено. ⚡Переходите в Yandex Cloud и забудьте о старом железе. А если успеете подать заявку до 31 декабря, мы покроем расходы на инженеров и тестовую инфраструктуру. Подать заявку #реклама 16+ yandex.cloud О рекламодателе Реклама на Яндексе

✈️ В Python FastAPI — это современный, высокопроизводительный веб-фреймворк для создания API. Он основан на стандартах OpenAPI и JSON Schema, что обеспечивает автоматическую генерацию интерактивной документации и валидацию данных. FastAPI использует асинхронный подход (ASGI), что делает его одним из самых быстрых Python фреймворков. ➡️ Применение FastAPI идеально подходит для разработки API, микросервисов, backend-систем и других веб-приложений, где требуется высокая производительность, простота разработки и надежная валидация данных. Автоматическая генерация документации существенно упрощает взаимодействие с API. ➡️ Вот пример простого приложения FastAPI:

from fastapi import FastAPI, Query, Path, HTTPException
from pydantic import BaseModel
from typing import List, Optional

app = FastAPI(title="My Awesome API", version="1.0.0", description="Example FastAPI application")


class Item(BaseModel):
    name: str
    description: Optional[str] = None
    price: float
    tax: Optional[float] = None


@app.get("/")  # GET-запрос на корневой путь
async def root():
    return {"message": "Hello World"}


@app.get("/items/{item_id}")  # GET-запрос с параметром пути
async def read_item(item_id: int = Path(..., title="The ID of the item to get", ge=1)): # Валидация параметра пути
    return {"item_id": item_id}


@app.get("/items/")
async def read_items(q: Optional[str] = Query(None, min_length=3, max_length=50)): # Валидация query-параметра
    results = {"items": [{"item_id": "foo"}, {"item_id": "bar"}]}
    if q:
        results.update({"q": q})
    return results



@app.post("/items/", response_model=Item)  # POST-запрос с валидацией тела запроса
async def create_item(item: Item):
    return item


@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
    return {"item_id": item_id, **item.dict()}


@app.get("/users/{user_id}")
async def get_user(user_id: int):
    # Пример обработки ошибок
    if user_id == 404:
        raise HTTPException(status_code=404, detail="User not found")
    return {"user_id": user_id}

# Запуск приложения
uvicorn main:app --reload

⬆️ В этом примере демонстрируется создание приложения FastAPI, определение GET и POST маршрутов, использование параметров пути и запроса с валидацией, работа с Pydantic моделями для валидации тела запроса и обработка ошибок с помощью HTTPException. Для запуска приложения используйте команду uvicorn main:app --reload, где main — имя файла, а app — имя экземпляра FastAPI. После запуска перейдите по адресу /docs в браузере, чтобы увидеть автоматически сгенерированную интерактивную документацию. 🐍 Pythoner

✈️ В Python dataclasses — это модуль, предоставляющий декоратор @dataclass, который автоматически генерирует шаблонный код для классов, преимущественно предназначенных для хранения данных. Это упрощает создание классов с атрибутами, методами __init__, __repr__, __eq__ и другими, без необходимости писать их вручную. ➡️ Применение dataclasses позволяет сократить объем кода, улучшить его читаемость и уменьшить вероятность ошибок, связанных с ручным написанием шаблонного кода. Они особенно полезны для создания классов, представляющих структуры данных или объекты с простым набором атрибутов. ➡️ Вот пример использования dataclasses:

from dataclasses import dataclass, field

@dataclass(order=True)  # order=True добавляет методы сравнения
class Person:
    name: str
    age: int
    city: str = "Unknown"  # Значение по умолчанию
    email: str = field(default="no_email@example.com", repr=False) # repr=False скрывает поле в __repr__
    scores: list[int] = field(default_factory=list)  # mutable default value


person1 = Person("Alice", 30, "New York", scores=[100, 90])
person2 = Person("Bob", 25, "Los Angeles")
person3 = Person("Charlie", 35, scores=[80, 85])
person4 = Person("Alice", 30, "New York", scores=[100, 90])


print(person1)  # Вывод: Person(name='Alice', age=30, city='New York', scores=[100, 90])
print(person2)  # Вывод: Person(name='Bob', age=25, city='Los Angeles', scores=[])
print(person3) # Вывод: Person(name='Charlie', age=35, city='Unknown', scores=[80, 85])

print(person1 == person4) # True
print(person1 > person2) # True  (сравнение по name, затем age)


# Изменение атрибутов:
person1.city = "San Francisco"
person1.scores.append(95)

print(person1)  # Вывод: Person(name='Alice', age=30, city='San Francisco', scores=[100, 90, 95])

# Post-init processing
@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def __post_init__(self):
        self.total_cost = self.unit_price * self.quantity_on_hand



item = InventoryItem("Pen", 1.5, 50)
print(item.total_cost) # 75.0

⬆️ В этом примере показано создание dataclass Person с различными типами полей, включая значение по умолчанию, field для скрытия поля в __repr__ и default_factory для изменяемых значений по умолчанию. Демонстрируется вывод информации о dataclass с помощью print, сравнение объектов dataclass и изменение атрибутов. Также приведен пример использования __post_init__ для выполнения действий после инициализации dataclass, как, например, вычисление total_cost в InventoryItem. order=True позволяет сравнивать экземпляры dataclass. 🐍Pythoner

✈️ В Python си-коллбеки (C callbacks) — это механизм, позволяющий вызывать функции, написанные на языке C или C++, из Python кода. Это мощный инструмент для интеграции Python с существующими библиотеками C/C++ или для оптимизации производительности критически важных участков кода. ➡️ Применение си-коллбеков находит применение в различных областях, таких как: * Интеграция с C/C++ библиотеками: вызов функций из библиотек, написанных на C/C++, непосредственно из Python. * Оптимизация производительности: реализация критичных к производительности участков кода на C/C++ и вызов их из Python. * Обработка событий: использование функций Python в качестве обработчиков событий в C/C++ приложениях. * Расширение функциональности Python: добавление новых возможностей в Python с помощью C/C++. ➡️ Вот пример использования си-коллбеков с ctypes:

import ctypes
import time

# Загрузка библиотеки C (libcallback_example.so - пример,  нужно скомпилировать код C)
lib = ctypes.CDLL("./libcallback_example.so")

# Определение типа функции обратного вызова
CMPFUNC = ctypes.CFUNCTYPE(None, ctypes.c_int)


# Функция Python, которая будет использоваться в качестве обратного вызова
def my_callback(value):
    print(f"Python callback called with value: {value}")



# Регистрация функции обратного вызова в библиотеке C
#  Предполагается, что в библиотеке C есть функция register_callback, принимающая указатель на функцию
register_callback = lib.register_callback
register_callback.argtypes = [CMPFUNC]
register_callback.restype = None
register_callback(CMPFUNC(my_callback))


# Вызов функции C, которая будет периодически вызывать функцию обратного вызова
# Предполагается, что в библиотеке C есть функция run_loop, которая запускает цикл
run_loop = lib.run_loop
run_loop.argtypes = []
run_loop.restype = None
run_loop()

Пример кода на C (callback_example.c):

#include <stdio.h>
#include <unistd.h> // for sleep


typedef void (*callback_function)(int);

static callback_function registered_callback = NULL;

void register_callback(callback_function callback) {
    registered_callback = callback;
}

void run_loop() {
    int i = 0;
    while (i < 5) {
        sleep(1);
        if (registered_callback != NULL) {
            registered_callback(i);
        }
        i++;
    }
}

Компиляция кода на C:

gcc -shared -o libcallback_example.so -fPIC callback_example.c

⬆️ В этом примере показано, как использовать ctypes для вызова функций из динамически подключаемой библиотеки C и передачи функции Python в качестве обратного вызова. Код на C регистрирует коллбек и периодически вызывает его. Важно правильно определить типы данных с помощью ctypes.CFUNCTYPE и argtypes/restype. Перед запуском Python кода необходимо скомпилировать код C в shared library (.so файл для Linux). 🐍 Pythoner

✈️ В Python BeautifulSoup4 (bs4) — это мощная библиотека для парсинга HTML и XML документов. Она предоставляет удобный интерфейс для навигации, поиска и модификации элементов в древовидной структуре документа. BeautifulSoup4 автоматически обрабатывает некорректный HTML, что делает её незаменимой для работы с реальными веб-страницами. ➡️ Применение BeautifulSoup4 широко распространено в веб-скрапинге, извлечении данных, анализе веб-контента и автоматизации задач, связанных с обработкой HTML и XML. Библиотека позволяет легко извлекать текст, ссылки, атрибуты и другие данные из веб-страниц. ➡️ Вот пример использования BeautifulSoup4 для парсинга HTML:

from bs4 import BeautifulSoup

html_content = """
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Example Page</title>
    <meta name="description" content="Example description">
</head>
<body>
    <h1>This is a heading</h1>
    <p>This is some text in a paragraph.</p>
    <a href="https://www.example.com">This is a link</a>
    <ul>
        <li>Item 1</li>
        <li>Item 2</li>
    </ul>
    <div class="my-class">This is a div</div>

    <p id="my-id">This is a paragraph with id </p>
</body>
</html>
"""

soup = BeautifulSoup(html_content, "html.parser")  # "html.parser" - используемый парсер


# Навигация и поиск элементов:
title = soup.title.string  # Получение текста заголовка
print("Title:", title)

description = soup.find("meta", attrs={"name": "description"})["content"]
print("Description:", description)


links = soup.find_all("a")
for link in links:
    print("Link:", link["href"])

paragraphs = soup.find_all("p")
for p in paragraphs:
    print("Paragraph:", p.text)

list_items = soup.find("ul").find_all("li")
for item in list_items:
    print("List item:", item.text)

div_with_class = soup.find("div", class_="my-class")
print("Div with class:", div_with_class.text)

paragraph_with_id = soup.find("p", id="my-id")
print("Paragraph with id:", paragraph_with_id.text)



# Модификация HTML:

new_paragraph = soup.new_tag("p")
new_paragraph.string = "This is a new paragraph."
soup.body.append(new_paragraph)

print(soup.prettify()) #  Вывод измененного HTML с отступами

⬆️ В этом примере демонстрируется создание объекта BeautifulSoup из HTML-строки, получение заголовка, поиск элементов по тегам, атрибутам и классам, извлечение текста и атрибутов элементов, а также добавление нового элемента в HTML-структуру. Используется парсер "html.parser", который встроен в Python. Для более сложных случаев можно использовать другие парсеры, такие как lxml или html5lib. Вывод soup.prettify() позволяет увидеть форматированный HTML-код после внесенных изменений. 🐍 Pythoner

🐍Разбор Что возвращает метод строки find()? Самый быстрый способ это узнать — заглянуть в документацию Python. Согласно официальной документации, если подстрока не найдена, метод `find()` возвращает -1. Теперь интересный момент: что произойдет, если преобразовать `-1` в логическое значение? Давайте проверим:

print(bool(-1))  # Результат: True

Как видите, -1 в Python считается истинным значением (True) при приведении к типу bool.

✈️ В 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