学习python(入门篇)

俺这里想给大家初步介绍一下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能干什么活了. 当你自己想用它编简单任务时,直
接在其某个样例的基础进行加工是最省事的了.

学习python(入门篇)相关推荐

猿编程python代码_程序猿编程课堂 Python学习之入门篇3：简单的数据类型
1. 什么是数据类型? 我们知道编程就是编写程序解决某个问题,而任何能使用编程来解决的问题都是能够提取或者转换出相应的数据,只是数据的表达形式是不一样的,而这表达形式就是数据类型. 比如,数学中的数字 ...
程序猿编程课堂 Python学习之入门篇1：环境搭建与第一个程序
前言: Python作为目前比较热门的编程语言,其简单和简洁的语法使它成为一种非常好的通用编程语言,它是一种面向对象的动态类型语言,最初被设计用于编写自动化脚本(shell),并且随着版本的不断更新和 ...
python网络爬虫学习之入门篇
预备知识学习者需要预先掌握Python的数字类型.字符串类型.分支.循环.函数.列表类型.字典类型.文件和第三方库使用等概念和编程方法. Python入门篇:https://www.cnblogs. ...
C# 学习笔记入门篇（上）
文章目录 C# 学习笔记入门篇〇.写在前面 Hello World! 这篇学习笔记适合什么人这篇学习笔记到底想记什么附加说明一.命名空间 "进入"命名空间嵌套的命名空间. ...
Python入门篇-匿名函数
Python入门篇-匿名函数作者:尹正杰版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.匿名函数概述 1>.什么是匿名函数匿名,即没有名字匿名函数,即没有名字的函数 2>. ...
Python入门篇-数据结构堆排序Heap Sort
Python入门篇-数据结构堆排序Heap Sort 作者:尹正杰版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.堆Heap 堆是一个完全二叉树每个非叶子结点都要大于或者等于其左右孩子结点的 ...
Python入门篇-functools
Python入门篇-functools 作者:尹正杰版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.partial方法 1>.partial概述偏函数,把函数部分的参数固定下来,相当 ...
Python入门篇-高级数据类型集合（set）和字典（dict）
Python入门篇-高级数据类型集合(set)和字典(dict) 作者:尹正杰版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.集合(set) 1>.集合的特点约定set 翻译为集合c ...
Vue学习笔记入门篇——数据及DOM
本文为转载,原文:Vue学习笔记入门篇--数据及DOM 数据 data 类型 Object | Function 详细 Vue 实例的数据对象.Vue 将会递归将 data 的属性转换为 getter ...

学习python(入门篇)

学习python(入门篇)相关推荐

最新文章

热门文章