python_lectures/python_lesson_part_8.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5056d2bd",
   "metadata": {},
   "source": [
    "## Содержание:\n",
    "\n",
    "- Библиотека tkinter для разработки графического интерфейса\n",
    "- Создание виджетов\n",
    "- Настройка окна\n",
    "- Свойства виджета\n",
    "- Расположение виджетов\n",
    "- Пример виджетов\n",
    "- Примеры работы с библиотекой tkinter"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67f2a626",
   "metadata": {},
   "source": [
    "# Библиотека tkinter для разработки графического интерфейса\n",
    "\n",
    "Tkinter – это стандартная библиотека GUI (графического интерфейса пользователя) для Python. Она предоставляет набор инструментов для создания окон, кнопок, ярлыков, меню, текстовых полей и других виджетов для создания настольных приложений. Это кроссплатформенная библиотека, что означает, что ее можно использовать в Windows, macOS и Linux.\n",
    "\n",
    "[Документация](https://docs.python.org/3/library/tkinter.html)\n",
    "\n",
    "[TkDocs](https://tkdocs.com/)\n",
    "\n",
    "[Tk Tutorial](https://tk-tutorial.readthedocs.io/en/latest/index.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e902ef03",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter\n",
    "\n",
    "window = tkinter.Tk()\n",
    "\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50f3d7fe",
   "metadata": {},
   "source": [
    "Класс `Tk()` создает новый объект \"окно\", а метод `mainloop()` запускает цикл событий, который \"слушает\" пользовательский ввод – нажатие мыши и нажатия на клавиатуру.\n",
    "\n",
    "### Создание виджетов:\n",
    "\n",
    "**Tkinter** предоставляет несколько виджетов, которые вы можете использовать для создания графических интерфейсов. Вот некоторые из наиболее часто используемых виджетов:\n",
    "\n",
    "* Лейбл (Label): отображает текст или изображение\n",
    "* Кнопка (Button): кликабельная кнопка, выполняющая действие при нажатии\n",
    "* Ввод (Entry): текстовое поле для ввода пользователем\n",
    "* Текст (Text): многострочное текстовое поле для ввода или отображения пользователем\n",
    "* Фрейм (Frame): контейнер для других виджетов\n",
    "\n",
    "Чтобы создать виджет, необходимо вызвать его конструктор и указать ему родительский виджет – виджет, который будет содержать новый виджет."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc39a80a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Создаём окно\n",
    "window = tkinter.Tk()\n",
    "\n",
    "# Создаём лейбл\n",
    "label = tkinter.Label(window, text = \"Hello, world!\")\n",
    "\n",
    "# Создаём кнопку\n",
    "button = tkinter.Button(window, text = \"Клик!\")\n",
    "\n",
    "# Добавляем виджеты в окно\n",
    "label.pack()\n",
    "button.pack()\n",
    "\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28edc379",
   "metadata": {},
   "source": [
    "### Настройка окна:\n",
    "\n",
    "Вы можете настроить внешний вид окна, задав его свойства. Вот некоторые часто используемые методы:\n",
    "\n",
    "* title: текст, который отображается в строке заголовка окна\n",
    "* geometry: размер и положение окна (в пикселях)\n",
    "* resizable: может ли пользователь изменять размер окна\n",
    "\n",
    "В Tkinter можно конфигурировать виджеты и окна, задавая их свойства с помощью метода `configure()`. Этот метод принимает именованные аргументы (`**kwargs`), которые соответствуют свойствам, которые вы хотите установить."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "539daebe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Создаём окно\n",
    "window = tkinter.Tk()\n",
    "window.title('Hello')\n",
    "window.configure(padx = 200, pady = 300)\n",
    "\n",
    "# Создаём лейбл\n",
    "label = tkinter.Label(window, text = \"Hello, world!\")\n",
    "\n",
    "# Создаём кнопку\n",
    "button = tkinter.Button(window, text = \"Клик!\")\n",
    "\n",
    "# Добавляем виджеты в окно\n",
    "label.pack()\n",
    "button.pack()\n",
    "\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66dc2d76",
   "metadata": {},
   "source": [
    "### Свойства виджета:\n",
    "\n",
    "Виджеты имеют множество свойств, которые вы можете установить для настройки их внешнего вида и поведения. Вот некоторые из наиболее часто используемых свойств:\n",
    "\n",
    "* text: текст, отображаемый на виджете\n",
    "* bg: цвет фона виджета\n",
    "* fg: цвет переднего плана (цвет текста) виджета\n",
    "* font: шрифт, используемый для текста на виджете\n",
    "* command: функция, которая будет вызвана при нажатии на виджет"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c8c6070",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Создаём окно\n",
    "window = tkinter.Tk()\n",
    "window.title('Hello')\n",
    "window.configure(padx = 200, pady = 300)\n",
    "\n",
    "# Создаём лейбл\n",
    "label = tkinter.Label(window, text = \"Hello, world!\", bg = \"white\", fg = \"blue\", font = ('Arial', 20))\n",
    "\n",
    "def button_clicked():\n",
    "    label.configure(text = 'Кнопка нажата!')\n",
    "\n",
    "# Создаём кнопку\n",
    "button = tkinter.Button(window, text = \"Клик!\", command = button_clicked)\n",
    "\n",
    "# Добавляем виджеты в окно\n",
    "label.pack()\n",
    "button.pack()\n",
    "\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5d076ea",
   "metadata": {},
   "source": [
    "### Расположение виджетов\n",
    "\n",
    "Чтобы добавить виджеты в окно, необходимо создать их, а затем добавить в окно с помощью одного из менеджеров компоновки, предоставляемых Tkinter. Вот некоторые часто используемые менеджеры компоновки:\n",
    "\n",
    "* pack: упаковывает виджеты плотно друг к другу в вертикальную или горизонтальную рамку\n",
    "* grid: располагает виджеты в виде сетки из строк и столбцов\n",
    "* place: позиционирует виджеты, используя абсолютные координаты\n",
    "\n",
    "### Пример виджетов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33f0854d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "\n",
    "# Создаём новое окно и конфигурацию\n",
    "window = Tk()\n",
    "window.title(\"Примеры виджетов\")\n",
    "window.minsize(width = 500, height = 500)\n",
    "\n",
    "# Лейблы\n",
    "label = Label(text = \"Это старый текст\")\n",
    "label.config(text = \"Это новый текст\")\n",
    "label.pack()\n",
    "\n",
    "# Кнопки\n",
    "def action():\n",
    "    print(\"Сделай что-нибудь\")\n",
    "\n",
    "# Вызывает команду, когда нажимаем на кнопку\n",
    "button = Button(text = \"Клик\", command = action)\n",
    "button.pack()\n",
    "\n",
    "# Entries\n",
    "entry = Entry(width = 30)\n",
    "entry.insert(END, string = \"Текст для начала.\")  # Добавим текст для начала\n",
    "print(entry.get())  # Получаем введенный текст\n",
    "entry.pack()\n",
    "\n",
    "# Текст\n",
    "text = Text(height = 5, width = 30)\n",
    "text.focus()  # Помещаем курсор в этот виджет\n",
    "text.insert(END, \"Пример строки на несколько строчек\")  # Добавим текст для начала\n",
    "print(text.get(\"1.0\", END))  # Получаем значения из окошка для текста (начиная со строки 1, символа 0 до конца)\n",
    "text.pack()\n",
    "\n",
    "# Cчётчик\n",
    "def spinbox_used():\n",
    "    # Получает текущее значение счетчика\n",
    "    print(spinbox.get())\n",
    "spinbox = Spinbox(from_ = 0, to = 10, width = 5, command = spinbox_used)\n",
    "spinbox.pack()\n",
    "\n",
    "# Шкала\n",
    "# Вызывается с текущим уровнем шкалы\n",
    "def scale_used(value):\n",
    "    print(value)\n",
    "scale = Scale(from_ = 0, to = 100, command = scale_used)\n",
    "scale.pack()\n",
    "\n",
    "# Флажок\n",
    "def checkbutton_used():\n",
    "    # Печатает 1, если нажат флажок, иначе 0\n",
    "    print(checked_state.get())\n",
    "# Переменная, чтобы зафиксировать текущий выбор, 0 off, 1 on.\n",
    "checked_state = IntVar()\n",
    "checkbutton = Checkbutton(text = \"Вкл?\", variable = checked_state, command = checkbutton_used)\n",
    "checkbutton.pack()\n",
    "\n",
    "# Выбор\n",
    "def radio_used():\n",
    "    print(radio_state.get())\n",
    "# Переменная, чтобы зафиксировать текущий выбор\n",
    "radio_state = IntVar()\n",
    "radiobutton1 = Radiobutton(text = \"Вариант1\", value = 1, variable = radio_state, command = radio_used)\n",
    "radiobutton2 = Radiobutton(text = \"Вариант2\", value = 2, variable = radio_state, command = radio_used)\n",
    "radiobutton1.pack()\n",
    "radiobutton2.pack()\n",
    "\n",
    "# Список\n",
    "def listbox_used(event):\n",
    "    # Получает текущий выбор из списка\n",
    "    print(listbox.get(listbox.curselection()))\n",
    "\n",
    "listbox = Listbox(height = 4)\n",
    "fruits = [\"Яблоко\", \"Груша\", \"Банан\", \"Апельсин\", \"Тест\"]\n",
    "for item in fruits:\n",
    "    listbox.insert(fruits.index(item), item)\n",
    "listbox.bind(\"<<ListboxSelect>>\", listbox_used)\n",
    "listbox.pack()\n",
    "\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6699a687",
   "metadata": {},
   "source": [
    "Построим GUI менеджера паролей, который будет:\n",
    "\n",
    "а) генерировать пароли;\n",
    "\n",
    "б) сохранять пароли в файл;\n",
    "\n",
    "в) взаимодействовать с пользователем."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c72bcd19",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "from tkinter import messagebox\n",
    "from random import choice, randint, shuffle\n",
    "import pyperclip  # Будем сохранять сгенерированный пароль в буфер обмена\n",
    "\n",
    "# ---------------------------- ГЕНЕРАТОР ПАРОЛЯ ------------------------------- #\n",
    "\n",
    "def generate_password():\n",
    "    letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']\n",
    "    numbers = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']\n",
    "    symbols = ['!', '#', '$', '%', '&', '(', ')', '*', '+']\n",
    "\n",
    "    password_letters = [choice(letters) for _ in range(randint(8, 10))]\n",
    "    password_symbols = [choice(symbols) for _ in range(randint(2, 4))]\n",
    "    password_numbers = [choice(numbers) for _ in range(randint(2, 4))]\n",
    "\n",
    "    password_list = password_letters + password_symbols + password_numbers\n",
    "    shuffle(password_list)\n",
    "\n",
    "    password = \"\".join(password_list)\n",
    "    password_entry.insert(0, password)\n",
    "    pyperclip.copy(password)  # Сохраняет сгенерированный пароль в буфер обмена\n",
    "\n",
    "# ---------------------------- СОХРАНЕНИЕ ПАРОЛЯ ------------------------------- #\n",
    "\n",
    "def save():\n",
    "\n",
    "    website = website_entry.get()\n",
    "    email = email_entry.get()\n",
    "    password = password_entry.get()\n",
    "\n",
    "    if len(website) == 0 or len(password) == 0:\n",
    "        messagebox.showinfo(title = \"Упс!\", message = \"Не все поля заполнены.\")\n",
    "    else:\n",
    "        is_ok = messagebox.askokcancel(title = website, message = f\"Введенные данные: \\nEmail: {email} \"\n",
    "                                                      f\"\\nПароль: {password} \\nСохранить?\")\n",
    "        if is_ok:\n",
    "            with open(\"data.txt\", \"a\") as data_file:\n",
    "                data_file.write(f\"{website} | {email} | {password}\\n\")\n",
    "                website_entry.delete(0, END)  # Константа END из tkinter хранит в себе индекс последнего элемента Entry\n",
    "                password_entry.delete(0, END)  # То есть эта запись удалит все данные от начала (0) до конца (END) Entry\n",
    "\n",
    "# ---------------------------- НАСТРОЙКА UI (User Interface – интерфейс пользователя) ------------------------------- #\n",
    "\n",
    "window = Tk()\n",
    "window.title(\"Хранитель паролей\")\n",
    "window.configure(padx = 50, pady = 50)\n",
    "\n",
    "# Загружаем изображение\n",
    "canvas = Canvas(height = 200, width = 200)\n",
    "logo_img = PhotoImage(file=\"_add_material_lesson_python\\\\pass_01.png\")\n",
    "canvas.create_image(100, 100, image = logo_img)\n",
    "canvas.grid(row = 0, column = 1)\n",
    "\n",
    "# Лейблы\n",
    "website_label = Label(text = \"Сайт:\")\n",
    "website_label.grid(row = 1, column = 0)\n",
    "\n",
    "email_label = Label(text = \"Email/Username:\")\n",
    "email_label.grid(row = 2, column = 0)\n",
    "\n",
    "password_label = Label(text = \"Пароль:\")\n",
    "password_label.grid(row = 3, column = 0)\n",
    "\n",
    "# Текстовые вставки\n",
    "website_entry = Entry(width = 35)\n",
    "website_entry.grid(row = 1, column = 1, columnspan = 2)\n",
    "website_entry.focus()  # Этот метод позволяет пользователю без клика на поле вводить текст\n",
    "\n",
    "email_entry = Entry(width = 35)\n",
    "email_entry.grid(row = 2, column = 1, columnspan = 2)\n",
    "email_entry.insert(0, \"user_1@mail.ru\")\n",
    "\n",
    "password_entry = Entry(width = 21)\n",
    "password_entry.grid(row = 3, column = 1)\n",
    "\n",
    "# Кнопки\n",
    "generate_password_button = Button(text = \"Генерация\", command = generate_password)\n",
    "generate_password_button.grid(row = 3, column = 2)\n",
    "\n",
    "add_button = Button(text = \"Добавить\", width = 36, command = save)\n",
    "add_button.grid(row = 4, column = 1, columnspan = 2)\n",
    "\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b27af7ac",
   "metadata": {},
   "source": [
    "## Примеры работы с библиотекой tkinter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6437dda",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Tkinter. Создание окна приложения\n",
    "\n",
    "from tkinter import *\n",
    " \n",
    "root = Tk()  # Для создания графического окна применяется конструктор Tk()\n",
    "root.title(\"Графическая программа на Python\")\n",
    "root.geometry(\"200x300\")\n",
    "\n",
    "root.mainloop()  # Отображения окна"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a01ef07b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Изменение первоночальной позиции окна\n",
    "from tkinter import *\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"Графическая программа на Python\")\n",
    "root.geometry(\"400x300+300+550\")  # \"Ширина x Высота + координата X + координата Y\"\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "848782a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Кнопки\n",
    "\n",
    "from tkinter import *\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "btn = Button(text = \"Hello\")  # Создание кнопки\n",
    "btn.pack()  # Чтобы сделать элемент видимым, у него вызывается метод pack()\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae2212f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Атрибуты кнопок\n",
    "\n",
    "from tkinter import *\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "# Button (master, options)          параметры Button\n",
    "\n",
    "btn = Button(root,\n",
    "             text = \"Hello\",          # Текст кнопки\n",
    "             background = \"#555\",     # Фоновый цвет кнопки\n",
    "             foreground = \"#ccc\",     # Цвет текста\n",
    "             padx = \"20\",             # Отступ от границ до содержимого по горизонтали\n",
    "             pady = \"8\",              # Отступ от границ до содержимого по вертикали\n",
    "             font = \"16\"              # Высота шрифта\n",
    "             )\n",
    "btn.pack()\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78afdcfe",
   "metadata": {},
   "source": [
    "**Набор параметров**:\n",
    "\n",
    "activebackground: цвет кнопки, когда она находится в нажатом состоянии\n",
    "\n",
    "activeforeground: цвет текста кнопки, когда она в нажатом состоянии\n",
    "\n",
    "bd: толщина границы (по умолчанию 2)\n",
    "\n",
    "bg/background: фоновый цвет кнопки\n",
    "\n",
    "fg/foreground: цвет текста кнопки\n",
    "\n",
    "font: шрифт текста, например, font = \"Arial 14\" – шрифт Arial высотой 14px, или font = (\"Verdana\", 13, \"bold\") – шрифт Verdana высотой 13px с выделением жирным\n",
    "\n",
    "height: высота кнопки\n",
    "\n",
    "highlightcolor: цвет кнопки, когда она в фокусе\n",
    "\n",
    "image: изображение на кнопке\n",
    "\n",
    "justify: устанавливает выравнивание текста. Значение LEFT выравнивает текст по левому краю, CENTER – по центру, RIGHT – по правому краю\n",
    "\n",
    "padx: отступ от границ кнопки до ее текста справа и слева\n",
    "\n",
    "pady: отступ от границ кнопки до ее текста сверху и снизу\n",
    "\n",
    "relief: определяет тип границы, может принимать значения SUNKEN, RAISED, GROOVE, RIDGE\n",
    "\n",
    "state: устанавливает состояние кнопки, может принимать значения DISABLED, ACTIVE, NORMAL (по умолчанию)\n",
    "\n",
    "text: устанавливает текст кнопки\n",
    "\n",
    "textvariable: устанавливает привязку к элементу StringVar\n",
    "\n",
    "underline: указывает на номер символа в тексте кнопки, который подчеркивается. По умолчанию значение -1, то есть никакой символ не подчеркивается\n",
    "\n",
    "width: ширина кнопки\n",
    "\n",
    "wraplength: при положительном значении строки текста будут переносится для вмещения в пространство кнопки  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35567068",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Обработка нажатия на кнопку\n",
    "\n",
    "from tkinter import *\n",
    "\n",
    "clicks = 0\n",
    "\n",
    "def click_button():\n",
    "    global clicks\n",
    "    clicks += 1\n",
    "    root.title(\"Clicks {}\".format(clicks))\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "btn = Button(text = \"Click Me\", background = \"#555\", foreground = \"#ccc\",\n",
    "             padx = \"20\", pady = \"8\", font = \"16\", command = click_button)\n",
    "btn.pack()\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66edb377",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Изменение свойств элементов\n",
    "\n",
    "# Компонент StringVar\n",
    "\n",
    "from tkinter import *\n",
    "\n",
    "clicks = 0\n",
    "\n",
    "def click_button():\n",
    "    global clicks\n",
    "    clicks += 1\n",
    "    buttonText.set(\"Clicks {}\".format(clicks))  # Изменения при клике\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "buttonText = StringVar()\n",
    "buttonText.set(\"Clicks {}\".format(clicks))  # Значение при запуске программы\n",
    "\n",
    "btn = Button(textvariable = buttonText,  # Вывод текста\n",
    "             background = \"#555\", foreground = \"#ccc\",\n",
    "             padx = \"20\", pady = \"8\", font = \"16\", command = click_button)\n",
    "btn.pack()\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67b1c604",
   "metadata": {},
   "outputs": [],
   "source": [
    "# config\n",
    "\n",
    "from tkinter import *\n",
    "\n",
    "clicks = 0\n",
    "\n",
    "def click_button():\n",
    "    global clicks\n",
    "    clicks += 1\n",
    "    btn.config(text = \"Clicks {}\".format(clicks))\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "btn = Button(text = \"Clicks 0\", background = \"#555\", foreground = \"#ccc\",\n",
    "             padx = \"20\", pady = \"8\", font = \"16\", command = click_button)\n",
    "btn.pack()\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61a9f51a",
   "metadata": {},
   "source": [
    "## Позиционирование элементов.\n",
    "\n",
    "Метод `pack()`. Этот метод принимает следующие параметры:\n",
    "\n",
    "expand: если равно True, то виджет заполняет все пространство контейнера.\n",
    "\n",
    "fill: определяет, будет ли виджет растягиваться, чтобы заполнить свободное пространство вокруг. Этот параметр может принимать следующие значения:\n",
    "- NONE (по умолчанию, элемент не растягивается),\n",
    "- X (элемент растягивается только по горизонтали),\n",
    "- Y (элемент растягивается только по вертикали)\n",
    "- BOTH (элемент растягивается по вертикали и горизонтали).\n",
    "\n",
    "side: выравнивает виджет по одной из сторон контейнера. Может принимать значения:\n",
    "- TOP (по умолчанию, выравнивается по верхней стороне контейнера),\n",
    "- BOTTOM (выравнивание по нижней стороне),\n",
    "- LEFT (выравнивание по левой стороне),\n",
    "- RIGHT (выравнивание по правой стороне)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19710fd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Растянем кнопку на всю форму, используя параметры expand и fill\n",
    "\n",
    "from tkinter import *\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "btn1 = Button(text = \"CLICK ME\", background = \"#555\", foreground = \"#ccc\",\n",
    "              padx = \"15\", pady = \"6\", font = \"15\")\n",
    "btn1.pack(expand = True, fill = BOTH)\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17784b06",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Используем параметр side\n",
    "\n",
    "from tkinter import *\n",
    "import random\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "btn1 = Button(text = \"BOTTOM\", background = \"#555\", foreground = \"#ccc\",\n",
    "              padx = \"15\", pady = \"6\", font = \"15\")\n",
    "btn1.pack(side = BOTTOM)\n",
    "\n",
    "btn2 = Button(text = \"RIGHT\", background = \"#555\", foreground = \"#ccc\",\n",
    "             padx = \"15\", pady = \"6\", font = \"15\")\n",
    "btn2.pack(side = RIGHT)\n",
    "\n",
    "btn3 = Button(text = \"LEFT\", background = \"#555\", foreground = \"#ccc\",\n",
    "             padx = \"15\", pady = \"6\", font = \"15\")\n",
    "btn3.pack(side = LEFT)\n",
    " \n",
    "btn4 = Button(text = \"TOP\", background = \"#555\", foreground = \"#ccc\",\n",
    "             padx = \"15\", pady = \"6\", font = \"15\")\n",
    "btn4.pack(side = TOP)\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e4fa1a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Комбинируя параметры side и fill, можно растянуть элемент по вертикали\n",
    "\n",
    "from tkinter import *\n",
    "import random\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "btn1 = Button(text = \"CLICK ME\", background = \"#555\", foreground = \"#ccc\",\n",
    "              padx = \"15\", pady = \"6\", font = \"15\")\n",
    "btn1.pack(side = RIGHT, fill = Y)\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cbf5cf4",
   "metadata": {},
   "source": [
    "Метод `place()` позволяет более точно настроить параметры позиционирования. Параметры:\n",
    "\n",
    "height и width: устанавливают соответственно высоту и ширину элемента в пикселях\n",
    "\n",
    "relheight и relwidth: также задают соответственно высоту и ширину элемента, но в качестве значения используется число float в промежутке между 0.0 и 1.0, которое указывает на долю от высоты и ширины родительского контейнера x и y: устанавливают смещение элемента по горизонтали и вертикали в пикселях соответственно относительно верхнего левого угла контейнера.\n",
    "\n",
    "relx и rely: также задают смещение элемента по горизонтали и вертикали, но в качестве значения используется число float в промежутке между 0.0 и 1.0, которое указывает на долю от высоты и ширины родительского контейнера.\n",
    "\n",
    "bordermode: задает формат границы элемента. Может принимать значение INSIDE (по умолчанию) и OUTSIDE\n",
    "\n",
    "anchor: устанавливает опции растяжения элемента. Может принимать значения n, e, s, w, ne, nw, se, sw, c, которые являются сокращениями от Noth (север – вверх), South (юг – низ), East (восток – правая сторона), West (запад – левая сторона) и Center (по центру). Например, значение nw указывает на верхний левый угол."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a3d03537",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Разместим кнопку с шириной 130 пикселей и высотой 30 пикселей в центре окна\n",
    "\n",
    "from tkinter import *\n",
    "\n",
    "clicks = 0\n",
    "\n",
    "def click_button():\n",
    "    global clicks\n",
    "    clicks += 1\n",
    "    btn.config(text = \"Clicks {}\".format(clicks))\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "btn = Button(text = \"Clicks 0\", background = \"#555\", foreground = \"#ccc\",\n",
    "             padx=\"20\", pady = \"8\", font = \"16\", command = click_button)\n",
    "btn.place(relx = .5, rely = .5, anchor = \"c\", height = 30, width = 130, bordermode = OUTSIDE)\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5076217c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Разместим три кнопки\n",
    "\n",
    "from tkinter import *\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "btn1 = Button(text = \"x = 10, y = 20\", background = \"#555\", foreground = \"#ccc\", padx = \"14\",\n",
    "              pady = \"7\", font = \"13\")\n",
    "btn1.place(x = 10, y = 20)\n",
    "\n",
    "btn2 = Button(text = \"x = 50, y = 100\", background = \"#555\", foreground = \"#ccc\", padx = \"14\",\n",
    "              pady = \"7\", font = \"13\")\n",
    "btn2.place(x = 50, y = 100)\n",
    "\n",
    "btn3 = Button(text = \"x = 140, y = 160\", background = \"#555\", foreground = \"#ccc\", padx = \"14\",\n",
    "              pady = \"7\", font = \"13\")\n",
    "btn3.place(x = 140, y = 160)\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa1cb410",
   "metadata": {},
   "source": [
    "Метод `grid` применяет другой подход к позиционированию элементов, нежели метод `place`, позволяя поместить элемент в определенную ячейку условной сетки или грида. Параметры:\n",
    "\n",
    "column: номер столбца, отсчет начинается с нуля\n",
    "\n",
    "row: номер строки, отсчет начинается с нуля\n",
    "\n",
    "columnspan: сколько столбцов должен занимать элемент\n",
    "\n",
    "rowspan: сколько строк должен занимать элемент\n",
    "\n",
    "ipadx и ipady: отступы по горизонтали и вертикали соответственно от границ элемента до его текста\n",
    "\n",
    "padx и pady: отступы по горизонтали и вертикали соответственно от границ ячейки грида до границ элемента\n",
    "\n",
    "sticky: выравнивание элемента в ячейке, если ячейка больше элемента. Может принимать значения n, e, s, w, ne, nw, se, sw, которые указывают соответствующее направление выравнивания"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3161e820",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Грид из 9 кнопок\n",
    "\n",
    "from tkinter import *\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "for r in range(3):\n",
    "    for c in range(3):\n",
    "        btn = Button(text = \"{}-{}\".format(r,c))\n",
    "        btn.grid(row = r, column = c, ipadx = 10, ipady = 6, padx = 10, pady = 10)\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4271484",
   "metadata": {},
   "source": [
    "Текстовая метка `Label`\n",
    "\n",
    "Label(master, options):\n",
    "\n",
    "anchor: устанавливает позиционирование текста\n",
    "\n",
    "bg/background: фоновый цвет\n",
    "\n",
    "bitmap: ссылка на изображение, которое отображается на метке\n",
    "\n",
    "bd: толщина границы метки\n",
    "\n",
    "fg/foreground: цвет текста\n",
    "\n",
    "font: шрифт текста, например, font = \"Arial 14\" – шрифт Arial высотой 14px\n",
    "\n",
    "height: высота элемента\n",
    "\n",
    "cursor: курсор указателя мыши при наведении на метку\n",
    "\n",
    "image: ссылка на изображение, которое отображается на метке\n",
    "\n",
    "justify: устанавливает выравнивание текста. Значение LEFT выравнивает текст по левому краю, CENTER – по центру, RIGHT – по правому краю\n",
    "\n",
    "padx: отступ от границ элемента до его текста справа и слева\n",
    "\n",
    "pady: отступ от границ элемента до его текста сверху и снизу\n",
    "\n",
    "relief: определяет тип границы, по умолчанию значение FLAT\n",
    "\n",
    "text: устанавливает текст метки\n",
    "\n",
    "textvariable: устанавливает привязку к элементу StringVar\n",
    "\n",
    "underline: указывает на номер символа в тексте кнопки, который подчеркивается. По умолчанию значение -1, то есть никакой символ не подчеркивается\n",
    "\n",
    "width: ширина элемента\n",
    "\n",
    "wraplength: при положительном значении строки текста будут переносится для вмещения в пространство элемента"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60839956",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "label1 = Label(text = \"Hello Python\", fg = \"#eee\", bg = \"#333\")\n",
    "label1.pack()\n",
    " \n",
    "poetry = \"Текст\\nв несколько \\nстрок\"\n",
    "label2 = Label(text = poetry, justify = LEFT)\n",
    "label2.place(relx = .2, rely = .3)\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3741830",
   "metadata": {},
   "source": [
    "Поле ввода `Entry`\n",
    "\n",
    "Entry(master, options):\n",
    "\n",
    "bg: фоновый цвет\n",
    "\n",
    "bd: толщина границы\n",
    "\n",
    "cursor: курсор указателя мыши при наведении на текстовое поле\n",
    "\n",
    "fg: цвет текста\n",
    "\n",
    "font: шрифт текста\n",
    "\n",
    "justify: устанавливает выравнивание текста. Значение LEFT выравнивает текст по левому краю, CENTER – по центру, RIGHT – по правому краю\n",
    "\n",
    "relief: определяет тип границы, по умолчанию значение FLAT\n",
    "\n",
    "selectbackground: фоновый цвет выделенного куска текста\n",
    "\n",
    "selectforeground: цвет выделенного текста\n",
    "\n",
    "show: задает маску для вводимых символов\n",
    "\n",
    "state: состояние элемента, может принимать значения NORMAL (по умолчанию) и DISABLED\n",
    "\n",
    "textvariable: устанавливает привязку к элементу StringVar\n",
    "\n",
    "width: ширина элемента"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7cd706c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "from tkinter import messagebox  # Дополнительный модуль для вывода сообщения\n",
    "\n",
    "def show_message():\n",
    "    messagebox.showinfo(\"GUI Python\", message.get())\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "message = StringVar()\n",
    "\n",
    "message_entry = Entry(textvariable = message)\n",
    "message_entry.place(relx = .5, rely = .1, anchor = \"c\")\n",
    "\n",
    "message_button = Button(text = \"Click Me\", command = show_message)\n",
    "message_button.place(relx = .5, rely = .5, anchor = \"c\")\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "301ef15d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ещё один пример с формой\n",
    "\n",
    "from tkinter import *\n",
    "from tkinter import messagebox\n",
    "\n",
    "def display_full_name():\n",
    "    messagebox.showinfo(\"GUI Python\", name.get() + \" \" + surname.get())\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "\n",
    "name = StringVar()\n",
    "surname = StringVar()\n",
    "\n",
    "name_label = Label(text = \"Введите имя:\")\n",
    "surname_label = Label(text = \"Введите фамилию:\")\n",
    "\n",
    "name_label.grid(row = 0, column = 0, sticky = \"w\")\n",
    "surname_label.grid(row = 1, column = 0, sticky = \"w\")\n",
    "\n",
    "name_entry = Entry(textvariable = name)\n",
    "surname_entry = Entry(textvariable = surname)\n",
    "\n",
    "name_entry.grid(row = 0,column = 1, padx = 5, pady = 5)\n",
    "surname_entry.grid(row = 1,column = 1, padx = 5, pady = 5)\n",
    "\n",
    "message_button = Button(text = \"Click Me\", command = display_full_name)\n",
    "message_button.grid(row = 2,column = 1, padx = 5, pady = 5, sticky = \"e\")\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a58467be",
   "metadata": {},
   "source": [
    "Элемент `Entry` имеет ряд методов. Основные из них:\n",
    "\n",
    "insert(index, str): вставляет в текстовое поле строку по определенному индексу\n",
    "\n",
    "get(): возвращает введенный в текстовое поле текст\n",
    "\n",
    "delete(first, last = None): удаляет символ по индексу first. Если указан параметр last, то удаление производится до индекса last. Чтобы удалить до конца, в качестве второго параметра можно использовать значение END"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2431fa87",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "from tkinter import messagebox\n",
    "\n",
    "def clear():\n",
    "    name_entry.delete(0, END)\n",
    "    surname_entry.delete(0, END)\n",
    "\n",
    "def display():\n",
    "    messagebox.showinfo(\"GUI Python\", name_entry.get() + \" \" + surname_entry.get())\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "\n",
    "name_label = Label(text = \"Введите имя:\")\n",
    "surname_label = Label(text = \"Введите фамилию:\")\n",
    "\n",
    "name_label.grid(row = 0, column = 0, sticky = \"w\")\n",
    "surname_label.grid(row = 1, column = 0, sticky = \"w\")\n",
    "\n",
    "name_entry = Entry()\n",
    "surname_entry = Entry()\n",
    "\n",
    "name_entry.grid(row = 0,column = 1, padx = 5, pady = 5)\n",
    "surname_entry.grid(row = 1,column = 1, padx = 5, pady = 5)\n",
    "\n",
    "# Вставка начальных данных\n",
    "name_entry.insert(0, \"Tom\")\n",
    "surname_entry.insert(0, \"Soyer\")\n",
    "\n",
    "display_button = Button(text = \"Display\", command = display)\n",
    "clear_button = Button(text = \"Clear\", command = clear)\n",
    "\n",
    "display_button.grid(row = 2, column = 0, padx = 5, pady = 5, sticky = \"e\")\n",
    "clear_button.grid(row = 2, column = 1, padx = 5, pady = 5, sticky = \"e\")\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9518c0f1",
   "metadata": {},
   "source": [
    "`Checkbutton`\n",
    "\n",
    "Отличительной чертой Checkbutton является возможность привязки к компоненту IntVar через параметр variable. В отмеченном состоянии привязанный компонент IntVar имеет значение 1, а в неотмеченном – 0. В итоге через IntVar мы можем получать значение, указанное пользователем."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0642f34",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "ismarried = IntVar()\n",
    "\n",
    "ismarried_checkbutton = Checkbutton(text = \"Женат/Замужем\", variable = ismarried)\n",
    "ismarried_checkbutton.pack()\n",
    "\n",
    "ismarried_label = Label(textvariable = ismarried)\n",
    "ismarried_label.place(relx = .5, rely = .5, anchor = \"c\")\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b8e924a",
   "metadata": {},
   "source": [
    "`Checkbutton(master, options)`\n",
    "\n",
    "activebackground: фоновый цвет флажка в нажатом состоянии\n",
    "\n",
    "activeforeground: цвет текста флажка в нажатом состоянии\n",
    "\n",
    "bg: фоновый цвет флажка\n",
    "\n",
    "bitmap: монохромное изображение для флажка\n",
    "\n",
    "bd: граница вокруг флажка\n",
    "\n",
    "command: ссылка на функцию, которая вызывается при нажатии на флажок\n",
    "\n",
    "cursor: курсор при наведении на элемент\n",
    "\n",
    "disabledforeground: цвет текста в состоянии DISABLED\n",
    "\n",
    "font: шрифт\n",
    "\n",
    "fg: цвет текста\n",
    "\n",
    "height: высота элемента\n",
    "\n",
    "image: графическое изображение, отображаемое на элементе\n",
    "\n",
    "justify: выравнивание текста, принимает значения CENTER, LEFT, RIGHT\n",
    "\n",
    "offvalue: значение ассоциированной с флажком переменной IntVar в неотмеченном состоянии, по умолчанию равно 0\n",
    "\n",
    "onvalue: значение ассоциированной с флажком переменной IntVar в отмеченном состоянии, по умолчанию равно 1\n",
    "\n",
    "padx: отступы справа и слева от текста до границы флажка\n",
    "\n",
    "pady: отступы сверху и снизу от текста до границы флажка\n",
    "\n",
    "relief: стиль флажка, по умолчанию имеет значение FLAT\n",
    "\n",
    "selectcolor: цвет квадратика флажка\n",
    "\n",
    "selectimage: изображение на флажке, когда он находится в отмеченном состоянии\n",
    "\n",
    "state: состояние элемента, может принимать значения NORMAL (по умолчанию), DISABLED и ACTIVE\n",
    "\n",
    "text: текст элемента\n",
    "\n",
    "underline: индекс подчеркнутого символа в тексте флажка\n",
    "\n",
    "variable: ссылка на переменную, как правило, типа IntVar, которая хранит состояние флажка\n",
    "\n",
    "width: ширина элемента\n",
    "\n",
    "wraplength: устанавливает перенос символов на другую строку в тексте элемента"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99e8f8f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "python_lang = IntVar()\n",
    "python_checkbutton = Checkbutton(text = \"Python\", variable = python_lang,\n",
    "                                 onvalue = 1, offvalue = 0, padx = 15, pady = 10)\n",
    "python_checkbutton.grid(row = 0, column = 0, sticky = W)\n",
    "\n",
    "javascript_lang = IntVar()\n",
    "javascript_checkbutton = Checkbutton(text = \"JavaScript\", variable = javascript_lang,\n",
    "                                     onvalue = 1, offvalue = 0, padx = 15, pady = 10)\n",
    "javascript_checkbutton.grid(row = 1, column = 0, sticky = W)\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5531aac",
   "metadata": {},
   "source": [
    "`Radiobutton`\n",
    "\n",
    "Элемент Radiobutton представляет переключатель, который может находиться в двух состояниях: отмеченном или неотмеченном. Но в отличие от Checkbutton переключатели могут создавать группу, из которой одномоментно мы можем выбрать только один переключатель."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6b3c427",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "header = Label(text = \"Выберите курс\", padx = 15, pady = 10)\n",
    "header.grid(row = 0, column = 0, sticky = W)\n",
    "\n",
    "lang = IntVar()\n",
    "\n",
    "python_checkbutton = Radiobutton(text = \"Python\", value = 1, variable = lang, padx = 15, pady = 10)\n",
    "python_checkbutton.grid(row = 1, column = 0, sticky = W)\n",
    "\n",
    "javascript_checkbutton = Radiobutton(text = \"JavaScript\", value = 2, variable = lang, padx = 15, pady = 10)\n",
    "javascript_checkbutton.grid(row = 2, column = 0, sticky = W)\n",
    "\n",
    "selection = Label(textvariable = lang, padx = 15, pady = 10)\n",
    "selection.grid(row = 3, column = 0, sticky = W)\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72bc438c",
   "metadata": {},
   "source": [
    "`Radiobutton` (master, options):\n",
    "\n",
    "activebackground: фоновый цвет переключателя в нажатом состоянии\n",
    "\n",
    "activeforeground: цвет текста переключателя в нажатом состоянии\n",
    "\n",
    "bg: фоновый цвет переключателя\n",
    "\n",
    "bitmap: монохромное изображение для переключателя\n",
    "\n",
    "borderwidth: граница вокруг переключателя\n",
    "\n",
    "command: ссылка на функцию, которая вызывается при нажатии на переключатель\n",
    "\n",
    "cursor: курсор при наведении на элемент\n",
    "\n",
    "font: шрифт\n",
    "\n",
    "fg: цвет текста\n",
    "\n",
    "height: высота элемента в строках текста. По умолчанию равно 1\n",
    "\n",
    "image: графическое изображение, отображаемое на элементе\n",
    "\n",
    "justify: выравнивание текста, принимает значения CENTER, LEFT, RIGHT\n",
    "\n",
    "padx: отступы справа и слева от текста до границы переключателя\n",
    "\n",
    "pady: отступы сверху и снизу от текста до границы переключателя\n",
    "\n",
    "relief: стиль переключателя, по умолчанию имеет значение FLAT\n",
    "\n",
    "selectcolor: цвет кружка переключателя\n",
    "\n",
    "selectimage: изображение на переключателе, когда он находится в отмеченном состоянии\n",
    "\n",
    "state: состояние элемента, может принимать значения NORMAL (по умолчанию), DISABLED и ACTIVE\n",
    "\n",
    "text: текст элемента\n",
    "\n",
    "textvariable: устанавливает привязку к переменной StringVar, которая задает текст переключателя\n",
    "\n",
    "underline: индекс подчеркнутого символа в тексте элемента\n",
    "\n",
    "variable: ссылка на переменную, как правило, типа IntVar, которая хранит состояние переключателя\n",
    "\n",
    "value: значение переключателя\n",
    "\n",
    "width: ширина элемента\n",
    "\n",
    "wraplength: устанавливает перенос символов на другую строку в тексте элемента"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "157287f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "\n",
    "languages = [(\"Python\", 1), (\"C++\", 2), (\"C#\", 3), (\"Java\", 4)]\n",
    "\n",
    "def select():\n",
    "    l = language.get()\n",
    "    if l == 1:\n",
    "        sel.config(text = \"Выбран Python\")\n",
    "    elif l == 2:\n",
    "        sel.config(text = \"Выбран C++\")\n",
    "    elif l == 3:\n",
    "        sel.config(text = \"Выбран C#\")\n",
    "    elif l == 4:\n",
    "        sel.config(text = \"Выбран Java\")\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x280\")\n",
    "\n",
    "header = Label(text = \"Выберите курс\", padx = 15, pady = 10)\n",
    "header.grid(row = 0, column = 0, sticky = W)\n",
    "\n",
    "language = IntVar()\n",
    "\n",
    "row = 1\n",
    "for txt, val in languages:\n",
    "    Radiobutton(text = txt, value = val, variable = language, padx = 15, pady = 10, command = select)\\\n",
    "        .grid(row = row, sticky = W)\n",
    "    row += 1\n",
    "\n",
    "sel = Label(padx = 15, pady = 10)\n",
    "sel.grid(row = row, sticky = W)\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f01f6ab1",
   "metadata": {},
   "source": [
    "Параметры `Listbox`:\n",
    "\n",
    "bg: фоновый цвет\n",
    "\n",
    "bd: толщина границы вокруг элемента\n",
    "\n",
    "cursor: курсор при наведении на Listbox\n",
    "\n",
    "font: настройки шрифта\n",
    "\n",
    "fg: цвет текста\n",
    "\n",
    "height: высота элемента в строках. По умолчанию отображает 10 строк\n",
    "\n",
    "highlightcolor: цвет элемента, когда он получает фокус\n",
    "\n",
    "highlightthickness: толщина границы элемента, когда он находится в фокусе\n",
    "\n",
    "relief: устанавливает стиль элемента, по умолчанию имеет значение SUNKEN\n",
    "\n",
    "selectbackground: фоновый цвет для выделенного элемента\n",
    "\n",
    "selectmode: определяет, сколько элементов могут быть выделены. Может принимать следующие значения: BROWSE, SINGLE, MULTIPLE, EXTENDED. Например, если необходимо включить множественное выделение элементов, то можно использовать значения MULTIPLE или EXTENDED\n",
    "\n",
    "width: устанавливает ширину элемента в символах. По умолчанию ширина – 20 символов\n",
    "\n",
    "xscrollcommand: задает горизонтальную прокрутку\n",
    "\n",
    "yscrollcommand: устанавливает вертикальную прокрутку"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3385d4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "\n",
    "languages = [\"Python\", \"C++\", \"C#\", \"Java\"]\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x280\")\n",
    "\n",
    "languages_listbox = Listbox()\n",
    "\n",
    "for language in languages:\n",
    "    languages_listbox.insert(END, language)\n",
    "\n",
    "languages_listbox.pack()\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5030311",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "\n",
    "languages = [\"Python\", \"JavaScript\", \"C#\", \"Java\", \"C/C++\", \"Swift\", \"PHP\", \"Visual Basic.NET\", \"F#\", \n",
    "             \"Ruby\", \"Rust\", \"R\", \"Go\",\"T-SQL\", \"PL-SQL\", \"Typescript\"]\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "\n",
    "scrollbar = Scrollbar(root)\n",
    "scrollbar.pack(side = RIGHT, fill = Y)\n",
    "\n",
    "languages_listbox = Listbox(yscrollcommand = scrollbar.set, width = 40)\n",
    "\n",
    "for language in languages:\n",
    "    languages_listbox.insert(END, language)\n",
    "\n",
    "languages_listbox.pack(side = LEFT, fill = BOTH)\n",
    "scrollbar.config(command = languages_listbox.yview)\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b582ccb",
   "metadata": {},
   "source": [
    "`Listbox` имеет ряд методов для управления поведением элемента и его содержимым. Некоторые из них:\n",
    "\n",
    "curselection(): возвращает набор индексов выделенных элементов\n",
    "\n",
    "delete(first, last = None): удаляет элементы с индексами из диапазона [first, last]. Если второй параметр опущен, то удаляет только один элемент по индексу first.\n",
    "\n",
    "get(first, last = None): возвращает кортеж, который содержит текст элементов с индексами из дипазона [first, last]. Если второй параметр опущен, возвращается только текст элемента с индексом first.\n",
    "\n",
    "insert(index, element): вставляет элемент по определенному индексу\n",
    "\n",
    "size(): возвращает количество элементов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "992bab29",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "\n",
    "# Удаление выделенного элемента\n",
    "def delete():\n",
    "    selection = languages_listbox.curselection()\n",
    "    # Мы можем получить удаляемый элемент по индексу\n",
    "    # selected_language = languages_listbox.get(selection[0])\n",
    "    languages_listbox.delete(selection[0])\n",
    "\n",
    "# Добавление нового элемента\n",
    "def add():\n",
    "    new_language = language_entry.get()\n",
    "    languages_listbox.insert(0, new_language)\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "\n",
    "# Текстовое поле и кнопка для добавления в список\n",
    "language_entry = Entry(width = 40)\n",
    "language_entry.grid(column = 0, row = 0, padx = 6, pady = 6)\n",
    "add_button = Button(text = \"Добавить\", command = add).grid(column = 1, row = 0, padx = 6, pady = 6)\n",
    "\n",
    "# Создаем список\n",
    "languages_listbox = Listbox()\n",
    "languages_listbox.grid(row = 1, column = 0, columnspan = 2, sticky = W+E, padx = 5, pady = 5)\n",
    "\n",
    "# Добавляем в список начальные элементы\n",
    "languages_listbox.insert(END, \"Python\")\n",
    "languages_listbox.insert(END, \"C#\")\n",
    "\n",
    "delete_button = Button(text = \"Удалить\", command = delete).grid(row = 2, column = 1, padx = 5, pady = 5)\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60716507",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Меню\n",
    "\n",
    "from tkinter import *\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "main_menu = Menu()\n",
    "main_menu.add_cascade(label = \"File\")\n",
    "main_menu.add_cascade(label = \"Edit\")\n",
    "main_menu.add_cascade(label = \"View\")\n",
    "\n",
    "root.config(menu = main_menu)\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bfeabf19",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Подменю\n",
    "\n",
    "from tkinter import *\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "main_menu = Menu()\n",
    "\n",
    "file_menu = Menu()\n",
    "file_menu.add_command(label = \"New\")\n",
    "file_menu.add_command(label = \"Save\")\n",
    "file_menu.add_command(label = \"Open\")\n",
    "file_menu.add_separator()\n",
    "file_menu.add_command(label = \"Exit\")\n",
    "\n",
    "main_menu.add_cascade(label = \"File\", menu = file_menu)\n",
    "main_menu.add_cascade(label = \"Edit\")\n",
    "main_menu.add_cascade(label = \"View\")\n",
    "\n",
    "root.config(menu = main_menu)\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac61ce7d",
   "metadata": {},
   "source": [
    "Опции:\n",
    "\n",
    "activebackground: цвет активного пункта меню\n",
    "\n",
    "activeborderwidth: толщина границы активного пункта меню\n",
    "\n",
    "activeforeground: цвет текста активного пункта меню\n",
    "\n",
    "bg: фоновый цвет\n",
    "\n",
    "bd: толщина границы\n",
    "\n",
    "cursor: курсор указателя мыши при наведении на меню\n",
    "\n",
    "disabledforeground: цвет, когда меню находится в состоянии DISABLED\n",
    "\n",
    "font: шрифт текста\n",
    "\n",
    "fg: цвет текста\n",
    "\n",
    "tearoff: меню может быть отсоединено от графического окна. В частности, при создании подменю а скриншоте можно увидеть прерывающуюся линию в верху подменю, за которую его можно отсоединить. Однако при значении tearoff = 0 подменю не сможет быть отсоединено"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "374d7151",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "main_menu = Menu()\n",
    "\n",
    "file_menu = Menu(font = (\"Verdana\", 13, \"bold\"), tearoff = 0)\n",
    "file_menu.add_command(label = \"New\")\n",
    "file_menu.add_command(label = \"Save\")\n",
    "file_menu.add_command(label = \"Open\")\n",
    "file_menu.add_separator()\n",
    "file_menu.add_command(label = \"Exit\")\n",
    "\n",
    "main_menu.add_cascade(label = \"File\", menu = file_menu)\n",
    "main_menu.add_cascade(label = \"Edit\")\n",
    "main_menu.add_cascade(label = \"View\")\n",
    "\n",
    "root.config(menu = main_menu)\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0155796",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Взаимодействие с меню\n",
    "\n",
    "from tkinter import *\n",
    "from tkinter import messagebox\n",
    "\n",
    "def edit_click():\n",
    "    messagebox.showinfo(\"GUI Python\", \"Нажата опция Edit\")\n",
    "\n",
    "root = Tk()\n",
    "root.title(\"GUI на Python\")\n",
    "root.geometry(\"300x250\")\n",
    "\n",
    "main_menu = Menu()\n",
    "\n",
    "main_menu.add_cascade(label = \"File\")\n",
    "main_menu.add_cascade(label = \"Edit\", command = edit_click)\n",
    "main_menu.add_cascade(label = \"View\")\n",
    "\n",
    "root.config(menu = main_menu)\n",
    "\n",
    "root.mainloop()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}