Визуализация данных и создание интерфейсов на Python: полный гид

pip install matplotlib # для визуализации данных
pip install pygame # для разработки игр
pip install pyqt5 # для создания GUI
pip install pillow # для обработки изображений

pip install matplotlib

import matplotlib.pyplot as plt
import numpy as np

# Создаем данные
x = np.linspace(0, 10, 100) # 100 точек от 0 до 10
y = np.sin(x) # Синусоида

# Создаем график
plt.figure(figsize=(8, 4)) # Размер графика
plt.plot(x, y, 'b-', label='sin(x)') # Синяя линия
plt.title('Синусоида') # Заголовок
plt.xlabel('x') # Подпись оси X
plt.ylabel('sin(x)') # Подпись оси Y
plt.grid(True) # Сетка
plt.legend() # Легенда
plt.savefig('sinus.png') # Сохранить в файл
plt.show() # Показать график

import matplotlib.pyplot as plt
import numpy as np

# Создаем данные
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# Создаем фигуру и оси (объектно-ориентированный подход)
fig, ax = plt.subplots(figsize=(10, 5))
ax.plot(x, y1, 'r-', label='sin(x)')
ax.plot(x, y2, 'g--', label='cos(x)')
ax.set_title('Синус и косинус')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.grid(True)
ax.legend()
plt.show()

# Создание 2x2 сетки подграфиков
fig, axs = plt.subplots(2, 2, figsize=(12, 8))

# Первый подграфик (верхний левый)
axs[0, 0].plot(x, y1)
axs[0, 0].set_title('Синус')

# Второй подграфик (верхний правый)
axs[0, 1].plot(x, y2)
axs[0, 1].set_title('Косинус')

# Третий подграфик (нижний левый)
axs[1, 0].plot(x, y1 ** 2)
axs[1, 0].set_title('Синус в квадрате')

# Четвертый подграфик (нижний правый)
axs[1, 1].plot(x, y2 ** 2)
axs[1, 1].set_title('Косинус в квадрате')

fig.tight_layout() # Автоматическая настройка расположения
plt.show()

import pandas as pd
import matplotlib.pyplot as plt

# Создаем DataFrame
df = pd.DataFrame({
'x': range(1, 11),
'y1': np.random.randn(10),
'y2': np.random.randn(10) + 1
})

# Создаем график прямо из DataFrame
df.plot(x='x', figsize=(8, 4))
plt.title('Данные из Pandas DataFrame')
plt.xlabel('Значение X')
plt.ylabel('Значение Y')
plt.grid(True)
plt.show()

pip install pygame

import pygame
import sys

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

# Настройки окна
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Моё первое Pygame приложение")

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

# Позиция и скорость круга
circle_pos = [WIDTH // 2, HEIGHT // 2]
circle_radius = 30
circle_speed = [5, 5] # [скорость_x, скорость_y]

# Основной игровой цикл
clock = pygame.time.Clock()
while True:
# Проверка событий
for event in pygame.event.get():
if event.type == pygame.QUIT: # Если нажали на "крестик"
pygame.quit()
sys.exit()

# Обновление позиции круга
circle_pos[0] += circle_speed[0]
circle_pos[1] += circle_speed[1]

# Проверка столкновения со стенками
if circle_pos[0] <= circle_radius or circle_pos[0] >= WIDTH – circle_radius:
circle_speed[0] = -circle_speed[0] # Отражение по X
if circle_pos[1] <= circle_radius or circle_pos[1] >= HEIGHT – circle_radius:
circle_speed[1] = -circle_speed[1] # Отражение по Y

# Отрисовка
screen.fill(WHITE) # Заливка фона
pygame.draw.circle(screen, BLUE, circle_pos, circle_radius) # Рисуем круг

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

import pygame
import sys

pygame.init()

# Настройки окна
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Управляемый квадрат")

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

# Игровой объект – квадрат
player_size = 50
player_pos = [WIDTH // 2, HEIGHT // 2]
player_speed = 5

# Основной игровой цикл
clock = pygame.time.Clock()
while True:
# Проверка событий
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()

# Обработка нажатий клавиш
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
player_pos[0] -= player_speed
if keys[pygame.K_RIGHT]:
player_pos[0] += player_speed
if keys[pygame.K_UP]:
player_pos[1] -= player_speed
if keys[pygame.K_DOWN]:
player_pos[1] += player_speed

# Ограничение движения игрока в пределах окна
player_pos[0] = max(0, min(WIDTH – player_size, player_pos[0]))
player_pos[1] = max(0, min(HEIGHT – player_size, player_pos[1]))

# Отрисовка
screen.fill(WHITE)
pygame.draw.rect(screen, GREEN, (player_pos[0], player_pos[1], player_size, player_size))

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

import pygame
import sys

class Game:
def __init__(self):
pygame.init()
self.WIDTH, self.HEIGHT = 800, 600
self.screen = pygame.display.set_mode((self.WIDTH, self.HEIGHT))
pygame.display.set_caption("Структурированная игра")

self.WHITE = (255, 255, 255)
self.GREEN = (0, 255, 0)
self.RED = (255, 0, 0)

self.clock = pygame.time.Clock()

self.player = Player(self.WIDTH // 2, self.HEIGHT // 2)
self.obstacles = [Obstacle(100, 100), Obstacle(700, 500)]

def handle_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
return False
return True

def update(self):
keys = pygame.key.get_pressed()
self.player.update(keys, self.WIDTH, self.HEIGHT)

# Проверка коллизий
for obstacle in self.obstacles:
if self.player.check_collision(obstacle):
print("Столкновение!")
# Здесь может быть логика для обработки столкновений

def render(self):
self.screen.fill(self.WHITE)
self.player.draw(self.screen)
for obstacle in self.obstacles:
obstacle.draw(self.screen)
pygame.display.flip()

def run(self):
running = True
while running:
running = self.handle_events()
self.update()
self.render()
self.clock.tick(60)
pygame.quit()
sys.exit()

class Player:
def __init__(self, x, y):
self.x = x
self.y = y
self.size = 50
self.speed = 5
self.color = (0, 255, 0)

def update(self, keys, max_width, max_height):
if keys[pygame.K_LEFT]:
self.x -= self.speed
if keys[pygame.K_RIGHT]:
self.x += self.speed
if keys[pygame.K_UP]:
self.y -= self.speed
if keys[pygame.K_DOWN]:
self.y += self.speed

# Ограничиваем движение в пределах окна
self.x = max(0, min(max_width – self.size, self.x))
self.y = max(0, min(max_height – self.size, self.y))

def draw(self, screen):
pygame.draw.rect(screen, self.color, (self.x, self.y, self.size, self.size))

def check_collision(self, other):
return (self.x < other.x + other.size and
self.x + self.size > other.x and
self.y < other.y + other.size and
self.y + self.size > other.y)

class Obstacle:
def __init__(self, x, y):
self.x = x
self.y = y
self.size = 50
self.color = (255, 0, 0)

def draw(self, screen):
pygame.draw.rect(screen, self.color, (self.x, self.y, self.size, self.size))

# Запуск игры
if __name__ == "__main__":
game = Game()
game.run()

pip install pyqt5

import sys
from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout, QLabel, QLineEdit

class SimpleApp(QWidget):
def __init__(self):
super().__init__()
self.init_ui()

def init_ui(self):
# Создаем виджеты
self.label = QLabel("Введите ваше имя:")
self.name_input = QLineEdit()
self.button = QPushButton("Приветствовать")
self.greeting_label = QLabel("")

# Подключаем сигнал нажатия кнопки к слоту (функции)
self.button.clicked.connect(self.greet)

# Создаем вертикальный layout и добавляем в него виджеты
layout = QVBoxLayout()
layout.addWidget(self.label)
layout.addWidget(self.name_input)
layout.addWidget(self.button)
layout.addWidget(self.greeting_label)

# Устанавливаем layout для окна
self.setLayout(layout)

# Настраиваем окно
self.setWindowTitle("Моё первое PyQt приложение")
self.setGeometry(300, 300, 300, 200) # x, y, width, height
self.show()

def greet(self):
name = self.name_input.text()
if name:
self.greeting_label.setText(f"Привет, {name}!")
else:
self.greeting_label.setText("Пожалуйста, введите ваше имя.")

# Запуск приложения
if __name__ == "__main__":
app = QApplication(sys.argv)
window = SimpleApp()
sys.exit(app.exec_())

import sys
from PyQt5.QtWidgets import (QApplication, QWidget, QPushButton, QVBoxLayout,
QHBoxLayout, QLabel, QLineEdit, QGridLayout)

class Calculator(QWidget):
def __init__(self):
super().__init__()
self.init_ui()

def init_ui(self):
# Создаем дисплей калькулятора
self.display = QLineEdit("0")
self.display.setReadOnly(True)

# Создаем кнопки
grid = QGridLayout()
buttons = [
"7", "8", "9", "/",
"4", "5", "6", "*",
"1", "2", "3", "-",
"0", ".", "=", "+"
]

positions = [(i, j) for i in range(4) for j in range(4)]

# Добавляем кнопки в сетку
for position, button_text in zip(positions, buttons):
button = QPushButton(button_text)
button.clicked.connect(self.on_button_clicked)
grid.addWidget(button, *position)

# Создаем кнопку очистки
clear_button = QPushButton("C")
clear_button.clicked.connect(self.clear_display)

# Создаем layout и добавляем виджеты
layout = QVBoxLayout()
layout.addWidget(self.display)
layout.addWidget(clear_button)
layout.addLayout(grid)

self.setLayout(layout)
self.setWindowTitle("Калькулятор")
self.setGeometry(300, 300, 300, 400)
self.show()

# Переменные для вычислений
self.current_input = "0"
self.first_operand = None
self.operator = None
self.reset_display = False

def on_button_clicked(self):
button = self.sender()
button_text = button.text()

if button_text in "0123456789.":
# Если сейчас на дисплее "0" или нужно сбросить дисплей
if self.current_input == "0" or self.reset_display:
if button_text == ".":
self.current_input = "0."
else:
self.current_input = button_text
self.reset_display = False
else:
# Проверяем, что не вводим вторую десятичную точку
if button_text == "." and "." in self.current_input:
return
self.current_input += button_text
self.display.setText(self.current_input)

elif button_text in "+-*/":
# Если у нас уже есть первый операнд и оператор, выполняем вычисление
if self.first_operand is not None and not self.reset_display:
self.calculate_result()

self.first_operand = float(self.current_input)
self.operator = button_text
self.reset_display = True

elif button_text == "=":
if self.first_operand is not None and not self.reset_display:
self.calculate_result()
self.first_operand = None
self.operator = None
self.reset_display = True

def calculate_result(self):
second_operand = float(self.current_input)
if self.operator == "+":
result = self.first_operand + second_operand
elif self.operator == "-":
result = self.first_operand – second_operand
elif self.operator == "*":
result = self.first_operand * second_operand
elif self.operator == "/":
if second_operand == 0:
result = "Ошибка: деление на ноль"
else:
result = self.first_operand / second_operand

if isinstance(result, str):
self.current_input = result
else:
# Убираем десятичную точку и нули после неё для целых чисел
result_str = str(result)
if result_str.endswith(".0"):
self.current_input = result_str[:-2]
else:
self.current_input = result_str

self.display.setText(self.current_input)

def clear_display(self):
self.current_input = "0"
self.first_operand = None
self.operator = None
self.reset_display = False
self.display.setText(self.current_input)

if __name__ == "__main__":
app = QApplication(sys.argv)
calc = Calculator()
sys.exit(app.exec_())

import requests
import matplotlib.pyplot as plt
from datetime import datetime
import numpy as np

def get_weather_data(city):
api_key = "YOUR_API_KEY" # Получите ключ на сайте OpenWeatherMap
url = f"http://api.openweathermap.org/data/2.5/forecast?q={city}&appid={api_key}&units=metric"
response = requests.get(url)
return response.json()

def plot_weather(city):
data = get_weather_data(city)

# Извлекаем данные о времени и температуре
times = []
temps = []
for item in data["list"]:
time = datetime.fromtimestamp(item["dt"])
times.append(time)
temps.append(item["main"]["temp"])

# Создаем график
plt.figure(figsize=(12, 6))
plt.plot(times, temps, 'b-', marker='o', markersize=4)
plt.title(f"Прогноз температуры для {city}")
plt.xlabel("Дата и время")
plt.ylabel("Температура (°C)")
plt.grid(True)

# Улучшаем форматирование оси X
plt.gcf().autofmt_xdate()

# Добавляем средние, минимальные и максимальные значения
plt.axhline(y=np.mean(temps), color='r', linestyle='--', label=f"Средняя: {np.mean(temps):.1f}°C")
plt.axhline(y=max(temps), color='g', linestyle=':', label=f"Максимальная: {max(temps):.1f}°C")
plt.axhline(y=min(temps), color='y', linestyle=':', label=f"Минимальная: {min(temps):.1f}°C")

plt.legend()
plt.tight_layout()
plt.savefig(f"{city}_weather.png")
plt.show()

# Пример использования
plot_weather("Moscow")

import pygame
import sys
import random

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

# Константы
WIDTH, HEIGHT = 600, 400
GRID_SIZE = 20
GRID_WIDTH = WIDTH // GRID_SIZE
GRID_HEIGHT = HEIGHT // GRID_SIZE
FPS = 10

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

# Настройка экрана
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Змейка на Python")

# Функция для генерации случайной позиции для еды
def get_random_position():
return (random.randint(0, GRID_WIDTH – 1) * GRID_SIZE,
random.randint(0, GRID_HEIGHT – 1) * GRID_SIZE)

# Класс змейки
class Snake:
def __init__(self):
self.positions = [(WIDTH // 2, HEIGHT // 2)]
self.direction = (GRID_SIZE, 0) # Начальное направление – вправо
self.grow = False

def get_head_position(self):
return self.positions[0]

def move(self):
head = self.get_head_position()
x, y = self.direction
new_position = ((head[0] + x) % WIDTH, (head[1] + y) % HEIGHT)

# Проверка на столкновение с собой
if new_position in self.positions[1:]:
return False

self.positions.insert(0, new_position)
if not self.grow:
self.positions.pop()
else:
self.grow = False
return True

def change_direction(self, direction):
# Предотвращаем движение в противоположном направлении
if (direction[0] * -1, direction[1] * -1) == self.direction:
return
self.direction = direction

def grow_snake(self):
self.grow = True

def draw(self, surface):
for position in self.positions:
pygame.draw.rect(surface, GREEN, (position[0], position[1], GRID_SIZE, GRID_SIZE))

# Класс еды
class Food:
def __init__(self):
self.position = get_random_position()

def spawn(self, snake_positions):
# Генерируем новую позицию, которая не совпадает с позицией змейки
self.position = get_random_position()
while self.position in snake_positions:
self.position = get_random_position()

def draw(self, surface):
pygame.draw.rect(surface, RED, (self.position[0], self.position[1], GRID_SIZE, GRID_SIZE))

# Основная функция игры
def main():
clock = pygame.time.Clock()
snake = Snake()
food = Food()
score = 0
font = pygame.font.SysFont(None, 36)

while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP:
snake.change_direction((0, -GRID_SIZE))
elif event.key == pygame.K_DOWN:
snake.change_direction((0, GRID_SIZE))
elif event.key == pygame.K_LEFT:
snake.change_direction((-GRID_SIZE, 0))
elif event.key == pygame.K_RIGHT:
snake.change_direction((GRID_SIZE, 0))

# Движение змейки
if not snake.move():
# Столкновение с собой, конец игры
text = font.render(f"Игра окончена! Счёт: {score}", True, RED)
text_rect = text.get_rect(center=(WIDTH//2, HEIGHT//2))
screen.blit(text, text_rect)
pygame.display.flip()
pygame.time.delay(2000) # Пауза перед рестартом
snake = Snake()
food = Food()
score = 0

# Проверка на поедание еды
if snake.get_head_position() == food.position:
snake.grow_snake()
food.spawn(snake.positions)
score += 1

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

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

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

if __name__ == "__main__":
main()

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout,
QHBoxLayout, QPushButton, QColorDialog, QSlider,
QLabel, QAction, QFileDialog)
from PyQt5.QtGui import QPixmap, QPainter, QPen, QColor, QIcon
from PyQt5.QtCore import Qt, QPoint

class Canvas(QWidget):
def __init__(self):
super().__init__()
# Создаем pixmap для рисования
self.pixmap = QPixmap(800, 600)
self.pixmap.fill(Qt.white)

self.last_point = QPoint()
self.pen_color = QColor(0, 0, 0) # Черный
self.pen_width = 3

def paintEvent(self, event):
painter = QPainter(self)
painter.drawPixmap(0, 0, self.pixmap)

def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.last_point = event.pos()

def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
painter = QPainter(self.pixmap)
painter.setPen(QPen(self.pen_color, self.pen_width, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.drawLine(self.last_point, event.pos())
self.last_point = event.pos()
self.update()

def clear(self):
self.pixmap.fill(Qt.white)
self.update()

def set_pen_color(self, color):
self.pen_color = color

def set_pen_width(self, width):
self.pen_width = width

def save_image(self, filename):
self.pixmap.save(filename)

class DrawingApp(QMainWindow):
def __init__(self):
super().__init__()
self.init_ui()

def init_ui(self):
# Создаем меню
menubar = self.menuBar()
file_menu = menubar.addMenu("Файл")

save_action = QAction("Сохранить", self)
save_action.triggered.connect(self.save_file)
file_menu.addAction(save_action)

clear_action = QAction("Очистить", self)
clear_action.triggered.connect(self.clear_canvas)
file_menu.addAction(clear_action)

exit_action = QAction("Выход", self)
exit_action.triggered.connect(self.close)
file_menu.addAction(exit_action)

# Создаем холст
self.canvas = Canvas()

# Создаем виджеты управления
color_button = QPushButton("Выбрать цвет")
color_button.clicked.connect(self.choose_color)

# Ползунок для толщины
thickness_label = QLabel("Толщина:")
self.thickness_slider = QSlider(Qt.Horizontal)
self.thickness_slider.setMinimum(1)
self.thickness_slider.setMaximum(20)
self.thickness_slider.setValue(3)
self.thickness_slider.valueChanged.connect(self.change_thickness)

# Организуем layout
controls_layout = QHBoxLayout()
controls_layout.addWidget(color_button)
controls_layout.addWidget(thickness_label)
controls_layout.addWidget(self.thickness_slider)

main_layout = QVBoxLayout()
main_layout.addWidget(self.canvas)
main_layout.addLayout(controls_layout)

# Создаем центральный виджет
central_widget = QWidget()
central_widget.setLayout(main_layout)
self.setCentralWidget(central_widget)

# Настраиваем окно
self.setWindowTitle("Приложение для рисования")
self.setGeometry(100, 100, 800, 700)

def choose_color(self):
color = QColorDialog.getColor()
if color.isValid():
self.canvas.set_pen_color(color)

def change_thickness(self):
self.canvas.set_pen_width(self.thickness_slider.value())

def clear_canvas(self):
self.canvas.clear()

def save_file(self):
filename, _ = QFileDialog.getSaveFileName(self, "Сохранить изображение", "", "PNG (*.png);;JPG (*.jpg);;All Files (*)")
if filename:
self.canvas.save_image(filename)

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