Python标准GUI工具包：现代Tkinter快速开发美观界面指南

需积分: 50 75 浏览量更新于2024-07-19 收藏 2.07MB PDF 举报

本资源是一本名为《Modern Tkinter for Busy Python Developers》的教程，作者是Mark Roseman，专注于介绍如何利用Python的标准GUI工具包Tkinter快速创建适用于Windows、Mac和Linux系统的漂亮用户界面。该教程旨在帮助忙碌的Python开发者掌握现代Tkinter的最佳实践，并提供了详细的安装步骤和实际示例。首先，教程从介绍开始，明确了目标读者群体——那些希望提升Tkinter技能的开发者。随后，章节"Modern Best Practices"阐述了当前最佳的Tkinter开发策略，强调了与时俱进的方法和技巧，以适应不断变化的软件开发环境。安装部分占据了教程的重要位置，分别讲解了在不同操作系统上安装Tkinter的方法，包括在Mac OS X上的Homebrew、ActiveTcl的安装，以及在Windows和Linux（通过系统包管理器或自定义安装ActivePython及编译标准Python发行版）的安装步骤。作者还强调了安装验证的重要性，确保Tkinter环境的正确配置。紧接着，作者引导读者通过一个"Obligatory First Program"实例来熟悉基本概念，展示了一个真实的编程例子，涉及设计、代码编写以及编码风格指南。在"Step-by-Step Walkthrough"中，作者逐步解析代码，使初学者能更好地理解和应用。 "Tk Concepts"章节深入探讨了Tkinter的核心概念，如组件（Widgets）、窗口层次结构、创建和使用控件、配置选项、布局管理和事件处理机制。这里详细介绍了各类基础控件如Frame、Label的功能和用法，以及如何处理大小调整、边距、边框、样式更改以及文本和图像的显示。 "Event Handling"部分特别关注事件驱动编程，包括命令回调（Command Callbacks）、事件绑定（Event Bindings）、虚拟事件（Virtual Events）和多绑定（Multiple Bindings），这些都是构建动态用户界面的关键要素。这本教程提供了一套全面且实用的Tkinter指南，帮助开发者快速上手并掌握Python的图形用户界面开发，无论是对于初次接触Tkinter的新手，还是有一定经验的开发者，都具有很高的参考价值。通过学习和实践，开发者可以为他们的项目创建出功能齐全、界面美观的应用程序。

mainframe = ttk.Frame(root, padding="3 3 12 12")

mainframe.grid(column=0, row=0, sticky=(N, W, E, S))

mainframe.columnconfigure(0, weight=1)

mainframe.rowconfigure(0, weight=1)

feet = StringVar()

meters = StringVar()

feet_entry = ttk.Entry(mainframe, width=7, textvariable=feet)

feet_entry.grid(column=2, row=1, sticky=(W, E))

ttk.Label(mainframe, textvariable=meters).grid(column=2, row=2, sticky=(W, E))

ttk.Button(mainframe, text="Calculate", command=calculate).grid(column=3, row=3,

sticky=W)

ttk.Label(mainframe, text="feet").grid(column=3, row=1, sticky=W)

ttk.Label(mainframe, text="is equivalent to").grid(column=1, row=2, sticky=E)

ttk.Label(mainframe, text="meters").grid(column=3, row=2, sticky=W)

for child in mainframe.winfo_children(): child.grid_configure(padx=5, pady=5)

feet_entry.focus()

root.bind('<Return>', calculate)

root.mainloop()

And the resulting user interface:

Screenshot of our completed feet to meters user interface (on Mac OS X, Windows and Linux).

A Note on Coding Style

Each of the languages included in this tutorial has a variety of coding styles and conventions

available to choose from, which help determine conventions for variable and function naming,

procedural, functional or object-oriented styles, and so on.

Because the focus on this tutorial is Tk, this tutorial will keep things as simple as possible, generally

using a very direct coding style, rather than wrapping up most of our code in procedures, modules,

objects, classes and so on. As much as possible, you'll also see the same names for objects,

variables, etc. used across the languages for each example.

Step-by-Step Walkthrough

Let's take a closer look at that code, piece by piece. For now, all we're trying to do is get a basic

understanding of the types of things we need to do to create a user interface in Tk, and roughly what

those things look like. We'll go into details later.

from tkinter import *

from tkinter import ttk

These two lines tell Python that our program needs two modules. The first, "tkinter", is the

standard binding to Tk, which when loaded also causes the existing Tk library on your system to be

loaded. The second, "ttk", is Python's binding to the newer "themed widgets" that were added to

Tk in 8.5.

Notice that we've imported everything from the tkinter module, so that we can call tkinter functions

etc. without prefixing them, which is standard Tkinter practice. However, because we've imported

just "ttk" itself, that means we'll need to prefix anything inside that module. So for example

calling "Entry(...)" would invoke the function inside the tkinter module, while we'd need

"ttk.Entry(...)" to invoke the function inside ttk. As you'll see, several functions are

defined in both modules, and sometimes you will need both, depending on the context. Making the

ttk calls explicit facilitates this, and will be the style used in this tutorial.

One of the first things you'll find if you're migrating new code over, is that the name of the Tkinter

module is now lowercase, i.e. "tkinter", rather than "Tkinter". This was changed as of Python 3.0.

root = Tk()

root.title("Feet to Meters")

mainframe = ttk.Frame(root, padding="3 3 12 12")

mainframe.grid(column=0, row=0, sticky=(N, W, E, S))

mainframe.columnconfigure(0, weight=1)

mainframe.rowconfigure(0, weight=1)

Yes, the "calculate" function appeared before this. We'll describe it down below, but need to

include it near the start because we reference it in other parts of the program.

Next, the above lines set up the main window, giving it the title "Feet to Meters". Next, we create a

frame widget, which will hold all the content of our user interface, and place that in our main

window. The "columnconfigure"/"rowconfigure" bits just tell Tk that if the main

window is resized, the frame should expand to take up the extra space.

Strictly speaking, we could just put the other parts of our interface directly into the main root

window, without the intervening content frame. However, the main window isn't itself part of the

"themed" widgets, so its background color wouldn't match the themed widgets we will put inside it.

Using a "themed" frame widget to hold the content ensures that the background is correct.

feet = StringVar()

meters = StringVar()

feet_entry = ttk.Entry(mainframe, width=7, textvariable=feet)

feet_entry.grid(column=2, row=1, sticky=(W, E))

ttk.Label(mainframe, textvariable=meters).grid(column=2, row=2, sticky=(W, E))

ttk.Button(mainframe, text="Calculate", command=calculate).grid(column=3, row=3,

sticky=W)

The preceding lines create the three main widgets in our program: the entry where we type the

number of feet in, a label where we put the resulting number of meters, and the calculate button that

we press to perform the calculation.

For each of the three widgets, we need to do two things: create the widget itself, and then place it

onscreen. All three widgets, which are 'children' of our content window are created as instances of

one of Tk's themed widget classes. At the same time as we create them, we give them certain

options, such as how wide the entry is, the text to put inside the Button, etc. The entry and label

each are assigned a mysterious "textvariable"; we'll see what that does shortly.

If the widgets are just created, they won't automatically show up on screen, because Tk doesn't

know how you want them to be placed relative to other widgets. That's what the "grid" part does.

Remembering the layout grid for our application, we place each widget in the appropriate column

(1, 2 or 3), and row (also 1, 2 or 3). The "sticky" option says how the widget would line up

within the grid cell, using compass directions. So "w" (west) means anchor the widget to the left

side of the cell, "we" (west-east) means anchor it to both the left and right sides, and so on.

ttk.Label(mainframe, text="feet").grid(column=3, row=1, sticky=W)

ttk.Label(mainframe, text="is equivalent to").grid(column=1, row=2, sticky=E)

ttk.Label(mainframe, text="meters").grid(column=3, row=2, sticky=W)

The above three lines do exactly the same thing for the three static text labels in our user interface;

create each one, and place it onscreen in the appropriate cell in the grid.

for child in mainframe.winfo_children(): child.grid_configure(padx=5, pady=5)

feet_entry.focus()

root.bind('<Return>', calculate)

The preceeding three lines help put some nice finishing touches on our user interface.

The first line walks through all of the widgets that are children of our content frame, and adds a

little bit of padding around each, so they aren't so scrunched together. We could have added these

options to each "grid" call when we first put the widgets onscreen, but this is a nice shortcut.

The second line tells Tk to put the focus on our entry widget. That way the cursor will start in that

field, so the user doesn't have to click in it before starting to type.

The third line tells Tk that if the user presses the Return key (Enter on Windows) anywhere within

the root window, that it should call our calculate routine, the same as if the user pressed the

Calculate button.

def calculate(*args):

try:

value = float(feet.get())

meters.set((0.3048 * value * 10000.0 + 0.5)/10000.0)

except ValueError:

pass

Here we define our calculate procedure, which is called either when the user presses the Calculate

button, or hits the Return key. It performs the feet to meters calculation, taking the number of feet

from our entry widget, and placing the result in our label widget.

Say what? It doesn't look like we're doing anything with those widgets! Here's where the magic

"textvariable" options we specified when creating the widgets come into play. We specified

the global variable "feet" as the textvariable for the entry, which means that anytime the entry

changes, Tk will automatically update the global variable feet. Similarly, if we explicitly change the

value of a textvariable associated with a widget (as we're doing for "meters" which is attached to

our label), the widget will automatically be updated with the current contents of the variable. Slick.

root.mainloop()

This final line tells Tk to enter its event loop, which is needed to make everything run.

What's Missing

It's also worth examing what we didn't have to include in our Tk program to make it work. For

example:

• we didn't have to worry about redrawing the screen as things changed

• we didn't have to worry about parsing and dispatching events, hit detection, or handling

events on each widget

• we didn't have to provide a lot of options when we created widgets; the defaults seemed to

take care of most things, and so we only had to change things like the text the button

displayed

• we didn't have to write complex code to get and set the values of simple widgets; we just

attached them to variables

• we didn't have to worry about what happens when the user closes the window or resizes it

• we didn't need to write extra code to get this all to work cross-platform

Tk Concepts

With a first example behind you, you should have a basic idea of what a Tk program might look like

and the types of tasks it needs to accomplish. We'll step back and look at three broad concepts that

you need to know to understand Tk: widgets, geometry management, and event handling.

Widgets

Widgets are all the things that you see onscreen. In our example, we had a button, an entry, a few

labels, and a frame. Others are things like checkboxes, tree views, scrollbars, text areas, and so on.

剩余143页未读，继续阅读

sinat_25018475

粉丝: 0

Python标准GUI工具包：现代Tkinter快速开发美观界面指南

利用Tkinter简化Python GUI打包大小

Tkinter入门指南：Python GUI编程基础

Tkinter打造Python GUI效率胜过Qt5，节省77.5%文件大小

Tkinter是Python的标准GUI库.docx

tkinter 是 Python 的标准 GUI（图形用户界面）库，用于创建窗口应用程序 它是 Tk 图形用户界面工具包的 Py

tkinter-designer:A Gui Designer for Tkinter of Python embedding in VB6 (直接使用VB6设计Tkinter GUI界面), Muliti-Languages supported

Airlines-Reservation-Program:航空公司预订计划可帮助维护航空公司的日常预订，航班数据和航班预订。它使用通过Tkinter-Python编码的GUI界面，并以.txt格式存储数据

Python-GUI-Programming-with-Tkinter:Packt发布的使用Tkinter进行Python GUI编程

tkinter（python gui编程）

tkinter-tutorial:使用 Tkinter 学习 Python GUI

最新资源

tkinter 是 Python 的标准 GUI（图形用户界面）库，用于创建窗口应用程序它是 Tk 图形用户界面工具包的 Py