Топ-5 графических библиотек Python: возможности и применение

# Установка основных графических библиотек
pip install matplotlib seaborn pillow pygame PyQt5

import matplotlib.pyplot as plt
import numpy as np

# Генерация данных
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Создание графика
plt.figure(figsize=(10, 6))
plt.plot(x, y, label='sin(x)', color='blue', linewidth=2)
plt.title('Синусоидальная функция')
plt.xlabel('X')
plt.ylabel('sin(x)')
plt.grid(True)
plt.legend()
plt.savefig('sin_function.png')
plt.show()

import seaborn as sns
import pandas as pd
import matplotlib.pyplot as plt

# Загрузка встроенного датасета
tips = sns.load_dataset("tips")

# Создание комплексной визуализации
plt.figure(figsize=(12, 8))
sns.set_style("whitegrid")

# Диаграмма рассеяния с регрессией
sns.lmplot(x="total_bill", y="tip", hue="smoker", data=tips, height=8,
palette="Set1", scatter_kws={"s": 100, "alpha": 0.7})

plt.title('Зависимость чаевых от суммы счета', fontsize=16)
plt.savefig('tips_analysis.png', dpi=300, bbox_inches='tight')
plt.show()

import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import pandas as pd

# Создание синтетических данных
np.random.seed(42)
data = pd.DataFrame({
'x': np.random.normal(0, 1, 1000),
'y': np.random.normal(0, 1, 1000),
'category': np.random.choice(['A', 'B', 'C'], 1000)
})

# Настройка стилистики через Seaborn
sns.set_theme(style="darkgrid", palette="Set2")

# Создание графика с помощью Matplotlib
fig, ax = plt.subplots(figsize=(10, 8))

# Использование Seaborn для рисования
scatter = sns.scatterplot(data=data, x='x', y='y', hue='category', 
size='category', sizes=(100, 200), ax=ax)

# Добавление деталей через Matplotlib
ax.set_title('Комбинированная визуализация Matplotlib + Seaborn', fontsize=16)
ax.set_xlabel('Параметр X', fontsize=12)
ax.set_ylabel('Параметр Y', fontsize=12)

# Настройка легенды
plt.legend(title='Категория', fontsize=10, title_fontsize=12)

# Добавление аннотаций
for category, color in zip(['A', 'B', 'C'], sns.color_palette("Set2", 3)):
subset = data[data['category'] == category]
center_x = subset['x'].mean()
center_y = subset['y'].mean()
plt.annotate(f'Центр {category}', (center_x, center_y), 
fontsize=12, color=color, fontweight='bold')

plt.tight_layout()
plt.savefig('advanced_visualization.png', dpi=300)
plt.show()

import tkinter as tk
from tkinter import messagebox

def show_greeting():
name = name_entry.get()
if name:
messagebox.showinfo("Приветствие", f"Здравствуйте, {name}!")
else:
messagebox.showerror("Ошибка", "Пожалуйста, введите ваше имя")

# Создание основного окна
root = tk.Tk()
root.title("Демонстрация Tkinter")
root.geometry("400x200")

# Создание виджетов
frame = tk.Frame(root, padx=20, pady=20)
frame.pack(fill=tk.BOTH, expand=True)

name_label = tk.Label(frame, text="Введите ваше имя:", font=("Arial", 12))
name_label.pack(pady=(0, 10))

name_entry = tk.Entry(frame, width=30, font=("Arial", 12))
name_entry.pack(pady=(0, 20))

greet_button = tk.Button(frame, text="Приветствовать", command=show_greeting,
font=("Arial", 12), bg="#4CAF50", fg="white")
greet_button.pack()

# Запуск цикла обработки событий
root.mainloop()

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel, QPushButton, QVBoxLayout, QWidget, QLineEdit, QMessageBox
from PyQt5.QtCore import Qt

class MainWindow(QMainWindow):
def __init__(self):
super().__init__()

self.setWindowTitle("Демонстрация PyQt")
self.setMinimumSize(500, 300)

# Центральный виджет и макет
central_widget = QWidget()
self.setCentralWidget(central_widget)
layout = QVBoxLayout(central_widget)

# Создание виджетов
title_label = QLabel("Калькулятор температуры")
title_label.setAlignment(Qt.AlignCenter)
title_label.setStyleSheet("font-size: 18px; margin-bottom: 20px;")

self.temp_input = QLineEdit()
self.temp_input.setPlaceholderText("Введите температуру в градусах Цельсия")
self.temp_input.setStyleSheet("padding: 8px; font-size: 14px;")

self.convert_button = QPushButton("Конвертировать в Фаренгейты")
self.convert_button.setStyleSheet("""
QPushButton {
background-color: #2196F3;
color: white;
padding: 10px;
font-size: 14px;
border-radius: 5px;
}
QPushButton:hover {
background-color: #0b7dda;
}
""")
self.convert_button.clicked.connect(self.convert_temperature)

self.result_label = QLabel("Результат: ")
self.result_label.setAlignment(Qt.AlignCenter)
self.result_label.setStyleSheet("font-size: 16px; margin-top: 20px;")

# Добавление виджетов на макет
layout.addWidget(title_label)
layout.addWidget(self.temp_input)
layout.addWidget(self.convert_button)
layout.addWidget(self.result_label)
layout.addStretch()

def convert_temperature(self):
try:
celsius = float(self.temp_input.text())
fahrenheit = (celsius * 9/5) + 32
self.result_label.setText(f"Результат: {celsius}°C = {fahrenheit:.2f}°F")
except ValueError:
QMessageBox.warning(self, "Ошибка", "Пожалуйста, введите корректное число")

if __name__ == "__main__":
app = QApplication(sys.argv)
window = MainWindow()
window.show()
sys.exit(app.exec_())

import wx

class MyFrame(wx.Frame):
def __init__(self):
super().__init__(None, title="Демонстрация wxPython", size=(500, 300))

# Создание панели и сайзера
panel = wx.Panel(self)
sizer = wx.BoxSizer(wx.VERTICAL)

# Заголовок
title = wx.StaticText(panel, label="Менеджер задач")
title.SetFont(wx.Font(14, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_BOLD))
sizer.Add(title, 0, wx.ALL | wx.CENTER, 10)

# Поле ввода и кнопка добавления
input_sizer = wx.BoxSizer(wx.HORIZONTAL)
self.task_input = wx.TextCtrl(panel, size=(300, -1))
add_button = wx.Button(panel, label="Добавить задачу")
add_button.Bind(wx.EVT_BUTTON, self.add_task)

input_sizer.Add(self.task_input, 1, wx.ALL, 5)
input_sizer.Add(add_button, 0, wx.ALL, 5)
sizer.Add(input_sizer, 0, wx.EXPAND | wx.ALL, 10)

# Список задач
self.task_list = wx.ListCtrl(panel, style=wx.LC_REPORT)
self.task_list.InsertColumn(0, "ID", width=50)
self.task_list.InsertColumn(1, "Задача", width=350)

sizer.Add(self.task_list, 1, wx.EXPAND | wx.ALL, 10)

# Кнопка удаления
delete_button = wx.Button(panel, label="Удалить выбранную задачу")
delete_button.Bind(wx.EVT_BUTTON, self.delete_task)
sizer.Add(delete_button, 0, wx.ALIGN_RIGHT | wx.ALL, 10)

panel.SetSizer(sizer)
self.task_id = 1

def add_task(self, event):
task_text = self.task_input.GetValue()
if task_text:
self.task_list.InsertItem(self.task_list.GetItemCount(), str(self.task_id))
self.task_list.SetItem(self.task_list.GetItemCount() – 1, 1, task_text)
self.task_id += 1
self.task_input.SetValue("")
else:
wx.MessageBox("Пожалуйста, введите текст задачи", "Ошибка", wx.OK | wx.ICON_ERROR)

def delete_task(self, event):
selected = self.task_list.GetFirstSelected()
if selected >= 0:
self.task_list.DeleteItem(selected)
else:
wx.MessageBox("Пожалуйста, выберите задачу для удаления", "Ошибка", wx.OK | wx.ICON_ERROR)

if __name__ == "__main__":
app = wx.App()
frame = MyFrame()
frame.Show()
app.MainLoop()

from PIL import Image, ImageFilter, ImageEnhance, ImageDraw, ImageFont
import os

# Создание директории для сохранения результатов
output_dir = "processed_images"
os.makedirs(output_dir, exist_ok=True)

# Открытие изображения
image_path = "sample_image.jpg" # Замените на путь к вашему изображению
try:
img = Image.open(image_path)
except:
# Если изображение не найдено, создаем пустое для демонстрации
img = Image.new('RGB', (800, 600), color = (73, 109, 137))

# 1. Базовые трансформации
# Изменение размера
resized = img.resize((int(img.width/2), int(img.height/2)))
resized.save(f"{output_dir}/resized.jpg")

# Обрезка (кадрирование)
width, height = img.size
crop_box = (width/4, height/4, width*3/4, height*3/4) # (left, top, right, bottom)
cropped = img.crop(crop_box)
cropped.save(f"{output_dir}/cropped.jpg")

# Поворот
rotated = img.rotate(45, expand=True)
rotated.save(f"{output_dir}/rotated.jpg")

# 2. Применение фильтров
# Размытие
blurred = img.filter(ImageFilter.GaussianBlur(radius=5))
blurred.save(f"{output_dir}/blurred.jpg")

# Повышение резкости
sharpened = img.filter(ImageFilter.SHARPEN)
sharpened.save(f"{output_dir}/sharpened.jpg")

# Обнаружение границ
edges = img.filter(ImageFilter.FIND_EDGES)
edges.save(f"{output_dir}/edges.jpg")

# 3. Улучшение изображения
# Яркость
brightness_enhancer = ImageEnhance.Brightness(img)
brightened = brightness_enhancer.enhance(1.5) # 1.5 = 50% ярче
brightened.save(f"{output_dir}/brightened.jpg")

# Контрастность
contrast_enhancer = ImageEnhance.Contrast(img)
high_contrast = contrast_enhancer.enhance(2.0) # 2.0 = удвоенный контраст
high_contrast.save(f"{output_dir}/high_contrast.jpg")

# 4. Композиция и рисование
# Создаем копию для рисования
draw_img = img.copy()
draw = ImageDraw.Draw(draw_img)

# Рисование примитивов
draw.rectangle([50, 50, 200, 150], outline="red", width=3)
draw.ellipse([250, 50, 400, 150], outline="blue", width=3)
draw.line([450, 50, 600, 150], fill="green", width=5)

# Добавление текста
try:
font = ImageFont.truetype("arial.ttf", 36)
except:
font = ImageFont.load_default()

draw.text((50, 200), "Пример текста Pillow", fill="white", font=font, stroke_width=2, stroke_fill="black")

draw_img.save(f"{output_dir}/drawing.jpg")

# 5. Создание водяного знака
watermark = Image.new('RGBA', img.size, (0, 0, 0, 0))
watermark_draw = ImageDraw.Draw(watermark)
watermark_draw.text((img.width/2, img.height/2), "WATERMARK", fill=(255, 255, 255, 128), 
font=font, anchor="mm", stroke_width=2, stroke_fill=(0, 0, 0, 128))

watermarked = img.copy()
watermarked.paste(watermark, (0, 0), watermark)
watermarked.save(f"{output_dir}/watermarked.jpg")

print(f"Все обработанные изображения сохранены в директорию '{output_dir}'")

from PIL import Image, ImageDraw
import numpy as np
from matplotlib import pyplot as plt

# Функция для создания фрактала Мандельброта
def mandelbrot_set(height, width, x_min, x_max, y_min, y_max, max_iter):
x = np.linspace(x_min, x_max, width)
y = np.linspace(y_min, y_max, height)
c = x[np.newaxis, :] + 1j * y[:, np.newaxis]
z = np.zeros_like(c)

divtime = max_iter + np.zeros(z.shape, dtype=int)

for i in range(max_iter):
z = z**2 + c
diverge = z*np.conj(z) > 2**2
div_now = diverge & (divtime == max_iter)
divtime[div_now] = i
z[diverge] = 2

return divtime

# Создание изображения фрактала
def create_fractal_image(size=1000, max_iter=100):
img_array = mandelbrot_set(size, size, -2, 1, -1.5, 1.5, max_iter)

# Нормализация для лучшей визуализации
img_array = img_array / max_iter

# Преобразование в цветное изображение с помощью matplotlib
plt.figure(figsize=(10, 10))
plt.imshow(img_array, cmap='hot', extent=[-2, 1, -1.5, 1.5])
plt.title("Фрактал Мандельброта")
plt.axis('off')
plt.tight_layout()

# Сохранение как изображение
plt.savefig(f"{output_dir}/mandelbrot_fractal.png", dpi=300, bbox_inches='tight')
plt.close()

# Открытие с помощью Pillow для дальнейшей обработки
fractal = Image.open(f"{output_dir}/mandelbrot_fractal.png")

# Добавление рамки и текста
draw = ImageDraw.Draw(fractal)
draw.rectangle([(0, 0), (fractal.width-1, fractal.height-1)], outline="white", width=5)

try:
font = ImageFont.truetype("arial.ttf", 60)
except:
font = ImageFont.load_default()

draw.text((fractal.width/2, 80), "Множество Мандельброта", 
fill="white", font=font, anchor="ms", stroke_width=2, stroke_fill="black")

fractal.save(f"{output_dir}/final_mandelbrot.png")
return fractal

# Создание фрактала
create_fractal_image(size=1000, max_iter=100)
print(f"Фрактал Мандельброта создан и сохранен в '{output_dir}'")

import pygame
import sys
import random

# Инициализация Pygame
pygame.init()

# Константы
WIDTH, HEIGHT = 800, 600
PLAYER_SIZE = 50
ENEMY_SIZE = 30
PLAYER_SPEED = 5
ENEMY_SPEED = 3
FPS = 60
ENEMY_COUNT = 5

# Цвета
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)

# Настройка экрана
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Простая игра на Pygame")
clock = pygame.time.Clock()

# Класс игрока
class Player:
def __init__(self, x, y, size):
self.rect = pygame.Rect(x, y, size, size)
self.color = GREEN
self.speed = PLAYER_SPEED
self.score = 0

def move(self, dx, dy):
if 0 <= self.rect.x + dx <= WIDTH – self.rect.width:
self.rect.x += dx
if 0 <= self.rect.y + dy <= HEIGHT – self.rect.height:
self.rect.y += dy

def draw(self, surface):
pygame.draw.rect(surface, self.color, self.rect)

# Класс врага
class Enemy:
def __init__(self, size):
self.rect = pygame.Rect(
random.randint(0, WIDTH – size),
random.randint(0, HEIGHT – size),
size, size
)
self.color = RED
self.speed_x = random.choice([-1, 1]) * ENEMY_SPEED
self.speed_y = random.choice([-1, 1]) * ENEMY_SPEED

def update(self):
self.rect.x += self.speed_x
self.rect.y += self.speed_y

# Отскок от границ экрана
if self.rect.left <= 0 or self.rect.right >= WIDTH:
self.speed_x *= -1
if self.rect.top <= 0 or self.rect.bottom >= HEIGHT:
self.speed_y *= -1

def draw(self, surface):
pygame.draw.rect(surface, self.color, self.rect)

# Класс еды
class Food:
def __init__(self):
self.rect = pygame.Rect(
random.randint(0, WIDTH – 20),
random.randint(0, HEIGHT – 20),
20, 20
)
self.color = BLUE

def respawn(self):
self.rect.x = random.randint(0, WIDTH – 20)
self.rect.y = random.randint(0, HEIGHT – 20)

def draw(self, surface):
pygame.draw.rect(surface, self.color, self.rect)

# Создание объектов игры
player = Player(WIDTH // 2, HEIGHT // 2, PLAYER_SIZE)
enemies = [Enemy(ENEMY_SIZE) for _ in range(ENEMY_COUNT)]
food = Food()

# Шрифт для счета
font = pygame.font.Font(None, 36)

# Главный игровой цикл
running = True
while running:
# Обработка событий
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False

# Управление игроком
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
player.move(-player.speed, 0)
if keys[pygame.K_RIGHT]:
player.move(player.speed, 0)
if keys[pygame.K_UP]:
player.move(0, -player.speed)
if keys[pygame.K_DOWN]:
player.move(0, player.speed)

# Обновление врагов
for enemy in enemies:
enemy.update()
# Проверка столкновения с игроком
if player.rect.colliderect(enemy.rect):
running = False # Игра окончена при столкновении с врагом

# Проверка подбора еды
if player.rect.colliderect(food.rect):
player.score += 10
food.respawn()

# Отрисовка
screen.fill(BLACK)

# Рисуем объекты
player.draw(screen)
for enemy in enemies:
enemy.draw(screen)
food.draw(screen)

# Отображение счета
score_text = font.render(f"Счет: {player.score}", True, WHITE)
screen.blit(score_text, (10, 10))

# Обновление экрана
pygame.display.flip()
clock.tick(FPS)

# Завершение Pygame
pygame.quit()
sys.exit()

import pygame
from pygame.locals import *
from OpenGL.GL import *
from OpenGL.GLU import *
import numpy as np

# Вершины куба (x, y, z)
vertices = (
(1, -1, -1), (1, 1, -1), (-1, 1, -1), (-1, -1, -1),
(1, -1, 1), (1, 1, 1), (-1, -1, 1), (-1, 1, 1)
)

# Грани куба (индексы вершин)
edges = (
(0, 1), (1, 2), (2, 3), (3, 0),
(4, 5), (5, 7), (7, 6), (6, 4),
(0, 4), (1, 5), (2, 7), (3, 6)
)

# Цвета для каждой вершины
colors = (
(1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 0),
(1, 0, 1), (0, 1, 1), (0.5, 0.5, 0.5), (1, 1, 1)
)

# Функция для отрисовки куба
def draw_cube():
glBegin(GL_LINES)
for edge in edges:
for vertex in edge:
glColor3fv(colors[vertex])
glVertex3fv(vertices[vertex])
glEnd()

def main():
pygame.init()
display = (800, 600)
pygame.display.set_mode(display, DOUBLEBUF | OPENGL)
pygame.display.set_caption("PyOpenGL 3D Куб")

# Настройка перспективы
gluPerspective(45, (display[0] / display[1]), 0.1, 50.0)
glTranslatef(0.0, 0.0, -5)

# Переменные для вращения
rot_x, rot_y, rot_z = 0, 0, 0
rot_speed = 1

clock = pygame.time.Clock()

while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
return

# Управление скоростью вращения с клавиатуры
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP:
rot_speed += 0.5
if event.key == pygame.K_DOWN:
rot_speed = max(0.5, rot_speed – 0.5)
if event.key == pygame.K_SPACE:
rot_x, rot_y, rot_z = 0, 0, 0

# Обновление вращения
rot_x += rot_speed
rot_y += rot_speed * 0.7
rot_z += rot_speed * 0.5

# Очистка экрана и буфера глубины
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

# Сохранение текущей матрицы
glPushMatrix()

# Применение вращений
glRotatef(rot_x, 1, 0, 0)
glRotatef(rot_y, 0, 1, 0)
glRotatef(rot_z, 0, 0, 1)

# Отрисовка объекта
draw_cube()

# Восстановление матрицы
glPopMatrix()

pygame.display.flip()
clock.tick(60)

if __name__ == "__main__":
main()