Python для новичков

🎨 Работа с сериями изображений в Python с помощью scikit-image Python — незаменимый инструмент для обработки изображений. Когда дело доходит до работы с несколькими изображениями — будь то слайд-шоу, кадры с камеры или серия снимков для ML-проекта — нам нужно что-то мощное и удобное. И тут на сцену выходит scikit-image. Scikit-image — это библиотека на базе NumPy, предназначенная для обработки изображений. Она умеет всё: от базовой фильтрации до сложного анализа форм и объектов. А ещё — она умеет работать с сериями изображений. 📦 Установка: Если вы ещё не установили библиотеку:

    
        pip install scikit-image
{}
    

🔍 Загрузка серии изображений Допустим, у вас есть папка с изображениями .png или .jpg. Вместо того чтобы грузить каждое вручную, используем skimage.io.imread_collection.

    
        from skimage.io import imread_collection

images = imread_collection('images/*.png')  # Загружаем все .png из папки images
{}
    

Теперь images — это коллекция, с которой можно обращаться как со списком. Например, images[0] — первое изображение, а len(images) — общее количество. 🛠️ Обработка серии Допустим, вы хотите перевести все кадры в оттенки серого. Можно использовать skimage.color.rgb2gray:

    
        from skimage.color import rgb2gray

gray_images = [rgb2gray(img) for img in images]
{}
    

Хотите применить фильтр Гаусса ко всем изображениям?

    
        from skimage.filters import gaussian

blurred = [gaussian(img, sigma=1) for img in gray_images]
{}
    

📊 Построим гистограммы яркости Иногда нужно проанализировать распределение яркости в серии. Используем skimage.exposure.histogram:

    
        from skimage.exposure import histogram
import matplotlib.pyplot as plt

for i, img in enumerate(gray_images[:3]):
    hist, hist_centers = histogram(img)
    plt.plot(hist_centers, hist, label=f'Image {i}')
    
plt.legend()
plt.title("Brightness histograms")
plt.show()
{}
    

🎞️ Построение таймлапса Допустим, вы обработали серию и теперь хотите сохранить новую последовательность:

    
        from skimage.io import imsave
import os

output_dir = 'processed'

if not os.path.exists(output_dir):
    os.makedirs(output_dir)

for i, img in enumerate(blurred):
    imsave(f'{output_dir}/frame_{i:03d}.png', img)
{}
    

🧠 Идеи для практики: - Сделайте маску объектов на каждом кадре с помощью skimage.filters.threshold_otsu. - Выделите контуры с skimage.feature.canny. - Сравните движение объектов между изображениями. Scikit-image — настоящий швейцарский нож в мире изображений. Он понятен, лаконичен и отлично дружит с NumPy. Работать с сериями изображений с его помощью — одно удовольствие, а возможности практически безграничны.

https://t.me/info_sol У админа этого канала есть личный блог, в котором он пишет про саморазвитие, нейросети, постит картинки и созданную в нейросетях музыку. Подписывайтесь )

🎨 Простейшие графические редакторы с использованием библиотеки tkinter Каждому программисту когда-то хочется превратить консольную рутину во что-то более… зрелищное. Если вы только начинаете осваивать Python – отличной отправной точкой может стать создание собственного графического редактора с помощью tkinter, стандартной библиотеки GUI в Python. Да-да, самый настоящий Paint в несколько десятков строк! tkinter поставляется в комплекте с Python, так что ничего дополнительно устанавливать не нужно. Запускаем редактор – и рисуем прямо мышкой. Прекрасная демонстрация того, как события и интерактивность работают в Python. Разберем базовую версию редактора — с возможностью рисования линий мышкой. Вот простой пример:

    
        import tkinter as tk

class SimplePaint:
    def __init__(self, root):
        self.root = root
        self.root.title("Mini Paint")
        self.canvas = tk.Canvas(root, bg="white", width=600, height=400)
        self.canvas.pack(fill=tk.BOTH, expand=True)
        
        self.last_x, self.last_y = None, None

        self.canvas.bind("<Button-1>", self.start_draw)
        self.canvas.bind("<B1-Motion>", self.draw_line)

    def start_draw(self, event):
        self.last_x, self.last_y = event.x, event.y

    def draw_line(self, event):
        x, y = event.x, event.y
        self.canvas.create_line(self.last_x, self.last_y, x, y, fill="black", width=2)
        self.last_x, self.last_y = x, y

root = tk.Tk()
app = SimplePaint(root)
root.mainloop()
{}
    

Что здесь происходит: - Мы создаем окно и холст (canvas), на котором можно рисовать. - Событие <Button-1> (нажатие левой кнопки мыши) отслеживает начало рисования. - <B1-Motion> ловит перемещения мыши при нажатой кнопке и соединяет координаты линиями. Теперь добавим выбор цвета — немного разнообразия:

    
        from tkinter.colorchooser import askcolor

def choose_color():
    color = askcolor()[1]
    if color:
        app.current_color = color

color_btn = tk.Button(root, text="Color", command=choose_color)
color_btn.pack()
{}
    

Добавим в класс:

    
        self.current_color = "black"
...
self.canvas.create_line(self.last_x, self.last_y, x, y, fill=self.current_color, width=2)
{}
    

Хотите очистить холст? Пожалуйста:

    
        def clear_canvas():
    app.canvas.delete("all")

clear_btn = tk.Button(root, text="Clear", command=clear_canvas)
clear_btn.pack()
{}
    

В результате — у нас простенький редактор с выбором цвета и кнопкой очистки. Интересно? На основе такой базы можно реализовать: - выбор толщины линии; - сохранение в PNG (с помощью PIL); - разные инструменты (овал, прямоугольник, ластик — да, просто белая линия!); - undo/redo с помощью хранения команд; - и даже распознавание фигур, если вы фанат ML. tkinter — отличный способ перейти из мира print('Hello') в более наглядный и живой Python. Начните с мини-графредактора, а дальше — рамки только в вашем воображении.

https://t.me/info_sol Саморазвитие Полезные нейросети Интересные книги Хорошие авторские песни И многое другое тут: https://t.me/info_sol Подписывайтесь!

🚀 Быстрая обработка гигантских наборов данных с использованием библиотеки Vaex Обработка миллионов строк данных за секунды — звучит как фантастика? Для pandas — возможно, но не факт. А вот для Vaex — это его стихия. В этом посте я расскажу о том, как справляться с большими объёмами данных с помощью библиотеки Vaex — легковесного и ультрабыстрого инструмента для анализа данных на Python. 🧠 Что такое Vaex? Vaex — это библиотека для обработки больших табличных данных, созданная с фокусом на производительность. В отличие от pandas, она использует ленивые вычисления (lazy evaluation), memory-mapping и мультиядерные вычисления для обработки данных в десятки раз быстрее. Миллионы строк? Подумаешь. Даже миллиард — не предел. Вот ключевые фишки Vaex: - Обработка данных, которые не помещаются в оперативную память. - Поддержка ленивых операций (т.е. ничего не считается до тех пор, пока не попросишь). - Использование zero-copy memory access — данные читаются прямо с диска без загрузки в RAM. - Интеграция с файловыми форматами Arrow, HDF5 и Parquet. 📦 Установка Устанавливаем библиотеку:

    
        pip install vaex
{}
    

🚀 Быстрый старт Допустим, у нас есть CSV-файл с 50 миллионами строк. Попробуем прочитать его и посмотреть средние значения по колонке:

    
        import vaex

# Быстрая загрузка большого файла
df = vaex.from_csv('big_data.csv', convert=True, chunk_size=5_000_000)

# Просмотр первых строк, как в pandas
print(df.head())

# Вычисление средней температуры, к примеру
mean_temp = df['temperature'].mean()
print(f"Mean temperature: {mean_temp}")
{}
    

Метод from_csv с параметром convert=True один раз конвертирует CSV в более быстрый бинарный формат Arrow/HDF5, чтобы в будущем грузиться мгновенно. 🧪 Где быстрее, чем в pandas? Vaex особенно хорош для агрегаций и фильтраций. Сравним простую агрегацию:

    
        # Средняя цена по категориям
df.groupby('category', agg={'avg_price': vaex.agg.mean('price')})
{}
    

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

    
        # Отфильтруем дорогие продукты
df_filtered = df[df.price > 1000]

# Считаем средний рейтинг у дорогих товаров
print(df_filtered['rating'].mean())
{}
    

🔥 Визуализация огромных данных Vaex умеет делать биннинг (разбиение по диапазонам), что особенно полезно при визуализации плотных scatter-плотов:

    
        df.plot(df.x, df.y, f='log1p', shape=512)
{}
    

Да, прямо так. Интерактивное, быстрое, работает на миллионах точек. 📁 Разделение и экспорт Вы можете экспортировать уже отфильтрованные или агрегированные данные обратно в Parquet или CSV:

    
        df_filtered.export_parquet('filtered_data.parquet')
{}
    

🧩 Vaex против pandas Время выполнения задачи агрегации в pandas: десятки секунд или даже минуты (и возможный MemoryError). В Vaex — доли секунды. И не нужно думать, достаточно ли у тебя оперативки. 📌 Используй тогда, когда: - Твои данные занимают десятки или сотни ГБ - pandas падает с ошибками памяти - Требуется быстрая агрегация, фильтрация, группировка - Нужно делать всё это без громоздких кластеров Spark/Dask ✨ Вывод Vaex — отличный инструмент, когда речь идёт о больших объемах данных и важна скорость. Он не заменяет pandas как основной инструмент работы с данными, но для heavy-duty аналитики — просто must-have. Попробуй использовать его в своём следующем дата-проекте — и удивишься, насколько это быстро.

🔥 Как использовать библиотеки для автоматического тестирования веб-приложений Сегодня поговорим о настоящем магическом арсенале Python — библиотеках для автоматизированного тестирования веб-приложений. Зачем вручную кликать по кнопкам и проверять, что форма отправляется, если можно поручить это роботу? Да, автоматизация тестирования — это не только для корпораций с огромным QA-отделом. Даже если ты пишешь свой первый сайт на Flask — запускать тесты «по кнопке» и быть уверенным, что ничего не сломано после очередного коммита — бесценно. Давайте рассмотрим две популярные библиотеки: Selenium и pytest, плюс кратко затронем requests и BeautifulSoup для API и контентных проверок. 🎯 Selenium — когда надо кликать мышкой и вводить текст Selenium позволяет имитировать поведение пользователя в браузере: запустить сайт, заполнить поля, нажать кнопки и проверить, как всё работает. Вот простой пример с использованием Chrome WebDriver:

    
        from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys

driver = webdriver.Chrome()
driver.get("https://example.com/login")

username_input = driver.find_element(By.NAME, "username")
password_input = driver.find_element(By.NAME, "password")

username_input.send_keys("test_user")
password_input.send_keys("secure_pass")
password_input.send_keys(Keys.RETURN)

assert "Dashboard" in driver.title
driver.quit()
{}
    

Этот код удобно запускать в рамках pytest или unittest. Selenium особенно полезен, когда нужно протестировать интерфейс, JavaScript и формы. 🤖 Pytest — быстрые и читаемые тесты Pytest — это ядро для любого вида тестов. Оно прекрасно умеет работать с фикстурами и параметризацией, а код остаётся чистым и читаемым. Пример интеграции с requests для проверки REST API:

    
        import requests

def test_api_status():
    response = requests.get("https://api.example.com/status")
    assert response.status_code == 200

def test_login_api():
    data = {"username": "test_user", "password": "secure_pass"}
    response = requests.post("https://api.example.com/login", json=data)
    assert response.json().get("token") is not None
{}
    

Иногда этого достаточно — особенно если ты делаешь SPA с разделённым backend. 🍜 Bonus: BeautifulSoup для проверки содержимого Допустим, приходит HTML, и хочется убедиться, что нужный блок отрисовался:

    
        from bs4 import BeautifulSoup

html = "<html><body><div id='welcome'>Hello, test_user!</div></body></html>"
soup = BeautifulSoup(html, "html.parser")
welcome_div = soup.find("div", id="welcome")
assert welcome_div.text == "Hello, test_user!"
{}
    

Не затыкай нос — HTML можно парсить, не страдая. 📦 Как собрать вместе? Обычно автоматика выглядит так: ты пишешь тесты на pytest, которые используют библиотеки вроде requests для API и selenium для UI. Запуск происходит через команду:

    
        pytest tests/
{}
    

Или, если хочется сборку в CI/CD — используется GitHub Actions или GitLab CI. Всё по-взрослому. ⚡ Итог Автоматизированное тестирование — это не роскошь. Это важный инструмент, который экономит время и нервы. Python предоставляет для этого весь необходимый инструментарий: от selenium до requests и pytest. Начни с простого, а потом постепенно автоматизируй всё, что можно. Тестируй умно — пиши код с уверенностью.

https://t.me/info_sol Саморазвитие Полезные нейросети Интересные книги Хорошие авторские песни И многое другое тут: https://t.me/info_sol Подписывайтесь!

🏗 Введение в web scraping с использованием Scrapy и Selenium Собирать данные с сайтов — это почти как добывать золото: кто вовремя начал, тот и нашёл сокровища. Web scraping позволяет автоматизировать сбор информации с сайтов, и в Python для этого есть мощные инструменты. Сегодня мы взглянем на два самых популярных — Scrapy и Selenium. 📌 Scrapy: паук, который знает, куда ползти Если вам нужно быстро и масштабируемо собирать структурированные данные, Scrapy — идеальный выбор. Это асинхронный фреймворк, созданный специально для парсинга. Установка:

    
        pip install scrapy
{}
    

Как выглядит простейший Scrapy-паук:

    
        import scrapy

class QuotesSpider(scrapy.Spider):
    name = "quotes"
    start_urls = ["http://quotes.toscrape.com/"]

    def parse(self, response):
        for quote in response.css("div.quote"):
            yield {
                "text": quote.css("span.text::text").get(),
                "author": quote.css("small.author::text").get(),
            }
{}
    

Запуск:

    
        scrapy runspider quotes_spider.py -o quotes.json
{}
    

Scrapy быстро, удобно и экономно вытянет нужные данные из HTML — пока сайт не вставляет всё содержимое с помощью JavaScript. Тогда на сцену выходит Selenium. 🚘 Selenium: браузерный пилот-робот Иногда сайты упрямо не отдают нужные данные, пока JavaScript не "догрузит" контент. Тогда у нас один выход — автоматизировать действия настоящего браузера. Установка:

    
        pip install selenium
{}
    

Пример: как с помощью Selenium вытащить цитаты со страницы с динамическим контентом:

    
        from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
import time

options = Options()
options.add_argument("--headless")
driver = webdriver.Chrome(options=options)

driver.get("http://quotes.toscrape.com/js/")
time.sleep(2)  # подождём, пока JS подгрузит контент

quotes = driver.find_elements(By.CLASS_NAME, "quote")
for q in quotes:
    text = q.find_element(By.CLASS_NAME, "text").text
    author = q.find_element(By.CLASS_NAME, "author").text
    print({"text": text, "author": author})

driver.quit()
{}
    

🔥 Scrapy против Selenium | Характеристика | Scrapy | Selenium | |----------------------|-------------------------------|-------------------------| | Скорость | Высокая (асинхронная) | Низкая (имитирует браузер) | | Поддержка JS | Нет | Да | | Использование памяти | Экономное | Тяжёлое | | Удобство отладки | Лучше для парсинга | Лучше для автотестов и сложной логики | 🧩 Идеальный сценарий — совмещать: использовать Selenium для получения HTML со сложных JS-страниц, а дальнейший парсинг делать с помощью Scrapy или BeautifulSoup. Если вы собираетесь парсить десятки тысяч страниц, стоит идти через Scrapy. Если же цель — парсинг интерактивных компонентов одной-двух страниц, Selenium подойдёт лучше. А иногда — сочетайте. Следите за "золотыми правилами" scraping-а: соблюдайте robots.txt, не перегружайте сервер запросами, и, конечно, уважайте условия использования сайта. В следующем посте мы разберём, как Scrapy можно расширять — добавим логин на сайт и парсинг нескольких уровней ссылок.

Привет! Сегодня поговорим о том, как с помощью Python и библиотеки OpenCV сделать собственное приложение для черепичной сшивки изображений (image tiling & stitching). Эта задача особенно актуальна в сфере обработки спутниковых снимков, работы с изображениями высокой чёткости или при создании панорам. Самое интересное — почти всё можно сделать на базе стандартных функций OpenCV. Да, да, без любой магии и глубокого машинного обучения. Просто рабочий пайплайн, немного математики и правильный подход. — Что такое черепичная сшивка? Представьте, что у вас есть несколько перекрывающихся фрагментов одной и той же большой сцены, но снятых по частям. Ваша задача — склеить эти плитки (tiles) в одно большое изображение. Чтобы это сделать, нужно: 1. Найти ключевые точки (keypoints) в каждом изображении. 2. Сопоставить соответствующие точки между изображениями. 3. Посчитать матрицу преобразования (гомографию). 4. Трансформировать изображения и сшить в финальную панораму. Теперь перейдем к коду. Первым делом, необходимые модули:

    
        import cv2
import numpy as np
{}
    

Теперь загрузим два изображения:

    
        image_1 = cv2.imread("tile_left.jpg")
image_2 = cv2.imread("tile_right.jpg")
{}
    

Далее — извлечение ключевых точек и дескрипторов с помощью ORB:

    
        orb = cv2.ORB_create(nfeatures=2000)

kp1, des1 = orb.detectAndCompute(image_1, None)
kp2, des2 = orb.detectAndCompute(image_2, None)
{}
    

Для поиска совпадений используем BFMatcher:

    
        bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
matches = bf.match(des1, des2)
matches = sorted(matches, key=lambda x: x.distance)
{}
    

Отфильтруем и найдем гомографию:

    
        src_pts = np.float32([kp1[m.queryIdx].pt for m in matches[:50]]).reshape(-1,1,2)
dst_pts = np.float32([kp2[m.trainIdx].pt for m in matches[:50]]).reshape(-1,1,2)

H, mask = cv2.findHomography(dst_pts, src_pts, cv2.RANSAC, 5.0)
{}
    

И наконец — применим гомографию и объединим изображения:

    
        height, width = image_1.shape[:2]
image_2_warped = cv2.warpPerspective(image_2, H, (width * 2, height))
image_2_warped[0:height, 0:width] = image_1

cv2.imwrite("stitched_output.jpg", image_2_warped)
{}
    

— Приложение, построенное на этом пайплайне, способно объединить десятки изображений в одну панораму. Конечно, для большого количества тайлов придётся реализовать логику автоматического выбора пар изображений, контроля перекрытия и конечной обрезки границ. Но фундамент уже есть. Можно также использовать SIFT или AKAZE вместо ORB, повысить количество фич, настроить лучшее сопоставление по расстоянию — и ваша сшивка будет максимально качественной. Бонус: если изображения GRID-подобные (например, каждая плитка — квадрат одной мозаики), можно автоматизировать позиции сшивки заранее, что даст прирост скорости. А если вы работаете с гигабайтными изображениями — добавьте Pillow или Dask для потоковой обработки. С OpenCV и всего сотней строк кода на Python вы можете превратить десятки скучных фрагментов в полноценную мозаику мира.

Когда Python встречает физику: симулятор с помощью NVIDIA PhysX Что объединяет гоночные симуляторы, реалистичную анимацию разрушений и эффектное поведение объектов на сцене? Конечно, физика. А если быть конкретнее — движок PhysX, изначально разработанный Ageia, а позже поглощённый NVIDIA. Он лежит в основе механики многих игр и симуляторов. Но что, если мы хотим использовать его вместе с Python? Благодаря проекту physx-python от NVIDIA, теперь это возможно. Интуитивный интерфейс Python позволяет собирать полноценные трёхмерные сцены с телами, гравитацией и столкновениями — и всё это с минимальной настройкой. Что потребуется? - Установленный Python 3.8+ - Установленный модуль physx (доступен через PyPI или GitHub) - Знание базовых концепций физики (масса, силы, импульсы) Установка:

    
        pip install physx
{}
    

Сборка первой сцены Создадим простую сцену: куб падает на плоскость под действием гравитации.

    
        from physx import PxPhysics, PxSceneDesc, PxDefaultErrorCallback, PxDefaultAllocator, PxSimulationEventCallback
from physx import PxRigidStatic, PxRigidDynamic, PxShape, PxBoxGeometry, PxMaterial, PxTransform, PxVec3

physics = PxPhysics()
material = physics.create_material(0.5, 0.5, 0.6)

scene_desc = PxSceneDesc(gravity=PxVec3(0, -9.81, 0))
scene = physics.create_scene(scene_desc)

# Создаем землю (плоскость)
ground_shape = physics.create_shape(PxBoxGeometry(50, 1, 50), material)
ground_body = physics.create_rigid_static(transform=PxTransform(p=PxVec3(0, -1, 0)))
ground_body.attach_shape(ground_shape)
scene.add_actor(ground_body)

# Создаем динамический куб
box_shape = physics.create_shape(PxBoxGeometry(1, 1, 1), material)
box_body = physics.create_rigid_dynamic(transform=PxTransform(p=PxVec3(0, 5, 0)))
box_body.attach_shape(box_shape)
scene.add_actor(box_body)
{}
    

Теперь запустим симуляцию:

    
        time_step = 1.0 / 60.0  # 60 FPS
for step in range(120):
    scene.simulate(time_step)
    scene.fetch_results()
    pos = box_body.get_global_pose().p
    print(f"Step {step}: Box Y={pos.y:.2f}")
{}
    

На выходе мы получим по кадрам, как куб падает и отскакивает — PhysX учитывает инерцию, массу, трение и отскок автоматически. Почему PhysX и не, скажем, Pymunk или Box2D? - PhysX — это полноценная 3D-физика. Большинство Python-движков оперируют 2D. - Оптимизация. PhysX используется в AAA-проектах и оптимизирован под реальные нагрузки. - Расширяемость. С PhysX можно моделировать не только твердые тела, но и жидкости, ткани, разрушения (через расширения). Советы: - Обрабатывайте столкновения через колбэки (наследуйте PxSimulationEventCallback) - Используйте инерцию и силы, а не вручную перемещайте тела - Не забывайте освобождать ресурсы (release()) PhysX с Python — это серьезный инструмент для тех, кто хочет симулировать реальные процессы: от гравитации и столкновений до сложного взаимодействия объектов. Создавайте симуляторы роботов, физические головоломки или тестируйте алгоритмы управления — теперь это возможно без написания ни строчки C++. Следующий шаг? Визуализация. А значит, впереди ждёт интеграция с OpenGL, Pyglet или Panda3D. Физика оживает, а Python снова доказывает, что с ним возможны настоящие чудеса.