Tkinter grid: Tkinter использование .grid() правильно — CodeRoad

Tkinter — grid() менеджер геометрии, как пользоваться — Разработка

import tkinter

from tkinter import Tk, Text, Label, Frame

import tk

«»»

Документация по grid()

https://www.tcl.tk/man/tcl/TkCmd/grid.html

https://tkdocs.com/tutorial/grid.html

https://www.pythontutorial.net/tkinter/tkinter-grid/

«»»

if __name__ == ‘__main__’:

    print(«** Hola Hey, Azzrael_YT subs!!!\n»)

    r = Tk()

    r.geometry(«+960+120»)

    args = {‘width’: 100, ‘height’: 100, ‘master’: r}

    # Frame(**args, bg=»red»).grid(row=0, column=0)

    # Frame(**args, bg=»green»).grid(row=0,column=1)

    # Frame(**args, bg=»blue»).grid(row=1, column=0)

    # Frame(**args, bg=»black»).grid(row=1,column=1)

    # xxxconfigure

    # r.columnconfigure(2, minsize=200)

    # r.columnconfigure(3, pad=10)

    # r.rowconfigure(0, weight=1)

    # Frame(**args, bg=»red»).grid(row=0, column=0)

    # Frame(**args, bg=»green»).grid(row=0,column=1)

    # Frame(**{**args, ‘height’:300}, bg=»green»).grid(row=0,column=1)

    # Frame(**args, bg=»blue»).grid(row=1, column=3)

    # Frame(**args, bg=»black»).grid(row=1,column=4)

    # columnspan, rowspan

    # Frame(**args, bg=»red»).grid(row=0, column=0)

    # Frame(r, width=50, height=200, bg=»green»).grid(row=0, column=1, rowspan=3)

    # Frame(**args, bg=»gray»).grid(row=1, column=1) # , sticky=»EW»)

    # Frame(**{**args, «width»:100}, bg=»blue»).grid(row=1, column=2) #, sticky=»EW»)

    # Frame(**args, bg=»black»).grid(row=1,column=3)

    # sticky — N+S+W+E, растягивается если WE, NS, в углы если NW etc.

    Frame(**args, bg=»red»).grid(row=0, column=0, sticky=»S»)

    Frame(r, width=300, height=300, bg=»green»).grid(row=0,column=1, columnspan=2)

    # Frame(**args, bg=»blue»).grid(row=1, column=1)

    Frame(**args, bg=»blue»).grid(row=1, column=1, sticky=tkinter.NSEW, columnspan=2)

    Frame(r, width=100, height=300,  bg=»gray»).grid(row=1,column=0)

    # Frame(r, width=100, height=300,  bg=»black»).grid(row=1,column=2)

    # Frame(r, width=100, height=300,  bg=»black»).grid(row=1,column=2, sticky=»WE»)

    r.mainloop()

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

Вы должны использовать grid_columnconfigure, чтобы придать столбцам в середине некоторый вес. Имея больший вес, чем другие столбцы, они будут расширяться и сжиматься, чтобы заполнить любое дополнительное пространство, которое у вас есть. Тем не менее, в вашем случае нет необходимости использовать сетку. Все в вашем GUI выровнено по определенным сторонам, для которых pack подходит более естественно. 

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

Разделяй и властвуй

Лучший способ сделать макет в Tkinter — «разделяй и властвуй». Начните с самых внешних виджетов и получайте их именно так, как вы хотите. Затем займитесь каждым из них по одному.

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

self.main_container = Frame(parent. background="bisque")
self.main_container.pack(side="top", fill="both", expand=True)

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

Далее у вас есть два кадра — top_frame и bottom_frame. По их именам и судя по тому, как вы пытались использовать сетку, я предполагаю, что они должны заполнить графический интерфейс в направлении х. Кроме того, я предполагаю, что верхний фрейм — это своего рода панель инструментов, а нижний фрейм — настоящая «основная» часть вашего графического интерфейса. Итак, давайте заставим нижний виджет занимать все лишнее пространство. 

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

    self.top_frame = Frame(self.main_container, background="green")
    self.bottom_frame = Frame(self.main_container, background="yellow")
    self.top_frame.pack(side="top", fill="x", expand=False)
    self.bottom_frame.pack(side="bottom", fill="both", expand=True)

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

    self.top_left = Frame(self.top_frame, background="pink")
    self.top_right = Frame(self.top_frame, background="blue")
    self.top_left.pack(side="left", fill="x", expand=True)
    self.top_right.pack(side="right", fill="x", expand=True)

Далее у вас есть «угловые» ярлыки. Опять же, поскольку контейнер представляет собой всего лишь одну строку виджетов, pack облегчает это. Поскольку вам нужны метки в углах, мы установим атрибут pack для каждого:

    self.top_left_label = Label(self.top_left, text="Top Left")
    self.top_right_label = Label(self.top_right, text="Top Right")
    self.top_left_label.pack(side="left")
    self.top_right_label.pack(side="right")

Наконец, у вас есть текстовый виджет. Он заполняет всю нижнюю рамку, поэтому еще раз — переменная — наш друг:

    self.text_box = Text(self.bottom_frame, height=5, width=40, background="gray")
    self.text_box.pack(side="top", fill="both", expand=True)

пачка или сетка?

Вы использовали grid для своего исходного кода и спросили, как это исправить. Почему я использовал pack для своих примеров? 

Когда вы используете sticky, все параметры конфигурации могут быть объединены в один вызов. С pack наряду с помещением виджетов в их контейнеры, вы также должны позаботиться о том, чтобы ваши столбцы и строки «весили», чтобы они правильно меняли размер. Когда вы просто размещаете виджеты друг над другом или выстраиваете их в ряд, pack использовать гораздо проще. 

В моих графических интерфейсах я почти всегда использую комбинацию grid и pack. Они оба мощные, и Excel в разных вещах. Единственное, что нужно помнить — и это очень важно — это то, что вы не можете использовать их в одном и том же родителе. Используя ваш код в качестве примера, вы не можете использовать grid для фрейма top_left и pack для фрейма top_right, поскольку оба они имеют одного и того же родителя. Однако вы {можете смешивать их в одном приложении.Еще раз, используя сетку.

Итак, возможно, вы действительно хотите использовать

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

Начните с основного кадра. Замените один оператор, в который мы упаковываем основной контейнер, следующими строками. Обратите внимание, что мы должны настраивать строки и столбцы в parent, а не в созданном нами фрейме.

self.main_container.grid(row=0, column=0, sticky="nsew")
self.myParent.grid_rowconfigure(0, weight=1)
self.myParent.grid_columnconfigure(0, weight=1)


self.top_frame.grid(row=0, column=0, sticky="ew")
self.bottom_frame.grid(row=1, column=0,sticky="nsew")
self.main_container.grid_rowconfigure(1, weight=1)
self.main_container.grid_columnconfigure(0, weight=1)


self.top_left.grid(row=0, column=0, sticky="w")
self.top_right.grid(row=0, column=2, sticky="e")
self.top_frame.grid_columnconfigure(1, weight=1)


    self.top_left_label.grid(row=0, column=0, sticky="w")
    self.top_right_label.grid(row=0, column=0, sticky="e")

self.text_box.grid(row=0, column=0, sticky="nsew")
self.bottom_frame.grid_rowconfigure(0, weight=1)
self.bottom_frame.grid_columnconfigure(0, weight=1)


pack требует еще несколько строк кода, но это правильный выбор, когда у вас действительно есть грид. В вашем случае вы уже подразделили свой графический интерфейс на разделы, и поэтому, хотя конечным результатом была сетка, каждый раздел был либо упакован сверху или снизу другого, либо по левому или правому краю. В этих случаях pack немного проще в использовании, так как вам не нужно беспокоиться о весе строк и столбцов. 
As you can see, grid requires a few more lines of code but it's the right choice when you really do have a grid. In your case you had already sub-divided your GUI into sections, and so even though the end result was a grid, each section was either packed on top or below another, or to the left or right edges. In these cases, pack is a bit easier to use since you don't have to worry about row and column weights. 

Модуль tkinter | Кодкамп

Введение

Примеры

Минимальное приложение tkinter

tkinter представляет собой графический инструментарий , который предоставляет обертку вокруг библиотеки Tk / Tcl GUI и входит в Python. Следующий код создает новое окно с помощью tkinter и помещает текст в окне тела.

Примечание. В Python 2 заглавные буквы могут немного отличаться, см. Раздел «Примечания» ниже.

 import tkinter as tk

# GUI window is a subclass of the basic tkinter Frame object
class HelloWorldFrame(tk.Frame):
    def __init__(self, master):
        # Call superclass constructor
        tk.Frame.__init__(self, master)
        # Place frame into main window
        self.grid()
        # Create text box with "Hello World" text
        hello = tk.Label(self, text="Hello World! This label can hold strings!")
        # Place text box into frame
        hello.grid(row=0, column=0)

# Spawn window
if __name__ == "__main__":
    # Create main window object
    root = tk.Tk()
    # Set title of window
    root.title("Hello World!")
    # Instantiate HelloWorldFrame object
    hello_frame = HelloWorldFrame(root)
    # Start GUI
    hello_frame.mainloop() 

Менеджеры по геометрии

Tkinter имеет три механизма для управления геометрией: place , pack и grid .

place менеджер использует абсолютные координаты пикселя.

pack менеджер размещает виджеты в один из 4 -х сторон. Новые виджеты размещаются рядом с существующими виджетами.

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

Наиболее распространенные ключевые аргументы для widget.place заключаются в следующем:

• x , абсолютные координаты х виджета
• y , абсолютное у-координаты виджета
• height , абсолютная высота виджета
• width , абсолютная ширина виджета

Пример кода , используя place :

 class PlaceExample(Frame):
    def __init__(self,master):
        Frame.__init__(self,master)
        self.grid()
        top_text=Label(master,text="This is on top at the origin")
        #top_text.pack()
        top_text.place(x=0,y=0,height=50,width=200)
        bottom_right_text=Label(master,text="This is at position 200,400")
        #top_text.pack()
        bottom_right_text.place(x=200,y=400,height=50,width=200)
# Spawn Window
if __name__=="__main__":
    root=Tk()
    place_frame=PlaceExample(root)
    place_frame.mainloop()
 

widget.pack может принимать следующие именованные аргументы:

• expand , или не заполнять оставленное родителю пространство
• fill , следует ли расширить , чтобы заполнить все пространство (NONE ( по умолчанию), X, Y, или ОБА)
• side , сторона паковать против (TOP ( по умолчанию), НИЖНИЙ, ЛЕВЫЙ или ПРАВЫЙ)

Наиболее часто используемые ключевые слова , аргументы widget.grid заключаются в следующем:

• row , строка виджета ( по умолчанию наименьшее незанятым)
• rowspan , количество colums виджета пролеты ( по умолчанию 1)
• column , столбец виджета ( по умолчанию 0)
• columnspan , число столбцов виджета пролеты ( по умолчанию 1)
• sticky , где поместить виджет , если ячейка сетки больше , чем (комбинация N, NE, E, SE, S, SW, W, NW)

Строки и столбцы проиндексированы нулями. Строки увеличиваются при спуске, а столбцы — при движении вправо.

Пример кода с использованием grid :

 from tkinter import *

class GridExample(Frame):
    def __init__(self,master):
        Frame.__init__(self,master)
        self.grid()
        top_text=Label(self,text="This text appears on top left")
        top_text.grid() # Default position 0, 0
        bottom_text=Label(self,text="This text appears on bottom left")
        bottom_text.grid() # Default position 1, 0
        right_text=Label(self,text="This text appears on the right and spans both rows",
                         wraplength=100)
        # Position is 0,1
        # Rowspan means actual position is [0-1],1
        right_text.grid(row=0,column=1,rowspan=2)

# Spawn Window
if __name__=="__main__":
    root=Tk()
    grid_frame=GridExample(root)
    grid_frame.mainloop()

 

Никогда не смешивайте pack и grid в том же кадре! Это приведет к тупику приложения!

Синтаксис

Параметры

Примечания

python — Масштабирование виджетов Tkinter

Вы хотите настроить строки /столбцы так, чтобы они имели weight, чтобы они могли расширяться при изменении размера окна. Кроме того, вы хотите, чтобы виджеты располагались sticky по бокам их ячеек. frame строки /столбцы нуждаются не только в weight, но также все строки и столбцы внутри frame, следовательно, for loop.

from Tkinter import *

class MyFrame(Frame):
    def __init__(self, master):
        Frame.__init__(self, master)
        self.grid(row=0, column=0, sticky=N+S+E+W)
        #Give the grid, column of the frame weight...
        Grid.rowconfigure(master, 0, weight=1)
        Grid.columnconfigure(master, 0, weight=1)
        self.create_widgets()

    def create_widgets(self):
        #Give the grid, column of each widget weight...
        for rows in xrange(3):
            Grid.rowconfigure(self, rows, weight=1)
        for columns in xrange(1):
            Grid.columnconfigure(self, columns, weight=1)

        self.label = Label(self, text="This is a test")
        self.label.grid(row=0, column=0, sticky=N+S+E+W)

        self.mytext1 = Text(self, width=30, height=5)
        self.mytext1.grid(row=1, column=0, sticky=N+S+E+W)

        self.mytext2 = Text(self, width=30, height=5)
        self.mytext2.grid(row=2, column=0, sticky=N+S+E+W)


root = Tk()
app = MyFrame(root)
root.mainloop()

Ваш основной frame выглядит следующим образом:

from Tkinter import *

#Sets up a frame
class MyApplication(Frame):

    #When a class is initialized, this is called as per any class 
    def __init__(self, master):

        #Similar to saying MyFrame = Frame(master)
        Frame.__init__(self, master)

        #Puts the frame on a grid. If you had two frames on one window, you would do the row, column keywords (or not...)
        self.grid()

        #Function to put the widgets on the frame. Can have any name!
        self.create_widgets()

    def create_widgets(self):
        label = Label(self, text='Hello World!')
        label.grid()

        button = Button(self, text='Press Me!', command=self.hello)
        button.grid()

   def hello(self):
        print "Hello World!"

root = Tk()
app = MyApplication(root)
root.mainloop()

Любой виджет Tkinter можно обрабатывать подобным образом с учетом шаблонов (у меня была программа, в которой мне нужно было несколько записей с одинаковым поведением (нажмите кнопку, чтобы очистить текст по умолчанию, нажмите кнопку выключения, чтобы вернуть его, если ничего не было введено), и вместо добавления привязки к каждому, я смог создать класс записей, которые действовали одинаково) и простую реализацию toplevels (дополнительные окна). Вот пример более сложной программы:

class IntroScreen(Frame):
    def __init__(self, master):
        Frame.__init__(self, master)
        self.grid()
        self.title('Intro Screen')
        self.create_widgets()
        self.focus_force()

    def create_widgets(self):
        label = Label(self, text='Hello World!')
        label.grid()

        button = Button(self, text='Open Window', command=self.newWindow)
        button.grid()

   def newWindow(self):
        self.toplevel = InfoWindow()

#Like the frame, or any widget, this inherited from the parent widget
class InfoWindow(Toplevel):
    def __init__(self):
        Toplevel.__init__(self)
        self.grid()
        self.create_widgets()
        self.focus_force()

    def create_widgets(self):
        label = Label(self, text='This is a window!')
        label.grid()

root = Tk()
app = IntroScreen(root)
root.mainloop()

Как видите, это добавило функциональность, которая была бы намного сложнее без классов. Ищите больше ответов на stackoverflow (я рекомендую многочисленные и информативные ответы Брайана Оукли) и проведите некоторое исследование в Интернете, если вы собираетесь углубиться в мощную функциональность Tkinter!

PS: вот хорошее место для начала: Переключение между двумя кадрами в tkinter

Python | Позиционирование элементов

Позиционирование элементов

Последнее обновление: 13.05.2017

Метод pack

Для позиционирования элементов в окне применяются различные способы, и самый простой способ представляет вызов у элемента метода pack().
Этот метод принимает следующие параметры:

• expand: если равно True, то виджет заполняет все пространство контейнера.

• fill: определяет, будет ли виджет растягиваться, чтобы заполнить свободное пространство вокруг. Этот параметр может принимать следующие значения:
  NONE (по умолчанию, элемент не растягивается), X (элемент растягивается только по горизонтали), Y (элемент растягивается только по вертикали) и
  BOTH (элемент растягивается по вертикали и горизонтали).

• side: выравнивает виджет по одной из сторон контейнера. Может принимать значения: TOP (по умолчанию, выравнивается по верхней стороне контейнера),
  BOTTOM (выравнивание по нижней стороне), LEFT (выравнивание по левой стороне), RIGHT (выравнивание по правой стороне).

Например, растянем кнопку на всю форм, используя параметры expand и fill:

from tkinter import *

root = Tk()
root.title("GUI на Python")
root.geometry("300x250")

btn1 = Button(text="CLICK ME", background="#555", foreground="#ccc",
              padx="15", pady="6", font="15")
btn1.pack(expand = True, fill=BOTH)

root.mainloop()

Используем параметр side:

from tkinter import *

root = Tk()
root.title("GUI на Python")
root.geometry("300x250")

btn1 = Button(text="BOTTOM", background="#555", foreground="#ccc",
              padx="15", pady="6", font="15")
btn1.pack(side=BOTTOM)

btn2 = Button(text="RIGHT", background="#555", foreground="#ccc",
             padx="15", pady="6", font="15")
btn2.pack(side=RIGHT)

btn3 = Button(text="LEFT", background="#555", foreground="#ccc",
             padx="15", pady="6", font="15")
btn3.pack(side=LEFT)

btn4 = Button(text="TOP", background="#555", foreground="#ccc",
             padx="15", pady="6", font="15")
btn4.pack(side=TOP)

root.mainloop()

Комбинируя параметры side и fill, можно растянуть элемент по вертикали:

btn1 = Button(text="CLICK ME", background="#555", foreground="#ccc",
              padx="15", pady="6", font="15")
btn1.pack(side=LEFT, fill=Y)

Метод place

Метод place() позволяет более точно настроить параметры позиционирования. Он принимает следующие параметры:

• height и width: устанавливают соответственно высоту и ширину элемента в пикселях

• relheight и relwidth: также задают соответственно высоту и ширину элемента, но в качестве значения
  используется число float в промежутке между 0.0 и 1.0, которое указывает на долю от высоты и ширины родительского контейнера

• x и y: устанавливают смещение элемента по горизонтали и вертикали в пикселях соответственно относительно верхнего левого угла контейнера

• relx и rely: также задают смещение элемента по горизонтали и вертикали, но в качестве
  значения используется число float в промежутке между 0.0 и 1.0, которое указывает на долю от высоты и ширины родительского контейнера

• bordermode: задает формат границы элемента. Может принимать значение INSIDE (по умолчанию) и OUTSIDE

• anchor: устанавливает опции растяжения элемента. Может принимать значения n, e, s, w, ne, nw, se, sw, c, которые являются сокращениями от Noth(север — вверх),
  South (юг — низ), East (восток — правая сторона), West (запад — левая сторона) и Center (по центру). Например, значение nw указывает на верхний левый угол

Например, разместим кнопку с шириной 130 пикселей и высотой 30 пикселей в центре окна:

from tkinter import *

clicks = 0


def click_button():
    global clicks
    clicks += 1
    btn.config(text="Clicks {}".format(clicks))

root = Tk()
root.title("GUI на Python")
root.geometry("300x250")


btn = Button(text="Clicks 0", background="#555", foreground="#ccc",
             padx="20", pady="8", font="16", command=click_button)
btn.place(relx=.5, rely=.5, anchor="c", height=30, width=130, bordermode=OUTSIDE)

root.mainloop()

Следует заметить, что при использовании метода place() не надо использовать метод pack(), чтобы сделать элемент видимым.

Или разместим три кнопки:

from tkinter import *

root = Tk()
root.title("GUI на Python")
root.geometry("300x250")

btn1 = Button(text="x=10, y=20", background="#555", foreground="#ccc", padx="14", pady="7", font="13")
btn1.place(x=10, y=20)

btn2 = Button(text="x=50, y=100", background="#555", foreground="#ccc", padx="14", pady="7", font="13")
btn2.place(x=50, y=100)

btn3 = Button(text="x=140, y=160", background="#555", foreground="#ccc", padx="14", pady="7", font="13")
btn3.place(x=140, y=160)

root.mainloop()

Метод grid

Метод grid применяет другой подход к позиционированию элементов, нежели метод place, позволяя поместить элемент в определенную ячейку условной сетки или грида.

Метод grid применяет следующие параметры:

• column: номер столбца, отсчет начинается с нуля

• row: номер строки, отсчет начинается с нуля

• columnspan: сколько столбцов должен занимать элемент

• rowspan: сколько строк должен занимать элемент

• ipadx и ipady: отступы по горизонтали и вертикали соответственно от границ элемента до его текста

• padx и pady: отступы по горизонтали и вертикали соответственно от границ ячейки грида до границ элемента

• sticky: выравнивание элемента в ячейке, если ячейка больше элемента. Может принимать значения n, e, s, w, ne, nw, se, sw, которые указывают
  соответствующее направление выравнивания

Например, определим грид из 9 кнопок:

from tkinter import *

root = Tk()
root.title("GUI на Python")
root.geometry("300x250")

for r in range(3):
    for c in range(3):
        btn = Button(text="{}-{}".format(r,c))
        btn.grid(row=r, column=c, ipadx=10, ipady=6, padx=10, pady=10)

root.mainloop()

Введение в Tkinter / Хабр

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

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. Работа с изображениями в tkinter.

На уроке Python. Работа с изображениями мы с вами научились загружать и отображать картинки, а также всяко извращаться с ними. Это мы делали при помощи библиотеки PIL.  На уроке Python. GUI мы с вами при помощи библиотеки tkinter создавали виндовый интерфейс программы: всякие кнопочки, флажки, и прочие элементы управления. Но возникает вопрос: а нельзя ли при помощи tkinter как-то выводить изображение на виндовую форму? Можно. Например вот такая программа:

import tkinter
from PIL import Image, ImageTk

root = tkinter.Tk()

# создаем рабочую область
frame = tkinter.Frame(root)
frame.grid()

#Добавим метку
label = tkinter.Label(frame, text="Hello, World!").grid(row=1,column=1)


# вставляем кнопку
but = tkinter.Button(frame, text="Кнопка").grid(row=1, column=2)

#Добавим изображение
canvas = tkinter.Canvas(root, height=400, width=700)
image = Image.open("d:/3/Dscn0116.jpg")
photo = ImageTk.PhotoImage(image)
image = canvas.create_image(0, 0, anchor='nw',image=photo)
canvas.grid(row=2,column=1)
root.mainloop()

выдаст вот такое окно:

Что интересно, PIL здесь нужен, чтобы загружать изображения типа jpg, gif-ы и png можно открыть и без него:

import tkinter

root = tkinter.Tk()

# создаем рабочую область
frame = tkinter.Frame(root)
frame.grid()

#Добавим метку
label = tkinter.Label(frame, text="Hello, World!").grid(row=1,column=1)


# вставляем кнопку
but = tkinter.Button(frame, text="Кнопка").grid(row=1, column=2)

#Добавим изображение
canvas = tkinter.Canvas(root, height=400, width=700)
img = tkinter.PhotoImage(file = 'd:/3/Dscn0116.png') 
image = canvas.create_image(0, 0, anchor='nw',image=img)
canvas.grid(row=2,column=1)
root.mainloop()

А теперь попробуем при нажатии на кнопку сменить изображение:

import tkinter
from PIL import Image, ImageTk

root = tkinter.Tk()

# создаем рабочую область
frame = tkinter.Frame(root)
frame.grid()

# Добавим метку
label = tkinter.Label(frame, text="Hello, World!").grid(row=1, column=1)

image = Image.open("d://1//DSCN1128.png")
photo = ImageTk.PhotoImage(image)


def my_event_handler():
    print("my_event_handler")
    image = Image.open("d://1//original.jpg")
    photo = ImageTk.PhotoImage(image)
    image = canvas.create_image(0, 0, anchor='nw', image=photo)
    canvas.grid(row=2, column=1)


# вставляем кнопку
but = tkinter.Button(frame, text="Кнопка", command=my_event_handler).grid(row=1, column=2)

# Добавим изображение
canvas = tkinter.Canvas(root, height=400, width=700)
image = canvas.create_image(0, 0, anchor='nw', image=photo)
canvas.grid(row=2, column=1)
root.mainloop()

Но не тут то было. При нажатии на кнопку изображение не меняется. Хотя, казалось бы, все написано правильно, и наш обработчик событий работает, наше сообщение, что мы выводим командой print выводится в окно сообщений. В чем же дело? А дело в сборщике мусора (garbage collector). Как только мы вышли из my_event_handler, локальные переменные тут же уничтожаются сборщиком мусора. Именно поэтому мы видим на форме ту же самую картинку, что и до нажатия на кнопку. Как же быть? Не использовать локальные переменные. Давайте объявим класс, пусть изображение и прочие объекты хранятся в его полях:

import tkinter
from PIL import Image, ImageTk

class App:
    def __init__(self):
        self.root = tkinter.Tk()

        # создаем рабочую область
        self.frame = tkinter.Frame(self.root)
        self.frame.grid()

        # Добавим метку
        self.label = tkinter.Label(self.frame, text="Hello, World!").grid(row=1, column=1)

        self.image = Image.open("d://1//DSCN1128.png")
        self.photo = ImageTk.PhotoImage(self.image)

        # вставляем кнопку
        self.but = tkinter.Button(self.frame, text="Кнопка", command=self.my_event_handler).grid(row=1, column=2)

        # Добавим изображение
        self.canvas = tkinter.Canvas(self.root, height=600, width=700)
        self.c_image = self.canvas.create_image(0, 0, anchor='nw', image=self.photo)
        self.canvas.grid(row=2, column=1)
        self.root.mainloop()

    def my_event_handler(self):
        print("my_event_handler")
        self.image = Image.open("d://1//original.jpg")
        self.photo = ImageTk.PhotoImage(self.image)
        self.c_image = self.canvas.create_image(0, 0, anchor='nw', image=self.photo)
        self.canvas.grid(row=2, column=1)

app= App()

Теперь все работает.

Tkinter Grid Geometry Manager

Резюме : в этом руководстве вы узнаете, как использовать диспетчер геометрии сетки Tkinter для размещения виджетов в окне.

Введение в диспетчер геометрии сетки Tkinter

Диспетчер геометрии сетки использует концепции строк и столбцов для упорядочивания виджетов.

Ниже показана сетка, состоящая из четырех строк и трех столбцов:

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

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

Например, у вас может быть сетка с индексами столбцов 1, 2, 10, 11 и 12. Это полезно, когда вы планируете добавить больше виджетов в середине сетки позже.

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

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

Ширина столбца зависит от ширины содержащегося в нем виджета. Точно так же высота строки зависит от высоты виджетов, содержащихся в строке.

Строки и столбцы могут охватывать. На следующем рисунке показана сетка с ячейкой (1,1), занимающей два столбца, и ячейкой (0,2), занимающей две строки:

Настройка сетки

Перед размещением виджетов в сетке вам потребуется для настройки строк и столбцов сетки.

Tkinter предоставляет вам два метода настройки строк и столбцов сетки:

 
  container.columnconfigure (index, weight)
container.rowconfigure (index, weight)  
  Язык кода: CSS (css)  

Метод columnconfigure () настраивает столбец , индекс сетки.

Вес определяет ширину столбца по отношению к другим столбцам.

Например, столбец с весом 2 будет вдвое шире столбца с весом 1.

Размещение виджета в сетке

Чтобы разместить виджет в сетке, вы используете сетку виджета () метод:

 
  widget.grid (** параметры)  
  Язык кода: Python (python)  

Метод grid () имеет следующие параметры:

Прикрепленный

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

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

Значение липкого имеет следующие допустимые значения:

Если вы хотите разместить виджет в углу ячейки, вы можете использовать N, S, E и W.

В следующем примере показано, как расположить виджет с параметром прикрепления, установленным на N :

Если вы хотите разместить виджет по центру одной стороны ячейки, вы можете использовать NW (вверху слева), NE (вверху справа), SE (внизу справа) и SW (внизу слева).

В следующем примере показано, как позиционировать виджет с параметром закрепления, установленным на NW :

NS растягивает виджет по вертикали. Однако он оставляет виджет центрированным по горизонтали:

EW растягивает виджет по горизонтали. Однако он оставляет виджет центрированным по вертикали:

Padding

Чтобы добавить отступы между ячейками сетки, вы используете параметры padx и pady . padx и pady — это внешние отступы:

 
  сетка (столбец, строка, липкий, padx, pady)  
  Язык кода: Python (python)  

Чтобы добавить отступы внутри самого виджета, вы используйте варианты ipadx и ipady . ipadx и ipady — это внутренние отступы:

 
  сетка (столбец, строка, липкая, padx, pady, ipadx, ipady)  
  Язык кода: Python (python)  

Внутренние и внешние отступы по умолчанию — ноль.

Пример диспетчера геометрии сетки Tkinter

В этом примере мы будем использовать диспетчер геометрии сетки для создания экрана входа в систему следующим образом:

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

Ниже показано полное окно входа в систему:

 
  import tkinter as tk
из tkinter import ttk


корень = tk.Tk ()
root.geometry ("240x100")
root.title ('Логин')
root.resizable (0, 0)


root.columnconfigure (0, вес = 1)
root.columnconfigure (1, вес = 3)



username_label = ttk.Label (root, text = "Имя пользователя:")
username_label.grid (column = 0, row = 0, sticky = tk.W, padx = 5, pady = 5)

username_entry = ttk.Entry (корень)
имя_пользователя.сетка (столбец = 1, строка = 0, липкий = tk.E, padx = 5, pady = 5)


password_label = ttk.Label (root, text = "Пароль:")
password_label.grid (столбец = 0, строка = 1, липкий = tk.W, padx = 5, pady = 5)

password_entry = ttk.Entry (root, show = "*")
password_entry.grid (столбец = 1, строка = 1, липкий = tk.E, padx = 5, pady = 5)


login_button = ttk.Button (root, text = "Войти")
login_button.grid (столбец = 1, строка = 3, липкий = tk.E, padx = 5, pady = 5)


root.mainloop ()
  
  Язык кода: Python (python)  

Как это работает.

Сначала используйте метод columnconfigure () , чтобы установить вес первого и второго столбцов сетки.Ширина второго столбца в три раза больше ширины первого столбца.

 
  root.columnconfigure (0, вес = 1)
root.columnconfigure (1, weight = 3)  
  Язык кода: Python (python)  

Во-вторых, поместите метку имени пользователя в первый столбец, а запись имени пользователя во второй столбец первой строки сетки:

 
  username_label = ttk.Label (root, text = "Имя пользователя:")
username_label.grid (column = 0, row = 0, sticky = tk.W, padx = 5, пады = 5)

username_entry = ttk.Entry (корень, текстовая переменная = имя пользователя)
username_entry.grid (column = 1, row = 0, sticky = tk.E, padx = 5, pady = 5  
  Язык кода: Python (python)  

В-третьих, разместите метку пароля и ввод на первом и второй столбец второй строки:

 
  password_label = ttk.Label (root, text = "Пароль:")
password_label.grid (столбец = 0, строка = 1, липкий = tk.W, padx = 5, pady = 5)

password_entry = ttk.Entry (root, textvariable = password, show = "*")
password_entry.grid (column = 1, row = 1, sticky = tk.E, padx = 5, pady = 5)  
  Язык кода: Python (python)  

Наконец, поместите кнопку входа в систему в третьей строке. Поскольку для параметра залипания установлено значение E , кнопка выровнена по правому краю третьей строки.

 
  login_button = ttk.Button (root, text = "Login")
login_button.grid (column = 1, row = 3, sticky = tk.E, padx = 5, pady = 5)  
  Язык кода: Python (python)  

Ниже показана та же программа.Однако вместо этого он использует объектно-ориентированное программирование:

 
  import tkinter as tk
из tkinter import ttk


класс App (т.к.
    def __init __ (сам):
        супер () .__ init __ ()

        self.geometry ("240x100")
        self.title ('Логин')
        self.resizable (0, 0)

        
        self.columnconfigure (0, вес = 1)
        self.columnconfigure (1, вес = 3)

        self.create_widgets ()

    def create_widgets (сам):
        
        username_label = ttk.Label (self, text = "Имя пользователя:")
        username_label.сетка (столбец = 0, строка = 0, липкий = tk.W, padx = 5, pady = 5)

        username_entry = ttk.Entry (сам)
        username_entry.grid (column = 1, row = 0, sticky = tk.E, padx = 5, pady = 5)

        
        password_label = ttk.Label (self, text = "Пароль:")
        password_label.grid (столбец = 0, строка = 1, липкий = tk.W, padx = 5, pady = 5)

        password_entry = ttk.Entry (self, show = "*")
        password_entry.grid (столбец = 1, строка = 1, липкий = tk.E, padx = 5, pady = 5)

        
        login_button = ttk.Button (self, text = "Войти")
        login_button.сетка (столбец = 1, строка = 3, липкий = tk.E, padx = 5, pady = 5)


если __name__ == "__main__":
    app = Приложение ()
    app.mainloop ()
  
  Язык кода: Python (python)  

Сводка

• Используйте методы columnconfigure (), и rowconfigure () , чтобы указать вес столбца и строки сетки.
• Используйте метод grid () для размещения виджета в сетке.
• Используйте опцию sticky , чтобы выровнять положение виджета в ячейке и определить, как виджет будет растягиваться.
• Используйте ipadx , ipady и padx , pady , чтобы добавить внутренние и внешние отступы.

Вы нашли это руководство полезным?

tkinter Tutorial => grid ()

Пример

Сетка () Менеджер геометрии организует виджеты в виде таблицы в родительском виджете. Главный виджет разделен на строки и столбцы, и каждая часть таблицы может содержать виджет.Он использует столбца , столбца , ipadx , ipady , padx , pady , row , rowspan и sticky .

Синтаксис

widget.grid (опции)

Колонка
Столбец, в который нужно поместить виджет. Столбец по умолчанию — 0, это крайний левый столбец.

Размах колонн
Сколько столбцов занимает виджет.По умолчанию 1.

.

IPadx
Сколько пикселей разместить виджет по горизонтали внутри границ виджета.

Ипады
Сколько пикселей разместить виджет по вертикали внутри границ виджета.

Padx
Сколько пикселей разместить виджет по горизонтали за пределами виджета.

Пады
Сколько пикселей разместить виджет по вертикали за пределами виджета.

ряд
Строка, в которую нужно поместить виджет.Строка по умолчанию — 0, это самый верхний столбец.

Рядный
Сколько строк занимает виджет. По умолчанию 1.

.

Клейкий
Когда виджет меньше ячейки, липкий используется, чтобы указать, к каким сторонам и углам ячейки прикрепляется виджет. Направление определяется по компасу: N, E, S, W, NE, NW, SE, SW и ноль. Это может быть конкатенация строк, например, NESW заставляет виджет занимать всю область ячейки.

Пример

  из tkinter import *
корень = Tk ()
btn_column = Button (root, text = "Я в столбце 3")
btn_column.grid (столбец = 3)

btn_columnspan = Button (root, text = "У меня размер столбцов 3")
btn_columnspan.grid (columnspan = 3)

btn_ipadx = Кнопка (root, text = "ipadx of 4")
btn_ipadx.grid (ipadx = 4)

btn_ipady = Кнопка (root, text = "ipady of 4")
btn_ipady.grid (ipady = 4)

btn_padx = Кнопка (root, text = "padx of 4")
btn_padx.сетка (padx = 4)

btn_pady = Кнопка (root, text = "pady of 4")
btn_pady.grid (pady = 4)

btn_row = Button (root, text = "Я в строке 2")
btn_row.grid (строка = 2)

btn_rowspan = Кнопка (root, text = "Диапазон строк из 2")
btn_rowspan.grid (rowspan = 2)

btn_sticky = Button (root, text = "Я застрял на северо-востоке")
btn_sticky.grid (липкий = NE)

root.mainloop ()
  

Результат

Python | grid () в Tkinter

из tkinter import * из tkinter.ttk импорт *

мастер = Tk ()

l1 = Этикетка (мастер, текст = "Высота " )

l2 = Этикетка (мастер, текст = " Ширина " )

l1 grid (строка = 0 , столбик = 0 , липкий = Вт, пади = 2 )

l2.сетка (строка = 1 , столбец = 0 , липкий = W, pady = 2 )

e1 = Запись (главная)

e2 = Запись (главная)

e1.grid (строка = 0 , столбец = 1 , пады = 2 )

e2.сетка (строка = 1 , столбец = 1 , pady = 2 )

c1 = Флажок (мастер, текст = «Сохранить» )

c1.grid (строка = 2 , столбец = 0 , липкий = W, интервал столбца = 2 )

img = Фотоизображение ( файл = r "C: \ Users \ Admin \ Pictures \ capture1.png " )

img1 = img.subsample ( 2 , 2 )

Этикетка (мастер, изображение = img1 ) .grid (строка = 0 , столбец = 2 ,

интервал столбцов = 2 , интервал строк = 2 , padx = 5 , pady = 5 )

b1 = Кнопка (мастер, текст = "Увеличить" )

b2 = Кнопка (мастер, текст = «Уменьшить» )

90 023 b1.сетка (строка = 2 , столбец = 2 , липкий = E)

b2.grid (строка = 2 , столбец = 3 , липкий = E)

mainloop ()

Python — пример Tkinter Grid

Всем привет! В предыдущем разделе руководства по Tkinter мы рассмотрели текстовый виджет Tkinter.Теперь рассмотрим пример использования диспетчера Tkinter Grid.

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

Зачем использовать Tkinter Grid Manager?

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

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

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

Теперь, когда мы это рассмотрели, давайте перейдем к фактическому использованию Grid-менеджера в нашем приложении!

ПРИМЕЧАНИЕ : Никогда не используйте несколько менеджеров упаковки в одном приложении Tkinter. Это приведет к непреднамеренным ошибкам и не рекомендуется. Используйте только один менеджер упаковки для одного приложения.

Использование Tkinter Grid Geometry Manager

Давайте спроектируем приведенный ниже макет с помощью Grid Manager.

Макет

Этот макет будет иметь два виджета входа с меткой для каждого и виджет кнопки ниже.

Мы также добавим изображение справа и виджет кнопки для изображения.

Хотя этим типом макета сложно управлять с помощью pack , мы можем легко сделать это с помощью сетки grid !

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

Сначала мы создадим наш мастер-объект.

 импорт tkinter as tk

master = tk.Tk ()
 

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

Нам нужны метки в столбце номер 0, проиндексированные номерами строк 0 и 1. После создания меток мы можем напрямую упаковать их, используя сетку , используя:

 label_object.grid (row, col)
 

Итак, прямо можем записать это так:

 тк.Ярлык (основной, текст = "Ярлык 1"). Сетка (строка = 0, столбец = 0)
tk.Label (master, text = "Label 2"). grid (row = 1, column = 0)
 

Теперь добавим запись для каждого из двух ярлыков.

 e1 = tk.Entry (мастер)
e2 = tk.Entry (мастер)
 

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

Просто позвоните по номеру entry_obj.grid () ! Это похоже на упаковку, но в целом гораздо удобнее в использовании.

 e1.сетка (строка = 0, столбец = 1)
e2.grid (строка = 1, столбец = 1)
 

После этого мы можем добавить наш основной цикл tkinter, используя tk.mainloop () .

Я опубликую полный код до этого момента.

 импорт tkinter as tk

# Создаем мастер-объект
master = tk.Tk ()

# Создать объекты этикеток и упаковать их с помощью сетки
tk.Label (master, text = "Label 1"). grid (row = 0, column = 0)
tk.Label (master, text = "Label 2"). grid (row = 1, column = 0)

# Создаем входные объекты с помощью master
e1 = tk.Entry (мастер)
е2 = тк.Вступление (мастер)

# Упакуйте их, используя сетку
e1.grid (строка = 0, столбец = 1)
e2.grid (строка = 1, столбец = 1)

# Главный цикл
tk.mainloop ()

 

Выход

Tkinter Grid Sample

Хорошо! Кажется, это работает, как ожидалось. А теперь давайте добавим к нему кнопку прямо под ним!

 button1 = tk.Button (master, text = "Button 1")
button1.grid (диапазон столбцов = 2, строка = 2, столбец = 0)
 

Теперь наша левая сторона закрыта.

Давайте добавим изображение и еще одну кнопку с правой стороны.

Поскольку мы обсуждали вопросы отображения изображения в предыдущем уроке, мы должны содержать ссылку на объект PhotoImage , чтобы избежать автоматической сборки мусора!

 из PIL import Image, ImageTk

# Создаем объект изображения PIL
image = Изображение.open ("debian.png")
photo = ImageTk.PhotoImage (изображение)

# Создать метку изображения
img_label = tk.Label (изображение = фото)
# Сохраните ссылку на объект PhotoImage, чтобы избежать ее
# выполняется сборка мусора! Это необходимо для вывода изображения!
img_label.image = фото

img_label.grid (строка = 0, столбец = 2)
 

Наконец, давайте добавим кнопку внизу.

 # Создать еще одну кнопку
button2 = tk.Button (master, text = "Кнопка 2")
button2.grid (столбцы = 2, строка = 2, столбец = 2)
 

А сейчас я выложу полную программу здесь.

 импорт tkinter as tk
из PIL импорт изображения, ImageTk

# Создаем мастер-объект
master = tk.Tk ()

# Создать объекты этикеток и упаковать их с помощью сетки
tk.Label (master, text = "Label 1"). grid (row = 0, column = 0)
tk.Label (master, text = "Label 2"). grid (row = 1, column = 0)

# Создаем входные объекты с помощью master
e1 = tk.Entry (мастер)
e2 = tk.Entry (мастер)

# Упакуйте их, используя сетку
e1.grid (строка = 0, столбец = 1)
e2.grid (строка = 1, столбец = 1)

button1 = tk.Button (master, text = "Кнопка 1")
button1.grid (диапазон столбцов = 2, строка = 2, столбец = 0)

# Создаем объект изображения PIL
image = Изображение.open ("debian.png")
photo = ImageTk.PhotoImage (изображение)

# Создать метку изображения
img_label = tk.Label (изображение = фото)
# Сохраните ссылку на объект PhotoImage, чтобы избежать ее
# выполняется сборка мусора! Это необходимо для вывода изображения!
img_label.image = фото

img_label.grid (строка = 0, столбец = 2)

# Создать еще одну кнопку
button2 = tk.Button (master, text = "Кнопка 2")
button2.grid (столбцы = 2, строка = 2, столбец = 2)

# Главный цикл
tk.mainloop ()
 

Выходные данные

Tkinter Grid Complete Layout

Наконец, мы завершили наш макет! И это было так же просто, как просто создать виджеты и указать сетке разместить их в правильных местах!

Заключение

В этом руководстве мы узнали, как можно добавлять виджеты в наше приложение Tkinter и разрабатывать макеты с помощью Tkinter Grid Geometry Manager.

Следите за новостями о Tkinter!

Python Tkinter Grid (метод grid () в Python Tkinter)

Хотите узнать, как использовать Python Tkinter grid ? В этом руководстве мы расскажем обо всем, что касается Grid в Python Tkinter. Мы увидим, как использовать метод grid () в Python Tkinter . Также мы рассмотрим эти темы:

• Python Tkinter Grid
• Как использовать метод Python Tkinter grid ()
• Python Tkinter Grid Пример
• Python Tkinter Grid Align Left
• Python Tkinter Grid Function
• Python Tkinter Grid Padding
• Python Tkinter Grid Colourpan
• columns Python Tkinter Grid Column
• umns Tkinter Grid Spacing
• Python Tkinter Grid Not Working
• Python Tkinter Grid Expand
• Python Tkinter Grid Fill

Сетка Python Tkinter

• Python Tkinter предоставляет виджеты, которые делают приложение удобным и простым в использовании для пользователей.Размещение виджетов в приложении не менее важно, чем выбор правильного виджета.
• Python Tkinter предоставляет три типа менеджеров компоновки, которые помогают разработчику разместить виджет в нужном месте приложения.
  • Pack: он упаковывает все виджеты в центре и размещает виджеты в последовательности.
  • Сетка: Сетка размещает виджеты по строкам и столбцам.
  • Место: Разместите виджеты позиций в координатах X и Y.
• В этом руководстве мы обсудим метод Python Tkinter Grid () . Мы рассмотрим все варианты, доступные в диспетчере компоновки сетки в Python Tkinter.

Пример сетки Python Tkinter

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

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

Python Tkinter Grid

Исходный код приведенного выше примера :

В этом примере мы поместили виджеты меток в столбец 0, виджеты записей — в столбец 1.Тогда как кнопка расширена до двух столбцов.

  из tkinter import *

ws = Tk ()
ws.title ('PythonGuides')
ws.geometry ('400x300')
ws.config (bg = '# 9FD996')

Этикетка(
    WS,
    text = 'Введите адрес электронной почты',
    bg = '# 9FD996'
) .grid (строка = 0, столбец = 0)

Этикетка(
    WS,
    text = 'Введите пароль',
    bg = '# 9FD996'
) .grid (строка = 1, столбец = 0)

Запись (ws) .grid (строка = 0, столбец = 1)
Запись (ws) .grid (строка = 1, столбец = 1)

Кнопка(
    WS,
    text = 'Войти',
    command = Нет
) .grid (row = 2, columnspan = 2)


ws.mainloop ()  

Python Tkinter Grid Align Left

• Диспетчер компоновки grid в Python Tkinter предоставляет опцию sticky , которая позволяет выровнять виджеты по направлению LEFT, RIGHT, TOP, BOTTOM.В этом разделе мы увидим, как установить выравнивание по левому краю с помощью сетки в Python Tkinter.
• Sticky требует первой буквы универсального направления в нижнем регистре, чтобы установить виджет в выбранном направлении. Вот варианты:
  • sticky = ‘e’: По правому краю
  • sticky = ‘w’: По левому краю
  • sticky = ‘n’: По верхнему краю
  • sticky = ‘s ‘: По нижнему краю

  сетка (строка = 0, столбец = 1, липкий =' w ')  

Пример выравнивания сетки Python Tkinter по левому краю:

В этом примере мы отобразили два изображения.В первом изображении виджет Label и виджет Button не выровнены, тогда как на втором изображении мы выровняли оба виджета по левому краю, используя параметр «Прилипание» в диспетчере компоновки сетки Python Tkinter.

Python Tkinter Grid выровняйте по левому краю с помощью липкого

Функция сетки Python Tkinter

• Grid в Python Tkinter — это функция, которая позволяет управлять макетом виджета. Он принимает в качестве аргумента строки и столбцы и помещает виджет в 2D-формат.
• Благодаря свойству 2D, Python Tkinter Grid широко используется для игр и приложений, таких как калькулятор, крестики-нолики, шахты и т. Д.
• Помимо строк и столбцов, Grid предлагает еще несколько вариантов:

Python Tkinter Grid Padding

• Grid в Python Tkinter предоставляет параметр заполнения, с помощью которого можно добавить пространство как внутри, так и за пределами границы виджета.
• При организации виджета временами размер по умолчанию или позиция виджета не соответствовали ожиданиям разработчика. В это время, используя отступы, разработчик настраивает виджет.
• Существует два типа отступов:
  • Отступ внутри границы виджета
  • Отступ за пределами границы виджета
• ipadx, ipady используются для добавления пробелов по горизонтали и вертикали внутри границы виджета.
• padx, pady используются для добавления пробелов по горизонтали и вертикали за пределами границы виджета.

Пример заполнения сетки в Python Tkinter

В этом примере отображаются четыре изображения, и на каждом показано изменение кнопки при добавлении отступов. У нас есть кнопка 5, которая находится в центре всех кнопок.

Image 1: image one не имеют отступов. Цель добавления этого изображения — показать вам исходное изображение, чтобы вы могли сравнить его с измененными изображениями.

Изображение 2: Мы добавили ipadx = 10 и ipady = 10 , при этом 10 пикселей добавлены внутри границы виджета, и он стал увеличиваться.

Изображение 3: Мы добавили padx = 10 и pady = 10 , при этом 10 пикселей добавляются за границу виджета, в результате чего другие виджеты должны перемещаться.

Изображение 4: Четвертое изображение является окончательным, его исходный код представлен ниже.Здесь мы применили оба отступа, в результате чего кнопка 5 выглядит больше, а другие виджеты смещены на 10 пикселей.

Сетка Python Tkinter

Фрагмент кода для приведенной выше диаграммы

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

  из tkinter import *

ws = Tk ()
ws.название ('PythonGuides')
ws.geometry ('400x300')
ws.config (bg = '# F2B33D')

frame = Frame (ws, bg = '# F2B33D')

Кнопка (рамка, текст = "7"). Сетка (строка = 0, столбец = 0, залипание = 'ew')
Кнопка (рамка, текст = "8"). Сетка (строка = 0, столбец = 1)
Кнопка (рамка, текст = "9"). Сетка (строка = 0, столбец = 2)

Кнопка (рамка, текст = "4"). Сетка (строка = 1, столбец = 0)
Кнопка (рамка, текст = "5"). Сетка (строка = 1, столбец = 1, ipadx = 10, ipady = 10, padx = 10, pady = 10)
Кнопка (рамка, текст = "6"). Сетка (строка = 1, столбец = 2)

Кнопка (рамка, текст = "7"). Сетка (строка = 2, столбец = 0)
Кнопка (рамка, текст = "8").сетка (строка = 2, столбец = 1)
Кнопка (рамка, текст = "9"). Сетка (строка = 2, столбец = 2)

frame.pack (expand = True)

ws.mainloop ()  

Python Tkinter Grid Columnspan

• Grid в Python Tkinter предоставляет столбцов с интервалом , с помощью которых мы можем объединить две или более ячеек в одну.
• columnspan полезно в случаях, когда вам нужно дополнительное место для определенного виджета.
• columnspan принимает целое число в качестве аргумента и объединяет одинаковое количество ячеек вместе.

Python Tkinter Grid Columnspan

Фрагмент кода:

В этом коде, онлайн 14, мы использовали columnspan = 3 , он объединил три ячейки в одну и отобразил для нее кнопку. Кнопка расширяется до доступного места, потому что мы установили sticky = ’ew’ .

  из tkinter import *

ws = Tk ()
ws.title ('PythonGuides')
ws.geometry ('400x300')
ws.config (bg = '# F2B33D')

frame = Frame (ws, bg = '# F2B33D')

Кнопка (рамка, текст = "Эти кнопки").сетка (строка = 0, столбец = 0)
Кнопка (рамка, текст = "позиционируются"). Сетка (строка = 0, столбец = 1)
Кнопка (frame, text = "using Grid"). Grid (row = 0, column = 2)

Кнопка (рамка, текст = "другая строка"). Сетка (строка = 1, диапазон столбцов = 3, липкое = 'ew')


frame.pack (expand = True)

ws.mainloop ()  

Шаг сетки Python Tkinter

• Grid в Python Tkinter предоставляет опцию padding , с помощью которой пробел может быть добавлен как внутри, так и за пределами границы виджета.
• При организации виджета временами размер или положение виджета по умолчанию не соответствовали ожиданиям разработчика.
• В это время, используя заполнение, разработчик настраивает виджет. Есть два типа заполнения:
  • Padding внутри границы виджета
  • Padding вне границы виджета
• ipadx, ipady используются для добавления пробелов по горизонтали и вертикали внутри границы виджета. padx, pady используются для добавления пробелов по горизонтали и вертикали за пределами границы виджета.
• См. Python Tkinter Grid Padding , чтобы увидеть пример.

Сетка Python Tkinter не работает

В этом разделе мы обсудим распространенные ошибки или ошибки, из-за которых Python Tkinter Grid не работает.

• Значение Columnspan не может быть больше, чем общее количество столбцов. Если у вас есть 5 столбцов в приложении, максимальное количество столбцов может быть объединено 5. Если вы ввели более 5, оно будет объединено только до 5

Python Tkinter Grid Expand

• Grid в Python Tkinter предоставляет sticky , с помощью которого виджет может быть расширен в направлениях X и Y.Другие менеджеры компоновки, такие как Place and Pack, имеют параметр expand , с помощью которого виджету можно разрешить расширение expand = True .
• Sticky требует первой буквы универсального направления в нижнем регистре, чтобы установить виджет в выбранном направлении. Вот варианты:
  • sticky = ‘e’: Выровнять по правому краю
  • sticky = ‘w’: Выровнять по левому краю sticky = ‘n’: Выровнять по верхнему краю sticky = ‘s’: Выровнять вниз

Предоставляя комбинацию направлений, мы можем разместить виджет в доступном пространстве.Например, если вы хотите заполнить позицию X виджета, введите: sticky = 'ew' . здесь ‘e’ покрывает восточное направление виджета, а « w » покрывает западное направление.

Заливка сетки Python Tkinter

• Grid в Python Tkinter предоставляет sticky , с помощью которого виджет может быть расширен в направлениях X и Y. Другие менеджеры компоновки, такие как Place и Pack, имеют опцию fill , с помощью которой виджету можно разрешить расширяться в доступном пространстве, если expand = True.
• Sticky требует первой буквы универсального направления в нижнем регистре, чтобы установить виджет в выбранном направлении. Вот варианты:
  • sticky = ‘e’: По правому краю
  • sticky = ‘w’: По левому краю
  • sticky = ‘n’: По верхнему краю
  • sticky = ‘s’: По нижнему краю
• Предоставляя комбинацию направлений, мы можем разместить виджет в доступном пространстве.Например, если вы хотите заполнить позицию X виджета, введите: sticky = 'ew' . здесь ‘e’ покрывает восточное направление виджета, а « w » покрывает западное направление.

Пример заполнения сетки в Python Tkinter

В этом коде мы реализовали заливку сетки в Python Tkinter. Сетка всегда начинается с верхнего левого угла экрана, поэтому мы создали рамку, поместили эту рамку в центр, а затем создали кнопки с помощью диспетчера компоновки сетки.В строках 11, 12 мы использовали sticky, чтобы растянуть кнопку влево-вправо.

  из tkinter import *

ws = Tk ()
ws.title ('PythonGuides')
ws.geometry ('400x300')
ws.config (bg = '# F2B33D')

frame = Frame (ws, bg = '# F2B33D')

Кнопка (рамка, текст = "Эти кнопки"). Сетка (строка = 0, столбец = 0)
Кнопка (рамка, текст = "позиционируются"). Сетка (строка = 0, столбец = 1)
Кнопка (frame, text = "using Grid"). Grid (row = 0, column = 2)

Кнопка (frame, text = "This is") .grid (row = 1, column = 0, sticky = 'ew')
Кнопка (рамка, текст = "другая строка").сетка (строка = 1, столбец = 1, липкий = 'ew')
Кнопка (frame, text = "using Grid"). Grid (row = 1, column = 2)

frame.pack (expand = True)

ws.mainloop ()  

Выход:

В этом выводе кнопки отображаются на экране с использованием сетки в Python Tkinter. Кнопки буксировки маленькие из-за меньшего количества слов. Итак, чтобы заполнить это уродливое пространство, мы использовали sticky = ’ew’ на этих двух кнопках. Теперь вы можете видеть на правом рисунке, что все кнопки организованы и нет пустого места.

Заливка сетки Python Tkinter

В этом руководстве мы узнали все о Gird Layout Manager в Python Tkinter. Также мы рассмотрели эти темы.

• Python Tkinter
• Как использовать метод grid () в Python Tkinter
• Python Tkinter Grid Layout Пример
• Python Tkinter Grid Align Left
• Python Tkinter Grid Function
• Python Tkinter Grid Padding
• Python Tkinter Grid Columns

Python Tkinter Grid Spacing

• Python Tkinter Grid не работает
• Python Tkinter Grid Expand
• Python Tkinter Grid Fill

Python tkinter Grid для разметки в строках и столбцах

«Основы Python Tkinter

Макет страницы для размещения компонентов в строках и столбцах.

Пустые строки и столбцы игнорируются. (row = 3 совпадает с row = 1, если row = 1 и row = 2 не используются)

Другой метод компоновки — Pack, никогда не смешивайте Pack и сетку в одном окне.

Мы будем хранить одну этикетку вместе с полем ввода.

Строка и столбец

Управление компоновкой Tkinter Grid по строкам и столбцам и выравнивание в горизонтальном и вертикальном направлениях

Горизонтальное размещение выполняется строками, а вертикальное — столбцами.

  импорт tkinter as tk
my_w = tk.Tk ()
my_w.geometry ("300x200")

l1 = tk.Label (my_w, text = 'строка = 1, столбец = 1')
l1.grid (строка = 1, столбец = 1)

l2 = tk.Label (my_w, text = 'строка = 1, столбец = 2')
l2.grid (строка = 1, столбец = 2)

l3 = tk.Label (my_w, text = 'row = 2, column = 1')
l3.grid (строка = 2, столбец = 1)

l4 = tk.Label (my_w, text = 'строка = 2, столбец = 2')
l4.grid (строка = 2, столбец = 2)

my_w.mainloop ()  

Верхняя строка — строка = 1, вторая строка — строка = 2, аналогично первый вертикальный столбец — это столбец = 1, а следующий вертикальный столбец — это столбец = 2.

липкий вариант

Если размер компонента меньше доступного пространства сетки, то мы можем использовать «E», «W», «N», «S» для выравнивания правого левого верхнего и нижнего края.

Проверка F Имя и L Имя выровнено по левому и правому краю. Мы также можем выровнять компоненты сверху и снизу.

  импорт tkinter as tk
my_w = tk.Tk ()
my_w.geometry ("250x100")
my_w.title ("plus2net.com") # Добавление заголовка

l1 = tk.Label (my_w, text = 'F Name (sticky = \' W \ ')') # добавлен один ярлык
l1.grid (строка = 1, столбец = 1, липкий = 'W')

e1 = tk.Entry (my_w, width = 10, bg = 'yellow') # добавлено одно поле ввода
e1.сетка (строка = 1, столбец = 2)

l2 = tk.Label (my_w, text = 'L Name (sticky = \' E \ ')') #
l2.grid (строка = 2, столбец = 1, липкий = 'E')

e2 = tk.Entry (my_w, width = 10, bg = 'yellow') # добавлено одно поле ввода
e2.grid (строка = 2, столбец = 2)

l3 = tk.Label (my_w, text = 'Добавить номер двери и почтовый адрес')
l3.grid (строка = 3, столбец = 1, липкий = 'W')

e3 = tk.Entry (my_w, width = 10, bg = 'yellow') # добавлено одно поле ввода
e3.grid (строка = 3, столбец = 2)

my_w.mainloop ()  

опция размаха колонны

Макет сетки окна Tkinter с использованием rowspan и columnspan для управления несколькими строками и столбцами

По умолчанию columnspan = 1 , мы можем установить другое значение, увеличивая его, чтобы расширить более одного столбца.

  l1 = tk.Label (my_w, text = 'First', width = 20)
l1.grid (строка = 1, столбец = 1)
l2 = tk.Label (my_w, text = 'Second', width = 20)
l2.grid (строка = 1, столбец = 2)

l3 = tk.Label (my_w, text = 'И первый, и второй, columnspan = 2')
l3.grid (строка = 2, столбец = 1, диапазон столбцов = 2)  

вариантов ширины междурядий

Мы можем использовать rowspan = 3 для расширения до трех строк.

  импорт tkinter as tk
my_w = tk.Tk ()
my_w.geometry ("300x150")
l1 = tk.Ярлык (my_w, text = 'First', width = 20)
l1.grid (строка = 1, столбец = 1)
l2 = tk.Label (my_w, text = 'Second', width = 20)
l2.grid (строка = 2, столбец = 1)
l3 = tk.Label (my_w, text = 'Third', width = 20)
l3.grid (строка = 3, столбец = 1)

t1 = tk.Text (my_w, height = 3, width = 8, bg = 'yellow') # текстовое поле
t1.grid (строка = 1, столбец = 2, rowspan = 3)

my_w.mainloop ()  

варианты ipadx, ipady, padx, pady

Макет сетки окна Tkinter с использованием padx pady и внутреннего заполнения с помощью ipadx, ipady

ipadx и ipady добавляет заполнение к внутреннему заполнению границы виджета.

  l4 = tk.Label (my_w, text = 'ipadx = 50, ipady = 50',
borderwidth = 2, Relief = 'гребень')
l4.grid (строка = 2, столбец = 2, ipadx = 50, ipady = 50)  

padx и pady добавляет отступ от виджета к границе сетки.

  l4 = tk.Label (my_w, text = 'padx = 50, pady = 50',
borderwidth = 2, Relief = 'гребень')
l4.grid (строка = 2, столбец = 2, padx = 50, pady = 50)  

grid_size ()

Это вернет кортеж, показывающий первые пустые столбцы и строки.В этом примере мы использовали upto row = 3 и column = 3, поэтому мы получим вывод как (4,4).

  импорт tkinter as tk
my_w = tk.Tk ()
my_w.geometry ("300x150")
l1 = tk.Label (my_w, text = 'First', width = 8)
l1.grid (строка = 1, столбец = 1)
l2 = tk.Label (my_w, text = 'Second', width = 8)
l2.grid (строка = 2, столбец = 2)
l3 = tk.Label (my_w, text = 'Третий', ширина = 8)
l3.grid (строка = 3, столбец = 3)

print (my_w.grid_size ()) # кортеж столбцы, строки

my_w.mainloop ()  

Выход

  (4, 4)  

Вы можете удалить последний элемент и проверить вывод.Мы установим значение как column = 2 для последнего элемента.

  l3 = tk.Label (my_w, text = 'Third', width = 8)
l3.grid (строка = 3, столбец = 2)  

Выход

  (3, 4)  

grid_slaves (строка = Нет, столбец = Нет)

Мы получим список виджетов, управляемых сеткой.

  импорт tkinter as tk
my_w = tk.Tk ()
my_w.geometry ("300x150")
l1 = tk.Label (my_w, text = 'First', width = 8)
l1.grid (строка = 1, столбец = 1)
l2 = tk.Ярлык (my_w, text = 'Second', width = 8)
l2.grid (строка = 2, столбец = 2)
l3 = tk.Label (my_w, text = 'Третий', ширина = 8)
l3.grid (строка = 3, столбец = 2)

печать (my_w.grid_slaves ())

my_w.mainloop ()  

Выход

  [<объект tkinter.Label.! Label3>, <объект tkinter.Label.! Label2>,
 ]  

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

  печать (my_w.grid_slaves (2,2))  

Выход

  []  

grid_remove ()

Удалите виджет из пертикулярной сетки. Можно добавить снова.

  импорт tkinter as tk
my_w = tk.Tk ()
my_w.geometry ("300x150")
l1 = tk.Label (my_w, text = 'First', width = 8)
l1.grid (строка = 1, столбец = 1)
l2 = tk.Label (my_w, text = 'Second', width = 8)
l2.grid (строка = 2, столбец = 2)
l3 = tk.Label (my_w, text = 'Третий', ширина = 8)
l3.grid (строка = 3, столбец = 2)
l3.grid_remove ()
my_w.mainloop ()  

Чтобы восстановить виджет в том же месте, мы должны просто использовать сетку ()

  сетка l3 ()  

grid_forget ()

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

  l3.grid_forget ()  

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

  л3.сетка (строка = 3, столбец = 2)  

Удаление через некоторое время

Мы можем использовать виджет как окно сообщения и удалить его через 300 секунд.

  l3.after (3000, лямбда: l3.grid_remove ())  

Удалить все виджеты

  для w в my_w.grid_slaves ():
    w.grid_forget ()  

Удалить все виджеты только 2-й строки

  для w в my_w.grid_slaves (2):
    w.grid_forget ()  

Удалить все виджеты 2-го столбца

  для w в my_w.grid_slaves (Нет, 2):
    w.grid_forget ()  

grid_info ()

Вся информация о расположении виджета в сетке.

  импорт tkinter as tk
из tkinter import *
my_w = tk.Tk ()
my_w.geometry ("400x200") # Размер окна
my_w.title ("www.plus2net.com") # Добавление заголовка
l1 = tk.Label (my_w, text = 'строка = 1, столбец = 1')
l1.grid (строка = 1, столбец = 1, padx = 10, pady = 10, ipadx = 3, ipady = 4)

# элементы словаря (строка, столбец, ipadx, ipday, sticky, rowspan, columnspan)
печать (l1.grid_info ()) # словарь значение всех элементов
print (l1.grid_info () ['столбец']) # 1
print (l1.grid_info () ['padx']) # 10

my_w.mainloop () # Не закрывать окно  

«Макет пакета в Tkinter
«Макет места
«Текст Python Tkinter

Менеджер геометрии сетки Tkinter

Привет! На этой неделе мы возвращаемся к разработке графического интерфейса с помощью Tkinter, и в этом посте мы собираемся познакомиться с диспетчером геометрии grid .

Если вы пропустили предыдущие публикации на Tkinter, вы можете проверить их по ссылкам ниже. В этих постах мы рассмотрим основную информацию о работе с Tkinter, а также рассмотрим другой менеджер геометрии под названием pack .

https://blog.tecladocode.com/tkinters-pack-geometry-manager/

https://blog.tecladocode.com/side-values-in-tkinters-pack-geometry-manager/

Почему следует мы заботимся о сетке

?

Как я только что упомянул, мы уже посвятили два поста другому менеджеру геометрии под названием pack , так зачем нам еще один?

На самом деле это действительно хороший вопрос, и, как оказалось, grid является гораздо более новым дополнением к Tk, чем pack , и был введен для устранения некоторых недостатков менеджера геометрии pack .Теперь он был основным продуктом Tk в течение двух десятилетий, так что он, должно быть, что-то делает правильно!

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

grid — это намного больше, чем pack , поэтому мы должны меньше полагаться на Tkinter, который автоматически согласовывает приемлемый макет для всех соответствующих виджетов.С помощью сетки grid мы вместо этого определяем двухмерную структуру таблицы и приказываем виджетам занимать определенные ячейки внутри этой таблицы. Это значительно упрощает рассуждение о размещении виджетов в более сложных интерфейсах.

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

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

Определение сетки

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

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

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

У нас есть два доступных метода для определения макета сетки: columnconfigure и rowconfigure .

У них одинаковые параметры, но, как следует из названия, они управляют разными размерами сетки.

В большинстве случаев вы собираетесь указать две части конфигурации для columnconfigure и rowconfigure : столбцы или строки, которые вы настраиваете, и веса этих столбцов или строк.

Вес строки или столбца определяет, какую часть доступного пространства должна занимать строка или столбец относительно других строк или столбцов. Например, столбец с весом из 2 будет вдвое шире, чем столбец с весом из 1 , при условии, что есть место для размещения виджетов.

В коде мы могли бы определить два таких столбца, где контейнер для наших виджетов является корневым контейнером:

  import tkinter as tk

корень = тк.Тк ()
root.geometry ("600x400")

root.columnconfigure (0, вес = 1)
root.columnconfigure (1, вес = 2)

root.mainloop ()
  

Мы снова вернулись к нашей верной настройке окна фиксированного размера и только что включили нашу обычную котельную плиту Tkinter. Если вам непонятен приведенный выше код, ознакомьтесь с нашим предыдущим постом о пакете pack , где мы рассказываем о многих из этих вещей: https://blog.tecladocode.com/tkinters-pack-geometry-manager/

В дополнение к обычному коду мы определили два столбца сетки, столбец 0 и столбец 1 , где столбец 1 вдвое шире столбца 0 .

Если мы хотим указать одну и ту же конфигурацию для нескольких столбцов, мы можем передать кортеж номеров столбцов вместо одного числа:

  import tkinter as tk

корень = tk.Tk ()
root.geometry ("600x400")

root.columnconfigure ((0, 2, 3), вес = 1)
root.columnconfigure (1, вес = 2)

root.mainloop ()
  

Теперь у нас есть четыре определенных столбца, из которых столбец 1 вдвое шире любого другого.

rowconfigure работает точно так же.

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

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

  импорт tkinter as tk

корень = tk.Tk ()
root.geometry ("600x400")

root.columnconfigure (0, вес = 1)
root.columnconfigure (1, вес = 2)

rectangle_1 = tk.Label (root, text = "Rectangle 1", bg = "green", fg = "white")
прямоугольник_2 = тк.Ярлык (корень, текст = "Прямоугольник 2", bg = "красный", fg = "белый")

root.mainloop ()
  

Здесь мы определили пару цветных прямоугольников с помощью виджета Label . Если используемые здесь параметры вам не понятны, взгляните на нашу первую публикацию pack .

Теперь, когда мы определили наши прямоугольники, давайте воспользуемся сеткой , чтобы разместить их в окне. Как и в случае с примерами пакетов, мы начнем использовать сетку без значимой конфигурации, чтобы увидеть поведение по умолчанию.Как и раньше, мы добавим небольшое количество внутренних отступов, используя ipadx и ipady , чтобы облегчить чтение текста Label .

  импорт tkinter as tk

корень = tk.Tk ()
root.geometry ("600x400")

root.columnconfigure (0, вес = 1)
root.columnconfigure (1, вес = 2)

rectangle_1 = tk.Label (root, text = "Rectangle 1", bg = "green", fg = "white")
rectangle_1.grid (ipadx = 10, ipady = 10)

rectangle_2 = tk.Label (root, text = "Rectangle 2", bg = "red", fg = "white")
прямоугольник_2.сетка (ipadx = 10, ipady = 10)

root.mainloop ()
  

Как мы видим, конфигурация по умолчанию для сетки выглядит примерно так же, как pack . Мы просто вызываем метод grid для соответствующего виджета, и любая конфигурация передается в качестве аргумента.

Так как это выглядит в окне?

Не знаю, как вы, но я не ожидал этого. Разве мы не указали сетку из двух столбцов для главного окна?

Как оказалось, сетка всегда помещает наши виджеты в новые строки, если мы не укажем иное.Для этого есть довольно веская причина: на самом деле существует бесконечное количество строк и столбцов. Даже если мы настроим только два столбца, мы действительно можем поместить вещи в столбцы 2, 5 или 67, при этом пустые столбцы свернутся до нулевой ширины.

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

Итак, как нам указать, куда должны идти виджеты? Мы можем использовать параметры строки и столбца .

  импорт tkinter as tk

корень = tk.Tk ()
root.geometry ("600x400")

root.columnconfigure (0, вес = 1)
root.columnconfigure (1, вес = 2)

rectangle_1 = tk.Label (root, text = "Rectangle 1", bg = "green", fg = "white")
rectangle_1.grid (столбец = 0, ipadx = 10, ipady = 10)

rectangle_2 = tk.Label (root, text = "Rectangle 2", bg = "red", fg = "white")
rectangle_2.grid (столбец = 1, ipadx = 10, ipady = 10)

корень.mainloop ()
  

Здесь я определил только значение столбца, поместив первый прямоугольник в столбец 0 , а второй прямоугольник в столбец 1 . Мы могли бы ожидать, что теперь Tkinter поместит виджеты в одну строку, но это не так. Вместо этого они попадают в указанные столбцы, но в разные строки.

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

  import tkinter as tk

корень = тк.Тк ()
root.geometry ("600x400")

root.columnconfigure (0, вес = 1)
root.columnconfigure (1, вес = 2)

rectangle_1 = tk.Label (root, text = "Rectangle 1", bg = "green", fg = "white")
rectangle_1.grid (столбец = 0, строка = 0, ipadx = 10, ipady = 10)

rectangle_2 = tk.Label (root, text = "Rectangle 2", bg = "red", fg = "white")
rectangle_2.grid (столбец = 1, строка = 0, ipadx = 10, ipady = 10)

root.mainloop ()
  

Теперь у нас есть оба прямоугольника в одной строке, занимающие два разных столбца:

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

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

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

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

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

Указание одного направления по компасу заставляет виджеты «прилипать» к единственному краю назначенной им области. Например, мы можем установить rectangle_1 так, чтобы они придерживались левой стороны назначенной ему области с "W" , а rectangle_2 придерживались правой стороны назначенной области с помощью "E" .

  импорт tkinter as tk

корень = tk.Tk ()
root.geometry ("600x400")

корень.columnconfigure (0, вес = 1)
root.columnconfigure (1, вес = 2)

rectangle_1 = tk.Label (root, text = "Rectangle 1", bg = "green", fg = "white")
rectangle_1.grid (столбец = 0, строка = 0, ipadx = 10, ipady = 10, sticky = "W")

rectangle_2 = tk.Label (root, text = "Rectangle 2", bg = "red", fg = "white")
rectangle_2.grid (столбец = 1, строка = 0, ipadx = 10, ipady = 10, sticky = "E")

root.mainloop ()
  

Это дает нам что-то вроде этого:

Однако, если мы укажем противоположные направления компаса, виджеты застрянут с обеих сторон, что приведет к растяжению виджета:

  import tkinter as tk

корень = тк.Тк ()
root.geometry ("600x400")

root.columnconfigure (0, вес = 1)
root.columnconfigure (1, вес = 2)

rectangle_1 = tk.Label (root, text = "Rectangle 1", bg = "green", fg = "white")
rectangle_1.grid (столбец = 0, строка = 0, ipadx = 10, ipady = 10, sticky = "EW")

rectangle_2 = tk.Label (root, text = "Rectangle 2", bg = "red", fg = "white")
rectangle_2.grid (столбец = 1, строка = 0, ipadx = 10, ipady = 10, sticky = "EW")

root.mainloop ()
  

Теперь мы можем очень ясно видеть наши веса столбцов в действии: rectangle_2 занимают вдвое больше места, чем rectangle_1 .

Итак, что происходит, когда мы устанавливаем виджет так, чтобы он придерживался всех краев назначенной ему области?

  импорт tkinter as tk

корень = tk.Tk ()
root.geometry ("600x400")

root.columnconfigure (0, вес = 1)
root.columnconfigure (1, вес = 2)

rectangle_1 = tk.Label (root, text = "Rectangle 1", bg = "green", fg = "white")
rectangle_1.grid (столбец = 0, строка = 0, ipadx = 10, ipady = 10, sticky = "NSEW")

rectangle_2 = tk.Label (root, text = "Rectangle 2", bg = "red", fg = "white")
rectangle_2.grid (столбец = 1, строка = 0, ipadx = 10, ipady = 10, sticky = "NSEW")

корень.mainloop ()
  

Здесь мы указали "NSEW" как наше значение прилипания для обоих виджетов, что означает, что оно будет прилипать ко всем краям назначенной ему области. Вы также можете использовать кортеж, если хотите, и в Tkinter определены константы, которые вы можете использовать вместо строк:

  rectangle_1.grid (column = 0, row = 0, ipadx = 10, ipady = 10, sticky = (" N, S, E, W))

rectangle_1.grid (столбец = 0, строка = 0, ipadx = 10, ipady = 10, sticky = (tk.N, tk.S, tk.E, tk.W))

rectangle_1.grid (столбец = 0, строка = 0, ipadx = 10, ipady = 10, sticky = tk.NSEW)
  

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

Однако код может не дать ожидаемого результата:

Помните, что параметр sticky заставляет виджет придерживаться заданного края назначенной ему области, но ранее мы говорили, что по умолчанию Tkinter назначает только количество пространства строки равно высоте виджетов внутри. В конце концов, им больше не нужно.

Мы можем указать бит конфигурации для строки 0 , чтобы исправить это, присвоив ей вес 1 .

  импорт tkinter as tk

корень = tk.Tk ()
root.geometry ("600x400")

root.columnconfigure (0, вес = 1)
root.columnconfigure (1, вес = 2)

root.rowconfigure (0, вес = 1)

rectangle_1 = tk.Label (root, text = "Rectangle 1", bg = "green", fg = "white")
rectangle_1.grid (столбец = 0, строка = 0, ipadx = 10, ipady = 10, sticky = "NSEW")

rectangle_2 = tk.Label (root, text = "Rectangle 2", bg = "red", fg = "white")
rectangle_2.grid (столбец = 1, строка = 0, ipadx = 10, ipady = 10, sticky = "NSEW")

root.mainloop ()
  

И вот так наши виджеты заполняют все окно:

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

Присвоение веса пустым строкам

Ранее в этом посте я отмечал, что пустые строки сворачиваются до нулевой высоты, но это верно только тогда, когда они имеют вес 0 .

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

Например, мы можем присвоить вес 1 пустой строке под основным содержимым, чтобы ограничить первую строку только половиной экрана:

  import tkinter as tk

корень = тк.Тк ()
root.geometry ("600x400")

root.columnconfigure (0, вес = 1)
root.columnconfigure (1, вес = 2)

root.rowconfigure ((0, 1), вес = 1)

rectangle_1 = tk.Label (root, text = "Rectangle 1", bg = "green", fg = "white")
rectangle_1.grid (столбец = 0, строка = 0, ipadx = 10, ipady = 10, sticky = "NSEW")

rectangle_2 = tk.Label (root, text = "Rectangle 2", bg = "red", fg = "white")
rectangle_2.grid (столбец = 1, строка = 0, ipadx = 10, ipady = 10, sticky = "NSEW")

root.mainloop ()
  

Объединение строк и столбцов

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

К счастью, это очень просто в Tkinter и требует единственной настройки.

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

  import tkinter as tk

корень = tk.Tk ()
root.geometry ("600x400")

root.columnconfigure (0, вес = 1)
корень.columnconfigure (1, вес = 2)

root.rowconfigure (1, вес = 1)

rectangle_1 = tk.Label (root, text = "Rectangle 1", bg = "green", fg = "white")
rectangle_1.grid (column = 0, row = 0, columnspan = 2, ipadx = 20, ipady = 20, sticky = "NSEW")

rectangle_2 = tk.Label (root, text = "Rectangle 2", bg = "red", fg = "white")
rectangle_2.grid (столбец = 0, строка = 1, ipadx = 10, ipady = 10, sticky = "NSEW")

rectangle_3 = tk.Label (root, text = "Rectangle 3", bg = "blue", fg = "white")
rectangle_3.grid (столбец = 1, строка = 1, ipadx = 10, ipady = 10, sticky = "NSEW")

корень.mainloop ()
  

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

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

rectangle_1 теперь имеет немного дополнительных внутренних отступов и имеет новый аргумент ключевого слова columnspan = 2 . Это то, что позволяет виджету занимать несколько столбцов, как мы сейчас увидим.

rectangle_2 теперь находится в строке 1 и находится в первом столбце.

Был добавлен новый прямоугольник rectangle_3 , который находится во второй строке и столбце, но в остальном такой же, как rectangle_2 , только с другим текстом и другим цветом фона.

Вот как все это выглядит:

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