Python GUI编程：Tkinter入门指南

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

"an-introduction-to-tkinter.pdf - 英文版" 《An Introduction to Tkinter》是由Fredrik Lundh编写的，这本书是关于Python GUI编程的入门指南，特别关注Tkinter库的使用。Tkinter是Python的标准GUI库，允许开发者创建桌面应用程序。 1. **Tkinter是什么?** Tkinter是Python的默认图形用户界面库，它基于Tcl/Tk库。它提供了一种简单的方式来创建交互式的窗口和控件，使得程序员能够快速地构建用户界面而无需深入学习底层图形系统。 2. **Hello, Tkinter** 这个部分介绍了如何运行Tkinter的第一个示例程序，通常是一个简单的"Hello, World!"程序。这个例子展示了如何导入Tkinter库，创建主窗口，并显示基本的文本信息。 3. **Hello, Again** 在这一章，作者深入讨论了如何操作和修改窗口中的文本，以及如何再次显示信息。这包括对控件的引用和命名的理解，以便于在程序中对它们进行操作。 4. **Tkinter类** 这一部分介绍Tkinter中的不同类，如控件（widgets）类，混合类（mixins），以及实现混合类和几何管理混合类。控件类包括按钮、文本框、标签等，而混合类则提供了额外的功能。 5. **控件配置** Tkinter提供了配置接口来改变控件的外观和行为，如大小、颜色、字体等。这里还提到了向后兼容性，意味着新版本的Tkinter仍能处理旧代码的配置方式。 6. **控件样式** 这一章节涵盖了颜色、字体、边框、高亮、救济效果、焦点提示和光标等主题，这些都是控制控件视觉效果的关键元素。 7. **事件和绑定** 事件是用户与应用程序交互的方式，如点击按钮或移动鼠标。事件绑定让开发者可以定义响应这些事件的函数。事件对象包含了关于事件的详细信息，而实例和类绑定允许你指定哪些对象应响应特定事件。此外，还有协议，如键盘快捷键和窗口关闭请求的处理。 8. **应用窗口** 应用窗口不仅包括主窗口，还包括菜单和其他窗口部件。菜单是用户界面的重要组成部分，提供了命令的集合，可以通过单击或使用快捷键来执行。以上是对《An Introduction to Tkinter》的简要概述，这本书详细介绍了Tkinter的基本概念和高级特性，对于想要在Python中开发GUI应用的人来说是一份宝贵的资源。通过深入学习，开发者将能够创建功能丰富的、用户友好的桌面应用程序。

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页未读，继续阅读

Iamtheodore

粉丝: 5
资源: 95

Python GUI编程：Tkinter入门指南

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

Tkinter简介An Introduction to Tkinter

中文An Introduction to Tkinter

Tkinter代码与实例大全(Tkinter Programming Code By Examples).pdf

Python 2.6 Graphics Cookbook.pdf

Introduction to Programming Using Python (英文版)

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

数学建模学习资料 神经网络算法 参考资料-Matlab 共26页.pptx

happybirthday2 升级版生日祝福密码0000(7).zip

ssm框架Java项目源码-基于web技术的税务门户网站的实现+vue毕设-大作业.zip

最新资源

数学建模学习资料神经网络算法参考资料-Matlab 共26页.pptx