PyExcelerator是一个第三方库，用来处理Excel文件。它的优点是：

简单易用，上手快。

写操作很方便，适合用来生成Excel文件记录数据。

不需要WinCOM支持，没装Office也 可以生成Excel表格

当然，PyExcelerator也是有缺点的，它所提供的读写操作方式相对简单，要对已有的Excel文件进行修改，就显得比较麻烦了。

如果要对已有的Excel表格进行较复杂的修改操作，选择PyExcelerator就不太合适了，这时候可以试试另外的方法。比如使用pywin32通过WinCOM来操作Excel表格，或者使用xlrd。

PyExcelerator的官方主页是http://sourceforge.net/projects/pyexcelerator，程序包中并没有太多的教程文档，不过包含了一些简单的示范操作的小例子，如果需要更详细的信息，就只能读源代码了。

一。初始pyExcelerator

     pyExcelerator是一个基于python的可以读写excel文件的产品。和xlrd相比，pyExcelrator的主要特点在于可以对excel文件进行写操作。但是在读取数据方面，功能就没有xlrd强大了。

　　pyExcelerator只能提供关于表单内容的基础数据，对于表单行数、列数、单元格数据类型等详细信息都没有提供访问接口。因此开发人员必须了解表单的具体结构，才对表单中的数据进行正确的分析转换。

　　将pyExcelerator产品包（pyexcelerator-0.6.3a.tgz）上传到服务器上之后解压缩，然后在产品目录下键入如下命令：

     # python setup.py install







在命令行中，你将看到一连串的running，creating，copying，byte—compiling命令结果，吧啦吧啦。。。



最后一行出现

Writing C:/Python26/Lib/site-packages/pyExcelerator-0.6.4.1-py2.6.egg-info



说明已经将插件安装到你的python环境中了，至此安装完成。



这里提一个小例子：

from pyExcelerator import *



w = Workbook() #创建一个工作簿



ws = w.add_sheet('Hey, Hades') #创建一个工作表



ws.write(0,0,'bit') #在1行1列写入bit



ws.write(0,1,'huang') #在1行2列写入huang



ws.write(1,0,'xuan') #在2行1列写入xuan



w.save('mini.xls') #保存

http://blog.csdn.net/suofiya2008/article/details/6284208

有一万年没来这儿写blog了，今天等着发版，抽空来写点东西吧。

python有很多模块都是用来操作excel的，比如xlrd，xlwt，pyExcelerator。用着很方便，但是问题是，只能支持到 excel2003。虽然一般的应用其实足够了，但是如果遇到了导出大量数据（超过65535条）的需求时，excel2003就不够用了。所以我就只好 去找一个能支持excel2007的模块。

google了一下，发现了这个openpyxl，不过网上也没什么中文的文档可以看，于是就自己琢磨琢磨。

I.安装

openpyxl的最新版本是1.5.0 下载地址 http://pypi.python.org/pypi/openpyxl/1.5.0

需求python的版本是2.6+  ，也就是说，如果centOS系统的机器想用，那得升级系统的python。。。

安装就是解压缩，然后cd到目录，然后

python setup.py install

你懂的~

 II.读取excel2007文件

 注意的是ws.cell()方法，支持的参数有两种，cell（ coordinate=None , row=None , column=None）

coordinate坐标，eg  ws.cell("B1")

row 和 column 是行和列 ，都是从0开始

还有，如果想取得格里的值，得用ws.cell("A1").value 取到，如果用过xlrd，因为写法差不多，可能就会忘记加value了。

III.写入excel2007

 注意的地方：

# col是用列号x为参数，调用了这个模块的get_column_letter方法算出来的字母，这个比较蛋疼。

    col = get_column_letter(x)

#在为数据格赋值的时候，注意写的格式：要不会有各种不靠谱的问题出现（这个是用坐标的方式写的，其实用row ，col的方式可能没那么麻烦）

    ws.cell( '%s%s'%(col, i) ).value = '%s' % (record[x-1])

关于该模块的API  可以查询官方文档   http://packages.python.org/openpyxl/api.html

总体来说，这个模块还是挺方便的，但是问题就是在对于python的版本有一定要求，如果在centOs上用，可能会有些问题。

本文只是简单的写了下使用的方法，之后格式超链接神马的之后再填上~

转载：http://www.cnblogs.com/sding/archive/2011/11/12/2246675.html

最近对Python的开发又来了兴趣，对于Python的开发一直停留在一个表面层的认识，玩的部分比较大。

Python的入手简单，语法让人爱不释手，在网络通信方面自带有成熟的类库，还有第三方开发的开源包。

在GUI的开发上，Python自身带有TKinter库，还有第三方的库 (比如wxPython, Qt)

今天就来简单介绍下wxPython开发的环境搭建与示例

开发环境搭建采用wxFormBuilder + uiPad + wxPython，按照顺序进行安装

Python 2.6 下载地址：http://www.python.org/download/releases/2.6.7/

wxPython 2.8 下载地址：http://www.wxpython.org/download.php#stable

wxFormBuilder 3.2 beta 下载地址：http://sourceforge.net/projects/wxformbuilder/

uiPad 4.0 下载地址：http://www.onlinedown.net/soft/101104.htm

Python GUI程式的开发步骤

1  wxFormBuilder 的界面设计过程

这里不再详述，可以BAIDU下wxPython的界面设计方法

2 界面设计完成后，接下来对界面上的BUTTON事件进行响应

如下图所示，产生响应事件代码

3 事件映射结束后，复制Python 代码到py文件

4 用UliPad编辑Py文件

在py文件末加入app的初始化代码,并在相应的事件中，加入响应代码即可。

1 class App(wx.App): 2     def OnInit(self): 3         frame = MyFrame1(None)   ##这里为我们生成GUI的Frame类名 4         frame.Show() 5         return True 6  7 app = App() 8      9 app.MainLoop()

5 运行py文件

第一个wxPython的界面程序到这里就完成，有兴趣可以再进行深入研究。

有关win32 api 大全
有关消息的解释，还有一篇文章解释的非常详细：http://blog.csdn.net/mengde666/article/details/4036398

前些日子，由于需要，用python写了个小插件，通过win32api 访问外部程序的窗口 并且做些小操作。

因为原来对win32api 不怎么熟悉 所以只好求救。群里有个QQ：32034767 唐骁勇tsy_007@163.com

这小伙子不错 心热人善

动手之前要选对好工具。（既然是基于WIN32api 当然要用微软的专用的spyxx.exe，上手相当简单。比较专业 ，能查出当前桌面上所有的窗口句柄和类型。VC的那个绿色版的 spy++效果不强（Au3Info.exe也一样），无法追踪多级子窗口。 下面是简易代码：（实际上就是用钩子原理 网络上也可以找到）

import win32ui,win32con,pyHook,pythoncom，win32gui ,wx
        def hookhandle(event):
            
            if event.KeyID==9:#tab键值
                try:
                    pwin=win32gui.FindWindow('AfxMDIFrame70',None)#主窗口 AfxMDIFrame70就是你用#spyxx.exe查找到的窗口类名
                    pwin1=win32gui.FindWindowEx(pwin,None,'MDIClient',None)
                    pwin2=win32gui.FindWindowEx(pwin1,None,'AfxFrameOrView70',None)
                    pwin3=win32gui.FindWindowEx(pwin2,None,"AfxOleControl70",None)
                    pwin4=win32gui.FindWindowEx(pwin3,None,None,"PatientCardControl Frame")#可以根据窗口#的标题名称查找 标题名称一般外接程序是不变的 而类名有时是变化的 比如机器重启 关闭等 
                    pwin5=win32gui.FindWindowEx(pwin4,None,"AfxMDIFrame70",None)
                    pwin6=win32gui.FindWindowEx(pwin5,None,"AfxWnd70",None)
                    pwin7=win32gui.FindWindowEx(pwin6,None,"#32770",None)

                    textbox=pwin7.GetDlgItem(222)#获取控件的ID
                    textbox2=pwin7.GetDlgItem(224)

                    buf='0x0'*1024 
                    buf2='0x0'*1024
                    textbox.SendMessage(win32con.WM_SETTEXT,"")#先清空控件内容
                    textbox2.SendMessage(win32con.WM_SETTEXT,"")

                    oldlen=textbox.SendMessage(win32con.WM_GETTEXT,buf)
                    oldlen2=textbox2.SendMessage(win32con.WM_GETTEXT,buf2)

                    textbox.SendMessage(win32con.WM_SETTEXT,buf[0:oldlen]+str(blh))#发送消息 注意不能##用%s 替换 所以一般需要全局变量 来替换
                    textbox2.SendMessage(win32con.WM_SETTEXT,buf2[0:oldlen]+str(name))
                except:
                    wx.LogMessage('没有发现可用的窗口！请确保程序已经运行')

        hm = pyHook.HookManager()#初始实例
        hm.KeyDown=hookhandle
        hm.HookKeyboard()
        pythoncom.PumpMessages(5000)#据说是winctype的新功能 延迟吧 具体什么也不清楚 
        hm.UnhookKeyboard()#释放键盘捕捉 好像效果不明显
        #for i in range (0,40):
            #win32api.Sleep(20)
            #if win32ui.PumpWaitingMessages(0,-1):
        win32api.PostQuitMessage(0)# 退出监控消息 很关键 必须配合sys.setrecursionlimit(4000)使用效果##才明显 不然的话 程序无法退出。
               #raise exceptions.SystemExit

    def OnClose(self, event):
        sys.setrecursionlimit(4000)#相当关键
        self.Close(True)
        self.Destroy()

OperationalError: Could not decode to UTF-8 column 'shouji_lanshouyuan' with text '国际2部 邬长春'

解决方案：

conn = sqlite3.connection(" ... ")
conn.text_factory = str

解决问题方案来源：http://bbs.csdn.net/topics/250055755

设置python使用什么类型来处理sqlite3的text类型，默认是unicode，所以才会产生
OperationalError: Could not decode to UTF-8 column 'name' with text '国内其他' 
这个错误

因为从数据库中取出数据时，是gbk编码（因为你上次存进去的是gbk）
conn.text_factory的默认值是unicode，python会尝试将text类型的字段转换成unicode，就产生了错误

附：sqlite3的row操作：

Row对象的详细介绍

class sqlite3.Row

A Row instance serves as a highly optimized row_factory for Connection objects. It tries to mimic a tuple in most of its features.

It supports mapping access by column name and index, iteration, representation, equality testing and len().

If two Row objects have exactly the same columns and their members are equal, they compare equal.

Changed in version 2.6: Added iteration and equality (hashability).

keys()

This method returns a tuple of column names. Immediately after a query, it is the first member of each tuple in Cursor.description.

New in version 2.6.

    下面举例说明

cx.row_factory = sqlite3.Row

c = cx.cursor()

c.execute('select * from catalog')

 <sqlite3.Cursor object at 0x05666680>

r = c.fetchone()

type(r)
<type 'sqlite3.Row'>

r
<sqlite3.Row object at 0x05348980>

print r
(0, 10, u'\u9c7c', u'Yu')

len(r)
4

r[2]            #使用索引查询
u'\u9c7c'

r.keys()
['id', 'pid', 'name', 'nickname']

 使用列的关键词查询

In [43]: r['id']

Out[43]: 0

In [44]: r['name']

Out[44]: u'\u9c7c'

    def getTdOfTableContains(self,table,conText):

        #add 20130607 by sho

        #find first td in table and td's innertext contains conText

        for cell in table.cells:

            if conText in cell.innertext:

                return cell

        return None

    def getTrOfTableContains(self,table,conText):

        #add 20130607 by sho

        #find first tr in table and tr's cells contains conText

        td=self.getTdOfTableContains(table,conText)

        if td:

            return self.getElementParent(td)

        else:

            return None

测试代码：

*** 远程解释器再初始化了  ***

>>> from PAM30 import PAMIE

>>> ie=PAMIE("http://1.1.1.1/query/itemQueryAction.do?method=jumpToSingleItemTrackQuery")

>>> ie.setTextBox("itemno","1191590659011")

True

>>> ie.submitForm("itemQueryForm")

True

>>> tb4=ie.findElement("table","classname","table4")

>>> tr_sj=ie.getTrOfTableContains(tb4,u"收寄")

>>> print tr_sj.outerhtml

PAMIE是一套为Python写的用于Web自动化测试的工具，采用Win32COM的方式操作IE来实现。
pamie是个很好的操作IE的模块
用pamie来操作ie浏览器好方便啊，本来它就是一个IE测试自动化的东西，
这样，用pamie来抓取网页，自动提交表单很容易。

使用：
来测试一个最简单的例子：

from cPAMIE import PAMIE

ie = PAMIE()

ie.navigate("google.com")
ie.textBoxSet('q','python')
ie.buttonClick('btnG')
ie.linkClick('Python Programming Language -- Official Website')
ie.windowChange('Python Programming Language -- Official Website')
ie.windowFind('Python Programming Language -- Official Website')
ie.textBoxSet('q',"Automation")
ie.buttonClick('submit')

直接操作页面上的form元素，访问页面的文本信息，来判断用户登陆是否成功。

pamie中怎样处理中文标题的弹出对话框?
http://www.python-forum.org/pythonforum/viewtopic.php?f=17&t=3194 
http://markmail.org/message/u3ojkyj2ns7p3dn3#query:+page:1+mid:5wuwfctervph6tlv+state:results 
python：

import cPAMIE, cModalPopUp, winGuiAuto
import time

ie = cPAMIE.PAMIE()
wga = winGuiAuto

# 登录
ie.navigate('D:\\python\\WebDialogTest\\1.html')

#启动新的进程，自动点击"取消"
clickCancel = cModalPopUp.handlePopup("Confirm","取消")
clickCancel.popupName = "选择文件"
clickCancel.start()

ie.buttonClick("install")
time.sleep(1)

clickCancel.join() #进程结束

-------------------------------------------------------------------------------------------------------------------------------------

另外一篇介绍:

PAMIE 是一个很有意思的模块。它是一个实现IE自动化的模块。在此之前我使用过ClientCookie这个模块，它可以使用urllib2来通过程序访问页 面，并且很适合在需要cookie支持的环境中。不过，有些web的访问过程并不仅仅是下载文件这样的事情，有时是一系统的动作。PAMIE应该是一个更 直观，更简单的模拟手工输入的过程。不过，局限就是它只支持IE，在某些特殊情况下还是可以的。

使用它的话你需要安装win32all模块。

下面是它的readme 提供的一个简单示例：

import cPAMIE

ie= cPAMIE.PAMIE()

# Start Script:

ie.Navigate ('http://pamie.sourceforge.net/pamieform.html')
ie.SetTextBox('John','firstname',0)
ie.SetTextBox('Doe','lastname',0)
ie.SetTextBox('1020 State Street','Addline1',0)
ie.SetTextBox('Suite #16','Addline2',0)
ie.SetTextBox('San Mateo','city',0)
ie.SetListBox('CA','state',0)
ie.SetTextBox('90210','zip',0)

ie.ClickButton('Submit',0)

那 么在我们下载完这个模块之后，它是一个zip包。它没有做成安装模式，可以自行将cPAMIE.py拷贝到python安装目录下的lib子目录中即可。 上面的代码很简单，先导入cPAMIE模块，然后生成一个自动化对象ie。这时我们会看到程序自动打开一个ie窗口，我们的操作可以在这个ie窗口中看 到，执行的部分以黄底显示。

ie.Navigate()用来访问一个链接。
ie.SetTextBox()用来设置一个文本域的值。第一个参数为输入的值，第二个参数为对应的form表格的Input域的名字（这一点需要查看源码才知识），第三个是form的名字（示例为0表示下标）。
ie.SetListBox()用来设置列表框的值。
ie.ClickButton()用来模拟点击按钮。第一个参数是按钮的名字，第二个参数为0表示下标。

在PAMIE主页中写出了一些可用的其它的方法，如ClickLink()。它的第一个参数为链接对应的文本，如果是中文，转成unicode即可。如页面是GB2312，链接源码为：

<a href="http://xxx.com">汉字</a>

调用如下：

ie.ClickButton(unicode('汉字', 'cp936'))

在实际运行中可能不需要这样，只要参数是unicode编码即可。

同时如果你查看源码，还可以看到一些其它的方法：

Quit() -- 关闭打开的ie
GoBack() -- 后退
Refresh() -- 刷新

大家有兴趣可以试一试，一边操作一边就可以看到结果，很简单也很方便。

-------------------------------------------------------------------------------------------------------------------------------

第三个文章介绍

简单明了的Python,第三方提供的模块或称组件 module 等 也很简单明了的

下面是 一个 例子所列举的功能较全了 代码加注解...

# -*- coding: cp936 -*-
import sys

#我把cPAMIE等 pamie2.0里的所有文件放在了 如下路径的 名为pamie 的文件夹里了 加进sys.path方便import 出所有pamie文件夹里的 模块
#只要能import CPAMIE 这里的例子就可运行了呵呵
sys.path.append(r"F:\Python25\lib\site-packages\pamie")
import cPAMIE

#new 实例
ie= cPAMIE.PAMIE()

#打开目标网页

ie.navigate ('http://pamie.sourceforge.net/pamieform.html')

#注意下面所列的 第一个参数如 fistname 等 都是 网页源代码里的 input name="firstname"
#里找出来的,不能用 网页上看见的黑体字: "First Name:"
#填文本框
ie.textBoxSet('firstname','JustThisName')

ie.textBoxSet('lastname','Iamhere')

#先择下拉菜单:

ie.listBoxSelect('state',"MS")

#方形选择框:

ie.checkBoxSet('cxbx',1) #1 2 3 或 * 号等都是 "勾选"的意思 '' 空字符串代表取消选择

#圆形选择框: 英语是 radio 做过网页设计就容易知道这些元素的命名了
#这里选择 Jazz
ie.radioButtonSet("music","Jazz") # music是这个 选择列表的名字,从网页源代码里找出

#最后提交按钮

print "now 提交按钮,只要再Python解释器里输入下面这句就 提交 了"
#ie.buttonClick("Submit") 用来取代鼠标点击 方便多了

#源代码里是 input type="submit" name="Submit" 所以 第一个参数就是name的值"Submit"
#pamie是共分 大小写的

#ie.buttonClick("Submit")

#IE有自已的特性, 好像用 pamie 打开多个网页,都是加在同一个IE进程里的,不是一个网页一个进程

'''很多网页较复杂,有图片按钮, javaScript按钮 等的... 若是 图片类按钮
用 ie.buttonImageClick("submitRegister")

有些按钮是 鼠标点击后 会执行一个 javascript 来提交内容的 如源代码里内容是:
<input type="image" src="http://www.sit.com/member/images/register.gif " width="100" height="54" border="0"
onClick="javascript:submitMe();
就是说 点击 那个 叫做 register.gif的图片会 会执行 javascript:submitMe() 来提交页面...时 可用:

ie.javaScriptExecute("javascript:submitMe()")   来自动提交页面. 这类按钮 鼠标移上去后,IE左下角一般会出现 相应的

javascript:theFunction() 很容易找...

执行 带参数的 javascript function 也是可以的... ie.javaScriptExecute("javascript:submitMe('param')")
也可直接设置一个 网页里元素的值:
例如 网页源文件里 设置了 document.Form.id.value="string" 可用下面语句直接更改

ie.javaScriptExecute("javascript:document.Form.id.value='theValueYouWant'")

另外: pamie2.0 里有个 模块用来处理 简单的 弹出窗口 这类窗口的标题一般为: Microsoft Internet Explorer

import cModalPopUp

a=cModalPopUp.handlePopup('Confirm',"确定") #"第二个参数是 "确定",表示 弹出窗口的按钮上的 文字是 "确定"这二个字

如图:

执行:

a.run() 就可用程序来点击那个"弹出窗口"的"确定"按钮了...
可用多线程程序用一个线程来处理这类窗口就不妨碍主程序了...

另外 一个对 pamie 很有用的 填表类工具 : AiRoboForm.exe

安装好这个IE工具栏工具后,就可按一下"保存"如上图的"Save"按钮 保存网页表格,然后 鼠标移到 如上图 "Baidu"处停一点时间就出弹出一个子菜单 选择 "edit" 就可看到 那个页面的 表单的 所有名字了 就不用在 源代码里 辛苦的找那么多的 "第一个参数" 也就是说 不用自已找 文本框和列表框名称等了, 你可在那个打开了的 编缉器里看到所有的 要填的框的 "名字"了的只是显示的全是"小写"了, 需要在源文件里看一下第一个字母是否是大写等...pamie是 区分大小写的 AiRoboForm是不区分大小写的...

pamie2.0也有不足的地方:

下文是一个引自 http://yinxl.spaces.live.com/blog/cns!4626e4f8c0bfc0bc!172.entry 的 "扩展补丁".

让PAMIE能轻松控制一个新开的IE窗口

附录：网易注册程序代码

#coding:gbk
import cPAMIE
import time
import random
username = ''.join(random.sample('abcdefghijklmnopqrstuvwxyz0123456789',8))
password = '******'
zhanghao = '|'.join([username,password])
ie= cPAMIE.PAMIE()

#打开目标网页

ie.navigate ('http://reg.163.com/reg0.shtml')

#注意下面所列的 第一个参数如 fistname 等 都是 网页源代码里的 input name="firstname"
#里找出来的,不能用 网页上看见的黑体字: "First Name:"
#填文本框
ie.textBoxSet('username',username)

ie.textBoxSet('password','*****')
ie.textBoxSet('cpassword','*****')

#先择下拉菜单:

ie.listBoxSelect('question',unicode('我的自定义问题', 'cp936'))#注意此处编码转换 cp936 可以换成GBK
ie.textBoxSet('myQuestion','wodewentishishenme')
ie.textBoxSet('answer','wodoubuxihuan')
ie.textBoxSet('year','1986')
ie.listBoxSelect('month','6')
ie.listBoxSelect('day','22')
#方形选择框:

#ie.checkBoxSet('cxbx',1) #1 2 3 或 * 号等都是 "勾选"的意思 '' 空字符串代表取消选择

#圆形选择框: 英语是 radio 做过网页设计就容易知道这些元素的命名了
#这里选择 Jazz
ie.radioButtonSet("gender","1") # music是这个 选择列表的名字,从网页源代码里找出


#最后提交按钮

print "请输入验证码 然后提交"
#ie.buttonClick("Submit") #用来取代鼠标点击 方便多了

i = 0
while i<100:
    pass
    i = i+1
    if True == ie.findText(unicode('恭喜', 'gbk')):
       break

fp = open('163zhanghao.txt','a')
fp.write(zhanghao+'\n')
fp.close()
ie.quit()

循环注册

#coding:gbk
import cPAMIE
import time
import random
username = ''.join(random.sample('abcdefghijklmnopqrstuvwxyz0123456789',8))
password = 'wokao1'
zhanghao = '|'.join([username,password])
i = 0
while i<1000:
    ie= cPAMIE.PAMIE()
    ie.navigate ('https://passport.baidu.com/?reg')
    ie.textBoxSet('username',username)
    ie.textBoxSet('loginpass','*****')
    ie.textBoxSet('verifypass','*****')
    ie.radioButtonSet("sex","1") 
    ie.textBoxSet("email",username+'@msn.cn')
    i = 0
    while i<1000:
       pass
       i = i+1
       if True == ie.findText(unicode('恭喜', 'gbk')):
          break
    fp = open('163zhanghao.txt','a')
    fp.write(zhanghao+'\n')
    fp.close()
    ie.quit()
    i = i+1

__________________________________________________再补充一个：
import winGuiAuto
# 获取得的hwnd是一个列表
hwnd = winGuiAuto.findTopWindows("Windows Internet Explorer")
# 获取得的control_list是一个列表，每个元素又是一个列表，这个列表中第一个是句柄,第二个是文本，第三个是窗口类型
control_list=winGuiAuto.dumpWindow(hwnd[0])
for control_item in control_list:
if control_item[1]='OK':
# 单击确定OK
winGuiAuto.clickButton(control_item[0])

这里每个contrl item有三个成员，第一个是系统id号，第二个是显示出来的文字，第三个是类型，具体可以print出来看看。

在我们登录网页的时候，如果某账户刚刚登录，系统会有如下提示：

本文就是讲述如何用PAMIE处理这种POPUP window。主要是如何选择POPUP window以及点击上面的"OK"或者"Cancel"按钮。对弹出窗口的处理，主要都在winGuiAuto.py中。

import winGuiAuto
# 获取得的hwnd是一个列表
hwnd = winGuiAuto.findTopWindows("Windows Internet Explorer")
# 获取得的control_list是一个列表，每个元素又是一个列表，这个列表中第一个是句柄,第二个是文本，第三个是窗口类型
control_list=winGuiAuto.dumpWindow(hwnd[0])
for control_item in control_list:
if control_item[1]='OK':
# 单击确定OK
winGuiAuto.clickButton(control_item[0])

建议安装python2.5及以上版本，但不建议使用python3.0。

• __init__.py:暂时是空的，标识这个目录是一个python package。
• manage.py: Django的命令行工具集，使用方法：python manage.py ***
  
• settings.py: project 的配置文件
• urls.py: project的url路径管理配置文件

打开settings.py，在database节点下：

• ENGINE 数据库引擎名称，可以是'django.db.backends.postgresql_psycopg2'或 'django.db.backends.mysql' 或 'django.db.backends.sqlite3'

• NAME  数据库名称， 如果使用sqlite，这里就是db文件绝对路径，比如f:/temp/mysite/data.db

• USER 数据库用户名，sqlite不需要

• PASSWORD 密码，sqlite不需要

• HOST 数据库主机ip，sqlite不需要

建议使用sqlite。如果使用其他如PostgerSQL、MySQL等，在配置之前要确保先在数据库中已建立相关项目。

from django.db import models



class Poll(models.Model):



question = models.CharField(max_length=200)



pub_date = models.DateTimeField('date published')



class Choice(models.Model):



poll = models.ForeignKey(Poll)



choice = models.CharField(max_length=200)



votes = models.IntegerField()



这里有两个model，Poll和Choice，还存在一个one Poll to many Choice关系。



在setting.py 中将polls 加入到installed app 节点中，然后使用python manage.py syncdb 将在database中新建相应的tables。table name 分别是：



polls_poll,polls_choice。



当然还有其他一些manage command:

• python manage.py validate -- 校验model内容是否正确
  
• python manage.py sqlcustom polls -- 输出polls app中的model相关的sql相关语句
  
• python manage.py sqlclear polls -- 输出删除table的相关sql
• python manage.py sqlindexes polls -- 输出建立index的相关sql
• python manage.py sqlall polls -- 是sql, sqlcustom, and sqlindexes 输出内容的组合
  

6、使用django shell：



python manage.py shell



这个cmd背后做了两件事：一是将mysite2加入到sys.path中去；二是新建了DJANGO_SETTINGS_MODULE环境变量，可以引用settings.py中的配置内容。



接下来就可以测试了。

2008年7月21日

复杂的Unicode，疑惑的Python

>>> len("\N{MUSICAL SYMBOL G CLEF}")

2

>>> len("\N{MUSICAL SYMBOL G CLEF}")

1

high = ((X-0x10000)>>10)&0x3FF+0xD800

low = (X-0x10000)&0x3FF+0xDC00

时间： 1:27:00 上午 标签： encoding, python

在本文中，以'哈'来解释作示例解释所有的问题，“哈”的各种编码如下：

  1. UNICODE (UTF8-16)，C854；

  2． UTF-8，E59388；

  3． GBK，B9FE。

一、python中的str和unicode

一直以来，python中的中文编码就是一个极为头大的问题，经常抛出编码转换的异常，python中的str和unicode到底是一个什么东西呢？

在python中提到unicode，一般指的是unicode对象，例如'哈哈'的unicode对象为

u'\u54c8\u54c8'

而str，是一个字节数组，这个字节数组表示的是对unicode对象编码(可以是utf-8、gbk、cp936、GB2312)后的存储的格式。这里它仅仅是一个字节流，没有其它的含义，如果你想使这个字节流显示的内容有意义，就必须用正确的编码格式，解码显示。

例如：

对于unicode对象哈哈进行编码，编码成 一个utf-8编码的str－s_utf8,s_utf8就是是一个字节数组，存放的就是'\xe5\x93\x88\xe5\x93\x88'，但是这 仅仅是一个字节数组，如果你想将它通过print语句输出成哈哈，那你就失望了，为什么呢？

因为print语句它的实现是将要输出的内容 传送了操作系统，操作系统会根据系统的编码对输入的字节流进行编码，这就解释了为什么utf-8格式的字符串“哈哈”，输出的是“鍝堝搱”，因为 '\xe5\x93\x88\xe5\x93\x88'用GB2312去解释，其显示的出来就是“鍝堝搱”。这里再强调一下，str记录的是字节数组，只 是某种编码的存储格式，至于输出到文件或是打印出来是什么格式，完全取决于其解码的编码将它解码成什么样子。

这里再对print进行一点补充说明：当将一个unicode对象传给print时，在内部会将该unicode对象进行一次转换，转换成本地的默认编码（这仅是个人猜测）

二、str和unicode对象的转换

str和unicode对象的转换，通过encode和decode实现，具体使用如下：

将GBK'哈哈'转换成unicode，然后再转换成UTF8

三、Setdefaultencoding

如上图的演示代码所示：

当把s(gbk字符串)直接编码成utf-8的时候，将抛出异常，但是通过调用如下代码：

import sys

reload(sys)

sys.setdefaultencoding('gbk')

后就可以转换成功，为什么呢？在python中str和unicode在编码和解码过程中，如果将一个str直接编码成另一种编码，会先把str解码成unicode，采用的编码为默认编码，一般默认编码是anscii，所以在上面示例代码中第一次转换的时候会出错，当设定当前默认编码为'gbk'后，就不会出错了。

至于reload(sys)是因为Python2.5 初始化后会删除 sys.setdefaultencoding 这个方法，我们需要重新载入。

四、操作不同文件的编码格式的文件

建立一个文件test.txt，文件格式用ANSI，内容为:

abc中文

用python来读取

# coding=gbk

print open("Test.txt").read()

结果：abc中文

把文件格式改成UTF-8：

结果：abc涓枃

显然，这里需要解码：

# coding=gbk

import codecs

print open("Test.txt").read().decode("utf-8")

结果：abc中文

上面的test.txt我是用Editplus来编辑的，但当我用Windows自带的记事本编辑并存成UTF-8格式时，

运行时报错：

Traceback (most recent call last):

File "ChineseTest.py", line 3, in 

print open("Test.txt").read().decode("utf-8")

UnicodeEncodeError: 'gbk' codec can't encode character u'\ufeff' in position 0: illegal multibyte sequence

原来，某些软件，如notepad，在保存一个以UTF-8编码的文件时，会在文件开始的地方插入三个不可见的字符（0xEF 0xBB 0xBF，即BOM）。

因此我们在读取时需要自己去掉这些字符，python中的codecs module定义了这个常量：

# coding=gbk

import codecs

data = open("Test.txt").read()

if data[:3] == codecs.BOM_UTF8:

data = data[3:]

print data.decode("utf-8")

结果：abc中文

五、文件的编码格式和编码声明的作用

源文件的编码格式对字符串的声明有什么作用呢？这个问题困扰一直困扰了我好久，现在终于有点眉目了，文件的编码格式决定了在该源文件中声明的字符串的编码格式，例如：

str = '哈哈'

print repr(str)

a.如果文件格式为utf-8，则str的值为：'\xe5\x93\x88\xe5\x93\x88'（哈哈的utf-8编码）

b.如果文件格式为gbk，则str的值为：'\xb9\xfe\xb9\xfe'（哈哈的gbk编码）

在第一节已经说过，python中的字符串， 只是一个字节数组，所以当把a情况的str输出到gbk编码的控制台时，就将显示为乱码：鍝堝搱；而当把b情况下的str输出utf-8编码的控制台时， 也将显示乱码的问题，是什么也没有，也许'\xb9\xfe\xb9\xfe'用utf-8解码显示，就是空白吧。>_<

说完文件格式，现在来谈谈编码声明的作用吧，每个文件在最上面的地方，都会用# coding=gbk 类似的语句声明一下编码，但是这个声明到底有什么用呢？到止前为止，我觉得它的作用也就是三个：

1. 声明源文件中将出现非ascii编码，通常也就是中文；
2. 在高级的IDE中，IDE会将你的文件格式保存成你指定编码格式。
3. 决定源码中类似于u'哈'这类声明的将‘哈’解码成unicode所用的编码格式，也是一个比较容易让人迷惑的地方，看示例：

ss = u'哈哈'

print repr(ss)

print 'ss:%s' % ss

将这个些代码保存成一个utf-8文本，运行，你认为会输出什么呢？大家第一感觉肯定输出的肯定是：

u'\u54c8\u54c8'

ss:哈哈

但是实际上输出是：

u'\u935d\u581d\u6431'

ss:鍝堝搱

为什么会这样，这时候，就是编码声明在作怪了，在运行ss = u'哈哈'的时候，整个过程可以分为以下几步：

1) 获取'哈哈'的编码：由文件编码格式确定，为'\xe5\x93\x88\xe5\x93\x88'（哈哈的utf-8编码形式）

2) 转成 unicode编码的时候，在这个转换的过程中，对于'\xe5\x93\x88\xe5\x93\x88'的解码，不是用utf-8解码，而是用声明编 码处指定的编码GBK，将'\xe5\x93\x88\xe5\x93\x88'按GBK解码，得到就是''鍝堝搱''，这三个字的unicode编码就 是u'\u935d\u581d\u6431'，至止可以解释为什么print repr(ss)输出的是u'\u935d\u581d\u6431' 了。

好了，这里有点绕，我们来分析下一个示例：

#-*- coding:utf-8 -*-

ss = u'哈哈'

print repr(ss)

print 'ss:%s' % ss

将这个示例这次保存成GBK编码形式，运行结果，竟然是：

UnicodeDecodeError: 'utf8' codec can't decode byte 0xb9 in position 0: unexpected code byte

这里为什么会有utf8解码错误呢？想想上个 示例也明白了，转换第一步，因为文件编码是GBK，得到的是'哈哈'编码是GBK的编码'\xb9\xfe\xb9\xfe'，当进行第二步，转换成 unicode的时候，会用UTF8对'\xb9\xfe\xb9\xfe'进行解码，而大家查utf-8的编码表会发现，utf8编码表（关于UTF- 8解释可参见字符编码笔记：ASCII、UTF-8、UNICODE）中根本不存在，所以会报上述错误。

字符编码是计算机技术的基石，想要熟练使用计算机，就必须懂得一点字符编码的知识。

1. ASCII码

我们知道，在计算机内部，所有的信息最终都表示为一个二进制的字符串。每一个二进制位（bit）有0和1两种状态，因此八个二进制位就可以组合出 256种状态，这被称为一个字节（byte）。也就是说，一个字节一共可以用来表示256种不同的状态，每一个状态对应一个符号，就是256个符号，从 0000000到11111111。

上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码，一直沿用至今。

ASCII码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0。

2、非ASCII编码

英语用128个符号编码就够了，但是用来表示其他语言，128个符号是不够的。比如，在法语中，字母上方有注音符号，它就无法用ASCII码表示。 于是，一些欧洲国家就决定，利用字节中闲置的最高位编入新的符号。比如，法语中的é的编码为130（二进制10000010）。这样一来，这些欧洲国家使 用的编码体系，可以表示最多256个符号。

但是，这里又出现了新的问题。不同的国家有不同的字母，因此，哪怕它们都使用256个符号的编码方式，代表的字母却不一样。比如，130在法语编码 中代表了é，在希伯来语编码中却代表了字母Gimel (ג)，在俄语编码中又会代表另一个符号。但是不管怎样，所有这些编码方式中，0—127表示的符号是一样的，不一样的只是128—255的这一段。

至于亚洲国家的文字，使用的符号就更多了，汉字就多达10万左右。一个字节只能表示256种符号，肯定是不够的，就必须使用多个字节表达一个符号。 比如，简体中文常见的编码方式是GB2312，使用两个字节表示一个汉字，所以理论上最多可以表示256x256=65536个符号。

中文编码的问题需要专文讨论，这篇笔记不涉及。这里只指出，虽然都是用多个字节表示一个符号，但是GB类的汉字编码与后文的Unicode和UTF-8是毫无关系的。

3.Unicode

正如上一节所说，世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码。为什么电子邮件常常出现乱码？就是因为发信人和收信人使用的编码方式不一样。

可以想象，如果有一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，那么乱码问题就会消失。这就是Unicode，就像它的名字都表示的，这是一种所有符号的编码。

Unicode当然是一个很大的集合，现在的规模可以容纳100多万个符号。每个符号的编码都不一样，比如，U+0639表示阿拉伯字母 Ain，U+0041表示英语的大写字母A，U+4E25表示汉字“严”。具体的符号对应表，可以查询unicode.org，或者专门的汉字对应表。

4. Unicode的问题

需要注意的是，Unicode只是一个符号集，它只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储。

比如，汉字“严”的unicode是十六进制数4E25，转换成二进制数足足有15位（100111000100101），也就是说这个符号的表示至少需要2个字节。表示其他更大的符号，可能需要3个字节或者4个字节，甚至更多。

这里就有两个严重的问题，第一个问题是，如何才能区别unicode和ascii？计算机怎么知道三个字节表示一个符号，而不是分别表示三个符号 呢？第二个问题是，我们已经知道，英文字母只用一个字节表示就够了，如果unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必 然有二到三个字节是0，这对于存储来说是极大的浪费，文本文件的大小会因此大出二三倍，这是无法接受的。

它们造成的结果是：1）出现了unicode的多种存储方式，也就是说有许多种不同的二进制格式，可以用来表示unicode。2）unicode在很长一段时间内无法推广，直到互联网的出现。

5.UTF-8

互联网的普及，强烈要求出现一种统一的编码方式。UTF-8就是在互联网上使用最广的一种unicode的实现方式。其他实现方式还包括UTF-16和UTF-32，不过在互联网上基本不用。重复一遍，这里的关系是，UTF-8是Unicode的实现方式之一。

UTF-8最大的一个特点，就是它是一种变长的编码方式。它可以使用1~4个字节表示一个符号，根据不同的符号而变化字节长度。

UTF-8的编码规则很简单，只有二条：

1）对于单字节的符号，字节的第一位设为0，后面7位为这个符号的unicode码。因此对于英语字母，UTF-8编码和ASCII码是相同的。

2）对于n字节的符号（n>1），第一个字节的前n位都设为1，第n+1位设为0，后面字节的前两位一律设为10。剩下的没有提及的二进制位，全部为这个符号的unicode码。

下表总结了编码规则，字母x表示可用编码的位。

下面，还是以汉字“严”为例，演示如何实现UTF-8编码。

已知“严”的unicode是4E25（100111000100101），根据上表，可以发现4E25处在第三行的范围内（0000 0800-0000 FFFF），因此“严”的UTF-8编码需要三个字节，即格式是“1110xxxx 10xxxxxx 10xxxxxx”。然后，从“严”的最后一个二进制位开始，依次从后向前填入格式中的x，多出的位补0。这样就得到了，“严”的UTF-8编码是 “11100100 10111000 10100101”，转换成十六进制就是E4B8A5。

6. Unicode与UTF-8之间的转换

通过上一节的例子，可以看到“严”的Unicode码是4E25，UTF-8编码是E4B8A5，两者是不一样的。它们之间的转换可以通过程序实现。

在Windows平台下，有一个最简单的转化方法，就是使用内置的记事本小程序Notepad.exe。打开文件后，点击“文件”菜单中的“另存为”命令，会跳出一个对话框，在最底部有一个“编码”的下拉条。

里面有四个选项：ANSI，Unicode，Unicode big endian 和 UTF-8。

1）ANSI是默认的编码方式。对于英文文件是ASCII编码，对于简体中文文件是GB2312编码（只针对Windows简体中文版，如果是繁体中文版会采用Big5码）。

2）Unicode编码指的是UCS-2编码方式，即直接用两个字节存入字符的Unicode码。这个选项用的little endian格式。

3）Unicode big endian编码与上一个选项相对应。我在下一节会解释little endian和big endian的涵义。

4）UTF-8编码，也就是上一节谈到的编码方法。

选择完”编码方式“后，点击”保存“按钮，文件的编码方式就立刻转换好了。

7. Little endian和Big endian

上一节已经提到，Unicode码可以采用UCS-2格式直接存储。以汉字”严“为例，Unicode码是4E25，需要用两个字节存储，一个字节 是4E，另一个字节是25。存储的时候，4E在前，25在后，就是Big endian方式；25在前，4E在后，就是Little endian方式。

这两个古怪的名称来自英国作家斯威夫特的《格列佛游记》。在该书中，小人国里爆发了内战，战争起因是人们争论，吃鸡蛋时究竟是从大头(Big- Endian)敲开还是从小头(Little-Endian)敲开。为了这件事情，前后爆发了六次战争，一个皇帝送了命，另一个皇帝丢了王位。

因此，第一个字节在前，就是”大头方式“（Big endian），第二个字节在前就是”小头方式“（Little endian）。

那么很自然的，就会出现一个问题：计算机怎么知道某一个文件到底采用哪一种方式编码？

Unicode规范中定义，每一个文件的最前面分别加入一个表示编码顺序的字符，这个字符的名字叫做”零宽度非换行空格“（ZERO WIDTH NO-BREAK SPACE），用FEFF表示。这正好是两个字节，而且FF比FE大1。

如果一个文本文件的头两个字节是FE FF，就表示该文件采用大头方式；如果头两个字节是FF FE，就表示该文件采用小头方式。

8. 实例

下面，举一个实例。

打开”记事本“程序Notepad.exe，新建一个文本文件，内容就是一个”严“字，依次采用ANSI，Unicode，Unicode big endian 和 UTF-8编码方式保存。

然后，用文本编辑软件UltraEdit中的”十六进制功能“，观察该文件的内部编码方式。

1）ANSI：文件的编码就是两个字节“D1 CF”，这正是“严”的GB2312编码，这也暗示GB2312是采用大头方式存储的。

2）Unicode：编码是四个字节“FF FE 25 4E”，其中“FF FE”表明是小头方式存储，真正的编码是4E25。

3）Unicode big endian：编码是四个字节“FE FF 4E 25”，其中“FE FF”表明是大头方式存储。

4）UTF-8：编码是六个字节“EF BB BF E4 B8 A5”，前三个字节“EF BB BF”表示这是UTF-8编码，后三个“E4B8A5”就是“严”的具体编码，它的存储顺序与编码顺序是一致的。

在我开始设计系统的时候，我会花去很多时间去设计命名，因为好的命名和好的设计是分不开的。

In the beginning was the Word, and the Word was with God, and the Word was God
太初有道。道与神同在，道就是神。 (约翰福音第一章，第一节)

在设计过程中给类，方法和函数好的命名会带来好的设计，虽然这不是一定成立，但是如果坏的命名那一定不会给你带来好的设计。在设计过程，如果你发现 你很难命名某一个模块，某个方法时，可能你真正遇到的问题不是难命名的问题，而是这个设计是否真的合理，你或许应该花更多的时间来重新设计一下你的模块。【无语，我就经常犯，功力不够呀】

好的命名不仅会带来好的设计，好的命名还提高了程序的可读性，降低代码维护的成本。另一方面，如果糟糕的命名会给代码带来一堵无形的墙，让你必须深入代码去研究代码具有的行为，增加你理解代码的时间。

为此我总结了几条关于命名的指导原则，希望这几条原则能为你的命名设计带来帮助，我使用的是C++的语法，当然这些原则也很容易扩展到其他语言中去。

类型命名(类，接口，和结构)

名字应该尽量采用名词
Bad:           Happy
Good:          Happiness

不要使用类似名字空间的前缀
Bad:           SystemOnlineMessage
Good:          System::Online:Message


形容词不要用太多，能描述清楚就行
Bad:           IAbstractFactoryPatternBase
Good:          IFactory


在类型中不要使用Manager 或则 Helper 或则其他没意义的单词
如果你一定要在一个类型上加上Manager或Helper，那么这个类型要么就是命名的非常糟糕，要么就是设计的非常糟糕，如果是后则，那么这个类型就应该管理manage和帮助help一下自己了。
Bad:           ConnectionManager
               XmlHelper
Good:          Connection
               XmlDocument, XmlNode, etc.


如果某个类不能通过简单的命名来描述它具有的功能，可以考虑用类比的方式来命名
Bad:           IncomingMessageQueue
               CharacterArray
               SpatialOrganizer
Good:          Mailbox
               String
               Map


如果你使用类比，你就应该一致的使用它们
Bad:           Mailbox,DestinationID
Good:          Mailbox,Address


函数(方法和过程)

简洁
Bad:           list.GetNumberOfItems()
Good:          list.Count()


不要太简洁
Bad:           list.Verify()
Good:          list.ContainsNull()


避免缩写
Bad:           list.Srt()
Good:          list.Sort()


对于完成某件事情的函数使用动词
Bad:           obj.RefCount();
Good:          list.Clear();
               list.Sort();
               obj.AddReference();


对于返回布尔型的函数，使用类似提问的方式
Bad:           list.Empty();
Good:          list.IsEmpty();
               list.Contains(item);


对于只是返回属性，而不改变状态的函数则使用名词
Bad:           list.GetCount();
Good:          list.Count();


不要在函数名字中重复参数的名称
Bad:           list.AddItem(item);
               handler.ReceiveMessage(msg);
Good:          list.Add(item);
               handler.Receive(msg);


不要方法的名字中重复此方法的类的名称
Bad:           list.AddToList(item);
Good:          list.Add(item);


不要在函数的名字中加入返回类型，除非函数名必须以返回类型进行区别
Bad:           list.GetCountInt();
Good:          list.GetCount();
               message.GetIntValue();
               message.GetFloatValue();


不要名字中使用And 或则 Or
如果你使用一个连接词来连接函数名，那么这个函数肯定是做了太多的事情，更好的做法是将其分成更小的函数来处理(类似面向对象设计准则中的责任单一原则)。
如果你想确保是这是一个原子的操作，那么你应该用一个名字来描述这个操作或一个类来封装他
Bad:           mail.VerifyAddressAndSendStatus();
Good:          mail.VerifyAddress();
               mail.SendStatus();


这是一篇非常优秀的文章，我用我的语言在组织了一下，如果喜欢英文的读者可以点击这里阅读原文

Gems of Python

* Tags:
* programming,
* python

Posted on Nov. 2, 2008 at 4:04 P.M.

I've been using Python for a few years now, and continue to love it. But the language is large enough that it seems every project that I look at uses a different subset of the language's features. The nice thing is that by reading different people's code, you can find out about some real gems in the Python programming language. Some of these tips are extremely obvious, and some are more obscure. In any case, here are what I consider to be some real gems:

1.

filter This is one of Python's built-in functions, which allows you to remove unwanted items from a list. It's very useful and highly overlooked. Here's an example of how to use it:

>>> lst = ['1', '2', '3', '4', 'asdf', '5']
>>> def is_int_string(i):
... try:
... int(i)
... return True
... except ValueError:
... return False
...
>>> int_string_list = filter(is_int_string, lst)
>>> int_string_list
['1', '2', '3', '4', '5']

But there is a really neat filter shortcut, too. You can have it filter out any values which evaluate to False.

>>> lst = [0, 2, '', 'asdf', None, [], (), 'fdsa']
>>> filter(None, lst)
[2, 'asdf', 'fdsa']

This is really great for filtering out unwanted values in a list. I use it actually quite frequently and hope to see it in more python projects.
2.

itertools.chain I often have a list of lists, and want to run some operation on each item in that list of lists. itertools.chain allows that to happen. Let me demonstrate with an example:

>>> import itertools
>>> lst = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> list(itertools.chain(*lst))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> sum(itertools.chain(*lst))
45

itertools.chain has become a major part of my day-to-day coding toolbox, and it's a real python gem.
3.

setdefault Do you find yourself writing this type of try..except KeyError pattern often?

>>> dct = {}
>>> items = ['anne', 'david', 'kevin', 'eric', 'anthony', 'andrew']
... for name in items:
... try:
... dct[name[0]].append(name)
... except KeyError:
... dct[name[0]] = [name]
>>> dct
{'a': ['anne', 'anthony', 'andrew'], 'k': ['kevin'], 'e': ['eric'], 'd': ['david']}

That's a lot of boilerplate code for something that seems like it should be much easier. Thankfully, this can be solved much more easily by using setdefault, like so:

>>> dct = {}
>>> items = ['anne', 'david', 'kevin', 'eric', 'anthony', 'andrew']
>>> for name in items:
... dct.setdefault(name[0], []).append(name)
...
>>> dct
{'a': ['anne', 'anthony', 'andrew'], 'k': ['kevin'], 'e': ['eric'], 'd': ['david']}

Much better, isn't it?
4.

defaultdict Given setdefault, it still seems like there should be a better way. If you know upfront that you will be setting everything to an empty list if it isn't found, you should be able to specify that and have it just Do The Right Thing. Thankfully, defaultdict does just that:

>>> from collections import defaultdict
>>> dct = defaultdict(list)
>>> items = ['anne', 'david', 'kevin', 'eric', 'anthony', 'andrew']
>>> for name in items:
... dct[name[0]].append(name)
...
>>> dct
defaultdict(, {'a': ['anne', 'anthony', 'andrew'], 'k': ['kevin'], 'e': ['eric'], 'd': ['david']})
>>> dict(dct)
{'a': ['anne', 'anthony', 'andrew'], 'k': ['kevin'], 'e': ['eric'], 'd': ['david']}

I usually end up converting the defaultdict back to a regular dict before passing it around, but other than that, it's quite a useful tool to use.
5.

zip This is one that most people usually know, but still I find that sometimes people do strange things where a zip would be much easier.

>>> numbers = [1, 2, 3, 4, 5]
>>> letters = ['a', 'b', 'c', 'd', 'e']
>>> for num, let in zip(numbers, letters):
... print "Letter %d is '%s'" % (num, let)
...
Letter 1 is 'a'
Letter 2 is 'b'
Letter 3 is 'c'
Letter 4 is 'd'
Letter 5 is 'e'

Pretty simple, very common, and yet sometimes coders seem to work around it. Also worth mentioning is that there's an iterable version of this, izip, which is located in itertools.
6.

title I wrote some little function to turn a string of lower case text into a 'titleized' string at work, and a few coworkers laughed and said, "why didn't you just use title"? The answer: I didn't know about it. It's not something you run into every day, but when you need it, it's super useful. Here's an example:

>>> s = 'the little green men'
>>> s.title()
'The Little Green Men'

It's that easy! Next time you need to turn something into a title, look for this method on strings first.

That's all I've got for now. There are many more gems in the Python programming language, but these are some that I think are especially useful. Please share in the comments if you have any other gems that you have found in your uses of Python.

UPDATE: Eric Holscher has posted a list of his Python gems as well, and it's got some great stuff on it. Check it out!

== 概述 ==

. 对于一种编程语言来说，语法格式是其最直观的表现，各种类库的 API 是其最直接的应用。
. 但在水面之下，语言的基础设施、模型、原理以及背后的设计思想才是其最本质的部分，也是一种语言真正区别于另一种的所在。
. 此条目关注 Python 本身语言、语法的研究和探讨，收集整理相关的文档和心得（尤其是中文资料）。
. 如无特别注明，均以 CPython 实现为准。

== 系统学习 ==

* 参见[:PyBooks:Python 图书概览]
. 对于语言特性的学习来说，特别推荐以下几本
* 《Python Tutorial》（最新版本2.5） -- 最新，最权威，公开文档
* 《A Byte of Python》 -- 简洁明了，浅显易懂，公开文档
* 《Learning Python》（第二版） -- 最细致，最深入
* 《Text Process in Python》的附录A ：[:TPiP/AppendixA:python精要]
. “对 python 的超精简的但绝不失深度的介绍” -- from 译者 HuangYi

== 语言进化 ==

* [http://docs.python.org/dev/whatsnew/whatsnew25.html What's New in Python 2.5]
* [http://www.aleax.it/Python/py25.pdf Python 2.5 Slides by Alex Martelli]
* [:WeiZhong/WhatsNewOfPython25:WeiZhong 节译]
* [:PythoNology/New4Py2.5:ZoomQuiet 译自另一篇文档]

* [http://docs.python.org/dev/whatsnew/ What's New in Python 2.6]

* [:Python3000:Python 3000 专题] -- 收集了 Python 3000 的规范、展望和最新消息

== 专题剖析 ==

=== 内置类型和操作 ===

* [http://www.voidspace.org.uk/python/articles/python_datatypes.shtml A Very Brief Introduction to Python And its Data-Types]
. “一篇短小精悍的 python tutorial 。对一些容易被忽视的问题讲得很清楚！很专业的 tutorial！” -- from HuangYi

* [http://blog.donews.com/limodou/archive/2004/05/11/18038.aspx 集合(sets)模块] from [http://blog.donews.com/limodou/ limodou 的学习记录]
. 在 2.4 以后，sets 模块已经成为内置类型 set

=== 语句和语法 ===

==== 自省 ====
* [http://www.ibm.com/developerworks/cn/linux/l-pyint/index1.html Python 自省指南]、[http://www.ibm.com/developerworks/cn/linux/l-pyint/index2.html （二）] （原网页上“下一页”链接有误）
. 发表于 IBM developerWorks 网站，作者 Patrick O'Brien 是 Py``Crust 的作者，此为中文版。

* [:PyBatteriesIncluded:内省的威力]

==== Iterator、Generator 和 yield ====
* [http://www.ibm.com/developerworks/cn/linux/sdk/python/charm-20/index.html 可爱的 Python: 迭代器和简单生成器——Python 2.2 中的新型构造]
* [http://www.ibm.com/developerworks/cn/linux/sdk/python/charm-25/index.html 可爱的 Python: 用 Python 生成器实现“轻便线程”——微线程的力量]
* [http://www.ibm.com/developerworks/cn/linux/sdk/python/charm-26/index.html 可爱的 Python: 基于生成器的状态机——用基于生成器的状态机和协同程序增加效率]
. 以上三篇均为 David Mertz 的 developerWorks Python 专栏文章

* [http://blog.donews.com/limodou/archive/2004/07/10/40913.aspx Iterator 和 Generator的学习心得] by limodou

* [:Py25yieldNote:Py2.5 yield 详说] -- shhgs 和 limodou 关于 yield 在2.5中加强语法的探讨
* [:HuangYi/yield_stacklesspython:用 2.5 中的 yield 模拟 Stackless Python] by HuangYi
. 可与[http://www.ibm.com/developerworks/cn/linux/sdk/python/charm-25/index.html 《用 Python 生成器实现“轻便线程”》]对照，加强的 yield 语法带来了更强大的力量和更灵活的运用

==== Decorator ====
* [wiki:peps/pep-0318/ PEP 318 : Decorators for Functions and Methods]
* [:WeiZhong/DecoratorsInPython24:Python2.4中的新东西(1):函数和方法的修饰符] by WeiZhong
* [http://blog.donews.com/limodou/archive/2004/12/19/207521.aspx decorator的使用] by limodou
* [http://www.donews.net/limodou/archive/2004/12/20/208356.aspx Decorator 应用：使用decorator的线程同步] by limodou
* [http://blog.donews.com/limodou/archive/2004/12/31/221653.aspx 关于阅读《Doing abstract methods with decorators》的思考] by limodou

==== with ====

=== 名字空间与对象模型 ===

==== 概述 ====
* Python 官方网站上的 [http://www.python.org/doc/newstyle/ New-style Classes 经典文档汇集]

* [http://www.effbot.org/zone/python-objects.htm Python Objects]
. Python 对象概念简析 —— 比你想像中更简单！

* 两篇系统讲解的精彩文档
* [http://www.cafepy.com/article/python_types_and_objects Python Types and Objects]
* [http://www.cafepy.com/article/python_attributes_and_methods/ Python Attributes and Methods]

* [:PyNewStyleClass:Python 中的新型类及其实例详解] -- WeiZhong 节译自《Python in a Nutshell》（第一版）

* [http://blog.csdn.net/jrgao/archive/2004/03/04/22248.aspx python的对象与名字绑定]、[http://blog.csdn.net/dreamingk/archive/2004/07/26/51658.aspx 对于"python的对象与名字绑定"一文错误的纠正!]
* [http://blog.donews.com/limodou/archive/2005/07/09/460187.aspx 关于Python对象及名字绑定] -- limodou 的补充感想

==== Metaclass ====

* [:MetaClassInPython:Python中的元类(metaclass)] -- WeiZhong 节译自《Python in a Nutshell》（第一版）

* [http://www.ibm.com/developerworks/cn/linux/l-pymeta/index.html Python 中的元类编程]、[http://www.ibm.com/developerworks/cn/linux/l-pymeta2/index.html Python 中的元类编程，第 2 部分]
. 发表于 IBM developerWorks 网站，作者为知名 Python 专栏作家 David Mertz，此为中文版。

* [http://www.python.org/pycon/dc2004/papers/24/metaclasses-pycon.pdf Python Metaclasses: Who? Why? When?] -- 2004年 Py{{{}}}Con 上的一篇讲稿

* [http://www.voidspace.org.uk/python/articles/metaclasses.shtml Eliminating self with Metaclasses]
. Python 在成员方法中对 self 的显式声明往往会令初学者困惑和不习惯，Michael Foord 在这篇文章中利用 metaclass 和 bytecode 实现了一种不需要显式声明 self 参数的类定义方式。

* HuangYi 的心得，发表于[http://codeplayer.blogspot.com 他的 blog]
* [http://codeplayer.blogspot.com/2006/12/metaclass-in-python.html metaclass in python (part 1)]
* [http://codeplayer.blogspot.com/2006/12/metaclass-in-python-part-2.html metaclass in python (part 2)]

==== Descriptor ====
* [http://users.rcn.com/python/download/Descriptor.htm How-To Guide for Descriptors] -- descriptor 机制详解，by Raymond Hettinger

* [http://codeplayer.blogspot.com/2006/12/python-method-function-descriptor.html 理解 python 的 method 和 function 兼谈 descriptor] by HuangYi

==== Magic Methods ====
* [http://blog.donews.com/limodou/archive/2004/10/16/134808.aspx 使用__getattr__要注意的]、[http://blog.donews.com/limodou/archive/2004/10/18/137326.aspx 又一次谈“使用__getattr__要注意的”]
. 自定义 __getattr__ 带来的意想不到的副作用， from [http://blog.donews.com/limodou/ limodou 的学习记录]

=== 模块导入机制 ===

* [http://www.ibm.com/developerworks/cn/linux/sdk/python/python-8/index.html 可爱的 Python：动态重新装入——在长期运行的进程中动态重新装入模块]
. David Mertz 的 developerWorks Python 专栏文章
* [http://blog.donews.com/limodou/archive/2005/06/10/422024.aspx __import__与reload要注意的] from [http://blog.donews.com/limodou/ limodou 的学习记录]

=== 异常机制 ===

=== 其它 ===
* [http://www-128.ibm.com/developerworks/cn/linux/l-pydisp/index.html 可爱的 Python: 多分派——用多元法泛化多态性]
* [http://blog.donews.com/limodou/archive/2004/07/24/49297.aspx 我看“Python中的多分派”] -- limodou的感想
* [http://codeplayer.blogspot.com/2006/09/getcaller.html 意外收获：get_caller] by HuangYi
* [http://www.donews.net/limodou/archive/2004/12/28/218443.aspx Python 中的 Lazy 计算]、[http://blog.donews.com/limodou/archive/2004/12/30/221020.aspx 再谈一谈Lazy计算] from [http://blog.donews.com/limodou/ limodou 的学习记录]

== 参考 ==
* http://www.python.org/doc/newstyle/
* ["ThinkIntoPython"]
* ["PythonZhDoc"]
* ["PythoNology"]
* http://www.voidspace.org.uk/python/index.shtml
* [http://www.ibm.com/developerworks/cn/linux/theme/special/index.html#python IBM developerWorks 的 Python 专栏]
* [http://blog.donews.com/limodou/ limodou 的学习记录] -- limodou 的 blog
* [http://codeplayer.blogspot.com 白菜] -- HuangYi 的 blog

2008-03-26 15:00

原作：Python.org
翻译：nasi

图是由边或者弧连接起来的节点的网络。在有向图中，节点之间的连接是有方向的，叫做弧(arcs)。在无向图中，节点间的连接没有方向，叫做边 (edge)。图算法包括查找两点间路径、两点间的最短路径、判断一个图中是否存在环(环是从一个节点可以沿一条非空路径回到它自己)、找到可以遍历所有 节点的路径(著名的TSP问题，即旅行商问题)等等。有些情况下节点或者图的弧是带有权重(weight)或者消耗(cost)的，我们一般需要寻找这类 图上的最小消耗路径。

图算法作为离散数学中的一个重要部分，有很多文献可供参考。图在计算机算法中有很多的应用，一个很明显的例子就是网络管理。而且图还在其它的很多领 域有广泛的应用，再比如在一个计算机程序之内的函数叫与被叫关系就可以看成是一个图，如果出现了环(cycle)就表示递归，而不能到达的节点就是“死代 码”。

几乎没有编程语言把图作为一项直接支持的数据类型，Python也不例外。然而，图很容易通过列表和词典来构造。比如说，这有一张简单的图：

　A -> B
　A -> C
　B -> C
　B -> D
　C -> D
　D -> C
　E -> F
　F -> C

这个图有6个节点(A-F)和8个弧。它可以通过下面的Python数据结构来表示：
graph = {'A': ['B', 'C'],
             'B': ['C', 'D'],
             'C': ['D'],
             'D': ['C'],
             'E': ['F'],
             'F': ['C']}

这是一个词典，每个key都是图的节点。每个key都对应一个列表，列表里面存的是直接通过一个弧和这个节点连接的节点。这个图非常简单了，不过更简单的是用数字来代替字母来表示一个节点。不过用名字(字母)来表示很方便，而且也便于扩展，比如可以改成城市的名字等等。

我们来写一个函数来判断两个节点间的路径。它的参数是一个图、一个起始节点和一个终点。它会返回一个列表，列表里面存有组成这条路径的节点(包括起 点和终点)。如果两个节点之间没有路径的话，那就返回None。相同的节点不会在返回的路径中出现两次或两次以上(就是说不会包括环)。这个算法用到了一 个很重要的技术，叫做回溯：它会去尝试每一种可能，直到找到结果。

def find_path(graph, start, end, path=[]):
        path = path + [start]
        if start == end:
            return path
        if not graph.has_key(start):
            return None
        for node in graph[start]:
            if node not in path:
                newpath = find_path(graph, node, end, path)
                if newpath: return newpath
        return None
运行的结果(上面的那张图)：
>>> find_path(graph, 'A', 'D')
　　['A', 'B', 'C', 'D']
>>>

代码中的第二个if(译者注：是指if not graph.has_key(start):这句)仅仅在遇到一类 特殊的节点的时候才有用，这类节点有其他的节点指向它，但是它没有任何弧指向其他的节点，所以就并不会在图这个词典中作为key被列出来。也可以这样来处 理，即这个节点也作为一个key，但是有一个空的列表来表示其没有指向其他节点的弧，不过不列出来会更好一些。

注意，当我们调用find_graph()的时候，使用了3个参数，但是实际上使用了4个参数：还有一个是当前已经走过的路径。这个参数的默认值是 一个空列表，“[]”，表示还没有节点被访问过。这个参数用来避免路径中存在环(for循环中的第一个if语句)。path这个参数本身不会修改，我们用 “path = path + [start]”只是创建了一个新的列表。如果我们使用“path.append(start)”的话，那我们就修改了path的值，这样会产生灾难性后 果了。如果使用元组的话，我们可以保证这个是不会发生的。在使用的时候要写“path = path + (start,)”，注意“(start)”并不是一个单体元组，只是一个括号表达式而已。

很容易修改这个函数来实现返回一个节点到另一个节点的所有路径，而不仅仅只查找第一条路径：

def find_all_paths(graph, start, end, path=[]):

path = path + [start]
        if start == end:
            return [path]
        if not graph.has_key(start):
            return []
        paths = []
        for node in graph[start]:
            if node not in path:
                newpaths = find_all_paths(graph, node, end, path)
                for newpath in newpaths:
                    paths.append(newpath)
        return paths

>>> find_all_paths(graph, 'A', 'D')
　　[['A', 'B', 'C', 'D'], ['A', 'B', 'D'], ['A', 'C', 'D']]
>>>

还可以改成查找最短路径：

def find_shortest_path(graph, start, end, path=[]):
        path = path + [start]
        if start == end:
            return path
        if not graph.has_key(start):
            return None
        shortest = None
        for node in graph[start]:
            if node not in path:
                newpath = find_shortest_path(graph, node, end, path)
                if newpath:
                    if not shortest or len(newpath) < len(shortest):
                        shortest = newpath
        return shortest

运行结果：
>>> find_shortest_path(graph, 'A', 'D')
　　['A', 'C', 'D']

这些函数都非常简单，但是却已经接近最优了(用Python写成的代码中)。在另一篇文章中，我将尝试去分析它们的运行速度，并改进它们的性能。

另外还可以引入更多的数据抽象：用一个类来表示一个图，并通过各种方法来实现各种算法。如果通过结构化编程来做这个事情的话，其实对代码的效率提升 没什么帮助(有时恰恰相反)。很容易把节点或者弧加上一个命名，就可以来解决实际问题了(比如在地图上查找两个城市中的最短路)。这个也会在另一篇文章中 讨论。

版本：v2.21 (2007-8-3) 作者：deerchao 来源:unibetter大学生社区

目录

1. 本文目标
2. 如何使用本教程
3. 正则表达式到底是什么？
4. 入门
5. 测试正则表达式
6. 元字符
7. 字符转义
8. 重复
9. 字符类
10. 反义
11. 替换
12. 分组
13. 后向引用
14. 零宽断言
15. 负向零宽断言
16. 注释
17. 贪婪与懒惰
18. 处理选项
19. 平衡组/递归匹配
20. 还有些什么东西没提到
21. 联系作者
22. 最后,来点广告...
23. 一些我认为你可能已经知道的术语的参考
24. 网上的资源及本文参考文献
25. 更新说明

本文目标

30分钟内让你明白正则表达式是什么，并对它有一些基本的了解，让你可以在自己的程序或网页里使用它。

如何使用本教程

最重要的是——请给我30分钟，如果你没有使用正则表达式的经验，请不要试图在30秒内入门。当然，如果你是超人，那自然得另当别论。

别被下面那些复杂的表达式吓倒，只要跟着我一步一步来，你会发现正则表达式其实并没有你 想像中的那么困难。当然，如果你看完了这篇教程之后，发现自己明白了很多，却又几乎什么都记不得，那也是很正常的——我认为，没接触过正则表达式的人在看 完这篇教程后，能把提到过的语法记住80%以上的可能性为零。这里只是让你明白基本的原理，以后你还需要多练习，多使用，才能熟练掌握正则表达式。

除了作为入门教程之外，本文还试图成为可以在日常工作中使用的正则表达式语法参考手册。就作者本人的经历来说，这个目标还是完成得不错的——你看，我自己也没能把所有的东西记下来，不是吗？

文本格式约定：专业术语 元字符/语法格式 正则表达式 正则表达式中的一部分(用于分析) 用于在其中搜索的字符串 对正则表达式或其中一部分的说明清除格式

正则表达式到底是什么？

在编写处理字符串的程序或网页时，经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说，正则表达式就是记录文本规则的代码。

很可能你使用过Windows/Dos下用于文件查找的通配符(wildcard)，也就是*和?。如果你想查找某个目录下的所有的Word文档的话，你会搜索*.doc。在这里，*会被解释成任意的字符串。和通配符类似，正则表达式也是用来进行文本匹配的工具，只不过比起通配符，它能更精确地描述你的需求——当然，代价就是更复杂——比如你可以编写一个正则表达式，用来查找所有以0开头，后面跟着2-3个数字，然后是一个连字号“-”，最后是7或8位数字的字符串(像010-12345678或0376-7654321)。

正则表达式是用于进行文本匹配的工具，所以本文里多次提到了在字符串里搜索/查找，这种说法的意思是在给定的字符串中，寻找与给定的正则表达式相匹配的部分。有可能字符串里有不止一个部分满足给定的正则表达式，这时每一个这样的部分被称为一个匹配。匹配在本文里可能会有三种意思：一种是形容词性的，比如说一个字符串匹配一个表达式；一种是动词性的，比如说在字符串里匹配正则表达式；还有一种是名词性的，就是刚刚说到的“字符串中满足给定的正则表达式的一部分”。

入门

学习正则表达式的最好方法是从例子开始，理解例子之后再自己对例子进行修改，实验。下面给出了不少简单的例子，并对它们作了详细的说明。

假设你在一篇英文小说里查找hi，你可以使用正则表达式hi。

这是最简单的正则表达式了，它可以精确匹配这样的字符串：由两个字符组成，前一个字符是h,后一个是i。通常，处理正则表达式的工具会提供一个忽略大小写的选项，如果选中了这个选项，它可以匹配hi,HI,Hi,hI这四种情况中的任意一种。

不幸的是，很多单词里包含hi这两个连续的字符，比如him,history,high等等。用hi来查找的话，这里边的hi也会被找出来。如果要精确地查找hi这个单词的话，我们应该使用\bhi\b。

\b是正则表达式规定的一个特殊代码（好吧，某些人叫它元字符，metacharacter），代表着单词的开头或结尾，也就是单词的分界处。虽然通常英文的单词是由空格或标点符号或换行来分隔的，但是\b并不匹配这些单词分隔符中的任何一个，它只匹配一个位置。（如果需要更精确的说法，\b匹配这样的位置：它的前一个字符和后一个字符不全是(一个是,一个不是或不存在)\w）

假如你要找的是hi后面不远处跟着一个Lucy，你应该用\bhi\b.*\bLucy\b。

这里，.是另一个元字符，匹配除了换行符以外的任意字符。*同样是元字符，不过它代表的不是字符，也不是位置，而是数量——它指定*前边的内容可以连续重复出现任意次以使整个表达式得到匹配。因此，.*连在一起就意味着任意数量的不包含换行的字符。现在\bhi\b.*\bLucy\b的意思就很明显了：先是一个单词hi,然后是任意个任意字符(但不能是换行)，最后是Lucy这个单词。

如果同时使用其它的一些元字符，我们就能构造出功能更强大的正则表达式。比如下面这个例子：

0\d\d-\d\d\d\d\d\d\d\d匹配这样的字符串：以0开头，然后是两个数字，然后是一个连字号“-”，最后是8个数字(也就是中国的电话号码。当然，这个例子只能匹配区号为3位的情形)。

这里的\d是一个新的元字符，匹配任意的数字(0，或1，或2，或……)。-不是元字符，只匹配它本身——连字号。

为了避免那么多烦人的重复，我们也可以这样写这个表达式：0\d{2}-\d{8}。 这里\d后面的{2}({8})的意思是前面\d必须连续重复匹配2次(8次)。

测试正则表达式

如果你不觉得正则表达式很难读写的话，要么你是一个天才，要么，你不是地球人。正则表达式的语法很令人头疼，即使对经常使用它的人来说也是如此。由于难于读写，容易出错，所以很有必要创建一种工具来测试正则表达式。

由于在不同的环境下正则表达式的一些细节是不相同的，本教程介绍的是Microsoft .Net 2.0下正则表达式的行为，所以，我向你介绍一个.Net下的工具Regex Tester。首先你确保已经安装了.Net Framework 2.0，然后下载Regex Tester。这是个绿色软件，下载完后打开压缩包,直接运行RegexTester.exe就可以了。

下面是Regex Tester运行时的截图：

元字符

现在你已经知道几个很有用的元字符了，如\b,.,*，还有\d.当然还有更多的元字符可用，比如\s匹配任意的空白符，包括空格，制表符(Tab)，换行符，中文全角空格等。\w匹配字母或数字或下划线或汉字等。

下面来试试更多的例子：

\ba\w*\b匹配以字母a开头的单词——先是某个单词开始处(\b)，然后是字母a,然后是任意数量的字母或数字(\w*)，最后是单词结束处(\b)（好吧，现在我们说说正则表达式里的单词是什么意思吧：就是几个连续的\w。不错，这与学习英文时要背的成千上万个同名的东西的确关系不大）。

\d+匹配1个或更多连续的数字。这里的+是和*类似的元字符，不同的是*匹配重复任意次(可能是0次)，而+则匹配重复1次或更多次。

\b\w{6}\b 匹配刚好6个字母/数字的单词。

元字符^（和数字6在同一个键位上的符号）以及$和\b有点类似，都匹配一个位置。^匹配你要用来查找的字符串的开头，$匹配结尾。这两个代码在验证输入的内容时非常有用，比如一个网站如果要求你填写的QQ号必须为5位到12位数字时，可以使用：^\d{5,12}$。

这里的{5,12}和前面介绍过的{2}是类似的，只不过{2}匹配只能不多不少重复2次，{5,12}则是重复的次数不能少于5次，不能多于12次，否则都不匹配。

因为使用了^和$，所以输入的整个字符串都要用来和\d{5,12}来匹配，也就是说整个输入必须是5到12个数字，因此如果输入的QQ号能匹配这个正则表达式的话，那就符合要求了。

和忽略大小写的选项类似，有些正则表达式处理工具还有一个处理多行的选项。如果选中了这个选项，^和$的意义就变成了匹配行的开始处和结束处。

字符转义

如果你想查找元字符本身的话，比如你查找.,或者*,就出现了问题：你没法指定它们，因为它们会被解释成其它的意思。这时你就必须使用\来取消这些字符的特殊意义。因此，你应该使用\.和\*。当然，要查找\本身，你也得用\\.

例如：www\.unibetter\.com匹配www.unibetter.com，c:\\Windows匹配c:\Windows。

重复

你已经看过了前面的*,+,{2},{5,12}这几个匹配重复的方式了。下面是正则表达式中所有的限定符(指定数量的代码，例如*,{5,12}等)：

下面是一些使用重复的例子：

Windows\d+匹配Windows后面跟1个或更多数字

13\d{9}匹配13后面跟9个数字(中国的手机号)

^\w+匹配一行的第一个单词(或整个字符串的第一个单词，具体匹配哪个意思得看选项设置)

字符类

要想查找数字，字母或数字，空白是很简单的，因为已经有了对应这些字符集合的元字符，但是如果你想匹配没有预定义元字符的字符集合(比如元音字母a,e,i,o,u),应该怎么办？

很简单，你只需要在中括号里列出它们就行了，像[aeiou]就匹配任何一个英文元音字母，[.?!]匹配标点符号(.或?或!)(英文语句通常只以这三个标点结束)。

我们也可以轻松地指定一个字符范围，像[0-9]代表的含意与\d就是完全一致的：一位数字，同理[a-z0-9A-Z_]也完全等同于\w（如果只考虑英文的话）。

下面是一个更复杂的表达式：\(?0\d{2}[) -]?\d{8}。

这个表达式可以匹配几种格式的电话号码，像(010)88886666，或022-22334455，或02912345678等。我们对它进行一些分析吧：首先是一个转义字符\(,它能出现0次或1次(?),然后是一个0，后面跟着2个数字(\d{2})，然后是)或-或空格中的一个，它出现1次或不出现(?)，最后是8个数字(\d{8})。不幸的是，它也能匹配010)12345678或(022-87654321这样的“不正确”的格式。要解决这个问题，请在本教程的下面查找答案。

反义

有时需要查找不属于某个能简单定义的字符类的字符。比如想查找除了数字以外，其它任意字符都行的情况，这时需要用到反义：

例子：\S+匹配不包含空白符的字符串。

<a[^>]+>匹配用尖括号括起来的以a开头的字符串。

替换

好了，现在终于到了解决3位或4位区号问题的时间了。正则表达式里的替换指的是有几种规则，如果满足其中任意一种规则都应该当成匹配，具体方法是用|把不同的规则分隔开。听不明白？没关系，看例子：

0\d{2}-\d{8}|0\d{3}-\d{7}这个表达式能匹配两种以连字号分隔的电话号码：一种是三位区号，8位本地号(如010-12345678)，一种是4位区号，7位本地号(0376-2233445)。

\(0\d{2}\)[- ]?\d{8}|0\d{2}[- ]?\d{8}这个表达式匹配3位区号的电话号码，其中区号可以用小括号括起来，也可以不用，区号与本地号间可以用连字号或空格间隔，也可以没有间隔。你可以试试用替换|把这个表达式扩展成也支持4位区号的。

\d{5}-\d{4}|\d{5}这个表达式用于匹配美国的邮政编码。美国邮编的规则是5位数字，或者用连字号间隔的9位数字。之所以要给出这个例子是因为它能说明一个问题：使用替换时，顺序是很重要的。如果你把它改成\d{5}|\d{5}-\d{4}的话，那么就只会匹配5位的邮编(以及9位邮编的前5位)。原因是匹配替换时，将会从左到右地测试每个分枝条件，如果满足了某个分枝的话，就不会去管其它的替换条件了。

Windows98|Windows2000|WindosXP这个例子是为了告诉你替换不仅仅能用于两种规则，也能用于更多种规则。

分组

我们已经提到了怎么重复单个字符（直接在字符后面加上限定符就行了）；但如果想要重复多个字符又该怎么办？你可以用小括号来指定子表达式(也叫做分组)，然后你就可以指定这个子表达式的重复次数了，你也可以对子表达式进行其它一些操作(后面会有介绍)。

(\d{1,3}\.){3}\d{1,3}是一个简单的IP地址匹配表达式。要理解这个表达式，请按下列顺序分析它：\d{1,3}匹配1到3位的数字，(\d{1,3}\.){3}匹配三位数字加上一个英文句号(这个整体也就是这个分组)重复3次，最后再加上一个一到三位的数字(\d{1,3})。

不幸的是，它也将匹配256.300.888.999这 种不可能存在的IP地址(IP地址中每个数字都不能大于255。题外话，好像反恐24小时第三季的编剧不知道这一点，汗...)。如果能使用算术比较的 话，或许能简单地解决这个问题，但是正则表达式中并不提供关于数学的任何功能，所以只能使用冗长的分组，选择，字符类来描述一个正确的IP地址：((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)。

理解这个表达式的关键是理解2[0-4]\d|25[0-5]|[01]?\d\d?，这里我就不细说了，你自己应该能分析得出来它的意义。

后向引用

使用小括号指定一个子表达式后，匹配这个子表达式的文本(也就是此分组捕获的内容)可以在表达式或其它程序中作进一步的处理。默认情况下，每个分组会自动拥有一个组号，规则是：从左向右，以分组的左括号为标志，第一个出现的分组的组号为1，第二个为2，以此类推。

后向引用用于重复搜索前面某个分组匹配的文本。例如，\1代表分组1匹配的文本。难以理解？请看示例：

\b(\w+)\b\s+\1\b可以用来匹配重复的单词，像go go, kitty kitty。首先是一个单词，也就是单词开始处和结束处之间的多于一个的字母或数字(\b(\w+)\b)，然后是1个或几个空白符(\s+)，最后是前面匹配的那个单词(\1)。

你也可以自己指定子表达式的组名。要指定一个子表达式的组名，请使用这样的语法：(?<Word>\w+)(或者把尖括号换成'也行：(?'Word'\w+)),这样就把\w+的组名指定为Word了。要反向引用这个分组捕获的内容，你可以使用\k<Word>,所以上一个例子也可以写成这样：\b(?<Word>\w+)\b\s+\k<Word>\b。

使用小括号的时候，还有很多特定用途的语法。下面列出了最常用的一些：

我们已经讨论了前两种语法。第三个(?:exp)不会改变正则表达式的处理方式，只是这样的组匹配的内容不会像前两种那样被捕获到某个组里面。

零宽断言

接下来的四个用于查找在某些内容(但并不包括这些内容)之前或之后的东西，也就是说它们像\b,^,$那样用于指定一个位置，这个位置应该满足一定的条件(断言)，因此它们也被称为零宽断言。最好还是拿例子来说明吧：

(?=exp)也叫零宽度正预测先行断言，它断言自身出现的位置的后面能匹配表达式exp。比如\b\w+(?=ing\b)，匹配以ing结尾的单词的前面部分(除了ing以外的部分)，如查找I'm singing while you're dancing.时，它会匹配sing和danc。

(?<=exp)也叫零宽度正回顾后发断言，它断言自身出现的位置的前面能匹配表达式exp。比如(?<=\bre)\w+\b会匹配以re开头的单词的后半部分(除了re以外的部分)，例如在查找reading a book时，它匹配ading。

假如你想要给一个很长的数字中每三位间加一个逗号(当然是从右边加起了)，你可以这样查找需要在前面和里面添加逗号的部分：((?<=\d)\d{3})*\b，用它对1234567890进行查找时结果是234567890。

下面这个例子同时使用了这两种断言：(?<=\s)\d+(?=\s)匹配以空白符间隔的数字(再次强调，不包括这些空白符)。

负向零宽断言

前面我们提到过怎么查找不是某个字符或不在某个字符类里的字符的方法(反义)。但是如果我们只是想要确保某个字符没有出现，但并不想去匹配它时怎么办？例如，如果我们想查找这样的单词--它里面出现了字母q,但是q后面跟的不是字母u,我们可以尝试这样：

\b\w*q[^u]\w*\b匹配包含后面不是字母u的字母q的单词。但是如果多做测试(或者你思维足够敏锐，直接就观察出来了)，你会发现，如果q出现在单词的结尾的话，像Iraq,Benq，这个表达式就会出错。这是因为[^u]总要匹配一个字符，所以如果q是单词的最后一个字符的话，后面的[^u]将会匹配q后面的单词分隔符(可能是空格，或者是句号或其它的什么)，后面的\w*\b将会匹配下一个单词，于是\b\w*q[^u]\w*\b就能匹配整个Iraq fighting。负向零宽断言能解决这样的问题，因为它只匹配一个位置，并不消费任何字符。现在，我们可以这样来解决这个问题：\b\w*q(?!u)\w*\b。

零宽度负预测先行断言(?!exp)，断言此位置的后面不能匹配表达式exp。例如：\d{3}(?!\d)匹配三位数字，而且这三位数字的后面不能是数字；\b((?!abc)\w)+\b匹配不包含连续字符串abc的单词。

同理，我们可以用(?<!exp),零宽度正回顾后发断言来断言此位置的前面不能匹配表达式exp：(?<![a-z])\d{7}匹配前面不是小写字母的七位数字。

一个更复杂的例子：(?<=<(\w+)>).*(?=<\/\1>)匹配不包含属性的简单HTML标签内里的内容。(<?(\w+)>)指定了这样的前缀：被尖括号括起来的单词(比如可能是<b>)，然后是.*(任意的字符串),最后是一个后缀(?=<\/\1>)。注意后缀里的\/，它用到了前面提过的字符转义；\1则是一个反向引用，引用的正是捕获的第一组，前面的(\w+)匹配的内容，这样如果前缀实际上是<b>的话，后缀就是</b>了。整个表达式匹配的是<b>和</b>之间的内容(再次提醒，不包括前缀和后缀本身)。

注释

小括号的另一种用途是通过语法(?#comment)来包含注释。例如：2[0-4]\d(?#200-249)|25[0-5](?#250-255)|[01]?\d\d?(?#0-199)。

要包含注释的话，最好是启用“忽略模式里的空白符”选项，这样在编写表达式时能任意的添加空格，Tab，换行，而实际使用时这些都将被忽略。启用这个选项后，在#后面到这一行结束的所有文本都将被当成注释忽略掉。

例如，我们可以前面的一个表达式写成这样：

      (?<=    # 断言要匹配的文本的前缀

<(\w+)> # 查找尖括号括起来的字母或数字(即HTML/XML标签)

)       # 前缀结束

.*      # 匹配任意文本

(?=     # 断言要匹配的文本的后缀

<\/\1>  # 查找尖括号括起来的内容：前面是一个"/"，后面是先前捕获的标签

)       # 后缀结束

贪婪与懒惰

当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能多的字符。考虑这个表达式：a.*b，它将会匹配最长的以a开始，以b结束的字符串。如果用它来搜索aabab的话，它会匹配整个字符串aabab。这被称为贪婪匹配。

有时，我们更需要懒惰匹配，也就是匹配尽可能少的字符。前面给出的限定符都可以被转化为懒惰匹配模式，只要在它后面加上一个问号?。这样.*?就意味着匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复。现在看看懒惰版的例子吧：

a.*?b匹配最短的，以a开始，以b结束的字符串。如果把它应用于aabab的话，它会匹配aab和ab（为什么第一个匹配是aab而不是ab？简单地说，因为正则表达式有另一条规则，比懒惰／贪婪规则的优先级更高：最先开始的匹配拥有最高的优先权——The Match That Begins Earliest Wins）。

处理选项

上面介绍了几个选项如忽略大小写，处理多行等，这些选项能用来改变处理正则表达式的方式。下面是.Net中常用的正则表达式选项：

一个经常被问到的问题是：是不是只能同时使用多行模式和单行模式中的一种？答案是：不是。这两个选项之间没有任何关系，除了它们的名字比较相似（以至于让人感到疑惑）以外。

平衡组/递归匹配

注意：这里介绍的平衡组语法是由.Net Framework支持的；其它语言／库不一定支持这种功能，或者支持此功能但需要使用不同的语法。

有时我们需要匹配像( 100 * ( 50 + 15 ) )这样的可嵌套的层次性结构，这时简单地使用\(.+\)则只会匹配到最左边的左括号和最右边的右括号之间的内容(这里我们讨论的是贪婪模式，懒惰模式也有下面的问题)。假如原来的字符串里的左括号和右括号出现的次数不相等，比如( 5 / ( 3 + 2 ) ) )，那我们的匹配结果里两者的个数也不会相等。有没有办法在这样的字符串里匹配到最长的，配对的括号之间的内容呢？

为了避免(和\(把你的大脑彻底搞糊涂，我们还是用尖括号代替圆括号吧。现在我们的问题变成了如何把xx <aa <bbb> <bbb> aa> yy这样的字符串里，最长的配对的尖括号内的内容捕获出来？

这里需要用到以下的语法构造：

• (?'group') 把捕获的内容命名为group,并压入堆栈
• (?'-group') 从堆栈上弹出最后压入堆栈的名为group的捕获内容，如果堆栈本来为空，则本分组的匹配失败
• (?(group)yes|no) 如果堆栈上存在以名为group的捕获内容的话，继续匹配yes部分的表达式，否则继续匹配no部分
• (?!) 零宽负向先行断言，由于没有后缀表达式，试图匹配总是失败

如果你不是一个程序员（或者你是一个对堆栈的概念不熟的程序员），你就这样理解上面的三种语法吧：第一个就是在黑板上写一个 "group"，第二个就是从黑板上擦掉一个"group"，第三个就是看黑板上写的还有没有"group"，如果有就继续匹配yes部分，否则就匹配 no部分。

我们需要做的是每碰到了左括号，就在黑板上写一个"group"，每碰到一个右括号，就擦掉一个，到了最后就看看黑板上还有没有－－如果有那就证明左括号比右括号多，那匹配就应该失败。

<                         #最外层的左括号

[^<>]*                #最外层的左括号后面的不是括号的内容

(

(

(?'Open'<)    #碰到了左括号，在黑板上写一个"Open"

[^<>]*       #匹配左括号后面的不是括号的内容

)+

(

(?'-Open'>)   #碰到了右括号，擦掉一个"Open"

[^<>]*        #匹配右括号后面不是括号的内容

)+

)*

(?(Open)(?!))         #在遇到最外层的右括号前面，判断黑板上还有没有没擦掉的"Open"；如果还有，则匹配失败

>                         #最外层的右括号

平衡组的一个最常见的应用就是匹配HTML,下面这个例子可以匹配嵌套的<div>标签：<div[^>]*>[^<>]*(((?'Open'<div[^>]*>)[^<>]*)+((?'-Open'</div>)[^<>]*)+)*(?(Open)(?!))</div>.

还有些什么东西没提到

我已经描述了构造正则表达式的大量元素，还有一些我没有提到的东西。下面是未提到的元素的列表，包含语法和简单的说明。你可以在网上找到更详细的参考资料来学习它们--当你需要用到它们的时候。如果你安装了MSDN Library,你也可以在里面找到关于.net下正则表达式详细的文档。

联系作者

好吧,我承认,我骗了你,读到这里你肯定花了不止30分钟.相信我,这是我的错,而不是因为你太笨.我之所以说"30分钟",是为了让你有信心,有耐心继续下去.既然你看到了这里,那证明我的阴谋成功了.上这种当的滋味还不错吧?

要投诉我,或者觉得我其实可以做得更好,或者有任何其它问题,欢迎来我的博客进行讨论.

一些我认为你可能已经知道的术语的参考

字符

程序处理文字时最基本的单位，可能是字母，数字，标点符号，空格，换行符，汉字等等。

字符串

0个或更多个字符的序列。

文本

文字，字符串。

匹配

符合规则，检验是否符合规则，符合规则的部分。

断言

声明一个应该为真的事实。只有当断言为真时才会对正则表达式继续进行匹配。

网上的资源及本文参考文献

• 微软的正则表达式教程
• System.Text.RegularExpressions.Regex类(MSDN)
• 专业的正则表达式教学网站(英文)
• 关于.Net下的平衡组的详细讨论（英文）
• Mastering Regular Expressions (Second Edition)

更新说明

1. 2006-3-27 第一版
2. 2006-10-12 第二版
   • 修正了几个细节上的错误和不准确的地方
   • 增加了对处理中文时的一些说明
   • 更改了几个术语的翻译（采用了MSDN的翻译方式）
   • 增加了平衡组的介绍
   • 放弃了对The Regulator的介绍，改用Regex Tester
3. 2007-3-12 V2.1
   • 修正了几个小的错误
   • 增加了对处理选项(RegexOptions)的介绍
4. 2007-5-28 V2.2
   • 重新组织了对零宽断言的介绍
   • 删除了几个不太合适的示例，添加了几个实用的示例
   • 其它一些微小的更改
5. 2007-8-3 V2.21
   • 修改了几处文字错误
   • 修改/添加了对$,\b的精确说明
   • 承认了作者是个骗子
   • 给RegexTester添加了Singleline选项的相关功能