Библиотека Tkinter установлена в Python в качестве стандартного модуля, поэтому нам не нужно устанавливать что-либо для его использования. Tkinter — очень мощная библиотека. Если вы уже установили Python, можете использовать IDLE, который является интегрированной IDE, поставляемой в Python, эта IDE написана с использованием Tkinter. Звучит круто!
Мы будем использовать Python 3.7 поэтому, если вы все еще используете Python 2.x, настоятельно рекомендуем перейти на Python 3.x, если вы не в курсе нюансов изменения языка, с целью, чтобы вы могли настроить код для запуска без ошибок.
Давайте предположим, что у вас уже есть базовые знания по Python, которые помогут понять, что мы будем делать.
Мы начнем с создания окна, в котором мы узнаем, как добавлять виджеты, такие, как кнопки, комбинированные поля и т. д. После этого поэкспериментируем со своими свойствами, поэтому предлагаю начать.
Создание своего первого графического интерфейса
Первый тест программы
import tkinter
tkinter._test()
Более подробно, для начала, следует импортировать Tkinter и создать окно, в котором мы зададим его название:
from tkinter import *
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
window.mainloop()
Результат будет выглядеть следующим образом:
Прекрасно! Наше приложение работает.
Последняя строка вызывает функцию mainloop.
Эта функция вызывает бесконечный цикл окна, поэтому окно будет ждать любого взаимодействия с пользователем, пока не будет закрыто.
В случае, если вы забудете вызвать функцию mainloop, для пользователя ничего не отобразится.
Создание виджета Label
Чтобы добавить текст в наш предыдущий пример, мы создадим lbl, с помощью класса Label, например:
lbl = Label(window, text=”Привет”)
Затем мы установим позицию в окне с помощью функции grid и укажем ее следующим образом:
lbl.grid(column=0, row=0)
Полный код, будет выглядеть следующим образом:
from tkinter import *
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
lbl = Label(window, text=”Привет”)
lbl.grid(column=0, row=0)
window.mainloop()
И вот как будет выглядеть результат:
Если функция grid не будет вызвана, текст не будет отображаться.
Настройка размера и шрифта текста
Вы можете задать шрифт текста и размер. Также можно изменить стиль шрифта. Для этого передайте параметр font таким образом:
lbl = Label(window, text=”Привет”, font=(“Arial Bold”, 50))
Обратите внимание, что параметр font может быть передан любому виджету для того, чтобы поменять его шрифт, он применяется не только к Label.
Отлично, но стандартное окно слишком мало. Как насчет настройки размера окна?
Настройка размеров окна приложения
Мы можем установить размер окна по умолчанию, используя функцию geometry следующим образом:
window.geometry(‘400×250’)
В приведенной выше строке устанавливается окно шириной до 400 пикселей и высотой до 250 пикселей.
Попробуем добавить больше виджетов GUI, например, кнопки и посмотреть, как обрабатывается нажатие кнопок.
Добавление виджета Button
Начнем с добавления кнопки в окно. Кнопка создается и добавляется в окно так же, как и метка:
btn = Button(window, text=”Не нажимать!”)
btn.grid(column=1, row=0)
Наш код будет выглядеть вот так:
from tkinter import *
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
window.geometry(‘400×250’)
lbl = Label(window, text=”Привет”, font=(“Arial Bold”, 50))
lbl.grid(column=0, row=0)
btn = Button(window, text=”Не нажимать!”)
btn.grid(column=1, row=0)
window.mainloop()
Результат будет следующим:
Обратите внимание, что мы помещаем кнопку во второй столбец окна, что равно 1. Если вы забудете и поместите кнопку в том же столбце, который равен 0, он покажет только кнопку.
Изменение цвета текста и фона у Button
Вы можете поменять цвет текста кнопки или любого другого виджета, используя свойство fg.
Кроме того, вы можете поменять цвет фона любого виджета, используя свойство bg.
btn = Button(window, text=”Не нажимать!”, bg=”black”, fg=”red”)
Теперь, если вы попытаетесь щелкнуть по кнопке, ничего не произойдет, потому что событие нажатия кнопки еще не написано.
Кнопка Click (функция нажатия)
Для начала, мы запишем функцию, которую нужно выполнить при нажатии кнопки:
def clicked():
lbl.configure(text=”Я же просил…”)
Затем мы подключим ее с помощью кнопки, указав следующую функцию:
btn = Button(window, text=”Не нажимать!”, command=clicked)
Обратите внимание: мы пишем clicked, а не clicked() с круглыми скобками.
Теперь полный код будет выглядеть так:
from tkinter import *
def clicked():
lbl.configure(text=”Я же просил…”)
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
window.geometry(‘400×250’)
lbl = Label(window, text=”Привет”, font=(“Arial Bold”, 50))
lbl.grid(column=0, row=0)
btn = Button(window, text=”Не нажимать!”, command=clicked)
btn.grid(column=1, row=0)
window.mainloop()
При нажатии на кнопку, результат, как и ожидалось, будет выглядеть следующим образом:
Круто!
Получение ввода с использованием класса Entry (текстовое поле Tkinter)
В предыдущих примерах GUI Python мы ознакомились со способами добавления простых виджетов, а теперь попробуем получить пользовательский ввод, используя класс Tkinter Entry (текстовое поле Tkinter).
Вы можете создать текстовое поле с помощью класса Tkinter Entry следующим образом:
txt = Entry(window, width=10)
Затем вы можете добавить его в окно, используя функцию grid.
Наш код будет выглядеть так:
from tkinter import *
def clicked():
lbl.configure(text=”Я же просил…”)
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
window.geometry(‘400×250’)
lbl = Label(window, text=”Привет”)
lbl.grid(column=0, row=0)
txt = Entry(window,width=10)
txt.grid(column=1, row=0)
btn = Button(window, text=”Не нажимать!”, command=clicked)
btn.grid(column=2, row=0)
window.mainloop()
Полученный результат будет выглядеть так:
Теперь, если вы нажмете кнопку, она покажет то же самое старое сообщение, но что же будет с отображением введенного текста в виджет Entry?
Во-первых, вы можете получить текст ввода, используя функцию get. Мы можем записать код для выбранной функции таким образом:
def clicked():
res = “Привет {}”.format(txt.get())
lbl.configure(text=res)
Если вы нажмете на кнопку — появится текст «Привет » вместе с введенным текстом в виджете записи.
Вот полный код:
from tkinter import *
def clicked():
res = “Привет {}”.format(txt.get())
lbl.configure(text=res)
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
window.geometry(‘400×250’)
lbl = Label(window, text=”Привет”)
lbl.grid(column=0, row=0)
txt = Entry(window,width=10)
txt.grid(column=1, row=0)
btn = Button(window, text=”Клик!”, command=clicked)
btn.grid(column=2, row=0)
window.mainloop()
Запустите вышеуказанный код и проверьте результат:
Прекрасно!
Каждый раз, когда мы запускаем код, нам нужно нажать на виджет ввода, чтобы настроить фокус на ввод текста, но как насчет автоматической настройки фокуса?
Установка фокуса виджета ввода
Здесь все очень просто, ведь все, что нам нужно сделать, — это вызвать функцию focus:
txt.focus()
Когда вы запустите свой код, вы заметите, что виджет ввода в фокусе, который дает возможность сразу написать текст.
Отключить виджет ввода
Чтобы отключить виджет ввода, отключите свойство состояния:
txt = Entry(window,width=10, state=’disabled’)
Теперь вы не сможете ввести какой-либо текст.
Добавление виджета Combobox
Чтобы добавить виджет поля с выпадающем списком, используйте класс Combobox из ttk следующим образом:
from tkinter.ttk import Combobox
combo = Combobox(window)
Затем добавьте свои значения в поле со списком.
from tkinter import *
from tkinter.ttk import Combobox
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
window.geometry(‘400×250’)
combo = Combobox(window)
combo[‘values’] = (1, 2, 3, 4, 5, “Текст”)
combo.current(1) # установите вариант по умолчанию
combo.grid(column=0, row=0)
window.mainloop()
Как видите с примера, мы добавляем элементы combobox, используя значения tuple.
Чтобы установить выбранный элемент, вы можете передать индекс нужного элемента текущей функции.
Чтобы получить элемент select, вы можете использовать функцию get вот таким образом:
combo.get()
Добавление виджета Checkbutton (чекбокса)
С целью создания виджета checkbutton, используйте класс Checkbutton:
from tkinter.ttk import Checkbutton
chk = Checkbutton(window, text=’Выбрать’)
Кроме того, вы можете задать значение по умолчанию, передав его в параметр var в Checkbutton:
from tkinter import *
from tkinter.ttk import Checkbutton
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
window.geometry(‘400×250’)
chk_state = BooleanVar()
chk_state.set(True) # задайте проверку состояния чекбокса
chk = Checkbutton(window, text=’Выбрать’, var=chk_state)
chk.grid(column=0, row=0)
window.mainloop()
Посмотрите на результат:
Установка состояния Checkbutton
Здесь мы создаем переменную типа BooleanVar, которая не является стандартной переменной Python, это переменная Tkinter, затем передаем ее классу Checkbutton, чтобы установить состояние чекбокса как True в приведенном выше примере.
Вы можете установить для BooleanVar значение false, что бы чекбокс не был отмечен.
Так же, используйте IntVar вместо BooleanVar и установите значения 0 и 1.
chk_state = IntVar()
chk_state.set(0) # False
chk_state.set(1) # True
Эти примеры дают тот же результат, что и BooleanVar.
Добавление виджетов Radio Button
Чтобы добавить radio кнопки, используйте класс RadioButton:
rad1 = Radiobutton(window,text=’Первый’, value=1)
Обратите внимание, что вы должны установить value для каждой radio кнопки с уникальным значением, иначе они не будут работать.
from tkinter import *
from tkinter.ttk import Radiobutton
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
window.geometry(‘400×250’)
rad1 = Radiobutton(window, text=’Первый’, value=1)
rad2 = Radiobutton(window, text=’Второй’, value=2)
rad3 = Radiobutton(window, text=’Третий’, value=3)
rad1.grid(column=0, row=0)
rad2.grid(column=1, row=0)
rad3.grid(column=2, row=0)
window.mainloop()
Результатом вышеприведенного кода будет следующий:
Кроме того, вы можете задать command любой из этих кнопок для определенной функции. Если пользователь нажимает на такую кнопку, она запустит код функции.
Вот пример:
rad1 = Radiobutton(window,text=’Первая’, value=1, command=clicked)
def clicked():
# Делайте, что нужно
Достаточно легко!
Получение значения Radio Button (Избранная Radio Button)
Чтобы получить текущую выбранную radio кнопку или ее значение, вы можете передать параметр переменной и получить его значение.
from tkinter import *
from tkinter.ttk import Radiobutton
def clicked():
lbl.configure(text=selected.get())
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
window.geometry(‘400×250’)
selected = IntVar()
rad1 = Radiobutton(window,text=’Первый’, value=1, variable=selected)
rad2 = Radiobutton(window,text=’Второй’, value=2, variable=selected)
rad3 = Radiobutton(window,text=’Третий’, value=3, variable=selected)
btn = Button(window, text=”Клик”, command=clicked)
lbl = Label(window)
rad1.grid(column=0, row=0)
rad2.grid(column=1, row=0)
rad3.grid(column=2, row=0)
btn.grid(column=3, row=0)
lbl.grid(column=0, row=1)
window.mainloop()
Каждый раз, когда вы выбираете radio button, значение переменной будет изменено на значение кнопки.
Добавление виджета ScrolledText (текстовая область Tkinter)
Чтобы добавить виджет ScrolledText, используйте класс ScrolledText:
from tkinter import scrolledtext
txt = scrolledtext.ScrolledText(window,width=40,height=10)
Здесь нужно указать ширину и высоту ScrolledText, иначе он заполнит все окно.
from tkinter import *
from tkinter import scrolledtext
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
window.geometry(‘400×250’)
txt = scrolledtext.ScrolledText(window, width=40, height=10)
txt.grid(column=0, row=0)
window.mainloop()
Результат:
Настройка содержимого Scrolledtext
Используйте метод insert, чтобы настроить содержимое Scrolledtext:
txt.insert(INSERT, ‘Текстовое поле’)
Удаление/Очистка содержимого Scrolledtext
Чтобы очистить содержимое данного виджета, используйте метод delete:
txt.delete(1.0, END) # мы передали координаты очистки
Отлично!
Создание всплывающего окна с сообщением
Чтобы показать всплывающее окно с помощью Tkinter, используйте messagebox следующим образом:
from tkinter import messagebox
messagebox.showinfo(‘Заголовок’, ‘Текст’)
Довольно легко! Давайте покажем окно сообщений при нажатии на кнопку пользователем.
from tkinter import *
from tkinter import messagebox
def clicked():
messagebox.showinfo(‘Заголовок’, ‘Текст’)
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
window.geometry(‘400×250’)
btn = Button(window, text=’Клик’, command=clicked)
btn.grid(column=0, row=0)
window.mainloop()
Когда вы нажмете на кнопку, появится информационное окно.
Показ сообщений о предупреждениях и ошибках
Вы можете показать предупреждающее сообщение или сообщение об ошибке таким же образом. Единственное, что нужно изменить—это функция сообщения.
messagebox.showwarning(‘Заголовок’, ‘Текст’) # показывает предупреждающее сообщение
messagebox.showerror(‘Заголовок’, ‘Текст’) # показывает сообщение об ошибке
Показ диалоговых окон с выбором варианта
Чтобы показать пользователю сообщение “да/нет”, вы можете использовать одну из следующих функций messagebox:
from tkinter import messagebox
res = messagebox.askquestion(‘Заголовок’, ‘Текст’)
res = messagebox.askyesno(‘Заголовок’, ‘Текст’)
res = messagebox.askyesnocancel(‘Заголовок’, ‘Текст’)
res = messagebox.askokcancel(‘Заголовок’, ‘Текст’)
res = messagebox.askretrycancel(‘Заголовок’, ‘Текст’)
Вы можете выбрать соответствующий стиль сообщения согласно вашим потребностям. Просто замените строку функции showinfo на одну из предыдущих и запустите скрипт. Кроме того, можно проверить, какая кнопка нажата, используя переменную результата.
Если вы кликнете OK, yes или retry, значение станет True, а если выберете no или cancel, значение будет False.
Единственной функцией, которая возвращает одно из трех значений, является функция askyesnocancel; она возвращает True/False/None.
Добавление SpinBox (Виджет спинбокс)
Для создания виджета спинбокса, используйте класс Spinbox:
spin = Spinbox(window, from_=0, to=100)
Таким образом, мы создаем виджет Spinbox, и передаем параметры from и to, чтобы указать диапазон номеров.
Кроме того, вы можете указать ширину виджета с помощью параметра width:
spin = Spinbox(window, from_=0, to=100, width=5)
Проверим пример полностью:
from tkinter import *
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
window.geometry(‘400×250’)
spin = Spinbox(window, from_=0, to=100, width=5)
spin.grid(column=0, row=0)
window.mainloop()
Вы можете указать числа для Spinbox, вместо использования всего диапазона следующим образом:
spin = Spinbox(window, values=(3, 8, 11), width=5)
Виджет покажет только эти 3 числа: 3, 8 и 11.
Задать значение по умолчанию для Spinbox
В случае, если вам нужно задать значение по умолчанию для Spinbox, вы можете передать значение параметру textvariable следующим образом:
var = IntVar()
var.set(36)
spin = Spinbox(window, from_=0, to=100, width=5, textvariable=var)
Теперь, если вы запустите программу, она покажет 36 как значение по умолчанию для Spinbox.
Добавление виджета Progressbar
Чтобы создать данный виджет, используйте класс progressbar :
from tkinter.ttk import Progressbar
bar = Progressbar(window, length=200)
Установите значение progressbar таким образом:
bar[‘value’] = 70
Вы можете установить это значение на основе любого процесса или при выполнении задачи.
Изменение цвета Progressbar
Изменение цвета Progressbar немного сложно. Сначала нужно создать стиль и задать цвет фона, а затем настроить созданный стиль на Progressbar.
Посмотрите следующий пример:
from tkinter import *
from tkinter.ttk import Progressbar
from tkinter import ttk
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
window.geometry(‘400×250’)
style = ttk.Style()
style.theme_use(‘default’)
style.configure(“black.Horizontal.TProgressbar”, background=’black’)
bar = Progressbar(window, length=200, style=’black.Horizontal.TProgressbar’)
bar[‘value’] = 70
bar.grid(column=0, row=0)
window.mainloop()
И в результате вы получите следующее:
Добавление поля загрузки файла
Для добавления поля с файлом, используйте класс filedialog:
from tkinter import filedialog
file = filedialog.askopenfilename()
После того, как вы выберете файл, нажмите “Открыть”; переменная файла будет содержать этот путь к файлу. Кроме того, вы можете запросить несколько файлов:
files = filedialog.askopenfilenames()
Указание типа файлов (расширение фильтра файлов)
Возможность указания типа файлов доступна при использовании параметра filetypes, однако при этом важно указать расширение в tuples.
file = filedialog.askopenfilename(filetypes = ((“Text files”,”*.txt”),(“all files”,”*.*”)))
Вы можете запросить каталог, используя метод askdirectory :
dir = filedialog.askdirectory()
Вы можете указать начальную директорию для диалогового окна файла, указав initialdir следующим образом:
from os import path
file = filedialog.askopenfilename(initialdir= path.dirname(__file__))
Легко!
Добавление панели меню
Для добавления панели меню, используйте класс menu:
from tkinter import Menu
menu = Menu(window)
menu.add_command(label=’Файл’)
window.config(menu=menu)
Сначала мы создаем меню, затем добавляем наш первый пункт подменю. Вы можете добавлять пункты меню в любое меню с помощью функции add_cascade() таким образом:
menu.add_cascade(label=’Автор’, menu=new_item)
Наш код будет выглядеть так:
from tkinter import *
from tkinter import Menu
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
window.geometry(‘400×250’)
menu = Menu(window)
new_item = Menu(menu)
new_item.add_command(label=’Новый’)
menu.add_cascade(label=’Файл’, menu=new_item)
window.config(menu=menu)
window.mainloop()
Таким образом, вы можете добавить столько пунктов меню, сколько захотите.
from tkinter import *
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
window.geometry(‘400×250’)
menu = Menu(window)
new_item = Menu(menu)
new_item.add_command(label=’Новый’)
new_item.add_separator()
new_item.add_command(label=’Изменить’)
menu.add_cascade(label=’Файл’, menu=new_item)
window.config(menu=menu)
window.mainloop()
Теперь мы добавляем еще один пункт меню “Изменить” с разделителем меню. Вы можете заметить пунктирную линию в начале, если вы нажмете на эту строку, она отобразит пункты меню в небольшом отдельном окне.
Можно отключить эту функцию, с помощью tearoff подобным образом:
new_item = Menu(menu, tearoff=0)
Просто отредактируйте new_item, как в приведенном выше примере и он больше не будет отображать пунктирную линию.
Вы так же можете ввести любой код, который работает, при нажатии пользователем на любой элемент меню, задавая свойство команды.
new_item.add_command(label=’Новый’, command=clicked)
Добавление виджета Notebook (Управление вкладкой)
Для удобного управления вкладками реализуйте следующее:
Для начала, создается элемент управления вкладкой, с помощью класса Notebook .
Создайте вкладку, используя класс Frame.
Добавьте эту вкладку в элемент управления вкладками.
Запакуйте элемент управления вкладкой, чтобы он стал видимым в окне.
from tkinter import *
from tkinter import ttk
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
window.geometry(‘400×250’)
tab_control = ttk.Notebook(window)
tab1 = ttk.Frame(tab_control)
tab_control.add(tab1, text=’Первая’)
tab_control.pack(expand=1, fill=’both’)
window.mainloop()
Таким образом, вы можете добавлять столько вкладок, сколько нужно.
Добавление виджетов на вкладку
После создания вкладок вы можете поместить виджеты внутри этих вкладок, назначив родительское свойство нужной вкладке.
from tkinter import *
from tkinter import ttk
window = Tk()
window.title(“Добро пожаловать в приложение PythonRu”)
window.geometry(‘400×250’)
tab_control = ttk.Notebook(window)
tab1 = ttk.Frame(tab_control)
tab2 = ttk.Frame(tab_control)
tab_control.add(tab1, text=’Первая’)
tab_control.add(tab2, text=’Вторая’)
lbl1 = Label(tab1, text=’Вкладка 1′)
lbl1.grid(column=0, row=0)
lbl2 = Label(tab2, text=’Вкладка 2′)
lbl2.grid(column=0, row=0)
tab_control.pack(expand=1, fill=’both’)
window.mainloop()
Добавление интервала для виджетов (Заполнение)
Вы можете добавить отступы для элементов управления, чтобы они выглядели хорошо организованными с использованием свойств padx иpady.
Передайте padx и pady любому виджету и задайте значение.
lbl1 = Label(tab1, text= ‘label1’, padx=5, pady=5)
Это очень просто!
Модуль tkinter.ttk
В состав пакета tkinter входит модуль ttk, содержащий классы более стилизованных и современных виджет. По умолчанию их внешний вид зависит от операционной системы.
В коде ниже для сравнения в окне размещено несколько пар аналогичных виджетов из модулей tkinter и tkinter.ttk.
import tkinter as tk
import tkinter.ttk as ttk
root = tk.Tk()
tk.Button(text=”Hello”).pack()
ttk.Button(text=”Hello”).pack()
tk.Checkbutton(text=”Hello”).pack()
ttk.Checkbutton(text=”Hello”).pack()
tk.Radiobutton(text=”Hello”).pack()
ttk.Radiobutton(text=”Hello”).pack()
root.mainloop()
В операционной системе Ubuntu они будут выглядеть так:
Поскольку имена классов аналогичных виджетов совпадают, мы импортируем модули так, чтобы их пространства имен не перекрывались. При этом конструкторы классов вызываются через имена (в данном случае псевдонимы) модулей.
Если же нам не нужны виджеты модуля tkinter, подобные которым есть в tkinter.ttk, удобнее импортировать всё пространство имен как одного, так и второго модуля.
from tkinter import *
from tkinter.ttk import *
root = Tk()
b = Button(text=”Hello”)
b.pack()
t = Text(width=10, height=5)
t.pack()
print(root.__class__)
print(b.__class__)
print(t.__class__)
root.mainloop()
В данном случае пространство имен tkinter.ttk, который импортируется вторым, перекрывает часть имен tkinter. Поэтому выражение Button(text=”Hello”) вызывает конструктор класса Button, находящийся в модуле tkinter.ttk. В то же время в этом модуле нет классов Tk и Text. Следовательно, экземпляры этих классов создаются от базовых классов tkinter. В консоль будет выведено:
<class ‘tkinter.Tk’>
<class ‘tkinter.ttk.Button’>
<class ‘tkinter.Text’>
Как уже должно быть понятно, наборы виджетов обоих модулей не полностью перекрываются.
Есть общие (такие как Label, Button, Entry), есть характерные только для tkinter (например, Listbox и Canvas) и только для ttk (например, Combobox, Notebook).
Сложность заключается в том, что в ttk свойства виджетов программируются не совсем так как в tkinter. Если в приложении сочетаются элементы сразу обоих модулей, код программы становится менее ясным.
Для виджетов из tkinter.ttk многие свойства задаются с помощью экземпляра, созданного от класса ttk.Style. Основная идея ttk – отделить оформление виджета от описания его поведения.
Импортируем модули, не перекрывая пространства их имен, и сравним установку свойств для двух кнопок.
from tkinter import *
from tkinter import ttk
root = Tk()
b_tk = Button(text=”Hello Tk”)
b_ttk = ttk.Button(text=”Hello Ttk”)
b_tk.config(background=”#b00″,
foreground=”#fff”)
style = ttk.Style()
style.configure(“TButton”,
background=”#0b0″,
foreground=”#fff”)
b_tk.pack(padx=10, pady=10)
b_ttk.pack(padx=10, pady=10)
root.mainloop()
Мы задаем свойства для экземпляра Button из модуля tkinter с помощью метода кнопки config. Однако то же самое могли бы сделать, передав значения в конструктор:
b_tk = Button(text=”Hello Tk”,
background=”#b00″,
foreground=”#fff”)
Настроить так кнопку из модуля ttk нельзя. Вместо этого мы должны создать экземпляр от класса Style и уже через него изменять свойства по умолчанию.
В коде выше используется метод configure. Здесь первым аргументом в него передается имя стиля (TButton), связанного с классом объектов, для которых производится настройка. В данном случае это кнопки. Для уточнения имени стиля можно воспользоваться методом winfo_class:
…
print(ttk.Label().winfo_class())
print(ttk.Button().winfo_class())
…
Вывод:
TLabel
TButton
Что делать, если в программе нужны, например, кнопки разного стиля? Можно создать свой стиль, унаследовав его от исходного, и изменять лишь отдельные свойства.
from tkinter import *
from tkinter.ttk import *
root = Tk()
style = Style()
style.configure(“G.TButton”, foreground=”green”)
Button(text=”First”, style=”G.TButton”).pack()
Button(text=”Second”).pack()
root.mainloop()
В примере выше созданный стиль называется “G”. После точки указывается его родитель (в данном случае это стиль TButton. При создании первой кнопки через опцию style указываем применяемый стиль.
По-умолчанию для второй кнопки используется стиль TButton. Мы его не меняли, хотя могли бы изменить.
На самом деле острой или частой необходимости изменять внешний вид виджетов нет. Наоборот, в приложениях приветствуется стандартный и единообразный внешний вид и поведение. Это дает пользователю интуитивно понятный интерфейс.
Кроме того, в ttk есть разные темы. Можно менять не отдельные виджеты, а целиком тему оформления приложения. С помощью методов theme_names и theme_use можно выяснить список тем (который зависит от вашей ОС) и текущую тему:
from tkinter.ttk import *
style = Style()
print(style.theme_names())
print(style.theme_use())
Вывод:
(‘clam’, ‘alt’, ‘default’, ‘classic’)
Default
Если в метод theme_use передать название темы, она будет применена. В программе ниже при нажатии клавиши Enter изменяется тема приложения:
from tkinter import *
from tkinter.ttk import *
root = Tk()
style = Style()
e = Entry(justify=’center’)
e.pack()
Button(text=”Hello”).pack()
Label(text=”Hello”).pack()
themes = style.theme_names()
i = 0
def theme_next(event):
global i
style.theme_use(themes[i])
e.delete(0, END)
e.insert(0, themes[i])
if i < len(themes)-1:
i += 1
else:
i = 0
root.bind(‘<Return>’, theme_next)
root.mainloop()
Описание свойств виджетов в ttk не всегда совпадает с тем, как это делается в базовом tkinter. Выше в примере с красной и зеленой кнопками с помощью опций foreground и background мы устанавливаем цвета текста и фона кнопки, когда она не находится под курсором мыши, то есть когда она не активна.
Чтобы переопределить цвета по умолчанию при наводе курсора, для кнопок tkinter мы должны использовать опции activeforeground и activebackground. Однако эти свойства не работают для виджетов из ttk:
…
b_tk.config(background=”red”,
foreground=”white”,
activebackground=”orange”,
activeforeground=”white”)
style = ttk.Style()
style.configure(“TButton”,
background=”green”,
foreground=”white”,
activebackground=”lightgreen”,
activeforeground=”black”)
…
Код выше выполнится без ошибок. Однако фон зеленой кнопки при нажатии на нее останется светло-серым, он не станет светло-зеленым.
В данном случае вместо метода configure следует использовать метод map объектов типа Style:
from tkinter import *
from tkinter.ttk import *
root = Tk()
Button(text=”Hello World”).pack(
padx=40, pady=40,
ipadx=20, ipady=20
)
st = Style()
st.map(‘TButton’,
foreground=[(‘!active’, ‘purple’),
(‘pressed’, ‘orange’),
(‘active’, ‘red’)],
background=[
(‘pressed’, ‘brown’),
(‘active’, ‘white’)]
)
root.mainloop()
Виджеты Ttk
TTK поставляется с 18 виджетов, двенадцать из которых уже существовали в Tkinter:
Button,
Checkbutton,
Entry,
Frame,
Label,
LabelFrame,
Menubutton,
PanedWindow,
Radiobutton,
Scale,
Scrollbar,
и Spinbox.
Остальные шесть являются новыми:
Combobox,
Notebook,
Progressbar,
Separator,
Sizegrip и Treeview.
И все они являются подклассами Widget.
Использование виджетов Ttk придает приложению улучшенный внешний вид. Как обсуждалось выше, существуют различия в том, как кодируется стиль.
Код ТК:
l1 = tkinter.Label(text=”Test”, fg=”black”, bg=”white”)
l2 = tkinter.Label(text=”Test”, fg=”black”, bg=”white”)
Код ТТК:
style = ttk.Style()
style.configure(“BW.TLabel”, foreground=”black”, background=”white”)
l1 = ttk.Label(text=”Test”, style=”BW.TLabel”)
l2 = ttk.Label(text=”Test”, style=”BW.TLabel”)
С точки зрения программиста главное отличие новых виджетов от старых заключается в том, что у виджетов ttk отсутствуют опции для конфигурирования его внешнего вида.
Сравните, например, количество STANDARD OPTIONS для старого и нового виджета button.
Конфигурация внешнего вида виджетов ttk осуществляется через темы и стили.
В остальном использование виджетов ttk аналогично соответствующим виджетам tk.
ttk имеет четыре встроенных темы:
default, classic, alt, clam.
Кроме того, дополнительно под Windows есть темы winnative, xpnative и vista,
а под Mac OS X – aqua.
Style
Style это класс для работы со стилями и темами. Именно этот класс надо использовать для конфигурирования внешнего вида виджетов.
Основные аргументы
Основные функции
configure – конфигурирование внешнего вида виджетов;
map – конфигурирование внешнего вида виджетов в зависимости от их состояний;
lookup – возвращает соответствующую опцию конфигурирования;
layout – изменяет layout (схему) виджета.
Виджеты ttk состоят из отдельных элементов, опций конфигурирования и других вложенных layouts;
Label
Label в Windows 7
Основная статья: Label.
Виджет Label в модуле Tkinter Ttk.
Label – это виджет, предназначенный для отображения какой-либо надписи без возможности редактирования пользователем.
Основные аргументы
master – родительский виджет;
text – отображаемый текст;
font – шрифт и размер текста. Вводится в формате “font size”;
height/width – высота и ширина в символах;
Основные функции
pack()/grid()/place() – упаковщики;
Button
Button в Windows 7
Основная статья: Button.
Виджет Button в модуле Tkinter.
Виджет Button – самая обыкновенная кнопка, которая используется в тысячах программ.
Основные аргументы
master – родительский виджет;
text – отображаемый текст;
font – шрифт и размер текста. Вводится в формате “font size”;
command – функция, вызываемая при нажатии. Вводится без скобок;
height/width – высота и ширина в символах;
Основные функции
pack()/grid()/place() – упаковщики;
Frame
Основная статья: Frame.
Виджет Frame в модуле Tkinter.
Виджет Frame (рамка) предназначен для организации виджетов внутри окна.
Основные аргументы
master – родительский виджет;
Основные функции
pack()/grid()/place() – упаковщики;
Checkbutton
Checkbutton в Windows 7
Основная статья: Checkbutton.
Виджет Checkbutton в модуле Tkinter.
Checkbutton – это виджет, который позволяет отметить „галочкой“ определенный пункт в окне. При использовании нескольких пунктов нужно каждому присвоить свою переменную.
Основные аргументы
master – родительский виджет;
text – отображаемый текст;
variable – переменная, отвечающая за состояние;
onvalue/offvalue – значение задаваемое переменной в включеном/выключеном состоянии;
font – шрифт и размер текста. Вводится в формате “font size”;
Основные функции
pack()/grid()/place() – упаковщики;
Radiobutton
Radiobutton в Windows 7
Основная статья: Radiobutton.
Виджет Radiobutton в модуле Tkinter.
Виджет Radiobutton выполняет функцию, схожую с функцией виджета Checkbutton.
Разница в том, что в виджете Radiobutton пользователь может выбрать лишь один из пунктов.
Основные аргументы
master – родительский виджет;
text – отображаемый текст;
variable – переменная, отвечающая за состояние;
value – значение задаваемое переменной в выбраном состоянии;
font – шрифт и размер текста. Вводится в формате “font size”;
Основные функции
pack()/grid()/place() – упаковщики;
Entry
Entry в Windows 7
Основная статья: Entry.
Виджет Entry в модуле Tkinter.
Entry – это виджет, позволяющий пользователю ввести одну строку текста.
Основные аргументы
master – родительский виджет;
font – шрифт и размер текста. Вводится в формате “font size”;
width – ширина в символах;
Основные функции
pack()/grid()/place() – упаковщики;
get() – возвращает введенный текст;
Scale
Scale в Windows 7
Основная статья: Scale.
Виджет Scale в модуле Tkinter.
Виджет LabeledScale в модуле Tkinter Ttk.
Scale (шкала) – это виджет, позволяющий выбрать какое-либо значение из заданного диапазона.
Основные аргументы
master – родительский виджет;
orient – ориентация шкалы. Принимает значения HORIZONTAL (“horizontal”) и VERTICAL (“vertical”);
font – шрифт и размер текста. Вводится в формате “font size”;
length – длина в пикселях;
from_ – с какого значения начинается шкала;
to – каким значением заканчивается шкала;
tickinterval – интервал, через который отображаются метки шкалы;
resolution – шаг передвижения (минимальная длина, на которую можно передвинуть рычажок);
Основные функции
pack()/grid()/place() – упаковщики;
get() – возвращает выбранное значение;
Scrollbar
Scrollbar в Windows 7
Основная статья: Scrollbar.
Виджет Scrollbar в модуле Tkinter.
Этот виджет даёт возможность пользователю “прокрутить” другой виджет (например текстовое поле) и часто бывает полезен.
Основные аргументы
master – родительский виджет;
orient – ориентация шкалы. Принимает значения HORIZONTAL (“horizontal”) и VERTICAL (“vertical”);
Основные функции
pack()/grid()/place() – упаковщики;
Menubutton в Windows 7
Основная статья: Menubutton.
Виджет Menubutton в модуле Tkinter.
Menubutton – Виджет является комбинацией Button и в Menu виджета.
При щелчке по Menubutton значку отображается меню с вариантами выбора.
Основные аргументы
master – родительский виджет;
text – отображаемый текст;
variable – переменная, отвечающая за состояние;
onvalue/offvalue – значение задаваемое переменной в включеном/выключеном состоянии;
font – шрифт и размер текста. Вводится в формате “font size”;
activebackground – Цвет фона при наведении указателя мыши на кнопку меню.
Activeforeground – Цвет переднего плана, когда указатель мыши находится над кнопкой меню.
Anchor – Этот параметр определяет положение текста, если в виджете больше места, чем требуется для текста. По умолчанию якорь = ЦЕНТР, который центрирует текст.
Bg – Нормальный цвет фона, отображаемый за меткой и индикатором
Bitmap – Чтобы отобразить растровое изображение на кнопке меню, установите для этого параметра имя растрового изображения
Bd – Размер рамки вокруг индикатора. По умолчанию 2 пикселя.
Cursor – Курсор, который появляется при наведении указателя мыши на эту кнопку меню.
Direction – Установите направление = RIGHT (влево) для отображения меню слева от кнопки; используйте direction = RIGHT, чтобы отобразить меню справа от кнопки; или используйте direction = ‘above’, чтобы разместить меню над кнопкой.
Disabledforeground – Цвет переднего плана, отображаемый на этой кнопке меню, когда она отключена.
Fg – Цвет переднего плана, когда указатель мыши не находится над кнопкой меню.
Height – Высота кнопки меню в строках текста (не в пикселях!). По умолчанию размер кнопки меню соответствует ее содержимому.
Highlightcolor – Цвет, отображаемый в выделении фокуса, когда виджет находится в фокусе.
Image – Чтобы отобразить изображение на этой кнопке меню.
Justify – Этот параметр определяет, где находится текст, когда текст не заполняет кнопку меню: используйте justify = LEFT, чтобы выровнять текст по левому краю (это значение по умолчанию); используйте justify = CENTER, чтобы центрировать его, или justify = RIGHT, чтобы выровнять по правому краю.
Menu – Чтобы связать кнопку меню с набором вариантов, установите этот параметр для объекта Menu, содержащего эти варианты. Этот объект меню должен быть создан путем передачи связанной кнопки меню в конструктор в качестве его первого аргумента.
Padx – Сколько места оставить слева и справа от текста кнопки меню. По умолчанию 1.
Pady – Сколько места оставить над и под текстом кнопки меню. По умолчанию 1.
Relief – Выбирает эффекты затенения трехмерных границ. По умолчанию is RAISED (поднято).
State – Обычно кнопки меню реагируют на мышь. Установите состояние DISABLED (отключено) чтобы выделить кнопку меню серым цветом и сделать ее неактивной.
Text – Чтобы отображать текст на кнопке меню, установите для этого параметра строку, содержащую желаемый текст. Новые строки (“\ n”) внутри строки вызовут разрывы строк.
Textvariable – Вы можете связать управляющую переменную класса StringVar с этой кнопкой меню. Установка этой управляющей переменной изменит отображаемый текст.
Underline – Обычно под текстом на кнопке меню не отображается подчеркивание. Чтобы подчеркнуть один из символов, установите для этой опции индекс этого символа.
Width – Ширина виджета в символах. По умолчанию – 20.
Wraplength – Обычно строки не переносятся. Вы можете установить эту опцию на количество символов, и все строки будут разбиты на части не длиннее этого числа.
Combobox
Combobox в Windows 7
Основная статья: Combobox.
Виджет Combobox в модуле Tkinter.
Combobox – Поле со списком похоже на комбинацию виджета Entry и виджета Listbox .
Поле со списком позволяет вам выбрать одно значение из списка значений. Кроме того, он позволяет вам ввести собственное значение.
Combobox – важный виджет, он присутствует во многих приложениях. Это позволяет пользователю выбирать из списка опций. Он содержит несколько значений, но показывает только один вариант за раз. Обычно вы видели это в интерфейсе Macintosh и Windows. В этой статье вы узнаете, как создать поле со списком с помощью библиотеки Tkinter .
Импортировать модуль
Этот виджет является классом модуля ttk библиотеки Tkinter.
Чтобы начать использовать ttk , импортируйте его модуль после модуля Tk . Здесь мы заменяем виджеты модуля tk модулем ttk, поскольку ttk обеспечивает лучший внешний вид на многих платформах. Он более современный и оформлен в стилях.
from tkinter import *
from tkinter.ttk import *
Ttk.Combobox виджет используется для падения TkInter списка.
Синтаксис:
combobox = ttk.Combobox(master, option=value, …)
Этот виджет принимает следующие параметры:
Justify – Выравнивание текста внутри виджета.
Height – Высота раскрывающегося списка.
Postcommand – Он вызывается непосредственно перед отображением значений.
Textvariable – Он определяет имя, значение которого связано со значением виджета.
Values – Он определяет список значений для отображения в раскрывающемся списке.
Width – Он определяет ширину окна ввода.
Пример:
Чтобы создать поле со списком, вы будете использовать ttk.Combobox() конструктор:
widget_var = tk.StringVar()
combobox = ttk.combobox(container, textvariable=widget_var)
Container Это окно или рама, на которой находится локация выпадающего виджета.
textvariable Аргумент связывает переменную с текущим значением
ComboBox. Переменная должна быть экземпляром tk.StringVar().
Чтобы получить текущее выбранное значение, вы можете использовать get() метод:
current_value = combobox.get()
А чтобы установить текущее значение, вы можете использовать set()метод:
combobox.set(new_value)
После создания поля со списком вы можете предоставить список предопределенных значений, используя values опцию:
compbobox[‘values’] = (‘value1’, ‘value2’, ‘value3’)
По умолчанию вы можете ввести новую запись в поле со списком. Если вы этого не хотите, вы можете установить state следующую опцию ‘readonly’:
compbobox[‘state’] = ‘readonly’
Чтобы снова включить редактирование поля со списком, вы используете такое ‘normal’состояние:
compbobox[‘state’] = ‘normal’
Поле со списком сгенерирует ‘<<ComboboxSelected>>’виртуальное событие, к которому вы можете привязать каждый раз, когда его выбранное значение изменится:
combobox.bind(‘<<ComboboxSelected>>’, fn)
Пример комбинированного списка Python Tkinter
Следующая программа показывает, как создать виджет combobox:
import tkinter as tk
from tkinter import ttk
from tkinter.messagebox import showinfo
root = tk.Tk()
root.geometry(‘300×200’)
root.resizable(False, False)
root.title(‘Combobox Widget’)
def month_changed(event):
msg = f’You selected {month_cb.get()}!’
showinfo(title=’Result’, message=msg)
# month of year
months = (‘Jan’, ‘Feb’, ‘Mar’, ‘Apr’, ‘May’, ‘Jun’,
‘Jul’, ‘Aug’, ‘Sep’, ‘Oct’, ‘Nov’, ‘Dec’)
label = ttk.Label(text=”Please select a month:”)
label.pack(fill=’x’, padx=5, pady=5)
# create a combobox
selected_month = tk.StringVar()
month_cb = ttk.Combobox(root, textvariable=selected_month)
month_cb[‘values’] = months
month_cb[‘state’] = ‘readonly’ # normal
month_cb.pack(fill=’x’, padx=5, pady=5)
month_cb.bind(‘<<ComboboxSelected>>’, month_changed)
root.mainloop()
Выход:
Notebook
Notebook в Windows 7
Основная статья: Notebook.
Виджет Notebook в модуле Tkinter.
Виджет Notebook – еще один новый виджет из модуля ttk. Он позволяет добавлять разные виды отображения приложения в одном окне, предлагая после этого выбрать желаемый с помощью клика по соответствующей вкладке.
Панели с вкладками — это удобный вариант повторного использования графического интерфейса для тех ситуаций, когда содержимое нескольких областей не должно отображаться одновременно.
Основные аргументы
add(child, **kw) – Добавление новой вкладки в блокнот.
Если окно в настоящее время управляется записной книжкой, но скрыто, оно восстанавливается в прежнее положение.
Список доступных опций см. в разделе Опции Tab.
forget(tab_id) – Удаляет вкладку, заданную tab_id, отменяет сопоставление и отменяет управление связанным окном.
hide(tab_id) – Скрытие вкладки, указанной в tab_id.
Вкладка не отображается, но соответствующее окно остается управляемым записной книжкой и ее конфигурация запоминается. Скрытые вкладки можно восстановить с помощью команды add().
identify(x, y) – Возвращает имя элемента табуляции в позиции x, y или пустой строка, если она отсутствует.
index(tab_id) – Возвращает числовой индекс вкладки, указанный параметром tab_id, или общее число вкладок, если tab_id является строка «конец».
insert(pos, child, **kw) – Вставка панели в указанное положение.
pos – это либо строка «end», либо целочисленный индекс, либо имя управляемого нижестоящего элемента. Если child уже управляется записной книжкой, перемещает ее в указанное положение.
Список доступных опций см. в разделе Опции Tab.
select(tab_id=None) – Выбор указанного tab_id.
Будет отображено связанное дочернее окно, и ранее выбранное окно (если оно отличается) не будет сопоставлено. Если tab_id пропущено, возвращает имя графического элемента выбранной панели.
tab(tab_id, option=None, **kw) – Выполните запрос или измените параметры определенного tab_id.
Если kw не задан, возвращает словарь параметра tab значения. Если указан option, возвращает значение этого option. В противном случае устанавливает соответствующие значения.
tabs() – Возвращает список окон, управляемых записной книжкой.
enable_traversal() – Включить обход клавиатуры для окна верхнего уровня, содержащего эту записную книжку.
Это расширит привязки для окна верхнего уровня, содержащего блокнот, следующим образом:
Control-Tab: выбор вкладки, следующей за выбранной в данный момент.
Shift-Control-Tab: выбор вкладки, предшествующей выбранной в данный момент.
Alt-K: где K – мнемонический (подчеркнутый) символ любой вкладки, выберет эту вкладку.
Несколько записных книжек на одном верхнем уровне могут быть включены для обхода, включая вложенные записные книжки. Однако обход записной книжки работает правильно только в том случае, если все панели имеют записную книжку, в которой они находятся как главные.
ОБЗОР
instance = ttk.Notebook(parent ,**options)
instance.add(child ,**options)
instance.insert(pos ,subwindow ,**options)
ОПИСАНИЕ
Ttk.Notebook виджет управляет коллекцией окон и отображает один по одному. Каждое подчиненное окно связано с вкладкой , которую пользователь может выбрать, чтобы изменить текущее отображаемое окно.
СТАНДАРТНЫЕ ОПЦИИ
class
cursor
style
takefocus
ОПЦИИ ДЛЯ ВИДЖЕТОВ
height
Если присутствует и больше нуля, указывает желаемую высоту области панели (не включая внутренние отступы или вкладки). В противном случае используется максимальная высота всех панелей.
padding
Определяет количество дополнительного пространства, добавляемого за пределами записной книжки. Заполнение – это список до четырех значений длины слева вверху справа внизу . Если указано менее четырех элементов, нижний по умолчанию – вверху , правый – по умолчанию – левый , а верхний – по умолчанию левый . Другими словами, список из трех чисел определяет левое, вертикальное и правое заполнение; список из двух чисел определяет отступы по горизонтали и вертикали; одно число указывает одинаковое заполнение по всей длине виджета.
width
Если присутствует и больше нуля, указывает желаемую ширину области панели (не включая внутренние отступы). В противном случае используется максимальная ширина всех панелей.
ПАРАМЕТРЫ ВКЛАДКИ
Для отдельных панелей записной книжки можно указать следующие параметры:
State – Либо “normal”, “disabled” или “hidden”. Если “disabled” (отключено), то вкладку нельзя выбрать. Если “hidden” (скрыто), то вкладку нельзя видить.
Sticky – Определяет, как подчиненное окно располагается в области панели. Значение – это строка, содержащая ноль или более символов «n» , «s» , «e» или «w» . Каждая буква относится к стороне (север, юг, восток или запад), к которой подчиненное окно будет «прилипать» в соответствии с диспетчером геометрии grid () .
Padding – Определяет количество дополнительного пространства, которое нужно добавить между записной книжкой и этой панелью. Синтаксис такой же, как и для параметра заполнения виджета.
Text – Задает строку, которая будет отображаться на вкладке.
Image – Задает изображение для отображения на вкладке. Подробнее см. Ttk.Widget ().
Compound – Определяет, как отображать изображение относительно текста, если присутствуют и текст, и изображение . Допустимые значения см. В классе tkinter.Label .
Underline – Задает целочисленный индекс (отсчитываемый от 0) символа, который необходимо подчеркнуть в текстовой строке. Подчеркнутый символ используется для мнемонической активации, если вызывается метод enable_traversal ().
ИДЕНТИФИКАТОРЫ ТАБЛИЦЫ
Табетический аргумент следующих команд может принимать любой из следующих форм: число между нулем и числом вкладок; Имя дочернего окна; Позиционная спецификация в форме «@ x, y» , которая идентифицирует вкладку. Литеральная строка current, которая идентифицирует текущую выбранную вкладку; или: литеральный конец строки, который возвращает количество вкладок (действительно только для метода index () ).
СПОСОБЫ ВИДЖЕТА
instance .add ( child , ** options )
Добавляет новую вкладку в записную книжку. См. ТАБЛИЦА ОПЦИИ для списка доступных опций. Если окно в настоящее время управляется записной книжкой, но скрыто, оно возвращается в прежнее положение.
instance .cget ( “option” )
Возвращает текущее значение параметра конфигурации, заданного параметром option. Option может иметь любое из значений, принятых классом Notebook .
instance .configure ()
instance .configure ( “option” )
instance .configure ( ** options )
Запрос или изменение параметров конфигурации виджета.
Если параметр не указан, возвращает список, описывающий, например, все доступные параметры: элементами списка являются имя параметра, имя базы данных, класс базы данных, значение по умолчанию и текущее значение.
Если указан параметр “option”, то метод возвращает список, описывающий один именованный параметр (этот список будет идентичен соответствующему подсписку возвращаемого значения, если параметр не указан).
Если указаны ** параметры, то команда изменяет заданные параметры виджета, чтобы они имели заданные значения; в этом случае метод возвращает пустую строку. Option может иметь любое из значений, принятых классом Notebook .
instance .forget ( tabid )
Удаляет вкладку, указанную tabid, отключает отображение и отменяет управление связанным окном.
instance .hide ( tabid )
Скрывает вкладку, указанную tabid. Вкладка не будет отображаться, но связанное с ней окно останется управляемым записной книжкой, и его конфигурация будет сохранена. Скрытые вкладки можно восстановить с помощью метода add () .
instance .index ( tabid )
Возвращает числовой индекс вкладки, заданной параметром tabid, или общее количество вкладок, если tabid является строкой «end» .
instance .insert ( pos, subwindow, ** options )
Вставляет панель в указанную позицию. pos – это либо конец строки, целочисленный индекс, либо имя управляемого подокна. Если подокно уже управляется записной книжкой, перемещает его в указанную позицию. См. ТАБЛИЦА ОПЦИИ для списка доступных опций.
instance .state ( ** statepec , callback, * args, ** kwargs )
См. ttk.Widget ().
Instance .select ( tabid )
Выбирает указанную вкладку. Будет отображено связанное дочернее окно, а ранее выбранное окно (если оно другое) не будет отображено. Если tabid опущен, возвращает имя виджета текущей выбранной панели.
instance .state ( * statespac )
См. ttk.Widget ().
instance .tab ( tabid )
instance .tab ( tabid, option )
instance .tab ( tabid, ** options ) Запросите
или измените параметры конкретной вкладки.
Если параметр не указан, возвращает словарь значений параметров вкладки.
Если указан один параметр, возвращает значение этого параметра.
В противном случае устанавливает для параметров ** соответствующие значения. Доступные параметры см. В разделе «ПАРАМЕТРЫ ВКЛАДКИ».
instance .tabs ()
Возвращает список окон, управляемых записной книжкой, в порядке индексации связанных с ними вкладок.
КЛАВИАТУРА ПУТЕШЕСТВИЯ
Чтобы включить обход клавиатуры для окна верхнего уровня, содержащего виджет записной книжки nb, вызовите:
nb.enable_traversal ()
Это расширит привязки для окна верхнего уровня, содержащего записную книжку, следующим образом:
Control-Tab выбирает вкладку, следующую за текущей выбранной.
Control-Shift-Tab выбирает вкладку, предшествующую текущей выбранной.
Alt- K , где K – мнемонический (подчеркнутый) символ любой вкладки, выберет эту вкладку.
Несколько записных книжек на одном верхнем уровне могут быть включены для обхода, включая вложенные записные книжки. Однако обход записной книжки работает правильно только в том случае, если все панели являются прямыми дочерними элементами записной книжки.
ВИРТУАЛЬНЫЕ СОБЫТИЯ
Виджет записной книжки генерирует виртуальное событие <<NotebookTabChanged>> после выбора новой вкладки.
ПРИМЕР
# импорт модулей tkinter и ttk
import tkinter
from tkinter import ttk
# Сделать корневой виджет
root = tkinter . Тк ()
# Сделать блокнот
nb = ttk.Notebook(root)
nb.pack()
# Сделать 1-ю вкладку
f1 = tkinter . Frame ( nb )
# Добавить вкладку
nb . add ( f1 , text = “Первая вкладка” )
# Сделать 2-ю вкладку
f2 = tkinter . Frame ( nb )
# Добавить 2-ю вкладку
nb . add ( f2 , text = “Вторая вкладка” )
nb.select ( f2 )
nb . enable_traversal ()
# Введите корень основного цикла
root.mainloop()
Статья 1
В этой статье мы обсуждаем виджет записной книжки Tkinter на Python.
Этот виджет действует как вкладки или, можно сказать, блокнот с вкладками.
Этот виджет получен из библиотеки ttk, которая полезна для управления набором окон, и каждый раз он начинает отображать одно окно.
Поэтому мы можем сказать, что пользователи могут выбрать подчиненное окно, связанное с вкладкой, чтобы изменить текущее окно отображения.
Этот виджет записной книжки использует несколько методов для добавления и удаления вкладок, таких как add () для добавления вкладок и некоторые другие методы для временного скрытия вкладок или удаления вкладок.
Этот виджет также предоставляет набор параметров для каждой вкладки, которые обычно используются для управления внешним видом и поведением вкладок в виджетах, где эти параметры классифицируются как стандартные параметры, параметры, специфичные для виджета,
В следующем разделе мы увидим синтаксис записной книжки Tkinter, которую можно объявить как форму команды, так и форму метода.
Синтаксис:
ttk.notebook(root, options)
В приведенном выше синтаксисе мы видим, что виджет записной книжки получен из модуля ttk и имеет 2 параметра: корневой параметр, который указывает родительское или главное окно, а параметры второго параметра классифицируются как стандартные параметры, параметры вкладки, параметры виджета. такие как класс, курсор, вес, отступ, состояние, текст, изображение и т. д.
Виджет записной книжки предоставляет несколько методов, таких как add () для добавления вкладок, cget () для получения текущего значения параметра конфигурации, hide () для скрытия вкладок, index () для получения индекса в числовом формате. значение указанной вкладки и т. д.
В Python Tkinter – это модуль для разработки приложений на основе графического интерфейса пользователя, тогда как виджет записной книжки получается из модуля ttk, который рассматривается как расширение модуля Tkinter или, можно сказать, улучшение этого модуля Tkinter. Поэтому, когда мы используем этот виджет записной книжки, мы должны импортировать модуль ttk, который используется для создания вкладок в окнах и может отображать одно окно за раз, а дочернее окно связано с каждой из созданных вкладок, и эти вкладки обычно используются всякий раз, когда пользователь хочет вывести какое-то сообщение вдовы.
Давайте посмотрим на простой пример создания вкладок в окне с помощью виджета блокнота модуля ttk.
Пример
Код:
from Tkinter import *
import Tkinter as tk
import ttk
import tkMessageBox
master = tk.Tk()
master.geometry(‘500×200’)
def func():
tkMessageBox.showinfo( “Hello Educba”, “Click on the tabs to view the content”)
b1 = Button( master, text=’Click me for next step’, background = ‘Red’, fg = ‘#000000’, command = func)
b1.pack()
tc = ttk.Notebook(master)
t1 = ttk.Frame(tc)
t2 = ttk.Frame(tc)
tc.add(t1, text =’Notebook tab1′)
tc.add(t2, text =’Notebook tab2′)
tc.pack(expand = 1, fill =”both”)
ttk.Label(t1,
text =”Hello Educba Technology Institute”).grid(column = 3,
row = 3)
ttk.Label(t2,
text =”Notebook widget demonstration”).grid(column = 3,
row = 3)
master.mainloop()
В приведенной выше статье мы видим, что сначала импортируем модули Tkinter для разработки графического интерфейса пользователя, модуль ttk для использования виджета записной книжки для создания вкладок в родительском окне, модуль tkmessagebox для отображения любого сообщения во всплывающем диалоговом окне и в В приведенном выше примере появится всплывающее сообщение, когда мы щелкнем виджет кнопки в окне, которое будет отображаться как «щелкайте вкладки, чтобы просмотреть содержимое», чтобы пользователь мог переключаться между окнами по одному, используя эти созданные вкладки с помощью виджета записной книжки.
В этой программе мы передали родительское окно в блокнот (), чтобы мы могли контролировать вкладки для переключения и отображения содержимого по мере создания вкладок, для этого нам нужны отдельные фреймы.
Поэтому для каждой вкладки мы использовали метод frame и передали имена вкладок этому методу frame ().
Затем, используя функцию add (), мы добавляем имя к каждой вкладке, используя текстовый аргумент, и мы назвали вкладки как t1 как «Notebook Tab1», t2 как «Notebook tab2».
Затем, чтобы отобразить содержимое, щелкнув каждую вкладку, которая у нас есть для вкладки «Notebook tab1», мы отображаем контент как «Hello Educba Technology Institute», а для вкладки «Notebook tab2» мы отображаем «демонстрацию виджета Notebook», и это содержимое отображается использование функции label (), где она также принимает текстовый аргумент для содержимого и где содержимое должно отображаться, может использоваться функцией grid (), и здесь мы должны отображать сообщение в столбце 3 и строке 3 для обеих вкладок.
А вывод всей программы можно увидеть на скриншотах выше. t2 как «Notebook tab2».
Затем, чтобы отобразить содержимое, щелкнув каждую вкладку, которая у нас есть для вкладки «Блокнот tab1», мы отображаем контент как «Hello Educba Technology Institute», а для вкладки «Notebook tab2» мы отображаем «Демонстрация виджета Notebook», и это содержимое отображается использование функции label (), где она также принимает текстовый аргумент для содержимого и где содержимое должно отображаться, может использоваться функцией grid (), и здесь мы должны отображать сообщение в столбце 3 и строке 3 для обеих вкладок.
А вывод всей программы можно увидеть на скриншотах выше. t2 как «Notebook tab2».
Затем, чтобы отобразить содержимое, щелкнув каждую вкладку, которая у нас есть для вкладки «Блокнот tab1», мы отображаем контент как «Hello Educba Technology Institute», а для вкладки «Notebook tab2» мы отображаем «Демонстрация виджета Notebook», и это содержимое отображается использование функции label (), где она также принимает текстовый аргумент для содержимого и где содержимое должно отображаться, может использоваться функцией grid (), и здесь мы должны отображать сообщение в столбце 3 и строке 3 для обеих вкладок.
А вывод всей программы можно увидеть на скриншотах выше.
Затем, чтобы отобразить содержимое, щелкнув каждую вкладку, которая у нас есть для вкладки «Notebook tab1», мы отображаем контент как «Hello Educba Technology Institute», а для вкладки «Notebook tab2» мы отображаем «демонстрацию виджета Notebook», и это содержимое отображается использование функции label (), где она также принимает текстовый аргумент для содержимого и где содержимое должно отображаться, может использоваться функцией grid (), и здесь мы должны отображать сообщение в столбце 3 и строке 3 для обеих вкладок.
А вывод всей программы можно увидеть на скриншотах выше.
Затем, чтобы отобразить содержимое, щелкнув каждую вкладку, которая у нас есть для вкладки «Блокнот tab1», мы отображаем контент как «Hello Educba Technology Institute», а для вкладки «Notebook tab2» мы отображаем «Демонстрация виджета Notebook», и это содержимое отображается использование функции label (), где она также принимает текстовый аргумент для содержимого и где содержимое должно отображаться, может использоваться функцией grid (), и здесь мы должны отображать сообщение в столбце 3 и строке 3 для обеих вкладок.
А вывод всей программы можно увидеть на скриншотах выше.
Статья 2
Я написал приложение tkinter, в котором виджеты отображались в двух кадрах, как в этом примере, и оно успешно работает.
from tkinter import *
from tkinter import ttk
root = Tk()
root.title(“Example”)
notebook = ttk.Notebook(root)
frame1 = ttk.Frame(notebook)
frame2 = ttk.Frame(notebook)
notebook.add(frame1, text=”Frame One”)
notebook.add(frame2, text=”Frame Two”)
notebook.pack()
#(The labels are examples, but the rest of the code is identical in structure).
labelA = ttk.Label(frame1, text = “This is on Frame One”)
labelA.grid(column=1, row=1)
labelB = ttk.Label(frame2, text = “This is on Frame Two”)
labelB.grid(column=1, row=1)
root.mainloop()
Чтобы ваш код был ясным и целенаправленным, вы должны создать класс для вашего основного приложения и класс для каждой вкладки. Вам не нужно разделять классы вкладок на отдельные файлы, но, если вы работаете с другими разработчиками, это будет в ваших интересах.
В приведенном ниже коде показано, что ваш код переформатирован, чтобы иметь 3 класса: 1 для основного приложения (MainApplication) и 2 для каждой вкладки (Frame1 и Frame2). Кроме того, я импортировал tkinter as tk для ссылочной ясности.
import tkinter as tk
from tkinter import ttk
class MainApplication(tk.Tk):
def __init__(self):
super().__init__()
self.title(“Example”)
self.geometry(‘300×300’)
self.notebook = ttk.Notebook(self)
self.Frame1 = Frame1(self.notebook)
self.Frame2 = Frame2(self.notebook)
self.notebook.add(self.Frame1, text=’Frame1′)
self.notebook.add(self.Frame2, text=’Frame2′)
self.notebook.pack()
class Frame1(ttk.Frame):
def __init__(self, container):
super().__init__()
self.labelA = ttk.Label(self, text = “This is on Frame One”)
self.labelA.grid(column=1, row=1)
class Frame2(ttk.Frame):
def __init__(self, container):
super().__init__()
self.labelB = ttk.Label(self, text = “This is on Frame Two”)
self.labelB.grid(column=1, row=1)
if __name__ == ‘__main__’:
app = MainApplication()
app.mainloop()
Как вы понимаете, это позволит вам создавать дополнительные классы для добавления фреймов в классы вкладок.
В приведенном ниже коде показано изменение к class Frame1 приведенному выше, и добавление class Frame1 FrameA именно этого и делает.
class Frame1(ttk.Frame):
def __init__(self, container):
super().__init__(container)
self.labelA = ttk.Label(self, text = “This is on Frame One”)
self.labelA.grid(column=1, row=1)
self.frame = Frame1FrameA(self)
self.frame.grid(row=1, columnspan=2)
class Frame1FrameA(ttk.Frame):
def __init__(self, container):
super().__init__(container)
self.LabelA = ttk.Label(self, text=”LabelA in FrameA in tab Frame1″)
self.LabelA.grid(column=0, row=0)
self.LabelB = ttk.Label(self, text=”LabelB in FrameA in tab Frame1″)
self.LabelB.grid(column=1, row=0)
Пишем форму авторизации на Python Tkinter
В данной статье мы рассмотрим с Вами как можно быстро создать графическое приложение с использованием библиотеки Python Tkinter. Проектировать мы будем экран авторизации, в который пользователь должен ввести свой логин и пароль.
Версия Python, которая используется в коде 3.8. Код с комментариями представлен ниже.
# импортируем библиотеку tkinter всю сразу
from tkinter import *
from tkinter import messagebox
# главное окно приложения
window = Tk()
# заголовок окна
window.title(‘Авторизация’)
# размер окна
window.geometry(‘450×230’)
# можно ли изменять размер окна – нет
window.resizable(False, False)
# кортежи и словари, содержащие настройки шрифтов и отступов
font_header = (‘Arial’, 15)
font_entry = (‘Arial’, 12)
label_font = (‘Arial’, 11)
base_padding = {‘padx’: 10, ‘pady’: 8}
header_padding = {‘padx’: 10, ‘pady’: 12}
# обработчик нажатия на клавишу ‘Войти’
def clicked():
# получаем имя пользователя и пароль
username = username_entry.get()
password = password_entry.get()
# выводим в диалоговое окно введенные пользователем данные
messagebox.showinfo(‘Заголовок’, ‘{username}, {password}’.format(username=username, password=password))
# заголовок формы: настроены шрифт (font), отцентрирован (justify), добавлены отступы для заголовка
# для всех остальных виджетов настройки делаются также
main_label = Label(window, text=’Авторизация’, font=font_header, justify=CENTER, **header_padding)
# помещаем виджет в окно по принципу один виджет под другим
main_label.pack()
# метка для поля ввода имени
username_label = Label(window, text=’Имя пользователя’, font=label_font , **base_padding)
username_label.pack()
# поле ввода имени
username_entry = Entry(window, bg=’#fff’, fg=’#444′, font=font_entry)
username_entry.pack()
# метка для поля ввода пароля
password_label = Label(window, text=’Пароль’, font=label_font , **base_padding)
password_label.pack()
# поле ввода пароля
password_entry = Entry(window, bg=’#fff’, fg=’#444′, font=font_entry)
password_entry.pack()
# кнопка отправки формы
send_btn = Button(window, text=’Войти’, command=clicked)
send_btn.pack(**base_padding)
# запускаем главный цикл окна
window.mainloop()
Теперь проясню пару моментов в коде:
- в коде используется вот такая конструкция **header_padding – это операция разложения словаря в составляющие переменные.
В нашем примере преобразование будет выглядеть следующим образом:
**header_padding = {‘padx’: 10, ‘pady’: 12} -> header_padding -> padx=10, pady=12.
Т.е. в конструктор класса Label, например, фактически будут передаваться правильные параметры.
Это сделано для удобства, чтобы несколько раз не писать одни и теже настройки отступов.
2) у виджетов (Label, Button, Entry) – есть несколько менеджеров расположения, которые определяют, как дочерний виджет будет располагаться в родительском окне (контейнере). В примере, был использован метод pack(), который, по умолчанию, располагает виджет один под другим.
Таким образом, мы создали кроссплатформенное графическое приложение на Python – авторизация пользователя, которое может пригодиться на практике, остается добавить логику авторизации в методе clicked.
Создание окна по центру и кнопка выхода в Tkinter
Разметка виджетов в Tkinter — pack, grid и place
Виджеты Checkbutton, Label, Scale и Listbox в Tkinter
Примеры
import tkinter as tk
root = tk.Tk()
label = tk.Label(root, text=”Hello World”, padx=10, pady=10)
label.pack()
root.mainloop()
import tkinter as tkclass Root(tk.Tk):
def init(self):
super().init()
self.label = tk.Label(self, text="Hello World", padx=5, pady=5)
self.label.pack()
if name == "main":
root = Root()
root.mainloop()Пример 1
import tkinter
from tkinter import ttk
root = tkinter.Tk()
big_frame = ttk.Frame(root)
big_frame.pack(fill=’both’, expand=True)
label = ttk.Label(big_frame, text=”This is a button test.”)
label.pack()
button = ttk.Button(big_frame, text=”Click me!”)
button.pack()
root.title(“Button Test”)
root.geometry(‘200×100’)
root.minsize(150, 50)
root.mainloop()
Пример 2
import tkinter
from tkinter import ttk
root = tkinter.Tk()
big_frame = ttk.Frame(root)
big_frame.pack(fill=’both’, expand=True)
label = ttk.Label(big_frame, text=’Hello’)
label.pack()
def change_text():
if label[‘text’] == ‘Hello’:
label[‘text’] = ‘World’
else:
label[‘text’] = ‘Hello’
button = ttk.Button(big_frame, text=”Click here”, command=change_text)
button.pack()
root.mainloop()
Пример 3
import tkinter
from tkinter import ttk
root = tkinter.Tk()
big_frame = ttk.Frame(root)
big_frame.pack(fill=’both’, expand=True)
label = ttk.Label(big_frame, text=’Hello’)
label.pack()
def change_text():
if label[‘text’] == ‘Hello’:
label[‘text’] = ‘World’
else:
label[‘text’] = ‘Hello’
button = ttk.Button(big_frame, text=”Click here”, command=change_text)
button.pack()
root.mainloop()
Пример 4
import time
import tkinter
from tkinter import ttk
def ok_callback():
print(“hello”)
def stupid_callback():
time.sleep(5)
root = tkinter.Tk()
big_frame = ttk.Frame(root)
big_frame.pack(fill=’both’, expand=True)
button1 = ttk.Button(big_frame, text=”This is OK”, command=ok_callback)
button1.pack()
button2 = ttk.Button(big_frame, text=”This sucks”, command=stupid_callback)
button2.pack()
root.mainloop()
Пример 5
import tkinter
from tkinter import ttk
def print_hello():
print(“hello”)
root = tkinter.Tk()
big_frame = ttk.Frame(root)
big_frame.pack(fill=’both’, expand=True)
button = ttk.Button(big_frame, text=”Print hello”, command=print_hello)
button.pack()
root.mainloop()
Пример 6
import functools
import tkinter
from tkinter import ttk, messagebox, filedialog, simpledialog, colorchooser
class Demo:
def __init__(self, big_frame, modulename):
self.frame = ttk.LabelFrame(big_frame, text=("tkinter." + modulename))
self.modulename = modulename
# this makes buttons that demonstrate messagebox functions
# it's a bit weird but it makes this code much less repetitive
def add_button(self, functionname, function, args=(), kwargs=None):
# see http://stackoverflow.com/q/1132941
if kwargs is None:
kwargs = {}
# the call_string will be like "messagebox.showinfo('Bla Bla', 'Bla')"
parts = []
for arg in args:
parts.append(repr(arg))
for key, value in kwargs.items():
parts.append(key + "=" + repr(value))
call_string = "%s.%s(%s)" % (self.modulename, functionname,
', '.join(parts))
callback = functools.partial(self.on_click, call_string,
function, args, kwargs)
button = ttk.Button(self.frame, text=functionname, command=callback)
button.pack()
def on_click(self, call_string, function, args, kwargs):
print('running', call_string)
result = function(*args, **kwargs)
print(' it returned', repr(result))
root = tkinter.Tk()
big_frame = ttk.Frame(root)
big_frame.pack(fill='both', expand=True)
msgboxdemo = Demo(big_frame, "messagebox")
msgboxdemo.add_button(
"showinfo", messagebox.showinfo,
["Important Message", "Hello World!"])
msgboxdemo.add_button(
"showwarning", messagebox.showwarning,
["Warny Warning", "This may cause more problems."])
msgboxdemo.add_button(
"showerror", messagebox.showerror,
["Fatal Error", "Something went wrong :("])
msgboxdemo.add_button(
"askyesno", messagebox.askyesno,
["Important Question", "Do you like this?"])
msgboxdemo.add_button(
"askyesnocancel", messagebox.askyesnocancel,
["Important Question", "Do you like this?"])
msgboxdemo.add_button(
"askokcancel", messagebox.askokcancel,
["Stupid Question", "Do you really want to do this?"])
msgboxdemo.add_button(
"askyesnocancel", messagebox.askyesnocancel,
["Save Changes?", "Do you want to save your changes before quitting?"])
filedialogdemo = Demo(big_frame, "filedialog")
filedialogdemo.add_button(
"askopenfilename", filedialog.askopenfilename,
kwargs={'title': "Open File"})
filedialogdemo.add_button(
"asksaveasfilename", filedialog.asksaveasfilename,
kwargs={'title': "Save As"})
simpledialogdemo = Demo(big_frame, "simpledialog")
simpledialogdemo.add_button(
"askfloat", simpledialog.askfloat,
["Pi Question", "What's the value of pi?"])
simpledialogdemo.add_button(
"askinteger", simpledialog.askinteger,
["Computer Question", "How many computers do you have?"])
simpledialogdemo.add_button(
"askstring", simpledialog.askstring,
["Editor Question", "What is your favorite editor?"])
colorchooserdemo = Demo(big_frame, "colorchooser")
colorchooserdemo.add_button(
"askcolor", colorchooser.askcolor,
kwargs={'title': "Choose a Color"})
msgboxdemo.frame.grid(row=0, column=0, rowspan=3)
filedialogdemo.frame.grid(row=0, column=1)
simpledialogdemo.frame.grid(row=1, column=1)
colorchooserdemo.frame.grid(row=2, column=1)
root.title("Dialog Tester")
root.resizable(False, False)
root.mainloop()root = tkinter.Tk()
big_frame = ttk.Frame(root)
big_frame.pack(fill=’both’, expand=True)
msgboxdemo = Demo(big_frame, “messagebox”)
msgboxdemo.add_button(
“showinfo”, messagebox.showinfo,
[“Important Message”, “Hello World!”])
msgboxdemo.add_button(
“showwarning”, messagebox.showwarning,
[“Warny Warning”, “This may cause more problems.”])
msgboxdemo.add_button(
“showerror”, messagebox.showerror,
[“Fatal Error”, “Something went wrong :(“])
msgboxdemo.add_button(
“askyesno”, messagebox.askyesno,
[“Important Question”, “Do you like this?”])
msgboxdemo.add_button(
“askyesnocancel”, messagebox.askyesnocancel,
[“Important Question”, “Do you like this?”])
msgboxdemo.add_button(
“askokcancel”, messagebox.askokcancel,
[“Stupid Question”, “Do you really want to do this?”])
msgboxdemo.add_button(
“askyesnocancel”, messagebox.askyesnocancel,
[“Save Changes?”, “Do you want to save your changes before quitting?”])
filedialogdemo = Demo(big_frame, “filedialog”)
filedialogdemo.add_button(
“askopenfilename”, filedialog.askopenfilename,
kwargs={‘title’: “Open File”})
filedialogdemo.add_button(
“asksaveasfilename”, filedialog.asksaveasfilename,
kwargs={‘title’: “Save As”})
simpledialogdemo = Demo(big_frame, “simpledialog”)
simpledialogdemo.add_button(
“askfloat”, simpledialog.askfloat,
[“Pi Question”, “What’s the value of pi?”])
simpledialogdemo.add_button(
“askinteger”, simpledialog.askinteger,
[“Computer Question”, “How many computers do you have?”])
simpledialogdemo.add_button(
“askstring”, simpledialog.askstring,
[“Editor Question”, “What is your favorite editor?”])
colorchooserdemo = Demo(big_frame, “colorchooser”)
colorchooserdemo.add_button(
“askcolor”, colorchooser.askcolor,
kwargs={‘title’: “Choose a Color”})
msgboxdemo.frame.grid(row=0, column=0, rowspan=3)
filedialogdemo.frame.grid(row=0, column=1)
simpledialogdemo.frame.grid(row=1, column=1)
colorchooserdemo.frame.grid(row=2, column=1)
root.title(“Dialog Tester”)
root.resizable(False, False)
root.mainloop()
Пример 7
import tkinter
from tkinter import ttk, messagebox
def do_hello_world():
messagebox.showinfo(“Important Message”, “Hello World!”)
root = tkinter.Tk()
big_frame = ttk.Frame(root)
big_frame.pack(fill=’both’, expand=True)
button = ttk.Button(big_frame, text=”Click me”, command=do_hello_world)
button.pack()
root.mainloop()
Пример 8
import tkinter
from tkinter import ttk
# only use this before creating the main root window! otherwise you get
# two root windows at the same time, and that's bad, see above
def startup_dialog(labeltext):
result = None
rooty_dialog = tkinter.Tk()
big_frame = ttk.Frame(rooty_dialog)
big_frame.pack(fill='both', expand=True)
# result is left to None if the dialog is closed without clicking OK
def on_ok():
# usually 'result = entry.get()' creates a local variable called
# result, but this thing makes it also appear outside on_ok()
nonlocal result
result = entry.get()
rooty_dialog.destroy() # stops rooty_dialog.mainloop()
label = ttk.Label(big_frame, text=labeltext)
label.place(relx=0.5, rely=0.3, anchor='center')
entry = ttk.Entry(big_frame)
entry.place(relx=0.5, rely=0.5, anchor='center')
okbutton = ttk.Button(big_frame, text="OK", command=on_ok)
okbutton.place(relx=0.5, rely=0.8, anchor='center')
rooty_dialog.geometry('250x150')
rooty_dialog.mainloop()
# now the dialog's mainloop has stopped, so the dialog doesn't exist
# anymore and creating another root window is ok
return result
name = startup_dialog("Enter your name:")
if name is not None: # the user clicked OK
root = tkinter.Tk()
big_frame = ttk.Frame(root)
big_frame.pack(fill='both', expand=True)
label = ttk.Label(big_frame, text=("Hello %s!" % name))
label.pack()
root.mainloop()Пример 9
import tkinter
from tkinter import messagebox
root = tkinter.Tk()
root.withdraw()
messagebox.showerror(“Fatal Error”, “Something went badly wrong :(“)
Пример 10
import tkinter
from tkinter import ttk
def display_dialog():
dialog = tkinter.Toplevel()
big_frame = ttk.Frame(dialog)
big_frame.pack(fill='both', expand=True)
label = ttk.Label(big_frame, text="Hello World")
label.place(relx=0.5, rely=0.3, anchor='center')
dialog.transient(root)
dialog.geometry('300x150')
dialog.wait_window()
root = tkinter.Tk()
big_frame = ttk.Frame(root)
big_frame.pack(fill='both', expand=True)
button = ttk.Button(big_frame, text="Click me", command=display_dialog)
button.pack()
root.mainloop()
Пример 11
import tkinter
from tkinter import ttk
def display_dialog():
root2 = tkinter.Tk() # BAD! NO!!
big_frame2 = ttk.Frame(root2)
big_frame2.pack(fill='both', expand=True)
ttk.Label(big_frame2, text="Hello World").place(relx=0.5, rely=0.3, anchor='center')
root2.mainloop()
root = tkinter.Tk()
button = ttk.Button(root, text="Click me", command=display_dialog)
button.pack()
root.mainloop()Пример 12
import tkinter
from tkinter import messagebox
def wanna_quit():
if messagebox.askyesno(“Quit”, “Do you really want to quit?”):
# the user clicked yes, let’s close the window
root.destroy()
root = tkinter.Tk()
root.protocol(‘WM_DELETE_WINDOW’, wanna_quit)
root.mainloop()
Пример 13
import threading
import time
import tkinter
from tkinter import ttk, messagebox
def do_slow_stuff():
for i in range(1, 5):
print(i, ‘…’)
time.sleep(1)
print(‘done!’)
def check_if_ready(thread):
print(‘check’)
if thread.is_alive():
# not ready yet, run the check again soon
root.after(200, check_if_ready, thread)
else:
messagebox.showinfo(“Ready”, “I’m ready!”)
def start_doing_slow_stuff():
thread = threading.Thread(target=do_slow_stuff)
thread.start()
root.after(200, check_if_ready, thread)
root = tkinter.Tk()
big_frame = ttk.Frame(root)
big_frame.pack(fill=’both’, expand=True)
ttk.Button(big_frame, text=”Start”, command=start_doing_slow_stuff).pack()
root.mainloop()
Ну очень полезная ссылка https://www.youtube.com/playlist?list=PLjRuaCofWO0MVr1xkRXiHR3OAZ4M0C2nWа