Python tkinter что такое root

Общий шаблон программ

   
 # создал главное окно (всегда называйте его root)

 # теперь окно будет отображено при запуске

"Создаёт окно по типу да-нет"

Работа с командной строкой

Всем доброго времени суток!

Tkinter – это кроссплатформенная библиотека для разработки графического интерфейса на языке Python (начиная с Python 3.0 переименована в tkinter). Tkinter расшифровывается как Tk interface, и является интерфейсом к Tcl/Tk.
Tkinter входит в стандартный дистрибутив Python.

Весь код в этой статье написан для Python 2.x.
Чтобы убедиться, что Tkinter установлен и работает, воспользуемся стандартной функцией Tkinter _test():

import Tkinter
Tkinter._test()

После выполнения данного кода должно появиться следующее окно:

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

Hello world

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

from Tkinter import *
root = Tk()

Да-да, всего одна строка, это вам не WinAPI (=. Теперь создадим кнопку, при нажатии на которую будет выводиться текст в консоль:

def Hello(event):
    print "Yet another hello world"

btn = Button(root,                  #родительское окно
             text="Click me",       #надпись на кнопке
             width=30,height=5,     #ширина и высота
             bg="white",fg="black") #цвет фона и надписи
btn.bind("<Button-1>", Hello)       #при нажатии ЛКМ на кнопку вызывается функция Hello
btn.pack()                          #расположить кнопку на главном окне
root.mainloop()

Всё просто, не так ли? Создаём экземпляр класса Button, указываем родителя и при желании список параметров. Есть еще немало параметров, таких как шрифт, толщина рамки и т.д.
Затем привязываем к нажатию на кнопку событие (можно привязать несколько разных событий в зависимости, например, от того, какой кнопкой мыши был нажат наш btn.
mainloop() запускает цикл обработки событий; пока мы не вызовем эту функцию, наше окно не будет реагировать на внешние раздражители.

Упаковщики

Функция pack() — это так называемый упаковщик, или менеджер расположения. Он отвечает за то, как виджеты будут располагаться на главном окне. Для каждого виджета нужно вызвать метод упаковщика, иначе он не будет отображён. Всего упаковщиков три:

pack(). Автоматически размещает виджеты в родительском окне. Имеет параметры side, fill, expand. Пример:

from Tkinter import *
root = Tk()
Button(root, text = '1').pack(side = 'left')
Button(root, text = '2').pack(side = 'top')
Button(root, text = '3').pack(side = 'right')
Button(root, text = '4').pack(side = 'bottom')
Button(root, text = '5').pack(fill = 'both')
root.mainloop()

grid(). Размещает виджеты на сетке. Основные параметры: row/column – строка/столбец в сетке, rowspan/columnspan – сколько строк/столбцов занимает виджет. Пример:

from Tkinter import *
root = Tk()
Button(root, text = '1').grid(row = 1, column = 1)
Button(root, text = '2').grid(row = 1, column = 2)
Button(root, text = '__3__').grid(row = 2, column = 1, columnspan = 2)
root.mainloop()

place(). Позволяет размещать виджеты в указанных координатах с указанными размерами.
Основные параметры: x, y, width, height. Пример:

from Tkinter import *
root = Tk()
Button(root, text = '1').place(x = 10, y = 10, width = 30)
Button(root, text = '2').place(x = 45, y = 20, height = 15)
Button(root, text = '__3__').place(x = 20, y = 40)
root.mainloop()

Теперь для демонстрации других возможностей Tkinter, напишем простейший

Текстовый редактор

Без лишних слов приведу код:

from Tkinter import *
import tkFileDialog

def Quit(ev):
    global root
    root.destroy()
    
def LoadFile(ev): 
    fn = tkFileDialog.Open(root, filetypes = [('*.txt files', '.txt')]).show()
    if fn == '':
        return
    textbox.delete('1.0', 'end') 
    textbox.insert('1.0', open(fn, 'rt').read())
    
def SaveFile(ev):
    fn = tkFileDialog.SaveAs(root, filetypes = [('*.txt files', '.txt')]).show()
    if fn == '':
        return
    if not fn.endswith(".txt"):
        fn+=".txt"
    open(fn, 'wt').write(textbox.get('1.0', 'end'))

root = Tk()

panelFrame = Frame(root, height = 60, bg = 'gray')
textFrame = Frame(root, height = 340, width = 600)

panelFrame.pack(side = 'top', fill = 'x')
textFrame.pack(side = 'bottom', fill = 'both', expand = 1)

textbox = Text(textFrame, font='Arial 14', wrap='word')
scrollbar = Scrollbar(textFrame)

scrollbar['command'] = textbox.yview
textbox['yscrollcommand'] = scrollbar.set

textbox.pack(side = 'left', fill = 'both', expand = 1)
scrollbar.pack(side = 'right', fill = 'y')

loadBtn = Button(panelFrame, text = 'Load')
saveBtn = Button(panelFrame, text = 'Save')
quitBtn = Button(panelFrame, text = 'Quit')

loadBtn.bind("<Button-1>", LoadFile)
saveBtn.bind("<Button-1>", SaveFile)
quitBtn.bind("<Button-1>", Quit)

loadBtn.place(x = 10, y = 10, width = 40, height = 40)
saveBtn.place(x = 60, y = 10, width = 40, height = 40)
quitBtn.place(x = 110, y = 10, width = 40, height = 40)

root.mainloop()

Здесь есть несколько новых моментов.

Во-первых, мы подключили модуль tkFileDialog для диалогов открытия/закрытия файла. Использовать их просто: нужно создать объект типа Open или SaveAs, при желании задав параметр filetypes, и вызвать его метод show(). Метод вернёт строку с именем файла или пустую строку, если пользователь просто закрыл диалог.

Во-вторых, мы создали два фрейма. Фрейм предназначен для группировки других виджетов. Один содержит управляющие кнопки, а другой — поле для ввода текста и полосу прокрутки.
Это сделано, чтобы textbox не налезал на кнопки и всегда был максимального размера.

В-третьих, появился виджет Text. Мы его создали с параметром wrap=’word’, чтобы текст переносился по словам. Основные методы Text: get, insert, delete. Get и delete принимают начальный и конечный индексы. Индекс — это строка вида ‘x.y’, где x — номер символа в строке, а y — номер строки, причём символы нумеруются с 1, а строки — с 0. То есть на самое начала текста указывает индекс ‘1.0’. Для обозначения конца текста есть индекс ‘end’. Также допустимы конструкции вида ‘1.end’.

B в-четвёртых, мы создали полосу прокрутки (Scrollbar). После создания её нужно связать с нужным виджетом, в данном случае, с textbox. Связывание двустороннее:

scrollbar['command'] = textbox.yview
textbox['yscrollcommand'] = scrollbar.set

Вот и всё. Tkinter – это, безусловно, мощная и удобная библиотека. Мы осветили не все её возможности, остальные — тема дальнейших статей.

Полезные ссылки:
http://ru.wikiversity.org
http://www.pythonware.com/

Python — один из самых лёгких и популярных языков программирования. С помощью python решается достаточно много проблем — он сможет помочь в почти любой ситуации. Сегодня речь пойдёт о встроенной библиотеке tkinter. С помощью tkinter создаётся уникальный графический интерфейс для приложения на python.

В этой статье:

Загрузка

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

Загрузка для windows:

pip install tkinter

pip install --update tkinter

либо на всё том же PyPi выбираете tkinter для Windows, macOS или Linux.

Синтаксис

Теперь надо разобраться с синтаксисом tkinter. Сначала импортируем:

from tkinter import *

Теперь наша задача — сделать окно приложения. Для этого выберем название приложения (у меня это My App). Запишем

from tkinter import *
#исходный код

if __name__ == '__main__':
  #выполнение кода до загрузки
  root = Tk()
  root.title('My App') #заголовок
  root.mainloop() #отображение окна

Сначала мы импортировали tkinter. После него идёт исходный код — виджеты, текст и тд. После if name == ‘main’ в отступах идёт код, который выполняется до загрузки, тоесть первее чем код в начале (не считая импорт). Сам код, который будет дальше, пишите до. .mainloop() отвечает за отображение окна — оно обязательно должно быть в конце кода. Если вы редактируете 2 окна, нужно ставить не в конец, а в начало кода второго окна (да я «очень хорошо» объясняю)

виджеты и текст

Теперь наша задача — ввести текст. Наше окно пока что пустое. Выглядит оно так:

Чтобы добавить и редактировать текст, нужно использовать виджет Label. Давайте попробуем записать

lbl1 = Label(root, text='Привет')
lbl1.grid(column=0, row=0)

Row отвечает за строку, а column за столбец. Правда, у некоторых могут возникнуть проблемы в том, что вторая строка сдвинута. Для этого изменим grid на place

lbl1.place(x=10,y=10)

Нужно всего лишь указать место по x и y. Для удобства можете задать отдельный класс для управления переменными

class wid_prm():
  #класс управления переменными
  x     = 10
  y1    = 10
  y2    = 30
  y3    = 50
  x_y_z = 410
  #...

lbl1 = Label(root, text='...')
lbl2 = Label(root, text='...')

#плейсы
lbl1.place(x=x,y=y1)
lbl2.place(x=x,y=y2)

Думаю, тут всё понятно. Местоположение по x нужно использовать одно, если вы хотите использовать один столбец. Думаю, не стоит тратить время, нужно автоматизировать управление переменными x, y

for auto_prm in range(5):
  y1 = 10
  y1 += 20
  y1 -= 10
  y1 -= 10
  if y1 == 30:
    #останавливаем процесс
    y1 = 30
  else:
    y2          = y1 + 20
    y3          = y1 + 40
    y4          = y1 + 60
    y5,y6,y7,y8 = y1 * 2 + (y1 * 4)
    y990 = 4
    if y990 > 1:
      x = 10
    else:
      x = 5

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

Давайте теперь сделаем шрифт жирным в Label

lbl1 = Label(root,text='...',font=("Times New Roman",21,"bold"))

Вы, наверное, уже поняли, что за шрифт отвечает функция font. «bold» можете убрать, если вы не хотите жирный шрифт текста. 21 — размер текста в пикселях/мм.

Теперь попробуем использовать виджет Button — добавим кнопку

btn1 = Button(root, text='Не нажимай', command=clicked)
btn1.place(x=x_x,y=y1_y)

def clicked():
  print('Я же сказал...')

При нажатии на кнопку будет писать определённый текст по команде clicked. Вы можете дать любое название и любое содержимое команды.

Получается, что полный код пока-что выглядит так:

from tkinter import * #импорт
#исходный код

class wid_prm():
  #класс управления переменными
  x     = 10
  y1    = 10
  y2    = 30
  y3    = 50
  x_y_z = 410
  for auto_prm in range(5):
    y1 = 10
    y1 += 20
    y1 -= 10
    y1 -= 10
    if y1 == 30:
      #останавливаем процесс
      y1 = 30
    else:
      y2          = y1 + 20
      y3          = y1 + 40
      y4          = y1 + 60
      y5,y6,y7,y8 = y1 * 2 + (y1 * 4)
      y990 = 4
      if y990 > 1:
        x = 10
      else:
        x = 5
class prm_x_y():
  x_x = 10
  y1_y = 50

lbl1 = Label(root, text='...')
btn1 = Label(root, text='Не нажимай', command=clicked)
def clicked():
  print('Я же сказал...')

#плейсы
lbl1.place(x=x,y=y1)
btn1.place(x=x_x,y=y1_y)

if __name__ == '__main__':
  root = Tk()
  root.title('My App')
  root.geometry('400x400')
  root.mainloop()

Виджет messagebox позволяет создать отдельное окно с информацией. Давайте попробуем

from tkinter import *
from tkinter import messagebox

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

Это довольно круто для дополнительных виджетов.

Я, наверное, с синтаксисом закончу.

Компиляция

Первым делом нужно установить приложение auto-py-to-exe. Вы его можете установить либо с того же PyPi, либо через командную строку:

pip install auto-py-to-exe

pip install --update auto-py-to-exe

Вы скачаете приложение auto-py-to-exe от python. Вот как оно выглядит:

В script location указываете путь к файлу. Вот небольшой пример:

>Path to file:
>\Users\username\Desktop\file.py

Дальше всё просто. Укажите One File, если не хотите, чтобы файлы приложения засоряли ваш пк. Если хотите скрыть консоль (и оставить только окно tkinter), выберите Window Based.

Загрузите иконку приложения в Icon. И наконец-то нажимаете CONVERT .PY TO .EXE. Думаю, с последующим вы сами справитесь — в консоль будет выводиться всякая всячина, и в итоге вы успешно сконвертируете приложение на tkinter.

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

from tkinter import *


self.root = Tk()
self.root.configure(bg="red", padx=10, pady=10)
self.root.title("WELCOME- PLEASE LOGIN)")

name = Label(self.root, text="Name:", bg="magenta")
password = Label(self.root, text="Password", bg="magenta")
nameentry = Entry(self.root)
passwordentry = Entry(self.root)

name.grid(row=0, sticky=E)
password.grid(row=1, sticky=E)
nameentry.grid(row=0, column=1)
passwordentry.grid(row=1, column=1)

mainloop()

A window opens but is blank.

from tkinter import *


root = Tk()
root.configure(bg="red", padx=10, pady=10)
root.title("WELCOME- PLEASE LOGIN)")

name = Label(root, text="Name:", bg="magenta")
password = Label(root, text="Password", bg="magenta")
nameentry = Entry(root)
passwordentry = Entry(root)

name.grid(row=0, sticky=E)
password.grid(row=1, sticky=E)
nameentry.grid(row=0, column=1)
passwordentry.grid(row=1, column=1)

mainloop()

This works fine.

Why is using self.root causing an error vs just root?

from tkinter import *


def __init__(self, Event= None):

    root = Tk()
    root.configure(bg="red", padx=10, pady=10)
    root.title("WELCOME- PLEASE LOGIN)")

    name = Label(root, text="Name:", bg="magenta")
    password = Label(root, text="Password", bg="magenta")
    nameentry = Entry(root)
    passwordentry = Entry(root)

    name.grid(row=0, sticky=E)
    password.grid(row=1, sticky=E)
    nameentry.grid(row=0, column=1)
    passwordentry.grid(row=1, column=1)

mainloop()

Causes this error using init:
AttributeError: ‘NoneType’ object has no attribute ‘tk’
Using self.root in place of root causes the same error. Removing event= None also causes this error.

Basically, I am confused on self.root vs root, definitions and their errors, and classes.

I’m not sure if you’ll find this answer satisfying, but you call root.mainloop() because root is the object that has the mainloop method. In the code you’ve given, App has no mainloop function.

In simpler terms, this is just how tkinter works — you always end your script by calling the mainloop method of the root window. When that method returns, your program will exit.

import Tkinter as tk
root = tk.Tk()
<your widgets go here>
root.mainloop()

Many people find that a pure procedural style is not an effective way to write code, so they might choose to write this in an object-oriented style. It’s natural to think of «the app» as a singleton object. There are many ways to do this — the one in your question is, unfortunately, not one of the clearer ways to do it.

A slightly better way, IMO, would be to structure the code like this:

class App(tk.Tk):
    def __init__(self, *args, **kwargs):
        tk.Tk.__init__(self, *args, **kwargs)
        <your widgets go here>
app = App()
app.mainloop()

In this case, mainloop is still being called, though now it’s a method of App since App inherits from Tk. It is conceptually the same as root.mainloop() since in this case, app is the root window even though it goes by a different name.

So, in both cases, mainloop is a method that belongs to the root window. And in both cases, it must be called for the GUI to function properly.

There is a third variation which is what the code you picked is using. And with this variation, there are several ways to implement it. The variation is your question uses a class to define the GUI, but does not inherit from Tk. This is perfectly fine, but you still must call mainloop at some point. Since you don’t create (or inherit) a mainloop function in your class, you must call the one associated with the root window. The variations I speak of are how and where the instance of App is added to the root window, and how mainloop is ultimately called.

Personally I prefer that App inherits from Frame, and that you pack the app outside the definition of the app. The template I use looks like this:

class App(tk.Frame):
    def __init__(self, *args, **kwargs):
        tk.Frame.__init__(self, *args, **kwargs)
        <your widgets go here>

if __name__ == "__main__":
    root = tk.Tk()
    app = App(root)
    app.pack(fill="both", expand=True)
    root.mainloop()

In this final example, app and root are two completely different objects. app represents a frame that exists inside the root window. Frames are commonly used this way, as a container for groups of other widgets.

So, in all cases, mainloop must be called. where it is called, and how, depends a bit on your coding style. Some people prefer to inherit from the root window, some don’t. In either case, you must call the mainloop function of the root window.

Summary: in this tutorial, you’ll learn step by step how to develop the Tkinter “Hello, World!” program.

Creating a window

 tkinter  tk

root = tk.Tk()
root.mainloop()  

How it works.

First, import the tkinter module as tk to the program:

 tkinter  tk  

Second, create an instance of the tk.Tk class that will create the application window:

root = tk.Tk()  

By convention, the main window in Tkinter is called root. But you can use any other name like main.

Third, call the mainloop() method of the main window object:

The mainloop() keeps the window visible on the screen. If you don’t call the mainloop() method, the window will display and disappear immediately. It will be so fast that you may not see its appearance.

Also, the mainloop() method keeps the window displaying and running until you close it.

Typically, you place the call to the mainloop() method as the last statement in a Tkinter program, after creating the widgets.

Troubleshooting

ImportError: No  named Tkinter  

sudo apt- install python3-tk  

Displaying a label

Now, it’s time to place a component on the window. In Tkinter, components are called widgets.

 tkinter  tk


root = tk.Tk()

# place a label on the root window
message = tk.Label(root, text=)
message.pack()

# keep the window displaying
root.mainloop()  

How it works.

widget = WidgetName(container, **options)  

In this syntax:

• The container is the parent window or frame where you want to place the widget.
• The options is one or more keyword arguments that specify the configurations of the widget.

message = tk.Label(root, text=)  

Fixing the blur UI on Windows

If you find the text and UI are blurry on Windows, you can use the ctypes Python library to fix it.

First import the ctypes module:

 ctypes  windll  

Second, call the SetProcessDpiAwareness() function:

:
     ctypes  windll

    windll.shcore.SetProcessDpiAwareness()
:
    root.mainloop()  

Summary

• Import tkinter module to create a Tkinter desktop application.
• Use Tk class to create the main window and call the mainloop() method to keep the window displays.
• In Tkinter, components are called widgets.

Did you find this tutorial helpful ?

Summary: in this tutorial, you’ll learn how to manipulate various attributes of a Tkinter window.

Let’s start with a simple program that consists of a window:

 tkinter  tk

root = tk.Tk()
root.mainloop()  

The root window has a title that defaults to tk. It also has three system buttons including Minimize, Maximize, and Close.

Let’s learn how to change the attributes of the root window.

Changing the window title

To change the window’s title, you use the title() method like this:

 tkinter  tk

root = tk.Tk()
root.title('Tkinter Window Demo')

root.mainloop()  

To get the current title of a window, you use the title() method with no argument:

title = window.title()  

Changing window size and location

In Tkinter, the position and size of a window on the screen is determined by geometry.

In this specification:

• The width is the window’s width in pixels.
• The height is the window’s height in pixels.
• The x is the window’s horizontal position. For example, +50 means the left edge of the window should be 50 pixels from the left edge of the screen. And -50 means the right edge of the window should be 50 pixels from the right edge of the screen.
• The y is the window’s vertical position. For example, +50 means the top edge of the window should be 50 pixels below the top of the screen. And -50 means the bottom edge of the window should be 50 pixels above the bottom of the screen.

To change the size and position of a window, you use the geometry() method:

 tkinter  tk


root = tk.Tk()
root.title('Tkinter Window Demo')
root.geometry()

root.mainloop()  

How it works.

• First, get the screen width and height using the winfo_screenwidth() and winfo_screenheight() methods.
• Second, calculate the center coordinate based on the screen and window width and height.
• Finally, set the geometry for the root window using the geometry() method.

Дополнительно:  Блокировать рекламу на андроиде в приложениях без root прав

If you want to get the current geometry of a window, you can use the geometry() method without providing any argument:

Resizing behavior

By default, you can resize the width and height of a window. To prevent the window from resizing, you can use the resizable() method:

The resizable() method has two parameters that specify whether the width and height of the window can be resizable.

 tkinter  tk

root = tk.Tk()
root.title('Tkinter Window Demo')
root.geometry()
root.resizable(, )

root.mainloop()  

When a window is resizable, you can specify the minimum and maximum sizes using the minsize() and maxsize() methods:

window.minsize(min_width, min_height)
window.maxsize(min_height, max_height)  

Transparency

Tkinter allows you to specify the transparency of a window by setting its alpha channel ranging from 0.0 (fully transparent) to 1.0 (fully opaque):

 tkinter  tk

root = tk.Tk()
root.title('Tkinter Window Demo')
root.geometry()
root.resizable(, )
root.attributes(, )

root.mainloop()  

Window stacking order

The window stack order refers to the order of windows placed on the screen from bottom to top. The closer window is on the top of the stack and it overlaps the one lower.

To ensure that a window is always at the top of the stacking order, you can use the -topmost attribute like this:

To move a window up or down of the stack, you can use the lift() and lower() methods:

 tkinter  tk


root = tk.Tk()
root.title('Tkinter Window Demo')
root.geometry()
root.resizable(, )
root.attributes(, )

root.mainloop()  

Changing the default icon

• Prepare an image in the .ico format. If you have the image in other formats like png or jpg, you can convert it to the .ico format. There are many online tools that allow you to do it quite easily.
• Place the icon in a folder that can be accessible from the program.
• Call the iconbitmap() method of the window object.

If you want to use the above icon, you can download it to your computer:

Summary

• Use the title() method to change the title of the window.
• Use the geometry() method to change the size and location of the window.
• Use the resizable() method to specify whether a window can be resizable horizontally or vertically.
• Use the window.attributes('-alpha',0.5) to set the transparency for the window.
• Use the window.attributes('-topmost', 1) to make the window always on top.
• Use lift() and lower() methods to move the window up and down of the window stacking order.
• Use the iconbitmap() method to change the default icon of the window.

Did you find this tutorial helpful ?

 tkinter  tk
root = tk.Tk()
root.mainloop()  

 tkinter  tk



    
        super().__init__()


 __name__ == :
    app = App()
    app.mainloop()  

   

 
      
        
          
        
        

     
          
          
          
        

            
                              
        

     
        "hi there, everyone!"

  
  

         
               \
                          
                
        

                     # по умолчанию в side="top"

   

 
      
        
        

          
        

        # Создать переменную приложения.
          
        # Установить для неё какое-нибудь значение.
        "this is a variable"
        # Сказать виджету ввода, чтобы он следил за этой переменной.
          

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

      
        "Hi. The current entry content is:"
              

  
  

   

 
      
        
        

# создать приложение
  


# вот вызовы метода для класса менеджера окон

"My Do-Nothing Application"
 

# запустить программу