Программный модуль «Книжный магазин» с графическим интерфейсом пользователя

import tkinter as tk
from tkinter import ttk
from tkinter import messagebox
import json
 
 
class Book:
    def __init__(self, title, author, genre, price, quantity):
        self.title = title
        self.author = author
        self.genre = genre
        self.price = price
        self.quantity = quantity
 
    def __str__(self):
        return f"Название: {self.title}\nАвтор: {self.author}\nЖанр: {self.genre}\nЦена: {self.price}\nКоличество: {self.quantity}"
 
    def to_dict(self):
        return {
            "title": self.title,
            "author": self.author,
            "genre": self.genre,
            "price": self.price,
            "quantity": self.quantity
        }
 
 
class BookStore:
    def __init__(self, filename="books.json"):
        self.filename = filename
        self.inventory = self.load_inventory()
 
    def load_inventory(self):
        try:
            with open(self.filename, "r") as f:
                data = json.load(f)
                return [Book(**book) for book in data]
        except FileNotFoundError:
            return []
 
    def save_inventory(self):
        with open(self.filename, "w") as f:
            json.dump([book.to_dict() for book in self.inventory], f, indent=4)
 
    def add_book(self, title, author, genre, price, quantity):
        self.inventory.append(Book(title, author, genre, price, quantity))
        self.save_inventory()
 
    def remove_book(self, title):
        for i, book in enumerate(self.inventory):
            if book.title == title:
                del self.inventory[i]
                self.save_inventory()
                return True
        return False
 
    def find_book(self, criteria, value):
        result = []
        for book in self.inventory:
            if getattr(book, criteria) == value:
                result.append(book)
        return result
 
    def sort_inventory(self, criteria):
        self.inventory.sort(key=lambda book: getattr(book, criteria))
 
    def filter_inventory(self, criteria, value):
        return self.find_book(criteria, value)
 
 
class BookStoreGUI:
    def __init__(self, master):
        self.master = master
        master.title("Книжный магазин")
 
        self.store = BookStore()
 
        self.create_widgets()
 
    def create_widgets(self):
        # Меню
        menubar = tk.Menu(self.master)
        filemenu = tk.Menu(menubar, tearoff=0)
        filemenu.add_command(label="Добавить книгу", command=self.add_book_window)
        filemenu.add_command(label="Удалить книгу", command=self.remove_book_window)
        filemenu.add_command(label="Изменить книгу", command=self.edit_book_window)
        filemenu.add_separator()
        filemenu.add_command(label="Выход", command=self.master.quit)
        menubar.add_cascade(label="Файл", menu=filemenu)
        self.master.config(menu=menubar)
 
        # Фрейм для списка книг
        book_frame = tk.Frame(self.master)
        book_frame.pack()
 
        # Список книг
        self.book_listbox = tk.Listbox(book_frame, width=60, height=10)
        self.book_listbox.pack(side="left")
 
        # Скроллбар для списка
        scrollbar = tk.Scrollbar(book_frame)
        scrollbar.pack(side="right", fill="y")
 
        # Привязка скроллбара к списку
        self.book_listbox.config(yscrollcommand=scrollbar.set)
        scrollbar.config(command=self.book_listbox.yview)
 
        # Кнопка "Обновить список"
        refresh_button = tk.Button(book_frame, text="Обновить список", command=self.refresh_book_list)
        refresh_button.pack()
 
        # Фрейм для поиска
        search_frame = tk.Frame(self.master)
        search_frame.pack()
 
        # Метка "Поиск"
        search_label = tk.Label(search_frame, text="Поиск:")
        search_label.pack(side="left")
 
        # Поле ввода для поиска
        self.search_entry = tk.Entry(search_frame)
        self.search_entry.pack(side="left")
 
        # Выпадающий список критериев поиска
        self.search_criteria_var = tk.StringVar(search_frame)
        self.search_criteria_var.set("title")
        search_criteria_options = ["title", "author", "genre"]
        search_criteria_dropdown = ttk.Combobox(search_frame, textvariable=self.search_criteria_var,
                                                values=search_criteria_options)
        search_criteria_dropdown.pack(side="left")
 
        # Кнопка "Искать"
        search_button = tk.Button(search_frame, text="Искать", command=self.search_books)
        search_button.pack(side="left")
 
        self.refresh_book_list()
 
    def refresh_book_list(self):
        self.book_listbox.delete(0, tk.END)
        for book in self.store.inventory:
            self.book_listbox.insert(tk.END, book)
 
    def add_book_window(self):
        def add_book():
            title = title_entry.get()
            author = author_entry.get()
            genre = genre_entry.get()
            try:
                price = float(price_entry.get())
                quantity = int(quantity_entry.get())
            except ValueError:
                messagebox.showerror("Ошибка", "Некорректный ввод цены или количества")
                return
            self.store.add_book(title, author, genre, price, quantity)
            self.refresh_book_list()
            add_book_window.destroy()
 
        add_book_window = tk.Toplevel(self.master)
        add_book_window.title("Добавить книгу")
 
        title_label = tk.Label(add_book_window, text="Название:")
        title_label.grid(row=0, column=0)
        title_entry = tk.Entry(add_book_window)
        title_entry.grid(row=0, column=1)
 
        author_label = tk.Label(add_book_window, text="Автор:")
        author_label.grid(row=1, column=0)
        author_entry = tk.Entry(add_book_window)
        author_entry.grid(row=1, column=1)
 
        genre_label = tk.Label(add_book_window, text="Жанр:")
        genre_label.grid(row=2, column=0)
        genre_entry = tk.Entry(add_book_window)
        genre_entry.grid(row=2, column=1)
 
        price_label = tk.Label(add_book_window, text="Цена:")
        price_label.grid(row=3, column=0)
        price_entry = tk.Entry(add_book_window)
        price_entry.grid(row=3, column=1)
 
        quantity_label = tk.Label(add_book_window, text="Количество:")
        quantity_label.grid(row=4, column=0)
        quantity_entry = tk.Entry(add_book_window)
        quantity_entry.grid(row=4, column=1)
 
        add_button = tk.Button(add_book_window, text="Добавить", command=add_book)
        add_button.grid(row=5, columnspan=2)
 
    def remove_book_window(self):
        def remove_book():
            title = title_entry.get()
            if self.store.remove_book(title):
                self.refresh_book_list()
                remove_book_window.destroy()
            else:
                messagebox.showerror("Ошибка", f"Книга '{title}' не найдена.")
 
        remove_book_window = tk.Toplevel(self.master)
        remove_book_window.title("Удалить книгу")
 
        title_label = tk.Label(remove_book_window, text="Название:")
        title_label.grid(row=0, column=0)
        title_entry = tk.Entry(remove_book_window)
        title_entry.grid(row=0, column=1)
 
        remove_button = tk.Button(remove_book_window, text="Удалить", command=remove_book)
        remove_button.grid(row=1, columnspan=2)
 
    def edit_book_window(self):
        def edit_book():
            title = title_entry.get()
            author = author_entry.get()
            genre = genre_entry.get()
            try:
                price = float(price_entry.get())
                quantity = int(quantity_entry.get())
            except ValueError:
                messagebox.showerror("Ошибка", "Некорректный ввод цены или количества")
                return
 
            for i, book in enumerate(self.store.inventory):
                if book.title == selected_book.title:
                    self.store.inventory[i] = Book(title, author, genre, price, quantity)
                    self.store.save_inventory()
                    self.refresh_book_list()
                    edit_book_window.destroy()
                    return
 
            messagebox.showerror("Ошибка", f"Книга '{selected_book.title}' не найдена.")
 
        selected_book = self.get_selected_book()
        if not selected_book:
            messagebox.showerror("Ошибка", "Выберите книгу для редактирования")
            return
 
        edit_book_window = tk.Toplevel(self.master)
        edit_book_window.title("Изменить книгу")
 
        title_label = tk.Label(edit_book_window, text="Название:")
        title_label.grid(row=0, column=0)
        title_entry = tk.Entry(edit_book_window)
        title_entry.grid(row=0, column=1)
        title_entry.insert(0, selected_book.title)
 
        author_label = tk.Label(edit_book_window, text="Автор:")
        author_label.grid(row=1, column=0)
        author_entry = tk.Entry(edit_book_window)
        author_entry.grid(row=1, column=1)
        author_entry.insert(0, selected_book.author)
 
        genre_label = tk.Label(edit_book_window, text="Жанр:")
        genre_label.grid(row=2, column=0)
        genre_entry = tk.Entry(edit_book_window)
        genre_entry.grid(row=2, column=1)
        genre_entry.insert(0, selected_book.genre)
 
        price_label = tk.Label(edit_book_window, text="Цена:")
        price_label.grid(row=3, column=0)
        price_entry = tk.Entry(edit_book_window)
        price_entry.grid(row=3, column=1)
        price_entry.insert(0, selected_book.price)
 
        quantity_label = tk.Label(edit_book_window, text="Количество:")
        quantity_label.grid(row=4, column=0)
        quantity_entry = tk.Entry(edit_book_window)
        quantity_entry.grid(row=4, column=1)
        quantity_entry.insert(0, selected_book.quantity)
 
        edit_button = tk.Button(edit_book_window, text="Изменить", command=edit_book)
        edit_button.grid(row=5, columnspan=2)
 
    def get_selected_book(self):
        selection = self.book_listbox.curselection()
        if selection:
            index = selection[0]
            return self.store.inventory[index]
        else:
            return None
 
    def search_books(self):
        criteria = self.search_criteria_var.get()
        value = self.search_entry.get()
        result = self.store.find_book(criteria, value)
        self.book_listbox.delete(0, tk.END)
        for book in result:
            self.book_listbox.insert(tk.END, book)
 
 
root = tk.Tk()
app = BookStoreGUI(root)
root.mainloop()

import tkinter as tk
from tkinter import ttk, messagebox, filedialog
import json
import pandas as pd
from collections import defaultdict
from functools import partial
 
 
class ExcelDataManager:
    def __init__(self, filename):
        self.filename = filename
        self.df = None
        self.load_data()
 
    def load_data(self):
        try:
            self.df = pd.read_excel(self.filename)
        except Exception as e:
            messagebox.showerror("Ошибка", f"Не удалось загрузить файл: {e}")
 
    def get_all_books(self):
        if self.df is None:
            return []
        return [Book(**row) for _, row in self.df.iterrows()]
 
    def save_books(self, books):
        self.df = pd.DataFrame([book.to_dict() for book in books])
        try:
            self.df.to_excel(self.filename, index=False)
        except Exception as e:
            messagebox.showerror("Ошибка", f"Не удалось сохранить файл: {e}")
 
 
class Book:
    def __init__(self, Номер_продажи, Название_товара, Категория, Цена, Количество, Сумма, Способ_оплаты, Продавец,
                 Дата):
        self.id = Номер_продажи
        self.title = Название_товара
        self.category = Категория
        self.price = Цена
        self.quantity = Количество
        self.total = Сумма
        self.payment_method = Способ_оплаты
        self.seller = Продавец
        self.date = Дата
 
    def __str__(self):
        return f"{self.title} - {self.category} - {self.price} руб."
 
    def to_dict(self):
        return {
            "Номер_продажи": self.id,
            "Название_товара": self.title,
            "Категория": self.category,
            "Цена": self.price,
            "Количество": self.quantity,
            "Сумма": self.total,
            "Способ_оплаты": self.payment_method,
            "Продавец": self.seller,
            "Дата": self.date
        }
 
 
class BookStore:
    def __init__(self, filename="books.xlsx"):
        self.data_manager = ExcelDataManager(filename)
        self.inventory = self.data_manager.get_all_books()
        self.sorted_inventory = {}
 
    def save_inventory(self):
        self.data_manager.save_books(self.inventory)
        self.sorted_inventory.clear()
 
    def add_book(self, **kwargs):
        new_book = Book(**kwargs)
        self.inventory.append(new_book)
        self.save_inventory()
 
    def remove_book(self, book_id):
        self.inventory = [book for book in self.inventory if book.id != book_id]
        self.save_inventory()
 
    def find_books(self, criteria, value):
        return list(filter(lambda book: getattr(book, criteria, '').lower() == value.lower(), self.inventory))
 
    def sort_inventory(self, criteria):
        if criteria not in self.sorted_inventory:
            self.sorted_inventory[criteria] = sorted(self.inventory, key=lambda book: getattr(book, criteria))
        return self.sorted_inventory[criteria]
 
    def filter_inventory(self, criteria, value):
        return self.find_books(criteria, value)
 
 
class BookStoreGUI:
    def __init__(self, master):
        self.master = master
        self.master.title("Книжный магазин")
        self.store = BookStore()
        self.create_widgets()
 
    def create_widgets(self):
        self.create_menu()
        self.create_book_list()
        self.create_search_frame()
        self.create_sort_frame()
        self.create_filter_frame()
 
    def create_menu(self):
        menubar = tk.Menu(self.master)
        filemenu = tk.Menu(menubar, tearoff=0)
        filemenu.add_command(label="Добавить книгу", command=self.add_book_window)
        filemenu.add_command(label="Удалить книгу", command=self.remove_book_window)
        filemenu.add_command(label="Изменить книгу", command=self.edit_book_window)
        filemenu.add_separator()
        filemenu.add_command(label="Экспорт в файл", command=self.export_to_file)
        filemenu.add_command(label="Выход", command=self.master.quit)
        menubar.add_cascade(label="Файл", menu=filemenu)
        self.master.config(menu=menubar)
 
    def create_book_list(self):
        book_frame = ttk.Frame(self.master)
        book_frame.pack(padx=10, pady=10, fill=tk.BOTH, expand=True)
 
        self.book_tree = ttk.Treeview(book_frame, columns=("ID", "Название", "Категория", "Цена", "Количество"),
                                      show="headings")
        self.book_tree.heading("ID", text="ID")
        self.book_tree.heading("Название", text="Название")
        self.book_tree.heading("Категория", text="Категория")
        self.book_tree.heading("Цена", text="Цена")
        self.book_tree.heading("Количество", text="Количество")
        self.book_tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
 
        scrollbar = ttk.Scrollbar(book_frame, orient=tk.VERTICAL, command=self.book_tree.yview)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        self.book_tree.configure(yscrollcommand=scrollbar.set)
 
        self.refresh_book_list()
 
    def create_search_frame(self):
        search_frame = ttk.LabelFrame(self.master, text="Поиск")
        search_frame.pack(padx=10, pady=5, fill=tk.X)
 
        self.search_var = tk.StringVar()
        search_entry = ttk.Entry(search_frame, textvariable=self.search_var)
        search_entry.pack(side=tk.LEFT, padx=5)
 
        search_button = ttk.Button(search_frame, text="Поиск", command=self.search_books)
        search_button.pack(side=tk.LEFT, padx=5)
 
    def create_sort_frame(self):
        sort_frame = ttk.LabelFrame(self.master, text="Сортировка")
        sort_frame.pack(padx=10, pady=5, fill=tk.X)
 
        self.sort_var = tk.StringVar()
        sort_options = ["id", "title", "category", "price", "quantity"]
        sort_menu = ttk.OptionMenu(sort_frame, self.sort_var, "Выберите поле", *sort_options)
        sort_menu.pack(side=tk.LEFT, padx=5)
 
        sort_button = ttk.Button(sort_frame, text="Сортировать", command=self.sort_books)
        sort_button.pack(side=tk.LEFT, padx=5)
 
    def create_filter_frame(self):
        filter_frame = ttk.LabelFrame(self.master, text="Фильтрация")
        filter_frame.pack(padx=10, pady=5, fill=tk.X)
 
        self.filter_var = tk.StringVar()
        filter_options = ["category", "payment_method", "seller"]
        filter_menu = ttk.OptionMenu(filter_frame, self.filter_var, "Выберите поле", *filter_options)
        filter_menu.pack(side=tk.LEFT, padx=5)
 
        self.filter_value_var = tk.StringVar()
        filter_entry = ttk.Entry(filter_frame, textvariable=self.filter_value_var)
        filter_entry.pack(side=tk.LEFT, padx=5)
 
        filter_button = ttk.Button(filter_frame, text="Фильтровать", command=self.filter_books)
        filter_button.pack(side=tk.LEFT, padx=5)
 
    def refresh_book_list(self):
        for item in self.book_tree.get_children():
            self.book_tree.delete(item)
        for book in self.store.inventory:
            self.book_tree.insert("", tk.END, values=(book.id, book.title, book.category, book.price, book.quantity))
 
    def add_book_window(self):
        add_window = tk.Toplevel(self.master)
        add_window.title("Добавить книгу")
 
        fields = ["ID", "Название", "Категория", "Цена", "Количество", "Сумма", "Способ оплаты", "Продавец", "Дата"]
        entries = {field: tk.StringVar() for field in fields}
 
        for i, field in enumerate(fields):
            tk.Label(add_window, text=field).grid(row=i, column=0, padx=5, pady=5)
            tk.Entry(add_window, textvariable=entries[field]).grid(row=i, column=1, padx=5, pady=5)
 
        def add_book():
            try:
                book_data = {
                    "Номер_продажи": int(entries["ID"].get()),
                    "Название_товара": entries["Название"].get(),
                    "Категория": entries["Категория"].get(),
                    "Цена": float(entries["Цена"].get()),
                    "Количество": int(entries["Количество"].get()),
                    "Сумма": float(entries["Сумма"].get()),
                    "Способ_оплаты": entries["Способ оплаты"].get(),
                    "Продавец": entries["Продавец"].get(),
                    "Дата": entries["Дата"].get()
                }
                self.store.add_book(**book_data)
                self.refresh_book_list()
                add_window.destroy()
            except ValueError as e:
                messagebox.showerror("Ошибка", f"Неверный формат данных: {e}")
            except Exception as e:
                messagebox.showerror("Ошибка", f"Не удалось добавить книгу: {e}")
 
        tk.Button(add_window, text="Добавить", command=add_book).grid(row=len(fields), column=0, columnspan=2, pady=10)
 
    def remove_book_window(self):
        selected_item = self.book_tree.selection()
        if not selected_item:
            messagebox.showerror("Ошибка", "Выберите книгу для удаления")
            return
 
        book_id = self.book_tree.item(selected_item)['values'][0]
        if messagebox.askyesno("Подтверждение", f"Вы уверены, что хотите удалить книгу с ID {book_id}?"):
            self.store.remove_book(book_id)
            self.refresh_book_list()
 
    def edit_book_window(self):
        selected_item = self.book_tree.selection()
        if not selected_item:
            messagebox.showerror("Ошибка", "Выберите книгу для редактирования")
            return
 
        book_id = self.book_tree.item(selected_item)['values'][0]
        book = next((book for book in self.store.inventory if book.id == book_id), None)
 
        if not book:
            messagebox.showerror("Ошибка", "Книга не найдена")
            return
 
        edit_window = tk.Toplevel(self.master)
        edit_window.title("Редактировать книгу")
 
        fields = [("ID", "id"), ("Название", "title"), ("Категория", "category"),
                  ("Цена", "price"), ("Количество", "quantity"), ("Сумма", "total"),
                  ("Способ оплаты", "payment_method"), ("Продавец", "seller"), ("Дата", "date")]
        entries = {}
 
        for i, (field_name, attr_name) in enumerate(fields):
            tk.Label(edit_window, text=field_name).grid(row=i, column=0, padx=5, pady=5)
            entries[field_name] = tk.Entry(edit_window)
            entries[field_name].grid(row=i, column=1, padx=5, pady=5)
            entries[field_name].insert(0, getattr(book, attr_name))
 
        def update_book():
            try:
                book_data = {
                    "Номер_продажи": int(entries["ID"].get()),
                    "Название_товара": entries["Название"].get(),
                    "Категория": entries["Категория"].get(),
                    "Цена": float(entries["Цена"].get()),
                    "Количество": int(entries["Количество"].get()),
                    "Сумма": float(entries["Сумма"].get()),
                    "Способ_оплаты": entries["Способ оплаты"].get(),
                    "Продавец": entries["Продавец"].get(),
                    "Дата": entries["Дата"].get()
                }
                self.store.remove_book(book_id)
                self.store.add_book(**book_data)
                self.refresh_book_list()
                edit_window.destroy()
            except ValueError as e:
                messagebox.showerror("Ошибка", f"Неверный формат данных: {e}")
            except Exception as e:
                messagebox.showerror("Ошибка", f"Не удалось обновить книгу: {e}")
 
        tk.Button(edit_window, text="Обновить", command=update_book).grid(row=len(fields), column=0, columnspan=2,
                                                                          pady=10)
 
    def search_books(self):
        search_term = self.search_var.get().lower()
        matching_items = [item for item in self.book_tree.get_children()
                          if any(search_term in str(value).lower()
                                 for value in self.book_tree.item(item)['values'])]
        self.book_tree.selection_set(matching_items)
 
    def sort_books(self):
        criteria = self.sort_var.get()
        if criteria in ["id", "title", "category", "price", "quantity"]:
            sorted_books = self.store.sort_inventory(criteria)
            self.update_book_list(sorted_books)
 
    def filter_books(self):
        criteria = self.filter_var.get()
        value = self.filter_value_var.get()
        if criteria and value:
            filtered_books = self.store.filter_inventory(criteria, value)
            self.update_book_list(filtered_books)
 
    def update_book_list(self, books):
        self.book_tree.delete(*self.book_tree.get_children())
        for book in books:
            self.book_tree.insert("", tk.END, values=(book.id, book.title, book.category, book.price, book.quantity))
 
    def export_to_file(self):
        file_path = filedialog.asksaveasfilename(defaultextension=".json",
                                                 filetypes=[("JSON files", "*.json"), ("All files", "*.*")])
        if file_path:
            try:
                data = [book.to_dict() for book in self.store.inventory]
                with open(file_path, 'w', encoding='utf-8') as f:
                    json.dump(data, f, ensure_ascii=False, indent=4)
                messagebox.showinfo("Экспорт завершен", f"Данные успешно экспортированы в {file_path}")
            except Exception as e:
                messagebox.showerror("Ошибка", f"Не удалось экспортировать данные: {e}")
 
 
def main():
    root = tk.Tk()
    app = BookStoreGUI(root)
    root.geometry("800x600")
    root.mainloop()
 
 
if __name__ == "__main__":
    main()