C++博客-mirguest-随笔分类-Python

[Python][PyQt4]PyQt4 中的俄罗斯方块

mirguest — Sun, 12 Feb 2012 02:18:00 GMT

摘要: PyQt4 中的俄罗斯方块¶ 创建一个电脑游戏是很具挑战性的。迟早程序员想创建一个电脑游戏。事实上，很多人对编程感兴趣，是因为它们玩了游戏，然后想创建自己的游戏。创建一个游戏会提升你的编程技能。俄罗斯方块¶ 俄罗斯方块从创建开始就成为很流行的游戏之一。游戏最开始是由俄罗斯程序员 Alexey Pajitnov 设计和编写的。从那时开始几乎在所有的计算机平台运行。甚至... 阅读全文

mirguest 2012-02-12 10:18 发表评论

[Python][PyQt4]在 PyQt4 中定制组件

mirguest — Sun, 12 Feb 2012 02:17:00 GMT

在 PyQt4 中定制组件¶

PyQt4 有丰富的组件。但是不可能提供所有的组件。PyQt4 中仅仅提供最常用的组件，像按钮，文本框，滑块等。如果我们需要特殊的组件，我们必须要自己创建。

自定制组件可以使用工具包画制工具创建。有两种可能，一个程序员可以修改或提升一个已存在的工具，或是从零开始创建。

Burning widget¶

这是一个组件，我们可以在 Nero，K3B 或其它 CD/DVD 刻录软件。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
In this example, we create a custom widget.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui, QtCore
class Communicate(QtCore.QObject):
    updateBW = QtCore.pyqtSignal(int)
class BurningWidget(QtGui.QWidget):
    def __init__(self):
        super(BurningWidget, self).__init__()
        self.initUI()
    def initUI(self):
        self.setMinimumSize(1, 30)
        self.value = 75
        self.num = [75, 150, 225, 300, 375, 450, 525, 600, 675]
    def setValue(self, value):
        self.value = value
    def paintEvent(self, e):
        qp = QtGui.QPainter()
        qp.begin(self)
        self.drawWidget(qp)
        qp.end()
    def drawWidget(self, qp):
        font = QtGui.QFont('Serif', 7, QtGui.QFont.Light)
        qp.setFont(font)
        size = self.size()
        w = size.width()
        h = size.height()
        step = int(round(w / 10.0))
        till = int(((w / 750.0) * self.value))
        full = int(((w / 750.0) * 700))
        if self.value >= 700:
            qp.setPen(QtGui.QColor(255, 255, 255))
            qp.setBrush(QtGui.QColor(255, 255, 184))
            qp.drawRect(0, 0, full, h)
            qp.setPen(QtGui.QColor(255, 175, 175))
            qp.setBrush(QtGui.QColor(255, 175, 175))
            qp.drawRect(full, 0, till-full, h)
        else:
            qp.setPen(QtGui.QColor(255, 255, 255))
            qp.setBrush(QtGui.QColor(255, 255, 184))
            qp.drawRect(0, 0, till, h)
        pen = QtGui.QPen(QtGui.QColor(20, 20, 20), 1,
            QtCore.Qt.SolidLine)
        qp.setPen(pen)
        qp.setBrush(QtCore.Qt.NoBrush)
        qp.drawRect(0, 0, w-1, h-1)
        j = 0
        for i in range(step, 10*step, step):
            qp.drawLine(i, 0, i, 5)
            metrics = qp.fontMetrics()
            fw = metrics.width(str(self.num[j]))
            qp.drawText(i-fw/2, h/2, str(self.num[j]))
            j = j + 1
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        sld = QtGui.QSlider(QtCore.Qt.Horizontal, self)
        sld.setFocusPolicy(QtCore.Qt.NoFocus)
        sld.setRange(1, 750)
        sld.setValue(75)
        sld.setGeometry(30, 40, 150, 30)
        self.c = Communicate()
        self.wid = BurningWidget()
        self.c.updateBW[int].connect(self.wid.setValue)
        sld.valueChanged[int].connect(self.changeValue)
        hbox = QtGui.QHBoxLayout()
        hbox.addWidget(self.wid)
        vbox = QtGui.QVBoxLayout()
        vbox.addStretch(1)
        vbox.addLayout(hbox)
        self.setLayout(vbox)
        self.setGeometry(300, 300, 390, 210)
        self.setWindowTitle('Burning widget')
        self.show()
    def changeValue(self, value):
        self.c.updateBW.emit(value)
        self.wid.repaint()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

在这个例子中，我们有一个 QtGui.QSlider 和一个自定制组件。滑块控制了自定制组件。这个组件显示一个媒介总的容量以及剩余的容量。这里最小的值是 1，最大是 750 。如果我们到达 700 ，我们开始画红色。这是用于指示过度烧制。

组件放在窗口的底部。这通过一个 QtGui.QHBoxLayout 和 QtGui.QVBoxLayout 实现。

class BurningWidget(QtGui.QWidget):
    def __init__(self):
        super(BurningWidget, self).__init__()

这个组件基于 QtGui.QWidget 组件。

self.setMinimumSize(1, 30)

我们更改了组件最小的大小（高度）。默认的值是一点点小。

font = QtGui.QFont('Serif', 7, QtGui.QFont.Light)
qp.setFont(font)

我们用小于默认的字体。这适合于我们的需要。

size = self.size()
w = size.width()
h = size.height()
step = int(round(w / 10.0))
till = int(((w / 750.0) * self.value))
full = int(((w / 750.0) * 700))

我们动态地绘制组件。窗口越大，组件会越大。反之亦然。这就是为何我们要计算组件的大小。参数 till 决定了要画多少。此值来自于滑块组件。这是整个区域的部分值。参数 full 决定了什么时候开始绘制红色部分。注意，此处使用了浮点运算，是为更高的精度。

真正绘制时包含三个部分。我们先绘制黄色或红色和黄色的矩形。然后绘制垂直的线，主要用于分割组件。最后是绘制数字，用于指示媒介的大小。

metrics = qp.fontMetrics()
fw = metrics.width(str(self.num[j]))
qp.drawText(i-fw/2, h/2, str(self.num[j]))

我们使用字体度量来绘制文本。我们必须要知道文本的宽度来居中绘制。

def changeValue(self, value):
    self.c.updateBW.emit(value)
    self.wid.repaint()

我们移动滑块时， changeValue() 方法就被调用了。在此方法内部，我们发送了自定义的 updateBW 信号，并且带了一个参数。这个参数是当前滑块的值。这个值用于计算在 Burning 这个组件中要绘制多少。自定义的组件然后被重绘。

本部分，我们创建了自己的组件。

mirguest 2012-02-12 10:17 发表评论

[Python][PyQt4]在 PyQt4 中绘图

mirguest — Sun, 12 Feb 2012 02:16:00 GMT

摘要: 在 PyQt4 中绘图¶ 绘图常用于，当我们想改变一个已存在的组件，或者是我们希望自己创建组件。为了实现绘图，我们可以使用 PyQt4 中提供的 API 。绘制一般由 paintEvent() 方法处理。绘制的代码放置于 QtGui.QPainter 对象的 begin() 与 end() 之间。绘制文本¶ 我们可以把一些 Unicode 文本绘制到屏幕上。 ... 阅读全文

mirguest 2012-02-12 10:16 发表评论

[Python][PyQt4]在 PyQt4 中 drag 和 drop

mirguest — Sun, 12 Feb 2012 02:14:00 GMT

在 PyQt4 中 drag 和 drop¶

本部分，我们将讨论 drag 和 drop 操作。

在计算机中的图形界面中， drag-and-drop 是例如点击到一个虚拟对象并把它拖到另外的位置上的行为。一般来说，这可以用于很多行为，或创建两个对象间的关联。（Wikipedia）

drag 和 drop 的功能是 GUI 最有用的功能之一。它可以是用户处理复杂的工作。

一般来说，我们可以 drag 和 drop 两种东西，数据或图形对象。如果我们吧一幅图像从一个应用拖到另一个应用，我们处理的是二进制数据。如果我们在 Firefox 中拖动了一个标签，我们拖的则是一个图形组件。

简单的 Drag 和 Drop¶

第一个例子，我们将有一个 QtGui.QLineEdit 和 QtGui.QPushButton 。我们将从行编辑区拖动文本到按钮上。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
This is a simple drag and
drop example.
author: Jan Bodnar
website: zetcode.com
last edited: December 2010
"""
import sys
from PyQt4 import QtGui
class Button(QtGui.QPushButton):
    def __init__(self, title, parent):
        super(Button, self).__init__(title, parent)
        self.setAcceptDrops(True)
    def dragEnterEvent(self, e):
        if e.mimeData().hasFormat('text/plain'):
            e.accept()
        else:
            e.ignore()
    def dropEvent(self, e):
        self.setText(e.mimeData().text())
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        edit = QtGui.QLineEdit('', self)
        edit.setDragEnabled(True)
        edit.move(30, 65)
        button = Button("Button", self)
        button.move(190, 65)
        self.setWindowTitle('Simple Drag & Drop')
        self.setGeometry(300, 300, 300, 150)
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    ex.show()
    app.exec_()
if __name__ == '__main__':
    main()

简单的拖拽操作。

class Button(QtGui.QPushButton):
    def __init__(self, title, parent):
        super(Button, self).__init__(title, parent)

为了可以把文字拖到 QtGui.QPushButton 组件上，我们必需要重新实现一些方法。所以我们创建了我们自己的按钮类。它从 QtGui.QPushButton 派生。

self.setAcceptDrops(True)

我们开启允许接受拖入的事件。

def dragEnterEvent(self, e):
    if e.mimeDate().hasFormat('text/plain'):
        e.accept()
    else:
        e.ignore()

首先，我们重新实现了 drageEnterEvent() 方法。我们将接受特定的数据类型，此处是纯文本。

def dropEvent(self, e):
    self.setText(e.mimeDate().text())

通过重新实现 dropEvent() 方法，我们定义了放下后处理的事件。我们在这里是改变了按钮中的显示文本。

edit = QtGui.QLineEdit('', self)
edit.setDragEnabled(True)

QtGui.QLineEdit 组件有内置的拖拽操作。我们只需要调用 setDragEnabled() 激活它就可以了。

拖拽一个按钮组件¶

下面的例子，我们将介绍如何拖拽一个按钮对象。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
In this program, we can press
on a button with a left mouse
click or drag and drop the button
with  the right mouse click.
author: Jan Bodnar
website: zetcode.com
last edited: December 2010
"""
import sys
from PyQt4 import QtGui
from PyQt4 import QtCore
class Button(QtGui.QPushButton):
    def __init__(self, title, parent):
        super(Button, self).__init__(title, parent)
    def mouseMoveEvent(self, e):
        if e.buttons() != QtCore.Qt.RightButton:
            return
        mimeData = QtCore.QMimeData()
        drag = QtGui.QDrag(self)
        drag.setMimeData(mimeData)
        drag.setHotSpot(e.pos() - self.rect().topLeft())
        dropAction = drag.start(QtCore.Qt.MoveAction)
    def mousePressEvent(self, e):
        QtGui.QPushButton.mousePressEvent(self, e)
        if e.button() == QtCore.Qt.LeftButton:
            print 'press'
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        self.setAcceptDrops(True)
        self.button = Button('Button', self)
        self.button.move(100, 65)
        self.setWindowTitle('Click or Move')
        self.setGeometry(300, 300, 280, 150)
    def dragEnterEvent(self, e):
        e.accept()
    def dropEvent(self, e):
        position = e.pos()
        self.button.move(position)
        e.setDropAction(QtCore.Qt.MoveAction)
        e.accept()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    ex.show()
    app.exec_()
if __name__ == '__main__':
    main()

在这个例子中，我们有一个 QtGui.QPushButton 在窗口上。如果我们点击按钮，将在控制台上输出 ‘press’ 。而如果右击按钮并且移动，我们就可以拖拽这个按钮组件。

class Button(QtGui.QPushButton):
    def __init__(self, title, parent):
        super(Button, self).__init__(title, parent)

我们创建了一个派生自 QtGui.QPushButton 的按钮类。我们还重新实现了 QtGui.QPushButton 中的两个方法， mouseMoveEvent() 和 mousePressEvent() 。其中， mouseMoveEvent() 方法是开始拖拽处发生的地方。

if event.buttons() != QtCore.Qt.RightButton:
    return

我们决定只用鼠标右击进行拖拽。左击用于点击按钮。

mimeData = QtCore.QMimeData()
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
drag.setHotSpot(event.pos() - self.rect().topLeft())

我们创建了一个 QDrag 对象。

dropAction = drag.start(QtCore.Qt.MoveAction)

start() 方法开始拖拽操作。

def mousePressEvent(self, e):
    QtGui.QPushButton.mousePressEvent(self, e)
    if e.button() == QtCore.Qt.LeftButton:
        print 'press'

如果点击了鼠标左键，我们在控制台上打印 ‘press’ 。注意，我们还调用了父类的 mousePressEvent() 方法。否则，我们将不会看到按钮被按下。

position = e.pos()
self.button.move(position)

在 dropEvent() 方法中，定义了当我们松开鼠标按钮停止拖拽的行为。我们找到鼠标当前的位置，并把按钮移到合适的位置。

e.setDropAction(QtCore.Qt.MoveAction)
e.accept()

我们指定了拖拽的类型。在此处是移动的行为。

本部分我们讨论了拖拽。

mirguest 2012-02-12 10:14 发表评论

[Python][PyQt4]PyQt4 Widget II

mirguest — Sun, 12 Feb 2012 02:13:00 GMT

PyQt4 Widget II¶

这里我们将继续介绍 PyQt4 组件。我们将涉及 QtGui.QPixmap ， QtGui.QLineEdit ， QtGui.QSplitter 和 QtGui.QComboBox 。

`QtGui.QPixmap`¶

QtGui.QPixmap 是可以处理图片的组件之一。它对显示图片进行了优化。在我们的例子中，我们会用 QtGui.QPixmap 来显示图片。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
In this example, we dispay an image
on the window.
author: Jan Bodnar
website: zetcode.com
last edited: September 2011
"""
import sys
from PyQt4 import QtGui, QtCore
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        hbox = QtGui.QHBoxLayout(self)
        pixmap = QtGui.QPixmap("redrock.png")
        lbl = QtGui.QLabel(self)
        lbl.setPixmap(pixmap)
        hbox.addWidget(lbl)
        self.setLayout(hbox)
        self.move(300, 200)
        self.setWindowTitle('Red Rock')
        self.show()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

在这个例子里，我们显示了一幅图片。

pixmap = QtGui.QPixmap("redrock.png")

我们创建了一个 QtGui.QPixmap 对象。它接受文件名作为参数。

lbl = QtGui.QLabel(self)
lbl.setPixmap(pixmap)

我们把 pixmap 放到了 QtGui.QLabel 中。

`QtGui.QLineEdit`¶

QtGui.QLineEdit 是一个允许输入和编辑一行纯文本。这个组件中可以撤销/恢复，剪切/粘贴以及拖拉。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
This example shows text which
is entered in a QtGui.QLineEdit
in a QtGui.QLabel widget.
author: Jan Bodnar
website: zetcode.com
last edited: August 2011
"""
import sys
from PyQt4 import QtGui, QtCore
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        self.lbl = QtGui.QLabel(self)
        qle = QtGui.QLineEdit(self)
        qle.move(60, 100)
        self.lbl.move(60, 40)
        qle.textChanged[str].connect(self.onChanged)
        self.setGeometry(300, 300, 280, 170)
        self.setWindowTitle('QtGui.QLineEdit')
        self.show()
    def onChanged(self, text):
        self.lbl.setText(text)
        self.lbl.adjustSize()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

这个例子显示一个行编辑区和一个标签。我们输入的就会立即在标签中显示。

qle = QtGui.QLineEdit(self)

创建了 QtGui.QLineEdit 组件。

qle.textChanged[str].connect(self.onChanged)

如果文本区的文本改变了，我们就调用 onChanged() 方法。

def onChanged(self, text):
    self.lbl.setText(text)
    self.lbl.adjustSize()

在 onChanged() 方法中，我们把输入的文本放到了标签中。通过调用 adjustSize() 方法，我们把标签设置到文本的长度。

`QtGui.QSplitter`¶

QtGui.QSplitter 可以让用户控制子组件的大小，通过拖动子组件的大小。在我们的例子中，我们的三个 QtGui.QFrame 将由两个 splitter 分割。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
This example shows
how to use QtGui.QSplitter widget.
author: Jan Bodnar
website: zetcode.com
last edited: September 2011
"""
import sys
from PyQt4 import QtGui, QtCore
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        hbox = QtGui.QHBoxLayout(self)
        topleft = QtGui.QFrame(self)
        topleft.setFrameShape(QtGui.QFrame.StyledPanel)
        topright = QtGui.QFrame(self)
        topright.setFrameShape(QtGui.QFrame.StyledPanel)
        bottom = QtGui.QFrame(self)
        bottom.setFrameShape(QtGui.QFrame.StyledPanel)
        splitter1 = QtGui.QSplitter(QtCore.Qt.Horizontal)
        splitter1.addWidget(topleft)
        splitter1.addWidget(topright)
        splitter2 = QtGui.QSplitter(QtCore.Qt.Vertical)
        splitter2.addWidget(splitter1)
        splitter2.addWidget(bottom)
        hbox.addWidget(splitter2)
        self.setLayout(hbox)
        QtGui.QApplication.setStyle(QtGui.QStyleFactory.create('Cleanlooks'))
        self.setGeometry(300, 300, 300, 200)
        self.setWindowTitle('QtGui.QSplitter')
        self.show()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

在这个例子中，有三个框架组件，两个分割条。

topleft = QtGui.QFrame(self)
topleft.setFrameShape(QtGui.QFrame.StyledPanel)

我们使用了有样式的框架，主要用于看到边框。

splitter1 = QtGui.QSplitter(QtCore.Qt.Horizontal)
splitter1.addWidget(topleft)
splitter1.addWidget(topright)

我们创建了一个 QtGui.QSplitter 组件，并添加到两个框架。

splitter2 = QtGui.QSplitter(QtCore.Qt.Vertical)
splitter2.addWidget(splitter1)

我们也可以把一个 splitter 添加到 splitter 中。

QtGui.QApplication.setStyle(QtGui.QStyleFactory.create('Cleanlooks'))

我们使用一个简洁的样式。在有些样式中，框架是不可见的。

`QtGui.QComboBox`¶

QtGui.QComboBox 允许用户从一组选项中选取一个。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
This example shows
how to use QtGui.QComboBox widget.
author: Jan Bodnar
website: zetcode.com
last edited: September 2011
"""
import sys
from PyQt4 import QtGui, QtCore
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        self.lbl = QtGui.QLabel("Ubuntu", self)
        combo = QtGui.QComboBox(self)
        combo.addItem("Ubuntu")
        combo.addItem("Mandriva")
        combo.addItem("Fedora")
        combo.addItem("Red Hat")
        combo.addItem("Gentoo")
        combo.move(50, 50)
        self.lbl.move(50, 150)
        combo.activated[str].connect(self.onActivated)
        self.setGeometry(300, 300, 300, 200)
        self.setWindowTitle('QtGui.QComboBox')
        self.show()
    def onActivated(self, text):
        self.lbl.setText(text)
        self.lbl.adjustSize()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

这个例子中有一个 QtGui.QComboBox 和 QtGui.QLable 。这里有五个选项。它们是 Linux 的发行版。标签中就会显示选中的项目。

combo = QtGui.QComboBox(self)
combo.addItem("Ubuntu")
combo.addItem("Mandriva")
combo.addItem("Fedora")
combo.addItem("Red Hat")
combo.addItem("Gentoo")

我们创建一个 QtGui.QComboBox 组件并增加了五个选项。

combo.activated[str].connect(self.onActivated)

当选择一个选项后，我们调用了 onActivated() 方法。

def onActivated(self, text):
    self.lbl.setText(text)
    self.lbl.adjustSize()

在这个方法中，我们把选中的选项的文本放到标签中。我们还调整标签的大小。

在本部分，我们涉及了另外四个 PyQt4 组件。

mirguest 2012-02-12 10:13 发表评论

[Python][PyQt4]PyQt4 Widget

mirguest — Sun, 12 Feb 2012 02:11:00 GMT

摘要: PyQt4 Widget¶ 组件（Widget）是一个应用最基本的构件。PyQt4 中有大量的组件。按钮，选择框，滑块，列表等等。任何一个程序员都会需要这些组件。这篇中，我们将介绍一些有用的组件， QtGui.QCheckBox ， ToggleButton ， QtGui.QSlider , QtGui.QProcessBar 和 QtGui.QCalendarWidget 。 ... 阅读全文

mirguest 2012-02-12 10:11 发表评论

[Python][PyQt4]PyQt4 中的 Dialog

mirguest — Sun, 12 Feb 2012 02:06:00 GMT

PyQt4 中的 Dialog¶

Dialog 窗口或 dialog 是现代 GUI 应用必不可少的一部分。一个 dialog 定义为两人或更多人间的会话。在计算机应用中，dialog 就是一个和应用说话的窗口。dialog 可以用于输入数据，修改数据，更改应用的设置等等。对话框在用户和计算机的通信间是重要的手段。

`QtGui.QInputDialog`¶

QtGui.QInputDialog 提供了一个简单方便的对话框，用于获取用户输入的一个值。输入值可以是字符串，数字，或者一个列表中的一项。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
In this example, we receive data from
a QtGui.QInputDialog dialog.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        self.btn = QtGui.QPushButton('Dialog', self)
        self.btn.move(20, 20)
        self.btn.clicked.connect(self.showDialog)
        self.le = QtGui.QLineEdit(self)
        self.le.move(130, 22)
        self.setGeometry(300, 300, 290, 150)
        self.setWindowTitle('Input dialog')
        self.show()
    def showDialog(self):
        text, ok = QtGui.QInputDialog.getText(self, 'Input Dialog',
            'Enter your name:')
        if ok:
            self.le.setText(str(text))
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

这个例子中用到了一个按钮和一个行编辑组件。按钮会显示一个输入对话框用于得到文本。而输入的文本将在行编辑组件中显示。

text, ok = QtGui.QInputDialog.getText(self, 'Input Dialog',
    'Enter your name:')

这一行显示了输入对话框。第一个字符串是对话框的标题，第二个字符串则是对话框中的消息。对话框将返回输入的文本和一个布尔值。如果点击了 ok 按钮，则布尔值为 true ，否则为 false 。

if ok:
    self.le.setText(str(text))

从对话框中接收到的文本就被设置到行编辑组件中。

`QtGui.QColorDialog`¶

QtGui.QColorDialog 用于选取颜色值。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
In this example, we select a color value
from the QtGui.QColorDialog and change the background
color of a QtGui.QFrame widget.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        col = QtGui.QColor(0, 0, 0)
        self.btn = QtGui.QPushButton('Dialog', self)
        self.btn.move(20, 20)
        self.btn.clicked.connect(self.showDialog)
        self.frm = QtGui.QFrame(self)
        self.frm.setStyleSheet("QWidget { background-color: %s }"
            % col.name())
        self.frm.setGeometry(130, 22, 100, 100)
        self.setGeometry(300, 300, 250, 180)
        self.setWindowTitle('Color dialog')
        self.show()
    def showDialog(self):
        col = QtGui.QColorDialog.getColor()
        if col.isValid():
            self.frm.setStyleSheet("QWidget { background-color: %s }"
                % col.name())
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

这个例子显示一个按钮和一个 QtGui.QFrame 。这个组件的背景被设为黑色。使用 QtGui.QColorDialog 可以改变其背景。

col = QtGui.QColor(0, 0, 0)

这个是 QtGui.QFrame 的初始颜色。

col = QtGui.QColorDialog.getColor()

这一行将弹出 QtGui.QColorDialog 。

if col.isValid():
    self.frm.setStyleSheet("QWidget { background-color: %s }"
        % col.name())

我们检查颜色是否合法。如果点击了取消按钮，返回的就不是合法值。如果颜色合法，我们就用样式表更改背景颜色。

`QtGui.QFontDialog`¶

QtGui.QFontDialog 用于选取字体。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
In this example, we select a font name
and change the font of a label.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        vbox = QtGui.QVBoxLayout()
        btn = QtGui.QPushButton('Dialog', self)
        btn.setSizePolicy(QtGui.QSizePolicy.Fixed,
            QtGui.QSizePolicy.Fixed)
        btn.move(20, 20)
        vbox.addWidget(btn)
        btn.clicked.connect(self.showDialog)
        self.lbl = QtGui.QLabel('Knowledge only matters', self)
        self.lbl.move(130, 20)
        vbox.addWidget(self.lbl)
        self.setLayout(vbox)
        self.setGeometry(300, 300, 250, 180)
        self.setWindowTitle('Font dialog')
        self.show()
    def showDialog(self):
        font, ok = QtGui.QFontDialog.getFont()
        if ok:
            self.lbl.setFont(font)
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

在我们的例子中，我们有一个按钮和一个标签。通过 QtGui.QFontDialog 我们可以改变标签的字体。

font, ok = QtGui.QFontDialog.getFont()

我们弹出一个字体对话框。 getFont() 方法将返回字体的名称和 ok 参数。如果用户点击了 OK 那么就是 True ，否则为 False 。

if ok:
    self.label.setFont(font)

如果我们点击了 ok，标签的字体就可能改变。

`QtGui.QFileDialog`¶

QtGui.QFileDialog 是允许用户选择文件或目录的对话框。文件可以用于打开或保存。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
In this example, we select a file with a
QtGui.QFileDialog and display its contents
in a QtGui.QTextEdit.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui
class Example(QtGui.QMainWindow):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        self.textEdit = QtGui.QTextEdit()
        self.setCentralWidget(self.textEdit)
        self.statusBar()
        openFile = QtGui.QAction(QtGui.QIcon('open.png'), 'Open', self)
        openFile.setShortcut('Ctrl+O')
        openFile.setStatusTip('Open new File')
        openFile.triggered.connect(self.showDialog)
        menubar = self.menuBar()
        fileMenu = menubar.addMenu('&File')
        fileMenu.addAction(openFile)
        self.setGeometry(300, 300, 350, 300)
        self.setWindowTitle('File dialog')
        self.show()
    def showDialog(self):
        fname = QtGui.QFileDialog.getOpenFileName(self, 'Open file',
                '/home')
        f = open(fname, 'r')
        with f:
            data = f.read()
            self.textEdit.setText(data)
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

这个例子中有菜单栏，文本编辑区以及状态栏。菜单中的选项显示 QtGui.QFileDialog 用于选择文件。而文件的内容则载入到文本编辑区。

class Example(QtGui.QMainWindow):
    def __init__(self):
        super(Example, self).__init__()

这个例子是基于 QtGui.QMainWindow 组件，因为我们要在中心设置文本编辑区。

fname = QtGui.QFileDialog.getOpenFileName(self, 'Open file',
    '/home')

我们弹出 QtGui.QFileDialog 。在 getOpenFileName() 方法中第一个字符串是标题。第二个则是指定对话框的工作目录。默认情况下，文件过滤为所有文件（ * ）。

f = open(fname, 'r')
with f:
    data = f.read()
    self.textEdit.setText(data)

选择的文件将被读取，并且其文件内容设置到文本编辑区。

这个部分，我们讨论了对话框。

mirguest 2012-02-12 10:06 发表评论

[Python][PyQt4]PyQt4 中的事件和信号

mirguest — Sun, 05 Feb 2012 02:05:00 GMT

PyQt4 中的事件和信号¶

在本部分，我们将会探讨事件和信号。

事件¶

在任何的 GUI 程序中，事件是很重要的部分。事件是由用户或操作系统产生的。当我们调用应用的 exec_() 时，应用就进入了主循环。主循环会接受事件并且把它们发送给对象。Trolltech 引入了一个独特的信号和槽机制。

事件是任何 GUI 程序中很重要的部分。所有 GUI 应用都是事件驱动的。一个应用对其生命期产生的不同的事件类型做出反应。事件是主要由应用的用户产生。但是，也可以通过其他方法产生，比如，网络通信，窗口的管理者，计时器。在事件模型中，有三个参与者：

事件源（event source）
事件对象（event object）
事件目标（event target）

event source 是那些状态改变的对象。它产生事件。而 event object （Event）封装了事件源的状态改变。而 event target 则是需要被通知的。事件源把处理事件的任务委托给了事件目标。

当我们调用了应用的 exec_() 方法，应用就进入主循环了。主循环接受事件然后把他们发送给对象。信号和槽用于对象间的通信。当特定的事件发生时信号就被发送了。而槽则是任何 Python 中可调用的。当信号发送给了这个槽，槽就被调用了。

新的 API¶

PyQt 4.5 引入了新的 API 用于信号和槽。

QtCore.QObject.connect(button, QtCore.SIGNAL('clicked()'), self.onClicked)

这是旧式的 API 。

button.clicked.connect(self.onClicked)

新式的更接近 Python 的标准。

信号与槽¶

这是一个简单的例子，描述 PyQt4 中的信号和槽。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
In this example, we connect a signal
of a QtGui.QSlider to a slot
of a QtGui.QLCDNumber.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui, QtCore
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        lcd = QtGui.QLCDNumber(self)
        sld = QtGui.QSlider(QtCore.Qt.Horizontal, self)
        vbox = QtGui.QVBoxLayout()
        vbox.addWidget(lcd)
        vbox.addWidget(sld)
        self.setLayout(vbox)
        sld.valueChanged.connect(lcd.display)
        self.setGeometry(300, 300, 250, 150)
        self.setWindowTitle('Signal & slot')
        self.show()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

在我们的例子中，我们显示了 QtGui.QLCDNumber 和 QtGui.QSlider 。通过拖拽滑块，我们就可以更改 lcd 的数字。

sld.valueChanged.connect(lcd.display)

此处，我们把 slider 的信号 valueChanged 和 lcd 的槽 display 连接了起来。

sender 是发送信号的对象。 receiver 是接受信号的对象。而 slot 是回馈信号的方法。

重新实现事件处理句柄¶

在 PyQt4 中事件的处理一般通过重新实现事件的句柄。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
In this example, we reimplement an
event handler.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui, QtCore
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        self.setGeometry(300, 300, 250, 150)
        self.setWindowTitle('Event handler')
        self.show()
    def keyPressEvent(self, e):
        if e.key() == QtCore.Qt.Key_Escape:
            self.close()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

在我们的例子中，我们重新实现了 keyPressEvent() 。

def keyPressEvent(self, e):
    if e.key() == QtCore.Qt.Key_Escape:
        self.close()

如果我们按 escape 键，那么应用就将终止。

事件发送者¶

有些时候，知道信号的发送者是很方便的。因此，PyQt4 有个 sender() 方法。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
In this example, we determine the event sender
object.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui, QtCore
class Example(QtGui.QMainWindow):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        btn1 = QtGui.QPushButton("Button 1", self)
        btn1.move(30, 50)
        btn2 = QtGui.QPushButton("Button 2", self)
        btn2.move(150, 50)
        btn1.clicked.connect(self.buttonClicked)
        btn2.clicked.connect(self.buttonClicked)
        self.statusBar()
        self.setGeometry(300, 300, 290, 150)
        self.setWindowTitle('Event sender')
        self.show()
    def buttonClicked(self):
        sender = self.sender()
        self.statusBar().showMessage(sender.text() + ' was pressed')
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

这个例子中有两个按钮。在 buttonClicked() 方法中，我们通过调用 sender() 方法知道了哪个按钮被点击了。

btn1.clicked.connect(self.buttonClicked)
btn2.clicked.connect(self.buttonClicked)

两个按钮都连接到相同的槽中。

def buttonClicked(self):
    sender = self.sender()
    self.statusBar().showMessange(sender.text() + " was pressed")

我们通过调用 sender() 方法知道了消息源。在状态栏中，我们显示了被按的按钮的标签。

发送信号¶

由 QtCore.QObject 创建的对象可以发送信号。如果我们点击按钮，一个 clicked() 信号就被生成。在下面的例子中我们将看到如何发送信号。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
In this example, we show how to emit a
custom signal.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui, QtCore
class Communicate(QtCore.QObject):
    closeApp = QtCore.pyqtSignal()
class Example(QtGui.QMainWindow):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        self.c = Communicate()
        self.c.closeApp.connect(self.close)
        self.setGeometry(300, 300, 290, 150)
        self.setWindowTitle('Emit signal')
        self.show()
    def mousePressEvent(self, event):
        self.c.closeApp.emit()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

我们创建了一个新的信号称为 closeApp 。这个信号在鼠标点击时将被发送。而这个信号又和 QtGui.QMainWindow 的 close() 槽相连接。

class Communicate(QtCore.QObject):
    closeApp = QtCore.pyqtSignal()

我们创建了基于 QtCore.QObject 的类。当它被实例化后就创建了一个 closeApp 信号。

self.c = Communicate()
self.c.closeApp.connect(self.close)

类 Communicate 的实例就被创建了。我们把 QtGui.QMainWindow 的 close() 槽连接到信号 closeApp 上。

def mousePressEvent(self, event):
    self.c.closeApp.emit()

当鼠标指针在窗口中点击，信号 closeApp 就被发送了。

在这个部分，我们涉及了信号与槽。

mirguest 2012-02-05 10:05 发表评论

[Python][PyQt4]PyQt4的 layout 管理

mirguest — Sun, 05 Feb 2012 02:04:00 GMT

PyQt4的 layout 管理¶

在编程中一个重要的事情就是 layout 的管理。layout 管理就是在窗口中布置 widget。管理有两种方式。我们可以使用 绝对定位 或者 layout 类 。

绝对定位¶

程序员可以指定每个 widget 的位置和大小。当你使用绝对定位时，你需要理解一些事情。

如果你改变了窗口的大小，widget 的大小和位置是不会改变的。
在不同平台上应用可能看起来不太一样。
在你的应用中改变字体会毁掉你的 layout。
如果你决定改变你的 layout，那么你必须要重新设计你的 layout，这意味着麻烦及耗时。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
This example shows three labels on a window
using absolute positioning.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        lbl1 = QtGui.QLabel('Zetcode', self)
        lbl1.move(15, 10)
        lbl2 = QtGui.QLabel('tutorials', self)
        lbl2.move(35, 40)
        lbl3 = QtGui.QLabel('for programmers', self)
        lbl3.move(55, 70)
        self.setGeometry(300, 300, 250, 150)
        self.setWindowTitle('Absolute')
        self.show()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

我们简单地调用 move() 方法来定位我们的 widget 。在我们这个情况下，这些 widget 是标签。我们通过给定 x 和 y 坐标进行定位。坐标系统是从左上角开始。x 的值从左到右增加。y 则是从上到下。

Box Layout¶

通过 layout 类管理会更加灵活和实用。这是优先考虑的方法。基本的 layout 类是 QtGui.QHBoxLayout 和 QtGui.QVBoxLayout 。它们分别以水平和垂直方式对 widget 进行布局。

假设我们想把两个按钮放置在右下角。为了创建这样的 layout，我们可以使用一个水平的和垂直的盒子。为了创建必要的空间，我们将会增加一个 缩放比例 。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
In this example, we position two push
buttons in the bottom-right corner
of the window.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        okButton = QtGui.QPushButton("OK")
        cancelButton = QtGui.QPushButton("Cancel")
        hbox = QtGui.QHBoxLayout()
        hbox.addStretch(1)
        hbox.addWidget(okButton)
        hbox.addWidget(cancelButton)
        vbox = QtGui.QVBoxLayout()
        vbox.addStretch(1)
        vbox.addLayout(hbox)
        self.setLayout(vbox)
        self.setGeometry(300, 300, 300, 150)
        self.setWindowTitle('Buttons')
        self.show()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

这里在窗口的右下角放置了两个按钮。他们在窗口调整时，会保持处于那个位置。我们使用了 QtGui.HBoxLayout 和 QtGui.QVBoxLayout 。

okButton = QtGui.QPushButton("OK")
cancelButton = QtGui.QPushButton("Cancel")

此处，我们创建了两个按钮。

hbox = QtGui.QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(okButton)
hbox.addWidget(cancelButton)

我们创建了一个水平的 layout 。增加了缩放比例和按钮。这个缩放在两个按钮前增加了合适的缩放空白。这就使得按钮在窗口的右边。

vbox = QtGui.QVBoxLayout()
vbox.addStretch(1)
vbox.addLayout(hbox)

为了创建必要的 layout，我们把水平的 layout 放置到垂直的 layout 中。而垂直盒子中的缩放因子使得水平的盒子处于窗口的底部。

最后，我们设置了窗口的 layout 。

QtGui.QGridLayout¶

最通用的 layout 类是网格 layout 。这个 layout 把空间分为行和列。为了创建一个网格的 layout，我们可以使用 QtGui.QGridLayout 类。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
In this example, we create a skeleton
of a calculator using a QtGui.QGridLayout.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        names = ['Cls', 'Bck', '', 'Close', '7', '8', '9', '/',
                '4', '5', '6', '*', '1', '2', '3', '-',
                '0', '.', '=', '+']
        grid = QtGui.QGridLayout()
        j = 0
        pos = [(0, 0), (0, 1), (0, 2), (0, 3),
                (1, 0), (1, 1), (1, 2), (1, 3),
                (2, 0), (2, 1), (2, 2), (2, 3),
                (3, 0), (3, 1), (3, 2), (3, 3 ),
                (4, 0), (4, 1), (4, 2), (4, 3)]
        for i in names:
            button = QtGui.QPushButton(i)
            if j == 2:
                grid.addWidget(QtGui.QLabel(''), 0, 2)
            else: grid.addWidget(button, pos[j][0], pos[j][1])
            j = j + 1
        self.setLayout(grid)
        self.move(300, 150)
        self.setWindowTitle('Calculator')
        self.show()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

在我们的例子中，我们创建了一组按钮，并以网格放置。为了填补一个空格，我们增加了一个 QtGui.QLable 的 widget 。

grid = QtGui.QGridLayout()

这里，我们创建了一个网格 layout 。

if j == 2:
    grid.addWidget(QtGui.QLable(''), 0, 2)
else: grid.addWidget(button, pos[j][0], pos[j][1])

为了把一个 widget 增加到网格中，我们调用了 addWidget() 方法。参数是 widget，行和列的数字。

再看例子¶

在网格中，widget 可以跨多行或多列。下面的例子我们就将介绍这个。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
In this example, we create a bit
more complicated window layout using
the QtGui.QGridLayout manager.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        title = QtGui.QLabel('Title')
        author = QtGui.QLabel('Author')
        review = QtGui.QLabel('Review')
        titleEdit = QtGui.QLineEdit()
        authorEdit = QtGui.QLineEdit()
        reviewEdit = QtGui.QTextEdit()
        grid = QtGui.QGridLayout()
        grid.setSpacing(10)
        grid.addWidget(title, 1, 0)
        grid.addWidget(titleEdit, 1, 1)
        grid.addWidget(author, 2, 0)
        grid.addWidget(authorEdit, 2, 1)
        grid.addWidget(review, 3, 0)
        grid.addWidget(reviewEdit, 3, 1, 5, 1)
        self.setLayout(grid)
        self.setGeometry(300, 300, 350, 300)
        self.setWindowTitle('Review')
        self.show()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

我们创建了一个窗口，其中有三个标签，两个行编辑区及一个文本编辑区。layout 由 QtGui.QGridLayout 创建。

grid = QtGui.QGridLayout()
grid.setSpacing(10)

我们创建了网格 layout，并设置了 widget 间的间隔。

grid.addWidget(reviewEdit, 3, 1, 5, 1)

如果我们增加一个 widget 到网格中，我们可以提供行和列的跨度。我们使得 reviewEdit 的跨度为 5 。

这个部分我们讲述了 layout 管理。

mirguest 2012-02-05 10:04 发表评论

[Python][PyQt4]在 PyQt4 中的菜单和工具栏

mirguest — Sun, 05 Feb 2012 02:03:00 GMT

在 PyQt4 中的菜单和工具栏¶

在本部分中，我们将要创建菜单和工具栏。菜单就是在菜单栏中的一组命令。工具栏就是一组常用命令的按钮。

主窗口¶

QtGui.QMainWindow 类提供了一个应用的主窗口。这使得我们可以创建典型的应用框架，包括状态栏，工具栏和菜单。

状态栏¶

状态栏主要用于显示状态信息。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
This program creates a statusbar.
author: Jan Bodnar
website: zetcode.com
last edited: September 2011
"""
import sys
from PyQt4 import QtGui
class Example(QtGui.QMainWindow):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        self.statusBar().showMessage('Ready')
        self.setGeometry(300, 300, 250, 150)
        self.setWindowTitle('Statusbar')
        self.show()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

状态栏由 QtGui.QMainWindow 帮忙创建。

self.statusBar().showMessage('Ready')

为了得到状态栏，我们调用了 QtGui.QMainWindow 的 statusBar() 方法。第一次调用创建了状态栏，随后返回 statusbar 对象。接着我们调用 showMessage 在状态栏上显示了一条消息。

菜单栏¶

菜单栏是 GUI 应用中很常用的一部分。它是在多个菜单中命令的集合。在 console 应用中，我们需要记住命令和它们的选项。而这里，我们把很多命令按照逻辑进行分组。这就使得学习使用一个新的应用的时间可以减少。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
This program creates a menubar. The
menubar has one menu with an exit action.
author: Jan Bodnar
website: zetcode.com
last edited: August 2011
"""
import sys
from PyQt4 import QtGui
class Example(QtGui.QMainWindow):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        exitAction = QtGui.QAction(QtGui.QIcon('exit.png'), '&Exit', self)
        exitAction.setShortcut('Ctrl+Q')
        exitAction.setStatusTip('Exit application')
        exitAction.triggered.connect(QtGui.qApp.quit)
        self.statusBar()
        menubar = self.menuBar()
        fileMenu = menubar.addMenu('&File')
        fileMenu.addAction(exitAction)
        self.setGeometry(300, 300, 300, 200)
        self.setWindowTitle('Menubar')
        self.show()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

在上面的例子中，我们创建了只有一个菜单的菜单栏。这个菜单中包含了一个 action ，如果选中后就会终止应用。我们还创建了一个状态栏。而且也可以用快捷键 Ctrl + Q 退出。

exitAction = QtGui.QAction(QtGui.QIcon('exit.png'))
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')

QtGui.QAction 是一个 action 的抽象，包括菜单栏，工具栏或者是自定义的快捷键。在上面的三行，我们创建了一个 action ，有一个指定的图标以及 ‘Exit’ 标签。而且，这个 action 定义了快捷键。第三行则是创建一个提示，当我们把鼠标指针移到菜单条目上，将在状态栏中显示相应的提示。

exitAction.triggered.connect(QtGui.qApp.quit)

当我们选择了这个特定的 action ，触发的信号就被发送了。这个信号和 QtGui.QApplication 的 quit() 方法联系在一起。这就终止了应用。

menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(exitAction)

此处三行，创建了一个菜单栏。我们往菜单栏中添加了一个名为 File 的菜单，而且，我们把 Alt + F 设为了快捷方式。然后我们再把 exitAction 放到了 fileMenu 中。

工具栏¶

在一个应用中，菜单把所有的命令分组。而工具栏中则提供了常用命令的快捷方式。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
This program creates a toolbar.
The toolbar has one action, which
terminates the application, if triggered.
author: Jan Bodnar
website: zetcode.com
last edited: September 2011
"""
import sys
from PyQt4 import QtGui
class Example(QtGui.QMainWindow):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        exitAction = QtGui.QAction(QtGui.QIcon('exit24.png'), 'Exit', self)
        exitAction.setShortcut('Ctrl+Q')
        exitAction.triggered.connect(QtGui.qApp.quit)
        self.toolbar = self.addToolBar('Exit')
        self.toolbar.addAction(exitAction)
        self.setGeometry(300, 300, 300, 200)
        self.setWindowTitle('Toolbar')
        self.show()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

在上面的例子中，我们创建了一个简单的工具栏。这个工具栏有一个退出的 action ，当触发时，就会终止应用。

exitAction = QtGui.QAction(QtGui.QIcon('exit24.png'), 'Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.triggered.connect(QtGui.qApp.quit)

和前面菜单栏的例子一样，我们也创建了一个 action 对象。这个对象有一个标签，图标以及快捷方式。而且 QtGui.QMainWindow 的 quit() 方法和其触发信号关联了起来。

self.toolbar = self.addToolBar('Exit')
self.toolbar.addAction(exitAction)

这里，我们创建了工具栏，并把 action 对象放入。

放到一起¶

本节的最后，我们将创建菜单栏，工具栏和状态栏。而且也会创建一个居中的 widget 。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
This program creates a skeleton of
a classic GUI application with a menubar,
toolbar, statusbar and a central widget.
author: Jan Bodnar
website: zetcode.com
last edited: September 2011
"""
import sys
from PyQt4 import QtGui
class Example(QtGui.QMainWindow):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        textEdit = QtGui.QTextEdit()
        self.setCentralWidget(textEdit)
        exitAction = QtGui.QAction(QtGui.QIcon('exit24.png'), 'Exit', self)
        exitAction.setShortcut('Ctrl+Q')
        exitAction.setStatusTip('Exit application')
        exitAction.triggered.connect(self.close)
        self.statusBar()
        menubar = self.menuBar()
        fileMenu = menubar.addMenu('&File')
        fileMenu.addAction(exitAction)
        toolbar = self.addToolBar('Exit')
        toolbar.addAction(exitAction)
        self.setGeometry(300, 300, 350, 250)
        self.setWindowTitle('Main window')
        self.show()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

这段代码创建了一个有菜单栏，工具栏及状态栏典型的 GUI 应用。

textEdit = QtGui.QTextEdit()
self.setCentralWidget(textEdit)

这里，我们创建了一个 text edit 的 widget 。我们把其设为 central widget。central widget会占用所有的空间。

在本部分，我们学习了菜单，工具栏，状态栏和主应用窗口。

mirguest 2012-02-05 10:03 发表评论

[Python][PyQt4]第一个 PyQt4 的程序

mirguest — Sun, 05 Feb 2012 02:00:00 GMT

第一个 PyQt4 的程序¶

本部分我们将学到一些基本的功能。

简单的例子¶

这里的代码非常简单。它仅仅显示一个小小的窗口。然后我们可以对这个窗口做很多事情。我们可以调正其大小，最大化，最小化。这个需要很多的代码。但某些人已经编写了这样的功能。因为在很多应用中重复出现了这样的代码，没有必要一再编写这样的代码。所以，对于程序员这样的代码就被隐藏了。PyQt4 是一个高层的工具。如果以更底层的开发，下面的例子可以要写上很多行。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
In this example, we create a simple
window in PyQt4.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui
def main():
    app = QtGui.QApplication(sys.argv)
    w = QtGui.QWidget()
    w.resize(250, 150)
    w.move(300, 300)
    w.setWindowTitle('Simple')
    w.show()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

上面的代码将会在屏幕上显示一个小窗口。

import sys
from PyQt4 import QtGui

这里我们提供一些必要的导入。最基本的 GUI widget 都在 QtGui 模块中。

app = QtGui.QApplication(sys.argv)

每个 PyQt4 应用必须创建一个 application 对象。此 application 对象处于 QtGui 模块中。参数 sys.argv 是从命令行获取的参数列表。Python 脚本可以从 shell 中运行。这是一种控制启动我们脚本的方式。

w = QtGui.QWidget()

在 PyQt4 中， QtGui.QWidget 是所有用户接口对象的基类。我们提供了 QtGui.QWidget 的默认构造函数。默认的构造函数没有父类。一个没有父类的 widget 称为一个窗口。

w.resize(250, 150)

resize() 方法调正了 widget 的大小。它宽 250px ，高 150px 。

w.move(300, 300)

move() 方法把 widget 移到屏幕坐标为 x = 300, y = 300 的地方。

w.setWindowTitle('Simple')

这里，我们设置了窗口的标题。标题在标题栏中显示。

w.show()

show() 方法把这个 widget 显示到屏幕上。一个 widget 最先在内存中创建，然后显示于屏幕上。

sys.exit(app.exec())

最后，我们进入程序的主循环。事件的处理就从此时开始。主循环接受从窗口系统发送的事例，并把它们发给应用的 widget 。如果我们调用了 exit() 或者主窗口被销毁，主循环就终止了。 sys.exit() 方法确保完全退出。整个环境将被通知应用如何终止。

exec_() 方法有一个下划线。这是由于 exec 是 Python 中的关键字。因此使用了 exec_() 。

一个应用的图标¶

应用的图标就是一块小的图像，显示于标题栏的左上角。下面的例子讲说明在 PyQt4 中是怎么做的。我们也会接受一些新的方法。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
This example shows an icon
in the titlebar of the window.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        self.setGeometry(300, 300, 250, 150)
        self.setWindowTitle('Icon')
        self.setWindowIcon(QtGui.QIcon('web.png'))
        self.show()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

先前的例子是以过程式编写的。Python 支持过程式和面向对象式的编程。在 PyQt4 中编程就意味着以 OOP 编程。

class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()

在面向对象编程中三个最重要的东西是类，数据及方法。这里，我们创建了一个新的类称为 Example 。这个类从 QtGui.QWidget 派生。这就意味着我们必须调用两个构造器。第一个是 Example 这个类，第二个是被继承的类。 super() 方法就返回了 Example 的父对象，然后我们调用了其构造器。在 Python 中 __init__() 是构造器。

self.initUI()

GUI 的创建就委托给了 initUI() 这个方法。

self.setGeometry(300, 300, 250, 150)
self.setWindowTitle('Icon')
self.setWindowIcon(QtGui.QIcon('web.png'))

这三个方法都是从类 QtGui.QWidget 中继承下来的。 setGeometry() 做了两件事情。首先是定位，然后是设置窗口大小。前两个参数是窗口的 x 和 y 。第三个参数是宽度，第四个是高度。事实上，它结合了 resize() 和 move() 。最后一个方法设置了应用的图标。为此，我们创建了 QtGui.QIcon 对象。 QtGui.QIcon 接受要显示图标的路径。

def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

启动代码放在了 main() 方法中。这是 Python 的惯用方式。

显示提示¶

我们可以给任何一个 widget 提供 balloon 式的提示。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
This example shows a tooltip on
a window and a button
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        QtGui.QToolTip.setFont(QtGui.QFont('SansSerif', 10))
        self.setToolTip('This is a QWidget widget')
        btn = QtGui.QPushButton('Button', self)
        btn.setToolTip('This is a QPushButton widget')
        btn.resize(btn.sizeHint())
        btn.move(50, 50)
        self.setGeometry(300, 300, 250, 150)
        self.setWindowTitle('Tooltips')
        self.show()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

在这个例子中，我们给 widget 都设置了 tooltip 。

QtGui.QToolTip.setFont(QtGui.QFont('SansSerif', 10))

这个静态方法设置了 tooltip 的字体。我们使用 10px 的 SansSerif 字体。

self.setToolTip('This is a QWidget widget')

为了创建 tooltip，我们调用了 setTooltip() 方法。我们可以使用富文本格式（rich text formatting）。

btn = QtGui.QPushButton('Button', self)
btn.setToolTip('This is a QPushButton widget')

我们创建了一个按钮并为它设置了 tooltip 。

btn.resize(btn.sizeHint())
btn.move(50, 50)

这个按钮被重新设置大小并移到窗口相应的位置。 sizeHint() 方法给出一个推荐的大小。

关闭窗口¶

关闭窗口最直观的方式就是点击标题栏上的 x 。在后面的例子中，我们将会展示如何编程来关闭窗口。我们将会简单的接触信号（signal）和槽（slot）。

下面是 QtGui.QPushButton 的构造器，我们将在例子中用到。

QPushButton(string text, QWidget parent = None)

参数中的 text 是将在按钮中显示的文字。而 parent 则是将要放置我们按钮的 widget 。在我们这个情况下则是 QtGui.QWidget 。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
This program creates a quit
button. When we press the button,
the application terminates.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui, QtCore
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        qbtn = QtGui.QPushButton('Quit', self)
        qbtn.clicked.connect(QtCore.QCoreApplication.instance().quit)
        qbtn.resize(qbtn.sizeHint())
        qbtn.move(50, 50)
        self.setGeometry(300, 300, 250, 150)
        self.setWindowTitle('Quit button')
        self.show()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

在这个例子中，我们创建了一个退出按钮。按了这个后，应用就将结束。

from PyQt4 import QtGui, QtCore

在这个例子中，我们用到了 QtCore 模块中的一个对象。

qbtn = QtGui.QPushButton('Quit', self)

我们创建了一个按钮。这个按钮是 QtGui.QPushButton 的实例。第一个参数是按钮的标签。第二个是父 widget 。此处的父 widget 是 Example 这个 widget。

qbtn.clicked.connect(QtCore.QCoreApplication.instance().quit)

在 PyQt4 中，事件系统（event processing system）建立于信号和槽机制。如果我们点击了一个按钮，点击的信号就被发送了。槽可以是 Qt 的槽或者任何 Python 可调用的。 QtCore.QCoreApplication 包含了事件的主循环。它处理所有的事件。 instance() 方法给我们它当前的实例。注意， QtCore.QCoreApplication 是和 QtGui.QApplication 一起创建的。点击的信号则和终止应用的 quit() 方法连接了起来。通信是在两个对象间完成。一个是发送者，也就是按钮，另一个是接受者，就是应用对象。

消息框¶

默认情况下，如果我们点击了关闭按钮， QtGui.QWidget 就被关闭了。有些时候我们需要修改默认的行为。例如，如果在编辑器中我们对某文件进行了修改。那么我们退出时就要弹出消息框进行确认。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
This program shows a confirmation
message box when we click on the close
button of the application window.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        self.setGeometry(300, 300, 250, 150)
        self.setWindowTitle('Message box')
        self.show()
    def closeEvent(self, event):
        reply = QtGui.QMessageBox.question(self, 'Message',
            "Are you sure to quit?", QtGui.QMessageBox.Yes |
            QtGui.QMessageBox.No, QtGui.QMessageBox.No)
        if reply == QtGui.QMessageBox.Yes:
            event.accept()
        else:
            event.ignore()
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

如果我们关闭 QtGui.QWidget ，就会产生 QtGui.QCloseEvent 。为了修改 widget 的行为，我们需要重新实现 closeEvent() 。

reply = QtGui.QMessageBox.question(self, 'Message',
    "Are you sure to quit?", QtGui.QMessageBox.Yes |
    QtGui.QMessageBox.No, QtGui.QMessageBox.No)

我们的消息框中有两个按钮， Yes 和 No 。第一个字符串显示在标题栏上。第二个则是对话框中的消息。第三个参数指定了要显示的按钮。最后的则是默认的按钮。焦点是默认在这个按钮上。返回值存在 reply 变量中。

if reply == QtGui.QMessageBox.Yes:
    event.accept()
else:
    event.ignore()

这里，我们可以测试返回值。如果我们点击了 Yes 按钮，我们接受了关闭应用的事件。否则，忽略这个事件。

居中窗口¶

下面的脚本将会演示如何把窗口在屏幕中居中。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
ZetCode PyQt4 tutorial
This program centers a window
on the screen.
author: Jan Bodnar
website: zetcode.com
last edited: October 2011
"""
import sys
from PyQt4 import QtGui
class Example(QtGui.QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()
    def initUI(self):
        self.resize(250, 150)
        self.center()
        self.setWindowTitle('Center')
        self.show()
    def center(self):
        qr = self.frameGeometry()
        cp = QtGui.QDesktopWidget().availableGeometry().center()
        qr.moveCenter(cp)
        self.move(qr.topLeft())
def main():
    app = QtGui.QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())
if __name__ == '__main__':
    main()

将会把窗口居中。

self.center()

把窗口居中的代码放在了自定制的 center() 方法中。

qr = self.frameGeometry()

我们得到一个指定主窗口几何的矩形。这个包含任何窗口框架。

cp = QtGui.QDesktopWidget().availableGeometry().center()

我们计算出显示器的分辨率，并且从分辨率中得到了中间点。

qr.moveCenter(cp)

我们的矩形已经有其宽度和高度了。现在，我们把矩形的中心移到屏幕的中心。矩形的大小并未改变。

self.move(qr.topLeft())

我们应用窗口的左上角移到 qr 的左上角，这样就完成了居中。

在本部分，我们涉及一些基本的知识。

mirguest 2012-02-05 10:00 发表评论

[Python][PyQt4]PyQt4 toolkit 介绍

mirguest — Sun, 05 Feb 2012 01:58:00 GMT

PyQt4 toolkit 介绍¶

关于此文档¶

本文档是一篇介绍 PyQt4 的教程。本教程的目的是让你开始使用 PyQt4 的toolkit。教程是在 Linux 中编写及测试。

关于 PyQt4¶

PyQt4 是用于创建 GUI 应用的 toolkit 。它是 Python 和 Qt 库的混合。Qt 库是一种很强大的 GUI 库。PyQt4 的官方网站在 www.riverbankcomputing.co.uk/news 。其开发者是 Phil Thompson 。

PyQt4 以一系列 Python 模块实现。它有超过 300 个类，以及几乎 6000 的函数及方法。它是一个多平台的 toolkit。它可以运行于大多数的操作系统。包括 Unix，Windows 和 Mac。PyQt4 具有双重的证书。开发者可以在 GPL 和商业的证书间选择。早先，GPL 只适用于 Unix。但从 PyQt4 开始，GPL 适用于所有支持的平台。

由于有很多类，所以它们被划分为几个模块。

QtCore
QtGui
QtNetwork
QtXml
QtSvg
QtOpenGL
QtSql

QtCore 模块包含核心的非GUI的功能。这个模块用于时间，文件和目录，多种数据类型，流，url，mime type，线程或进程。 QtGui 模块包含图形的组件和相关的类。这里包含例如按钮，窗口，状态栏，工具栏，边栏，位图，颜色，字体等。 QtNetwork 模块包含用于网络编程的类。这些类允许编写 TCP/IP 和 UDP 客户端及服务端。它们使得网络编程更加简单和可移植。 QtXml 包含用于处理 xml 文件的类。此模块提供了包括 SAX 和 DOM API 的实现。 QtSvg 模块提供了用于显示 SVG 文件内容的类。Scalable Vector Graphics（SVG）是一种用于描述二维图形的语言。 QtOpenGL 模块则用 OpenGL 库表现 3D 及 2D。这个模块可以无缝的把 Qt GUI 库和 OpenGL 库连接起来。 QtSql 库则提供了用于数据库的类。

Python¶

Python 是一个动态的面向对象的编程语言。这是一个通用的语言。它可以用于很多种软件开发。Python 语言的设计理念就是强调程序员的效率及代码的可读性。Python 最初是由 Guido van Rossum 开发。它在 1991 年放出第一版。Python 受到 ABC，Haskell，Java，Lisp，Icon 和 Perl 的启发。它是一个高层次，通用目的，多平台，解释型语言。Python 是一种极简的语言。其中一个最显而易见的特性就是它不使用分号或者花括号。取而代之，Python 使用缩进。目前 Python 有两个主要分支，Python 2.x 和 Python 3.x 。Python 3.x 不向下兼容。它的创建主要是想修改某些设计缺陷并使得语言更加简洁。最常见的 2.x 版本是 2.7.1 , 3.x 版本是 3.1.3 。本教程主要涉及 2.x 版本。大多数代码以 2.x 编写。把代码转到 3.x 需要花费一些时间。目前，Python 是由一大群世界上的志愿者维护。Python 是一个开源软件。

Python 非常适合于一些想学习编程的人。

Python 语言支持多种编程范式。它并不强行要求程序员用哪种特定的范式。Python 支持面向对象及过程式编程。对于函数式编程也有一定的支持。

Python 的官网是 python.org 。

在 2011年 8月，TIOBE Index 中 Python 的排名是第 8 名。在 langpop.com 中则是第 6 位。

Perl，Python 和 Ruby 是最常用的脚本语言。它们有很多相似之处。它们是相近的对手。

Python toolkit¶

为了创建图形用户接口，Python 程序员目前会选择几种，PyQt4，PyGTK 和 wxPython。选择哪个依赖于具体的条件。

因为一些证书的问题和技术需求，一种新的 Qt 和 Python 结合的项目被开发，成为 PySide 。PySide 与 PyQt4 有很高的兼容性。

mirguest 2012-02-05 09:58 发表评论

[Python] Leo 翻译 Some Outline Commands

mirguest — Fri, 03 Feb 2012 04:54:00 GMT

Some outline commands¶

You can use Leo as fairly typical outliner. Click the expansion box of nodes to show and hide their children.

你可以将 Leo 完全作为一个普通的 outliner 。点击节点的扩展盒子来显示隐藏它们的子节点。

Play around with some of the commands from the Outline menu or from the minibuffer. The keyboard shortcut and minibuffer key sequence appear in parentheses. Note: as usual, you can use tab completion in the minibuffer.

你可以从 outline 菜单或者 minibuffer 中玩弄一些命令。键盘的快捷键和 minibuffer 按键总是成对出现。注意：和普通的一样，在 minibuffer 中你可以使用 tab 进行补全。

Edit Headline (Ctrl+H or edit-headline)

Begins editing of the headline text of a node. To end editing, hit or

开始编辑一个节点的 headline 文字。要结束编辑，输入或

Insert Node (Ctrl+I or insert-node)

Inserts a new headline into the outline.

往 outline 中插入一个新的 headline 。

Cut Node (Ctrl+Shift+X or cut-node)

Deletes a node and all its descendants, copying them to the clipboard.

删除一个节点及其所有子节点，然后复制它们到剪贴板。

Paste Node (Ctrl+Shift+V or paste-node)

Pastes a tree copied by the Cut Node command.

粘贴一个被剪切的树节点。

Copy Node (Ctrl+Shift+C or copy-node)

Copies a node and all its descendants to clipboard without deleting it from outline. You can copy a tree from one Leo outline to another using Copy Node and Paste Node.

复制一个节点及其所有子节点，但是并不将其删除。你可以使用 Copy 和 Paste 将一棵树从一个 outline 到另一个 outline 。

Contract or Go Left (Alt-Left-Arrow or contract-or-go-left

Contracts a node if it is expanded, otherwise selects its parent.

如果一个节点是展开的，那么就将其收缩。否则，选中其父节点。

Expand and Go Right (Alt-Right-Arrow or expand-and-go-right)

Select a node’s first child, expanding the original node if needed.

选中一个节点的第一个子元素，如果有必要，就展开此节点。

Goto Prev Visible (Alt-Up-Arrow or goto-prev-visible)

Select the previous visible node.

选中前一个可见的节点。

Goto Next Visible (Alt-Down-Arrow or goto-next-visible)

Select the next visible node.

选中下一个可见的节点。

Move Up (Ctrl+U or move-outline-up)

Moves a node up in the outline.

将一个节点上移。

Move Down (Ctrl+D or move-outline-down)

Moves a node down.

将一个节点下移。

Move Left (Ctrl+L or move-outline-left)

Moves a node left.

将一个节点左移。

Move Right (Ctrl+R or move-outline-right)

Moves a node right.

将一个节点右移。

Promote (Ctrl+} or promote)

Makes all the children of a node to be siblings of the node.

使一个节点的所有子节点与其同级。

Demote (Ctrl+{ or demote)

Makes all following siblings of a node to be children of the headline.

使一个节点后面的同级节点变为该节点的子节点。

Please experiment with Leo’s outline now. Move around the tree and expand/collapse nodes by pressing Alt + arrow keys. This also moves the focus to tree, so, after pressing Alt + arrow, you can move around by using arrow keys alone. Return the focus to the body control by pressing Enter.

请现在就试试 Leo 的 outline 。通过 Alt + 箭头在树中上下移动，展开闭合节点。这也移动了焦点，所以，在按了 Alt + 箭头后，你可以直接用方向键了。按 Enter 可以把焦点移回 body 中。

mirguest 2012-02-03 12:54 发表评论

[Python] Leo Tutorial 翻译

mirguest — Fri, 03 Feb 2012 04:50:00 GMT

The Leo Tutorial ¶

Leo is a power tool for people who want to organize, study and work with data, especially complex data like computer programs, books, web sites and data bases. Superficially, Leo may look like other outlining programs, code folding editors or class browsers, but it most certainly is not.

Leo 是一个强大的工具，适用于下面的人：希望组织，管理，研究和处理数据，特别是复杂的数据，像计算机程序，书籍，网页以及数据库。表面上看， Leo 像其他 outline 的程序，代码折叠编辑器或类浏览器，但是事实上，它并不是。

People say Leo is a revolutionary tool, and that Leo is fun to use, even additive. There is a unique “Leo way” of managing data; the term Leonine describes how people treat data in “the world according to Leo”. Leo definitely takes a bit of work to understand. Leo’s users speak of an “Aha” moment, when they see how these pieces fit together: outline structure is significant everywhere. For a more detailed introduction to Leo, see Leo in a nutshell.

人们说 Leo 是一个革命性的工具，而且 Leo 用起来很有趣，而且还有甚者。管理书籍有 Leo 式的方法；单词 Leonine 描述了人么如何在 Leo 的世界中管理数据。 Leo 毫无疑问需要慢慢理解。当 Leo 的用户看到了一些片段，他们会说出“Aha”: outline 结构在任何地方都很有意义。具体介绍 Leo 请参考 Leo in a nutshell 。

Leo is freely available in source or binary form for all major platforms. You may download Leo from http://sourceforge.net/projects/leo/files/Leo/ Leo is Open Software and may be freely distributed.

Leo 无论源代码或是二进制程序都是免费的，而且支持大多数的平台。你可以从 http://sourceforge.net/projects/leo/files/Leo/ 下载 Leo。 Leo 是开源软件，而且可以免费发行。

Leo’s home page contains additional documentation and links to other resources. For another introduction to Leo, open the file quickstart.leo in the leo/doc folder.

Leo’s home page 包含了额外的文档和链接。关于 Leo 另外的介绍，打开在 leo/doc 目录中的 quickstart.leo 进行查看。

This tutorial introduces the reader to the basic concepts and features of Leo. It helps to have Leo running for hands-on experience, but all examples here are self-contained, so the tutorial can be read off-line as well. See Leo’s Installation Guide. for detailed installation instructions. If you have problems installing Leo, please ask for help on Leo’s forum.

本教程将介绍 Leo 基本的概念和特性。它帮助你快速的将 Leo 运行起来，所有的例子也是包含于安装包中，所以你可以离线的阅读。关于安装具体请看 Leo’s Installation Guide 。如果你在安装中碰到了困难，请在 Leo’s forum 中寻求帮助。

This tutorial does not attempt to be comprehensive and cover every single feature of Leo, or even every commonly used feature. Instead, it introduces many of Leo’s most noteworthy features, and will give you a good idea of Leo’s flavor and style. After reading it, you will be able to use Leo in basic ways to create external files, organize data and run simple scripts. You will then be ready to learn more about Leo’s many advanced features.

这篇教程并不打算很全面的涉及 Leo 的每个特性，或者甚至是最常用的特性。相反，它仅仅介绍很多值得注意的特性，并让你对 Leo 有相应的想法，比如它的流派和风格。在阅读完它之后，你将会用 Leo 创建外部文件，组织数据以及运行简单的脚本。然后你就会打算学习更多关于 Leo 的高级特性。

The Glossary is also worth reading.

Glossary 也是很值得一读。

Contents

The Leo Tutorial

Leo’s main window ¶

Let’s start looking at Leo in detail. We’ll start with what you see when you first open Leo, Leo’s main window. Leo’s main window, shown below, represents an entire project. As you can see, the main window contains three panes: the outline pane at the top left, the log pane at the top right, and the body pane at the bottom. The window also contains an icon area at the very top, a status area and a mini-buffer at the very bottom.

让我们更详细的看看 Leo 。我们将从你一打开 Leo 的地方开始讲解。 Leo 的主窗口。 Leo 的主窗口，像下面显示的，代表了一个完整的项目。正如你见到的，主窗口包含了三个面板：左上方的 outline pane ，右上方的 log pane ，以及底部的 body pane 。当然，窗口中还包含了很顶部的 icon area ，底部的 status area 和 mini-buffer 。

Outline pane

The outline pane shows your project as an outline. The outline contains all your project’s data. An outline consists of nodes. The icon box is a small icon directly to the left of the headline text. The border of the icon box is black if the node has been changed. Smaller icons within the icon box indicate the status of the node:

Outline pane 将你的项目以提纲的形式显示。 outline 中包含了所有你项目的数据。一个 outline 包含 node 。而 icon box 是一个紧挨着标题的小的图标。如果节点中的内容有改变，那么这个的边框就变为黑色的。而里面更小的图标指示了节点的状态：
A small blue box:   the node has body text.
A red vertical bar: the node is marked.
A circular arrow:   the node is cloned.
一个蓝色的盒子： 节点的 body 中包含了文字。
一个垂直的红棒： 节点被标记了。
一个圆形的箭头： 节点被 clone 了。
If a node contains children, a smaller icon appears to the left of the icon box. This icon contains a ‘+’ or ‘-‘ symbol. Clicking this expansion box expands or contracts the node.

如果一个节点包含了子节点，一个更小的图标将在这个的左边显示。图标中包含了以后 ‘+’ 或 ‘-‘ 这样的符号。点击这个符号就将这个节点展开或闭合。

Node

Each outline node has two two parts, a headline and body text. The outline pane shows headlines. Selecting a headline selects the entire node; the node’s body text appears in the body pane. Leo uses standard terminology to describe the relationships of nodes in an outline. We speak of parent nodes, child nodes, ancestor nodes and descendant nodes.

每个节点有两个部分，一个 headline 和 body text 。而 outline pane 中显示 headline 。选择一个 headline 就选择了一整个节点；节点的 body text 部分会显示在 body pane 中。 Leo 使用标准的术语来描述节点的关系。我们会说 parent 节点， child 节点， ancestor 节点和 descendant 节点。

Body pane

The body pane contains the body text of the node selected in the outline pane.

Body pane 包含了被选定的节点的内容。

Log pane

The log pane contains informational messages from Leo or your scripts.

Log pane 中包含从 Leo 或你的脚本中来的信息。

Icon area

Depending on what plugins are enabled, the icon area may contain buttons and other widgets that extend what Leo can do. The scripting plugin makes it easy to add buttons to the icon area.

根据插件的激活情况，此处将会包含不同的按钮和其他的部件，用于扩展 Leo 。 scripting plugin 可以很方便的将按钮放到 icon area 中。

Status area

The status area shows the line and column containing the body text’s cursor, and the UNL (Uniform Node Location), the path from the top of the outline to the selected node. This path will change as you change outline nodes.

Status area 显示光标所在行和列，以及 UNL （Uniform Node Location），从顶层节点到当前节点的路径。这个路径将随着你的选择而改变。

Minibuffer

You can type command and search strings in the minibuffer. It works much like the Emacs mini-buffer. To enter a command, type followed by the command name and then . To type a search string, type followed by the search string and then . For full details, see Using Leo’s Commands.

你可以在 minibuffer 中输入命令以及搜索的字符串。这个和 Emacs 中的 mini-buffer 非常相似。为了输入一个命令，输入然后后面输入命令的名称，然后输入。为了搜索字符串，输入然后输入要搜索的路径并按。具体的请参考 Using Leo’s Commands 。

External files and @file nodes ¶

Leo stores outline data on your file system in .leo files. The format of these files is XML. You don’t have to store all your data in .leo files: Leo allows you to store parts of your outline data external files, that is, other files on your file system.

Leo 将 outline 的数据以 .leo 存在你的文件系统中。这些文件的格式是 XML 。你不需要把你全部的数据全部存在 .leo 文件中： Leo 允许你将 outline 中的部分数据以 external file 的形式保存。

@file nodes create external files. @file nodes have headlines starting with @file followed by a file name. Some examples:

@file node 将创建外部的文件。 @file 节点的 headline 以 @file 开头，然后跟着一个文件名。后面是一些例子：

@file leoNodes.py
@file ../../notes.text

The file name can be an absolute path or a relative path to the file that starts at Leo’s load directory, the directory containing the .leo file.

文件名可以是绝对路径或者是相对路径（以当前载入 leo 文件的路径开始）。

Leo reads and writes external files automatically when you open or save your Leo outline:

Leo 将会自动地读取和写入 external file，当你打开或保存 Leo 的 outline：

When you open an outline (.leo file) Leo reads all the external files created by the @file nodes in the outline. If you have changed an external file outside of Leo, Leo will update the corresponding @file tree to reflect those changes when Leo next opens the outline.

当你打开一个 outline （.leo 文件） Leo 将会读取所有被 @file 节点创建的 external 文件。如果你在 Leo 外改变了一个 external 文件， Leo 在下一次打开 outline 时，将会更新相应的 @file 节点。

When you save your outline, Leo writes all dirty @file nodes. An @file is dirty if the node or any of its descendant nodes has changed. Important: When Leo writes an external file, Leo writes all the essential information in the @file tree to the external file, not to the .leo file. The only nodes that gets written to the .leo file are nodes that are not contained in any @file tree.

当你保存 outline 时， Leo 会写入所有的 dirty @file 节点。当一个节点或任何相应的子节点改变时，这个 @file 就是 dirty 的。重要：当 Leo 写一个 exteranl 文件， Leo 会写入所有重要的信息，尤其是 @file 树中的信息到外部文件中，而不是到 .leo 文件中。只有那些不包含 @file 的节点才被写入到 .leo 中。

Creating external files from outlines ¶

We come now to one of Leo’s most important and unusual features. When Leo writes an external file, it does so in a flexible manner, directed by outline-based markup. This markup tells Leo exactly how to create the external file from an @file node.

我们现在来见见 Leo 中很重要而不寻常的特性。当 Leo 向一个 external 的文件写入东西时， Leo 会通过 outline-based markup 的指令，进行合适配置。这个标记会准确的告诉 Leo 如果从一个 @file 节点创建 external 文件。

The obvious way to write an external file would be to write the @file node itself followed by all the descendant nodes in outline order (the order in which nodes appear in the outline). But Leo does not write external files exactly this way.

最明显的方式，就是根据子节点的 outline 顺序 对 @file 节点进行写入。但是 Leo 并不是完全按照这种方式进行。

Yes, Leo does indeed start by writing the @file node itself. But Leo writes the @file node’s descendants only when it sees one of three kinds of Leo markup: section references, the @others directive and the @all directive. We’ll discuss these three kinds of markup in the next section.

是的， Leo 的确从写入 @file 节点开始。但是对于 Leo ，只有它见到了相应的指令，才会将 @file 节点的子节点的内容写入。有三个这样的指令： section reference ， @other 指令 ，以及 @all 指令 。我们将在后面对这些标记进行讨论。

Section references and the @others and @all directives tell Leo to write the expansion of one or more descendant nodes to the external file. Programmers will recognize this process as akin to macro expansion. The following sections will explain this process in detail.

Section reference ， @others 和 @all 指令告诉 Leo 将子节点扩展到 external 文件中。程序员会知道这个宏扩展很像。下面的篇幅就将讨论这些。

Section references ¶

A section reference is a line of body text of the form:

一个 section reference 就是在 body text 中有下列形式：

<< a section name >>

Here, “a section name” can be any descriptive text not containing “>>”. When Leo encounters a section reference, Leo searches all the descendants of the node containing the reference looking for a node whose headline matches the section reference. That is, Leo looks for a descendant node whose headline starts with:

此处， "a section name" 可以是任何文字，但不包括 “>>” 。当 Leo 碰到一个 section reference ， Leo 会搜索所有的子节点，然后去匹配在 headline 中有相同内容的引用。也就是， Leo 会搜索下面的 headline ：

<< a section name >>

We call such nodes named nodes. Leo doesn’t require an exact match. Leo ignores whitespace and the case of letters when comparing headlines to section reference. Also, Leo ignores anything that may follow the section name in a named node. For example, the following headline will match the section reference above:

我们称这些节点为 named node 。Leo 不需要完全的匹配。它会忽略空格和大小写。同样， Leo 会忽略在此之后的内容。比如，下面的 headline 也是可以被匹配的：

<< A Section Name >> (to do)

If Leo does find a match, Leo replaces the section reference (“<< a section name>>”) by the expansion of the body text of the matched node. That is, Leo replaces the section reference by the body text of the matched node, but Leo expands all markup in the matched node before making the replacement. The entire expansion of the matched node replaces the original section reference. Programmers will recognize this process as recursive macro expansion.

如果 Leo 的确找到了一个匹配，Leo 会替换这个 section reference （”<< a section name>>”），并把 named node 的内容扩展进来。也就是， Leo 会把匹配的节点的 body text 替换到这里，但是 Leo 在进行替换前，会先对所有的标记进行扩展。这样，原始的 section reference 就被真正的内容替换了。程序员就会想到这就是递归的宏扩展。

We have just discussed what happens if Leo does find a descendant named node that matches the section reference. If no such match is found the section reference is said to be undefined and Leo does not write any data to the external file. This is not a serious error: Leo will will save the erroneous @ tree in the .leo file instead of the external file. No information is lost. By the way, Leo’s syntax coloring will indicate undefined section reference by underlining the section name.

我们刚讨论了如果 Leo 发现一个子的 named node 之后会发生的事情。如果没有找到这样的，那么这个 section reference 就被认为是 undefined 而且 Leo 也不会向 external 文件中写入任何东西。这不是一个很严重的错误： Leo 会把这些写入到 .leo 文件中，而不是 external 文件中。没有任何信息会被丢掉。顺便说下， Leo 的语法加色会指示这个是未定义的引用，通过加一个下划线。

Important: the indentation of section references matters. When expanding a section reference, Leo indents every line of the expansion by the leading whitespace that occurs before the section reference. Note also that you can’t write something after a section reference and expect it to end up on the same line after expansion–Leo always writes a newline after the expansion.

重要：section reference 的缩进是有意义的。当进行扩展时，被扩充的内容前面都会加入空格。而且注意，你不能往 section reference 后写入东西并指望这些会出现在每行的末尾。 Leo 在扩展后总会插入一个新行。

The @others directive ¶

The @others directive is the second (and most common) way of including descendant nodes in an external files. When Leo encounters the @others directive it replaces the @others directive by the expansion of all unnamed descendant nodes. As with section references, Leo replaces all markup in the descendant nodes, and the entire expansion replaces the @others directive.

@others directive 是第二个（而且是最常用的）方式，对子节点进行包含。当 Leo 碰到 @others 指令时，它会把所有 unamed 的子节点都包含进来。和 section reference 一样， Leo 会替换所有的标记，然后扩展完后的才会去替换 @others 指令。

In short, section references write named nodes; @others directives write all unnamed nodes. By the way, no node may contain more than one @others directive because there would be no way to “apportion” descendant nodes to more than one @others directive. However, nodes may contain as many section references as you like.

简而言之， section reference 会写入 named 节点；而 @others 指令则会写入 unnamed 节点。顺便说下，没有节点可以包含超过一个的 @others 指令。因为没法将这些子节点分配给多个 @others 指令。但是，节点中可以包含很多的 section reference 。

As with section references, the indentation of the @others directive matters. This allows Leo to handle Python source code properly. For example, the following is a common way of representing a Python class:

和 section reference 一样， @others 指令的缩进也是有意义的。这就允许 Leo 可以正确的处理 Python 的源代码。比如，下面一个是表示 Python 类最常用的方式：

class myClass:
    '''a docstring'''
    @others

When Leo writes this node to an external file, Leo will write the first two lines to the external file, with the indentation in effect for the node. Leo will then write all descendant nodes to the external files, with additional indentation equal to the leading whitespace appearing before the @others directive.

当 Leo 把这个节点写入一个 external 文件时， Leo 会把头两行先写入 external 文件，而且缩进也会影响节点。 Leo 然后就把所有的子节点写入，然后会在替换出的内容前再加上额外的空白。

The @all directive ¶

The @all directive is the third, simplest (and least common) way of including descendant nodes. This directive causes Leo to write all descendant nodes in outline order, regardless of whether they are named or not. Furthermore, the @all directive does not expand any markup in descendant nodes. This results in Leo writing the external file in the “obvious” way. That is, Leo writes all descendant nodes in outline order.

而 @all 指令是第三个，最简单（最不常用）的方式来包含子节点。这个指令会让 Leo 以 outline 的顺序写入所有的子节点，而不管节点是否命名。此外， @all 指令不会对子节点中的任何标记进行扩展。这个就使得 Leo 以最直接的方式写入 external 文件。 Leo 会以 outline 的顺序写入所有的子节点。

Use the all directive if your external file contains unrelated nodes. For example, I use an external file to store programming notes. These notes typically contain snippets of programming source code, but there is no real relationships between the snippets–the file is simply a grab bag of information. The @all directive is designed for this situation.

如果你的 external 文件包含了无关的节点，那么可以用这个指令。比如，我用一个 external 文件保存编程的笔记。这些笔记包含了代码中的一些片段，而在这些片段之间并无联系。这些文件仅仅就是存放信息的袋子而已。 @all 指令就是为这种情况设计的。

Choosing between @others and sections ¶

Newcomers to Leo frequently ask when to use the @others directive and when to use sections. It is good style to use section references only when the order of text within a external file matters. For example, Python programmers put docstrings and imports at the start of files. So the body text of @file nodes typically look something like this:

Leo 的新手经常会问到，什么时候使用 @others 指令而什么时候用 section 。在涉及内容的顺序时，使用 section reference 是比较好的。比如， Python 程序员一般会把 docstring 和模块导入放在文件的开头。所以， @file 节点中的 body text 经常看起来像这样：

<< docstring >>
\@language python
\@tabwidth -4
<< imports >>
@others

This ensures that the docstring is first in the file, followed by imports, followed by everything else. Note that the order in which functions are defined in a file, or methods defined within a class, typically does not matter. Thus, it is good style to define classes like this:

这就保证了 docstring 是在文件的最开始，然后再是模块导入，而后又是其他任何东西。注意，在文件中函数的定义，方法在类体内的定义的顺序是无关的。因此，下面的定义类的方式是比较好的习惯：

class myClass:
      << class attributes >>
      @others

It would be bad style to define a class like this:

而下面的则不是很好：

class myClass:
      << class attributes >>
      << method 1 >>
      << method 2 >>
      ...

Not only does this over-specify the order in which methods are defined, but it requires lots of extra typing. Not only must you add a line for each method, but headlines must contain section names such as << method 1 >>, <>, etc. When using @others it is good style simply to put the name of each method in the headline.

不仅仅因为这过分特化了方法在类中的顺序，而且这也需要大量额外的输入。你不仅需要为每个方法添加这样的一行，而且在 headline 中也需要包含像 << method 1 >> ， << method 2 >> 这样的东西。而使用 @others 就大大简化了要把方法放在 headline 中这样的事情。

Organizing programs as outlines ¶

A few more words about style:

更多关于风格：

It is good style to put each class, function or method in its own node. This makes it easy to see the shape of your code.

最好把每个类，函数或方法放在自己的节点中。这样就利于看清楚你代码的结构。
It is good style to use organizer nodes to group related functions or methods. An organizer node has no content except maybe for comments. Like this:

把相关的函数或方法分组也是很好的习惯。一个所谓的 organizer 节点除了用于注释，就可以没有其他用处了。像这样：
```
+ myClass
    + birth and death
        + __init__
        etc.
    + getters
        etc.
    + setters
        etc.
    + misc methods
        etc.
```
(In this notation, ‘+’ denotes a headline.) This organization is far superior to using hideous comments like:

（在这个记法中， ‘+’ 表示一个 headline 。）这样的组织比那种隐式的注释要好很多：
```
###########
# Getters #
###########
```
It is bad style to use @others in organizer nodes. There is no need to do so.

用 @others 当为组织节点并不好。没有必要那么做。
It is bad style to use @others when order does matter. The reason is that it is very easy to move nodes in a tree by mistake, say by alphabetizing nodes. One wants to make the meaning of a external file immune from such movements.

当顺序是有意义的时候，最好不要使用 @others 。原因是在一棵树中很容易误动节点，比如按字母顺序对节点排序。我们希望这样的移动对文件没有任何影响。

One last word about style. The world won’t end if you happen to use bad style by mistake: you just might cause a bit more work for yourself than was strictly necessary. Feel free to invent your own style of using Leo. Still, it would be wise to “know the rules before you break them.”

最后再说一点。你由于无意使用了不好的风格，也不会怎样：你可能仅仅为自己带来了一点小麻烦。在使用 Leo 的过程中你可以创造自己的风格。但是“在打破规则前了解它们”还是比较明智的。

Clones & views ¶

A clone is a node that appears in more than one place in a Leo outline. Clones are marked with a small red arrow in the icon box. All clones of a node are actually the same node, so any change to one clone affects all clones. For example, inserting, moving or deleting any child of a clone will change all other clones on the screen.

克隆（clone） 是在 Leo 的 outline 中，不止在一个地方出现的节点。在 icon box 中，以一个红色的箭头标记克隆。一个节点的所有 clone 事实上是 相同的节点 ，所以对任何一个克隆的改变都会影响所有的克隆。比如，插入，移动或删除任何克隆的子节点都会导致所有其他克隆的改变。

Please take a few moments to experiment with clones. Create a node whose headline is A. Clone node A using the Clone Node command in Leo’s Outline menu. Type some text into the body of either clone of A. The same text appears in the bodies of all other clones of A. Now insert a node, say B, as a child of any of the A nodes. All the A nodes now have a B child. See what happens if you clone B. See what happens if you insert, delete or move nodes that are children of A. Verify that when you delete the penultimate clone, the last clone becomes a regular node again.

请最好花一点时间试试克隆。创建一个节点，称其 headline 是 A 。然后再使用 Leo outline 菜单中的克隆命令对节点 A 进行克隆。然后再往 A 的任何克隆的 body 中输入一些文字。这样其他克隆中也就会出现相应的文字。现在，插入一个节点，称为 B ，作为 A 的子节点。这样，所有 A 节点就会有 B 这样的子节点。现在，再看看如果克隆了 B 有什么后果。看看如果你插入，删除或移动 A 的子节点会发生什么。核实下当你删除倒数第二个克隆后，最后一个克隆是不是又变回一个正常的节点了。

Clones are much more than a cute feature. Clones allow multiple views of data to exist within a single outline. With Leo, there is no such thing as a single, “correct” view of data. You can have as many views of data as you like.

克隆不止是一个非常好的特性。克隆允许对数据进行多种视图。在 Leo 中，没有所谓 “正确的”视图方式。你可以任由你的喜欢对数据进行视图。

To create a new view of the data in your outline, just do the following:

要创建一个新的视图方式，只要按下面做就可以了：

Create an ordinary node, that will represent the view. We call these nodes view nodes merely to indicate they represent a view.

创建一个 正常的 节点，用于代表视图（view）。我们称这些节点为 view node 仅仅是代表一个视图。
Clone all the nodes from the outline that you want the view to contain. Move these clones so they become children of the view node.

克隆所有你所需要的节点。然后把它们移到 view node 中。
(Optional) You can add regular nodes as children of the view node too.

（可选的）你可以增加一个正常的节点作为 view node 的子节点。

For example, when I fix a bug in Leo, I create an ordinary node to represent the bug. This bug node is my view of all the data in Leo’s source code that relates to the bug. As I discover code related to the bug, I clone their nodes and move them under the bug node. I’ll also add ordinary nodes as children of the bug node. These nodes contain the original bug report, descriptions of how I fixed the bug, test data, or any other notes I might want to keep.

比如，当我修复了 Leo 中的一个bug时，我会创建一个正常的节点用于表示bug。这个 bug node 就是用于 bug 相关的视图。如果我发现与此 bug 相关的代码，我会把这段代码进行克隆，然后移到 bug 节点下。我也会增加普通的节点作为 bug node 的子节点。这些节点包含了原始的 bug 报告，我如何修复了这个bug，测试的数据，或者其他我保留的节点。

Once I have created the bug node, I concentrate only on that node and its children. I can examine the bug node and its children without having to jump around the outline. Everything I need is in one place. When I get around to actually fixing the bug I can do so by changing the clones. Again, I do not have to jump around the outline. It doesn’t matter how big or complex the entire outline is: I am only dealing with the bug node and its children. This extremely narrow focus makes it much easier to fix bugs.

一旦我创建了一个 bug 节点，我主需要关注那个节点和它的子节点。我可以检验那个 bug 节点及子节点而无须在 outline 跳转。所有我需要做的，就是在一个地方。当我有时间修复了 bug ，我只需要修改 clone 。再次的，我也无须跳转。整个 outline 有多大或多复杂都无所谓：我仅仅需要处理 bug 节点及其子节点即可。把问题集中在一点就使得修复 bug 变得比较简单。

By the way, I never have to remember to save external files. When I change any clone, Leo marks all instances of that clone throughout the entire outline as dirty (changed). When I save the Leo outline, Leo automatically writes all the external files that contain dirty nodes.

顺便说下，我从来不需要记得保存 external 文件。当我改变了任何一个克隆，Leo 就会标记所有克隆的实例，整个 outline 被认为是 dirty （改变了）。当我保存 Leo 的 outline，Leo 自动的会写入包含 dirty 节点的 external 文件。

Views have an unlimited number of uses. Use them whenever you want to focus your attention on some smaller set of nodes. For example, I often create view nodes when studying other people’s code. The view node helps me concentrate on just the part of the code that interests me at the moment.

视图的使用没有限制。在你想集中于一些更小的节点集合时就使用它们。比如，我在研究别人的代码时，我就会创建视图节点。这些视图节点帮助我集中于某一段我感兴趣的代码。

More about directives ¶

Leo’s directives control such things as syntax coloring, line wrapping within the body pane and the width of tabs. Leo directives may appear in headlines or body text. Leo directives start with ‘@’, followed by the name of the directive.

Leo 的 指令(directive) 控制着一些这样的事情，如语法加亮，在 body 面板中行的包装和 tab 的宽度。Leo的指令可以出现于 headline 或 body 文字中。 Leo的指令以 '@' 开始，而后跟着指令的名字。

Note: Leo handles Python decorators properly, providing they don’t conflict with Leo’s directives.

注意：Leo可以正确的处理 Python 的装饰器（decorator），而不会使得与 Leo 的指令相冲突。

Here are some of Leo’s directives:

这里是一些 Leo 的指令：

@language python
@tabwidth -4
@wrap
@nowrap
@color
@nocolor
@killcolor

Most directives must start with the ‘@’ in the leftmost column, but whitespace may appear before the '@others‘ and '@all‘ directives. As we have seen, such whitespace is significant.

大多数的指令必需在最左边的列上以 '@' 开头，但是在 '@others' 及 '@all' 前可以出现空白。正如我们所见，这些空白是有意义的。

Directives apply until overridden in a subtree. All of these directives apply to the node they are contained in, and also to the entire tree of descendant nodes, unless over-ridden by a similar directive in a descendant node. For example, the directive:

指令在子树中都会生效直至遇到覆写。所有的这些指令在包含它们的节点中都会生效，以及相应的子节点，除非是在子节点有相同的指令对此进行覆写。比如，这个指令：

@language python

tells Leo to syntax color the node and all descendant nodes as Python code. However, some descendant node might contain:

告诉 Leo 以 Python 的语法加亮这个节点及所有派生节点。但是有些派生的节点可以包含：

@language rest

which tells Leo to color that node and all of its descendants as reStructureText. This principle applies to almost all of Leo’s directives: the directive is in effect throughout a tree, unless overridden in some subtree.

这个就告诉 Leo 以 reStructureText 对这个节点及派生节点进行高亮。这个原则对几乎所有的 Leo 指令都适用：指令在整棵树中都有效果，除非在一些子树中被覆写。

@color, @nocolor and @killcolor

These directives control how Leo colors body text. You can mix @nocolor and @color directives in a single node. This directives affect descendant nodes unless a node contains both @color and @color. Such ambiguous nodes do not affect the coloring of descendant nodes.

这些指令控制这 Leo 如何对 body 中的文字进行加亮。可以在一个节点中混合使用 @nocolor 和 @color 指令。这些指令会影响派生的节点除非一个节点中同时包含 @nocolor 和 @color 指令。这样不确定的节点的子节点就不会受到影响。

@first

This directive forces a lines to appear before the first sentinel of a external file. Here is a common way to start a Python file:

这个指令强行让一行按顺序出现于一个 external 文件中。此处在 Python 文件中是最常见的：

@first #! /usr/bin/env python @first # -- coding: utf-8 --

@language

Sets the language in effect for a tree. This affects how Leo colors body text. It also sets the comment delimiters used in external files. Leo supports dozens of languages. See Leo’s reference for a complete list. Here are a few:

设置相应的语言。这就影响 Leo 对 body 文字的加亮方式。这也设置了在 external 文件中注释所用的分界符。 Leo 支持挺多语言的。参考 Leo’s reference 。此处是一些：
@language python
@language c
@language rest # restructured text
@language plain # plain text: no syntax coloring.

@pagewidth

Sets the page width used to format break doc:

设置格式化文档时所用的页宽：
@pagewidth 100

@path

This directive is a convenience. Rather than specifying long paths in @file nodes, you can specify a path in an ancestor @path node. For example, suppose three nodes have the following headlines:

这个指令很方便。不需要在 @file 中指明很长的路径，你可以在一个父节点中指定 @path 节点。比如，假设有下面三个节点：
@path a
    @path b
        @file c/d.py
Because of the ancestor @path nodes, the @file node creates the file a/b/c/d.py

因为父节点的 @path ，@file 节点创建的文件会是 a/b/c/d.py 。

Within @path and @ paths, {{exp}} gets evaluated with the following symbols known: c, g, p, os and sys. For example:

在 @path 和 @ 的路径中， {{exp}} 会执行下面已知的符号： c，g，p，os和sys。比如：
@file {{os.path.abspath(os.curdir)}}/abc.py
refers to the file abc.py in (absolute path of) the current directory.

就会指向当当前目录下的 abc.py 文件。

@tabwidth

Sets the width of tabs. Negative tab widths cause Leo to convert tabs to spaces and are highly recommended for Python programming.

设置 tab 的宽度。负的宽度就表示将 tab 转换为空格，并且这是 Python 编程建议的。

@wrap and @nowrap.

These enable or disable line wrapping the Leo’s body pane.

这个开启或关闭行包装。

Scripting, extending and customizing Leo ¶

Leo is fully scriptable using the Python language. Leo can execute any body text as a Python script. To run the entire body text as a script, simply choose the node and execute the Execute Script command (Ctrl+B). If text is selected, the Execute Script command will run just the selected text as the script.

Leo 可以使用 Python 进行脚本编程。 Leo 可以将任意的 body 文字作为 Python 脚本执行。为了将一整段作为脚本执行，只要选中相应的节点，然后执行执行脚本的命令（Ctrl+B）。如果有文字被选中，那么就会只执行选中的部分。

The Execute Script command preprocesses the script before executing it, in exactly the same way that Leo writes external files. Leo expands section references and processes @others directives before executing the script. This allows you to use all of Leo’s outlining capabilities to organize your scripts.

执行脚本命令在执行它之前将预处理这个脚本，这和 Leo 写入 external 文件是一样的。在执行这个脚本前， Leo 将会扩展 section reference 和处理 @others 指令。这个就允许你使用 Leo 的 outline 来组织你的脚本。

Your Python scripts can easily access data in an outline. Leo’s execute-script (Ctrl-B) command predefines three variables, c, g and p, that scripts can use to easily access any part of any Leo outline, and Leo’s own source code. For example, the following script will print all the headlines in an outline:

你的 Python 脚本可以很容易访问在 outline 中的数据。 Leo 的执行脚本（Ctrl-B）命令预定义了三个变量，c，g和p，这样脚本可以访问 Leo 的 outline 的任意部分，以及 Leo 自身的代码。举个例子，下面的脚本将会打印所有的 headline：

for p in c.all_positions():
    print ' '*p.level(),p.h

The example above is only the beginning of what scripts can do. See Scripting Leo with Python for a complete discussion of scripting Leo.

上面的例子仅仅是脚本可以做什么的开端。参考 Scripting Leo with Python 有更详细的讨论。

Plugins are Python modules that change how Leo works. Leo’s user have contributed dozens of plugins that have extended Leo’s capabilities in many new directions. The file leoPlugins.leo contains all plugins that are included in Leo distributions.

Plugin 是 Python 的模块用于改变 Leo 运行的方式。 Leo 的用户贡献了大量的插件用于扩展 Leo 在各方面的能力。文件 leoPlugin.leo 包含了 Leo 发行版中所有的插件。

Plugins and other parts of Leo can get options from @settings trees. @settings trees allow plugins to get options without any further support from Leo’s core code. For a full discussion of @settings trees, see Customizing Leo.

插件和其他部分可以从 @settings 树中获取选项。 @settings 树允许插件获取选项而无须 Leo 核心代码的支持。关于此的更多讨论，参考 Customizing Leo 。

Summary ¶

Using Leo quickly becomes second nature:

使用 Leo 迅速变为第二种特性：

You can use Leo like any ordinary outliner, as a filing cabinet, but Leo’s clones makes this filing cabinet much more flexible and useful than usual.

你可以像任何普通的 outline 软件一样使用 Leo，像一个文件柜，但是 Leo 的克隆使得这个文件柜更灵活实用。
You create external files using @file trees. Within @file trees, you use section references and the @others directive to tell Leo how to write nodes to the external file. Directives such as @tabwidth and @language provide other information to Leo. Leo’s @file trees allow you to organize your scripts and programs with Leo’s outline structure.

你可以使用 @file 创建 external 文件。有了 @file 树，你可以用 section reference 以及 @others 指令告诉 Leo 如何把节点写入 Leo。 Leo 的 @file 使得你可以用 Leo 的 outline 组织你的脚本和程序。
You can execute Python scripts from any node in a Leo outline. Leo scripts have full, easy, access to all the information in the outline. Using scripts and plugins, you can easily add new features to Leo.

在一个 Leo 的 outline 中，你可以从任何一个节点中运行 Python 脚本。 Leo 脚本可以访问 outline 中的所有信息。使用脚本和插件，你可以轻松增加新的特性。

Further study ¶

LeoPyRef.leo (in the core subdirectory of the leo folder) contains almost all of Leo’s source code. It provides hundreds of examples of everything discussed here. This file will repay close study. For full details on all aspects of Leo see LeoDocs.leo.

LeoPyRef.leo（在leo目录的core目录下）包含了几乎所有的 Leo 源代码。它提供了这里讨论过的很多的例子。这个文件值得深入学习。关于 Leo 各方面的详情参考 LeoDocs.leo。

mirguest 2012-02-03 12:50 发表评论

[学习]使用python控制ie管理C++博客的css配置

mirguest — Fri, 04 Feb 2011 09:38:00 GMT

昨天，写了基本的控制代码。
然后，通过查看css中的html代码，分析出各个block的id。
在将value读取，写到临时文件中，使用vim对此文件进行编辑。
保存后，就把这个又写回去。然后确认。

代码：

1from win32com.client import DispatchEx
2import time
3import subprocess
4import os
5ie=DispatchEx("InternetExplorer.Application")
6ie.Navigate('http://www.cppblog.com/mirguest/admin/Configure.aspx')
7ie.Visible=1
8
9while ie.Busy:
10    time.sleep(1)
11
12body=ie.Document.body
13
14for i in body.getElementsByTagName("textarea"):
15    if str(i.getAttribute("id"))=="Edit_txbSecondaryCss":
16        break
17
18tmpcss=i.value
19
20f=open("tmp.css",'w')
21print >>f,tmpcss
22f.close()
23gvim=subprocess.Popen("gvim tmp.css")
24gvim.wait()
25f=open("tmp.css")
26s=f.read()
27f.close()
28i.value=s
29os.remove("tmp.css")
30
31
32for i in body.getElementsByTagName("a"):
33    if str(i.getAttribute("id"))=="Edit_lkbPost":
34        break
35i.click()
36

mirguest 2011-02-04 17:38 发表评论

[学习]使用python操作ie

mirguest — Thu, 03 Feb 2011 10:05:00 GMT

以前写过一个使用python的urllib操作的登录脚本。
今天逛着发现，在windows下可以用win32com操作。
参考文章：
http://msdn.microsoft.com/en-us/library/aa752084(VS.85).aspx
http://www.quou.cn/archives/234
下面是代码，登录人人的：

# -*- coding: utf-8 -*-
"""
http://msdn.microsoft.com/en-us/library/aa752084(VS.85).aspx
http://www.quou.cn/archives/234
"""
import win32com.client
import time
import getpass
ie=win32com.client.DispatchEx("InternetExplorer.Application")
ie.Navigate("http://renren.com/")
ie.Visible=1
while ie.Busy:
    time.sleep(1)

document=ie.Document
body=document.body
myElements=[]
for i in body.getElementsByTagName("input"):
    if str(i.getAttribute("id")) in ['email','password','login']:
        myElements.append(i)
for j in myElements:
    if str(j.getAttribute("id"))=="email":
        j.value="lintao51@163.com"
    elif str(j.getAttribute("id"))=="password":
        j.value=getpass.getpass()
    else:
        j.click()

因为随便的，所以看起来不够简洁。

mirguest 2011-02-03 18:05 发表评论

python in nutshell Section 5.1

mirguest — Thu, 03 Feb 2011 02:55:00 GMT

本来用sphinx+rst输出html，但贴上来发现效果不行，因此直接贴上rst的。

Section 5.1 Classes and Instances
+++++++++++++++++++++++++++++++++

如果你已经熟悉面向对象编程，像在其他语言，C++或Java，这样你可能有一个很好的理解，像类和实例：一个类，就是一个用户定义的类型，你可以将它实例化得到实例对象，而它们就是这个类型的。Python支持这些概念，通过它的类和各个实例对象。

5.1.1 Python Classes
--------------------

类就是有一些特性的python对象：

* 你可以调用一个类，好像它就是一个函数。这个调用返回了另一个对象，这就是一个类的实例；而类也就是这个实例的类型。
* 一个类的属性可以任意的绑定和引用。
* 类属性的值可以是描述符（包括函数），或者是普通的数据对象。
* 类属性绑定了函数，就是我们所知的类的方法。
* 一个方法，可以有一个特殊的python定义的名字，它是以两个下划线起始，而又以两个下划线结尾。Python会隐式地调用这些特殊的方法，如果一个类提供了它们，并且当各个操作发生在那个类的实例上。
* 一个类可以从其他类中继承，这就意味着它如果在本身中没有找到一个属性，那么它就会委托给其他类，让它们在它们的类中搜索。

一个类的实例，是一个python对象，有任意命名了的属性，而你可以绑定和引用。一个实例对象隐式地将在实例本身中未搜寻到的属性委托给它的类来搜索。而这个类，如果可以，又会依次的搜索它所继承的类。

在python中，类是对象，而且可以像其他对象那样使用。因此，你可以将一个类作为参数，传递给一个函数。同样的，一个函数可以返回一个类。一个类，就像其他的对象，可以绑定一个变量（全局或局部），一个容器中的元素，或者是一个对象的属性。类也可以成为一个字典的键值。事实上，类是一个普通的对象，这也就是常说的类是一级对象。

5.1.2 The class Statement
-------------------------

``class`` 语句是最常见的方式，来创建一个类对象。 ``class`` 是一个单子句符合语句，遵循下列的语法：

class classname(base-classes):

statement(s)

``classname`` 是一个标识符。它是一个变量，可以绑定到类对象，在 ``class`` 语句完成执行后。

``base-classes`` 是一系列以逗号分隔，而值都必须是类对象的表达式。这些类在不同的编程语言中有着不同的名字；这完全看你喜欢，可以是基类，超类，或者是被创建类的父类。而被创建的类，可以说是继承，派生，扩展，或是子类。这都完全看你所熟悉的语言是怎么称呼它们的。这个类也可以说是一个直接子类，或者是它基类的后代。

语法上， ``base-classes`` 是可选的：为了表示你创建的类是没有基类的，你可以忽略 ``base-classes`` （而且还有它两边的括号也要忽略），直接将冒号放在类名字后面（在python 2.5中，你也可以使用这对空括号，其意思是一样的）。但是，一个没有基类的类，由于向后兼容的问题，所以是一个 **旧式** 的类（除非你定义了 ``__metaclass__`` 属性）。为了创建 **新式** 的类，而又没有“真正”的基类，那么这样编写代码： ``class C(object):`` ；因为每个类型都把内置对象归入子类，为了区分是新式的类还是旧式的类，我们就用 ``object`` 来加以指明。如果你的类的祖先都是旧式的类，而又没有定义 ``__metaclass__`` 属性，那么它就是旧式的；否则，有基类的类总是新式的类（就算有些基类是新式的，有些是旧式的）。

在各个类中的子类关系，是可传递的：如果 ``C1`` 是 ``C2`` 的子类，而 ``C2`` 又是 ``C3`` 的子类，那么， ``C1`` 就是 ``C3`` 的子类。内置函数 ``issubclass(C1,C2)`` 接受两个是类对象的参数：它将会返回 ``True`` 如果 ``C1`` 是 ``C2`` 的子类；否则将返回 ``False`` 。任何一个类将被认为是自己的子类；所以， ``issubclass(C,C)`` 将会返回 ``True`` 。关于基类如何影响这个类的方式可以参考“继承”。

而在 ``class`` 语句后面的不为空的语句，则被称为类体。一个类体在 ``class`` 语句被执行时也就被作为其一部分被执行了。直到类体结束执行，一个新的类对象还不存在，并且 ``classname`` 标识符也并未绑定（或重绑定）。在“如何用元类构造类中”提供了更详细的信息。

最后，注意， ``class`` 语句并不是立即创建任何新类的实例，而是定义了一系列的属性的集合，而这个集合又被你后来创建的实例所共享。

5.1.3 The Class Body
--------------------

一个类的主体，是你指定类属性的地方；这些属性可以是描述符对象（包括函数），或者是任意类型的普通数据对象（一个类的属性可以是另一个类，举个例子，你可以有一个嵌套的 ``class`` 语句在另一个 ``class`` 语句中。）

5.1.3.1 Attributes of class objects
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

你可以指定一个类的属性，通过绑定一个值给类体中的标识符。举个例子：

class C1(object):
x = 23

print C1.x
#prints:23

类对象 ``C1`` 有一个属性，叫做 ``x`` ，它绑定了一个值 ``23`` ，而 ``C1.x`` 则指向这个属性。

你可以在类体外绑定或解除属性。举个例子：

class C2(object):
pass

    C2.x = 23
    print C2.x
    #prints: 23

但是，你的程序如果把绑定属性之类的东西都放入类体中，这样可读性可能高一点。任何类属性，都是隐式的被全部的实例共享，一旦实例被创建。这个我们后面很快就会讨论。

使用了 ``class`` 语句后，将会隐式的设置一些类属性。属性 ``__name__`` 是 ``classname`` 标识符的字符串值。而属性 ``__bases__`` 则是一个tuple，里面是各个给定的基类对象。举个例子，使用刚才创建的 ``C1`` ：

print C1.__name__, C1.__base__
#prints: C1, (,)

一个类还有个属性 ``__dict__`` ，它是一个字典对象，类用它来存放所有其他的属性。对于任意类对象 ``C`` ，任意对象 ``x`` ，和任意标识符 ``s`` （除了 ``__name__`` ， ``__bases__`` 和 ``__dict__`` ）， ``c.s`` 是和 ``c.__dict__['s']=x`` 等价的。举个例子，再次引用刚才创建的 ``C1`` ：

    C1.y=45
    C1.__dict__['z'] = 67
    print C1.x, C1.y, C1.z
    #prints: 23, 45, 67

以下的设定是没有区别的：像在类体内定义属性，或是在类体外通过指定一个属性，再或者，在类体外，显式地绑定到 ``c.__dict__`` 。

直接在类体中的语句，如果引用属性时，要使用简单的名字，而不是完全的名字。举个例子：

    class C3(object):
        x = 23
        y = x + 22
        #must use just x,not C3.x

但是呢，如果是在类体中所定义的方法内，引用时就必须使用完整的名字，而不是简单的名字。举个例子：

    class C4(object):
        x = 23
        def amethod(self):
            print C4.x
            # must use C4.x, not just x

注意，使用属性引用时（也就是像 ``c.s`` ）比函数绑定有更多的语义。具体参考“Attribute Reference Basics”。

5.1.3.2 Function definitions in a class body
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

大多数类体内包含 ``def`` 语句，因为函数（在此处被称为方法）对于很多类对象来说都是很重要的属性。一个 ``def`` 语句尽管在类体中，但是仍然是和 “Function”的约定是一样的。另外，在类体中的方法一直要有个强制的第一个参数，约定称为 ``self`` ，而他表示你调用方法所对应的实例。在方法调用中， ``self`` 扮演一个很重要的角色。

这里是一个例子，一个类包含一个方法：

    class C5(object):
        def hello(self):
            print "hello"

一个类可以定义多个特殊方法（就是方法的名字前后都有两个下划线），而它们又与实例的特殊操作有关。我在“Special Methods”中有详细讨论。

5.1.3.3 Class-private variables
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

当一个类体中的语句（或者是一个方法）使用一个标识符以两个下划线开头（但不是结尾），比如就像 ``__ident`` ，python就会隐式地将标识符转成了 ``_classname__ident`` ，此次 ``classname`` 就是类的名字。这就可以使一个类使用私有的命名，以此减少无意中命名冲突的风险。

根据约定，所有以单下划线起始的标识符，意味着对于绑定它们的作用域是私有的，不管这个作用域是不是一个类。python编译器并不会强制进行转换；这完全取决于编程人员来遵守它。

5.1.3.4 Class documentation strings
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

如果在类体中的第一条语句是一个字符串常量，那么编译器会将其认为是这个类的文档。这个属性叫做 ``__doc__`` 而且也被叫做一个类的 *docstring* 。更多地参考 “Docstring”。

5.1.4 Descriptors
-----------------

一个描述符，就是一个新式的对象，而这个类提供了特殊的方法叫做 ``__get__`` 。描述符就是在语义上，控制一个实例属性的访问及设定。通俗的来讲，就是当你访问一个实例的属性时，python会通过调用描述符的 ``__get__`` 来获取属性值。具体参考“Attribute Reference Basics”。

5.1.4.1 Overriding and nonoverriding descriptors
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

如果一个描述符类还提供了特殊方法 ``__set__`` ，那么这个描述符就是所谓的 *overriding descripter* （或者，一个旧式的，比较混乱的术语， *data descriptor* ）；如果这个描述符类仅仅提供了 ``__get__`` ，而没有 ``__set__`` ，那么这个描述符就是所谓的 *nonoverriding descriptor* （或者是 *nondata* ）。举个例子，一个函数对象的类如果提供了 ``__get__`` ，但没有 ``__set__`` ；那么，这个函数对象就是个 *nonoverriding descriptor* 。通俗地讲，当你指派一个值给一个实例的属性，而它又是一个 *overriding* 的描述符，那么python会调用 ``__set__`` 来赋值。
具体的参考“Attributes of instance object”。

旧式的类也可以有描述符，但是在旧式类中的描述符运行起来就好像是 *nonoverriding* 一样（它们的 ``__set__`` 方法，就会被忽略）。

5.1.5 Instance
--------------

为创建一个类的实例，可以像调用函数一样，调用那个类对象。每次调用都会返回一个新的实例，而它的类型就是那个类：

anInstance=C5()

你可以调用内置函数 ``isinstance(I,C)`` ，用一个类对象 ``C`` 作为参数。如果 ``isinstance`` 返回 ``True`` ，那么标识实例 ``I`` 是类 ``C`` 的实例或是其子类。不然， ``isinstance`` 返回 ``False`` 。

5.1.5.1 __init__
~~~~~~~~~~~~~~~~~~

当一个类定义了或继承了一个名为 ``__init__`` 的方法，那么调用这个类对象时，就会隐式地执行 ``__init__`` 来初始化一个新的实例。而调用时传入的参数必须要和 ``__init__`` 的参数一致，除了第一个参数 ``self`` 。举个例子，考虑下面的类：

    class C6(object):
        def __init__(self,n):
            self.x=n

这里是如何创建 ``C6`` 的实例：

anotherInstance = C6(42)

就像在 ``C6`` 中展示的， ``__init__`` 方法一般含有绑定实例属性的语句。而且，一个 ``__init__`` 方法不能够返回一个值；否则，python会抛出一个 ``TypeError`` 异常。

方法 ``__init__`` 的目的，是为了绑定，从而创建新建实例的属性。你也可以绑定或解除实例的属性在 ``__init__`` 的外面，就像你等等会看到的。但是，你的代码会有更好的可读性，如果你在 ``__init__`` 方法中初始化所有属性的值。

当 ``__init__`` 是缺省的，那么你调用时不能给定参数。而且，新生成的实例没有因实例而特殊的属性。

5.1.5.2 Attributes of instance objects
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

一旦你创建了一个实例，那么你就可以访问这个属性（数据和方法）通过使用点（ ``.`` ）操作符。举个例子：

    anInstance.hello()
    #prints: Hello
    anotherInstance.x
    #prints: 42

属性引用有很丰富的语义，具体参考“Attribute Reference Basics”。

你可以给一个实例对象任意的属性，通过绑定一个值给一个属性引用。举个例子：

class C7:
pass

    z = C7()
    z.x = 23
    print z.x
    #prints: 23

实例对象 ``z`` 现在就有一个名为 ``x`` 的属性，绑定了值 ``23`` ，而 ``z.x`` 则指向那个属性。注意特殊方法 ``__setattr__`` ，如果存在时，将会侦听每个绑定属性的行为。此外，对于一个新式的实例，如果你尝试绑定属性，而这个属性又是一个 *overriding* 描述符，那么这个描述符的 ``__set__`` 将会监听。在这种情况下，语句 ``z.x=23`` 其实是执行了 ``type(z).x.__set__(z,23)`` （旧式的实例将会忽略描述符的这个特性，也就是说，它们从未调用它们的 ``__set__`` 方法）。

创建一个实例时将隐式地设置两个实例属性。对于任何实例 ``z`` ， ``z.__class__`` 是 ``z`` 所属的类对象，而 ``z.__dict__`` 则是一个字典用来存放它的其它属性。例如，对于实例 ``z`` 我们这样创建：

print z.__class__.__name__, z.__dict__
#prints: C7, {'x':23}

你可能重新绑定（但不是解除）任意或全部的属性，但是这很少是必需的。一个新式实例的 ``__class__`` 仅仅可能被重绑定到新式类上，而且一个 *legacy* 实例的 ``__class__`` 仅能绑定到 *legacy* 的类上。

对于任何实例 ``z`` ，对象 ``x`` ，和标识符 ``s`` （除了 ``__class__`` 和 ``__dict__`` ）， ``z.s=x`` 等价于 ``z.__dict__['s']=x`` （除非有个特殊方法 ``__setattr__`` ，或者是一个 *overriding* 描述符的特殊方法 ``__set__`` ，将会监听尝试绑定的行为）。举个例子，重新使用刚才创建的 ``z`` ：

    z.y = 45
    z.__dict__['z'] = 67
    print z.x, z.y, z.z
    #prints: 23, 45, 67

在实例创建属性时使用 ``__init__`` 和显示使用 ``z.__dict__`` 是一样的。

5.1.5.3 The factory-function idiom
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

一个常见的任务是根据一些条件来创建不同类的实例，或者是防止创建一个新实例，假如已经存在一个可复用的。一个常见的误解就是，在 ``__init__`` 应该返回一个对象，但是这是很难实现的：python会产生异常，当返回了任何值而不是 ``None`` 。最好的方式来执行一个灵活对象的创建，是使用普通的函数，而不是直接调用这个类对象。一个扮演这个角色的函数称为一个 *factory function* 。

调用一个 *factory function* 是一个很灵活的方法：一个函数可能会返回一个已存在可复用的实例，或者是创建一个新的实例通过调用任何适合的类。加入你有两个差不多可交换的类（ ``SpecialCase`` 和 ``NormalCase`` ），而你希望依据参数，灵活地创建合适的实例。下面的 *factory function* ``appropriateCase`` 就允许你做这样的事情：

    class SpecialCase(object):
        def amethod(self):
            print "special"

    class NormalCase(object):
        def amethod(self):
            print "normal"

    def appropriateCase(isnormal=True):
        if isnormal:
            return NormalCase()
        else:
            return SpecialCase()

    aninstance = appropriateCase(isnormal=False)
    aninstance.amethod()
    #prints "special", as desired

5.1.5.4 __new__
~~~~~~~~~~~~~~~

每一个新式类都有（或继承了）一个静态方法（ **static method** ） ``__new__`` 。当你调用 ``C(*args,**kwds)`` 来创建类 ``C`` 的新实例时，Python会首先调用 ``C.__new__(C,*args,**kwds)`` 。Python使用 ``__new__`` 的返回值 ``x`` 作为新创建的实例。然后，python会再调用 ``C.__init__(x,*args,**kwds)`` ，但是仅仅当 ``x`` 确实是 ``C`` 或它子类的实例时（不然，``x`` 的状态仍处于 ``__new__`` 留给它的）。因此，举个例子，语句 ``x=C(23)`` 等同于：

    x = C.__new__(C,23)
    if isinstance(x,C):
        type(x).__init__(x,23)

这里， ``object.__new__`` 将创建一个新的，为初始化的实例，并且接受这个类作为第一个参数。它将会忽略其他的参数，如果它有一个 ``__init__`` 方法。但是如果它接受其他参数在这个参数之前，那么将会产生一个异常。当然如果没有 ``__init__`` 方法也是会抛出异常的。当你在类体中重载了 ``__new__`` ，你不需要增加 ``__new__=staticmethod(__new__)`` ，就如你一般会喜欢的：python会识别这个名字 ``__name__`` 并且在它的上下文特殊地处理它。在那些不常有的情况下，如果你在类体外面重新绑定了 ``C.__new__`` 那么你就确实需要使用 ``C.__new__=staticmethod(whatever)`` 。

对于 ``__new__`` 有着大部分 **factory function** 的灵活性。 ``__new__`` 将会适时地选择返回一个已存在的实例或创建一个新的实例。当 ``__new__`` 确实需要创建一个新的实例，它经常会把创建的任务委托给 ``object.__new__`` 的调用或者是它其他父类的 ``__new__`` 的调用。下面的例子演示了如何重载静态方法 ``__new__`` 为了实现一个 **Singleton** 设计模式：

    class Singleton(object):
        _singletons={}
        def __new__(cls,*args,**kwds):
            if cls not in cls._singletons:
                cls._singletons[cls] = super(Singleton,cls).__new__(cls)
            return cls._singletons[cls]

任何 ``Singleton`` 的子类（当然没有重载 ``__new__`` ），就将只有一个实例。如果一个子类定义了一个 ``__init__`` 方法，这个子类必须确保它的 ``__init__`` 是安全的，当被重复调用时（在每次的创建请求下）。

旧式的类是没有 ``__new__`` 方法的。

5.1.6 Attribute Reference Basics
--------------------------------

一个属性引用就是形如 ``x.name`` 的表达式，这里 ``x`` 可以是任何表达式，而 ``name`` 是一个被称为 *attribute name* 的标识符。很多种python对象都具有属性，但是一个熟悉引用在 ``x`` 指向一个类或实例时具有特殊的丰富的语义。记住，方法也是属性，所以任何我们所谓的属性同样也适用于可调用的属性（比如说方法）。

假如 ``x`` 是一个类 ``C`` 的实例，而它又是继承自基类 ``B`` 。两个类和实例有一些属性（数据和方法），就像下面的：

    class B(object):
        a = 23
        b = 45
        def f(self):
            print "method f in class B"
        def g(self):
            print "method g in class B"

    class C(B):
        b = 67
        c = 89
        d = 123
        def g(self):
            print "method g in class C"
        def h(self):
            print "method h in class C"

    x = C()
    x.d = 77
    x.e = 88

一些属性名字是特殊的。举个例子， ``C.__name__`` 是字符串 ``'C'`` 而且是这个类名称。 ``C.__bases__`` 则是一个元组 ``(B,)`` ，这是类 ``C`` 的基类。 ``x.__class__`` 是类 ``C`` ，它是 ``x`` 所属的类。当你指向这些特殊的属性，这个属性引用将会访问给定的位置，然后把它找到的值拿出来。你不能解除这些属性。重新绑定是允许的，所以你可以改变名字或者是这个类的基类，或者是实例的类对象，匆忙地，但是这个高级的技术非同寻常的重要。

类 ``C`` 和实例 ``x`` 都各自有一个其他的特殊属性：一个叫做 ``__dict__`` 的字典。全部其他的属性，除了仅有的几个特殊属性外，全部都被放在类或实例的 ``__dict__`` 中。

5.1.6.1 Getting an attribute from a class
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

当你使用语法 ``C.name`` 来指向一个类 ``C`` 上的属性，搜索会分成两步进行：

1. 如果 ``name`` 就在 ``C.__dict__`` 中，那么 ``C.name`` 将会从 ``C.__dict__['name']`` 中取得值 ``v`` 。然后，如果 ``v`` 是一个描述符（也就是说， ``type(v)`` 提供了名为 ``__get__`` 的方法）， ``C.name`` 的值将是调用 ``type(v).__get__(v,None,C)`` 的结果。否则， ``C.name`` 的值就是 ``v`` 。
2. 否则， ``C.name`` 就委托给 ``C`` 的基类来查找，意味着它会沿着 ``C`` 的祖先一个个查找 ``name`` （关于其查找顺序，参考1.8.1）。

5.1.6.2 Getting an attribute from an instance
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

但你使用 ``x.name`` 来指向类 ``C`` 的实例 ``x`` ，搜索会分成三步进行：

1. 当在 ``C`` （或者是在 ``C`` 的祖先类中）找到了 ``name`` ，作为一个 *overriding* 描述符 ``v`` 的名字（也就是说， ``type(v)`` 提供了 ``__get__`` 和 ``__set__`` 方法）， ``C.name`` 的值将是调用 ``type(v).__get__(v,x,C)`` 的结果。（此步不适用于旧式实例）。
2. 否则，当 ``name`` 是在 ``x.__dict__`` 中的键值，那么 ``x.name`` 将会获取并返回 ``x.__dict__['name']`` 的值。
3. 否则， ``x.name`` 将搜索委托给 ``x`` 的类（和搜索 ``C.name`` 的两步是一样的，就像刚才所说的）。如果一个描述符 ``v`` 被找到了，那么属性搜寻的结果，又将是 ``type(v).__get__(v,x,C)`` ；如果是一个非描述符值 ``v`` 被找到，那么结果就是 ``v`` 。

当这些搜索步骤结束后没有找到属性，python就会产生一个 ``AttributeError`` 的异常。但是，对于 ``x.name`` 的搜索，如果 ``C`` 定义或者继承了特殊方法 ``__getattr__`` ，python将会调用 ``C.__getattr__(x,'name')`` 而不是产生一个异常（这完全取决于 ``__getattr__`` 是返回一个合适的值还是产生一个合适的异常，经常是 ``AttributeError`` ）。

考虑下面的属性引用：

print x.e, x.d, x.c, x.b, x.a
#prints: 88, 77, 89, 67, 23

这里的 ``x.e`` 和 ``x.d`` 在实例搜寻的第二步就成功了，因为没有涉及描述符，而且 ``e`` 和 ``d`` 都是在 ``x.__dict__`` 中的键值。所以，搜索不会继续，而是返回 ``88`` 和 ``77`` 。而其他三个则是到第三步，并且搜索了 ``x.__class__`` （也就是 ``C`` ）。 ``x.c`` 和 ``x.b`` 是在类搜寻的第一步就成功了，因为 ``c`` 和 ``b`` 是在 ``C.__dict__`` 中。所以它们就返回了 ``89`` 和 ``67`` 。而 ``x.a`` 则是直到类搜索的第二步，搜索 ``C.__bases__[0]`` （也就是 ``B`` ）。 ``a`` 是 ``B.__dict__`` 的键值，所以 ``x.a`` 终于成功并且返回 ``23`` 。

5.1.6.3 Setting an attribute
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

注意属性搜寻的步骤，只有在你引用它时才会发生，而不是在你绑定一个属性的时候。当你绑定（不管是类还是实例）一个属性时，而它的名字不是特殊的（除非有个 ``__setattr__`` 方法，或者是一个 *overriding* 描述符的 ``__set__`` 方法，截取一个实例属性的绑定），你仅仅影响了在 ``__dict__`` 中的属性（在类或实例中）。换句话说，在属性绑定的情况下，是没有搜索被执行的，除了检查是否是个 *overriding* 描述符。

5.1.7 Bound and Unbound Methods
-------------------------------

一个函数对象的 ``__get__`` 方法返回一个包装了函数的 *unbound method object* 或 *bound method object* 。在两者间的不同点在于，一个 **unbound method** 没有和一个特别的实例绑定，而 **bound method** 则有。

在前面段落的代码中，属性 ``f`` ， ``g`` 和 ``h`` 都是函数；所以，对于任一的属性引用将会返回一个包装了相应函数的方法对象。考虑下面的：

print x.h, x.g, x.f, C.h, C.g, C.f

这个语句将输出三个绑定方法，像这样：

然后是像这样的三个未绑定方法：

当我们引用实例 ``x`` 的属性时将返回绑定方法，而引用类 ``C`` 的属性时则返回未绑定的方法。

因为一个绑定的方法已经和一个特殊的实例绑定了，你可以这样调用方法：

x.h()
#prints: method in class C

这里要注意的就是，你不需要传给方法第一个参数， ``self`` 。对于实例 ``x`` 的绑定方法会隐式地把对象 ``x`` 绑定给参数 ``self`` 。因此，方法的主体能够访问实例的属性，作为 ``self`` 的属性，尽管我们没有显示的传递给方法这个参数。

一个未绑定的方法，是没有和一个特殊实例关联的，所以你必须指定一个合适的对象给第一个参数，当你调用一个未绑定方法，举个例子：

C.h(x)
#prints: method h in class C

你调用一个未绑定的方法比绑定方法次数要少的多。未绑定方法的主要用途是来访问 *overridden* 方法；更好的是使用 ``super`` 。

5.1.7.1 Unbound method details
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

就像刚才我们讨论的，当一个属性引用是从类指向函数时，返回一个引用指向那个包裹了函数的未绑定方法。一个未绑定方法除了包装的函数外还有三个额外的属性： ``im_class`` 是提供方法的类对象， ``im_func`` 是被包装的函数，而 ``im_self`` 通常返回 ``None`` 。这些属性是只读的，这意味着尝试重绑定或解除绑定都会抛出异常。

你可以调用一个未绑定的方法就如同你调用了它的 ``im_func`` 函数，但是第一个参数必须是是 ``im_class`` 的实例或是后裔。换句话说，对于未绑定方法的调用，必须至少有一个参数，这个参数应该和被包装的函数的第一个参数一致（一般称为 ``self`` ）。

5.1.7.2 Bound method details
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

当一个属性引用自一个实例，在搜索中，找到一个函数对象，而那是一个实例的类中的属性，查找会调用函数的 ``__get__`` 方法来获取属性值。这个调用，在这种情况下，创建并返回了一个绑定的方法，并包裹着那个函数。

注意当一个属性引用的查找在 ``x.__dict__`` 中找到了函数对象，那么属性引用操作不会创建一个绑定方法，因为在这种情况下函数并不是当作一个描述符，而且，函数的 ``__get__`` 是不可调用的；更准确地说，函数对象本身就是属性值。类似的，没有一个绑定的方法是为不普通的函数调用而创建的，就如内置的（与python代码对照）函数，因为它们不是描述符。

一个绑定方法，和一个未绑定方法是类似的，它们都有三个只读的属性，那是包装函数对象多出来的。像在未绑定方法中， ``im_class`` 是一个提供方法的类对象，而 ``im_func`` 是被包装的函数。但是，在一个绑定方法的对象中，属性 ``im_self`` 指向获得方法的实例 ``x`` 。

一个绑定方法使用起来像它的 ``im_func`` 函数，但是调用绑定方法不需要显式提供第一个参数（一般约定为 ``self`` ）。当你调用一个绑定方法，在传递其他参数时，绑定方法把 ``im_self`` 传递给 ``im_func`` 的第一个参数。

让我们看看下面这个底层的概念上的是如何调用 ``x.name(arg)`` 。在下面的例子中：

    def f(a,b):
        ...
        # a function f with two arguments

class C(object):
name = f

x = C()

这里 ``x`` 是一个类 ``C`` 的实例对象， ``name`` 是一个标识符，指明了 ``x`` 的方法（ ``C`` 的属性，它是一个函数，在这里是函数 ``f`` ），而 ``arg`` 是任何的表达式。python先检查 ``name`` 是否是 ``C`` 中的属性，并且它还是一个描述符。但是事实上它并不是，因为它们的类虽然定义了 ``__get__`` 方法，但是并不是 *overriding* 的描述符，因为它们没有 ``__set__`` 方法。python接下来检查 ``name`` 是否在 ``x.__dict__`` 中。但它们也不是。所以python在类 ``C`` 中查找 ``name`` （任何东西都会起作用以同样的方式如果 ``name`` 被找到了，通过继承，在 ``C`` 的 ``__bases__`` 中）。python注意到这个属性值，也就是函数对象 ``f`` ，是一个描述符。所以，python调用 ``f.__get__(x,C)`` ，这就创建了一个绑定方法， ``im_func`` 设定为 ``f`` ， ``im_class`` 被设定为 ``C`` ，而 ``im_self`` 被设为 ``x`` 。然后python调用这个绑定方法对象，以 ``arg`` 作为唯一的参数。这个绑定方法插入了 ``im_self`` （也就是 ``x`` ）作为第一个参数，而 ``arg`` 成为第二个，然后调用 ``im_func`` （也就是 ``f`` ）。总的效果就像是这样调用：

x.__class__.__dict__['name'](x,arg)

当一个绑定方法的函数体执行了，它没有特别的命名空间，不管是 ``self`` 或其他类。变量引用的是局部或全局的，就像其他的函数一样。变量并不会隐式的指明 ``self`` 的属性，或是任何其他类中的属性。当一个方法需要指向，绑定，或解除绑定一个 ``self`` 对象的属性，它也需要标准的属性引用的语法（比如， ``self.name`` ）。隐式的作用域可能会导致使用其他用过的，而python则不是这样（因为python和其他面向对象不同），但是这使得python简洁明了，而避免了混淆。

绑定方法对象是一级对象，你可以在任何你可以使用可调用对象的地方使用它们。因为绑定方法持有一个包装函数的引用，并且指向它所执行的 ``self`` 对象，它是更有用更灵活的选择对应嵌套的来说。一个实例对象的类提供了特殊的方法 ``__call__`` 提供了另一个可行的选择。这些概念中的每一个使你绑定一些行为（代码）和状态（数据）到一个单独的可调用对象中。嵌套可能是最简单的，但有很多的限制。这里是嵌套：

    def make_adder_as_closure(augend):
        def add(addend, _augend=augend):
            return addend+_augend
        return add

绑定方法和可调用的实例更加的丰富和灵活。这里是用绑定方法实现同样的功能：

    def make_adder_as_bound_method(augend):
        class Adder(object):
            def __init__(self,augend):
                self.augend = augend
            def add(self, addend):
                return addend+self.augend
        return Adder(augend).add

这里是以一个可调用实例来执行（这个实例的类提供了特殊方法 ``__call__`` ）：

    def make_adder_as_callable_instance(augend):
        class Adder(object):
            def __init__(self,augend):
                self.augend=augend
            def __call__(self,addend):
                return addend+self.augend
        return Adder(augend)

从这些代码调用函数来看，它们是可交换的，因为它们都返回多态的可调用对象（也就是都是可用的）。在这里，嵌套是最简单的；而其他两种则是更灵活，普遍而且更强大的机制，但是在这个简单的例子中没必要使用这么强大的功能。

5.1.8 Inheritance
-----------------

当你使用一个属性引用 ``C.name`` ，但是 ``name`` 不在 ``C.__dict__`` 中，搜寻会隐式的在 ``C.__bases__`` 以特殊的顺序执行（历史原因，称为 *method resolution order* ，或者是 **MRO** ，甚至是对于任何属性，而不仅仅是对方法）。 ``C`` 的基类会又会依次的搜寻它们的基类。搜寻机制检查直接或间接的祖先，一个又一个，以 **MRO** 进行，当 ``name`` 被找到时将会停止。

5.1.8.1 Method resolution order
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

在一个类中，属性名字的搜寻本质上通过以 **left-to-right** ， **depth-first** 的顺序访问祖先发生。但是，在多继承的存在下（这样就使继承的图表是一个非循环的图表，而不是一个树形的），这个简单的方法可能导致一些祖先类被访问了两次。在这样的情况下，这种分解的顺序被阐明，通过在搜寻的列表留下右边的那个类，这将会持续到搜索完，然后再去刚才剩下的那些类中重新开始搜索。这个就使得多类继承很难正确有效的使用。而新式对象则在此方面更加高级。

这在 **left-right** ， **depth-first** 搜索中个问题，可以很简单的在旧式类中被论证：

    class Base1:
        def amethod(self):
            print "Base1"

class Base2(Base1):
pass

    class Base3:
        def amethod(self):
            print "Bases3"

class Derived(Base2,Base3):
pass

    aninstance=Derived()
    aninstance.amethod()
    #prints: "Base1"

在这个情况下， ``amethod`` 的搜寻将从 ``Derived`` 开始。当没有在此处找到，将会去搜索 ``Base2`` 。因为在此处也没有找到，旧式的搜寻将会继续搜索它的父类， ``Base1`` ，而在这里找到了那个属性。所以，就是类将会停止，而不在考虑 ``Base3`` ，而在这里也可以找到那个属性。而新式的 **MRO** 则解决了那个问题，通过移除最左边的 ``Base1`` ，所以将会搜索 ``Base3`` 中的 ``amethod`` 。

Figure 5-1 展示了旧式和新式的 **MRO** ，在这个菱形的继承图中。

.. figure:: pythonian_0501.jpg
:align: center

**Figure 5-1. Legacy and new-style MRO**

每一个新式的类和内置类型都有一个特殊制度的类属性，叫做 ``__mro__`` ，这是一个用于方法分解的元组，以一定顺序存放类型。你只可以在类中引用 ``__mro__`` ，而不以在实例上，而且因为 ``__mro__`` 是只读的属性，你不可以重新绑定或解除绑定。具体的，你可以参考 Michele Simionato 写的 “The Python 2.3 Method Resolution Order” ，在 http://www.python.org/2.3/mro.html 。

5.1.8.2 Overriding attributes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

就像我们刚看到的，一个属性的搜寻会依照 **MRO** （典型的是根据继承树）然后在找到时就会停止。而派生类会比他们的父类先被搜寻，这样子，当子类和父类都定义了相同名字的属性时，搜索就会在子类中寻到定义并在那里停止。这就是所谓的 **覆写** 了父类中的定义。考虑下面的例子：

    class B(object):
        a=23
        b=45
        def f(self):
            print "method f in class B"
        def g(self):
            print "method g in class B"

    class C(B):
        b=67
        c=89
        d=123
        def g(self):
            print "method g in class C"
        def h(self):
            print "method h in class C"

在这段代码中，类 ``C`` 覆写了超类 ``B`` 的属性 ``b`` 和 ``g`` 。注意，不像其他的语言，python中你可以覆写数据属性，也可以是可调用的属性（方法）。

5.1.8.3 Delegating to superclass methods
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

当一个子类 ``C`` 覆写了它的超类 ``B`` 中的一个方法 ``f`` 时， ``C.f`` 的主体经常需要把某些操作委托给超类中的方法来执行。这个可以使用未绑定方法，像下面：

    class Base(object):
        def greet(self,name):
            print "Welcome ",name

    class Sub(Base):
        def greet(self,name):
            print "Well Met and",
            Base.greet(self,name)

x=Sub()
x.greet('Alex')

在 ``Sub.greet`` 的主体中，超类的委托，通过属性引用 ``Base.greet`` 使用了未绑定方法，所以正常的传递了所有的属性，包括 ``self`` 。未绑定方法最常用的就是在委托超类执行中。

一个很常见的委托就是在特殊方法 ``__init__`` 中。当python创建一个实例时，基类的 ``__init__`` 方法不会自动调用，就像在其他一些面向对象的语言中一样。因此，必要时，就依靠于使用委托来完成合适的初始化。举个例子：

    class Base(object):
        def __init__(self):
            self.anattribute = 23

    class Derived(Base):
        def __init__(self):
            Base.__init__(self)
            self.anotherattribute=45

如果在类 ``Derived`` 的 ``__init__`` 中未显式调用类 ``Base`` ， ``Derived`` 的实例将会丢失初始化的部分信息，所以他将缺少属性 ``anotherattribute`` 。

5.1.8.4 Cooperative superclass method calling
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

使用未绑定方法调用超类的方法，可能在多重继承上出问题，特别是菱形状的。考虑下面的定义：

    class A(object):
        def met(self):
            print 'A.met'

    class B(A):
        def met(self):
            print 'B.met'
            A.met(self)

    class C(A):
        def met(self):
            print 'C.met'
            A.met(self)

    class D(B,C):
        def met(self):
            print 'D.met'
            B.met(self)
            C.met(self)

在这个代码中，当我们调用 ``D().met()`` ， ``A.met`` 将会出现两次。那我们如何确保祖先只被调用一次，而且仅仅一次？解决的办法就是，使用内置的 ``super`` 。 ``super(aclass,obj)`` ，将会返回对象 ``obj`` 的特殊超级对象。当我们搜寻一个属性（比如一个方法）在这个超级对象中，搜寻将会开始于在 ``obj`` 的 **MRO** 的类 ``aclass`` 中。所以我们可以这样改写先前的代码：

    class A(object):
        def met(self):
            print 'A.met'

    class B(A):
        def met(self):
            print 'B.met'
            super(B,self).met()

    class C(A):
        def met(self):
            print 'C.met'
            super(C,self).met()

    class D(B,C):
        def met(self):
            print 'D.met'
            super(D,self).met()

现在， ``D().met()`` 对每个类的 ``met`` 都只调用了一次。如果你形成了在使用超类时使用 ``super`` 的习惯，那么尽管可能有很复杂的结构，你的类也能很好的使用。无论这个继承结果有多简单，使用这个并没有坏处，而且，我也推荐使用新式的对象模型。

你使用未绑定方法的技术的唯一的情况，可能就是，类之间的方法有不相容的签名，但如果你真的要处理这种东西，那么使用未绑定方法的技术可能会至少有点讨厌。多重继承的合适使用可能会有限制。但是，就算OOP的大多数基本的特征，像在基类与子类间的多态将会因为签名的不一致导致有所削减。

5.1.8.5 "Deleting" class attributes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

继承和覆写提供了简单有效的方式来增加或修改类属性（特别是方法）但不带侵略性的（也就是说，不会修改那个定义了属性的类）通过在子类中增加或覆写属性。但是，继承并不提供来删除或隐藏基类的属性的方式但不带侵略性的。如果子类定义或覆写一个属性失败了，python就会寻找基类的定义。如果你需要执行这样的删除，那么可能包含：

* 覆写方法并在方法内产生异常。
* 避开继承，拥有这个属性在其他地方而不是在子类的 ``__dict__`` ，而且定义 ``__getattr__`` 来有选择的委托。
* 使用新式对象模型，而且覆写 ``__getattribute__`` 实现相同的效果。

5.1.9 The Built-in object Type
------------------------------

内置的 ``object`` 类型是全部内置类型和新式类的祖先。这个 ``object`` 类型定义了一些特殊的方法，它们执行对象的默认语义。

``__new__`` ``__init__``
你可以创建一个 ``object`` 的直接实例，通过不带参数的调用 ``object()`` 。调用将会隐式地使用 ``object.__new__`` 和 ``object.__init__`` 来创建和返回一个没有属性的实例对象（甚至没有存放属性的 ``__dict__`` ）。这个实例对象就像一个“哨兵”一样有用，保证不和其他不同的对象不相同。

``__delattr__`` ``__getattribute__`` ``__setattr__``
默认的，一个对象操作属性引用通过使用 ``object`` 的这些方法。

``__hash__`` ``__repr__`` ``__str__``
任意对象可以传递给函数 ``hash`` 和 ``repr`` 和传给类型 ``str`` 。

一个 ``object`` 的子类会覆写这些方法或增加其他。

5.1.10 Class-Level Methods
--------------------------

Python提供了两种内置的 **nonoverriding** 描述符类型，这就给了一个类两种不同的“类级方法（classlevel method）”。

5.1.10.1 Static methods
~~~~~~~~~~~~~~~~~~~~~~~

一个 **static method** 是一个方法，你可以在类上或者在类的任意实例调用，但没有特殊的行为和普通方法的约束，绑定和未绑定，而且关注第一个参数。一个静态方法可以有任意的签名；它可以没有参数，而第一个参数没有什么作用。你可以认为静态方法就是一个普通的函数，你可以正常的调用，尽管它事实上是一个绑定到类的方法。当它并不是必须要定义静态方法时（你总可以定义一个正常的函数取代之），一些程序员认为它们是一个精致的选择当一个函数的目的是更紧的绑定到一些特殊类上。

要创建一个静态方法，调用内置类型 ``staticmethod`` 然后把它的结果绑定到一个类属性。像所有的属性绑定，通常是在类体中被完成的，当然你也可以放在其他位置。唯一要给 ``staticmethod`` 的参数就是当python调用这个静态方法时要调用的函数。下面的例子展示了如何定义和调用一个静态方法：

    class AClass(object):
        def astatic():
            print 'a static method'
        astatic=staticmethod(astatic)

    anInstance=AClass()
    AClass.astatic()
    #prints: a static method
    anInstance.astatic()
    #prints: a static method

这个例子对于要传递给静态方法的函数和静态方法返回的结果使用相同的名字。这个方式并不是强制的，但是个好的主意，而且我也推荐使用。在Python 2.4中提供了特殊，简单的语法，可以参考 **装饰符** 。

5.1.10.2 Class methods
~~~~~~~~~~~~~~~~~~~~~~

一个类方法是一个方法，你可以在类或其任意实例中调用。Python把你所调用方法的类绑定给了这个方法的第一个参数，或者也可以所调用方法的实例的类；它并不会像绑定方法一样，把实例绑定给第一个参数。对于类方法来说，是没有等同的未绑定方法的。第一个参数一般约定为 ``cls`` 。虽然定义一个类方法不是必须的（你可以定义一个函数，然后接受类对象作为第一个参数），一些程序员认为对于这些函数来说是不错的选择。

要创建一个类方法，调用内置类型 ``classmethod`` 然后再把结果绑定到类属性上。也许所有的属性绑定，经常将其写在类体中，但你也可以在其他地方实现。而唯一的参数就是这个要作为类方法调用的函数。下面是定义和调用：

    class ABase(object):
        def aclassmet(cls):
            print 'a class method for',cls.__name__
        aclassmet=classmethod(aclassmet)

class ADeriv(ABase):
pass

    bInstance=ABase()
    dInstance=ADeriv()
    ABase.aclassmet()
    #prints: a class method for ABase
    bInstance.aclassmet()
    #prints: a class method for ABase
    ADeriv.aclassmet()
    #prints: a class method for ADeriv
    dInstance.aclassmet()
    #prints: a class method for ADeriv

同样，和上一小节所说，可以使用 **装饰符** 。

5.1.11 Properties
-----------------

python提供一个内置的 **overriding** 描述符，你可以用来给出一个类的实例 **property** 。

一个 **property** 是一个实例的属性，有着特殊的功能。你引用，绑定，解绑定一个属性可以用一个普通的语法（也就是 ``print x.prop`` ，``x.prop=23`` ， ``del x.prop`` ）。但是，不仅仅是这些普通的语义，你还可以给其指定特殊的方法。下面是定义一个只读的属性：

    class Rectangle(object):
        def __init__(self,width,height):
            self.width=width
            self.height=height
        def getArea(self):
            return self.width*self.height
        area=property(getArea,doc='area of the rectangle')

每一个类 ``Rectangle`` 的实例 ``r`` 都有个只读的属性 ``r.area`` ，通过调用方法 ``r.getArea()`` 把矩形的两边相乘。而docstring ``Rectangle.area.__doc__`` 则是 ```area of the rectangle``` 。属性 ``r.area`` 是只读的（尝试重绑定或解绑定都会失败）因为我们只给 ``property`` 一个 ``get`` 方法，而没有 ``set`` 或 ``del`` 方法。

属性和特殊方法 ``__getattr__`` ， ``__setattr__`` ， ``__delattr__`` 的工作差不多，但是方法更快更简单。你可以创建一个属性通过调用内置的 ``property`` 并把结果绑定给类属性。想其他的属性，一般是放在类体中，当然你也可以放其他地方。在类 ``C`` 内，使用这样的语法：

    attrib=property(fget=None,
    fset=None, fdel=None,
    doc=None)

当 ``x`` 是 ``C`` 的实例，你又引用 ``x.attrib`` ，python会调用 ``fget`` 给属性构造器，但没有参数。当以 ``x.attrib=value`` 赋值是，python会调用 ``fset`` ，并把 ``value`` 作为唯一传人的参数。而当执行 ``del x.attrib`` ，python又会执行 ``fdel`` ，不传人任何参数。python又会将 ``doc`` 的内容作为 ``doctstring`` 。 ``property`` 的全部参数都是 *可选的* 。当一个参数没有，那么这个操作就被认为是禁止的（此时，python会产生一个异常）。举个例子，刚才我们使 ``Rectangle`` 的属性 ``area`` 只读，那是因为我们只提供了 ``fget`` ，而没有 ``fset`` 或 ``fdel`` 。

5.1.11.1 Why properties are important
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

属性的重要性在于，它们的存在使得非常安全，而且你可以使这个属性作为公共接口。如果这变得必要的，在你以后的版本中可能需要这个属性多态运行，或是在被引用、重绑定或解绑定时调用其他的一些代码，你知道你将会将简单的属性变成 **property** ，而且得到想要的效果但不对其他代码产生影响。这就使你避免笨的特色，像一个 *accessor* 或 *mutator* 方法，这是在缺少 **property** 或等同机制的OOp中经常需要的。举个例子，客户代码可以使用下面自然的语法：

someInstance.widgetCounter += 1

而不是像下面这种嵌套的形式：

someInstance.setWidgetCounter(someInstance.getWidgetCounter()+1)

如果编写代码时，你考虑使用 ``getThis`` 或 ``setThis`` 的名字，那么就考虑使用 **property** 来变得清楚。

5.1.11.2 Properties and inheritance
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

**property** 也可以像其他属性那样继承。但是，这里可能有点小陷阱： **property** 所调用的是它所在类中的方法，而不是其子类的方法。举个例子：

    class B(object):
        def f(self):
            return 23
        g=property(f)

    class C(B):
        def f(self):
            return 42

    c=C()
    print c.g
    #prints 23, not 42

属性 ``c.g`` 调用了 ``B.f`` ，而不是你直觉上所想的 ``C.f`` 。这个原因很简单：因为 **property** 是通过传递函数对象 ``f`` 创建的（而且是在 ``B`` 被执行时所创建，所以这个时候，这个函数对象就被认为是 ``B.f`` ）。事实上， ``f`` 在子类 ``C`` 中被重新定义了，但是因为 **property** 并没有搜寻到它，而只是使用了先前的那个。如果你需要解决这个问题，那么就需要引入一个间接层：

    class B(object):
        def f(self):
            return 23
        def _f_getter(self):
            return self.f()
        g=property(_f_getter)

    class C(B):
        def f(self):
            return 42

    c=C()
    print c.g
    #prints 42, as expected

这里，被 **property** 所持有的函数对象是 ``B._f_getter`` ，它在执行时会搜寻到 ``f`` （因为它调用了 ``self.f()`` ）；所以，覆写的 ``f`` 会起效果。

5.1.12 __slots__
----------------

一般来说，任何类 ``C`` 的每个实例对象 ``x`` 都有一个字典 ``x.__dict__`` ，这是python用来让你任意绑定属性给 ``x`` 的。为了节省点内存（让 ``x`` 仅使用预定义的属性），你可以定义一个新式类 ``C`` 的 ``__slots__`` 属性，这是一个字符串（通常是表示符）序列（通常是元组）。当一个新式类 ``C`` 有个属性 ``__slots__`` 时，一个类 ``C`` 的直接实例 ``x`` 是没有 ``x.__dict__`` 的，而且尝试绑定不在 ``C.__slots__`` 中的属性将会产生异常。使用了 ``__slots__`` 就使你减少了内存的消耗，对于小的实例对象，这是很值得的，当有很多这样的对象时，就节省了大大的空间。但不像大多数的属性， ``__slots__`` 只有当一些类体中的语句把它绑定为类属性时才有效。后来修改 ``__slots__`` 是不起效果的，继承也是。这里是把 ``__slots__`` 增加到 ``Rectangle`` 中：

class OptimizedRectangle(Rectangle):
__slots__='width','height'

我们不需要给 ``area`` 定义个 *slot* 。 ``__slots__`` 中并不放 **property** ，仅仅是普通的实例对象，这些属性如果没有在 ``__slots__`` 中定义，将会搜寻 ``__dict__`` 。

5.1.13 __getattribute__
-----------------------

对于新式的实例，实例属性的引用都是通过特殊方法 ``__getattribute__`` 执行的。这个方法是基类 ``object`` 所提供的，它执行了所有具体的属性引用。但是，你也可以覆写这个 ``__getattribute__`` 方法，像隐藏被继承类的属性。下面的例子展示了在新式对象模型中一个没有 ``append`` 的链表：

    class listNoAppend(list):
        def __getattribute__(self,name):
            if name=='append':
                raise AttributeError,name
            return list.__getattribute__(self,name)

类 ``listNoAppend`` 的实例 ``x`` 几乎和内置的链表对象是一样的，除了当调用 ``x.append`` 时将产生异常。

5.1.14 Per-Instance Methods
---------------------------

不管旧式或是新式的对象模型，都允许一个实例，拥有一个实例特化的属性绑定，包括可调用的属性。对于一个方法，就像其他的属性（除了那些新式类中的 **overriding** 描述符），一个实例特化绑定隐藏了一个类级的绑定：属性搜索如果在实例中找到了就不会考虑类了。在两种对象模型中，对于可调用属性的一个实例特化的绑定不会进行什么变换。换句话说，一个属性引用返回相同的可调用对象，而且已经在先前已经绑定。

旧式和新式的对象模型的确有区别，在每个实例绑定的效果上，python会隐式地调用。在经典的的对象模型中，一个实例一般会覆写一个特殊方法，然后python在隐式调用方法时使用每个实例的绑定。在新式的对象模型上，特殊方法的隐式使用一般依赖于特殊方法的类级绑定，如果有的话。下面的代码展示了两者的区别：

def fakeGetItem(idx):
return idx

class Classic:
pass

    c=Classic()
    c.__getitem__=fakeGetItem
    print c[23]
    # prints: 23

class NewStyle(object):
pass

    n=NewStyle()
    n.__getitem__=fakeGetItem
    print n[23]
    #prints in:
    # Traceback (most recent call last):
    #   File "", line 1, in ?
    # TypeError: unindexable object

经典对象模型的语义在这个方面可能比较有用。但是，新式对象模型的方法更普遍，而且它调整和简化了类和元类的关系。

5.1.15 Inheritance from Built-in Types
--------------------------------------

一个新式类可以从内置类型派生。但是，一个类可能直接或间接从多个内置的类型派生，如果这些类型是特殊设计的，来允许这个层次的兼容。python不支持不受拘束的继承从多个任意的内置对象中。一般的，一个新式类只能以其中一种派生，当然也包括 ``object`` ，这是所有的类型的超类。举个例子：

class noway(dict,list):
pass

将会产生一个 ``TypeError`` 异常，具体会解释为“当调用元类的基类有错误：多基类有实例的冲突”。如果你曾经看过这样的错误，这就意味着你尝试继承，直接或间接，从多个内置类型派生，但他们并不是设定为可合作的。

mirguest 2011-02-03 10:55 发表评论