Python UI开发：Tkinter入门指南

需积分: 10 61 浏览量更新于2024-07-29 收藏 733KB PDF 举报

"这篇文档是关于Tkinter的入门介绍，由Fredrik Lundh撰写，主要讲解Python UI应用程序开发的基础知识。" Tkinter是Python的标准GUI（图形用户界面）库，它允许开发者创建丰富的桌面应用程序。这个文档深入浅出地介绍了Tkinter的核心概念和使用方法。 1. **What's Tkinter?** Tkinter是Python与Tk图形库的接口，它是Python的标准库之一，用于构建跨平台的图形用户界面。Tkinter提供了各种组件，如按钮、文本框、菜单等，使得开发者可以轻松地构建用户友好的交互式应用。 2. **Hello, Tkinter** 这个部分通常会展示一个简单的Tkinter程序示例，比如创建一个窗口并显示一条欢迎消息。运行例子的过程通常包括导入Tkinter库，创建顶级窗口，添加组件，并启动主事件循环。 3. **Hello, Again** 进一步扩展了基础示例，可能涉及更复杂的组件操作，如改变窗口大小、添加控件或处理用户输入。这里还会介绍如何获取和设置组件的属性，以及如何通过函数或方法响应用户操作。 4. **Tkinter Classes** 文档会详细列出Tkinter中的各种类，如Widget类，它们代表了用户界面的基本元素，如Button、Label等。此外，还可能讨论混合类（Mixins）和实现类，它们用于实现特定功能，如几何管理、配置管理等。 5. **Widget Configuration** 这一部分涵盖了如何配置Tkinter组件的属性，如颜色、字体、大小等。配置接口让开发者能动态改变组件的外观和行为。同时，也会提到向后兼容性问题，确保代码在不同版本的Tkinter中都能正常工作。 6. **Widget Styling** 详细解释了如何定义组件的样式，包括颜色（颜色名称、RGB规范）、字体（字体描述符、字体名称、系统字体）、文本格式化、边框、边框样式（Relief）、焦点高亮和光标。 7. **Events and Bindings** Tkinter通过事件和绑定机制来处理用户交互。事件是用户或系统产生的动作，如点击按钮或按下键盘。绑定则是将特定的事件与函数或方法关联起来，以便在事件发生时执行相应操作。文档还会介绍实例和类绑定的区别，以及如何处理协议事件。 8. **Application Windows** 最后，文档会介绍如何创建和管理应用程序窗口，包括基础窗口的创建、菜单的添加等。这有助于构建更加复杂的UI结构，提供多级菜单和子窗口。这个文档适合Python初学者和有经验的开发者，他们希望利用Tkinter创建桌面应用，或者对Tkinter有更深入的理解。通过学习，开发者将能够熟练掌握Tkinter，从而实现丰富的用户界面设计。

Review Copy. Do not redistribute! 1999-12-01 22:15

Chapter 6. Widget Styling

Note that if the family name contains spaces, you must use the tuple syntax described above.

The available styles are

normal, bold, roman, italic, underline, and overstrike.

Tk 8.0 automatically maps

Courier, Helvetica, and Times to their corresponding native family

names on all platforms. In addition, a font specification can never fail under Tk 8.0; if Tk

cannot come up with an exact match, it tries to find a similar font. If that fails, Tk falls back to a

platform-specific default font. Tk's idea of what is “similar enough” probably doesn't

correspond to your own view, so you shouldn't rely too much on this feature.

Tk 4.2 under Windows supports this kind of font descriptors as well. There are several

restrictions, including that the family name must exist on the platform, and not all the above

style names exist (or rather, some of them have different names).

Font names

In addition, Tk 8.0 allows you to create named fonts and use their names when specifying fonts

to the widgets.

The

tkFont module provides a Font class which allows you to create font instances. You can use

such an instance everywhere Tkinter accepts a font specifier. You can also use a font instance

to get font metrics, including the size occupied by a given string written in that font.

tkFont.Font(family="Times", size=10, weight=tkFont.BOLD)

tkFont.Font(family="Helvetica", size=10, weight=tkFont.BOLD,

slant=tkFont.ITALIC)

tkFont.Font(family="Symbol", size=8)

If you modify a named font (using the config method), the changes are automatically

propagated to all widgets using the font.

The

Font constructor supports the following style options (note that the constants are defined

in the

tkFont module):

Table 6-1. Font Style Options

Option Type Description

Chapter 6. Widget Styling

Option Type Description

family

string Font family.

size

integer Font size in points. To give the size in pixels, use a

negative value.

weight

constant Font thickness. Use one of NORMAL or BOLD. Default

NORMAL.

slant

constant Font slant. Use one of NORMAL or ITALIC. Default is

NORMAL.

underline

flag Font underlining. If 1 (true), the font is underlined.

Default is 0 (false).

overstrike

flag Font strikeout. If 1 (true), a line is drawn over text

written with this font. Default is 0 (false).

System fonts

Tk also supports system specific font names. Under X, these are usually font aliases like fixed,

6x10, etc.

Under Windows, these include

ansi, ansifixed, device, oemfixed, system, and systemfixed:

On the Macintosh, the system font names are application and system.

Note that the system fonts are full font names, not family names, and they cannot be combined

with size or style attributes. For portability reasons, avoid using these names wherever

possible.

X Font Descriptors

X Font Descriptors are strings having the following format (the asterisks represent fields that

are usually not relevant. For details, see the Tk documentation, or an X manual):

-*-family-weight-slant-*--*-size-*-*-*-*-charset

The font family is typically something like Times, Helvetica, Courier or Symbol.

The weight is either

Bold or Normal. Slant is either R for “roman” (normal), I for italic, or O for

oblique (in practice, this is just another word for italic).

Size is the height of the font in decipoints (that is, points multiplied by 10). There are usually

72 points per inch, but some low-resolution displays may use larger “logical” points to make

Review Copy. Do not redistribute! 1999-12-01 22:15

Chapter 6. Widget Styling

sure that small fonts are still legible. The character set, finally, is usually

ISO8859-1 (ISO Latin

1), but may have other values for some fonts.

The following descriptor requests a 12-point boldface Times font, using the ISO Latin 1

character set:

-*-Times-Bold-R-*--*-120-*-*-*-*-ISO8859-1

If you don't care about the character set, or use a font like Symbol which has a special character

set, you can use a single asterisk as the last component:

-*-Symbol-*-*-*--*-80-*

A typical X server supports at least Times, Helvetica, Courier, and a few more fonts, in sizes like

8, 10, 12, 14, 18, and 24 points, and in normal, bold, and italic (

Times) or oblique (Helvetica,

Courier) variants. Most servers also support freely scaleable fonts. You can use programs like

xlsfonts and xfontsel to check which fonts you have access to on a given server.

This kind of font descriptors can also be used on Windows and Macintosh. Note that if you use

Tk 4.2, you should keep in mind that the font family must be one supported by Windows (see

above).

Text Formatting

While text labels and buttons usually contain a single line of text, Tkinter also supports

multiple lines. To split the text across lines, simply insert newline characters (

\n) where

necessary.

By default, the lines are centered. You can change this by setting the

justify option to LEFT or

RIGHT. The default value is CENTER.

You can also use the

wraplength option to set a maximum width, and let the widget wrap the

text over multiple lines all by itself. Tkinter attempts to wrap on whitespace, but if the widget is

too narrow, it may break individual words across lines.

Borders

All Tkinter widgets have a border (though it's not visible by default for some widgets). The

border consists of an optional 3D relief, and a focus highlight region.

Relief

The relief settings control how to draw the widget border:

borderwidth (or bd) is the width of the border, in pixels. Most widgets have a default

borderwidth of one or two pixels. There's hardly any reason to make the border wider than

that.

relief controls how to draw the 3D border. It can be set to one of SUNKEN, RAISED, GROOVE,

RIDGE, and FLAT.

Chapter 6. Widget Styling

Focus Highlights

The highlight settings control how to indicate that the widget (or one of its children) has

keyboard focus. In most cases, the highlight region is a border outside the relief. The following

options control how this extra border is drawn:

The

highlightcolor is used to draw the highlight region when the widget has keyboard focus. It's

usually black, or some other distinct contrast color.

The

highlightbackground is used to draw the highlight region when the widget doesn't have

focus. It's usually same as the widget background.

The

highlightthickness option is the width of the highlight region, in pixels. It is usually one or

two pixels for widgets that can take keyboard focus.

Cursors

The cursor option control which mouse cursor to use when the mouse is moved over the

widget. If this option isn't set, the widget uses the same mouse pointer as its parent.

Note that some widgets, including the

Text and Entry widgets, set this option by default.

Review Copy. Do not redistribute! 1999-12-01 22:15

Chapter 7. Events and Bindings

As was mentioned earlier, a Tkinter application spends most of its time inside an event loop

(entered via the

mainloop method). Events can come from various sources, including key

presses and mouse operations by the user, and redraw events from the window manager

(indirectly caused by the user, in many cases).

Tkinter provides a powerful mechanism to let you deal with events yourself. For each widget,

you can

bind Python functions and methods to events.

widget.bind(event, handler)

If an event matching the event description occurs in the widget, the given handler is called with

an object describing the event.

Here's a simple example:

Example 7-1. Capturing clicks in a window

# File: bind1.py

from Tkinter import *

root = Tk()

def callback(event):

print "clicked at", event.x, event.y

frame = Frame(root, width=100, height=100)

frame.bind("<Button-1>", callback)

frame.pack()

root.mainloop()

In this example, we use the bind method of the frame widget to bind a callback function to an

event called

<Button-1>. Run this program and click in the window that appears. Each time

you click, a message like “

clicked at 44 63” is printed to the console window.

Events

Events are given as strings, using a special event syntax:

<modifier-type-detail>

The type field is the most important part of an event specifier. It specifies the kind of event that

we wish to bind, and can be user actions like

Button, and Key, or window manager events like

Enter, Configure, and others. The modifier and detail fields are used to give additional

information, and can in many cases be left out. There are also various ways to simplify the

Chapter 7. Events and Bindings

event string; for example, to match a keyboard key, you can leave out the angle brackets and

just use the key as is. Unless it is a space or an angle bracket, of course.

Instead of spending a few pages on discussing all the syntactic shortcuts, let's take a look on the

most common event formats:

Table 7-1. Event Formats

Event Description

<Button-1>

A mouse button is pressed over the widget. Button 1 is the leftmost

button, button 2 is the middle button (where available), and button 3 the

rightmost button. When you press down a mouse button over a widget,

Tkinter will automatically “grab” the mouse pointer, and mouse events

will then be sent to the current widget as long as the mouse button is held

down. The current position of the mouse pointer (relative to the widget)

is provided in the

x and y members of the event object passed to the

callback.

You can use

ButtonPress instead of Button, or even leave it out

completely:

<Button-1>, <ButtonPress-1>, and <1> are all synonyms.

For clarity, I prefer the

<Button-1> syntax.

<B1-Motion>

The mouse is moved, with mouse button 1 being held down (use B2 for

the middle button, B3 for the right button). The current position of the

mouse pointer is provided in the

x and y members of the event object

passed to the callback.

<Button-

Release-1>

Button 1 was released. The current position of the mouse pointer is

provided in the

x and y members of the event object passed to the

callback.

<Double-

Button-1>

Button 1 was double clicked. You can use Double or Triple as prefixes.

Note that if you bind to both a single click (<

Button-1>) and a double

click, both bindings will be called.

<Enter>

The mouse pointer entered the widget (this event doesn't mean that the

user pressed the Enter key!).

<Leave>

The mouse pointer left the widget.

The user pressed the Enter key. You can bind to virtually all keys on the

keyboard. For an ordinary 102-key PC-style keyboard, the special keys

are Cancel (the Break key), BackSpace, Tab, Return(the Enter key),

Shift_L (any Shift key), Control_L (any Control key), Alt_L (any Alt

key), Pause, Caps_Lock, Escape, Prior (Page Up), Next (Page

Down), End, Home, Left, Up, Right, Down, Print, Insert, Delete,

F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, Num_Lock, and

Scroll_Lock.

<Key>

The user pressed any key. The key is provided in the char member of the

event object passed to the callback (this is an empty string for special

keys).

Review Copy. Do not redistribute! 1999-12-01 22:15

Chapter 7. Events and Bindings

Event Description

The user typed an “a”. Most printable characters can be used as is. The

exceptions are space (

<space>) and less than (<less>). Note that 1 is a

keyboard binding, while

<1> is a button binding.

<Shift-Up>

The user pressed the Up arrow, while holding the Shift key pressed. You

can use prefixes like Alt, Shift, and Control.

The widget changed size (or location, on some platforms). The new size is

provided in the

width and height attributes of the event object passed to

the callback.

The Event Object

The event object is a standard Python object instance, with a number of attributes describing

the event.

Table 7-2. Event Attributes

Attribute Description

widget

The widget which generated this event. This is a valid Tkinter widget

instance, not a name. This attribute is set for all events.

x, y

The current mouse position, in pixels.

x_root, y_root

The current mouse position relative to the upper left corner of the screen,

in pixels.

char

The character code (keyboard events only), as a string.

keysym

The key symbol (keyboard events only).

keycode

The key code (keyboard events only)

num

The button number (mouse button events only)

width, height

The new size of the widget, in pixels (Configure events only).

type

The event type.

For portability reasons, you should stick to char, height, width, x, y, x_root, y_root, and widget

unless you know exactly what you're doing...

Instance and Class Bindings

The bind method we used in the above example creates an instance binding. This means that

the binding applies to a single widget only; if you create new frames, they will not inherit the

bindings.

But Tkinter also allows you to create bindings on the class and application level; in fact, you

can create bindings on four different levels:

Chapter 7. Events and Bindings

• the widget instance, using bind.

• the widget's toplevel window (Toplevel or root), also using bind.

• the widget class, using bind_class (this is used by Tkinter to provide standard bindings).

• the whole application, using bind_all.

For example, you can use

bind_all to create a binding for the F1 key, so you can provide help

everywhere in the application. But what happens if you create multiple bindings for the same

key, or provide overlapping bindings?

First, on each of these four levels, Tkinter chooses the “closest match” of the available bindings.

For example, if you create instance bindings for the

<Key> and <Return> events, only the

second binding will be called if you press the Enter key.

However, if you add a

<Return> binding to the toplevel widget, both bindings will be called.

Tkinter first calls the best binding on the instance level, then the best binding on the toplevel

window level, then the best binding on the class level (which is often a standard binding), and

finally the best available binding on the application level. So in an extreme case, a single event

may call four event handlers.

A common cause of confusion is when you try to use bindings to override the default behavior

of a standard widget. For example, assume you wish to disable the Enter key in the text widget,

so that the users cannot insert newlines into the text. Maybe the following will do the trick?

def ignore(event):

pass

text.bind("<Return>", ignore)

or, if you prefer one-liners:

text.bind("<Return>", lambda e: None)

(the lambda function used here takes one argument, and returns None)

Unfortunately, the newline is still inserted, since the above binding applies to the instance level

only, and the standard behavior is provided by a class level bindings.

You could use the

bind_class method to modify the bindings on the class level, but that would

change the behavior of all text widgets in the application. An easier solution is to prevent

Tkinter from propagating the event to other handlers; just return the string “

break” from your

event handler:

def ignore(event):

return "break"

text.bind("<Return>", ignore)

text.bind("<Return>", lambda e: "break")

By the way, if you really want to change the behavior of all text widgets in your application,

here's how to use the

bind_class method:

top.bind_class("Text", "<Return>", lambda e: None)

剩余89页未读，继续阅读

wanbosen

粉丝: 7
资源: 4

Python UI开发：Tkinter入门指南

Tkinter简介An Introduction to Tkinter

an-introduction-to-tkinter.pdf

An Introduction to Tkinter【last updated in November 2005】.pdf

中文An Introduction to Tkinter

Tkinter教程

Tkinter实例

Tkinter教程.doc

python的tkinter编程

python Tkinter参考资料

Tkinter编程代码示例

最新资源