Python tkinter图形界面编程高清教程

5星 · 超过95%的资源需积分: 50 78 浏览量更新于2024-07-19 4 收藏 760KB PDF 举报

"Python的Tkinter高清文档，由Fredrik Lundh编写，全面介绍Tkinter库，包含高清内容，适合学习和参考。" Tkinter是Python的内置GUI（图形用户界面）库，它允许开发者创建丰富的桌面应用程序。这个文档由Fredrik Lundh编著，提供了深入的Tkinter教程和指南。 1. **什么是Tkinter？** Tkinter是Python与Tk GUI工具包的接口。Tk是一个轻量级、可移植的GUI库，可以在多种操作系统上运行，包括Windows、Linux和Mac OS。Tkinter是Python的标准GUI库，无需额外安装即可使用，使得它成为初学者和专业开发者构建GUI应用的理想选择。 2. **Hello, Tkinter** 这部分介绍了如何创建一个简单的Tkinter程序，通常称为"Hello, World!"示例。通过运行程序，用户可以看到一个基本的窗口显示指定的文本。这涉及到了`Tk()`函数的使用，用于创建顶级窗口，以及`Label` widget来显示文本。 3. **更多关于Widget引用和名称** 文档进一步讲解了如何引用和管理Tkinter中的组件（Widgets），包括如何通过变量存储对Widget的引用，以便稍后进行操作，以及如何理解Widget的命名规则。 4. **Tkinter类和配置** 这一部分详细介绍了Tkinter中的各种Widget类，如Button、Label、Entry等，以及它们的混合（Mixins）和实现细节。还涵盖了Widget的配置管理，包括如何设置Widget的属性和样式。 5. **Widget配置** Widget配置接口让开发者能够改变Widget的外观和行为，如字体、颜色、大小等。文档讨论了向后兼容性，意味着新版本的Tkinter通常保留旧版本的功能。 6. **Widget样式** 在这一章，讨论了颜色、字体、边框、阴影、焦点高亮和光标等视觉元素。颜色可以使用预定义的颜色名、RGB值或系统字体来定义，字体则涉及字体描述符、字体名和系统字体。 7. **事件和绑定** Tkinter通过事件驱动模型工作，允许响应用户的交互，如点击按钮或键盘输入。事件绑定将特定的函数与特定的事件关联起来。文档详细解释了事件对象、实例和类绑定，以及事件协议，包括标准的和自定义的。 8. **应用窗口** 应用窗口章节探讨了基础窗口的创建和管理，以及如何添加菜单。Tkinter提供了一个基础窗口类，可以作为所有其他窗口的基础。菜单功能使开发者能为应用程序创建菜单栏，添加菜单项和快捷键。这个文档全面覆盖了Tkinter的基础和高级特性，对于任何希望在Python中构建GUI应用的人来说都是宝贵的资源。通过深入学习，开发者可以创建复杂且功能丰富的用户界面，同时享受到Python的简洁和易用性。

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

编程之路从0到1

粉丝: 1w+
资源: 8

Python tkinter图形界面编程高清教程

Python3 Tkinter官方文档：理解对称矩阵与欧氏空间

X3入门教程：账套复制与TKinter官方文档

Python Tkinter实例教程：高清带书签版

tkinter学习文档

python3-tkinter官方文档

tkinter组件.zip_Tkinter_completelyp6x_python_python tkinter_文档

tkinter开发教程文档.docx

python tkinter官方文档

tkinter新建文档功能

Tkinter的文档连接

最新资源