Python Tkinter官方教程：入门与配置详解

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

本资源是一份关于Python图形库Tkinter的官方使用详细指南，由Fredrik Lundh编写，版权日期为1999年12月1日。Tkinter是Python标准库中的一个重要部分，用于创建GUI（图形用户界面）应用程序，尤其适合初学者入门。 **1. 引言与Tkinter简介** Tkinter提供了Python与Tk工具包的接口，Tk是Tcl/Tk语言的一个图形界面库。Tkinter在第2章中详细介绍了其基本概念，包括什么是Tkinter，以及如何通过简单的例子如"Hello, Tkinter"来启动并运行一个基本的GUI程序。 **2. Hello, Tkinter示例** 这部分内容着重展示了如何创建一个带有窗口、标签、按钮等基本组件的简单应用，并指导读者如何运行和理解这些组件的工作原理。它不仅介绍了如何使用控件，还涉及到控件引用和命名的管理。 **3. 更深入的控件理解和配置** 随后章节讲解了Tkinter的核心类，包括各种控件类（如Button、Label、Frame等）、混入类（如Geometry Mixins处理窗口大小和位置），以及控件配置管理。这涵盖了如何调整控件的外观，如颜色、字体、边框和焦点样式。 **4. 控件配置接口** 此章节深入探讨了控件的配置接口，包括配置方法、向后兼容性，以及如何定制控件的外观和行为。 **5. 事件和绑定** Tkinter中的事件处理是关键部分，它解释了事件的类型、事件对象的结构，以及如何设置实例和类级别的绑定。此外，还介绍了Tkinter支持的协议，包括鼠标和键盘事件处理。 **6. 应用程序窗口与菜单设计** 在应用层面，指南覆盖了基础窗口设计，如顶级窗口、子窗口，以及如何创建和管理菜单系统，帮助开发者构建完整的应用架构。这份文档是一份全面的Tkinter教程，适合希望学习Python图形界面开发的人员，无论是为了个人项目还是职业发展。通过阅读和实践其中提供的代码示例，读者可以掌握如何利用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页未读，继续阅读

luciferdk47

粉丝: 1

Python Tkinter官方教程：入门与配置详解

Tkinter教程.pdf

an-introduction-to-tkinter.pdf

learning tkinter.pdf

python-cours-tkinter.pdf

programmation-avec-tkinter.pdf

programmation-graphique-python-tkinter.pdf

GUI-programming-python-tkinter.pdf

06_Python GUI篇1-tkinter.pdf

最新资源