[100 dias proficiente em python] Dia 35: programação de interface GUI _ Domine a operação básica do Tkinter em um artigo

A programação GUI (Graphical User Interface) é uma técnica usada para criar uma interface gráfica de usuário que permite ao usuário interagir com um programa por meio de elementos gráficos como janelas, botões, caixas de texto, etc.

Uma GUI (Graphical User Interface) é uma forma de interagir com um programa de computador por meio de elementos gráficos como janelas, botões, caixas de texto, imagens, etc. As GUIs permitem que os usuários se comuniquem com os aplicativos de maneira visual, sem a necessidade de memorizar comandos ou sintaxe complexos. A GUI pode melhorar muito a experiência do usuário, permitindo que os usuários operem aplicativos de forma mais intuitiva e conveniente.

1.1 Por que você precisa de uma GUI?

Facilidade de uso : a GUI torna o aplicativo mais fácil de usar, sem necessidade de lembrar parâmetros ou códigos de linha de comando. Os usuários podem realizar operações de forma intuitiva por meio de uma interface gráfica.

Visualização : Através de elementos gráficos, o usuário pode visualizar diretamente informações, dados e resultados de operações na interface, facilitando o entendimento das funções da aplicação.

Interatividade : a GUI permite aos usuários interagir com as aplicações através do mouse, teclado, toque, etc., de forma a realizar mais tipos de operações.

Maior eficiência : As ferramentas GUI fornecem uma interface simplificada para tarefas complexas, permitindo que os usuários executem tarefas mais rapidamente, aumentando assim a produtividade.

Plataforma cruzada : muitas bibliotecas e ferramentas GUI suportam vários sistemas operacionais, permitindo que os desenvolvedores criem experiências de usuário semelhantes em diferentes plataformas.

1.2 Ferramentas e bibliotecas comuns de programação GUI :

Tkinter : biblioteca GUI padrão do Python, adequada para aplicativos GUI simples, fácil de aprender e usar.

Qt : Uma biblioteca GUI multiplataforma com recursos avançados e aparência profissional, suportando múltiplas linguagens de programação, como C++ e Python.

wxWidgets : Outra biblioteca GUI multiplataforma que fornece uma aparência nativa para muitas linguagens de programação.

GTK : Um kit de ferramentas GUI de código aberto para criação de aplicativos em sistemas Linux e UNIX.

PyQt : ligações Qt para Python, trazendo a funcionalidade Qt para o mundo Python, fornecendo recursos avançados e opções de personalização.

Kivy : Uma biblioteca Python para desenvolvimento de aplicativos móveis e outras interfaces multitoque, com suporte a múltiplas plataformas.

1.3 Composição e arquitetura do aplicativo GUI :

Gerenciador de janelas : responsável por gerenciar e exibir as janelas da aplicação, incluindo tamanho, posição e aparência da janela.

Elementos da interface do usuário : incluindo botões, caixas de texto, rótulos, menus, barras de ferramentas, etc., são usados para interação usuário-programa.

Processamento de eventos : responda às ações do usuário (como clicar em botões, inserir texto, etc.) e execute as operações correspondentes para realizar a interação entre usuários e aplicativos.

Gerenciamento de layout : organizar e organizar a posição e o tamanho dos elementos da interface para apresentar uma interface consistente em diferentes tamanhos e resoluções de tela.

Desenho gráfico e exibição : exibe imagens, gráficos e gráficos para apresentação de dados e gráficos.

Interação de dados : comunique-se com a lógica de back-end, adquira, processe e exiba dados.

Loop de eventos : os aplicativos GUI geralmente são orientados a eventos, que monitorarão continuamente as operações do usuário e os eventos do sistema e, em seguida, executarão as operações correspondentes.

Loop principal : responsável por monitorar e distribuir eventos, além de gerenciar a exibição e atualização de janelas.

Experiência do usuário : Fornece uma boa experiência ao usuário, incluindo interface amigável, feedback e tratamento de erros.

Resumindo, GUI é uma tecnologia usada para criar uma interface gráfica de usuário, que pode melhorar significativamente a interação e usabilidade entre usuários e aplicações. Diferentes bibliotecas e ferramentas GUI fornecem diferentes níveis de funcionalidade e flexibilidade, e você pode escolher a solução de desenvolvimento GUI apropriada de acordo com as necessidades do seu projeto.

2 Programação GUI usando biblioteca Tkinter

Tkinter é a biblioteca GUI padrão do Python, que pode ser usada para criar janelas e vários componentes GUI, como rótulos, botões, caixas de texto, etc. É uma ferramenta leve e fácil de usar, adequada para criar aplicativos de desktop de pequeno a médio porte.

2.1 Fluxo básico de programação GUI usando a biblioteca Tkinter

Importe a biblioteca Tkinter : Primeiro, você precisa importar a biblioteca Tkinter. Geralmente usado import tkinter as tkpara simplificar chamadas.

Criar janela principal : Use Tk()a função para criar um objeto de janela principal, que é a interface principal do aplicativo.

Adicionar componentes GUI : Adicione diferentes componentes GUI, como Label, Button, Entry, etc., por meio de várias classes do Tkinter. Componentes de layout usando métodos como .pack(), .grid(), etc.

Definir funções de manipulação de eventos : se você precisar responder a eventos de componentes, como eventos de clique de botão, será necessário definir funções de manipulação de eventos correspondentes.

Gerenciamento de layout : use gerenciadores de layout (como .pack(), .grid(), .place()) para organizar e posicionar componentes para garantir que a interface esteja bem organizada.

Iniciar o loop principal : Use o método .mainloop() para iniciar o loop principal do aplicativo GUI, mantendo o aplicativo em execução e aguardando as operações do usuário.

2.2 Programação GUI usando biblioteca Tkinter

2.2.1 Importar biblioteca Tkinter

Primeiro, importe a biblioteca Tkinter e crie o objeto da janela principal.

import tkinter as tk

# 创建主窗口
root = tk.Tk()
root.title("GUI Application")



root.mainloop()  #启动主循环

2.2.2 Adicionar rótulos e botões

Use as classes Label e Button para adicionar componentes de rótulo e botão.

# 添加标签
label = tk.Label(root, text="Welcome to GUI Programming!")
label.pack()

# 添加按钮
def button_clicked():
    label.config(text="Button Clicked!")

button = tk.Button(root, text="Click Me", command=button_clicked)
button.pack()

2.2.3 Adicionar caixa de texto

Use a classe Entry para adicionar caixas de texto.

# 添加文本框
entry = tk.Entry(root)
entry.pack()

2.2.4 Gerenciamento de Layout

Use o método pack() para organizar os componentes.

label.pack()
button.pack()
entry.pack()

2.2.5 Tratamento de Eventos

Defina a função de retorno de chamada para o evento de clique do botão.

def button_clicked():
    label.config(text="Hello, " + entry.get())

button = tk.Button(root, text="Submit", command=button_clicked)
button.pack()

2.2.6 Iniciar o loop principal

Inicie o loop principal da GUI através do método mainloop().

root.mainloop()

3 Uso detalhado dos componentes Tkinter

3.1 Gerenciamento de Layout

3.1.1 Layout Absoluto vs. Layout Automático

O layout absoluto refere-se ao posicionamento preciso da posição de cada componente por meio de coordenadas de pixel. Porém, o layout absoluto pode causar instabilidade e desalinhamento da interface conforme o tamanho da janela muda, por isso não é recomendado na maioria dos casos. O layout automático usa gerenciadores de layout para ajustar e organizar automaticamente os componentes para se adaptarem às mudanças no tamanho da janela, tornando a interface mais responsiva e adaptável.

3.1.2 Usando layout de grade e layout de pacote

Tkinter fornece dois gerenciadores de layout comuns: .grid()e .pack(). .grid()Os componentes de layout usando linhas e colunas .pack()organizam automaticamente os componentes na ordem em que foram adicionados.

import tkinter as tk

root = tk.Tk()
root.title("Layout Example")

# 使用Grid布局
label1 = tk.Label(root, text="Label 1")
label2 = tk.Label(root, text="Label 2")
label1.grid(row=0, column=0)
label2.grid(row=1, column=1)

# 使用Pack布局
button1 = tk.Button(root, text="Button 1")
button2 = tk.Button(root, text="Button 2")
button1.pack()
button2.pack()

root.mainloop()

3.1.3 Agrupando componentes usando Frame e LabelFrame

Frame e LabelFrame são componentes contêineres no Tkinter que podem ser usados para agrupar e organizar outros componentes.

frame = tk.Frame(root)
frame.pack()

label_frame = tk.LabelFrame(root, text="Group")
label_frame.pack()

3.2 Tratamento de Eventos

O processamento de eventos é um conceito importante na programação GUI, que envolve a interação entre o usuário e a interface, como clique do mouse, clique em botão, entrada do teclado, etc. A seguir estão explicações detalhadas e exemplos de manipulação de eventos para ajudá-lo a entender como lidar com diferentes tipos de eventos no Tkinter.

Na programação GUI, as operações e ações do usuário acionarão diferentes eventos, e o programa responderá a esses eventos por meio de funções de processamento de eventos. Os eventos podem ser cliques do mouse, pressionamentos de teclas, fechamento de janelas, etc.

3.2.1 Eventos de ligação e funções de retorno de chamada

No Tkinter, você pode usar .bind()métodos para vincular eventos e funções de retorno de chamada correspondentes. Quando ocorre um evento, a função vinculada a ele será chamada.

import tkinter as tk

def button_clicked(event):
    label.config(text="Button Clicked!")

root = tk.Tk()
root.title("Event Handling Example")

label = tk.Label(root, text="Click the Button")
label.pack()

button = tk.Button(root, text="Click Me")
button.bind("<Button-1>", button_clicked)  # 绑定鼠标左键点击事件
button.pack()

root.mainloop()

Neste exemplo, ao clicar com o botão esquerdo do botão, button_clicked()a função é chamada, atualizando o conteúdo do rótulo.

3.2.2 Eventos comuns

Além dos eventos de clique de botão, há muitos outros eventos comuns, como eventos de mouse e eventos de teclado. Você pode vincular esses eventos usando diferentes descritores de eventos.

def mouse_enter(event):
    label.config(text="Mouse Entered!")

def key_pressed(event):
    label.config(text="Key Pressed: " + event.char)

label.bind("<Enter>", mouse_enter)  # 鼠标进入事件
label.bind("<KeyPress>", key_pressed)  # 键盘按键事件

Neste exemplo, quando o mouse entra na área do rótulo, mouse_enter()a função é chamada; quando o teclado é pressionado, key_pressed()a função é chamada e a tecla pressionada é exibida.

3.2.3 Objeto evento

Quando ocorre um evento, um objeto de evento é criado automaticamente, que pode ser usado no manipulador de eventos para obter informações sobre o evento.

def mouse_clicked(event):
    x = event.x  # 获取鼠标点击位置的x坐标
    y = event.y  # 获取鼠标点击位置的y坐标
    label.config(text=f"Mouse Clicked at ({x}, {y})")

label.bind("<Button-1>", mouse_clicked)  # 鼠标左键点击事件

Neste exemplo, quando o botão esquerdo do mouse é clicado, mouse_clicked()a função é chamada e as coordenadas do clique do mouse são exibidas.

Ao compreender os conceitos básicos de manipulação de eventos, vincular diferentes eventos e usar objetos de evento, você pode adicionar mais interatividade e capacidade de resposta aos aplicativos GUI, tornando a interação entre os usuários e a interface mais rica e em tempo real.

3.3 Entrada e Saída do Usuário

3.3.1 Obtenha e defina o conteúdo da caixa de texto

Você pode usar .get()os métodos e .insert()para obter e definir o conteúdo da caixa de texto.

entry = tk.Entry(root)
entry.pack()
text = entry.get()  # 获取文本框内容
entry.insert(0, "Hello")  # 在光标处插入文本

3.3.2 Tratamento do evento de clique do botão

O processamento do evento de clique do botão pode ser realizado vinculando a função de retorno de chamada.

import tkinter as tk

def button_clicked():
    label.config(text="Button Clicked!")

root = tk.Tk()
root.title("Button Click Event Example")

label = tk.Label(root, text="Click the Button")
label.pack()

button = tk.Button(root, text="Click Me", command=button_clicked)  # 绑定回调函数
button.pack()

root.mainloop()

Neste exemplo, criamos um botão ( button) e vinculamos uma função como função de retorno de chamada do botão por meio de commandum parâmetro . button_clickedAo clicar no botão, button_clickeda função é chamada automaticamente, atualizando o conteúdo da etiqueta.

Desta forma, desacopla a operação e função do botão da função de retorno de chamada, tornando o código mais modular e claro. Várias operações podem ser realizadas na função de retorno de chamada, como atualização da interface, realização de cálculos, exibição de informações e assim por diante.

3.3.3 Criar diálogos pop-up e caixas de mensagens

Tkinter fornece tkinter.messageboxmódulos para criar várias caixas de diálogo e caixas de mensagens.

import tkinter.messagebox as messagebox

def show_alert():
    messagebox.showinfo("Alert", "This is an alert message!")

button = tk.Button(root, text="Show Alert", command=show_alert)
button.pack()

3.4 Design de janela e interface

3.4.1 Criar múltiplas janelas

No Tkinter, você pode criar múltiplas janelas criando novos objetos Tk. Cada objeto Tk representa uma janela do aplicativo. Aqui está um exemplo que mostra como criar múltiplas janelas:

import tkinter as tk

# 创建第一个窗口
root1 = tk.Tk()
root1.title("Window 1")
label1 = tk.Label(root1, text="Window 1")
label1.pack()

# 创建第二个窗口
root2 = tk.Tk()
root2.title("Window 2")
label2 = tk.Label(root2, text="Window 2")
label2.pack()

root1.mainloop()
root2.mainloop()

Neste exemplo, criamos dois objetos Tk diferentes ( root1e root2), cada um representando uma janela. mainloop()Permite que duas janelas operem de forma independente , chamando seus respectivos métodos.

3.4.2 Adicionar barra de menu e barra de ferramentas

Tkinter suporta a criação de barras de menu e barras de ferramentas para aprimorar a funcionalidade de aplicativos GUI. Aqui está um exemplo que mostra como criar uma barra de menu simples:

import tkinter as tk
from tkinter import Menu

def do_something():
    label.config(text="Menu Item Clicked")

root = tk.Tk()
root.title("Menu Example")

# 创建菜单栏
menu_bar = Menu(root)
root.config(menu=menu_bar)

# 创建菜单
file_menu = Menu(menu_bar, tearoff=0)
menu_bar.add_cascade(label="File", menu=file_menu)
file_menu.add_command(label="New", command=do_something)
file_menu.add_command(label="Open", command=do_something)
file_menu.add_separator()
file_menu.add_command(label="Exit", command=root.quit)

# 添加标签
label = tk.Label(root, text="Menu Example")
label.pack()

root.mainloop()

Neste exemplo, criamos uma barra de menu ( menu_bar) e adicionamos um menu chamado “Arquivo” à barra de menu ( file_menu). O menu contém alguns itens de menu, cada item de menu possui um comando correspondente ( command) e quando o item de menu é clicado, a função correspondente será acionada.

Ao criar várias janelas e adicionar barras de menu, você pode implementar aplicativos GUI mais complexos e ricos em recursos que permitem aos usuários operar e interagir facilmente.

3.4.3 Criando uma interface rolável

No Tkinter, você pode implementar uma interface rolável usando barras de rolagem (Scrollbar), especialmente quando o conteúdo excede a área visível. Aqui está um exemplo que mostra como criar uma interface rolável em um aplicativo Tkinter:

import tkinter as tk
from tkinter import ttk

root = tk.Tk()
root.title("Scrollable Interface Example")

# 创建滚动条
scrollbar = tk.Scrollbar(root)
scrollbar.pack(side="right", fill="y")

# 创建文本框并绑定滚动条
text = tk.Text(root, yscrollcommand=scrollbar.set)
text.pack(side="left", fill="both", expand=True)

# 将滚动条与文本框关联
scrollbar.config(command=text.yview)

# 添加大量文本
for i in range(100):
    text.insert("end", f"Line {i}\n")

root.mainloop()

Neste exemplo, criamos uma caixa de texto ( text) e associamos uma barra de rolagem vertical ( scrollbar) para rolar quando o conteúdo do texto ultrapassa a área visível da caixa de texto. Ao definir o parâmetro da barra de rolagem commandcomo text.yview, a ligação entre a barra de rolagem e a caixa de texto é realizada.

Você pode adicionar diferentes tipos de componentes à interface rolável conforme necessário, permitindo que os usuários naveguem e visualizem grandes quantidades de conteúdo sem ocupar muito espaço na interface.

3.5 Gráficos e imagens

3.5.1 Desenhando gráficos básicos na GUI

Os componentes podem ser usados Canvaspara desenhar gráficos na GUI.

canvas = tk.Canvas(root, width=200, height=200)
canvas.pack()
canvas.create_rectangle(50, 50, 150, 150, fill="blue")

3.5.2 Exibir arquivos de imagem

Uma biblioteca pode ser usada PILpara exibir arquivos de imagem no Tkinter.

from PIL import Image, ImageTk

image = Image.open("image.png")
photo = ImageTk.PhotoImage(image)
label = tk.Label(root, image=photo)
label.pack()

3.5.3 Ferramentas de gráficos e desenho

Em aplicativos GUI, tabelas, gráficos e visualizações de dados podem ser criados usando ferramentas de desenho. O próprio Tkinter não possui ferramentas de desenho poderosas integradas, mas você pode combinar outras bibliotecas para obter funções de desenho e gráficos. Algumas bibliotecas de desenhos e exemplos comumente usados são apresentados abaixo.

Matplotlib: é uma biblioteca de plotagem amplamente utilizada para criar vários tipos de tabelas e gráficos em Python. Ele fornece uma variedade de funções de desenho, incluindo gráficos de linhas, gráficos de dispersão, histogramas, gráficos de pizza, etc. Você pode usar o Matplotlib para incorporar uma área de desenho em um aplicativo Tkinter para exibir gráficos em uma interface GUI.
Plotly : para criar gráficos e visualizações interativos.
Seaborn : Baseado em Matplotlib, usado para criar gráficos estatísticos e visualização de dados.
Almofada : para processamento e desenho de imagens.

Você pode escolher uma ferramenta de desenho adequada de acordo com os requisitos do projeto e incorporar gráficos e visualizações em aplicativos Tkinter para obter exibição e análise interativa de dados.

3.6 Elementos interativos

3.6.1 Fazendo tabelas e listas

Os componentes podem ser usados Treeviewpara criar tabelas e listas.

tree = ttk.Treeview(root, columns=("Name", "Age"))
tree.heading("#1", text="Name")
tree.heading("#2", text="Age")
tree.insert("", "end", values=("Alice", 25))
tree.pack()

3.6.2 Usando barras de rolagem e controles deslizantes

Barras de rolagem e controles deslizantes podem Scrollbarser adicionados por meio de componentes.

scrollbar = tk.Scrollbar(root)
scrollbar.pack(side="right", fill="y")

listbox = tk.Listbox(root, yscrollcommand=scrollbar.set)
for i in range(50):
    listbox.insert("end", "Item " + str(i))
listbox.pack(side="left", fill="both")

scrollbar.config(command=listbox.yview)

3.6.3 Criando caixas de seleção, botões de opção, etc.

Caixas de seleção e botões de opção podem ser criados usando Checkbuttone Radiobutton.

check_var = tk.IntVar()
checkbox = tk.Checkbutton(root, text="Check me", variable=check_var)
checkbox.pack()

radio_var = tk.StringVar()
radio_button1 = tk.Radiobutton(root, text="Option 1", variable=radio_var, value="option1")
radio_button2 = tk.Radiobutton(root, text="Option 2", variable=radio_var, value="option2")
radio_button1.pack()
radio_button2.pack()

No Tkinter, você pode selecionar opções através de componentes como caixas de seleção (Checkbutton) e botões de opção (Radiobutton). Aqui está um exemplo de código que demonstra como criar caixas de seleção e botões de opção:

Exemplo de criação de caixa de seleção:

import tkinter as tk
from tkinter import ttk

def show_selection():
    selected_items = []
    for var, text in zip(check_vars, check_texts):
        if var.get():
            selected_items.append(text)
    selection_label.config(text="Selected Items: " + ", ".join(selected_items))

root = tk.Tk()
root.title("Checkboxes Example")

check_texts = ["Option 1", "Option 2", "Option 3"]
check_vars = [tk.IntVar() for _ in check_texts]

for i, text in enumerate(check_texts):
    check = ttk.Checkbutton(root, text=text, variable=check_vars[i])
    check.pack()

selection_button = ttk.Button(root, text="Show Selection", command=show_selection)
selection_button.pack()

selection_label = tk.Label(root, text="")
selection_label.pack()

root.mainloop()

Neste exemplo, criamos três caixas de seleção ( check) e IntVarvinculamos o estado das caixas de seleção usando Quando o usuário marca ou desmarca uma caixa de seleção, o IntVarvalor correspondente muda. Ao iterar tudo IntVar, podemos obter as opções selecionadas pelo usuário.

Exemplo de criação de botões de opção:

import tkinter as tk
from tkinter import ttk

def show_selection():
    selected_item = radio_var.get()
    selection_label.config(text="Selected Item: " + selected_item)

root = tk.Tk()
root.title("Radiobuttons Example")

radio_texts = ["Option 1", "Option 2", "Option 3"]
radio_var = tk.StringVar()

for text in radio_texts:
    radio = ttk.Radiobutton(root, text=text, variable=radio_var, value=text)
    radio.pack()

selection_button = ttk.Button(root, text="Show Selection", command=show_selection)
selection_button.pack()

selection_label = tk.Label(root, text="")
selection_label.pack()

root.mainloop()

4 Prática: Crie um aplicativo GUI de calculadora simples

Aqui está um exemplo de código para criar um aplicativo GUI de calculadora simples usando Tkinter:

import tkinter as tk

# 定义按钮点击事件
def button_click(number):
    current = entry.get()
    entry.delete(0, tk.END)
    entry.insert(0, current + str(number))

def clear():
    entry.delete(0, tk.END)

def calculate():
    try:
        result = eval(entry.get())
        entry.delete(0, tk.END)
        entry.insert(0, str(result))
    except:
        entry.delete(0, tk.END)
        entry.insert(0, "Error")

# 创建主窗口
root = tk.Tk()
root.title("Simple Calculator")

# 创建文本框
entry = tk.Entry(root, font=("Helvetica", 16))
entry.grid(row=0, column=0, columnspan=4)

# 创建按钮
buttons = [
    ("7", 1, 0), ("8", 1, 1), ("9", 1, 2), ("/", 1, 3),
    ("4", 2, 0), ("5", 2, 1), ("6", 2, 2), ("*", 2, 3),
    ("1", 3, 0), ("2", 3, 1), ("3", 3, 2), ("-", 3, 3),
    ("0", 4, 0), (".", 4, 1), ("=", 4, 2), ("+", 4, 3),
]

for (text, row, col) in buttons:
    button = tk.Button(root, text=text, font=("Helvetica", 16), command=lambda t=text: button_click(t))
    button.grid(row=row, column=col, sticky="nsew")

# 清除按钮和等号按钮单独处理
clear_button = tk.Button(root, text="C", font=("Helvetica", 16), command=clear)
clear_button.grid(row=5, column=0, columnspan=2, sticky="nsew")

equal_button = tk.Button(root, text="=", font=("Helvetica", 16), command=calculate)
equal_button.grid(row=5, column=2, columnspan=2, sticky="nsew")

# 设置网格布局权重
for row in range(5):
    root.grid_rowconfigure(row, weight=1)
for col in range(4):
    root.grid_columnconfigure(col, weight=1)

# 启动主循环
root.mainloop()

A saída é a seguinte: