Разработка настольных приложений на Python: от идеи до готового продукта

my_app/
│
├── main.py # Точка входа в приложение
├── ui/ # Компоненты интерфейса
│ ├── main_window.py
│ └── dialogs.py
│
├── logic/ # Бизнес-логика
│ └── core.py
│
├── data/ # Работа с данными
│ └── storage.py
│
└── resources/ # Ресурсы (изображения, стили и т.д.)
└── icons/

# main.py
import tkinter as tk

def create_app():
root = tk.Tk()
root.title("Моё первое Python-приложение")

label = tk.Label(root, text="Hello, Python Desktop!")
label.pack(padx=50, pady=50)

return root

if __name__ == "__main__":
app = create_app()
app.mainloop()

# model.py
class TaskModel:
def __init__(self):
self.tasks = []

def add_task(self, title, deadline=None):
task = {"id": len(self.tasks) + 1, "title": title, 
"deadline": deadline, "completed": False}
self.tasks.append(task)
return task

def get_all_tasks(self):
return self.tasks

def mark_completed(self, task_id):
for task in self.tasks:
if task["id"] == task_id:
task["completed"] = True
return True
return False

# view.py
import tkinter as tk
from tkinter import ttk

class TaskView:
def __init__(self, root):
self.root = root
self.root.title("Task Manager – Prototype")

# Создание и размещение виджетов
self.frame = ttk.Frame(root, padding="10")
self.frame.pack(fill=tk.BOTH, expand=True)

self.task_var = tk.StringVar()
self.entry = ttk.Entry(self.frame, textvariable=self.task_var, width=40)
self.entry.grid(row=0, column=0, padx=5, pady=5)

self.add_button = ttk.Button(self.frame, text="Add Task")
self.add_button.grid(row=0, column=1, padx=5, pady=5)

self.task_list = tk.Listbox(self.frame, height=15, width=50)
self.task_list.grid(row=1, column=0, columnspan=2, padx=5, pady=5)

self.complete_button = ttk.Button(self.frame, text="Mark Completed")
self.complete_button.grid(row=2, column=0, columnspan=2, padx=5, pady=5)

def set_add_task_command(self, command):
self.add_button.config(command=command)

def set_complete_task_command(self, command):
self.complete_button.config(command=command)

def get_task_text(self):
return self.task_var.get()

def clear_task_input(self):
self.task_var.set("")

def update_task_list(self, tasks):
self.task_list.delete(0, tk.END)
for task in tasks:
status = "✓ " if task["completed"] else " "
self.task_list.insert(tk.END, f"{status}{task['id']}: {task['title']}")

def get_selected_task_index(self):
selection = self.task_list.curselection()
return selection[0] if selection else -1

# controller.py
class TaskController:
def __init__(self, model, view):
self.model = model
self.view = view

# Связываем представление с обработчиками событий
self.view.set_add_task_command(self.add_task)
self.view.set_complete_task_command(self.complete_task)
self.refresh_task_list()

def add_task(self):
task_text = self.view.get_task_text()
if task_text:
self.model.add_task(task_text)
self.view.clear_task_input()
self.refresh_task_list()

def complete_task(self):
selected_index = self.view.get_selected_task_index()
if selected_index >= 0:
task_id = self.model.get_all_tasks()[selected_index]["id"]
self.model.mark_completed(task_id)
self.refresh_task_list()

def refresh_task_list(self):
tasks = self.model.get_all_tasks()
self.view.update_task_list(tasks)

# main.py
import tkinter as tk
from model import TaskModel
from view import TaskView
from controller import TaskController

if __name__ == "__main__":
root = tk.Tk()
model = TaskModel()
view = TaskView(root)
controller = TaskController(model, view)
root.mainloop()

import tkinter as tk
from tkinter import ttk

# Создание базового приложения с Tkinter
root = tk.Tk()
root.title("Tkinter Demo")
root.geometry("400x300")

# Добавление некоторых виджетов
label = ttk.Label(root, text="Пример приложения на Tkinter")
label.pack(pady=10)

entry = ttk.Entry(root, width=30)
entry.pack(pady=10)

button = ttk.Button(root, text="Нажми меня")
button.pack(pady=10)

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

# Пример с PyQt5
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel, QLineEdit, QPushButton, QVBoxLayout, QWidget
import sys

# Создание приложения и главного окна
app = QApplication(sys.argv)
window = QMainWindow()
window.setWindowTitle("PyQt Demo")
window.setGeometry(100, 100, 400, 300)

# Создание центрального виджета и компоновки
central_widget = QWidget()
window.setCentralWidget(central_widget)
layout = QVBoxLayout(central_widget)

# Добавление элементов интерфейса
label = QLabel("Пример приложения на PyQt")
layout.addWidget(label)

entry = QLineEdit()
layout.addWidget(entry)

button = QPushButton("Нажми меня")
layout.addWidget(button)

# Отображение окна и запуск цикла событий
window.show()
sys.exit(app.exec_())

import customtkinter as ctk

# Настройка внешнего вида
ctk.set_appearance_mode("dark") # Доступные режимы: "dark", "light", "system"
ctk.set_default_color_theme("blue") # Темы: "blue", "green", "dark-blue"

# Создание окна приложения
app = ctk.CTk()
app.title("CustomTkinter Demo")
app.geometry("400x300")

# Добавление виджетов
label = ctk.CTkLabel(app, text="Пример приложения на CustomTkinter")
label.pack(pady=10)

entry = ctk.CTkEntry(app, width=300)
entry.pack(pady=10)

button = ctk.CTkButton(app, text="Нажми меня")
button.pack(pady=10)

# Запуск приложения
app.mainloop()

my_application/
│
├── app.py # Точка входа приложения
├── requirements.txt # Зависимости
│
├── core/ # Основная бизнес-логика
│ ├── __init__.py
│ ├── models.py # Модели данных
│ ├── services.py # Сервисные функции
│ └── utils.py # Вспомогательные утилиты
│
├── data/ # Слой работы с данными
│ ├── __init__.py
│ ├── database.py # Работа с БД
│ ├── file_storage.py # Файловое хранилище
│ └── api_client.py # Взаимодействие с API
│
├── ui/ # Интерфейс пользователя
│ ├── __init__.py
│ ├── main_window.py # Главное окно
│ ├── dialogs/ # Диалоговые окна
│ ├── widgets/ # Пользовательские виджеты
│ ├── views/ # Представления
│ └── resources/ # Ресурсы (изображения, стили)
│
└── tests/ # Тесты
├── __init__.py
├── test_core.py
├── test_data.py
└── test_ui.py

# models.py (Model)
class Note:
def __init__(self, title="", content="", id=None):
self.id = id
self.title = title
self.content = content

class NoteRepository:
def __init__(self):
self.notes = {}
self.next_id = 1

def add_note(self, note):
if not note.id:
note.id = self.next_id
self.next_id += 1
self.notes[note.id] = note
return note

def get_note(self, note_id):
return self.notes.get(note_id)

def get_all_notes(self):
return list(self.notes.values())

def update_note(self, note_id, title, content):
note = self.get_note(note_id)
if note:
note.title = title
note.content = content
return note
return None

def delete_note(self, note_id):
if note_id in self.notes:
del self.notes[note_id]
return True
return False

# views.py (View)
from PyQt5.QtWidgets import QMainWindow, QListWidget, QTextEdit, QLineEdit, QPushButton, QVBoxLayout, QHBoxLayout, QWidget, QMessageBox

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

def init_ui(self):
self.setWindowTitle("Python Notes App")
self.setGeometry(100, 100, 800, 500)

# Создаем основные виджеты
self.note_list = QListWidget()
self.title_edit = QLineEdit()
self.title_edit.setPlaceholderText("Заголовок заметки")
self.content_edit = QTextEdit()

# Создаем кнопки
self.add_button = QPushButton("Новая заметка")
self.save_button = QPushButton("Сохранить")
self.delete_button = QPushButton("Удалить")

# Создаем макеты
main_layout = QHBoxLayout()
left_layout = QVBoxLayout()
right_layout = QVBoxLayout()

# Настраиваем левую панель
left_layout.addWidget(self.note_list)
left_layout.addWidget(self.add_button)

# Настраиваем правую панель
right_layout.addWidget(self.title_edit)
right_layout.addWidget(self.content_edit)

button_layout = QHBoxLayout()
button_layout.addWidget(self.save_button)
button_layout.addWidget(self.delete_button)
right_layout.addLayout(button_layout)

# Объединяем макеты
main_layout.addLayout(left_layout, 1)
main_layout.addLayout(right_layout, 2)

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

def set_note_selected_handler(self, handler):
self.note_list.itemClicked.connect(handler)

def set_add_note_handler(self, handler):
self.add_button.clicked.connect(handler)

def set_save_note_handler(self, handler):
self.save_button.clicked.connect(handler)

def set_delete_note_handler(self, handler):
self.delete_button.clicked.connect(handler)

def display_notes(self, notes):
self.note_list.clear()
for note in notes:
self.note_list.addItem(f"{note.title}")
# Сохраняем ID заметки как пользовательские данные элемента списка
self.note_list.item(self.note_list.count()-1).setData(100, note.id)

def display_note(self, note):
if note:
self.title_edit.setText(note.title)
self.content_edit.setText(note.content)
else:
self.clear_note_display()

def clear_note_display(self):
self.title_edit.clear()
self.content_edit.clear()

def get_current_note_id(self):
selected_items = self.note_list.selectedItems()
if selected_items:
return selected_items[0].data(100)
return None

def get_note_data(self):
return {
"title": self.title_edit.text(),
"content": self.content_edit.toPlainText()
}

def show_error(self, message):
QMessageBox.critical(self, "Ошибка", message)

def show_info(self, message):
QMessageBox.information(self, "Информация", message)

# presenters.py (Presenter)
class NotePresenter:
def __init__(self, repository, view):
self.repository = repository
self.view = view

# Связываем представление с обработчиками
self.view.set_note_selected_handler(self.on_note_selected)
self.view.set_add_note_handler(self.on_add_note)
self.view.set_save_note_handler(self.on_save_note)
self.view.set_delete_note_handler(self.on_delete_note)

# Загружаем начальные данные
self.refresh_notes()

def refresh_notes(self):
notes = self.repository.get_all_notes()
self.view.display_notes(notes)

def on_note_selected(self, item):
note_id = item.data(100)
note = self.repository.get_note(note_id)
self.view.display_note(note)

def on_add_note(self):
self.view.clear_note_display()

def on_save_note(self):
note_data = self.view.get_note_data()

if not note_data["title"]:
self.view.show_error("Заголовок заметки не может быть пустым")
return

current_note_id = self.view.get_current_note_id()

if current_note_id:
# Обновляем существующую заметку
self.repository.update_note(
current_note_id,
note_data["title"],
note_data["content"]
)
self.view.show_info("Заметка обновлена")
else:
# Создаем новую заметку
new_note = Note(title=note_data["title"], content=note_data["content"])
self.repository.add_note(new_note)
self.view.show_info("Заметка создана")

self.refresh_notes()

def on_delete_note(self):
current_note_id = self.view.get_current_note_id()

if not current_note_id:
self.view.show_error("Выберите заметку для удаления")
return

self.repository.delete_note(current_note_id)
self.view.clear_note_display()
self.refresh_notes()
self.view.show_info("Заметка удалена")

# app.py (Основной файл приложения)
import sys
from PyQt5.QtWidgets import QApplication
from models import NoteRepository
from views import NoteView
from presenters import NotePresenter

if __name__ == "__main__":
app = QApplication(sys.argv)

# Создаем репозиторий данных
repository = NoteRepository()

# Создаем представление
view = NoteView()

# Создаем презентер, связывающий модель и представление
presenter = NotePresenter(repository, view)

# Показываем главное окно
view.show()

# Запускаем главный цикл приложения
sys.exit(app.exec_())

# Пример использования QThreadPool для выполнения фоновых задач
from PyQt5.QtCore import QRunnable, QThreadPool, pyqtSignal, QObject

# Класс для передачи сигналов из потока
class WorkerSignals(QObject):
finished = pyqtSignal()
error = pyqtSignal(str)
result = pyqtSignal(object)

# Класс для выполнения работы в отдельном потоке
class Worker(QRunnable):
def __init__(self, fn, *args, **kwargs):
super().__init__()
self.fn = fn
self.args = args
self.kwargs = kwargs
self.signals = WorkerSignals()

def run(self):
try:
result = self.fn(*self.args, **self.kwargs)
self.signals.result.emit(result)
except Exception as e:
self.signals.error.emit(str(e))
finally:
self.signals.finished.emit()

# Использование в презентере
def on_load_data(self):
# Показываем индикатор загрузки
self.view.show_loading_indicator(True)

# Создаем рабочий объект
worker = Worker(self.repository.load_large_dataset)

# Подключаем обработчики сигналов
worker.signals.result.connect(self.on_data_loaded)
worker.signals.error.connect(self.on_load_error)
worker.signals.finished.connect(
lambda: self.view.show_loading_indicator(False)
)

# Запускаем рабочий объект в пуле потоков
QThreadPool.globalInstance().start(worker)

# Пример настройки логирования
import logging

def setup_logging():
logger = logging.getLogger('my_app')
logger.setLevel(logging.DEBUG)

# Обработчик для консоли
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)

# Обработчик для файла
file_handler = logging.FileHandler('app.log')
file_handler.setLevel(logging.INFO)

# Формат сообщений
formatter = logging.Formatter('%(asctime)s – %(name)s – %(levelname)s – %(message)s')
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)

logger.addHandler(console_handler)
logger.addHandler(file_handler)

return logger

# Использование
logger = setup_logging()
logger.debug("Приложение запущено в режиме отладки")
logger.info("Пользователь авторизован")
logger.error("Ошибка при сохранении данных", exc_info=True)

pip install pyinstaller

pyinstaller --onefile --windowed app.py

pyi-makespec --onefile --windowed app.py

# -*- mode: python ; coding: utf-8 -*-

block_cipher = None

# Дополнительные файлы и ресурсы
added_files = [
('resources/images/*.png', 'resources/images'),
('resources/data/config.json', 'resources/data'),
('README.md', '.')
]

a = Analysis(
['app.py'],
pathex=[],
binaries=[],
datas=added_files,
hiddenimports=['pkg_resources.py2_warn'],
hookspath=[],
hooksconfig={},
runtime_hooks=[],
excludes=[],
win_no_prefer_redirects=False,
win_private_assemblies=False,
cipher=block_cipher,
noarchive=False,
)

pyz = PYZ(
a.pure, 
a.zipped_data,
cipher=block_cipher
)

exe = EXE(
pyz,
a.scripts,
a.binaries,
a.zipfiles,
a.datas,
[],
name='NotesApp',
debug=False,
bootloader_ignore_signals=False,
strip=False,
upx=True,
upx_exclude=[],
runtime_tmpdir=None,
console=False,
disable_windowed_traceback=False,
argv_emulation=False,
target_arch=None,
codesign_identity=None,
entitlements_file=None,
icon='resources/images/app_icon.ico',
)

pyinstaller app.spec

import os
import sys

def get_resource_path(relative_path):
"""Получить абсолютный путь к ресурсу, работает как в разработке, так и в собранном приложении"""
try:
# PyInstaller создает временную папку и сохраняет путь в _MEIPASS
base_path = sys._MEIPASS
except Exception:
base_path = os.path.abspath(".")

return os.path.join(base_path, relative_path)

# Использование
icon_path = get_resource_path("resources/images/icon.png")
config_path = get_resource_path("resources/data/config.json")