该文档为Python编程语言的基础教程，涵盖了数据类型（如整数、浮点数、字符串、列表和字典）及其基本操作。教程详细解释了函数、循环、条件语句、面向对象编程和错误处理等关键概念和编程实践。同时，文档还提供了示例代码以帮助理解各个概念的实际应用。

1. File: /home/aaron/Desktop/a Page 1 of 18
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2013-06-20T10:56:43+08:00
====== 第一章 ======
Created Thursday 20 June 2013
Python中 [[/为普通出发]] //为整除法
Python 现用printf("");
Python可以处理非常大的数据
在绝大部分情况下不用担心长整数和整数的区别
十六进制和八进制表示方法和C的相同: 16 0x, 8 0
表达式是某事而语句是做某事
解释器总是把所有表达式的值打印出来而已
nan是一个特殊值的简写， 意思是not a number
python可以求负数的平方根
推荐使用raw_input()函数
让脚本像普通程序一样运行:#!/usr/bin/env python, 在实际运行脚本前必须让脚本文件具有可执行的权限。
python 3.2.3没有raw_input了
pyhon拼接字符串eg；'k' 'ong' 拼接之后字符串为：'kong'，这仅仅是书写字符串的一种特殊的方法，并不
是拼接字符串的一般方法。那么该怎样拼接字符窜呢就像进行加法运算一样："Hello" + "World"
x="Hello";y="World" xy这样是错误的
通过前面的例子读者们可能注意到了，所有通过Python打印的字符串还是被引号扩起来的，这是因为Python打
印值的时候会保持该值在Python代码中的状态，而不是你希望看到的样子。 如果使用print语句，结果就不一
样那个了
str()便于用户理解， repr(）合法的python表达式， repr也可以用``来表示，如果希望打印一个包含数字的句
子，那么反引号就很有用了，但在python3.0中已经不用``号了
不可以将字符串和数字想加
长字符串“”“ ”“”
普通字符串有转意作用，但原始字符串就没有,r'abc'
函数：
abs(number)
float(object) //将字符串和字符转换为浮点数
cmath.sqrt(number)
help()
input(prompt) 获取用户输入
int(object) //字符串和数字
long()
math.floor()返回数的下舍整数

2. File: /home/aaron/Desktop/a Page 2 of 18
math.sqrt()
pow(x,y)返回x的y次幂
repr(object)
round(number[,ndigits]) 根据给定的精度对数字进行四射侮辱
str(object)
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2013-06-20T12:36:07+08:00
====== 第二章 ======
Created Thursday 20 June 2013
列表[]和元组()
在python中最基本的数据结构就是序列，序列中的每个元素被分配一个序号-元素的位置，也成为索引，第一
个是0.。。。。
python有6种内建的序列:列表字符串和元组
列表和元组主要区别在于：列表可以修改而元组不能
访问序列greetng[0]
numbers=[1,2,3,4,5,6]
numbers[3:6] [)
[4,5,6]
序列相加：[1,2,3] + [4,5,6] = [1,2,3,4,5,6]
两种相同类型的序列才能进行连接操作
初始化一个长度为10的列表[None] * 10
布尔运算符in: eg: permissions="rw"
'w' in permissions
>>>True
>>numbers = [100,34,678]
>>>len(numbers)
3
>>min(9,3,2,5)
2
列表: Python的苦力
list('Hello')
.join(somelist)
删除列表; del names[2]
name = list('perl');
name[2:] = list("ar"); 分片赋值
>>>name

3. File: /home/aaron/Desktop/a Page 3 of 18
['p','e','a','r']
numbers=[1,5]
numbers[1:1] = [2,3,4]
>>>numbers
[1,2,3,4,5]
numbers[1:4] = []
extend方法修改了被扩展的序列，而原始的连接操作则不然，它会返回一个全新的列表.
>>>knights.index('who')
4
pop方法是唯一一个既能修改列表又返回元素值的列表方法
remove方法用于移除列表中某个值的第一个匹配项:
x.remove('be')
reverse 方法用于将列表中的元素反响存放, 注意该方法改变了列表但不返回值
sort在原位置进行排序,返回的是None
sorted('Python') 可以用于任何序列，却总是返回一个列表
创建元组语法很简单： 如果你用逗号分割了一些值，那么你就自动创建了元组
>>>43,
(43,)
tuple函数的功能与list函数基本上是一样的， 以一个序列作为参数并把它转换为元组
一般来说列表可能更满足 对序列的所有需求
tuple和list并不是真正的函数--而是一种类型
本章的新函数：
cmp(x,y) 比较两个值 y>x 返回1
len(seq)
list()
max()
min()
reversed(seq)
sorted(seq)
tuple(seq)
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2013-06-20T13:51:25+08:00

4. File: /home/aaron/Desktop/a Page 4 of 18
====== 第三章 ======
Created Thursday 20 June 2013
格式化列表一般寻则元组
>>> format = "hello, %s,%s enough for ya?"
>>> values = ('world','hot')
>>>print format % values
Hello, Wrold Hot enough for ya?
如果使用列表或者其他序列替代元组， 那么序列就会被解释为一个值，只有元组和字典可以格式化一个以上
的值
格式转换,基本的转换说明符包括一下部分:
1. %字符: 标记转换说明的开始
2. 转换标致(可选) -表示左对齐;+表示在转换值之前要加上正负号
""空白字符，表示证书之前保留空格0表示转换值若位数不够则用0填充
3. 最小字段宽度： 转换后的字符串至少应该具有该值制定的宽度，如果是×则宽度会从值元组中读出
4. (.) 后跟精度值
5. 转换类型
...
字符串方法:
字符串的方法还要丰富的多，这是因为字符串从string模块中继承了很多方法
find() 返回字串所在位置的最左端的索引.如果没有找到则返回-1
join方法是非常重要的字符窜方法,它是split方法的逆方法,用来在队列中添加元素
lower()
replace()
eg:
>>> 'This is a test'.replace('is', 'eez')
split这是一个非常重要的字符串方法，用来将字符串分割成序列
eg:
'1+2+3'.spilt('+') 如果不提供任何分隔符，程序会把所有的空格作为分隔符(空格，制表，换行等)
strip方法去除两侧空格的字符串
它和lower方法一起使用的话就可以很方便的对比输入的和存储的值 very good
translate方法和replace方法一样，可以替换字符串中的某些部分,但是和前者不同的是该方法只处理单个字
符，他的优势在于可以同时进行多个替换，有时候比replace效率更高的多
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2013-06-20T15:06:51+08:00
====== 第四章 ======
Created Thursday 20 June 2013
字典!!!
>>>items=[('name', 'Gumby'), ('age', 43)]

5. File: /home/aaron/Desktop/a Page 5 of 18
>>>d = dict(items)
>>>d
{'age': 42, 'name': 'Gumby'}
copy方法返回一个具有相同兼职对的新字典
fromkeys 方法使用给定的键建新的字典，每个剑默默认的自己为None
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2013-06-20T16:25:06+08:00
====== 第五章 ======
Created Thursday 20 June 2013
print 'Age:',42
from math import sqrt as foobar
多个赋值同时进行
>>> x,y,z = 1, 2, 3
>>>print x,y,z
1 2 3
x,y = y,x 交换2个变量, 事实上这里所作的事情叫做序列解包-将多个值序列解开，然后放到变量的序列中，
当函数或者方法返回元组时，这个特性尤其有用，假设需要获取（和删除）字典中任意的键值对，可以使用
popitem方法，这个方法将键值作为元组返回
>>>key,value = scound.popitem()
>>key
1
>> value
2
Python中所有的值都能被解释成真值
bool函数可以用来将其他值转换成bool值
if语句
if name.endswith('Gumby'):
print ...
elif num < 0:
print ...
else:
print ...
elif 和shell表现一样 但和awk表现不一样 awk和c一样 else if
1. 比较运算符
2. x == y, x ！= y, x is y x和y是同一个对象, x is not y x和y 是不同的对象,x in y, x not in y
3. 0<age<100 在python是可以的但在c中是不可以的
if 's' in name:
print ...
bool运算符

6. File: /home/aaron/Desktop/a Page 6 of 18
c: && ||
awk: && ||
shell: -o, -a
python: and or not
循环
while 循环
x =1
while x<= 100:
print x;
x += 1;
while not name:
....
words = ['this', 'is', 'an', 'ex']
for word in words:
print word
因为迭代（循环的另外一种说法）某范围的数字是很常见的，所以有个内建的范围函数供使用：
>>> range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
eg:
for number in range(0,10):
print ...
循环遍历字典元素
for key in d:
print key,d[key]
for key, value in d.item():
print key,value
一些迭代工具：
1. 并行迭代
names=['a','b']
ages=[1,2]
for i in range(len(names)):
print names[i],ages[i]
zip(names,ages)
返回：[('a',1),('b',2)] 参考{‘a':1, 'b':2}
for name,age in zip(names,ages):
print name, is age
2. 编号迭代
for index, string in enumerate(strings):
if 'xxx' in string:
strings[index] = '[censored]'
from math import sqrt
for n in range(99,81,-1):
root = sqrt(n)
if root == int(root):
print n
break
else:
print ...
上面的else仅在没有调用break时执行

7. File: /home/aaron/Desktop/a Page 7 of 18
列表推导 — 轻量级循环
列表推导是利用其他列表创建新列表的一种方法,它的工作方式类似于for循环,也很简单
eg:
>>> [x*x for x in range(10)]
[0,1,4,9,...,81]
这个语句可以通过增加一个if部分添加到列表推导中eg:
[ x*x for x in range(10) if x%3 == 0 ]
[(x,y) for x in range(3) for y in range(3)]
[(0,0), (0,1),(0,2) ... ]
pass什么都不做
del 他不仅会移除一个对象的引用，也会移除那个名字本身
使用exec和eval执行和求值字符串
exec "print 'hello world'"
本章的函数
chr(n) 当传入序号时，返回n所代表的包含一个字符的字符串
eval()
enumerate(seq)
ord(c)返回单字符字符串的int值
range()
reversed(seq)
sorted
xrage
zip
== 哈哈 到这里基本知识已经学完了 ==
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2013-06-20T18:05:15+08:00
====== 第六章 ======
Created Thursday 20 June 2013
参数parameter 作用域:scope
__创建函数__
eg:
''def hello(name):''
''return 'Hello, ' + name +'!'''
文档字符串
''def square(x):''
'calculates the square of the number x.'
return x*x

8. File: /home/aaron/Desktop/a Page 8 of 18
文档字符串可以按如下方式访问:
>>> square.__doc__
>>> help(square)
__参数魔法：__
当两个变量同时引用一个__列表__时，他们的确是同时引用一个__列表,当在序列中做切片的时候 返回的切
片总是一个副本__
位置参数在调用时是不传入参数名字的
关键字参数ge: hello_2(greeting='hello',name='world')
收集参数:
def print_params(*params)
参数前面的*号将所有值放置在同一个元组中。可以说是将这些值收集起来，然后使用。*号意思是收集其余
参数
*收集元组 **收集字典
eg:
def print_params_4(x, y, z = 3, *pospar, **keypar):
print x, y, z
print pospar
print kdypar
>>> print_params_4(1,2,3,4,5,6,7,foo = 1,bar = 2)
1 2 3
(5,6,7)
{'foo':1, 'bar':2}
作用域
若变量同名 ，想访问全局变量需要：
print parameter + globals()['parameter']
def change_global():
global x
x = x + 1
本章新的函数:
map(func, seq, [, seq, ...]) 对序列中的每个元素应用函数
filter(func, seq) 返回其函数为真的序列列表
reduce(func, seq [, initial])
sun(seq)
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2013-06-20T19:16:34+08:00
====== 第七章 ======
Created Thursday 20 June 2013
Python是面向对象的程序设计语言
对象最重要的优点包含以下几方面：

9. File: /home/aaron/Desktop/a Page 9 of 18
1. 多态
2. 封装
3. 继承
很多对函数和运算符都是多态的，唯一能毁掉堕胎的就是使用函数显示地检查类型, 比如：type,
isinstance, issubclass函数等，如果可能的话应该尽力避免使用这些毁掉多态的方式.
类可以将它或多或少的视为种类或者类型的同义词,所有的对象都属于某一个类， 称为类的实例(instance)
创建类列子：
__metaclass__ = type #确定使用 新式类
class Person:
def setName(self, name):
self.name = name
def getName(self):
return self.name
def greet(self):
print "hello world! I'm %s." % self.name
>>> foo = Person()
>>> bar = Person()
>>> foo.setName('kong')
>>> bar.setName("fei")
>>> foo.greet()
在调用foo的setName和greet函数时， foo自动将自己作为第一个参数传入函数中-因此形象地命名为self, 没
有他的话成员方法就没法访问他们要对其特性进行操作的对象本身了
多多理解: yes i know!
和之前一样，特性是可以在外部访问的:
>>> foo.name
>>>bar.greet()
方法(更专业一点可以成为绑定方法) 将他们的第一个参数绑定到所属的实例上，因此这个参数可以不必提供
Python并不直接支持私有方式，而是要靠程序员自己把握在外部进行特性修改的时机。但是可以用一些小技巧
达到私有特性的效果，为了让方法或者特性变成私有（从外部无法访问），只要在他的名字前面加上双下划
线即可eg:
class Secretive:
def __inacessible(slef):
print "Bet you can't see me ...
尽管双下划线有些奇怪， 但是看起来像是其他语言中的标准私有方法，真正发生的事情才是不标准的，类的
内部定义中， 所有以双下划线开始的名字都被翻译成前面加上单下划线和类名的形式
eg:
>>> s._Secretive_inaccessible()
前面有下划线的名字都不会被带星号的imports语句导入(from module import *
issubclass(subclass,class) 返回True
SPAMFilter.__bases__
isinstance(object, class) 返回True

10. File: /home/aaron/Desktop/a Page 10 of 18
可以检查所需的方法是否已经存在，如果不存在就要做其他一些事情
>>> hasattr(tc, 'talk')
如果需要的话甚至还能检查talk特性是否可调用:
>>> callable(getattr(tc, 'talk', None))
setattr()
如果要查看对象内所有存储的值， 那么可以使用__dict__特性，
一些关于面向对象设计的思考：
1. 将属于一类的对象放在一起
2. 不要让对象过于亲密， 方法应该只关心自己实力的特性， 让其他实例管理自己的状态
3. 要小心继承， 尤其是多重继承
4. 简单就好， 让你的方法小巧,尽量将代码行数控制在一页或者一行内.
本章的新函数：
callable(object) 确定对象是否可调用， 比如函数或者方法
random.choice(sequence) 从非空序列中随即选择元素
type(object) 返回对象的类型
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2013-06-21T09:50:23+08:00
====== 第八章 ======
Created Friday 21 June 2013
异常：
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2013-06-21T09:52:47+08:00
====== 第九章 ======
Created Friday 21 June 2013
魔法方法， 属性和迭代器
构造方法和其他普通方法不同的地方在于：当一个对象被创建后，会立即调用构造方法
在Python中创建一个构造方法很容易。只要把init方法的名字从简单的init修改为魔法版本__init__即可：
class FooBar:
def __init__(self):
self.somevar = -42
>>> f = FooBar()
>>> f.somevar
42
在python中的所有魔法方法中__init__是使用最多的一个

11. File: /home/aaron/Desktop/a Page 11 of 18
__del__析构方法, 建议读者尽量避免使用析构函数
__iter__方法返回一个迭代器(iterator)， 所谓迭代器就是具有next方法的对象。在调用next方法时， 迭代器
会返回它的下一个值。如果next方法被调用，但迭代器没有值可以返回， 就会引发一个StopIteration异常
在很多情况下， __iter__会放到其他的会在for循环中使用的对象中。这样以来程序就能返回所需的迭代器。
正式的说法是：一个实现了__iter__方法的对象是可迭代的， 一个实现了next方法的对象则是迭代器
class Fibs:
def __init__(self):
self.a = 0
self.b = 0
def next(self):
self.a, self.b = self.b, self.a+self.b
return self.a
def __iter__(self):
retunr self
fibs = Fibs()
for f in fibs:
if f > 1000:
print f
break
....
1597
内建对象iter可以从可迭代的对象中获得迭代器
从迭代器得到序列：
class TestIterator:
value = 0
def next(self):
self.value +=1
if self.value > 10: raise StopIteration
return self.value
def __iter__(self):
return self
...
>>> ti = TestIterator()
>>>list(ti)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
生成器是一种用普通的函数语法定义的迭代器.
创建生成器:
包含任何yield语句的函数成为生成器.yield除了名字不同外，他的行为和普通函数也有很大的差别，这就在于
它不像return那样返回值， 而是每次产生多个值， 每次产生一个值（使用yield语句）， 函数就会被冻结：
即函数停在那点等待被激活， 函数被激活后就后就哦从嗯停止的那点开始执行
eg：
def flatten(nested):
for sublist in nested:
for element in sublist:
yield element

12. File: /home/aaron/Desktop/a Page 12 of 18
接下来可以通过在生成器上迭代来使用所有的值
>>> nested = [[1, 2], [3, 4], [5]]
>>> for num in flatten(nested):
print num
...
1
2
3
4
5
or
>>> list(flatten(nested))
[1, 2, 3, 4, 5]
递归生成器:
通用生成器:
....
__需要继续了解__
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2013-06-21T11:05:45+08:00
====== 第十章 ======
Created Friday 21 June 2013
Python的标准安装包括一组模块， 成为标准库
任何python程序都可以作为模块导入， 假设你写了一个如下代码清单，并将他存为hello.py文件（名字很重
要）
#hell.py
print "hello, world"
该文件保存在C：/python
接着就可以执行下面的代码：
>>> import sys
>>> sys.path.append(‘C：/python’)
导入模块：
>>> import hello
hello world!
代码重用: code reuse
在导入模块的时候， 你可能会看到有新文件出现：*.pyc， 这个以.pyc为扩展名的文件是经过处理(编译)
的， 已经转换为python能狗更加有效处理的文件
在导入模块的时候， 其中的代码已经被执行过了， 不过， 再再次导入的时候， 就什么都不发生了 ， 为

13. File: /home/aaron/Desktop/a Page 13 of 18
什么这次没用了？因为导入模块并不意味着在导入时执行某些操作， 它们主要用于定义， 比如变量， 函数
和类等.此外， 因为只需要定义这些东西一次， 导入模块多次和导入一次的效果是一样的
测试代码：
#hello4.py
def hello():
print "hello, world!"
def test():
hello()
if __name__ == "__main__":test()
更可取的方法：
def test():
hello()
让你的模块可用;
1. 将模块放置在正确的位置
pprint和print, pprint更适合打印路径 列 成一列, pprint能够提供更加智能的输出
>>> import sys, pprint
>>>pprint.pprint(sys.path)
site-packages最佳路径，因为它就是用来做这些事情的
2. 告诉编译器去哪里找
设置PYTHONPATH环境变量
为了组织好模块， 你可以将他们分成包（package）， 包基本上就是另外一类 模块， 有趣的是他们能包含
其他模块，当模块存储在文件中时， 包就是模块所在的目录, 为了让python将其作为包对待， 它必须包含名
为__init__.py的文件， 如果将它当作普通模块导入的话， 文件的内容就是包的内容，
简单的包布局：
-/python/
-/python/drawing/
-/python/drawing/__init__.py
-/python/drawing/colors.py
-/python/drawing/shapes.py
模块中有什么:
>>> import copy
>>>dir(copy)
>>>[n for n in dir(copy) if not n.startswith('_')]
__all__ = ['Error', 'copy'] 它定义了模块的共有接口
from copt import * 只能导入__all__变量中的函数
阅读python源代码:
>>> print copy.__file___
vi 打开该文件, 只查看相应的.py即可
比较好用的标准模块：
__sys模块__
函数/变量 --- 描述

14. File: /home/aaron/Desktop/a Page 14 of 18
argv 命令行参数，包括脚本名称
exit([arg])
modules --- 变量， 将模块名映射到实际存在的模块中，它只应用于目前的导入
path --- you know
platform --- 平台的名称
stdin ---类文件流对象
stdout
stderr
eg: sys.argv[0],
__os模块__
os模块为你提供了访问多个操作系统服务的功能。os模块的内容很多。os.path os模块很有用的子模块
函数/变量 --- 描述
environ --- 对环境变量进行映射
system(cmd) --- 在子shell中执行操作系统命令
sep --- 路径中的分隔符
pathsep --- 分隔路径的分隔符
linesep --- 行分隔符(n, r or rn)
urandom(n) --- 返回n字节的加密强随机数据
fileinput模块让你能够很轻松的便利文本文件的所有行，
如果通过以下方式调用脚本：
python some_script.py file1.txt file2.txt file3.txt
这样就可以依次对file1.txt file2.txt file3.txt文件中的所有行进行遍历了
fileinput模块中最重要的函数为input, 它会返回能够用于for循环遍历的对象
函数 --- 描述
input
filename() 返回当前文件的名称
lineno() 返回当前累计的行数
isfirstline() 返回当前文件的行数
isstdin() 检查座后一行是否来自sys.stdin
nextfile() 关闭当前文件，移动到 下一个文件
close() 关闭序列
为python脚本添加编号
#numberlines.py
import fileinput
for line in fileinput.input(inplace = True):
line = line.rstrip()
num = fileinput.lineno()
print '%s-40s #%2i' % (line, num)
python numberlines.py numberlines.py
__集合 堆和双端队列__

15. File: /home/aaron/Desktop/a Page 15 of 18
__time模块__
time模块所包含的函数能够实现以下功能: 获得当前的时间， 操作时间和日期， 从字符串读取时间， 以及格
式化时间为字符串.
time.asctime() 将当前时间格式化为字符串
localtime([secs]) 将秒数转换为日期元组， 一本地时间为准
mktime(tuple) 将时间元组转换为本地时间
sleep(secs)
strptime() 将字符串解析为时间元组
time() 获取当前时间/usr/lib64/python2.7/copy.pyc
__random模块__
如果需要真的随机性，应该使用os模块的urandom函数
random() 返回[0,1)之间的随机数
getrandbits(n)
uniform(a, b) 返回[a, b)之间的随机数
randrange(start, stop, step) 随机整数
choice(seq) 从序列seq 中返回随意元素
sample(seq, n) 从序列seq中选择n个随机且独立的元素
__re模块__
re模块包含对正则表达式的支持
其他模块
functools, difflib, hashlib, csv, timeit, profile ,trace.
timeit是衡量代码片段运行时间的工具， 它有很多神秘的功能， 你应该用它来代替time模块进行性能测试
logging 这个模块提供了一组标准的工具， 以便让开发人员管理一个或多个核心的日志文件， 同时还对日志
信息提供了一组标准的工具， 以便让开发人员管理一个或多个核心的日志文件，同时还对日志信息提供了多
层次的优先级
cmd 这个模块可以编写命令行解释器，就像Python的交互式解释器一样， 你可以自定义命令， 以便让用户能
够通过提示符来执行， 也许你还能将它作为程序的用户界面
略
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2013-06-21T14:56:27+08:00
====== 第十一章 ======
Created Friday 21 June 2013
=== 文件和素材 ===

16. File: /home/aaron/Desktop/a Page 16 of 18
open函数返回一个文件对象
>>> f = open(r'c:textfomefile.txt')
如果要向文件内写内容， 则必须提供一个模式参数来显示声明
mode: r w, b, a, +(读写模式)
from __future__ import with_statement
f = open(filename)
while True:
line = f.readline()
if not line:break
process(line)
f.close()
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2013-06-21T15:38:20+08:00
====== 第十二章 ======
Created Friday 21 June 2013
图形用户界面 -----good
我选择wxPython
编写wxPython程序的方法很多， 但不可避免的事情是创建应用程序对象， 基本的应用程序对象叫做：
ex.App, 它负责幕后所有的初始化.
wx框架中的部件都是由它们的父部作为构造函数的第一个参数创建的， 如果正在创建一个单独的
窗口， 就不需要考虑父部件， 使用None即可.
使用pos和size可以设置按钮的位置和尺寸
文本控件 ----
每个组件的位置和大小都是显示设定的， 但是没有明确在窗口大小变化的时候他们的行为是什么， 指定行
为的方法很多， 在wx内进行布局的最简单方法是使用尺寸器， 最容易适应的工具是：wx.BoxSizer
在GUI术语中， 用户执行的动作 叫做事件， 你需要让程序注意这些事件 并且作出反应。可以将函数绑定到
所涉及的时间可能发生的组件上达到这个效果
wxPython是Python的GUI工具包
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2013-06-21T16:41:05+08:00
====== 第十三章 ======
Created Friday 21 June 2013
略

17. File: /home/aaron/Desktop/a Page 17 of 18
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2013-06-21T16:44:36+08:00
====== 第十四章 ======
Created Friday 21 June 2013
网络编程
常用模块: socket模块(套节字：socket)，
套节字包括两个： 服务器套节字和客户机套节字， 创建一个服务器套节字后， 让它等待连接。 这样它就
在某个网络地址处监听
创建客户端套节子通常比处理服务器端套节子容易， 因为服务器必须准备随时处理客户端的连接， 同时还
要处理多个连接， 而客户机只是简单地连接完成事务，断开连接
一个套节子就是一个socket模块中的socket类的实例。三个参数：地址簇 默认：socket.AF_INET，流 默认：
socket.SOCK_STREAM，协议 默认 0
accept 开始监听客户端的连接， 这个方法会阻塞(等待)直到客户端连接， 然后该方法就返回一个格式为
(client, address)的元组， client是客户端套节子， address 是一个前面解释过的地址
在能使用的各种网络工作库中， 功能最去强大的是urllib和urllib2他们能让通过网络访问文件， 就像那些文
件存在于你的电脑上一样， 通过一个简单的函数调用， 几乎可以把任何URL所指向的东西用做程序的输入,
这两个模块的功能都差不多， 但urllib2更好一些。
1. 打开远程文件
>>> from urllib import urlopen
>>> webpage = urlopen('http://www.python.org'）
如果在线， 变量webpage现在应该包含一个链接到http://www.python.org网页的类文件对象
urlopen 返回的类文件对象支持close, read, readline, readlines, 当然也支持迭代
假设想要提取在前面打开的python页中"About“链接的(相对)URL, 那么就可以用正则表达式来实现:
>>> import re
>>> text = webpage.read()
>>> m = re.search('<a href="([^"]+)" .*?>about</a>'., text, re.IGNORECASE)
>>> m.grout(1)
'/about/'
一个小型服务器：
import socket
s = socket.socket() #info object
#host = socket.gethostname()
host = "127.0.0.1"
port = 1234
s.bind((host,port))
s.listen(5) #the max connect number
while True:
c, addr = s.accept()
print 'Got connection from', addr
c.send('Thank you for connecting!!!!')

18. File: /home/aaron/Desktop/a Page 18 of 18
c.close()
一个小型客户机:
import socket
s = socket.socket()
#host = socket.gethostname()
host = "127.0.0.1"
port = 1234
s.connect((host, port))
print s.recv(1024)
SocketServer和它们的朋友们
SocketServer包含了4个基本的类：针对TCP套节子流的TCPServer;针对UDP数据报套节子的UDPServer以及针对性
不强的UnixStreamServer和UnixDatagramServer.
为了写一个使用SocketServer框架的服务器， 大部分代码会在一个请求处理程序中， 每当服务器收到一个请
求时， 就会实例化一个请求处理程序，并且它的各种处理方法会在处理请求时被调用.
一个基于SocketServer的小型服务器:
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2013-06-22T08:47:44+08:00
====== 第十五章 ======
Created Saturday 22 June 2013
屏幕抓取
XHTML是HTML最新的方言， 是XML的一种形式
对于包含正确切有效的XHTML的网页而言， 解析的工作很简单。问题在于旧版的HTML的方言较为随意.
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2013-06-24T11:16:11+08:00
====== 第十六章 ======
Created Monday 24 June 2013