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

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

✈️Сегодня поговорим о вечном противостоянии в мире тестирования. Знаете, как в споре "табы или пробелы", у нас есть другая горячая тема: 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

✈️ Conda — это кроссплатформенный менеджер пакетов и система управления окружением, которая упрощает установку, обновление и управление пакетами, особенно для научных вычислений и анализа данных. Conda работает с языками программирования Python, R, Ruby, Lua, Scala, Java, JavaScript, C/ C++, FORTRAN.

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

➡️ Вот пример использования conda для создания и управления виртуальными окружениями:

# Создать новое окружение с Python 3.9
conda create -n my_env python=3.9

# Активировать окружение
conda activate my_env

# Установить пакеты в активное окружение
conda install numpy pandas scipy

# Просмотреть список установленных пакетов
conda list

# Деактивировать окружение
conda deactivate

# Удалить окружение
conda remove -n my_env --all

# Создать окружение из файла environment.yml
conda env create -f environment.yml

# Экспортировать окружение в файл environment.yml
conda env export > environment.yml

# Обновить все пакеты в активном окружении
conda update --all

# Поиск пакета
conda search numpy

⬆️ В этом примере показаны основные команды conda для создания, активации, деактивации и удаления виртуальных окружений. Также продемонстрировано, как устанавливать пакеты, просматривать список установленных пакетов, создавать окружение из файла environment.yml, экспортировать текущее окружение в файл environment.yml , обновлять все пакеты в окружении и искать нужный пакет. Использование виртуальных окружений с conda — лучшая практика для управления зависимостями проектов и предотвращения конфликтов.

🐍 Pythoner

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

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

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

from pathlib import Path

# Создание объекта Path
file_path = Path("my_file.txt")
directory_path = Path("my_directory")

# Проверка существования файла/директории
if file_path.exists():
    print(f"Файл {file_path} существует")
else:
    print(f"Файл {file_path} не существует")

if directory_path.exists():
    print(f"Директория {directory_path} существует")

if directory_path.is_dir():
    print(f"Это директория")

# Создание директории
directory_path.mkdir(parents=True, exist_ok=True) # parents=True создает все родительские директории при необходимости, exist_ok=True предотвращает ошибку, если директория уже существует

# Создание файла и запись в него
file_path.write_text("Hello, pathlib!")

# Чтение из файла
file_content = file_path.read_text()
print(f"Содержимое файла: {file_content}")

# Переименование файла
new_file_path = Path("my_new_file.txt")
file_path.rename(new_file_path)

# Удаление файла
new_file_path.unlink()

# Перебор файлов в директории
for file in directory_path.iterdir():
    print(file)

# Получение абсолютного пути
absolute_path = directory_path.resolve()
print(f"Абсолютный путь: {absolute_path}")


# Создание вложенных директорий и файла
nested_dir = Path("my_directory/nested/deeper")
nested_dir.mkdir(parents=True, exist_ok=True)
nested_file = nested_dir / "nested_file.txt" #  / используется для объединения путей
nested_file.write_text("Content in nested file")


import shutil

# Удаление директории и ее содержимого
shutil.rmtree(directory_path) #  rmtree из shutil используется для удаления непустых директорий

⬆️ В этом примере демонстрируются различные операции с файлами и директориями с использованием pathlib. Создаются объекты Path, проверяется существование файлов и директорий, создаются и удаляются файлы и директории, производится чтение и запись данных, переименование файлов, перебор файлов в директории и получение абсолютного пути. Также показан пример создания вложенных директорий и файла внутри них с помощью оператора /. И наконец, показано, как удалить директорию и ее содержимое с помощью shutil.rmtree.

🐍 Pythoner

😈 IT memer

✈️ Асинхронное использование httpx. В Python httpx предоставляет мощный и удобный асинхронный интерфейс для работы с HTTP-запросами. Асинхронный режим позволяет эффективно обрабатывать множество запросов параллельно, не блокируя основной поток выполнения, что особенно полезно при взаимодействии с медленными или перегруженными серверами.

➡️ Применение асинхронного httpx идеально подходит для ситуаций, где требуется высокая производительность при работе с сетью, например, при веб-скрапинге, взаимодействии с API, загрузке файлов и обработке потоковых данных. Асинхронный подход позволяет максимально использовать ресурсы системы и сократить время ожидания ответов от сервера.

➡️ Вот примеры, демонстрирующие асинхронную работу с httpx:

import asyncio
import httpx

async def fetch_page(client: httpx.AsyncClient, url: str):
    try:
        response = await client.get(url, timeout=10.0)
        response.raise_for_status()
        return {"url": url, "status_code": response.status_code, "content": response.text}
    except httpx.HTTPError as exc:
        return {"url": url, "error": f"HTTP Error: {exc}"}
    except httpx.TimeoutException:
        return {"url": url, "error": "Request timed out"}
    except Exception as e:
        return {"url": url, "error": f"An unexpected error occurred: {e}"}


async def main():
    urls = [
        "https://www.example.com",
        "https://www.google.com",
        "https://www.python.org",
        "https://this-is-an-invalid-url.com",  # Пример некорректного URL
        "https://jsonplaceholder.typicode.com/todos/1"  # Пример API
    ]

    async with httpx.AsyncClient(http2=True) as client:  # Использование HTTP/2
        tasks = [fetch_page(client, url) for url in urls]
        results = await asyncio.gather(*tasks)

    for result in results:
        print(result)




async def make_requests_with_limits(urls, max_concurrent=5):
    semaphore = asyncio.Semaphore(max_concurrent)

    async def fetch_with_semaphore(url):
        async with semaphore:
            return await fetch_page(httpx.AsyncClient(), url)


    async with httpx.AsyncClient() as client:
        tasks = [fetch_with_semaphore(url) for url in urls]
        results = await asyncio.gather(*tasks)

    for result in results:
        print(result)




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

    # Пример с ограничением числа одновременных запросов
    asyncio.run(make_requests_with_limits(["https://www.example.com"] * 10))

⬆️ В этом примере fetch_page теперь принимает httpx.AsyncClient в качестве аргумента, что позволяет использовать один клиент для всех запросов внутри main. Это способствует более эффективному использованию соединений. Добавлен пример с некорректным URL и API-запросом для демонстрации обработки ошибок и различных типов ответов. Также показано, как использовать HTTP/2 с помощью httpx.AsyncClient(http2=True). Дополнительно, представлен пример make_requests_with_limits с использованием asyncio.Semaphore для ограничения количества одновременных запросов, что позволяет контролировать нагрузку на сервер и предотвращать ошибки, связанные с превышением лимитов.

🐍 Pythoner

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

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

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

from tqdm import tqdm
import time

# Простой пример с range
for i in tqdm(range(100)):
    time.sleep(0.02)  # Имитация длительной операции


# С ручным обновлением
with tqdm(total=100) as pbar:
    for i in range(10):
        time.sleep(0.1)
        pbar.update(10) # Обновление индикатора на 10 единиц


# С описанием
for i in tqdm(range(100), desc="Обработка данных"):
    time.sleep(0.02)

# Вложенные циклы
from tqdm import trange
for i in trange(4, desc="1st loop"):
    for j in trange(5, desc="2nd loop", leave=False):
        for k in trange(50, desc="3rd loop", leave=False):
            time.sleep(0.001)

# С pandas
import pandas as pd
df = pd.DataFrame({'a': range(10000)})

# Применение tqdm к pandas DataFrame (apply с progress_apply)
tqdm.pandas() #  Необходимо для progress_apply
df['b'] = df['a'].progress_apply(lambda x: x*x) #  Индикатор выполнения для apply



# Пример с файлами
import os
with open("large_file.txt", "w") as f:
    for i in trange(10000, desc="Создание файла"):
        f.write("This is a line of text.\n")


with open("large_file.txt", "r") as f:
    for line in tqdm(f, total=os.path.getsize("large_file.txt"), unit="B", unit_scale=True, unit_divisor=1024, desc="Чтение файла"):
        # Обработка каждой строки файла
        pass

⬆️ В этом примере демонстрируются различные способы использования tqdm. Показаны примеры с range, ручным обновлением, описанием, вложенными циклами, интеграцией с pandas DataFrame с помощью progress_apply и обработкой файлов. Обратите внимание на использование tqdm.pandas() для работы с pandas. Пример с файлами показывает, как отображать прогресс чтения/записи с учетом размера файла.

🐍 Pythoner

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

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

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

import asyncio
import aioredis

async def redis_example():
    try:
        # Подключение к Redis
        redis = await aioredis.create_redis_pool(
            'redis://localhost',
            db=0,
            encoding='utf-8',  # Декодирование в UTF-8
            minsize=5,  # Минимальное количество соединений в пуле
            maxsize=10   # Максимальное количество соединений в пуле
        )


        # Работа со строками
        await redis.set('name', 'John Doe')
        name = await redis.get('name')
        print(f"Name: {name}") # Вывод: Name: John Doe



        # Работа со списками
        await redis.rpush('my_list', 'one', 'two', 'three')
        list_length = await redis.llen('my_list')
        list_items = await redis.lrange('my_list', 0, -1)
        print(f"List length: {list_length}") # Вывод: List length: 3
        print(f"List items: {list_items}") # Вывод: List items: ['one', 'two', 'three']


        # Работа с хэшами
        await redis.hset('user:1', 'name', 'Alice')
        await redis.hset('user:1', 'age', 30)
        user_data = await redis.hgetall('user:1')
        print(f"User data: {user_data}") # Вывод: User data: {'name': 'Alice', 'age': '30'}


        # Работа с множествами
        await redis.sadd('my_set', 'apple', 'banana', 'cherry')
        set_members = await redis.smembers('my_set')
        print(f"Set members: {set_members}") # Вывод: Set members: {'apple', 'banana', 'cherry'}



        #  Использование pipeline
        async with redis.pipeline(transaction=True) as pipe:  # transaction=True для атомарности операций
            await pipe.set('key1', 'value1')
            await pipe.get('key1')
            await pipe.hset('user:2', 'name', 'Bob')
            results = await pipe.execute()
        print(f"Pipeline results: {results}")



        redis.close()
        await redis.wait_closed()


    except aioredis.RedisError as e:
        print(f"Ошибка Redis: {e}")


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

⬆️ В этом примере показано асинхронное подключение к Redis с использованием aioredis.create_redis_pool, работа с различными типами данных (строки, списки, хэши, множества), и использование pipeline для пакетной обработки команд в транзакции. encoding='utf-8' в параметрах подключения обеспечивает декодирование в UTF-8. minsize и maxsize управляют размером пула соединений. Обработка исключения aioredis.RedisError помогает выявить проблемы с Redis. Важно запускать асинхронный код внутри asyncio.run.


🐍 Pythoner

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

➡️Основные возможности:
— Быстрый и эффективный подсчёт статистик по данным, таких как сумма, среднее, медиана, дисперсия.
— Аппроксимация распределений и плотностей вероятности.
— Вычисление квантилей, сглаживания, гистограмм.
— Тестирование статистических гипотез, оценка p-value.
— Генерация случайных чисел из разных распределений.

➡️Sketch позволяет ускорить статистический анализ данных с помощью простого и интуитивного API и используется для:
— Первичного анализа и визуализации данных.
— Статистических тестов в научных исследованиях.
— Построения прототипов моделей машинного обучения.
— Анализа пользовательских действий и событий.
— Симуляции процессов на основе статистических моделей.

🐍 Pythoner

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

➡️ Применение Selenium широко распространено в веб-тестировании, веб-скрапинге и автоматизации задач. Она поддерживает различные браузеры, включая Chrome, Firefox, Safari и Edge.

➡️ Вот пример использования Selenium для автоматизации открытия страницы и поиска элемента:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Инициализация драйвера Chrome (убедитесь, что ChromeDriver установлен и находится в PATH)
driver = webdriver.Chrome()

try:
    # Открытие страницы
    driver.get("https://www.example.com")

    # Явное ожидание элемента с ID "my-element" (до 10 секунд)
    element = WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.ID, "my-element"))
    )

    # Вывод текста элемента
    print(element.text)

finally:
    # Закрытие браузера
    driver.quit()

⬆️ В этом примере показано, как использовать Selenium для открытия веб-страницы, ожидания загрузки определенного элемента с помощью WebDriverWait и извлечения его текста. Убедитесь, что у вас установлен ChromeDriver и он добавлен в переменную окружения PATH или указан в executable_path при инициализации драйвера. Этот пример демонстрирует базовый сценарий использования Selenium, который можно расширить для выполнения более сложных действий, таких как заполнение форм, взаимодействие с JavaScript и обработка динамически загружаемого контента.

🐍 Pythoner

✈️ В Python typer — это современная и удобная библиотека для создания CLI-приложений (интерфейсов командной строки). Она построена на основе популярной библиотеки click и предоставляет простой и интуитивно понятный способ определения команд, аргументов и опций.

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

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

import typer

app = typer.Typer()

@app.command()
def hello(name: str):
    """
    Простое приветствие.
    """
    print(f"Привет, {name}!")

@app.command()
def goodbye(name: str, formal: bool = False):
    """
    Прощание.  Можно сделать формальным.
    """
    if formal:
        print(f"До свидания, {name}!")
    else:
        print(f"Пока, {name}!")

if __name__ == "__main__":
    app()

⬆️ В этом примере показано создание простого CLI-приложения с двумя командами: "hello" и "goodbye". Команда "hello" принимает один аргумент — имя, и выводит приветствие. Команда "goodbye" принимает имя и опциональный аргумент "formal", который определяет, будет ли прощание формальным. Запустив этот скрипт и введя python main.py --help, вы получите автоматически сгенерированную справку по использованию приложения.

🐍 Pythoner

✈️ В Python Pygments — это мощная библиотека для подсветки синтаксиса исходного кода. Она поддерживает огромное количество языков программирования и разметки, а также различные стили оформления.

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

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

from pygments import highlight
from pygments.lexers import PythonLexer
from pygments.formatters import HtmlFormatter

code = 'print("Hello, world!")'
highlighted_code = highlight(code, PythonLexer(), HtmlFormatter())
print(highlighted_code)

# <div class="highlight"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Hello, world!&quot;</span><span class="p">)</span>
# </pre></div>

⬆️ В этом примере показано, как подсветить синтаксис Python-кода с помощью Pygments и вывести результат в формате HTML. Сначала импортируются необходимые классы: highlight, PythonLexer и HtmlFormatter. Затем определяется исходный код, который нужно подсветить. Функция highlight принимает код, лексер (в данном случае PythonLexer для Python) и форматтер (в данном случае HtmlFormatter для HTML) и возвращает подсвеченный код.

🐍 Pythoner

✈️Сегодня поговорим о том, как превратить свой код в настоящий искусственный интеллект.

➡️Давайте сразу посмотрим на простой пример в PyTorch:

import torch
import torch.nn as nn

class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.layer1 = nn.Linear(784, 128)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(128, 10)
    
    def forward(self, x):
        x = self.layer1(x)
        x = self.relu(x)
        return self.layer2(x)

Создаем модель одной строчкой! 🎯
model = SimpleNet().to('cuda' if torch.cuda.is_available() else 'cpu')

➡️Круто, правда? А теперь давайте глянем, как то же самое делается в TensorFlow:

import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(10)
])

# Компилируем модель
model.compile(optimizer='adam',
             loss='sparse_categorical_crossentropy',
             metrics=['accuracy'])

➡️Для создания своей первой модели вам понадобится всего три шага:
1. Подготовка данных (самая нудная, но важная часть)
2. Определение архитектуры (тут можно пофантазировать)
3. Обучение модели (запасайтесь терпением и мощным железом)

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

# PyTorch стиль
optimizer = torch.optim.Adam(model.parameters())
criterion = nn.CrossEntropyLoss()

for epoch in range(10):
    for batch_x, batch_y in dataloader:
        optimizer.zero_grad()
        outputs = model(batch_x)
        loss = criterion(outputs, batch_y)
        loss.backward()
        optimizer.step()

🔎Крутая фишка: используйте GPU-ускорение! Одна строчка кода .to('cuda') в PyTorch или with tf.device('/GPU:0') в TensorFlow - и ваша модель учится в разы быстрее.

➡️Про что часто забывают новички? Про валидацию! Вот как это делается правильно:

# Разбиваем данные
from sklearn.model_selection import train_test_split

X_train, X_val, y_train, y_val = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Следим за метриками
val_loss = []
for epoch in range(epochs):
    model.train()
    # ... обучение ...
    
    model.eval()
    with torch.no_grad():
        val_predictions = model(X_val)
        v_loss = criterion(val_predictions, y_val)
        val_loss.append(v_loss.item())

🐍 Pythoner

✈️Признайтесь, кто из вас устал от статичных matplotlib графиков? Сегодня поговорим о том, как превратить ваши данные в интерактивные произведения искусства с помощью Plotly и Bokeh!

➡️Начинаем с Plotly

Plotly - это как швейцарский нож в мире визуализации. Вот простой пример создания интерактивного графика:

import plotly.express as px
import pandas as pd

# Создаём тестовые данные
df = pd.DataFrame({
    'Месяц': ['Янв', 'Фев', 'Март', 'Апр', 'Май'],
    'Продажи': [100, 150, 200, 180, 250],
    'Прибыль': [20, 30, 40, 35, 50]
})

# Создаём интерактивный график
fig = px.line(df, x='Месяц', y=['Продажи', 'Прибыль'],
              title='Динамика продаж и прибыли',
              template='plotly_dark')

# Добавляем hover-эффекты
fig.update_traces(mode='lines+markers', hovertemplate='%{y:,.0f}₽')

# Сохраняем как HTML или показываем в браузере
fig.write_html('sales_dashboard.html')

➡️Bokeh: Мощь серверного рендеринга

А теперь давайте создадим что-то более продвинутое с Bokeh:

from bokeh.plotting import figure, show
from bokeh.layouts import column
from bokeh.models import ColumnDataSource, HoverTool
import numpy as np

# Создаём интерактивный scatter plot
x = np.random.normal(0, 1, 1000)
y = np.random.normal(0, 1, 1000)

source = ColumnDataSource(data=dict(
    x=x,
    y=y,
    size=np.random.uniform(5, 15, 1000),
    color=['#%06x' % np.random.randint(0, 0xFFFFFF) for _ in range(1000)]
))

p = figure(width=800, height=600, title='Интерактивный Scatter Plot')
p.scatter('x', 'y', size='size', color='color', alpha=0.6, source=source)

# Добавляем интерактивные подсказки
hover = HoverTool(tooltips=[
    ('X', '@x{0.000}'),
    ('Y', '@y{0.000}'),
    ('Размер', '@size{0.00}')
])
p.add_tools(hover)

show(p)

👀Продвинутые фичи

🔎Вот несколько крутых возможностей, о которых многие не знают:

➡️Анимированные переходы в Plotly:

import plotly.graph_objects as go

fig = go.Figure(
    data=[go.Scatter(x=[1, 2, 3], y=[1, 3, 2])],
    layout=dict(
        updatemenus=[dict(
            type="buttons",
            buttons=[dict(label="Play",
                         method="animate",
                         args=[None])]
        )]
    )
)

➡️Real-time обновления в Bokeh:

from bokeh.plotting import curdoc
from functools import partial
from tornado.ioloop import IOLoop

def update():
    source.data['y'] = np.random.rand(100)
    
curdoc().add_periodic_callback(update, 100)  # Обновление каждые 100мс

➡️Pro-tip: Для больших датасетов используйте датаклассы и оптимизируйте память:

from dataclasses import dataclass
from typing import List

@dataclass
class DataPoint:
    x: float
    y: float
    category: str

data_points: List[DataPoint] = []  # Эффективнее, чем DataFrame для больших данных

⚡️Личный опыт: недавно делал дашборд для финтех-проекта. Начал с Matplotlib, намучался с интерактивностью, переписал на Plotly - заказчик в восторге, пользователи счастливы. Время разработки сократилось вдвое!

➡️Что выбрать?
- Plotly: если нужны красивые графики "из коробки" и важна простота использования
- Bokeh: если работаете с большими данными или нужна глубокая кастомизация

🐍 Pythoner

🎄 В Python transformers — это мощная и популярная библиотека, разработанная Hugging Face, предоставляющая простой доступ к предобученным моделям для обработки естественного языка (NLP). Она включает в себя широкий спектр моделей, таких как BERT, GPT, RoBERTa, T5 и другие, для решения разнообразных задач, включая классификацию текста, машинный перевод, вопрос-ответ, генерацию текста и многое другое.

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

➡️ Вот пример использования transformers для классификации текста:

from transformers import pipeline

classifier = pipeline("sentiment-analysis")  #  Загрузка предобученной модели для анализа тональности текста

results = classifier([
    "I love this library!",
    "This is a terrible movie.",
    "This is a neutral statement."
])

for result in results:
    print(result)

#  Примерный вывод:
# [{'label': 'POSITIVE', 'score': 0.9998950958251953}]
# [{'label': 'NEGATIVE', 'score': 0.9991175532341003}]
# [{'label': 'NEGATIVE', 'score': 0.9865201115608215}] #  Модель может ошибаться, особенно на нейтральных высказываниях



from transformers import pipeline

generator = pipeline('text-generation', model='gpt2') # Загрузка модели для генерации текста

text = generator("Once upon a time, there was a large language model.", max_length=50, num_return_sequences=2)

for generated_text in text:
    print(generated_text['generated_text'])

# Примерный вывод (будет отличаться при каждом запуске):
# Once upon a time, there was a large language model. It was trained on a massive dataset of text and code, and it could generate text, translate languages, write different kinds of creative content, and answer your questions in an informative way.
# Once upon a time, there was a large language model. And he lived in a little house made of straw. One day, he was sitting in his house, reading a book


from transformers import pipeline

summarizer = pipeline("summarization")

text = """
The quick brown fox jumps over the lazy dog. This is a test sentence.  
It is used to demonstrate text summarization.  The fox is brown and quick.
The dog is lazy.  Summarization is a useful NLP task.
"""

summary = summarizer(text, max_length=30, min_length=10, do_sample=False)

print(summary[0]['summary_text'])
# Примерный вывод:
# The quick brown fox jumps over the lazy dog. It is used to demonstrate text summarization. The fox is brown and quick. The dog is lazy.

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

🐍 Pythoner

🎄 В Python datasets — это мощная библиотека, разработанная Hugging Face, для удобной загрузки, обработки и управления датасетами, используемыми в задачах машинного обучения, особенно в области обработки естественного языка (NLP). Она предоставляет доступ к огромному количеству общедоступных датасетов и инструменты для создания собственных.

➡️ Применение datasets упрощает работу с данными, позволяя быстро загружать датасеты из различных источников, таких как Hugging Face Hub, CSV/JSON файлы и другие. Библиотека также предоставляет функциональность для фильтрации, сортировки, преобразования и разделения данных на обучающие, валидационные и тестовые наборы.

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

from datasets import load_dataset

# Загрузка датасета "imdb" с Hugging Face Hub
dataset = load_dataset("imdb")

print(dataset)
# Вывод: DatasetDict({
#     train: Dataset({
#         features: ['text', 'label'],
#         num_rows: 25000
#     })
#     test: Dataset({
#         features: ['text', 'label'],
#         num_rows: 25000
#     })
#     unsupervised: Dataset({
#         features: ['text', 'label'],
#         num_rows: 50000
#     })
# })

train_data = dataset['train']

print(train_data[0]) #  Доступ к первому примеру в обучающем наборе
# Вывод: {'text': 'A series of escapades demonstrating the adage that what is good for the goose is also good for the gander, some of which occasionally amuses but none of which amounts to much of a story.', 'label': 0}



small_train_dataset = dataset["train"].shuffle(seed=42).select(range(1000)) # Перемешивание и выборка


from datasets import ClassLabel
import random
import pandas as pd

def show_random_elements(dataset, num_examples=10):
    picks = []
    n = len(dataset)
    for _ in range(num_examples):
        pick = random.randint(0, n - 1)
        picks.append(dataset[pick])

    df = pd.DataFrame(picks)
    if isinstance(dataset.features['label'], ClassLabel):
        df['label'] = df['label'].apply(lambda x: dataset.features['label'].int2str(x))

    print(df)

show_random_elements(small_train_dataset)

#  Вывод: таблица с 10 случайными примерами

⬆️ В этом примере демонстрируется загрузка датасета "imdb" с помощью load_dataset. Выводится информация о структуре датасета и показан доступ к отдельным примерам. Также представлен пример перемешивания и выборки подмножества данных для создания меньшего обучающего набора. Функция show_random_elements демонстрирует удобный способ просмотра случайных элементов из датасета в формате таблицы, обрабатывая при этом ClassLabel для отображения понятных названий меток.

🐍 Pythoner

🎄Дорогие подписчики, поздравляем вас с Новым годом! 🎄

Спасибо что читаете, ставите реакции и комментируете наш канал 🥰

И самое главное помните что следующий год предоставит вам гораздо больше возможностей для роста. Наш информационный канал поможет вам стать гораздо лучше и достичь всех начинаний которых вы хотите, и также напоминаем что Новый год - это семейный праздник, сделайте всё возможное чтобы встретить его в кругу близких друзей и родных, всего самого наилучшего, в новом 2025 году!

✈️В мире Python-разработки часто возникает путаница между методами и функциями. Давайте детально разберем эти важные концепции и научимся их правильно использовать.

➡️Что такое функция?

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

def calculate_area(length, width):
    return length * width

# Использование функции
room_area = calculate_area(5, 4)
print(f"Площадь комнаты: {room_area} кв.м.")

➡️Что такое метод?

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

class BankAccount:
    def __init__(self, balance):
        self.balance = balance
    
    def deposit(self, amount):
        self.balance += amount
        return f"Новый баланс: {self.balance}"

# Использование метода
account = BankAccount(1000)
account.deposit(500)  # Вызов метода через объект

🔎Ключевые различия

1. Область видимости:

- Функции работают с переданными им аргументами
- Методы имеют доступ к данным объекта через self

2. Способ вызова:

- Функции вызываются напрямую: function_name()
- Методы вызываются через объект: object.method()

3. Контекст выполнения:

- Функции независимы от контекста
- Методы всегда работают в контексте своего класса

💡Практические примеры использования

➡️Когда использовать функции:
• Для операций, не требующих доступа к состоянию объекта
• При работе с независимыми данными
• Для создания утилитарных операций

➡️Когда использовать методы:
• При работе с данными объекта
• Когда логика тесно связана с классом
• Для реализации поведения объекта

🐍 Pythoner