俺这里想给大家初步介绍一下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能干什么活了. 当你自己想用它编简单任务时,直
接在其某个样例的基础进行加工是最省事的了.
最好是去看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能干什么活了. 当你自己想用它编简单任务时,直
接在其某个样例的基础进行加工是最省事的了.
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
