俺这里想给大家初步介绍一下Python编程. 各位能看英文的,

最好是去看www.python.org上的其原作者Guido van Rossum

的入门介绍. (Python看成自1.6版以后就能处理Unicode的了,

故而也能很方便也处理中文了.) 俺这里只略提一二:

1)解释性语言一般都是完成任务快, 但所编的程序运行起来

有时会比编译语言编的程序(C/C++, Fortran, Pascal等)

要慢一个数量及以上. 虽然, 日常生活中仍然有许多事

俺们是不在乎它是0.0001秒内完成还是在0.1秒内完成,及

有时更在乎在短时间内完成一个很大的任务, 故而解释性

语言仍有很大市场. 更别提一般的解释性语言都可以用C/C++

等编成模块来处理关键性的任务.

2)常用的解释性语言有Perl, Python, Lisp/Scheme, Ruby等.

其中Perl算是运用最广泛的了; 但Perl的程序不易管理大概

也是举世公认的(它的宗义即为: "总有其它方法来完成这个

任务", 从而经常每个人有每个人的风格). Python相对Perl

的这点真是简单了不少. 它比Perl年轻不少, 但用户增长速

度很快. 目前好象是说Mandrake, Debian的系统管理在用

Perl, 但大哥大红帽则在用Python.

3)Python的交互式用法(可用作计算器, 或测试一个不熟悉的

函数等). 示例如下( >>>是Python的提示符 ):

$python

Python 2.1a1 (#4, Jan 29 2001, 20:22:47)

[GCC 2.95.2 19991024 (release)] on sunos5

Type "copyright", "credits" or "license" for more information.

>>> 3+4**2

19

>>> x=5

>>> y=6

>>> x/y

0

>>> x*1.0/y

0.83333333333333337

>>>

4)略解:

a)变量不用先定义类型, 直接由系统识别(大多解释性语言

都这样)

b)用行头空格数来标识块的起始, 省去了Perl/C/C++的{;}

没有{}匹配问题应该是省了不少头痛的. — 这一点刚

开始会不太习惯, 熟了后真是很感谢G.V. Rossum的发明

c)没有了Perl中的$%@&等符号. (为方便, 下面俺将变量的

结果放在 ==> 的右边)

c.1) 字串(单引号等于双引号):

a = 'Well well study' + ', Day day up!'

则:

a[3] ==> 'l'

a[-1] ==> '!'

a[0:-1] ==> 'Well well study, Day day up!'

c.2) 数列(List), 相当于数组, 可以含不同类型

x = ['abc', 4, 'python']

则:

x[0] ==> 'abc'

x[1] ==> 4

c.3) 字典(Dictionary), 可以用字串作指标

mathScore = { 'xah': 59, 'tinybit': 99 }

则:

mathScore['tinybit'] ==> 99

d)函数, 可以用缺省参数:

def score (user='tinybit', whichExam='yesterday'):

if whichExam != 'yesterday': return 0

if user=='tinybit': return 99

else: return 59

于是:

score() ==> 99

score('xah') ==> 59

还可以用关键词来调用:

score(whichExam='tomorrow') ==> 0

e)模块, 俺就不多说了

f)类(Class), 面向对象的编程, 同上.

g)图形界面编程(GUI), 其缺省为基于TCL/TK上的Tkinter,

不过它的功能不是很多; 基于跨平台wxWindows库的

wxPython功能要强不少(尚未中文化, 有待各位努力).

还有基于Qt和Gtk库的, 不过Gtk好象目前还不能在Windows

上很好的运行, Qt虽能, 也很成熟, 但若在Windows上运行

它原则上要向TrollTech上贡$1,500的, 不象wxWindows完全

免费.

好了, 俺就先多嘴至此. 各位同仁感兴趣的, 该去 python.org

当下它的入门简介, 俺有80-90%的把握that你会喜欢它的.

循环, 条件 及 函数编程工具

俺在上篇中大略介绍了Python的变量与函数, 这里稍作补充来解释一下Python

的循环, 条件及函数编程工具. (还是按上篇的方法: 将变量或函数

的结果放在 ==> 的右边)

1) 循环

首先得更正上篇中一个小错误: Python的范围含首不含尾, 所以

若:

a = 'Well well study' + ', Day day up!'

则:

a[0:-1] ==> 'Well well study, Day day up' #不包括最后的'!'

Python还有一个专门的范围函数: range. 例如:

range(4) ==> [0, 1, 2, 3]

range(2, 5) ==> [2, 3, 4]

它在for循环中常用.如:

total = 0

for i in range(11): total += i

最后 total ==> 55

循环也可以用 while, 如:

total, i = 0, 0

while i<11: total += i; i += 1

2) 条件编程是:

if 条件语句 : 命令1

elif 条件语句: 命令2

else: 命令3

条件语句中相当于C的&&是and, 相当于||是or; 其中不允许赋值,

以避免C/C++中的不小心将 == 写成 = 后这一很常见的头痛. 例:

total, i = 0, 0

while 1:

total += i; i += 1

if i>11 or total > 55: break

3) 函数编程工具 (map/filter/reduce)

这几个工具, 可以帮你在处理数列时只调用一次函数, 从而在简

单处理大批数据时, 有可能大幅提高程度的执行速度.

map(函数f, 数列l) ==> [ f(l[0]), f(l[0]), … ]

filter (f, l) ==> 只在l中剩下对f是真的值

reduce (f, l) ==> 用l中头两个数作参数调用f, 产生的结果再

==> 与l中的第三个数作参数去调用f, 如此到底

如:

def add(x,y): return x+y

reduce ( add, range(1,11) ) ==> 55

def PingFang(x): return x*x

map ( PingFang, range(1,5) ) ==> [1, 4, 9, 16]

def JiShu (x): return x%2 == 1

filter ( JiShu, range(8) ) ==> [1, 3, 5, 7]

4) 若想让你编的脚本能直接执行, 只要象其他Shell脚本一样, 在脚本第一

行头加上Python的路径即可.

#!/PythonPath/python #或用: #!/usr/bin/env python

可以用sys.argv, len(sys.argv) 得到C/C++中的argv, argc. (若引入:

from sys import argv

之后, 上面的sys.argv 就可直接写成 argv — 下次俺提到模块时再

细说. )

—————————————————————————–

–

模块与类

头两篇都没提到Python的模块与类, 这里来补充一下:

1)模块(Module)

你可以将几个函数编好放在一个文件中, 比方说你的

score.py文件中有: mathScore(), physScore(),

chemScore() 等几个函数; 将之放在当前目录或是PYTHON

的系统调用目录中; 于是你在当前目录中的另一个文件中,

就可以有两种方法调用:

a)

import score

score.mathScore('xah')

…

b)

from score import *

#或可用 from score import mathScore

mathScore('xah')

…

第二种方法引入模块后,调用时就不要前缀score了; 当然

第二种调用方法容易重名. 总之, Python的模块编写是很

简单的. (稍麻烦一点的是你想用C/C++来编一个Python模

块.) 俺自己就把常用的物理常数编在physConst.py中,将

之放到Python安装目录下.

在简介(二)中俺提到过from sys import argv之事, 因为

Python作为缺省已经以"import sys"的形式引入了sys 模

块, 所以你可以直接把 sys.argv 当作C/C++中

main(int argc, char *argv[])

里的 argv 来用; 也可用"from sys import argv"再引入

一次, 于是后面皆可直接呼之为 argv

模块文件的第一个有效行(非注释行)可以是一行字串, 或

是夹在""" 与 """之间的若干行文字.(同样, 单引号等于

双引号: ''' == """ .) 函数的定义也一样. 于是日后

别人或自己在调用该函数/模块时, 即可用:

print 该函数/模块.__doc__

来看这个函数/模块的说明.

2)类(Class)

class MyClass(父类): #从父类遗传一个子类: MyClass

def method1(self, …):

…

def mether2(self, …):

self.method1()

…

类的实体化(instantiation)和调用为:

c = MyClass(…)

c.method1(…)

c.method2(…)

这里有方法(method)和函数(function)的区别在.

method(args) == function(对象, args)

所以在类的函数定义中, 第一个参数皆为对象. 通常情况下, 都将其

写为self. self本身并无实义, 这只是Python的习惯, 可能老的类浏

览软件会依靠self. 实体化后的调用, 如上面 c.method1(…) 就是

方法调用, 故不需要写出第一个对象参数.

self还有一个用法. 因Python没有用Private/Public/Protected, 它

的函数中定义的变量都是局部变量. 当在一个函数之内调用类的变量

或函数时要加上self. 如:

class My:

x = 3

def PingFang(self): return self.x ** 2

def LiFang(self): return self.PingFang() * self.x

于是当实体化: m = My() 后,

m.PingFang() ==> 9

m.LiFang() ==> 27

当在一个函数中调用另外一个函数的变量时, 两个函数中的变量都加

上"self."

通常还可定义一个相当于C++中类的初始构造器(constructor)的一个

函数:

def __init__(self, …):

…

类中的变量通常是不能隐形的, 在类的定义之外还可任意改变, 甚至

添加新变量, 与删除新变量. 但__AA_形式的变量是特别的 ( 前头最

少两个下划线, 尾部最多一个下划线.), 它相当于C++中的Protected

变量.

Python的类有点绕脑筋, 不过各位若去看看它的图形界面编程(GUI),就

会发现它还是蛮有用和蛮好用的. 感兴趣的, 可以到 python.org 和

wxPython.org上走走.

诡计之一: 对简单的任务, 俺通常将之写为非面向对象的, 🙂

图象界面编程 (GUI)

首先得对简介(三)中类的方法与函数的差别作一小更正(幸得Kh9

先生指正于其后的文章点评中):

在类的实体化:

对象 = 类(初始化参数)

之后对对象方法的调用:

对象.方法(参数)

其实是相当于调用如下函数:

类.方法(对象, 参数)

因为Python是用C而不是C++写的. 大家可以看到其作

者对类的处理还是蛮合理的.

对类的了解可以在其图象界面编程(GUI)中得以深入.俺自己当初

学C时就对它的画图功能十分感兴趣,曾用之画过不少数学解集,

如混沌学中气象预报的Lorentz方程 (正发现网上有Java展示:

http://www.wcinet.net/~joshw/na/chaos/Lorentz.html

和分形学中的Mandelbrot集合等. 所以对Python的图象编程也趣

味盎然.

Python的GUI主要是与其它己存在图形库的结合. 目前主要有:基

于Tcl/Tk库的Tkinter,基于wxWindows库的wxPython,基于Qt/Kde

库的PyQt/PyKde和基于Gtk+/Gnome库的PyGtk/PyGnome.其他还有

基于FlTk库的FlPy, 基于Fox库的FoxPy等.

Python自带了Tkinter,其编程之简单也基本类似Tcl/Tk, 但Tk的

对象不很丰富,所产生的图形也不是很漂亮.俺曾看到网上有人比

较过wxPython与Tkinter的画点速度,发现wxPython要快一个数量

级.这可能是因Tkinter不仅要调用Python还得用Tcl两个脚本语

言之故.对于PyQt,俺没能在俺的Mandrake7.2上编译成功,所以就

没学它了, 不过据说也拥有稍小于wxPython的用户群;PyGtk目前

还不如wxPython和PyQt成熟. 下面俺就略说一下Tkinter.就入门

而言, Tkinter还是值得一瞄的.而且网上有很多关于它的入门介

绍, 如:

http://www.pythonware.com/library/an-introduction-to-tkinter.htm

http://www.python.org/doc/life-preserver/

也正好看到OSO就有<<Teach Yourself Python>>的源码下载,其后

面几章就是Tkinter的样例, 其中一个就是画Mandelbrot集的.

a)Tk与Tkinter对照:

Tk ==> Tkinter

button .b ==> b=Button() #在根窗口中定义一个按钮

button .panel.b ==> b=Button(panel) #在面板中定义一个按钮.

button .b -fg red ==> b=Button(fg="red") #设置前景色

.b configure -fg red ==> b["fg"]=red #部件产生后再配置

==> b.config(fg="red") #第二种方法

pack .b -side left ==> b.pack(side="left") #列入右边并显示

b)最简单的例子 (一个窗口中含字串: Hello, world!)

from Tkinter import *

root = Tk() #产生一个根窗口

l = Label(root, text="Hello, world!")# 产生一个标识

l.pack()

root.mainloop() #进入主循环, 有事件则运行, 无事就等着

c)仍是十分简单的例子(一个窗口中两个按钮:Quit和Hello)

from Tkinter import * #引入Tkinter模块

class App: #定义一个类

def __init__(self, master): #类的构造器, 相当于C++的constructor

frame = Frame(master) #产生一个框架

frame.pack()

button = Button(frame, text="QUIT", fg="red", command=frame.quit)

button.pack(side=LEFT)

hi_there = Button(frame, text="Hello", command=self.say_hi)

#self.say_hi是调用类的函数 say_hi()

hi_there.pack(side=LEFT)

def say_hi(self):

print "hi there, everyone!"

root = Tk()

app = App(root) #上面__init__有两个参数, self只是对象

root.mainloop()

上面b), c)取自:

http://www.pythonware.com/library/tkinter/introduction/

因b)简单, c)介绍了类的用法. 在c)中俺将它原来的self.button

和self.hi_there改成了button和hi_there, 因为不会在类的其它

地方调用这两个器件. 俺刚才试过, 没问题的.

另外,OSO发文时好象不能发图片.俺自己倒是省了点事.读者可以到

上面所给地址去看程序运行结果, 及更多内容. 俺这里只是想给大

家一个初始印象.

顺便说一下,俺本来还想给出wxPython的两个例子,幸好到OSO上的

搜索了一下, 原来limodou先生已经将O'Reilly书:

<<Python Programming on Win32>>

中有关wxPython的内容全译了:

http://www.oso.com.cn/read_article.php?article_id=4134

而且是最近才译的, 看来 "英雄所见略同", 🙂 不过俺发现他文章

样例程序中的行头空格全没了 — 这样的Python程序是无法运行的.

也许是浏览器将之当作Html文件了.所以推荐其原网页供各位下载样

例源码:

http://www.oreilly.com/catalog/pythonwin32/chapter/ch20.html

(其实oreilly.com上仅仅给了<<Win32上的Python编程>>中的两章作

样子,但幸运的是其中就有这章GUI编程.) wxPython.org上的简介还

没有O'Reilly上的详细. wxPython的作者及wxWindows的几位一起开

了个wxpros.com, 来提供支持服务(如培训,付费答疑等), 愿其成功,

或至少能供养肚子继续发展wxPython, 🙂

杂类

这里俺想补充几点俺的前面四篇中尚未提及但仍很有用的地方. 下面

将要出现的 …是Python的第二提示符, 表示继续一个不完整的命令

*)Python中的每个变量都是对象 — Python特有的对象, 并不一定

都是 "面向对象的编程" 中的对象

*)第一有效行(非解释行), 其行首必须没有空格(在Python中, 表格

键Tab 缺省是等于8个空格.)

*)续行可以用行末的 '\', 注意其后必需是回车/换行; 对于包在大,

中, 小括号中的若干行, 系统都缺省作续在一起的一行. 但不能把

一个变量名分开放在两行上. 如:

>>> score = {'xah':59,

… 'you':99}

>>>

>>> score\

… ['xah']

59

>>> scor\

… e['xah'] #错误

File "<stdin>", line 2

e['xah']

^

SyntaxError: invalid syntax

>>>

*)交互式用法中的下划线: _ , 是上面一行命令运行的结果. 如:

>>> 3+5

8

>>> _ * 7

56

*)屏幕输出

在print最后加一逗号, 就不会自动输出'\n', 而输出一空格;

也可用格式符:

>>> print 'a'; print 'b'

a

b

>>> print 'a',; print 'b' #第一句后加了一个逗号

a b

>>> print '%x %s' % (11, 'abc') #多变量时须用小括号括起,见下面: Tuple

b abc

再重提一下, 包在匹配的 三个单引号或三个双引号之间的字

串, 可以是多行, 相当于HTML中的<PRE>和</PRE>, 即原样在

屏幕上输出. 也可对它们用格式符:

>>> a = ''' pytho

… n is %s!''' % 'great'

>>> a

' pytho\012n is great!' #Python用8进制显示控制字符: \n == \012

>>> print a

pytho

n is great!

>>>

Python 2.0版之后就可能用 >>stderr 来打印到标准错误输出:

>>> from sys import stderr

>>> print >> stderr, 'ok'

ok

2.0版之前好象是用文件形式: stderr.write('ok')

*)字串变数字, 数字变字串:

>>> int('123')

123

>>> float('123')

123.0

>>> eval('123') #随所给字串, 既可产生整数, 也可浮点数

123

>>> str(123) #数字到字串

'123'

>>> `123` #反向单引号, 还可用函数: repr(数字变量)

'123'

*)屏幕输入:

字串输入: s = raw_input(提示字串)

数字输入: x = input(提示字串) #相当于: eval(raw_input())

*)字串按空格或其它用户定义的分隔符来分隔.

Python 2.0版以后的, 可以用:

>>> a='123 321 456'

>>> a.split()

['123', '321', '456']

>>> a.split('2')

['1', '3 3', '1 456']

>>> 'AA'.join( a.split('2') ) #按分隔符'AA'将字串数列合并

'1AA3 3AA1 456'

但2.0(或至少1.6 ?)以前必须要引入string模块: (也即2.0

将原本在string模块中的不少函数并入字串的方法中去了,

但不是全部):

>>> from string import split, join

split(a,'2')

['1', '3 3', '1 456']

>>> join ( split(a,'2'), 'AA') #同上, 但调用了函数

'1AA3 3AA1 456'

*)交互式下可以用dir()来看从模块中引入了什么函数与变量:

>>> import math

>>> dir(math)

['__doc__', '__file__', '__name__', 'acos', 'asin',

'atan', 'atan2', 'ceil', 'cos', 'cosh', 'e', 'exp'

, 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp

', 'log', 'log10', 'modf', 'pi', 'pow', 'sin', 'sin

h', 'sqrt', 'tan', 'tanh']

看函数/模块的说明(函数/模块中的第一行字串, 或多行位于

成对的''', """之间):

>>> import math

>>> print math.__doc__

This module is always available. It provides access to the

mathematical functions defined by the C standard.

>>> print math.sin.__doc__

sin(x)

Return the sine of x.

>>>

*)文件

打开:

f = open("My.py") #只读

f = open("My.py", "r") #只读

f = open("My.py", 'r+b')#可读可写, 二进制文件

f = open("tmpFile", 'w')#只写

读:

s = f.read(字节数) #读给定字节数的内容

text = f.read() #读整个文件, 得到一字串

line = f.readline() #读一行(含换行符: '\n')

lines = f.readlines() #读整个文件, 得到字串数列

#lines[-1]是最末一行(含'\n'), 等等

写:

f.write('AAAbbb\n') #写一个字串

f.writelines(lines) #写字串所组成的数列

关闭:

f.close()

*)lambda函数

来自Lisp/Scheme, 好象是只能有一个执行句子. 可能主要是

用来简写一个函数的定义.

>>> f = lambda a, b, c : (a + b ) * c

>>> f(1,2,3)

9

看样子它有点类似于C/C++中的:

#define max(A, B) (A)>(B) ? (A) : (B)

*)空白类可以来作C中的"struct"功能:

>>> class My: pass

… #其中pass是不执行任何命令. 大概是由于分号在Python

… #中不太起作用, 所以引入"pass". 而C中就可以用:

… # for (;;);

… #来"等你等到天尽头".

…

>>> xah = My()

>>> xah.birthDay = 1

>>> xah.birthYear = 3000

>>> xah.birthYear

3000

>>>

*)错误处理

通常Python若出错误, 即会自动退出. 但你可以用

try : 可能出错语句

except 特定错误 : 出错后要执行的命令

来处理. 如:

>>> 1/0 #除0错误

Traceback (most recent call last):

File "<stdin>", line 1, in ?

ZeroDivisionError: integer division or modulo by zero

>>> try: 1/0

… except ZeroDivisionError:

… print "ok"

…

ok

*)Tuple, 俺在<<英华大字典>>上都没找到其译文. 马苏安的星际

译王将之译为"元组". 英文解释似乎也很强调它的有序性.这里

俺就暂用"元组".

Python的元组是用小括号括起来的变量, 常数, 函数等对象的组

合, 虽然有时候小括号可以省略. 如俺以前给出过:

total, i = 0, 0

其实就是元组赋值:

(total, i) = (0, 0)

*)字串和元组皆是一经产生就不可再变更, 只能另赋新值. 这也是

元组不同数列之处. 数列和字典皆可在产生之后变更. 如:

>>> s="abc"

>>> s[2] = 'D' #错误:

Traceback (most recent call last):

File "<stdin>", line 1, in ?

TypeError: object doesn't support item assignment

>>> t = (3, 5)

>>> t[0] = 4 #错误

Traceback (most recent call last):

File "<stdin>", line 1, in ?

TypeError: object doesn't support item assignment

但可以用其片段来组成一个另变量:

>>> s='abc'

>>> s2 = s[1:-1] + 'd'

>>> s2

'bd'

>>> s='def'

>>> s

'def'

元组中的可变更变量也可另赋值:

>>> x, y = 3, 5

>>> a=(x,y)

>>> a

(3, 5)

>>> y=4

>>> a

(3, 5)

>>> x,y=3, [4,5]

>>> z=x, y

>>> z

(3, [4, 5])

>>> y[0] = 2

>>> z

(3, [2, 5])

>>>

*)赋值,

跟能常所说的(如C/C++)赋值有些不一样.

变量赋给变量时, 只是增加了对同一对象的参考(Reference),

而不产生新变量. 如:

>>> l=[3,4]

>>> l2=l

>>> l[0]=-1

>>> l

[-1, 4]

>>> l2

[-1, 4]

而俺发现用l2 = l[0:]就不一样:

>>> l=[3,4]

>>> l2=l[0:]

>>> l[0]=-1

>>> l

[-1, 4]

>>> l2

[3, 4]

但对不可变更的对象, 因其不可变更, 或只能另赋新值, 所以

只表现为常见的"赋值即产生新对象"的样子:

>>> s='abc'

>>> ss = s

>>> ss

'abc'

>>> s='345'

>>> s

'345'

>>> ss

'abc'

本节结语: 希望大家不要被俺绕糊涂了, 俺只是想提供一些Python

与通常的语言, 如C/C++, 相比而不同之处. 总的来说, Python还是

蛮好用的. wxPython作者, 罗宾 . 邓恩 (Robin Dunn) 就在网上说,

他个人习惯是一切编程皆用Python; 即使真需要速度, 他也将C/C++

编成Python模块.

到此为止对Python还很感兴趣的同志, 可以去当Python的库参考了.

(mpage可以4合1, 加上正反面打印, python.org上的400页库参考

你50张纸就行了, 只要你视力不是太弱可以看小号字体, 🙂 )

–

pygtk 的图象编程

俺最近又稍学了点pygtk, 贴出来给大家分享.

俺去学pygtk的原因是, 俺发现在俺的机子上pygtk比wxpython在

启动时要几乎快上一倍(1-2秒相对于2-5秒); 并且俺发现一个简

单的按钮显示, wxpython的程序运行起来要占约10-12M内存, 而

pygtk的只要约5-6M.

后来俺就到wxpython的用户邮件列表上发问, 那里的人还很热心

地作了解释, 说启动速度和内存是因为UNIX下的wxGtk在是对Gtk

库进行包装的结果, 并说启动之后的执行速度二者应无显蓍差别.

wxWindows故而拥有很好的移植性. 还有人指出了二者其它异同.

大意是pygtk还可以使用主题色彩配置(themes), 而且gnomepy还

可以使用libglade库来简化很多编程任务; 但wxpython的小器件

(widget)还是要比目前的pygtk要丰富. 关于Gtk在MS Windows上

的运行, 有人说很稳定了, 也有人说每5分钟死一次机. 另外,俺

还瞄了瞄二者用户列表上的帖子数量, 发现wxpython的约为pygtk

的两倍左右.

所以总的看来, 还是各有千秋. 大家不妨也来瞄瞄pygtk.

Gtk+与Python的结合早就有人捣弄了, 不过目前最正统还是

James Henstridge做的,看网址他好象是澳大利亚人. pygtk的

主页在:

http://www.daa.com.au/~james/pygtk/

而在这里有pygnome的入门简介:

http://laguna.fmedic.unam.mx/~daniel/pygtutorial/

俺下面就取其中的两个例子(也是pygtk源程序中examples/simple

目录中的两个程序)稍作解释.

pygtk目前的稳定版是0.6.6; 作者说: 别看它版本还不高, 里

面的小器件还真不少, Gtk+ 1.2的玩意差不多全包括了. 咱这

就过来瞧一瞧.

pygtk有两种实现. 最老早的是基于C语言的函数调用形式, 这

倒与Gtk+本身很相近; 后来采用了面向对象的形式, 感觉要简

洁不少. 请看:

1)"世界好!"的C语言调用形式

(来自pygtk源程序中的examples/simple/hello1.py)

#!/usr/bin/env python #让程序可执行

from _gtk import * #引入pygtk的C函数模块, gtk前有下划线

from GTK import * #引入常用变量模块

def hello(*args): #函数定义: 屏幕显示"世界好"

print "Hello World"

gtk_widget_destroy(window)

def destroy(*args): #退出函数定义

gtk_widget_hide(window)

gtk_main_quit()

gtk_init() #Gtk初始化

window = gtk_window_new(WINDOW_TOPLEVEL) #产生一个窗口

gtk_signal_connect(window, "destroy", destroy) #退出信号连接

gtk_container_set_border_width(window, 10) #边界宽度设定

button = gtk_button_new_with_label("Hello World")#产生一个按钮

gtk_signal_connect(button, "clicked", hello) #鼠标点击传到函数

gtk_container_add(window, button) #将按钮加入到窗口中

gtk_widget_show(button) #显示按钮

gtk_widget_show(window) #显示窗口

gtk_main() #等待鼠标动作

2)"世界好!"的面向对象的形式

(来自pygtk源程序中的examples/simple/hello2.py)

#!/usr/bin/env python

from gtk import * #引入pygtk的面向对象的模块, gtk前无下划线

def hello(*args):

print "Hello World"

window.destroy()

def destroy(*args):

window.hide()

mainquit()

window = GtkWindow(WINDOW_TOPLEVEL) #产生一个窗口

window.connect("destroy", destroy) #退出信号连接

window.set_border_width(10) #边界宽度设定

button = GtkButton("Hello World") #产生一个按钮

button.connect("clicked", hello) #鼠标点击传到函数

window.add(button) #将按钮加入到窗口中

button.show() #显示按钮

window.show() #显示窗口

mainloop() #等待鼠标动作

===========

大家是不是也觉得第二种方法要简洁 ? pygtk的作者好象也是推荐

大家用第二种方式. 对大一点的程序, 照样可以用类(class)来把

它表达的很清楚.

俺就不多说了, 各位感兴趣的, 可以去上面的入门介绍中看看它们

运行的屏幕取像(screenshot), 再去当下pygtk的源程序装上(很小,

300k, 也很容易装上), 并运行一下它里面examples目录下的样例,

就会很了解pygtk能干什么活了. 当你自己想用它编简单任务时,直

接在其某个样例的基础进行加工是最省事的了.