Python Tkinter TTK 深入指南

4星 · 超过85%的资源需积分: 50 85 浏览量更新于2024-07-19 15 收藏 2.03MB PDF 举报

"Python的Tkinter库是用于创建图形用户界面（GUI）的工具，而ttk模块则是Tkinter的一个扩展，提供了更现代、更符合平台风格的控件和界面设计。本教程主要针对tkinter的ttk应用进行深入讲解，旨在帮助开发者实现更加美观和功能丰富的GUI应用。" 在Python的GUI编程中，Tkinter是内置的标准库之一，它是基于Tk图形库的接口。Tkinter虽然功能强大，但其默认的控件样式在现代操作系统中显得较为过时。ttk模块，全称为“Themed Tk”，解决了这个问题，它引入了主题机制，使得应用程序可以拥有与操作系统更一致的外观。 1. **现代最佳实践**：使用ttk可以使你的GUI应用看起来更加现代化，符合当前操作系统的设计风格。这包括控件的样式、颜色、边框等，ttk提供了更多的定制选项。 2. **Tk扩展**：ttk不仅包含了一些新的控件，还对原有的Tk控件进行了改进。例如，ttk的Frame控件允许更复杂的布局管理，提供更好的嵌套和组织能力。 3. **控件类**：ttk提供了多种新控件，如：Progressbar、treeview、scale等，以及增强的Button、Checkbutton、Radiobutton和Entry等。这些控件具有更丰富的功能和样式选择。 4. **窗口层级**：ttk支持窗口和控件的层次结构，使得可以构建复杂布局的界面。 5. **配置选项**：每个ttk控件都有大量的配置选项，可以调整大小、颜色、字体、边距、背景等，从而实现高度定制的界面设计。 6. **几何管理**：ttk遵循Tk的几何管理原则，如pack、grid和place，帮助开发者控制窗口和控件在屏幕上的位置和大小。 7. **事件处理**：ttk控件支持事件驱动编程，包括命令回调和事件绑定。开发者可以定义响应用户操作的函数，如点击按钮、输入文字等。 8. **虚拟事件**：ttk支持虚拟事件，允许自定义事件并绑定相应的处理函数，增加了程序的灵活性。 9. **基本控件**：例如，ttk的Label控件不仅可以显示文本，还可以显示图像；Button控件可设置文本或图像，以及命令回调；Checkbutton和Radiobutton则用于单选或多选；Entry控件则用于用户输入文本，支持密码模式；Combobox提供下拉列表功能，方便用户选择。 10. **验证**：ttk的Entry控件支持数据验证，可以限制用户输入的格式，保证数据的正确性。本教程将逐步介绍如何安装Tkinter和ttk，并通过实例代码展示如何使用这些控件和功能，从设计到编码，再到实现特定功能，帮助开发者熟练掌握ttk的用法，提升GUI开发技能。

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 willautomatically 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. Widgets are what are often referred to as

"controls"; you'll also often see them referred to as "windows", particularly in Tk's documentation, a holdover from its X11

roots (so under that terminology, both a toplevel window and things like a button would be called windows).

Here is an example showing some of Tk's widgets, which we'll cover individually shortly.

Widget Classes

Widgets are objects, instances of classes that represent buttons, frames, and so on. So the first thing you'll need to do is

identify the specific class of the widget you'd like to instantiate. This tutorial and the widget roundup will help with that.

Window Hierarchy

The other thing you'll need to know is the parent of the widget instance you'd like to create. In Tk, all widgets are part of

a window hierarchy, with a single root at the top of the hierarchy. This hierarchy can be arbitrarily deep; so you might have

a button in a frame in another frame within the root window. Even a new toplevel window is part of that same hierarchy,

with it and all its contents forming a subtree of the overall window hierarchy.

In our metric conversion example, we had a single frame that was created as a child of the root window, and that frame

had all the other controls as children. The root window was a container for the frame, and was therefore the

frame's parent. The complete hierarchy for the example looked like this:

The window hierarchy of the metric conversion example.

Creating and Using Widgets

Each separate widget is a Python object. When creating a widget, you must pass its parent as a parameter to the widget

creation function. The only exception is the "root" window, which is the toplevel window that will contain everything else.

That is automatically created, and it does not have a parent. For example:

root = Tk()

content = ttk.Frame(root)

button = ttk.Button(content)

Whether or not you save the widget object in a variable is entirely up to you, and depends of course whether you'll need to

refer to it later. Because the object is inserted into the widget hierarchy, it won't be garbage collected even if you don't

keep your own reference to it.

If you snuck a peak at how Tcl manages widgets, you'll see each widget has a specific pathname; you'll also see

this pathname referred to in Tk reference documentation. Tkinter chooses and manages all these pathnames for

you behind the scenes, so you should never have to worry about them. If you do though, you can get the

pathname from a widget by calling "str(widget)".

Configuration Options

All widgets also have a number of different configuration options, which generally control how they are displayed or how

they behave.

The options that are available depend upon the widget class of course. There is a lot of consistency between different

widget classes, so options that do pretty much the same thing tend to be named the same. So both a button and a label

have a "text" option to adjust the text the widget displays, while a scrollbar for example would not have a "text" option

since it's not needed. In the same way, the button has a "command" option telling it what to do when pushed, while a label,

which holds just static text, does not.

Configuration options can be set when the widget is first created, by passing along the names and values of the options as

optional parameters. You can later check what the value of those options are, and with a very small number of exceptions,

change them at any time. If you're not sure what all the different options are for a widget, you can ask the widget to

provide it. This gives you a long list of all the options, and for each option, you can see the name of the option and its

current value (along with three other attributes which you won't normally need to worry about).

This is all best illustrated with the following interactive dialog with the interpreter.

% python

>>> from tkinter import *

>>> from tkinter import ttk

>>> root = Tk()

create a button, passing two options:

>>> button = ttk.Button(root, text="Hello", command="buttonpressed")

>>> button.grid()

check the current value of the text option:

>>> button['text']

'Hello'

change the value of the text option:

>>> button['text'] = 'goodbye'

another way to do the same thing:

>>> button.configure(text='goodbye')

check the current value of the text option:

>>> button['text']

'goodbye'

get all information about the text option:

>>> button.configure('text')

('text', 'text', 'Text', '', 'goodbye')

get information on all options for this widget:

>>> button.configure()

{'cursor': ('cursor', 'cursor', 'Cursor', '', ''), 'style': ('style', 'style', 'Style', '', ''),

'default': ('default', 'default', 'Default', <index object at 0x00DFFD10>, <index object at 0x00DFFD10>),

'text': ('text', 'text', 'Text', '', 'goodbye'), 'image': ('image', 'image', 'Image', '', ''),

'class': ('class', '', '', '', ''), 'padding': ('padding', 'padding', 'Pad', '', ''),

'width': ('width', 'width', 'Width', '', ''),

'state': ('state', 'state', 'State', <index object at 0x0167FA20>, <index object at 0x0167FA20>),

'command': ('command', 'command' , 'Command', '', 'buttonpressed'),

'textvariable': ('textvariable', 'textVariable', 'Variable', '', ''),

'compound': ('compound', 'compound', 'Compound', <index object at 0x0167FA08>, <index object at 0x0167FA08>),

'underline': ('underline', 'underline', 'Underline', -1, -1),

'takefocus': ('takefocus', 'takeFocus', 'TakeFocus', '', 'ttk::takefocus')}

Geometry Management

If you've been playing around creating widgets, you've probably noticed that just by creating them they didn't end up

showing up onscreen. Having things actually put in the onscreen window, and precisely where in the window they show up

is a separate step called geometry management.

In our example, this positioning was accomplished by the "grid" command, where we passed along the column and row

we wanted each widget to go in, how things were to be aligned within the grid, and so on. Grid is an example of

a geometry manager (of which there are several in Tk, grid being the most useful). We'll talk about grid in detail in a later

chapter, but for now we'll look at geometry management in general.

A geometry manager's job is to figure out exactly where those widgets are going to be put. This turns out to be a very

difficult optimization problem, and a good geometry manager relies on quite complex algorithms. A good geometry

manager provides the flexibility, power and ease of use that makes programmers happy, and Tk's"grid" is without a doubt

one of the absolute best. A poor geometry manager... well, all the Java programmers who have suffered through

"GridBagLayout" please raise their hands.

The Problem

The problem for a geometry manager is to take all the different widgets the program creates, plus the instructions for

where in the window the program would like things to go (explicitly, or more often, relative to other widgets), and then

actually put them in the window.

In doing so, the geometry manager has to balance a number of different constraints:

•The widgets may have a "natural" size (e.g. the natural width of a label would normally be determined by the text and

font in it), but the toplevel all these different widgets are trying to fit into isn't big enough to accommodate them; the

geometry manager must decide which widgets to shrink to fit, by how much, etc.

•If the toplevel window is bigger than the natural size of all the widgets, how is the extra space used? Is it just used for

extra space between widgets, and if so, how is that space distributed? Is it used to make certain widgets bigger than

they normally want to be?

•If the toplevel window is resized, how does the size and position of the widgets in it change? Will certain areas (e.g. a

text entry area) expand or shrink, while other parts stay the same size, or is the area distributed differently? Do certain

widgets have a minimum (or maximum) size that you want to avoid going under (over)?

•How can widgets in different parts of the user interface be aligned with each other, to present a clean layout and

match platform guidelines to do with inter-widget spacing?

•For a complex user interface, which may have many frames nested in other frames nested in the window (etc.), how

can all the above be accomplished, trading off the conflicting demands of different parts of the entire user interface?

How it Works

Geometry management in Tk relies on the concept of master and slave widgets. A master is a widget, typically a toplevel

window or a frame, which will contain other widgets, which are called slaves. You can think of a geometry manager as

taking control of the master widget, and deciding what will be displayed within.

The geometry manager will ask each slave widget for its natural size, or how large it would ideally like to be displayed. It

then takes that information and combines it with any parameters provided by the program when it asks the geometry

manager to manage that particular slave widget. In our example, we passed grid a"column" and "row" number for each

widget, which indicated the relative position of the widget with respect to others, and also a "sticky" parameter to suggest

how the widget should be aligned or possibly stretched. We also used "columnconfigure" and "rowconfigure" to indicate

the columns and rows we'd like to have expand if there is extra space available in the window. Of course, all these

parameters are specific to grid; other geometry managers would use different ones.

剩余86页未读，继续阅读

编程之路从0到1

粉丝: 1w+
资源: 8

Python Tkinter TTK 深入指南

ttkbootstrap:Tkinter TTK的现代主题集合

Tkinter教程

Python tkinter 下拉日历控件代码

Python Tkinter Extensions:Tkinter / Ttk的其他图形类和小部件-开源

通过python连接mysql的图书管理系统，图形界面采用python'原生的tkinter以及ttk.zip

Python Tkinter入门指南：详细教程与实例

tkinter ttk详细教程

Tkinter中ttk

tkinter和tkinter.ttk如何混用

from tkinter import ttk

最新资源