Добавил пользователь Skiper
Обновлено: 18.09.2024

В этой статье мы рассмотрим примеры окон из модулей messagebox и filedialog пакета tkinter.

Для вызова диалоговых окон открытия и сохранения файлов и работу с ними необходимо импортировать “подмодуль” Tkinter – tkinter.filedialog, в котором описаны классы для окон данного типа. Рассмотрим пример:

Здесь создаются два объекта (op и sa): один вызывает диалоговое окно “Открыть”, а другой “Сохранить как…”. При выполнении программы, они друг за другом выводятся на экран после появления главного окна.

Диалоговые окна мы научились создавать, однако если мы попытаемся открыть какой-нибудь текстовый файл, то в лучшем случае ничего не произойдет. Поэтому нужен модуль, который может нам помочь.

Метод input модуля fileinput может принимать в качестве аргумента адрес файла, читать его содержимое, формируя список строк.

Далее с помощью цикла for можно извлекать строки последовательно и помещать их, например, в текстовое поле. Пример:

Программа “Редактор файлов”

Для закрепления теории создадим небольшую программу. Полный листинг:

Программа напоминает простейший редактор файлов. В программе есть небольшое меню. Загрузка и сохранение файла осуществляется с вызовом диалога открытия файла. Для открытия и сохранения мы создали две функции.

В функции close_win вызывается окно askyenso, которое позволяет получить от пользователя два ответа (true и false). При положительном ответе сработает ветка if и главное окно будет закрыто. В случае нажатия пользователем кнопки “Нет” окно просто закроется.

В данной статье мы создали неплохой текстовый редактор и теперь вы можете самостоятельно его улучшать. Пишите в комментариях свои варианты нашей программы.

Графический интерфейс – неотъемлемая составляющая любого современного приложения. Даже во времена MS DOS, несмотря на тотальное доминирование командной строки в те времена, все равно начали появляться первые графические интерфейсы. Чего только стоит легендарный файловый менеджер Norton Commander? А для создания игр работа с графическими интерфейсами вообще является приоритетной.

В Python работа с графическими интерфейсами осуществляется с помощью библиотеки Tkinter. Она предустановлена в язык, поэтому ее можно использовать сразу, без дополнительной установки.

Пример приложения, созданного с применением Tkinter – IDLE. Это очень популярная среда разработки приложений для Python.

Рекомендуется пользоваться Python 3.7 для того, чтобы проверять нашу инструкцию. Дело в том, что третья версия претерпела настолько существенные изменения, что использование второй версии уже далеко от реального программирования.

В этой инструкции мы будем подразумевать, что базовое представление о Python у Вас уже есть. Мы же будем говорить о том, как создавать окно, что такое виджеты и как их добавить и редактировать. Давайте начинать.

Создаем свой первый графический интерфейс

Перед тем, как использовать эту библиотеку, ее следует импортировать. После этого уже можно прописывать строки для настройки окна.

from tkinter import *

window.mainloop()

Все, теперь мы создали приложение с графической оболочкой. Поздравляем.

Обратите внимание на последнюю строку . Она содержит метод mainloop(), который принадлежит объекту window. Она нужна для того, чтобы зациклить отображение окна. Если ее не использовать, то окно сразу закроется, и пользователь ничего не увидит.

Создаем виджет Label

Сначала необходимо добавить виджет. Для этого объявляется переменная (в нашем случае – lbl ) с использованием следующего кода.

После этого мы задаем место, в котором будет размещаться наша надпись. В нашем случае это будет самый верх окна слева. Соответственно, необходимо задать такое положение:

lbl.grid(column=0, row=0)

После того, как мы добавим эти строки в приведенный выше код (а добавлять их надо после той строки, где задается заголовок), получится следующий.

from tkinter import *

lbl.grid(column=0, row=0)

window.mainloop()

Вызов метода grid – обязательный. Иначе пользователь не увидит текста, который мы захотели .

Настраиваем размер и шрифт текста

Этот параметр может использоваться, в том числе, и для других виджетов. Его можно применять не только к надписи. Если в виджете есть шрифт, его можно изменять.

Настраиваем размеры окна приложения

Программа у нас получилась отличная, конечно. Но, скажите, чего-то не хватает. Все правильно, окошко хотелось бы побольше. Что можно сделать для того, чтобы увеличить его?

window.geometry(‘500×350’)

Эта строка делает размер окна по ширине 500 пикселей, а по высоте – 250.

Видим, что нет ничего сложного. Но этого явно недостаточно для создания функционального приложения, которое будет взаимодействовать с пользователем. Например, не хватает кнопок. Давайте посмотрим, как добавлять на наше окно кнопку и обрабатывать ее нажатие.

Добавляем виджет Button

Теперь нам нужно добавить кнопку. Чтобы это сделать, необходимо создать объект соответствующего класса, а в свойствах задать текст, который будет на ней отображаться.

btn.grid(column=1, row=0)

Мы добавили кнопку после метки в коде. В целом, у нас получилась такая программа.

from tkinter import *

window.geometry(‘400×250’)

lbl.grid(column=0, row=0)

btn.grid(column=1, row=0)

window.mainloop()

После того, как этот код будет запущен, получится следующий результат.

Заметьте, что в коде выше мы указали позиционирование кнопки во втором столбце. Но поскольку индексация начинается с нуля, то, соответственно, мы написали индекс столбца 1. Если же его разместить с координатами 0,0, то он просто заменит надпись.

Как изменить цвет текста и фона у Button?

Кастомизация кнопок не ограничивается одним лишь изменением размера и начертания шрифтов. Например, можно сделать кнопку черной, а буквы на ней – красными. Для этого надо прописать соответствующие свойства: fg и bg. Они позволяют настроить цвет надписи и фон соответственно.

Точно так же, как и с размером и начертанием шрифта, с помощью этих свойств можно редактировать внешний вид любого другого элемента, не только кнопки.

А теперь приведем пример кода, с помощью которого мы сделали надпись кнопки красной на черном фоне.

Хорошо, а что сейчас будет, если нажать на кнопку? Если вы попробовали у себя написать аналогичный код, то вы увидите, что ничего не произойдет. Дело в том, что не был настроен обработчик события. Это такая функция, которая активируется при наступлении определенного события.

Кнопка Click

Давайте попробуем прописать действия приложения на случай, если пользователь таки попробует нажать на эту кнопку. Как это делается?

Для начала необходимо прописать ту функцию, которая активируется при нажатии кнопки (то есть, будет служить обработчиком событий).

def clicked():

После этого она прописывается в качестве свойства command таким образом:

Заметьте, что мы используем название функции обработчика событий без скобок.

Вот, что уже умеет наша программа. Но это еще не все.

Получение ввода при помощи класса Entry (текстовое поле Tkinter)

Раньше мы рассматривали самые простые виджеты, которые работали на вывод и простейший ввод (в виде нажатия кнопки). Теперь же мы рассмотрим, как вводить конкретную информацию в поле ввода, используя класс Entry. С его помощью можно добавить в программу такое текстовое поле, которое вы привыкли видеть в других приложениях.

Чтобы его добавить, необходимо создать объект соответствующего класса и присвоить его переменной. Для этого используется следующая строка кода.

txt = Entry(window, width=10)

Но, как вы уже поняли, этого недостаточно. Текстовое поле, равно как и любой другой объект, необходимо добавить к окну. Для этого используется функция grid . Например, так будет выглядеть поле ввода, размещенное во втором столбце (то есть, столбце, имеющем индекс 1). Соответственно, пришлось переместить кнопку немного правее.

Итоговый код получился следующим.

from tkinter import *

def clicked():

window.geometry(‘400×250’)

lbl.grid(column=0, row=0)

txt = Entry(window,width=10)

txt.grid(column=1, row=0)

btn.grid(column=2, row=0)

window.mainloop()

Ну, соответственно, программа будет выглядеть так.

Эта задача достигается с помощью функции get . Соответственно, запишем следующий код.

def clicked():

lbl.configure(text=res)

Ну и небольшая демонстрация окна программы, в которой реализован этот функционал.

Фокус виджета ввода

А знаете, в чем еще проблема этого приложения? В том, что нужно вручную настраивать фокус ввода. То есть, нельзя сразу вводить текст после того, как программа запустится. Как же осуществить автоматическую настройку фокуса? Для этого необходимо вызвать одноименную функцию.

При запуске кода вы увидите, что текст можно будет написать сразу, поскольку курсор стоит непосредственно в поле ввода. Это значительно упрощает взаимодействие с программой.

Отключение виджета ввода

txt = Entry(window,width=10, state=’disabled’)

После того, как вы запустите программу, вы увидите, что поле ввода заблокировано, и не имеете никакой возможности ввести текст. Применений этой возможности много. Например, блокировка поля пароля при трехразовом неправильном вводе.

Добавляем виджет Combobox

Combobox – это выпадающий список. Чтобы его добавить, необходимо создать объект соответствующего класса.

from tkinter.ttk import Combobox

combo = Combobox(window)

Далее необходимо присвоить значения для поля ввода и разместить поле ввода в подходящее место окна.

combo.grid(column=0, row=0)

Возможно также использование функции get , чтобы получить содержимое списка.

Добавляем виджет Checkbutton (чекбокс)

Чтобы добавить виджет Checkbutton, необходимо добавить объект соответствующего класса.

from tkinter.ttk import Checkbutton

chk = Checkbutton(window, text=’Выбрать’)

Если передать объекту var=chk_state , то можно задать значение по умолчанию.

Установка состояния с помощью intvar()

Чтобы чекбокс сделать с поставленной галочкой или пустым, используется метод set с соответствующим индексом. Если нужно сделать так, чтобы он был активирован, то в качестве аргумента этой функции используется 1. Если же надо, чтобы он был деактивирован, то используется 0 в качестве аргумента. Перед тем, как это использовать, необходимо присвоить соответствующему чекбоксу функцию intvar() .

chk_state = IntVar()

Установка состояния с помощью booleanvar()

Устанавливать состояние чекбокса можно и с помощью функции BooleanVar . В этом случае метод set устанавливается на значение True или False .

chk_state = BooleanVar()

Результат от использования BooleanVar и IntVar одинаковые. Можно использовать тот, который больше нравится.

Добавляем виджеты RadioButton

Радиокнопки – один из любимых виджетов пользователей любых программ. Выглядят они так.

Чтобы их добавить, действия аналогичные предыдущим, только присоединяется класс Radiobutton.

rad1 = Radiobutton(window, text=’Первый’, value=1)

rad2 = Radiobutton(window, text=’Второй’, value=2)

rad3 = Radiobutton(window, text=’Третий’, value=3)

И, аналогично предыдущим виджетам, необходимо задать позицию радиокнопок. Они должны располагаться на разных местах.

Также можно настроить радиокнопку так, чтобы она работала, как обычная кнопка. То есть, можно сделать обработчик события на нажатие. Делается это таким образом.

rad1 = Radiobutton(window,text=’Первая’, value=1, command=clicked)

def clicked():

Получаем значение Radio Button (избранная Radio Button)

Для получения значения радиокнопки и той, которая сейчас выбрана, необходимо передать соответствующий параметр переменной, а потом просто получить ее значение.

Для этого прописывается сама переменная, а ей присваивается функция IntVar . А номер кнопки передается в качестве свойства value .

Добавляем виджет ScrolledText (текстовая область Tkinter)

Чтобы добавить большое текстовое поле, необходимо присвоить соответствующей переменной объект класса ScrolledText:

from tkinter import scrolledtext

txt = scrolledtext.ScrolledText(window,width=40,height=10)

Видим, что в свойствах необходимо указать ширину и высоту. Можно этого не делать. В таком случае текстовое поле займет область всего окна.

Результат получится приблизительно следующим.

Настраиваем содержимое

Настройка содержимого большого текстового поля осуществляется с помощью метода insert . Смотрите, как это работает.

txt.insert(INSERT, ‘Поле для ввода текста’)

Удаление/Очистка содержимого Scrolledtext

Очистить содержимое текстового поля очень просто. Для этого используется функция delete , которая работает вместе с объектом. В скобках указываются координаты, начиная с какой позиции и до какой требуется убрать содержимое текстового поля.

txt.delete(1.0, END)

Всплывающие окна – важные составляющие любого программного обеспечения. Они позволяют быстро проинформировать пользователя о чем-то, не изменяя содержимого основного окна.

Они создаются таким образом.

from tkinter import messagebox

messagebox.showinfo(‘Заголовок’, ‘Текст’)

Например, можно прописать обработчик клика по кнопке, в котором предусмотрено всплывающее окно.

Также возможна настройка показа предупреждающего окна или же уведомления об ошибках. Отличается только функция, которая отображает окно.

Показ диалоговых окон с выбором варианта

Диалоговые окна бывают разными. Например, можно настроить показ такого окна, который выдавал бы варианты ответа. Если вы знаете язык, вы с легкостью догадаетесь, что означает каждая из этих команд.

res = messagebox.askquestion(‘Заголовок’, ‘Текст’)

res = messagebox.askyesno(‘Заголовок’, ‘Текст’)

res = messagebox.askyesnocancel(‘Заголовок’, ‘Текст’)

res = messagebox.askokcancel(‘Заголовок’, ‘Текст’)

res = messagebox.askretrycancel(‘Заголовок’, ‘Текст’)

Но есть еще функция, которая возвращает три значения – True/False/None в зависимости от выбранной кнопки. Это метод askyesnocancel .

Добавление SpinBox (Виджет спинбокс)

Spinbox – это такое поле ввода со стрелками. Добавляется он с помощью команды

spin = Spinbox(window, from_=0, to=100)

Соответственно, параметры from и to отвечают за диапазон допустимых значений.

Значение по умолчанию для Spinbox

Чтобы указать значение по умолчанию, нужно передать параметр textvariable .

spin = Spinbox(window, from_=0, to=100, width=5, textvariable=var)

Добавляем виджет Progressbar

Как и с предыдущими вариантами, для добавления шкалы прогресса, нужно использовать соответствующий класс.

from tkinter.ttk import Progressbar

bar = Progressbar(window, length=200)

Меняем цвет Progressbar

Схема изменения цвета Progressbar довольно сложная и требует отдельного рассмотрения. В целом, механика следующая: нужно создать стиль, задать цвет фона, а потом перенести его на Progressbar.

Добавляем поле загрузки файла

Поле открытия файла относится к классу filedialog . Соответственно, добавить его можно с помощью следующего кода.

from tkinter import filedialog

file = filedialog.askopenfilename()

Все эти фрагменты приводятся, как примеры. Вы подставляете свои значения, исходя из ваших задач .

Указываем тип файлов (расширение фильтра файлов)

Для этого нужно использовать параметр filetypes . При этом требуется указать расширение в tuples.

Добавление панели меню

Для работы с меню существует соответствующий класс menu .

menu = Menu(window)

menu.add_command(label=’Файл’)

window.config(menu=menu)

Видим, что сначала создается меню, а потом добавляются команды. А добавление подменю осуществляется так.

menu.add_cascade(label=’Автор’, menu=new_item)

Добавляем виджет Notebook (управление вкладкой)

Также Python позволяет создавать вкладки. Последовательность действий довольно сложная, и эта тема требует отдельного рассмотрения:

1. Создается объект класса Notebook.
2. Создается вкладка.
3. Вкладка добавляется в элемент управления вкладками и осуществляется запаковка с целью отображения его в окне.

Добавляем виджет на вкладку

Чтобы добавить виджет на вкладку, необходимо назначить родительское свойство той, на которую осуществляется добавление.

Добавляем интервал для виджетов (заполнение)

Для этого используются свойства padx и pady.

lbl1 = Label(tab1, text= ‘label1’, padx=5, pady=5)

Как видим, тема очень обширная, и работа с каждым действием, описанным выше, требует отдельной статьи. Тем не менее, хочется надеяться, что Вы получили общее представление о том, как работать с графическим интерфейсом в Python.

I. Основы Tkinter

Моя дочь, рассматривая экран моего Linux-компьютера, сказала: "Похоже на компьютер 80-х". Думаю, что это на самом деле так. Linux можно разукрасить, чтобы он был похож на машины с Windows XP или Маки, заполняющие мир сегодня, но многие пользователи Linux, подобно мне, так не делают. Нам нравятся команды, подаваемые с терминала, и угловатый рабочий стол Gnome. Это похоже на старые добрые времена, когда большая часть программного обеспечения писалась вручную. И до сих пор в очень многих случаях самостоятельно написанное приложение является наилучшим решением, и язык Python - прекрасный выбор для задач такого рода.

Python распространяется вместе с графической библиотекой языка Tk/Tcl, содержащейся в модуле Tkinter. Хотя для создания графических интерфейсов пользователя с помощью языка Python существует много других инструментов, полезно, начиная изучать этот язык, уделить время стандартному пакету, прежде чем браться за более современные. Настоящее краткое руководство поможет быстро разобраться с Tkinter. Дойдя до конца, вы овладеете всеми принципами, необходимыми для построения более сложных графических интерфейсов, и будете представлять общую объектно-ориентированную модель языка Python. Лично для меня вполне достаточно возможностей Tkinter. Для других - это трамплин к более сложным графическим решениям.

Это учебное пособие также "похоже на веб-страницу 90-х". Каждая из последующих страниц следует определенному шаблону. Окно с кодом сопровождается подробными комментариями. Перемещаться по ним можно посредством обычных кнопок [prev][home][next] или с помощью оглавления, приводимого ниже:

Наверное самый лучший способ работы с предлагаемым материалом - изучать код, запускать его на компьютере и затем снова анализировать код. В комментариях разъясняется каждый новый фрагмент кода по мере его расширения.

Создание окна

Данный модуль Python window_01.py создает пустое окно 200x150 с названием "myWindow", расположенное в центре экрана.

Довольно просто, не так ли? Понадобилось всего шесть строчек кода. Запустите Python; загрузите модуль Tkinter; присвойте какой-либо переменной значение Tk() ; затем настройте три метода Tk() для этой переменной. Итак, запускаем window_01.py . Voila! Вы создали окно - фундаментальный элемент любого графического интерфейса пользователя Tkinter.

Создание "дочернего" окна

Приведенный здесь модуль Python - window_02.py помещает на экран еще одно пустое "дочернее" окно 200x150. В большинстве графических интерфейсов для организации диалога используют всплывающие окна. "Дочернее" окно исчезает при закрытии основного окна.

Toplevel() - это класс Tkinter, с помощью которого можно создавать любое окно кроме главного. Он также присваивается переменной child . Toplevel(root) означает дочернее окно child , относящееся и зависящее от родительского окна root . Следующие две команды формируют заголовок и размеры дочернего окна аналогично случаю родительского окна. Коду дочернего окна не нужен свой метод mainloop() . Он запускается из родительского окна.

Снова довольно просто. Потребовалось лишь три дополнительные строчки кода. Присвойте Toplevel() новой переменной; свяжите его с корневым окном root с помощью Toplevel(root) ; затем задайте значения пары свойств Toplevel(root) . Наконец, запустите window_02.py .

Мы движемся быстро. Мы умеем создавать родительское окно и любое число дочерних окон. Закрытие родительского окна вызывает закрытие и окна дочернего, но не наоборот.

Уже похоже на интерфейс.

Работа с классами

Python - это объектно-ориентированный язык программирования. Tk() и Toplevel() являются классами Tkinter, принимающими форму объектов для создания на экране графических окон. Программирование на Tkinter подразумевает комбинирование и преобразование встроенных классов Tkinter в новые классы с индивидуальными свойствами и методами.

Следующей задачей данного руководства будет воспроизведение визуального эффекта, достигнутого в последнем примере [window_02.py], объектно-ориентированными средствами, заложенными в Python, т.е. путем создания классов. Приведенный выше код объявляет и определяет класс. Объект - это экземпляр класса. В данном случае мы собираемся создать простые классы родительских и дочерних окон. Позже мы будем формировать классы с их собственными (добавленными) свойствами и методами.

Вот обобщенная форма для создания классов. Замечание: отступы обязательны! Здесь указывается, что будет создан класс с именем имя-класса со следующими определениями [ def ]. Команду __init__(self) проще показать в действии, чем объяснить. __init__() - это конструктор объектов, позволяющий создавать экземпляр объекта во время исполнения программы. self - это метка экземпляра, необходимая для привязки переменных класса к данному объекту. Таким образом инструкция self.master = root создает переменную master и присваивает ей глобальное значение root [пока еще не определенное]. В оставшейся части кода вы увидите, как теперь определяется то же самое окно внутри класса main . Итак, что же такое child() ?

child() - это вызов другого класса, определенного в модуле. Так класс main генерирует экземпляр дочернего окна.

При запуске модуля на выполнение происходит вызов Python, загрузка Tkinter и сохранение определений классов main и child . Команды, приведенные выше, сначала задают значение переменной root , чтобы создать экземпляр Tk() , затем открывают окно, активируя main [который, в свою очередь, активирует child ]. Обратите внимание, что mainloop() расположен "внутри" класса main . Запустите window_03.py . Он должен сделать то же самое, что и предыдущий пример.

Если этот пример - ваша первая встреча с классами, объектами и т.п., в голову вполне может прийти мысль: "К чему такие сложности?" Но стоит нам перейти к более сложным примерам, как тотчас станет очевидно, что инкапсуляция кода внутрь классов - это отличный способ писать лаконичные, пригодные для многократного использования программы на Python. Потерпите немного. Некоторые из нас помнят, как учились составлять "макаронные" программы [ 'spaghetti' coding - слабо структурированные программы с большим размером процедур и интенсивным использованием оператора goto; трудны для изучения и модификаций (Электронный словарь ABBYY Lingvo 10).- Прим. пер. ], а потом изучали "структурное" программирование. Так что "объектно-ориентированное" программирование - это еще одна новинка.

Классы и элементы управления

Оставим на время разработку дочернего окна, чтобы сосредоточить все внимание на классах. Рассмотрим, как передавать классу информацию, и добавим к классу элемент управления [в данном случае кнопку (Button)] [и объект и окно].

В последнем примере [window_3.py] вас, возможно, удивило, что класс main содержит ссылку на переменную root , которая в программе еще не создана. Я сделал это специально, чтобы продемонстрировать, что классы ничего не делают, пока на их базе не будут созданы экземпляры объектов. Но есть лучший путь достичь того же самого. Объекту можно передать глобальную переменную root , и именно так сделано в нашем коде. Благодаря вызову main(root) параметр root передается переменной master класса main . В последующих примерах подобным же образом мы будем передавать классам множество различных параметров.

Ну, наконец и элемент управления. В Tkinter имеется определенное число графических элементов управления, которые можно размещать в нашем окне. В данном случае это будет кнопка (Button). Мы уже пользовались двумя элементами управления - Tk() и Toplevel() . Код self.button = Button(self.master, text = 'myButton') связывает элемент управления Button() с классом main [все элементы управления кроме Tk() кому-нибудь "принадлежат"], а text = 'myButton' задает значение свойства text [текст, который отобразится на кнопке во время исполнения программы].

Строка self.button.pack(side = BOTTOM) определяет, в какой части окна появится наша кнопка. Позже мы рассмотрим pack подробнее.

Между прочим, эта кнопка пока ничего не делает. Итак, запускаем window_04.py и нажимаем бесполезную кнопку.

Методы

Любая кнопка должна что-нибудь делать. В данном случае мы свяжем событие "нажатие кнопки" с открытием дочернего окна из одного из прошлых примеров. Для этого в класс main вводится метод openDialog , который создает экземпляр объекта child .

Для определения метода openDialog не нужна функция __init__() . Не создается экземпляра метода, - но метод создает экземпляр объекта child . Метод - это то, что класс main делает, а не то, чем класс main является. Обращение к openDialog содержит вездесущее self . Это означает, что метод openDialog является внутренним по отношению к main .

Toplevel() из класса child узнает о том, что относится к дочернему классу класса main , довольно мучительным путем. Tk() , связанный с root , передается классу main через параметр master [в main ], а затем пересылается другому параметру master [в child ]. Всякий класс имеет свою переменную master , локальную по отношению к данному классу. Их имена могут быть различными.

Ага! Метод. Запускаем window_05.py и испытываем работающую кнопку.

Модальное дочернее окно

В некоторых программах требуется для вывода информации создать дочернее окно, продолжая в тоже время использовать главное. При этом часто бывает нужно, чтобы все процессы, происходящие в дочернем окне, завершились до того, как вы продолжите работу. Такое окно называют модальным. Это значит, что оно будет удерживать фокус пока не будет закрыто. В Python дочернее окно можно превратить в модальное с помощью трех методов Toplevel() :

child перехватывает все события, происходящие в приложении.

child захватывает фокус.

child ждет, когда будет уничтожен текущий объект, не возобновляя работы [но и не оказывая влияния на основной цикл].

Итак, рецепт. Если нужно создать модальное окно, воспользуйтесь этими тремя методами. Как говорится, "Просто сделай это!"

• Поле для ввода текста в классе main .
• Текстовое окно в классе child для отображения введенной информации.
• Механизм передачи информации от текстового окна в main текстовому окну в child .

• side (сторона) определяет, какой стороны окна будет "держаться" элемент управления варианты: TOP (сверху) RIGHT (справа) LEFT (слева) BOTTOM (снизу)
  по умолчанию: NONE (никак)
• fill (заполнение) показывает, заполнит элемент доступное пространство или нет. варианты: X Y BOTH (X Y оба)
  по умолчанию: NONE (никак)
• expand (растяжение) указывает, будет ли элемент управления менять свой размер при изменении размеров окна. варианты: YES (да)
  по умолчанию: 0

Общение - хорошая штука, но оно должно быть улицей с двухсторонним движением.

Мы хотим, чтобы информация шла от родительского окна к дочернему И от дочернего к родительскому. Последнего можно добиться, добавив к дочернему окну кнопку accept и метод для регистрации всех изменений, произведенных в передаваемом тексте; также введем метод go как для создания экземпляра дочернего окна, так и для управления процессом обмена информацией. Такое применение методов [ go ] для открытия дочерних окон - полезный инструмент, который приобретет особую важность, когда мы будем иметь дело с более сложными операциями в последующих руководствах. Сейчас же он создает пустую переменную newValue , в которую будет записан измененный текст [если он был изменен].

При вызове дочернего метода go введенный текст вставляется в дочернее текстовое окно. Если текст редактировался и пользователь нажимает кнопку accept , исправленный текст возвращается как newValue . Если дочернее окно просто закрывается, newValue возвращается с пустым значением.

При возврате метод openDialog класса main осуществляет проверку. Если возвращаемая строка не пустая, возвращаемый текст будет вставлен в текстовое окно main .

Запускаем window_08.py . Убедитесь, что вы "уловили", как работает go . Нам придется еще довольно много иметь дело с этим методом.

Усложнение диалогов

window_09.py

Мы приближаемся к концу начала. Рассмотрим еще несколько приемов, которые будут использоваться позднее в "реальном" приложении: кнопки принятия (accept) и отмены (cancel), а также "перехват" закрытия основного окна с соответствующим диалогом.

Пока все просто. Размещение в дочерних диалоговых окнах кнопки отмены (cancel) - довольно стандартный прием. При этом происходит уничтожение дочернего окна без изменения newValue .

"Перехват" закрытия пользователем главного окна немного сложнее. Для чего это может потребоваться? Допустим, в случае текстового редактора нам бы хотелось фиксировать ситуации, когда не был сохранен измененный файл, чтобы предохранить пользователя от нечаянного уничтожения плодов всех его усилий из-за преждевременного закрытия окна.

Запустите window_09.py , чтобы увидеть нашу программу в действии.

Святой Грааль

Наша программа растет. У нас получается. И что еще более важно, ее части возможно использовать повторно. Класс yesno может быть применен еще раз в этом же приложении или даже в будущих приложениях. Итак, в коде, приводимом ниже, мы разбиваем программу на три отдельных модуля, которые будут храниться в трех отдельных автономных файлах.

Основной файл myWindow.py использует классы dialog и yesno так же, как и раньше, но, вместо того чтобы включить их в код, они импортируются из других файлов - myDialog.py и myBoolean.py .

Просмотрите завершающие части файлов myDialog.py и myBoolean.py . Там есть тестовая команда . Включать подобную команду в конец любого файла, который не выполняется напрямую, - стандартное правило. С помощью оператора if __name__ == '__main__': она проверяет, запущен файл из другой программы или сам по себе. В последнем случае открывается пустое окно, которое затем убирается с экрана командой root.withdraw() . Но именно к этому фиктивному окну привязывается рабочий код, позволяющий запускать данный файл. Это очень полезный инструмент для отладки. Использование тестов приводит к тому, что все модули становятся "исполняемыми".

Итак, запустим все три файла - myWindow.py , myDialog.py , myBoolean.py - и посмотрим, что произойдет.

Мини-руководство по Tkinter

Программа, которую мы составили, не сильно впечатляет - что-то вроде импровизации на тему "Hello World!". Предыдущая страница была названа "святым граалем" по двум причинам. Прежде всего, Python никак не связан со змеей. Это название взято из известного сериала Monty Python and the Quest for the Holy Grail. Кроме того, в легенде о Граале рассказывается о том, как нечто искали повсюду, и, когда, наконец, оно было найдено, оказалось, что ищущий обладал им с самого начала.

Это учебное руководство было написано пять или шесть лет тому назад. Тогда оно не было опубликовано, поскольку я посчитал его слишком примитивным. Позднее это руководство выручило меня самого, облегчив вспоминание Tkinter. Сейчас я сознаю, что оно уже содержало все необходимые идеи, чтобы начать использовать Tkinter для интересующих меня задач. Если вы похожи на меня, то будете применять Python для написания различных утилит, которые часто бывают полезны в повседневной жизни. Это превосходный язык для таких целей [а Tkinter - почти совершенный GUI]. Но для создания коммерческих мегапрограмм, чтобы заработать много денег, ни Python, ни Tkinter не годятся. [Как, впрочем, и само программирование в целом. Лучше идите учиться на менеджера!].

Перечислим элементы управления, с которыми мы уже успели познакомиться, вместе с их свойствами и методами, использованными в примерах. Общий стиль Tkinter - это размещение свойств внутри круглых скобок:
Имя_класса(свойство₁ = значение₁, свойство₂ = значение₂)
и использование методов в роли особых "точечных" команд:
Имя_класса.метод(параметры)

tkinter создание окна

Всем привет. Продолжим изучение библиотеки tkinter в python которая позволяет писать нам графический интерфейс. Тема сегодняшней статьи работа с окнами программы.

Рассмотрим следующий код:

Здесь мы создали главное окно программы. Заметьте что оно имеет определенные размеры и заголовок Tk.

Допустим мы хотим чтобы наше главное окно имело заголовок 'main' и размеры 400x400.

Для этого в библиотеке tkinter существует метод title() который устанавливает заголовок и minize(), устанавливает ширину и высоту окна.

Для того чтобы окну задать определенный фон мы можем воспользоваться элементом frame:

здесь через класс Frame мы создали элемент frame.

В класс мы передали следующие аргументы:

window - объект главного окна

width и height - ширина и высота(совпадают с параметрами главного окна)

bg - цвет фона(green - зеленный)

В результате цвет фона нашего главного окна стал зеленым. Сам по себе виджет frame представляет собой рамки с помощью которых мы можем более гибко структурировать данные в окне.

Мы нарисовали флаг Российской Федерации в самом центре нашего главного окна используя виджет Frame. Помимо всего прочего мы можем в фрейм помещать другие элементы.

Например здесь мы текстовое поле поместили в frame2

И напоследок мы рассмотрим как создавать дополнительные(дочерние окна).

Дочерние окна создаются с помощью класса Toplevel которому передается в качестве аргумента объект главного окна.

В данном примере мы создали дополнительное окно с размерами 400x200 и заголовком 'Дочернее окно'. Теперь мы можем обращаться и работать с ним через объект children. Отмечу что дочерних окон мы можем создавать сколько угодно.

Однако стоит помнить, что если мы закрываем наше главное окно, то все дочерние элементы закроются вместе с ним.

На этом данная статья подошла к концу. Надеюсь она была для вас полезной.

Желаю удачи и успехов! Пока!

Оцените статью:

Статьи

Комментарии

Внимание. Комментарий теперь перед публикацией проходит модерацию

Все комментарии отправлены на модерацию

Запись экрана

Данное расширение позволяет записывать экран и выводит видео в формате webm

Читайте также:

  
• Space engineers большая стальная труба как сделать
  
• Промывка радиатора печки без снятия своими руками уаз патриот
  
• Установка счетчика на столб своими руками
  
• Передавливатель для полиэтиленовых труб своими руками
  
• Как сделать в архикаде стены разной толщины