原文参考:
http://iregex.org/blog/regex-optimizing.html/comment-page-1#comment-2123
如果纯粹是为了挑战自己的正则水平，用来实现一些特效（例如使用正则表达式计算质数、解线性方程），效率不是问题；如果所写的正则表达式只是为了满足一两次、几十次的运行，优化与否区别也不太大。但是，如果所写的正则表达式会百万次、千万次地运行，效率就是很大的问题了。我这里总结了几条提升正则表达式运行效率的经验（工作中学到的，看书学来的，自己的体会），贴在这里。如果您有其它的经验而这里没有提及，欢迎赐教。
为行文方便，先定义两个概念。
* 误匹配：指正则表达式所匹配的内容范围超出了所需要范围，有些文本明明不符合要求，但是被所写的正则式“击中了”。例如，如果使用\d{11}来匹配11位的手机号，\d{11}不单能匹配正确的手机号，它还会匹配98765432100这样的明显不是手机号的字符串。我们把这样的匹配称之为误匹配。
* 漏匹配：指正则表达式所匹配的内容所规定的范围太狭窄，有些文本确实是所需要的，但是所写的正则没有将这种情况囊括在内。例如，使用\d{18}来匹配18位的身份证号码，就会漏掉结尾是字母X的情况。
写出一条正则表达式，既可能只出现误匹配（条件写得极宽松，其范围大于目标文本），也可能只出现漏匹配（只描述了目标文本中多种情况种的一种），还可能既有误匹配又有漏匹配。例如，使用\w+\.com来匹配.com结尾的域名，既会误匹配abc_.com这样的字串（合法的域名中不含下划线，\w包含了下划线这种情况），又会漏掉ab-c.com这样的域名（合法域名中可以含中划线，但是\w不匹配中划线）。
精准的正则表达式意味着既无误匹配且无漏匹配。当然，现实中存在这样的情况：只能看到有限数量的文本，根据这些文本写规则，但是这些规则将会用到海量的文本中。这种情况下，尽可能地（如果不是完全地）消除误匹配以及漏匹配，并提升运行效率，就是我们的目标。本文所提出的经验，主要是针对这种情况。
1. 掌握语法细节。正则表达式在各种语言中，其语法大致相同，细节各有千秋。明确所使用语言的正则的语法的细节，是写出正确、高效正则表达式的基础。例如，perl中与\w等效的匹配范围是[a-zA-Z0-9_]；perl正则式不支持肯定逆序环视中使用可变的重复（variable repetition inside lookbehind，例如(?<=.*)abc），但是.Net语法是支持这一特性的；又如，JavaScript连逆序环视（Lookbehind,如(?<=ab)c）都不支持，而perl和python是支持的。《精通正则表达式》第3章《正则表达式的特性和流派概览》明确地列出了各大派系正则的异同，这篇文章也简要地列出了几种常用语言、工具中正则的比较。对于具体使用者而言，至少应该详细了解正在使用的那种工作语言里正则的语法细节。
2. 先粗后精，先加后减。使用正则表达式语法对于目标文本进行描述和界定，可以像画素描一样，先大致勾勒出框架，再逐步在局步实现细节。仍举刚才的手机号的例子，先界定\d{11}，总不会错；再细化为1[358]\d{9}，就向前迈了一大步（至于第二位是不是3、5、8，这里无意深究，只举这样一个例子，说明逐步细化的过程）。这样做的目的是先消除漏匹配（刚开始先尽可能多地匹配，做加法），然后再一点一点地消除误匹配（做减法）。这样有先有后，在考虑时才不易出错，从而向“不误不漏”这个目标迈进。
3. 留有余地。所能看到的文本sample是有限的，而待匹配检验的文本是海量的，暂时不可见的。对于这样的情况，在写正则表达式时要跳出所能见到的文本的圈子，开拓思路，作出“战略性前瞻”。例如，经常收到这样的垃圾短信：“发*票”、“发#漂”。如果要写规则屏蔽这样烦人的垃圾短信，不但要能写出可以匹配当前文本的正则表达式 发[*#](?:票|漂)，还要能够想到 发.(?:票|漂|飘)之类可能出现的“变种”。这在具体的领域或许会有针对性的规则，不多言。这样做的目的是消除漏匹配，延长正则表达式的生命周期。
4. 明确。具体说来，就是谨慎用点号这样的元字符，尽可能不用星号和加号这样的任意量词。只要能确定范围的，例如\w，就不要用点号；只要能够预测重复次数的，就不要用任意量词。例如，写析取twitter消息的脚本，假设一条消息的xml正文部分结构是<span class=”msg”>…</span>且正文中无尖括号，那么<span class=”msg”>[^<]{1,480}</span>这种写法的思路要好于<span class=”msg”>.*</span>，原因有二：一是使用[^<]，它保证了文本的范围不会超出下一个小于号所在的位置；二是明确长度范围，{1,480}，其依据是一条twitter消息大致能的字符长度范围。当然，480这个长度是否正确还可推敲，但是这种思路是值得借鉴的。说得狠一点，“滥用点号、星号和加号是不环保、不负责任的做法”。
5. 不要让稻草压死骆驼。每使用一个普通括号()而不是非捕获型括号(?:…)，就会保留一部分内存等着你再次访问。这样的正则表达式、无限次地运行次数，无异于一根根稻草的堆加，终于能将骆驼压死。养成合理使用(?:…)括号的习惯。
6. 宁简勿繁。将一条复杂的正则表达式拆分为两条或多条简单的正则表达式，编程难度会降低，运行效率会提升。例如用来消除行首和行尾空白字符的正则表达式s/^\s+|\s+$//g;，其运行效率理论上要低于s/^\s+//g; s/\s+$//g; 。这个例子出自《精通正则表达式》第五章，书中对它的评论是“它几乎总是最快的，而且显然最容易理解”。既快又容易理解，何乐而不为？工作中我们还有其它的理由要将C==(A|B)这样的正则表达式拆为A和B两条表达式分别执行。例如，虽然A和B这两种情况只要有一种能够击中所需要的文本模式就会成功匹配，但是如果只要有一条子表达式（例如A）会产生误匹配，那么不论其它的子表达式（例如B）效率如何之高，范围如何精准，C的总体精准度也会因A而受到影响。
7. 巧妙定位。有时候，我们需要匹配的the，是作为单词的the（两边有空格），而不是作为单词一部分的t-h-e的有序排列（例如together中的the）。在适当的时候用上^，$，\b等等定位锚点，能有效提升找到成功匹配、淘汰不成功匹配的效率。
总结完发现，《精通正则表达式》的第5章、第6章已经以更为有条理的方式总结出了常用的优化方法。不过，泛泛地读过的印象是肤浅的，过后即忘的；而真正若有所悟时在书上得到了系统地印证，这种感觉才是真的爽。
28 Dec 2009
正则表达式-转载
来自: http://www.regular-expressions.info/tutorialcnt.html
翻译: http://dragon.cnblogs.com/archive/2006/05/08/394078.html
1. 什么是正则表达式
基本说来，正则表达式是一种用来描述一定数量文本的模式。Regex代表Regular Express。本文将用<<regex>>来表示一段具体的正则表达式。
一段文本就是最基本的模式，简单的匹配相同的文本。
2. 不同的正则表达式引擎
正则表达式引擎是一种可以处理正则表达式的软件。通常，引擎是更大的应用程序的一部分。在软件世界，不同的正则表达式并不互相兼容。本教程会集中讨论Perl 5 类型的引擎，因为这种引擎是应用最广泛的引擎。同时我们也会提到一些和其他引擎的区别。许多近代的引擎都很类似，但不完全一样。例如.NET正则库，JDK正则包。
3. 文字符号
最基本的正则表达式由单个文字符号组成。如<<a>>，它将匹配字符串中第一次出现的字符“a”。如对字符串“Jack is a boy”。“J”后的“a”将被匹配。而第二个“a”将不会被匹配。
正则表达式也可以匹配第二个“a”，这必须是你告诉正则表达式引擎从第一次匹配的地方开始搜索。在文本编辑器中，你可以使用“查找下一个”。在编程语言中，会有一个函数可以使你从前一次匹配的位置开始继续向后搜索。
类似的，<<cat>>会匹配“About cats and dogs”中的“cat”。这等于是告诉正则表达式引擎，找到一个<<c>>，紧跟一个<<a>>，再跟一个<<t>>。
要注意，正则表达式引擎缺省是大小写敏感的。除非你告诉引擎忽略大小写，否则<<cat>>不会匹配“Cat”。
· 特殊字符
对于文字字符，有11个字符被保留作特殊用途。他们是：
[ ] \ ^ $ . | ? * + ( )
这些特殊字符也被称作元字符。
如果你想在正则表达式中将这些字符用作文本字符，你需要用反斜杠“\”对其进行换码 (escape)。例如你想匹配“1+1=2”，正确的表达式为<<1\+1=2>>.
需要注意的是，<<1+1=2>>也是有效的正则表达式。但它不会匹配“1+1=2”，而会匹配“123+111=234”中的“111=2”。因为“+”在这里表示特殊含义（重复1次到多次）。
在编程语言中，要注意，一些特殊的字符会先被编译器处理，然后再传递给正则引擎。因此正则表达式<<1\+2=2>>在C++中要写成“1\\+1=2”。为了匹配“C:\temp”，你要用正则表达式<<C:\\temp>>。而在C++中，正则表达式则变成了“C:\\\\temp”。
· 不可显示字符
可以使用特殊字符序列来代表某些不可显示字符：
<<\t>>代表Tab(0x09)
<<\r>>代表回车符(0x0D)
<<\n>>代表换行符(0x0A)
要注意的是Windows中文本文件使用“\r\n”来结束一行而Unix使用“\n”。
4. 正则表达式引擎的内部工作机制
知道正则表达式引擎是如何工作的有助于你很快理解为何某个正则表达式不像你期望的那样工作。
有两种类型的引擎：文本导向(text-directed)的引擎和正则导向(regex-directed)的引擎。Jeffrey Friedl把他们称作DFA和NFA引擎。本文谈到的是正则导向的引擎。这是因为一些非常有用的特性，如“惰性”量词(lazy quantifiers)和反向引用(backreferences)，只能在正则导向的引擎中实现。所以毫不意外这种引擎是目前最流行的引擎。
你可以轻易分辨出所使用的引擎是文本导向还是正则导向。如果反向引用或“惰性”量词被实现，则可以肯定你使用的引擎是正则导向的。你可以作如下测试：将正则表达式<<regex|regex not>>应用到字符串“regex not”。如果匹配的结果是regex，则引擎是正则导向的。如果结果是regex not，则是文本导向的。因为正则导向的引擎是“猴急”的，它会很急切的进行表功，报告它找到的第一个匹配 。
· 正则导向的引擎总是返回最左边的匹配
这是需要你理解的很重要的一点：即使以后有可能发现一个“更好”的匹配，正则导向的引擎也总是返回最左边的匹配。
当把<<cat>>应用到“He captured a catfish for his cat”，引擎先比较<<c>>和“H”，结果失败了。于是引擎再比较<<c>>和“e”，也失败了。直到第四个字符，<<c>>匹配了“c”。<<a>>匹配了第五个字符。到第六个字符<<t>>没能匹配“p”，也失败了。引擎再继续从第五个字符重新检查匹配性。直到第十五个字符开始，<<cat>>匹配上了“catfish”中的“cat”，正则表达式引擎急切的返回第一个匹配的结果，而不会再继续查找是否有其他更好的匹配。
5. 字符集
字符集是由一对方括号“[]”括起来的字符集合。使用字符集，你可以告诉正则表达式引擎仅仅匹配多个字符中的一个。如果你想匹配一个“a”或一个“e”，使用<<[ae]>>。你可以使用<<gr[ae]y>>匹配gray或grey。这在你不确定你要搜索的字符是采用美国英语还是英国英语时特别有用。相反，<<gr[ae]y>>将不会匹配graay或graey。字符集中的字符顺序并没有什么关系，结果都是相同的。
你可以使用连字符“-”定义一个字符范围作为字符集。<<[0-9]>>匹配0到9之间的单个数字。你可以使用不止一个范围。<<[0-9a-fA-F] >>匹配单个的十六进制数字，并且大小写不敏感。你也可以结合范围定义与单个字符定义。<<[0-9a-fxA-FX]>>匹配一个十六进制数字或字母X。再次强调一下，字符和范围定义的先后顺序对结果没有影响。
· 字符集的一些应用
查找一个可能有拼写错误的单词，比如<<sep[ae]r[ae]te>> 或 <<li[cs]en[cs]e>>。
查找程序语言的标识符，<<A-Za-z_][A-Za-z_0-9]*>>。(*表示重复0或多次)
查找C风格的十六进制数<<0[xX][A-Fa-f0-9]+>>。(+表示重复一次或多次)
· 取反字符集
在左方括号“[”后面紧跟一个尖括号“^”，将会对字符集取反。结果是字符集将匹配任何不在方括号中的字符。不像“.”，取反字符集是可以匹配回车换行符的。
需要记住的很重要的一点是，取反字符集必须要匹配一个字符。<<q[^u]>>并不意味着：匹配一个q，后面没有u跟着。它意味着：匹配一个q，后面跟着一个不是u的字符。所以它不会匹配“Iraq”中的q，而会匹配“Iraq is a country”中的q和一个空格符。事实上，空格符是匹配中的一部分，因为它是一个“不是u的字符”。
如果你只想匹配一个q，条件是q后面有一个不是u的字符，我们可以用后面将讲到的向前查看来解决。
· 字符集中的元字符
需要注意的是，在字符集中只有4个 字符具有特殊含义。它们是：“] \ ^ -”。“]”代表字符集定义的结束；“\”代表转义；“^”代表取反；“-”代表范围定义。其他常见的元字符在字符集定义内部都是正常字符，不需要转义。例如，要搜索星号*或加号+，你可以用<<[+*]>>。当然，如果你对那些通常的元字符进行转义，你的正则表达式一样会工作得很好，但是这会降低可读性。
在字符集定义中为了将反斜杠“\”作为一个文字字符而非特殊含义的字符，你需要用另一个反斜杠对它进行转义。<<[\\x]>>将会匹配一个反斜杠和一个X。“]^-”都可以用反斜杠进行转义，或者将他们放在一个不可能使用到他们特殊含义的位置。我们推荐后者，因为这样可以增加可读性。比如对于字符“^”，将它放在除了左括号“[”后面的位置，使用的都是文字字符含义而非取反含义。如<<[x^]>>会匹配一个x或^。<<[]x]>>会匹配一个“]”或“x”。<<[-x]>>或<<[x-]>>都会匹配一个“-”或“x”。
· 字符集的简写
因为一些字符集非常常用，所以有一些简写方式。
<<\d>>代表<<[0-9]>>;
<<\w>>代表单词字符。这个是随正则表达式实现的不同而有些差异。绝大多数的正则表达式实现的单词字符集都包含了<<A-Za-z0-9_]>>。
<<\s>>代表“白字符”。这个也是和不同的实现有关的。在绝大多数的实现中，都包含了空格符和Tab符，以及回车换行符<<\r\n>>。
字符集的缩写形式可以用在方括号之内或之外。<<\s\d>>匹配一个白字符后面紧跟一个数字。<<[\s\d]>>匹配单个白字符或数字。<<[\da-fA-F]>>将匹配一个十六进制数字。
取反字符集的简写
<<[\S]>> = <<[^\s]>>
<<[\W]>> = <<[^\w]>>
<<[\D]>> = <<[^\d]>>
· 字符集的重复
如果你用“?*+”操作符来重复一个字符集，你将会重复整个字符集。而不仅是它匹配的那个字符。正则表达式<<[0-9]+>>会匹配837以及222。
如果你仅仅想重复被匹配的那个字符，可以用向后引用达到目的。我们以后将讲到向后引用。
6. 使用?*或+ 进行重复
?：告诉引擎匹配前导字符0次或一次。事实上是表示前导字符是可选的。
+：告诉引擎匹配前导字符1次或多次
*：告诉引擎匹配前导字符0次或多次
<[A-Za-z][A-Za-z0-9]*>匹配没有属性的HTML标签，“<”以及“>”是文字符号。第一个字符集匹配一个字母，第二个字符集匹配一个字母或数字。
我们似乎也可以用<[A-Za-z0-9]+>。但是它会匹配<1>。但是这个正则表达式在你知道你要搜索的字符串不包含类似的无效标签时还是足够有效的。
· 限制性重复
许多现代的正则表达式实现，都允许你定义对一个字符重复多少次。词法是：{min,max}。min和max都是非负整数。如果逗号有而max被忽略了，则max没有限制。如果逗号和max都被忽略了，则重复min次。
因此{0,}和*一样，{1，}和+ 的作用一样。
你可以用<<\b[1-9][0-9]{3}\b>>匹配1000~9999之间的数字(“\b”表示单词边界)。<<\b[1-9][0-9]{2,4}\b>>匹配一个在100~99999之间的数字。
· 注意贪婪性
假设你想用一个正则表达式匹配一个HTML标签。你知道输入将会是一个有效的HTML文件，因此正则表达式不需要排除那些无效的标签。所以如果是在两个尖括号之间的内容，就应该是一个HTML标签。
许多正则表达式的新手会首先想到用正则表达式<< <.+> >>，他们会很惊讶的发现，对于测试字符串，“This is a <EM>first</EM> test”，你可能期望会返回<EM>，然后继续进行匹配的时候，返回</EM>。
但事实是不会。正则表达式将会匹配“<EM>first</EM>”。很显然这不是我们想要的结果。原因在于“+”是贪婪的。也就是说，“+”会导致正则表达式引擎试图尽可能的重复前导字符。只有当这种重复会引起整个正则表达式匹配失败的情况下，引擎会进行回溯。也就是说，它会放弃最后一次的“重复”，然后处理正则表达式余下的部分。
和“+”类似，“?*”的重复也是贪婪的。
· 深入正则表达式引擎内部
让我们来看看正则引擎如何匹配前面的例子。第一个记号是“<”，这是一个文字符号。第二个符号是“.”，匹配了字符“E”，然后“+”一直可以匹配其余的字符，直到一行的结束。然后到了换行符，匹配失败(“.”不匹配换行符)。于是引擎开始对下一个正则表达式符号进行匹配。也即试图匹配“>”。到目前为止，“<.+”已经匹配了“<EM>first</EM> test”。引擎会试图将“>”与换行符进行匹配，结果失败了。于是引擎进行回溯。结果是现在“<.+”匹配“<EM>first</EM> tes”。于是引擎将“>”与“t”进行匹配。显然还是会失败。这个过程继续，直到“<.+”匹配“<EM>first</EM”，“>”与“>”匹配。于是引擎找到了一个匹配“<EM>first</EM>”。记住，正则导向的引擎是“急切的”，所以它会急着报告它找到的第一个匹配。而不是继续回溯，即使可能会有更好的匹配，例如“<EM>”。所以我们可以看到，由于“+”的贪婪性，使得正则表达式引擎返回了一个最左边的最长的匹配。
· 用懒惰性取代贪婪性
一个用于修正以上问题的可能方案是用“+”的惰性代替贪婪性。你可以在“+”后面紧跟一个问号“?”来达到这一点。“*”，“{}”和“?”表示的重复也可以用这个方案。因此在上面的例子中我们可以使用“<.+?>”。让我们再来看看正则表达式引擎的处理过程。
再一次，正则表达式记号“<”会匹配字符串的第一个“<”。下一个正则记号是“.”。这次是一个懒惰的“+”来重复上一个字符。这告诉正则引擎，尽可能少的重复上一个字符。因此引擎匹配“.”和字符“E”，然后用“>”匹配“M”，结果失败了。引擎会进行回溯，和上一个例子不同，因为是惰性重复，所以引擎是扩展惰性重复而不是减少，于是“<.+”现在被扩展为“<EM”。引擎继续匹配下一个记号“>”。这次得到了一个成功匹配。引擎于是报告“<EM>”是一个成功的匹配。整个过程大致如此。
· 惰性扩展的一个替代方案
我们还有一个更好的替代方案。可以用一个贪婪重复与一个取反字符集：“<[^>]+>”。之所以说这是一个更好的方案在于使用惰性重复时，引擎会在找到一个成功匹配前对每一个字符进行回溯。而使用取反字符集则不需要进行回溯。
最后要记住的是，本教程仅仅谈到的是正则导向的引擎。文本导向的引擎是不回溯的。但是同时他们也不支持惰性重复操作。
7. 使用“.”匹配几乎任意字符
在正则表达式中，“.”是最常用的符号之一。不幸的是，它也是最容易被误用的符号之一。
“.”匹配一个单个的字符而不用关心被匹配的字符是什么。唯一的例外是新行符。在本教程中谈到的引擎，缺省情况下都是不匹配新行符的。因此在缺省情况下，“.”等于是字符集[^\n\r](Window)或[^\n]( Unix)的简写。
这个例外是因为历史的原因。因为早期使用正则表达式的工具是基于行的。它们都是一行一行的读入一个文件，将正则表达式分别应用到每一行上去。在这些工具中，字符串是不包含新行符的。因此“.”也就从不匹配新行符。
现代的工具和语言能够将正则表达式应用到很大的字符串甚至整个文件上去。本教程讨论的所有正则表达式实现都提供一个选项，可以使“.”匹配所有的字符，包括新行符。在RegexBuddy, EditPad Pro或PowerGREP等工具中，你可以简单的选中“点号匹配新行符”。在Perl中，“.”可以匹配新行符的模式被称作“单行模式”。很不幸，这是一个很容易混淆的名词。因为还有所谓“多行模式”。多行模式只影响行首行尾的锚定(anchor)，而单行模式只影响“.”。
其他语言和正则表达式库也采用了Perl的术语定义。当在.NET Framework中使用正则表达式类时，你可以用类似下面的语句来激活单行模式：Regex.Match(“string”,”regex”,RegexOptions.SingleLine)
· 保守的使用点号“.”
点号可以说是最强大的元字符。它允许你偷懒：用一个点号，就能匹配几乎所有的字符。但是问题在于，它也常常会匹配不该匹配的字符。
我会以一个简单的例子来说明。让我们看看如何匹配一个具有“mm/dd/yy”格式的日期，但是我们想允许用户来选择分隔符。很快能想到的一个方案是<<\d\d.\d\d.\d\d>>。看上去它能匹配日期“02/12/03”。问题在于02512703也会被认为是一个有效的日期。
<<\d\d[-/.]\d\d[-/.]\d\d>>看上去是一个好一点的解决方案。记住点号在一个字符集里不是元字符。这个方案远不够完善，它会匹配“99/99/99”。而<<[0-1]\d[-/.][0-3]\d[-/.]\d\d>>又更进一步。尽管他也会匹配“19/39/99”。你想要你的正则表达式达到如何完美的程度取决于你想达到什么样的目的。如果你想校验用户输入，则需要尽可能的完美。如果你只是想分析一个已知的源，并且我们知道没有错误的数据，用一个比较好的正则表达式来匹配你想要搜寻的字符就已经足够。
8. 字符串开始和结束的锚定
锚定和一般的正则表达式符号不同，它不匹配任何字符。相反，他们匹配的是字符之前或之后的位置。“^”匹配一行字符串第一个字符前的位置。<<^a>>将会匹配字符串“abc”中的a。<<^b>>将不会匹配“abc”中的任何字符。
类似的，$匹配字符串中最后一个字符的后面的位置。所以<<c$>>匹配“abc”中的c。
· 锚定的应用
在编程语言中校验用户输入时，使用锚定是非常重要的。如果你想校验用户的输入为整数，用<<^\d+$>>。
用户输入中，常常会有多余的前导空格或结束空格。你可以用<<^\s*>>和<<\s*$>>来匹配前导空格或结束空格。
· 使用“^”和“$”作为行的开始和结束锚定
如果你有一个包含了多行的字符串。例如：“first line\n\rsecond line”(其中\n\r表示一个新行符)。常常需要对每行分别处理而不是整个字符串。因此，几乎所有的正则表达式引擎都提供一个选项，可以扩展这两种锚定的含义。“^”可以匹配字串的开始位置(在f之前)，以及每一个新行符的后面位置(在\n\r和s之间)。类似的，$会匹配字串的结束位置(最后一个e之后)，以及每个新行符的前面(在e与\n\r之间)。
在.NET中，当你使用如下代码时，将会定义锚定匹配每一个新行符的前面和后面位置：Regex.Match("string", "regex", RegexOptions.Multiline)
应用：string str = Regex.Replace(Original, "^", "> ", RegexOptions.Multiline)--将会在每行的行首插入“> ”。
· 绝对锚定
<<\A>>只匹配整个字符串的开始位置，<<\Z>>只匹配整个字符串的结束位置。即使你使用了“多行模式”，<<\A>>和<<\Z>>也从不匹配新行符。
即使\Z和$只匹配字符串的结束位置，仍然有一个例外的情况。如果字符串以新行符结束，则\Z和$将会匹配新行符前面的位置，而不是整个字符串的最后面。这个“改进”是由Perl引进的，然后被许多的正则表达式实现所遵循，包括Java，.NET等。如果应用<<^[a-z]+$>>到“joe\n”，则匹配结果是“joe”而不是“joe\n”。
9. 单词边界
元字符<<\b>>也是一种对位置进行匹配的“锚”。这种匹配是0长度匹配。
有4种位置被认为是“单词边界”：
1) 在字符串的第一个字符前的位置(如果字符串的第一个字符是一个“单词字符”)
2) 在字符串的最后一个字符后的位置(如果字符串的最后一个字符是一个“单词字符”)
3) 在一个“单词字符”和“非单词字符”之间，其中“非单词字符”紧跟在“单词字符”之后
4) 在一个“非单词字符”和“单词字符”之间，其中“单词字符”紧跟在“非单词字符”后面
“单词字符”是可以用“\w”匹配的字符，“非单词字符”是可以用“\W”匹配的字符。在大多数的正则表达式实现中，“单词字符”通常包括<<[a-zA-Z0-9_]>>。
例如：<<\b4\b>>能够匹配单个的4而不是一个更大数的一部分。这个正则表达式不会匹配“44”中的4。
换种说法，几乎可以说<<\b>>匹配一个“字母数字序列”的开始和结束的位置。
“单词边界”的取反集为<<\B>>，他要匹配的位置是两个“单词字符”之间或者两个“非单词字符”之间的位置。
· 深入正则表达式引擎内部
让我们看看把正则表达式<<\bis\b>>应用到字符串“This island is beautiful”。引擎先处理符号<<\b>>。因为\b是0长度 ，所以第一个字符T前面的位置会被考察。因为T是一个“单词字符”，而它前面的字符是一个空字符(void)，所以\b匹配了单词边界。接着<<i>>和第一个字符“T”匹配失败。匹配过程继续进行，直到第五个空格符，和第四个字符“s”之间又匹配了<<\b>>。然而空格符和<<i>>不匹配。继续向后，到了第六个字符“i”，和第五个空格字符之间匹配了<<\b>>，然后<<is>>和第六、第七个字符都匹配了。然而第八个字符和第二个“单词边界”不匹配，所以匹配又失败了。到了第13个字符i，因为和前面一个空格符形成“单词边界”，同时<<is>>和“is”匹配。引擎接着尝试匹配第二个<<\b>>。因为第15个空格符和“s”形成单词边界，所以匹配成功。引擎“急着”返回成功匹配的结果。
10. 选择符
正则表达式中“|”表示选择。你可以用选择符匹配多个可能的正则表达式中的一个。
如果你想搜索文字“cat”或“dog”，你可以用<<cat|dog>>。如果你想有更多的选择，你只要扩展列表<<cat|dog|mouse|fish>>。
选择符在正则表达式中具有最低的优先级，也就是说，它告诉引擎要么匹配选择符左边的所有表达式，要么匹配右边的所有表达式。你也可以用圆括号来限制选择符的作用范围。如<<\b(cat|dog)\b>>，这样告诉正则引擎把(cat|dog)当成一个正则表达式单位来处理。
· 注意正则引擎的“急于表功”性
正则引擎是急切的，当它找到一个有效的匹配时，它会停止搜索。因此在一定条件下，选择符两边的表达式的顺序对结果会有影响。假设你想用正则表达式搜索一个编程语言的函数列表：Get，GetValue，Set或SetValue。一个明显的解决方案是<<Get|GetValue|Set|SetValue>>。让我们看看当搜索SetValue时的结果。
因为<<Get>>和<<GetValue>>都失败了，而<<Set>>匹配成功。因为正则导向的引擎都是“急切”的，所以它会返回第一个成功的匹配，就是“Set”，而不去继续搜索是否有其他更好的匹配。
和我们期望的相反，正则表达式并没有匹配整个字符串。有几种可能的解决办法。一是考虑到正则引擎的“急切”性，改变选项的顺序，例如我们使用<<GetValue|Get|SetValue|Set>>，这样我们就可以优先搜索最长的匹配。我们也可以把四个选项结合起来成两个选项：<<Get(Value)?|Set(Value)?>>。因为问号重复符是贪婪的，所以SetValue总会在Set之前被匹配。
一个更好的方案是使用单词边界：<<\b(Get|GetValue|Set|SetValue)\b>>或<<\b(Get(Value)?|Set(Value)?\b>>。更进一步，既然所有的选择都有相同的结尾，我们可以把正则表达式优化为<<\b(Get|Set)(Value)?\b>>。
11. 组与向后引用
把正则表达式的一部分放在圆括号内，你可以将它们形成组。然后你可以对整个组使用一些正则操作，例如重复操作符。
要注意的是，只有圆括号“()”才能用于形成组。“[]”用于定义字符集。“{}”用于定义重复操作。
当用“()”定义了一个正则表达式组后，正则引擎则会把被匹配的组按照顺序编号，存入缓存。当对被匹配的组进行向后引用的时候，可以用“\数字”的方式进行引用。<<\1>>引用第一个匹配的后向引用组，<<\2>>引用第二个组，以此类推，<<\n>>引用第n个组。而<<\0>>则引用整个被匹配的正则表达式本身。我们看一个例子。
假设你想匹配一个HTML标签的开始标签和结束标签，以及标签中间的文本。比如<B>This is a test</B>，我们要匹配<B>和</B>以及中间的文字。我们可以用如下正则表达式：“<([A-Z][A-Z0-9]*)[^>]*>.*?</\1>”
首先，“<”将会匹配“<B>”的第一个字符“<”。然后[A-Z]匹配B，[A-Z0-9]*将会匹配0到多次字母数字，后面紧接着0到多个非“>”的字符。最后正则表达式的“>”将会匹配“<B>”的“>”。接下来正则引擎将对结束标签之前的字符进行惰性匹配，直到遇到一个“</”符号。然后正则表达式中的“\1”表示对前面匹配的组“([A-Z][A-Z0-9]*)”进行引用，在本例中，被引用的是标签名“B”。所以需要被匹配的结尾标签为“</B>”
你可以对相同的后向引用组进行多次引用，<<([a-c])x\1x\1>>将匹配“axaxa”、“bxbxb”以及“cxcxc”。如果用数字形式引用的组没有有效的匹配，则引用到的内容简单的为空。
一个后向引用不能用于它自身。<<([abc]\1)>>是错误的。因此你不能将<<\0>>用于一个正则表达式匹配本身，它只能用于替换操作中。
后向引用不能用于字符集内部。<<(a)[\1b]>>中的<<\1>>并不表示后向引用。在字符集内部，<<\1>>可以被解释为八进制形式的转码。
向后引用会降低引擎的速度，因为它需要存储匹配的组。如果你不需要向后引用，你可以告诉引擎对某个组不存储。例如：<<Get(?:Value)>>。其中“(”后面紧跟的“?:”会告诉引擎对于组(Value)，不存储匹配的值以供后向引用。
· 重复操作与后向引用
当对组使用重复操作符时，缓存里后向引用内容会被不断刷新，只保留最后匹配的内容。例如：<<([abc]+)=\1>>将匹配“cab=cab”，但是<<([abc])+=\1>>却不会。因为([abc])第一次匹配“c”时，“\1”代表“c”；然后([abc])会继续匹配“a”和“b”。最后“\1”代表“b”，所以它会匹配“cab=b”。
应用：检查重复单词--当编辑文字时，很容易就会输入重复单词，例如“the the”。使用<<\b(\w+)\s+\1\b>>可以检测到这些重复单词。要删除第二个单词，只要简单的利用替换功能替换掉“\1”就可以了。
· 组的命名和引用
在PHP，Python中，可以用<<(?P<name>group)>>来对组进行命名。在本例中，词法?P<name>就是对组(group)进行了命名。其中name是你对组的起的名字。你可以用(?P=name)进行引用。
.NET的命名组
.NET framework也支持命名组。不幸的是，微软的程序员们决定发明他们自己的语法，而不是沿用Perl、Python的规则。目前为止，还没有任何其他的正则表达式实现支持微软发明的语法。
下面是.NET中的例子：
(?<first>group)(?’second’group)
正如你所看到的，.NET提供两种词法来创建命名组：一是用尖括号“<>”，或者用单引号“’’”。尖括号在字符串中使用更方便，单引号在ASP代码中更有用，因为ASP代码中“<>”被用作HTML标签。
要引用一个命名组，使用\k<name>或\k’name’.
当进行搜索替换时，你可以用“${name}”来引用一个命名组。
12. 正则表达式的匹配模式
本教程所讨论的正则表达式引擎都支持三种匹配模式：
<</i>>使正则表达式对大小写不敏感，
<</s>>开启“单行模式”，即点号“.”匹配新行符
<</m>>开启“多行模式”，即“^”和“$”匹配新行符的前面和后面的位置。
· 在正则表达式内部打开或关闭模式
如果你在正则表达式内部插入修饰符(?ism)，则该修饰符只对其右边的正则表达式起作用。(?-i)是关闭大小写不敏感。你可以很快的进行测试。<<(?i)te(?-i)st>>应该匹配TEst，但是不能匹配teST或TEST.
13. 原子组与防止回溯
在一些特殊情况下，因为回溯会使得引擎的效率极其低下。
让我们看一个例子：要匹配这样的字串，字串中的每个字段间用逗号做分隔符，第12个字段由P开头。
我们容易想到这样的正则表达式<<^(.*?,){11}P>>。这个正则表达式在正常情况下工作的很好。但是在极端情况下，如果第12个字段不是由P开头，则会发生灾难性的回溯。如要搜索的字串为“1,2,3,4,5,6,7,8,9,10,11,12,13”。首先，正则表达式一直成功匹配直到第12个字符。这时，前面的正则表达式消耗的字串为“1,2,3,4,5,6,7,8,9,10,11,”，到了下一个字符，<<P>>并不匹配“12”。所以引擎进行回溯，这时正则表达式消耗的字串为“1,2,3,4,5,6,7,8,9,10,11”。继续下一次匹配过程，下一个正则符号为点号<<.>>，可以匹配下一个逗号“,”。然而<<，>>并不匹配字符“12”中的“1”。匹配失败，继续回溯。大家可以想象，这样的回溯组合是个非常大的数量。因此可能会造成引擎崩溃。
用于阻止这样巨大的回溯有几种方案：
一种简单的方案是尽可能的使匹配精确。用取反字符集代替点号。例如我们用如下正则表达式<<^([^,\r\n]*,){11}P>>，这样可以使失败回溯的次数下降到11次。
另一种方案是使用原子组。
原子组的目的是使正则引擎失败的更快一点。因此可以有效的阻止海量回溯。原子组的语法是<<(?>正则表达式)>>。位于(?>)之间的所有正则表达式都会被认为是一个单一的正则符号。一旦匹配失败，引擎将会回溯到原子组前面的正则表达式部分。前面的例子用原子组可以表达成<<^(?>(.*?,){11})P>>。一旦第十二个字段匹配失败，引擎回溯到原子组前面的<<^>>。
14. 向前查看与向后查看
Perl 5 引入了两个强大的正则语法：“向前查看”和“向后查看”。他们也被称作“零长度断言”。他们和锚定一样都是零长度的（所谓零长度即指该正则表达式不消耗被匹配的字符串）。不同之处在于“前后查看”会实际匹配字符，只是他们会抛弃匹配只返回匹配结果：匹配或不匹配。这就是为什么他们被称作“断言”。他们并不实际消耗字符串中的字符，而只是断言一个匹配是否可能。
几乎本文讨论的所有正则表达式的实现都支持“向前向后查看”。唯一的一个例外是Javascript只支持向前查看。
· 肯定和否定式的向前查看
如我们前面提过的一个例子：要查找一个q，后面没有紧跟一个u。也就是说，要么q后面没有字符，要么后面的字符不是u。采用否定式向前查看后的一个解决方案为<<q(?!u)>>。否定式向前查看的语法是<<(?!查看的内容)>>。
肯定式向前查看和否定式向前查看很类似：<<(?=查看的内容)>>。
如果在“查看的内容”部分有组，也会产生一个向后引用。但是向前查看本身并不会产生向后引用，也不会被计入向后引用的编号中。这是因为向前查看本身是会被抛弃掉的，只保留匹配与否的判断结果。如果你想保留匹配的结果作为向后引用，你可以用<<(?=(regex))>>来产生一个向后引用。
· 肯定和否定式的先后查看
向后查看和向前查看有相同的效果，只是方向相反
否定式向后查看的语法是：<<(?<!查看内容)>>
肯定式向后查看的语法是：<<(?<=查看内容)>>
我们可以看到，和向前查看相比，多了一个表示方向的左尖括号。
例：<<(?<!a)b>>将会匹配一个没有“a”作前导字符的“b”。
值得注意的是：向前查看从当前字符串位置开始对“查看”正则表达式进行匹配；向后查看则从当前字符串位置开始先后回溯一个字符，然后再开始对“查看”正则表达式进行匹配。
· 深入正则表达式引擎内部
让我们看一个简单例子。
把正则表达式<<q(?!u)>>应用到字符串“Iraq”。正则表达式的第一个符号是<<q>>。正如我们知道的，引擎在匹配<<q>>以前会扫过整个字符串。当第四个字符“q”被匹配后，“q”后面是空字符(void)。而下一个正则符号是向前查看。引擎注意到已经进入了一个向前查看正则表达式部分。下一个正则符号是<<u>>，和空字符不匹配，从而导致向前查看里的正则表达式匹配失败。因为是一个否定式的向前查看，意味着整个向前查看结果是成功的。于是匹配结果“q”被返回了。
我们在把相同的正则表达式应用到“quit”。<<q>>匹配了“q”。下一个正则符号是向前查看部分的<<u>>，它匹配了字符串中的第二个字符“i”。引擎继续走到下个字符“i”。然而引擎这时注意到向前查看部分已经处理完了，并且向前查看已经成功。于是引擎抛弃被匹配的字符串部分，这将导致引擎回退到字符“u”。
因为向前查看是否定式的，意味着查看部分的成功匹配导致了整个向前查看的失败，因此引擎不得不进行回溯。最后因为再没有其他的“q”和<<q>>匹配，所以整个匹配失败了。
为了确保你能清楚地理解向前查看的实现，让我们把<<q(?=u)i>>应用到“quit”。<<q>>首先匹配“q”。然后向前查看成功匹配“u”，匹配的部分被抛弃，只返回可以匹配的判断结果。引擎从字符“i”回退到“u”。由于向前查看成功了，引擎继续处理下一个正则符号<<i>>。结果发现<<i>>和“u”不匹配。因此匹配失败了。由于后面没有其他的“q”，整个正则表达式的匹配失败了。
· 更进一步理解正则表达式引擎内部机制
让我们把<<(?<=a)b>>应用到“thingamabob”。引擎开始处理向后查看部分的正则符号和字符串中的第一个字符。在这个例子中，向后查看告诉正则表达式引擎回退一个字符，然后查看是否有一个“a”被匹配。因为在“t”前面没有字符，所以引擎不能回退。因此向后查看失败了。引擎继续走到下一个字符“h”。再一次，引擎暂时回退一个字符并检查是否有个“a”被匹配。结果发现了一个“t”。向后查看又失败了。
向后查看继续失败，直到正则表达式到达了字符串中的“m”，于是肯定式的向后查看被匹配了。因为它是零长度的，字符串的当前位置仍然是“m”。下一个正则符号是<<b>>，和“m”匹配失败。下一个字符是字符串中的第二个“a”。引擎向后暂时回退一个字符，并且发现<<a>>不匹配“m”。
在下一个字符是字符串中的第一个“b”。引擎暂时性的向后退一个字符发现向后查看被满足了，同时<<b>>匹配了“b”。因此整个正则表达式被匹配了。作为结果，正则表达式返回字符串中的第一个“b”。
· 向前向后查看的应用
我们来看这样一个例子：查找一个具有6位字符的，含有“cat”的单词。
首先，我们可以不用向前向后查看来解决问题，例如：
<< cat\w{3}|\wcat\w{2}|\w{2}cat\w|\w{3}cat>>
足够简单吧！但是当需求变成查找一个具有6-12位字符，含有“cat”，“dog”或“mouse”的单词时，这种方法就变得有些笨拙了。
我们来看看使用向前查看的方案。在这个例子中，我们有两个基本需求要满足：一是我们需要一个6位的字符，二是单词含有“cat”。
满足第一个需求的正则表达式为<<\b\w{6}\b>>。满足第二个需求的正则表达式为<<\b\w*cat\w*\b>>。
把两者结合起来，我们可以得到如下的正则表达式：
<<(?=\b\w{6}\b)\b\w*cat\w*\b>>
具体的匹配过程留给读者。但是要注意的一点是，向前查看是不消耗字符的，因此当判断单词满足具有6个字符的条件后，引擎会从开始判断前的位置继续对后面的正则表达式进行匹配。
最后作些优化，可以得到下面的正则表达式：
<<\b(?=\w{6}\b)\w{0,3}cat\w*>>
15. 正则表达式中的条件测试
条件测试的语法为<<(?ifthen|else)>>。“if”部分可以是向前向后查看表达式。如果用向前查看，则语法变为：<<(?(?=regex)then|else)>>，其中else部分是可选的。
如果if部分为true，则正则引擎会试图匹配then部分，否则引擎会试图匹配else部分。
需要记住的是，向前先后查看并不实际消耗任何字符，因此后面的then与else部分的匹配时从if测试前的部分开始进行尝试。
16. 为正则表达式添加注释
在正则表达式中添加注释的语法是：<<(?#comment)>>
例：为用于匹配有效日期的正则表达式添加注释：
(?#year)(19|20)\d\d[- /.](?#month)(0[1-9]|1[012])[- /.](?#day)(0[1-9]|[12][0-9]|3[01])
翻译: http://dragon.cnblogs.com/archive/2006/05/08/394078.html
1. 什么是正则表达式
基本说来，正则表达式是一种用来描述一定数量文本的模式。Regex代表Regular Express。本文将用<<regex>>来表示一段具体的正则表达式。
一段文本就是最基本的模式，简单的匹配相同的文本。
2. 不同的正则表达式引擎
正则表达式引擎是一种可以处理正则表达式的软件。通常，引擎是更大的应用程序的一部分。在软件世界，不同的正则表达式并不互相兼容。本教程会集中讨论Perl 5 类型的引擎，因为这种引擎是应用最广泛的引擎。同时我们也会提到一些和其他引擎的区别。许多近代的引擎都很类似，但不完全一样。例如.NET正则库，JDK正则包。
3. 文字符号
最基本的正则表达式由单个文字符号组成。如<<a>>，它将匹配字符串中第一次出现的字符“a”。如对字符串“Jack is a boy”。“J”后的“a”将被匹配。而第二个“a”将不会被匹配。
正则表达式也可以匹配第二个“a”，这必须是你告诉正则表达式引擎从第一次匹配的地方开始搜索。在文本编辑器中，你可以使用“查找下一个”。在编程语言中，会有一个函数可以使你从前一次匹配的位置开始继续向后搜索。
类似的，<<cat>>会匹配“About cats and dogs”中的“cat”。这等于是告诉正则表达式引擎，找到一个<<c>>，紧跟一个<<a>>，再跟一个<<t>>。
要注意，正则表达式引擎缺省是大小写敏感的。除非你告诉引擎忽略大小写，否则<<cat>>不会匹配“Cat”。
· 特殊字符
对于文字字符，有11个字符被保留作特殊用途。他们是：
[ ] \ ^ $ . | ? * + ( )
这些特殊字符也被称作元字符。
如果你想在正则表达式中将这些字符用作文本字符，你需要用反斜杠“\”对其进行换码 (escape)。例如你想匹配“1+1=2”，正确的表达式为<<1\+1=2>>.
需要注意的是，<<1+1=2>>也是有效的正则表达式。但它不会匹配“1+1=2”，而会匹配“123+111=234”中的“111=2”。因为“+”在这里表示特殊含义（重复1次到多次）。
在编程语言中，要注意，一些特殊的字符会先被编译器处理，然后再传递给正则引擎。因此正则表达式<<1\+2=2>>在C++中要写成“1\\+1=2”。为了匹配“C:\temp”，你要用正则表达式<<C:\\temp>>。而在C++中，正则表达式则变成了“C:\\\\temp”。
· 不可显示字符
可以使用特殊字符序列来代表某些不可显示字符：
<<\t>>代表Tab(0x09)
<<\r>>代表回车符(0x0D)
<<\n>>代表换行符(0x0A)
要注意的是Windows中文本文件使用“\r\n”来结束一行而Unix使用“\n”。
4. 正则表达式引擎的内部工作机制
知道正则表达式引擎是如何工作的有助于你很快理解为何某个正则表达式不像你期望的那样工作。
有两种类型的引擎：文本导向(text-directed)的引擎和正则导向(regex-directed)的引擎。Jeffrey Friedl把他们称作DFA和NFA引擎。本文谈到的是正则导向的引擎。这是因为一些非常有用的特性，如“惰性”量词(lazy quantifiers)和反向引用(backreferences)，只能在正则导向的引擎中实现。所以毫不意外这种引擎是目前最流行的引擎。
你可以轻易分辨出所使用的引擎是文本导向还是正则导向。如果反向引用或“惰性”量词被实现，则可以肯定你使用的引擎是正则导向的。你可以作如下测试：将正则表达式<<regex|regex not>>应用到字符串“regex not”。如果匹配的结果是regex，则引擎是正则导向的。如果结果是regex not，则是文本导向的。因为正则导向的引擎是“猴急”的，它会很急切的进行表功，报告它找到的第一个匹配 。
· 正则导向的引擎总是返回最左边的匹配
这是需要你理解的很重要的一点：即使以后有可能发现一个“更好”的匹配，正则导向的引擎也总是返回最左边的匹配。
当把<<cat>>应用到“He captured a catfish for his cat”，引擎先比较<<c>>和“H”，结果失败了。于是引擎再比较<<c>>和“e”，也失败了。直到第四个字符，<<c>>匹配了“c”。<<a>>匹配了第五个字符。到第六个字符<<t>>没能匹配“p”，也失败了。引擎再继续从第五个字符重新检查匹配性。直到第十五个字符开始，<<cat>>匹配上了“catfish”中的“cat”，正则表达式引擎急切的返回第一个匹配的结果，而不会再继续查找是否有其他更好的匹配。
5. 字符集
字符集是由一对方括号“[]”括起来的字符集合。使用字符集，你可以告诉正则表达式引擎仅仅匹配多个字符中的一个。如果你想匹配一个“a”或一个“e”，使用<<[ae]>>。你可以使用<<gr[ae]y>>匹配gray或grey。这在你不确定你要搜索的字符是采用美国英语还是英国英语时特别有用。相反，<<gr[ae]y>>将不会匹配graay或graey。字符集中的字符顺序并没有什么关系，结果都是相同的。
你可以使用连字符“-”定义一个字符范围作为字符集。<<[0-9]>>匹配0到9之间的单个数字。你可以使用不止一个范围。<<[0-9a-fA-F] >>匹配单个的十六进制数字，并且大小写不敏感。你也可以结合范围定义与单个字符定义。<<[0-9a-fxA-FX]>>匹配一个十六进制数字或字母X。再次强调一下，字符和范围定义的先后顺序对结果没有影响。
· 字符集的一些应用
查找一个可能有拼写错误的单词，比如<<sep[ae]r[ae]te>> 或 <<li[cs]en[cs]e>>。
查找程序语言的标识符，<<A-Za-z_][A-Za-z_0-9]*>>。(*表示重复0或多次)
查找C风格的十六进制数<<0[xX][A-Fa-f0-9]+>>。(+表示重复一次或多次)
· 取反字符集
在左方括号“[”后面紧跟一个尖括号“^”，将会对字符集取反。结果是字符集将匹配任何不在方括号中的字符。不像“.”，取反字符集是可以匹配回车换行符的。
需要记住的很重要的一点是，取反字符集必须要匹配一个字符。<<q[^u]>>并不意味着：匹配一个q，后面没有u跟着。它意味着：匹配一个q，后面跟着一个不是u的字符。所以它不会匹配“Iraq”中的q，而会匹配“Iraq is a country”中的q和一个空格符。事实上，空格符是匹配中的一部分，因为它是一个“不是u的字符”。
如果你只想匹配一个q，条件是q后面有一个不是u的字符，我们可以用后面将讲到的向前查看来解决。
· 字符集中的元字符
需要注意的是，在字符集中只有4个 字符具有特殊含义。它们是：“] \ ^ -”。“]”代表字符集定义的结束；“\”代表转义；“^”代表取反；“-”代表范围定义。其他常见的元字符在字符集定义内部都是正常字符，不需要转义。例如，要搜索星号*或加号+，你可以用<<[+*]>>。当然，如果你对那些通常的元字符进行转义，你的正则表达式一样会工作得很好，但是这会降低可读性。
在字符集定义中为了将反斜杠“\”作为一个文字字符而非特殊含义的字符，你需要用另一个反斜杠对它进行转义。<<[\\x]>>将会匹配一个反斜杠和一个X。“]^-”都可以用反斜杠进行转义，或者将他们放在一个不可能使用到他们特殊含义的位置。我们推荐后者，因为这样可以增加可读性。比如对于字符“^”，将它放在除了左括号“[”后面的位置，使用的都是文字字符含义而非取反含义。如<<[x^]>>会匹配一个x或^。<<[]x]>>会匹配一个“]”或“x”。<<[-x]>>或<<[x-]>>都会匹配一个“-”或“x”。
· 字符集的简写
因为一些字符集非常常用，所以有一些简写方式。
<<\d>>代表<<[0-9]>>;
<<\w>>代表单词字符。这个是随正则表达式实现的不同而有些差异。绝大多数的正则表达式实现的单词字符集都包含了<<A-Za-z0-9_]>>。
<<\s>>代表“白字符”。这个也是和不同的实现有关的。在绝大多数的实现中，都包含了空格符和Tab符，以及回车换行符<<\r\n>>。
字符集的缩写形式可以用在方括号之内或之外。<<\s\d>>匹配一个白字符后面紧跟一个数字。<<[\s\d]>>匹配单个白字符或数字。<<[\da-fA-F]>>将匹配一个十六进制数字。
取反字符集的简写
<<[\S]>> = <<[^\s]>>
<<[\W]>> = <<[^\w]>>
<<[\D]>> = <<[^\d]>>
· 字符集的重复
如果你用“?*+”操作符来重复一个字符集，你将会重复整个字符集。而不仅是它匹配的那个字符。正则表达式<<[0-9]+>>会匹配837以及222。
如果你仅仅想重复被匹配的那个字符，可以用向后引用达到目的。我们以后将讲到向后引用。
6. 使用?*或+ 进行重复
?：告诉引擎匹配前导字符0次或一次。事实上是表示前导字符是可选的。
+：告诉引擎匹配前导字符1次或多次
*：告诉引擎匹配前导字符0次或多次
<[A-Za-z][A-Za-z0-9]*>匹配没有属性的HTML标签，“<”以及“>”是文字符号。第一个字符集匹配一个字母，第二个字符集匹配一个字母或数字。
我们似乎也可以用<[A-Za-z0-9]+>。但是它会匹配<1>。但是这个正则表达式在你知道你要搜索的字符串不包含类似的无效标签时还是足够有效的。
· 限制性重复
许多现代的正则表达式实现，都允许你定义对一个字符重复多少次。词法是：{min,max}。min和max都是非负整数。如果逗号有而max被忽略了，则max没有限制。如果逗号和max都被忽略了，则重复min次。
因此{0,}和*一样，{1，}和+ 的作用一样。
你可以用<<\b[1-9][0-9]{3}\b>>匹配1000~9999之间的数字(“\b”表示单词边界)。<<\b[1-9][0-9]{2,4}\b>>匹配一个在100~99999之间的数字。
· 注意贪婪性
假设你想用一个正则表达式匹配一个HTML标签。你知道输入将会是一个有效的HTML文件，因此正则表达式不需要排除那些无效的标签。所以如果是在两个尖括号之间的内容，就应该是一个HTML标签。
许多正则表达式的新手会首先想到用正则表达式<< <.+> >>，他们会很惊讶的发现，对于测试字符串，“This is a <EM>first</EM> test”，你可能期望会返回<EM>，然后继续进行匹配的时候，返回</EM>。
但事实是不会。正则表达式将会匹配“<EM>first</EM>”。很显然这不是我们想要的结果。原因在于“+”是贪婪的。也就是说，“+”会导致正则表达式引擎试图尽可能的重复前导字符。只有当这种重复会引起整个正则表达式匹配失败的情况下，引擎会进行回溯。也就是说，它会放弃最后一次的“重复”，然后处理正则表达式余下的部分。
和“+”类似，“?*”的重复也是贪婪的。
· 深入正则表达式引擎内部
让我们来看看正则引擎如何匹配前面的例子。第一个记号是“<”，这是一个文字符号。第二个符号是“.”，匹配了字符“E”，然后“+”一直可以匹配其余的字符，直到一行的结束。然后到了换行符，匹配失败(“.”不匹配换行符)。于是引擎开始对下一个正则表达式符号进行匹配。也即试图匹配“>”。到目前为止，“<.+”已经匹配了“<EM>first</EM> test”。引擎会试图将“>”与换行符进行匹配，结果失败了。于是引擎进行回溯。结果是现在“<.+”匹配“<EM>first</EM> tes”。于是引擎将“>”与“t”进行匹配。显然还是会失败。这个过程继续，直到“<.+”匹配“<EM>first</EM”，“>”与“>”匹配。于是引擎找到了一个匹配“<EM>first</EM>”。记住，正则导向的引擎是“急切的”，所以它会急着报告它找到的第一个匹配。而不是继续回溯，即使可能会有更好的匹配，例如“<EM>”。所以我们可以看到，由于“+”的贪婪性，使得正则表达式引擎返回了一个最左边的最长的匹配。
· 用懒惰性取代贪婪性
一个用于修正以上问题的可能方案是用“+”的惰性代替贪婪性。你可以在“+”后面紧跟一个问号“?”来达到这一点。“*”，“{}”和“?”表示的重复也可以用这个方案。因此在上面的例子中我们可以使用“<.+?>”。让我们再来看看正则表达式引擎的处理过程。
再一次，正则表达式记号“<”会匹配字符串的第一个“<”。下一个正则记号是“.”。这次是一个懒惰的“+”来重复上一个字符。这告诉正则引擎，尽可能少的重复上一个字符。因此引擎匹配“.”和字符“E”，然后用“>”匹配“M”，结果失败了。引擎会进行回溯，和上一个例子不同，因为是惰性重复，所以引擎是扩展惰性重复而不是减少，于是“<.+”现在被扩展为“<EM”。引擎继续匹配下一个记号“>”。这次得到了一个成功匹配。引擎于是报告“<EM>”是一个成功的匹配。整个过程大致如此。
· 惰性扩展的一个替代方案
我们还有一个更好的替代方案。可以用一个贪婪重复与一个取反字符集：“<[^>]+>”。之所以说这是一个更好的方案在于使用惰性重复时，引擎会在找到一个成功匹配前对每一个字符进行回溯。而使用取反字符集则不需要进行回溯。
最后要记住的是，本教程仅仅谈到的是正则导向的引擎。文本导向的引擎是不回溯的。但是同时他们也不支持惰性重复操作。
7. 使用“.”匹配几乎任意字符
在正则表达式中，“.”是最常用的符号之一。不幸的是，它也是最容易被误用的符号之一。
“.”匹配一个单个的字符而不用关心被匹配的字符是什么。唯一的例外是新行符。在本教程中谈到的引擎，缺省情况下都是不匹配新行符的。因此在缺省情况下，“.”等于是字符集[^\n\r](Window)或[^\n]( Unix)的简写。
这个例外是因为历史的原因。因为早期使用正则表达式的工具是基于行的。它们都是一行一行的读入一个文件，将正则表达式分别应用到每一行上去。在这些工具中，字符串是不包含新行符的。因此“.”也就从不匹配新行符。
现代的工具和语言能够将正则表达式应用到很大的字符串甚至整个文件上去。本教程讨论的所有正则表达式实现都提供一个选项，可以使“.”匹配所有的字符，包括新行符。在RegexBuddy, EditPad Pro或PowerGREP等工具中，你可以简单的选中“点号匹配新行符”。在Perl中，“.”可以匹配新行符的模式被称作“单行模式”。很不幸，这是一个很容易混淆的名词。因为还有所谓“多行模式”。多行模式只影响行首行尾的锚定(anchor)，而单行模式只影响“.”。
其他语言和正则表达式库也采用了Perl的术语定义。当在.NET Framework中使用正则表达式类时，你可以用类似下面的语句来激活单行模式：Regex.Match(“string”,”regex”,RegexOptions.SingleLine)
· 保守的使用点号“.”
点号可以说是最强大的元字符。它允许你偷懒：用一个点号，就能匹配几乎所有的字符。但是问题在于，它也常常会匹配不该匹配的字符。
我会以一个简单的例子来说明。让我们看看如何匹配一个具有“mm/dd/yy”格式的日期，但是我们想允许用户来选择分隔符。很快能想到的一个方案是<<\d\d.\d\d.\d\d>>。看上去它能匹配日期“02/12/03”。问题在于02512703也会被认为是一个有效的日期。
<<\d\d[-/.]\d\d[-/.]\d\d>>看上去是一个好一点的解决方案。记住点号在一个字符集里不是元字符。这个方案远不够完善，它会匹配“99/99/99”。而<<[0-1]\d[-/.][0-3]\d[-/.]\d\d>>又更进一步。尽管他也会匹配“19/39/99”。你想要你的正则表达式达到如何完美的程度取决于你想达到什么样的目的。如果你想校验用户输入，则需要尽可能的完美。如果你只是想分析一个已知的源，并且我们知道没有错误的数据，用一个比较好的正则表达式来匹配你想要搜寻的字符就已经足够。
8. 字符串开始和结束的锚定
锚定和一般的正则表达式符号不同，它不匹配任何字符。相反，他们匹配的是字符之前或之后的位置。“^”匹配一行字符串第一个字符前的位置。<<^a>>将会匹配字符串“abc”中的a。<<^b>>将不会匹配“abc”中的任何字符。
类似的，$匹配字符串中最后一个字符的后面的位置。所以<<c$>>匹配“abc”中的c。
· 锚定的应用
在编程语言中校验用户输入时，使用锚定是非常重要的。如果你想校验用户的输入为整数，用<<^\d+$>>。
用户输入中，常常会有多余的前导空格或结束空格。你可以用<<^\s*>>和<<\s*$>>来匹配前导空格或结束空格。
· 使用“^”和“$”作为行的开始和结束锚定
如果你有一个包含了多行的字符串。例如：“first line\n\rsecond line”(其中\n\r表示一个新行符)。常常需要对每行分别处理而不是整个字符串。因此，几乎所有的正则表达式引擎都提供一个选项，可以扩展这两种锚定的含义。“^”可以匹配字串的开始位置(在f之前)，以及每一个新行符的后面位置(在\n\r和s之间)。类似的，$会匹配字串的结束位置(最后一个e之后)，以及每个新行符的前面(在e与\n\r之间)。
在.NET中，当你使用如下代码时，将会定义锚定匹配每一个新行符的前面和后面位置：Regex.Match("string", "regex", RegexOptions.Multiline)
应用：string str = Regex.Replace(Original, "^", "> ", RegexOptions.Multiline)--将会在每行的行首插入“> ”。
· 绝对锚定
<<\A>>只匹配整个字符串的开始位置，<<\Z>>只匹配整个字符串的结束位置。即使你使用了“多行模式”，<<\A>>和<<\Z>>也从不匹配新行符。
即使\Z和$只匹配字符串的结束位置，仍然有一个例外的情况。如果字符串以新行符结束，则\Z和$将会匹配新行符前面的位置，而不是整个字符串的最后面。这个“改进”是由Perl引进的，然后被许多的正则表达式实现所遵循，包括Java，.NET等。如果应用<<^[a-z]+$>>到“joe\n”，则匹配结果是“joe”而不是“joe\n”。
9. 单词边界
元字符<<\b>>也是一种对位置进行匹配的“锚”。这种匹配是0长度匹配。
有4种位置被认为是“单词边界”：
1) 在字符串的第一个字符前的位置(如果字符串的第一个字符是一个“单词字符”)
2) 在字符串的最后一个字符后的位置(如果字符串的最后一个字符是一个“单词字符”)
3) 在一个“单词字符”和“非单词字符”之间，其中“非单词字符”紧跟在“单词字符”之后
4) 在一个“非单词字符”和“单词字符”之间，其中“单词字符”紧跟在“非单词字符”后面
“单词字符”是可以用“\w”匹配的字符，“非单词字符”是可以用“\W”匹配的字符。在大多数的正则表达式实现中，“单词字符”通常包括<<[a-zA-Z0-9_]>>。
例如：<<\b4\b>>能够匹配单个的4而不是一个更大数的一部分。这个正则表达式不会匹配“44”中的4。
换种说法，几乎可以说<<\b>>匹配一个“字母数字序列”的开始和结束的位置。
“单词边界”的取反集为<<\B>>，他要匹配的位置是两个“单词字符”之间或者两个“非单词字符”之间的位置。
· 深入正则表达式引擎内部
让我们看看把正则表达式<<\bis\b>>应用到字符串“This island is beautiful”。引擎先处理符号<<\b>>。因为\b是0长度 ，所以第一个字符T前面的位置会被考察。因为T是一个“单词字符”，而它前面的字符是一个空字符(void)，所以\b匹配了单词边界。接着<<i>>和第一个字符“T”匹配失败。匹配过程继续进行，直到第五个空格符，和第四个字符“s”之间又匹配了<<\b>>。然而空格符和<<i>>不匹配。继续向后，到了第六个字符“i”，和第五个空格字符之间匹配了<<\b>>，然后<<is>>和第六、第七个字符都匹配了。然而第八个字符和第二个“单词边界”不匹配，所以匹配又失败了。到了第13个字符i，因为和前面一个空格符形成“单词边界”，同时<<is>>和“is”匹配。引擎接着尝试匹配第二个<<\b>>。因为第15个空格符和“s”形成单词边界，所以匹配成功。引擎“急着”返回成功匹配的结果。
10. 选择符
正则表达式中“|”表示选择。你可以用选择符匹配多个可能的正则表达式中的一个。
如果你想搜索文字“cat”或“dog”，你可以用<<cat|dog>>。如果你想有更多的选择，你只要扩展列表<<cat|dog|mouse|fish>>。
选择符在正则表达式中具有最低的优先级，也就是说，它告诉引擎要么匹配选择符左边的所有表达式，要么匹配右边的所有表达式。你也可以用圆括号来限制选择符的作用范围。如<<\b(cat|dog)\b>>，这样告诉正则引擎把(cat|dog)当成一个正则表达式单位来处理。
· 注意正则引擎的“急于表功”性
正则引擎是急切的，当它找到一个有效的匹配时，它会停止搜索。因此在一定条件下，选择符两边的表达式的顺序对结果会有影响。假设你想用正则表达式搜索一个编程语言的函数列表：Get，GetValue，Set或SetValue。一个明显的解决方案是<<Get|GetValue|Set|SetValue>>。让我们看看当搜索SetValue时的结果。
因为<<Get>>和<<GetValue>>都失败了，而<<Set>>匹配成功。因为正则导向的引擎都是“急切”的，所以它会返回第一个成功的匹配，就是“Set”，而不去继续搜索是否有其他更好的匹配。
和我们期望的相反，正则表达式并没有匹配整个字符串。有几种可能的解决办法。一是考虑到正则引擎的“急切”性，改变选项的顺序，例如我们使用<<GetValue|Get|SetValue|Set>>，这样我们就可以优先搜索最长的匹配。我们也可以把四个选项结合起来成两个选项：<<Get(Value)?|Set(Value)?>>。因为问号重复符是贪婪的，所以SetValue总会在Set之前被匹配。
一个更好的方案是使用单词边界：<<\b(Get|GetValue|Set|SetValue)\b>>或<<\b(Get(Value)?|Set(Value)?\b>>。更进一步，既然所有的选择都有相同的结尾，我们可以把正则表达式优化为<<\b(Get|Set)(Value)?\b>>。
11. 组与向后引用
把正则表达式的一部分放在圆括号内，你可以将它们形成组。然后你可以对整个组使用一些正则操作，例如重复操作符。
要注意的是，只有圆括号“()”才能用于形成组。“[]”用于定义字符集。“{}”用于定义重复操作。
当用“()”定义了一个正则表达式组后，正则引擎则会把被匹配的组按照顺序编号，存入缓存。当对被匹配的组进行向后引用的时候，可以用“\数字”的方式进行引用。<<\1>>引用第一个匹配的后向引用组，<<\2>>引用第二个组，以此类推，<<\n>>引用第n个组。而<<\0>>则引用整个被匹配的正则表达式本身。我们看一个例子。
假设你想匹配一个HTML标签的开始标签和结束标签，以及标签中间的文本。比如<B>This is a test</B>，我们要匹配<B>和</B>以及中间的文字。我们可以用如下正则表达式：“<([A-Z][A-Z0-9]*)[^>]*>.*?</\1>”
首先，“<”将会匹配“<B>”的第一个字符“<”。然后[A-Z]匹配B，[A-Z0-9]*将会匹配0到多次字母数字，后面紧接着0到多个非“>”的字符。最后正则表达式的“>”将会匹配“<B>”的“>”。接下来正则引擎将对结束标签之前的字符进行惰性匹配，直到遇到一个“</”符号。然后正则表达式中的“\1”表示对前面匹配的组“([A-Z][A-Z0-9]*)”进行引用，在本例中，被引用的是标签名“B”。所以需要被匹配的结尾标签为“</B>”
你可以对相同的后向引用组进行多次引用，<<([a-c])x\1x\1>>将匹配“axaxa”、“bxbxb”以及“cxcxc”。如果用数字形式引用的组没有有效的匹配，则引用到的内容简单的为空。
一个后向引用不能用于它自身。<<([abc]\1)>>是错误的。因此你不能将<<\0>>用于一个正则表达式匹配本身，它只能用于替换操作中。
后向引用不能用于字符集内部。<<(a)[\1b]>>中的<<\1>>并不表示后向引用。在字符集内部，<<\1>>可以被解释为八进制形式的转码。
向后引用会降低引擎的速度，因为它需要存储匹配的组。如果你不需要向后引用，你可以告诉引擎对某个组不存储。例如：<<Get(?:Value)>>。其中“(”后面紧跟的“?:”会告诉引擎对于组(Value)，不存储匹配的值以供后向引用。
· 重复操作与后向引用
当对组使用重复操作符时，缓存里后向引用内容会被不断刷新，只保留最后匹配的内容。例如：<<([abc]+)=\1>>将匹配“cab=cab”，但是<<([abc])+=\1>>却不会。因为([abc])第一次匹配“c”时，“\1”代表“c”；然后([abc])会继续匹配“a”和“b”。最后“\1”代表“b”，所以它会匹配“cab=b”。
应用：检查重复单词--当编辑文字时，很容易就会输入重复单词，例如“the the”。使用<<\b(\w+)\s+\1\b>>可以检测到这些重复单词。要删除第二个单词，只要简单的利用替换功能替换掉“\1”就可以了。
· 组的命名和引用
在PHP，Python中，可以用<<(?P<name>group)>>来对组进行命名。在本例中，词法?P<name>就是对组(group)进行了命名。其中name是你对组的起的名字。你可以用(?P=name)进行引用。
.NET的命名组
.NET framework也支持命名组。不幸的是，微软的程序员们决定发明他们自己的语法，而不是沿用Perl、Python的规则。目前为止，还没有任何其他的正则表达式实现支持微软发明的语法。
下面是.NET中的例子：
(?<first>group)(?’second’group)
正如你所看到的，.NET提供两种词法来创建命名组：一是用尖括号“<>”，或者用单引号“’’”。尖括号在字符串中使用更方便，单引号在ASP代码中更有用，因为ASP代码中“<>”被用作HTML标签。
要引用一个命名组，使用\k<name>或\k’name’.
当进行搜索替换时，你可以用“${name}”来引用一个命名组。
12. 正则表达式的匹配模式
本教程所讨论的正则表达式引擎都支持三种匹配模式：
<</i>>使正则表达式对大小写不敏感，
<</s>>开启“单行模式”，即点号“.”匹配新行符
<</m>>开启“多行模式”，即“^”和“$”匹配新行符的前面和后面的位置。
· 在正则表达式内部打开或关闭模式
如果你在正则表达式内部插入修饰符(?ism)，则该修饰符只对其右边的正则表达式起作用。(?-i)是关闭大小写不敏感。你可以很快的进行测试。<<(?i)te(?-i)st>>应该匹配TEst，但是不能匹配teST或TEST.
13. 原子组与防止回溯
在一些特殊情况下，因为回溯会使得引擎的效率极其低下。
让我们看一个例子：要匹配这样的字串，字串中的每个字段间用逗号做分隔符，第12个字段由P开头。
我们容易想到这样的正则表达式<<^(.*?,){11}P>>。这个正则表达式在正常情况下工作的很好。但是在极端情况下，如果第12个字段不是由P开头，则会发生灾难性的回溯。如要搜索的字串为“1,2,3,4,5,6,7,8,9,10,11,12,13”。首先，正则表达式一直成功匹配直到第12个字符。这时，前面的正则表达式消耗的字串为“1,2,3,4,5,6,7,8,9,10,11,”，到了下一个字符，<<P>>并不匹配“12”。所以引擎进行回溯，这时正则表达式消耗的字串为“1,2,3,4,5,6,7,8,9,10,11”。继续下一次匹配过程，下一个正则符号为点号<<.>>，可以匹配下一个逗号“,”。然而<<，>>并不匹配字符“12”中的“1”。匹配失败，继续回溯。大家可以想象，这样的回溯组合是个非常大的数量。因此可能会造成引擎崩溃。
用于阻止这样巨大的回溯有几种方案：
一种简单的方案是尽可能的使匹配精确。用取反字符集代替点号。例如我们用如下正则表达式<<^([^,\r\n]*,){11}P>>，这样可以使失败回溯的次数下降到11次。
另一种方案是使用原子组。
原子组的目的是使正则引擎失败的更快一点。因此可以有效的阻止海量回溯。原子组的语法是<<(?>正则表达式)>>。位于(?>)之间的所有正则表达式都会被认为是一个单一的正则符号。一旦匹配失败，引擎将会回溯到原子组前面的正则表达式部分。前面的例子用原子组可以表达成<<^(?>(.*?,){11})P>>。一旦第十二个字段匹配失败，引擎回溯到原子组前面的<<^>>。
14. 向前查看与向后查看
Perl 5 引入了两个强大的正则语法：“向前查看”和“向后查看”。他们也被称作“零长度断言”。他们和锚定一样都是零长度的（所谓零长度即指该正则表达式不消耗被匹配的字符串）。不同之处在于“前后查看”会实际匹配字符，只是他们会抛弃匹配只返回匹配结果：匹配或不匹配。这就是为什么他们被称作“断言”。他们并不实际消耗字符串中的字符，而只是断言一个匹配是否可能。
几乎本文讨论的所有正则表达式的实现都支持“向前向后查看”。唯一的一个例外是Javascript只支持向前查看。
· 肯定和否定式的向前查看
如我们前面提过的一个例子：要查找一个q，后面没有紧跟一个u。也就是说，要么q后面没有字符，要么后面的字符不是u。采用否定式向前查看后的一个解决方案为<<q(?!u)>>。否定式向前查看的语法是<<(?!查看的内容)>>。
肯定式向前查看和否定式向前查看很类似：<<(?=查看的内容)>>。
如果在“查看的内容”部分有组，也会产生一个向后引用。但是向前查看本身并不会产生向后引用，也不会被计入向后引用的编号中。这是因为向前查看本身是会被抛弃掉的，只保留匹配与否的判断结果。如果你想保留匹配的结果作为向后引用，你可以用<<(?=(regex))>>来产生一个向后引用。
· 肯定和否定式的先后查看
向后查看和向前查看有相同的效果，只是方向相反
否定式向后查看的语法是：<<(?<!查看内容)>>
肯定式向后查看的语法是：<<(?<=查看内容)>>
我们可以看到，和向前查看相比，多了一个表示方向的左尖括号。
例：<<(?<!a)b>>将会匹配一个没有“a”作前导字符的“b”。
值得注意的是：向前查看从当前字符串位置开始对“查看”正则表达式进行匹配；向后查看则从当前字符串位置开始先后回溯一个字符，然后再开始对“查看”正则表达式进行匹配。
· 深入正则表达式引擎内部
让我们看一个简单例子。
把正则表达式<<q(?!u)>>应用到字符串“Iraq”。正则表达式的第一个符号是<<q>>。正如我们知道的，引擎在匹配<<q>>以前会扫过整个字符串。当第四个字符“q”被匹配后，“q”后面是空字符(void)。而下一个正则符号是向前查看。引擎注意到已经进入了一个向前查看正则表达式部分。下一个正则符号是<<u>>，和空字符不匹配，从而导致向前查看里的正则表达式匹配失败。因为是一个否定式的向前查看，意味着整个向前查看结果是成功的。于是匹配结果“q”被返回了。
我们在把相同的正则表达式应用到“quit”。<<q>>匹配了“q”。下一个正则符号是向前查看部分的<<u>>，它匹配了字符串中的第二个字符“i”。引擎继续走到下个字符“i”。然而引擎这时注意到向前查看部分已经处理完了，并且向前查看已经成功。于是引擎抛弃被匹配的字符串部分，这将导致引擎回退到字符“u”。
因为向前查看是否定式的，意味着查看部分的成功匹配导致了整个向前查看的失败，因此引擎不得不进行回溯。最后因为再没有其他的“q”和<<q>>匹配，所以整个匹配失败了。
为了确保你能清楚地理解向前查看的实现，让我们把<<q(?=u)i>>应用到“quit”。<<q>>首先匹配“q”。然后向前查看成功匹配“u”，匹配的部分被抛弃，只返回可以匹配的判断结果。引擎从字符“i”回退到“u”。由于向前查看成功了，引擎继续处理下一个正则符号<<i>>。结果发现<<i>>和“u”不匹配。因此匹配失败了。由于后面没有其他的“q”，整个正则表达式的匹配失败了。
· 更进一步理解正则表达式引擎内部机制
让我们把<<(?<=a)b>>应用到“thingamabob”。引擎开始处理向后查看部分的正则符号和字符串中的第一个字符。在这个例子中，向后查看告诉正则表达式引擎回退一个字符，然后查看是否有一个“a”被匹配。因为在“t”前面没有字符，所以引擎不能回退。因此向后查看失败了。引擎继续走到下一个字符“h”。再一次，引擎暂时回退一个字符并检查是否有个“a”被匹配。结果发现了一个“t”。向后查看又失败了。
向后查看继续失败，直到正则表达式到达了字符串中的“m”，于是肯定式的向后查看被匹配了。因为它是零长度的，字符串的当前位置仍然是“m”。下一个正则符号是<<b>>，和“m”匹配失败。下一个字符是字符串中的第二个“a”。引擎向后暂时回退一个字符，并且发现<<a>>不匹配“m”。
在下一个字符是字符串中的第一个“b”。引擎暂时性的向后退一个字符发现向后查看被满足了，同时<<b>>匹配了“b”。因此整个正则表达式被匹配了。作为结果，正则表达式返回字符串中的第一个“b”。
· 向前向后查看的应用
我们来看这样一个例子：查找一个具有6位字符的，含有“cat”的单词。
首先，我们可以不用向前向后查看来解决问题，例如：
<< cat\w{3}|\wcat\w{2}|\w{2}cat\w|\w{3}cat>>
足够简单吧！但是当需求变成查找一个具有6-12位字符，含有“cat”，“dog”或“mouse”的单词时，这种方法就变得有些笨拙了。
我们来看看使用向前查看的方案。在这个例子中，我们有两个基本需求要满足：一是我们需要一个6位的字符，二是单词含有“cat”。
满足第一个需求的正则表达式为<<\b\w{6}\b>>。满足第二个需求的正则表达式为<<\b\w*cat\w*\b>>。
把两者结合起来，我们可以得到如下的正则表达式：
<<(?=\b\w{6}\b)\b\w*cat\w*\b>>
具体的匹配过程留给读者。但是要注意的一点是，向前查看是不消耗字符的，因此当判断单词满足具有6个字符的条件后，引擎会从开始判断前的位置继续对后面的正则表达式进行匹配。
最后作些优化，可以得到下面的正则表达式：
<<\b(?=\w{6}\b)\w{0,3}cat\w*>>
15. 正则表达式中的条件测试
条件测试的语法为<<(?ifthen|else)>>。“if”部分可以是向前向后查看表达式。如果用向前查看，则语法变为：<<(?(?=regex)then|else)>>，其中else部分是可选的。
如果if部分为true，则正则引擎会试图匹配then部分，否则引擎会试图匹配else部分。
需要记住的是，向前先后查看并不实际消耗任何字符，因此后面的then与else部分的匹配时从if测试前的部分开始进行尝试。
16. 为正则表达式添加注释
在正则表达式中添加注释的语法是：<<(?#comment)>>
例：为用于匹配有效日期的正则表达式添加注释：
(?#year)(19|20)\d\d[- /.](?#month)(0[1-9]|1[012])[- /.](?#day)(0[1-9]|[12][0-9]|3[01])
16 Dec 2009
gpedit.msc in Windows XP Home
There's no gpedit.msc within Windows XP Home Edition.
If you really want to use it, read this entry carefully.
It's stupid simple.
If you really want to use it, read this entry carefully.
It's stupid simple.
1, download the rar file from HERE 2, decompress the file with winrar or 7-zip 3, run the exe file 4, it's ok now. Run gpedit.msc and enjoy.
7 Dec 2009
Python标准库手册 - 2. 内置函数 - 3 & 3. 次要内置函数
2. 内置函数 - 3:S-Z
set([iterable])
返回一个新集合,元素来自可选参数iterable.set类型在集合类型中有描述 - set, frozenset.
其他容器请参看内置dict,list,tuple类和collections模块.
2.4版本新增
setattr(object, name, value)
这是getattr()的对应函数.参数分别是对象,字符串和任意值.字符串可能是一个已有属性或者新的属性.如果object允许,此函数会将value指定给对应属性.例如setattr(x, 'foobar', 123)等价于x.foobar = 123.
slice([start], stop[, step])
返回由range(start, stop, step)指定的索引集合表示的切片对象.start和step参数默认为None.切片对象含有只读数据属性start, stop和step,它们仅仅返回参数值(或者默认值),而无其他明确的功能;然而它们被Numerical Python和其他第三方扩展使用.扩展索引语句也会生成切片对象.例如: a[start:stop:step]或者a[start:stop, i].参考返回迭代器的替代版本itertools.islice().
sorted(iterable[, cmp[, key[, reverse]]])
根据iterable的元素,返回一个排过序的新列表.
可选参数cmp, key和reverse与list.sort()方法的参数意义相同(在可变序列类型一节有描述).
cmp指定一个个性化的2参数(迭代器元素)的比较函数,该函数根据第一个参数小于,等于或者大于第二个参数返回负数,0或者正数: cmp=lambda x,y: cmp(x.lower(), y.lower()).默认值是None.
key指定一个从每个列表元素提取比较键值的单参数函数: key=str.lower.默认值为None.
reverse是一个布尔值.如果为True,列表元素的排序会把每次比较都颠倒.
总的来说,key和reverse转换过程比指定一个等价的cmp函数快得多.这是因为对每个列表元素cmp会被多次调用,而key和reverse仅访问每个元素一次.转换老式cmp函数为key函数,请参考ASPN食谱-CmpToKey偏方.
2.4版本新增
staticmethod(function)
返回function的静态方法.
静态方法不接受隐含第一参数.采用如下方式定义一个静态方法:
class C: @staticmethod def f(arg1, arg2, ...): ...
@staticmethod形式是函数修饰符 - 参看函数定义一节详细描述.
它可被类(C.f())或者实例(C().f())调用.实例会被忽略.
Python的静态方法与Java或者C++类似.高级概念参看本节classmethod().
更多信息请参考标准类型层次的文档.
2.2版本新增.
2.4版本改动:增加函数修饰符.
str([object])
返回表示object可美观打印的描述字符串.对于字符串对象,返回字符串本身.与repr(object)的不同在于,str(object)不会总尝试返回可被eval()接受的字符串;它的目标是返回一个可打印字符串.如果没有参数,返回空字符串''.
关于字符串更多信息参看序列类型功能描述(字符串也是序列) - str, unicode, list, tuple, buffer, xrange,或者字符串方法一节描述的字符特殊方法.使用模板字符串或者%操作符(字符串格式化操作章节)输出格式化字符串.另外也可参考字符串服务章节,或者unicode().
sum(iterable[, start])
从start开始,对iterable的所有元素从左至右求和,并返回.start默认值为0.iterable的元素一般为数字,不能为字符串.快速正确的字符串序列连接方法是调用''.join(sequence).注意sum(range(n), m)等价于reduce(operator.add, range(n), m).浮点值扩展精度加法参考math.fsum().
2.3版本新增
super(type[, object-or-type])
返回一个调用type父类或者胞类的方法的代理对象.在访问类中被重载的继承方法时很有用.搜索顺序与getattr()相同,但是type本身会被跳过.
type的__mro__属性列出getattr()和super()使用的方法判定搜索顺序.这个属性是动态的,且继承层次更新时会被改变.
如果第二个参数省略,返回的super对象是非绑定的.如果第二参数是object, isinstance(obj, type)必须为真.如果第二个参数是一个type, issubclass(type2, type)必须为真(类方法很有用).
注意:
super()只对新式类有效.
super有2个典型应用.单重继承的类层次,super可以不用明确指明名称指代父类,得以提高代码的可维护性.这种用法跟其他编程语言的super极为相似.
第二种用法在动态执行环境下支持合作多重继承.这种用法仅在python中有,绝对不会在静态编译语言或者只支持单重继承的语言中发现.这样让实现"钻石图"成为可能 - 多个基类做实同一个方法.好的设计让这个方法在各种情况下有相同的调用签名(由于调用顺序在执行时被确定,也由于顺序适应类层次的改变,还由于顺序包含在运行之前不知道的兄弟类).
两种情况下,典型的超类调用如下:
class C(B): def method(self, arg): super(C, self).method(arg)
注意super()做实为显式点属性查找绑定过程的一部分,例如super().__getitem__(name).它做实自己的__getattribute__()方法以可预知的,支持合作多重继承的顺序来搜索类.相应的,对于使用语句或者操作符的形如super()[name]的隐式查找,super()并未定义.
还要注意,super()不仅限于用作内部方法.两个参数的形式指明了参数并且做了恰当的引用.
2.2版本新增
tuple([iterable])
返回一个元组,其元素与iterable元素相同且有相同的顺序.iterable可能是序列,支持迭代的容器,或者一个迭代对象.如果iterable已经是tuple,不做任何修改返回它.例如,tuple('abc')返回('a','b','c'),tuple([1,2,3])返回(1,2,3).如果未指定参数,返回新的空元组, ().
元组是不可变序列类型,在序列类型中有文档 - str, unicode, list, tuple, buffer, xrange.其他容器参看内置类dict, list,set和collections模块.
type(object)
返回对象的类型.返回值是类型对象.推荐使用内置函数isinstance()来测试对象的类型.
下面会介绍含有3个参数的type()函数作为构建器使用.
type(name, bases, dict)
返回一个新的类型对象.这是类语句本质上的动态形式.name字符串是类名,会变成__name__属性;bases元组逐条列出基类,会变成__bases__属性;dict字典是包含类体定义的命名空间,会变成__dict__属性.例如,如下的2条语句创建了相同的类型对象:
>>> class X(object):
... a = 1
...
>>> X = type('X', (object,), dict(a=1))
2.2版本新增
unichr(i)
返回unicode码是整数i的字符的unicode字符串.例如,unichr(97)返回字符串u'a'.对于unicode字符串,这是ord()函数的逆函数.参数的有效范围基于python如何配置 - 可能是UCS2 [0..0xFFFF]或者UCS4 [0..0x10FFFF].否则抛出ValueError异常.对于ASCII和8位字符串参看chr().
2.0版本新增
unicode([object[, encoding[, errors]]])
根据下面的模式,返回object的unicode字符串版本:
如果encoding和/或者error该出,unicode()将使用encoding的解码器对克表示为8位字符串或者字符缓冲区的object解码.encoding参数是一个字符串,它指定了编码的名称;如果是未知的encoding会抛出LookupError异常.异常处理机制会根据errors处理异常;它指定了输入编码字符无效时的处理方式:如果errors是'strict'(默认)会抛出ValueError异常;如果是'ignore'则忽略;'replace'会使用官方unicode替换字符U+FFFD替换不能被编码的输入字符.参考codecs模块.
如果没有给出可选参数,unicode()的行为类似str(),区别是返回的是Unicode字符串而非8位字符串.明确点说就是,如果对象是Unicode字符串或其子类,将会返回Unicode字符串,而不会附加任何编解码.
对于提供了__unicode__()方法的对象,会直接无参数呼叫这个函数创建一个unicode字符串.对于其他对象,则请求一个8位字符串版本或者描述,然后使用默认编码器并以'strict'模式转换为unicode字符串.
关于unicode字符串的更多信息,请参看描述序列功能的序列类型-str(字符串),unicode,list(列表),tuple(元组),buffer,xrange(unicode字符串也是序列),也可以参考字符串方法一节具体关于字符串的方法.为了输出格式化字符串,可以使用字符串格式化操作符一节提供的模板字符串或者%操作符方法,也可参考字符串服务一节.参考str().
2.0版本新增
2.2版本改动: 支持__unicode__().
vars([object])
没有参数时,类似locals().
如果指定参数为模块,类或者类实例对象(或其他拥有__dict__属性的对象),返回其属性.
注意:
返回的字典不可编辑: 对相应的符号表的影响未定义.(目前的实现中,局部变量绑定一般不会被如此影响,但从其他作用域(例如模块)获得的变量会受此影响.可能将来版本会有改变.)
xrange([start], stop[, step])
本函数非常类似range(),但是返回一个"xrange"对象而非列表.这是一个不明序列类型,与相应的列表有相同的值,但是并非同时储存这些值.与range()相比,一般情况下xrange()的优势很小(由于xrange()仍然需要在请求值时创建这些值),除非请求的range范围极大而机器内存有限;或者并非所有range的元素会被使用(例如一个循环可能被中途break跳出).
CPython实现细节: xrange()是简单而快速的.实现可能添加了一些约束来达到此目的.Python的C实现约定所有参数都是原生C的long类型(python的short整型),并要求元素的个数也满足原生C的long类型.如果需要更大的范围,可以使用itertools模块来提供一个代替版本: islice(cout(start,step),(stop-start+step-1)//step).
zip([iterable, ...])
本函数返回一个列表或元组,其中第i个元组包含每个序列或迭代器参数的第i个元素.返回的列表长度会被截断与最短的序列参数等长.当多个等长参数,zip()与初值参数为None的map()非常类似.如果只有一个序列参数,返回仅含一个元组的列表.如果没有参数,返回一个空列表.
迭代器按照从左至右顺序赋值,因此可以使用此函数将一系列数据聚类为长度为n的群: zip(*[iter(s)]*n).
zip()与*操作符连用可被用来解压一个列表.
>>> x = [1, 2, 3] >>> y = [4, 5, 6] >>> zipped = zip(x, y) >>> zipped [(1, 4), (2, 5), (3, 6)] >>> x2, y2 = zip(*zipped) >>> x == list(x2) and y == list(y2) True
2.0版本新增
2.4版本改动:此版本前,zip()要求至少一个参数,如果没有指定参数,会抛出TypeError异常而非返回空列表.
__import__(name[, globals[, locals[, fromlist[, level]]]])
注意:
这是一个高级函数,日常Python编程不会用到.
本函数会被import声明调用.它可被替代以改变import声明的语义(导入内置模块并指定builtins.__import__),但如今使用import钩子很容易(参考PEP302).直接使用__import__()很少见,除非你想导入一个模块,而此模块的名称仅在运行时可知).
本函数导入模块name,后台使用给定的globals和locals来决定如何解释包里面名称.fromlist指定了需要从name模块中导入的对象或者子模块的名称.标准的实现根本不会使用locals参数,仅使用globals来决定import声明的包内容.
level指定了使用绝对或者相对导入.默认值为-1,表示绝对和相对导入都会被尝试.0表示仅使用绝对导入.正值表示相对呼叫__import__()的模块的路径需要搜索的父路径数目.
当name变量形式为package.module,一般的,顶层package(点之前的名称)被返回,而非name指定的模块.但是,如果给出非空参数fromlist,name指定的模块被返回.
例如,语句import spam返回的字节码类似于下面的代码:
spam = __import__('spam', globals(), locals(), [], -1)
而语句import spam.ham的结果
spam = __import__('spam.ham', globals(), locals(), [], -1)
注意:为何这儿__import()返回顶层模块,由于此模块被import语句绑定了一个名称.
另一方面,语句from spam.ham import eggs, sausage as saus的结果如下:
_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], -1)
eggs = _temp.eggs
saus = _temp.sausage
这儿,spam.ham模块被__import__()返回,待导入的名称从此对象获取并指定为相应的名称.
如果你仅仅想简单使用name导入一个模块(在一个包中),可以呼叫__import__()然后查看sys.modules:
>>> import sys >>> name = 'foo.bar.baz' >>> __import__(name) <module 'foo' from ...> >>> baz = sys.modules[name] >>> baz <module 'foo.bar.baz' from ...>
2.5版本新增: 添加level参数; 参数支持关键字.
3. 非必要内置函数
现代的Python编程时有一些内置函数不再需要学习,使用甚至知道.保留于此仅为了保持向后兼容那些使用老版本python写的程序.
Python程序员,培训人员,学生和书籍作者可以直接跳过这些函数而不用考虑是否错过了某些重要的东西.
apply(function, args[, keywords])
function参数必须是一个可被调用的对象(用户指定或内置函数或者方法,或者一个类对象),args参数必须是一个序列.以args作为参数列表呼叫function函数,参数对象是元组的长度.如果可选参数keywords指定,必须是一个字典并且字典的键值都是字符串.它指定了要被附加到参数列表末尾的关键字参数.呼叫apply()与直接呼叫function(args)是不同的,由于直接呼叫永远都有且仅有一个参数,而apply()相当于呼叫function(*args,**keywrods).
2.3版本改动: 使用扩展呼叫语法 *args和**keywords.
buffer(object[, offset[, size]])
object参数必须是支持buffer呼叫接口的对象(例如字符串,数组和buffer).根据对象的参数会创建一个新的buffer对象,该对象是从object对象的开始(或者offset指定的偏移)的切片.切片会扩展到object对象的结尾(或者size参数指定的长度).
coerce(x, y)
返回一个元组,包含2个数值元素并使用与数学操作符相同的规则转换为一个普通类型.如果无法执行coerce操作,抛出TypeError异常.
intern(string)
将string输入被interned的字符串的表中兵返回该字符串-返回字符串本身或者其拷贝.此方法在字典查找时略有小小的性能提高-如果字典的键值被interned,同时待查找的键值也被interned,键值比较(哈希之后)会使用指针比较而非字符串比较.一般的,Python中使用的名称都被自动interned,字典被用来保持模块,类或者实例属性拥有interned键值.
2.3版本改动:interned字符串不再被长期保存(像2.2版本及之前的版本中那样);你必须保存intern()返回值的参考以从此方法中得到便利.
<<2. 内置函数-2:I-R >>目录 >>4. 内置常量
Python标准库手册 - 2. 内置函数 - 2
2. 内置函数 - 2: I-R
id(object)
返回object的标识符.结果是整型(或者长整型),在其生命周期内保证唯一且不变.2个生命周期不重叠的对象可能含有相同的id()值.
CPython实现细节:这是object的地址.
input([prompt])
等价于eval(raw_input(prompt))
警告:
如果用户输入错误,此函数并不安全!它要求一个合法的Python表达式作为输入;如果输入有语法错误,会抛出SyntaxError异常.当执行时,其他异常也可能被抛出.(另一方面,高级用户写快速脚本是正想得到如此的结果?)
如果导入了readline模块,input()会使用它来提供详尽的行编辑和历史功能.
通常情况下应考虑使用raw_input()函数.
int([x[, base]])
将一个字符串或者数字转换为整型.如果参数是字符串,必须包含能被表示为Python整型的十进制符号数,该字符串可被嵌入白空格.base参数为转换提供了基(默认是10),它可能是属于[2,36]的任意整数或者0.如果base是0,取决于字符串的内容,会检测一个合适的基;表现形式与整型相同.(参考数值)如果base存在且x不是字符串,会抛出TypeError异常.否则参数可能是整型或者长整型或者浮点数.浮点数转换成整型会被截尾(向0).如果参数超出整型范围会返回一个长整型对象.如果不指定参数,返回0.
整数类型在数值类型一节有描述 - int, float, long, complex.
isinstance(object, classinfo)
如果object参数是classinfo参数的实例,或者是它的(直接或者间接)子类返回true.如果classinfo是一个类型对象(新型类)且object是该类型的对象或者(直接或间接)子类,也会返回true.如果object不是类实例或者给定类型的对象,返回false.如果classinfo既非类对象也非类型对象,它可能是类对象或者类型对象的元组,或者递归包含其他类似元组(其他序列类型不可被接受).如果classinfo不是类,类型,也不是类或类型等这些元组,会抛出TypeError异常.
2.2版本改动:支持类型信息元组.
issubclass(class, classinfo)
如果class是classinfo的(直接或间接)子类返回true.任何类都是自身的子类.classinfo可以使类对象的元组,此时classinfo的每个元素都会执行检测.其他情况下,会抛出TypeError异常.
2.3版本改动:支持类型信息元组.
iter(o[, sentinel])
返回一个迭代对象.根据第二个参数的不同,第一个参数会有不同的解释.如果没有第二个参数,o必需是一个支持迭代协议(__iter__()方法)的对象集合,或者必需支持序列协议(从0开始的整型参数的__getitem()方法).如果它不支持这两种协议,会抛出TypeError异常.如果第二个参数sentinel给出,那么o必须是一个可调用的对象.此时迭代器创建时会无参数调用它的next()方法;如果返回结果等于sentinel,会抛出StopIteration异常,否则返回该结果.
非常有用的iter()第二种形式应用是按行读取一个文件,直至某一特定行.下面的例子按行读取一个文件,直到读到'STOP':
with open("mydata.txt") as fp:
for line in iter(fp.readline, "STOP"):
process_line(line)
2.2版本新增
len(s)
返回一个对象的长度(元素的数目).参数必须是一个序列(字符串,元组或者列表)或者映射(字典).
list([iterable])
返回一个列表,其元素与iterable相同且元素顺序相同.iterable可能是一个序列,支持迭代的容器或者一个迭代对象.如果iterable是一个列表,会拷贝一份返回,类似于iterable[:].例如list('abc')返回['a','b','c'],list((1,2,3))返回[1,2,3].如果未指定参数,返回一个空列表[].
列表是一个可变序列类型,归档于序列类型 - str, unicode, list, tuple, buffer, xrange.其他容器请参考内置类dict, set和tuple, 和collections模块.
locals()
更新并返回表示当前局部符号表的一个字典.在函数代码块内调用locals()会返回自由变量,但是类代码块内则不会.
注意:
该字典的内容不应被修改;改变可能不会影响local的值和解释器使用的自由变量.
long([x[, base]])
将字符串或者数字转换为长整型.如果参数是字符串,必须包含任意大小的符号数,可能嵌入白空格.base参数的解释方式与int()相同,只有在x是字符串是才需要给出.否则,参数可以是整型,长整型或者浮点数,会返回相同值的长整型.浮点数转换为整型会向0截尾.如果没有参数,返回0L.
长整型请参考数值类型 - int, float, long, complex.
map(function, iterable, ...)
对iterable的每个元素应用function,并返回结果列表.如果有额外的iterable参数,function会同时取这些iterables的元素为参数执行.如果一个iterable长度小于另一个,默认会用None扩展为相同长度.如果function是None,默认使用恒等函数;如果有多个参数,map()返回一个有元组组成的列表,其中元组包含所有iterables的对应元素(类似于对应操作).iterable参数可以使序列或者其他迭代对象.结果永远是列表.(例子翻译时加的)例如:
>>> a = [1,2,3]<br /> >>> b = ['a','b','c']<br /> >>> map(None,a,b)<br /> [(1, 'a'), (2, 'b'), (3, 'c')]<br />
max(iterable[, args...][, key])
如果仅有iterable参数,返回非空iterable的最大元素(例如字符串,元组和列表).多于一个参数时,返回其中最大的.
可选参数key指定了一个形如list.sort()的单参数排序函数.如果给定key参数,必须用关键字形式(例如: max(a,b,c,key=func)).
2.5版本改动:支持可选参数key.
min(iterable[, args...][, key])
如果仅有iterable参数,返回非空iterable的最小元素(例如字符串,元组和列表).多于一个参数时,返回其中最小的.
可选参数key指定了一个形如list.sort()的单参数排序函数.如果给定key参数,必须用关键字形式(例如: max(a,b,c,key=func)).
2.5版本改动:支持可选参数key.
next(iterator[, default])
调用iterator的next方法取得其下一个元素.如果default参数给定,如果iterator结束返回default,否则抛出StopIteration异常.
2.6版本新增
object()
返回一个新的对象.object是所有新型类的基础.它有所有新型类实例共有的方法.
2.2版本新增.
2.3版本改动:该函数不接受任何参数.以前版本可以传入参数,但是会被忽略.
oct(x)
将整型数字(任意大小)转换为八进制字符串.结果是有效的Python表达式.
2.4版本改动:以前只返回无符号数
open(filename[, mode[, bufsize]])
打开一个文件,返回一个文件对象(文件对象一节有描述).如果文件不能打开,抛出IOError异常.当需要打开文件时,最好采用open()而非直接调用文件构建器.
前2个参数与stdio的fopen()参数相同:filename是要打开文件名,mode是文件读写类型字符串.
最常用的mode值是'r'-读和'w'-写(会覆盖已存在文件)和'a'-追加(在某些Unix系统上会无视当前位置直接追加到文件末尾).如果省略mode,默认是'r'.默认使用文本类型,当写回文件再读取时会将'\n'转换为平台相关的表示方法.因此,当打开二进制文件时,应该给mode添加'b'以使用二进制读写,这会增加可移植性.(即使在不区分二进制与文本文件而一概视为文档的系统上,添加'b'也是非常有用的)下面列出了mode参数的其他可取值.
可选参数bufsize指定了缓冲区大小:0是无缓冲,1是行缓冲,其他整数则使用(近似)该数大小的缓冲区,负值bufsize则使用系统默认(tty设备是行缓冲,其他文件是全缓冲).如果省略,使用系统默认缓冲区大小.-脚注[2]
模式'r+','w+'和'a+'可以更新文件(注意'w+'会覆盖文件).添加'b'模式可以在区别对待文本文件和二进制文件的系统上,以二进制方式打开文件;在无区别系统上,'b'不起作用.
除标准fopen()的模式外,还有'U'或者'rU'.编译Python时通常有通用新行支持;'U'会以文本方式打开文件,但是行会以下列方式之一终止:Unix行结束标志'\n';Mac行结束标志'\r'或者Windows行结束标志'\r\n'.Python一律按照'\n'对待所有这些表示.如果Python编译时没有通用新行支持,'U'与普通文本模式相同.注意:以这种方式打开的文件对象也有一个叫新行的属性,其值为None(如果没有新行被读取),'\n','\r','\r\n'或者包含所有以读取的新行类型的元组.
Python强制模式添加'U'后,以'r','w','a'开始.Python提供了许多文件处理模块,包含fileinput, os, os.path, tempfile和shutil.
2.5版本改动:限定mode字符串的第一个字母.
ord(c)
给定长度为1的字符串c,当是一个unicode对象或者当参数是一个8位字符串时是其字节值,返回表示其Unicode码的整数.例如,ord('a')返回整数97,ord(u'\u2020')返回8224.对于8位字符串,这是chr()的逆函数;对于unicode对象,则是unichr()的逆函数.如果python基于unicode UCS2编译且给定unicode参数,则该字符的码点必须在范围[0...65535],否则字符串长度是2,抛出TypeError异常.
pow(x, y[, z])
返回x的y次幂,如果有z,则返回x的y次幂对z取模(比pow(x,y) % z效率高).两个参数形式的pow(x, y)等价于幂运算符: x**y.
参数必须是数值类型.对于混合操作数类型,会使用二元运算符强制转换规则.对于整型和长整型操作数,结果与操作数类型相同(强制转换后),除非第二个参数是负数,此时所有的参数被转换为浮点数,结果也是浮点数.例如,10**2返回100,但是10**-2返回0.01.(2.2版本新增负指数.2.1版本以前,如果2个参数均为整型且第二个参数为负,会抛出异常.)如果第二个参数是负数,第三个参数必须被省略.如果有参数z,x和y必须是整型且y非负.(2.2版本新增的限定.2.1版本之前,浮点3参数pow()函数会根据平台浮点数舍入规则,返回平台相关的结果.)
print([object, ...][, sep=' '][, end='\n'][, file=sys.stdout])
打印object(s)到文件流,以sep分隔以end结束.sep,end,file参数如果有,必须以关键字形式给出.
所有非关键字形式参数会被转换成字符串(如函数str()),以sep分隔end结束写入流.sep和end都必须是字符串,但也可以是None,这是使用默认值.如果object没有给出,print()写入end.
file参数必须是一个有write(string)方法的对象;如果没有给出或者是None,使用sys.stdout.
注意:
一般情况下,由于print被认为是print语句,此函数不会被看做内置函数.为了禁用这个功能以使用print()功能,可以在模块顶部使用future语句:
from __future__ import print_function
2.6版本新增
property([fget[, fset[, fdel[, doc]]]])
返回新类(从对象衍生出来的类)property属性.
fget是获得属性值的函数,正如fset是设置属性值的函数,fdel是删除属性值的函数.典型用法是定义托管属性x:
class C(object):<br /> def __init__(self):<br /> self._x = None<br /><br /> def getx(self):<br /> return self._x<br /> def setx(self, value):<br /> self._x = value<br /> def delx(self):<br /> del self._x<br /> x = property(getx, setx, delx, "I'm the 'x' property.")<br />
如果给出doc参数,必须是property属性的文档字符串.否则,property会拷贝fget的文档字符串(如果存在).这样可以用property()作为修饰符来创建只读属性:
class Parrot(object):<br /> def __init__(self):<br /> self._voltage = 100000<br /><br /> @property<br /> def voltage(self):<br /> """Get the current voltage."""<br /> return self._voltage<br />
上述代码将voltage()方法转换为有相同名称的"getter"来获得只读属性.
property对象含有getter, setter和deleter方法,可以用作修饰函数使用对应的存取函数创建property的拷贝.下面的例子是个极好的解释:
class C(object):<br /> def __init__(self):<br /> self._x = None<br /><br /> @property<br /> def x(self):<br /> """I'm the 'x' property."""<br /> return self._x<br /><br /> @x.setter<br /> def x(self, value):<br /> self._x = value<br /><br /> @x.deleter<br /> def x(self):<br /> del self._x<br />
上面的代码与第一个例子完全相同,可以提供附加函数与原property函数相同的名称(上面例子中的x).
返回的属性也包含fget, fset和fdel属性,这些属性与构建其参数相关.
2.2版本新增.
2.5版本改动: 如果没有文档字符串,则使用fget的文档字符串.
2.6版本改动: 新增getter, setter和deleter属性.
range([start], stop[, step])
这是一个通用函数,可以用以创建包含算数序列的列表.通常被用于for循环.参数必须是整型.如果step参数省略,默认是1;如果start参数省略,默认是0.所有参数齐全时返回一个整型列表[start, start + step, start + 2 * step, ...].如果step为正值,最后一个元素是最大值start + i * step(小于stop);如果step为负值,最后一个元素是最小值start + i * step(大于stop).step必需非零,否则抛出ValueError异常.例如:
>>> range(10)<br /> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]<br /> >>> range(1, 11)<br /> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]<br /> >>> range(0, 30, 5)<br /> [0, 5, 10, 15, 20, 25]<br /> >>> range(0, 10, 3)<br /> [0, 3, 6, 9]<br /> >>> range(0, -10, -1)<br /> [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]<br /> >>> range(0)<br /> []<br /> >>> range(1, 0)<br /> []
raw_input([prompt])
如果prompt参数给出,它会被写到标准输出(末尾无新行),然后该函数会读取一行并转换为字符串作为输入(扔掉结尾的新行符)并返回该字符串.如果输入为EOF,抛出EOPError异常.例如:
>>> s = raw_input('--> ')<br /> --> Monty Python's Flying Circus<br /> >>> s<br /> "Monty Python's Flying Circus"<br /> 如果readline模块被加载,raw_input()会使用它来提供复杂的行编辑和历史功能.
reduce(function, iterable[, initializer])
对iterable的元素,从左至右循环应用2个参数的function,最后得到一个值.例如,reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])计算((((1+2)+3)+4)+5).左参数x是累加值,右参数y是迭代的更新值.如果可选参数initializer给出,它会被作为迭代运算的初始值;如果iterable为空则作为默认值返回.如果initializer未给出且iterable仅包含一个元素,则返回该元素.
reload(module)
重新加载一个已被导入的模块.参数必须是一个模块对象,它之前必须被成功导入过.当使用外部编辑器编辑过某个模块的源码,并且想在不离开python解释器的情况下试用新版本时,这个函数很有用.返回值是模块对象(与module参数相同)
当reload(module)被执行时:
* python模块代码被重新编译,模块级代码被重新执行,定义一个新的绑定到模块字典中名称的对象集合.扩展模块init函数不会被再次执行.
* 如python中的所有其他对象,原有的对象仅在它们的为0计数时才会被回收.
* 模块命名空间的名称会被更新以指向新增或改动的对象.
* 其他旧对象的引用(例如模块之外的名称)不会重新绑定到新的对象,如有必要,它们必须在各自的命名空间被更新.
其他警告:
如果一个模块语法正确却初始化出错,第一次导入时会无法局部绑定名称,却会在sys.modules中产生一个(部分初始化的)模块对象.要重新载入该模块,必须再reload()之前先再次导入(会绑定名称到部分初始化的模块对象).
当一个模块被重新载入,它的字典(包含模块的全局变量)会保留.新的名称定义会覆盖旧的定义,因此一般情况下不会造成问题.如果新版本的模块没有定义在旧模块中已有定义的名称,旧的定义会保留.这个特性可以看作是模块的优点因为它维护了一份全局对象的表或者缓存 - 如有需要,可在try语句中测试表或者跳过初始情况:
try:<br /> cache<br /> except NameError:<br /> cache = {}<br /> 一般情况下,除了sys, __main__和__builtin__,重新载入内置或者动态装载模块不是很有用.然而很多情况下,扩展模块被设计为不会初始化多次,在重新装载时某些情况下可能出错.
当一个模块使用from ... import ...从另一个模块中导入对象,被导入模块调用reload()并不会重新定义从它中导入的对象 - 一个办法是重新执行from语句,另一种办法是使用import和限定名称(module.*name*).
如果一个模块实例化了一个类实例,重新载入定义该类的模块并不会影响实例定义的方法 - 它们会按照原有类定义的方式使用.这条规则同样适用于衍生类.
repr(object)
返回一个对象的描述字符串,与转换函数生成的值相同(反向引用).此函数可以作为普通函数使用.对于许多类型,此函数尝试返回一个字符串,是把该类型传递给eval()时产生的同名对象;否则描述是尖括号中的一个字符串,该字符串包含了对象和附加信息(通常包含对象的名称和地址)的类型的名称.类可以通过定义__repr__()方法来控制其实例的repr函数返回值.
reversed(seq)
返回一个逆序迭代器.seq必须是一个有__reversed__()方法的对象,或者支持序列协议(__len__()方法和从0开始整数参数的__getitem__()方法).
2.4版本新增.
2.6版本改动:增加个性化__reversed__()方法的可能.
round(x[, n])
返回浮点数x四舍五入到小数点后n位的结果.如果n省略,默认为0.结果是浮点数,会向最近的10**(-n)的倍数四舍五入;如果2个倍数同等接近,四舍五入向离开0的方向(例如,round(0.5)结果为1.0,round(-0.5)结果为-1.0).
<<2. 内置函数 - 1:A-H >>目录 >>2. 内置函数 - 3:S-Z
29 Nov 2009
python处理word
利用win32com接口直接调用office API，好处是简单、兼容性好，只要office能处理的，python都可以处理，处理出来的结果和office word里面“另存为”一致。
当然你也可以用上面的代码将word文件转换成任意格式文件（只要office 2007支持，比如将word文件转换成PDF文件，把8改成17即可），下面是office 2007支持的全部文件格式对应表：
照着字面意思应该能对应到相应的文件格式，如果你是office 2003可能支持不了这么多格式。word文件转html有两种格式可选wdFormatHTML、wdFormatFilteredHTML（对应数字 8、10），区别是如果是wdFormatHTML格式的话，word文件里面的公式等ole对象将会存储成wmf格式，而选用 wdFormatFilteredHTML的话公式图片将存储为gif格式，而且目测可以看出用wdFormatFilteredHTML生成的HTML 明显比wdFormatHTML要干净许多。
当然你也可以用任意一种语言通过com来调用office API.
#!/usr/bin/env python关键的就是doc.SaveAs(’d:/labs/math.html’, 8)这一行，网上很多文章写成：doc.SaveAs(’d:/labs/math.html’, win32com.client.constants.wdFormatHTML)，直接报错：
#coding=utf-8
from win32com import client as wc
word = wc.Dispatch('Word.Application')
doc = word.Documents.Open('d:/labs/math.doc')
doc.SaveAs('d:/labs/math.html', 8)
doc.Close()
word.Quit()
AttributeError: class Constants has no attribute ‘wdFormatHTML’
当然你也可以用上面的代码将word文件转换成任意格式文件（只要office 2007支持，比如将word文件转换成PDF文件，把8改成17即可），下面是office 2007支持的全部文件格式对应表：
wdFormatDocument = 0 wdFormatDocument97 = 0 wdFormatDocumentDefault = 16 wdFormatDOSText = 4 wdFormatDOSTextLineBreaks = 5 wdFormatEncodedText = 7 wdFormatFilteredHTML = 10 wdFormatFlatXML = 19 wdFormatFlatXMLMacroEnabled = 20 wdFormatFlatXMLTemplate = 21 wdFormatFlatXMLTemplateMacroEnabled = 22 wdFormatHTML = 8 wdFormatPDF = 17 wdFormatRTF = 6 wdFormatTemplate = 1 wdFormatTemplate97 = 1 wdFormatText = 2 wdFormatTextLineBreaks = 3 wdFormatUnicodeText = 7 wdFormatWebArchive = 9 wdFormatXML = 11 wdFormatXMLDocument = 12 wdFormatXMLDocumentMacroEnabled = 13 wdFormatXMLTemplate = 14 wdFormatXMLTemplateMacroEnabled = 15 wdFormatXPS = 18
照着字面意思应该能对应到相应的文件格式，如果你是office 2003可能支持不了这么多格式。word文件转html有两种格式可选wdFormatHTML、wdFormatFilteredHTML（对应数字 8、10），区别是如果是wdFormatHTML格式的话，word文件里面的公式等ole对象将会存储成wmf格式，而选用 wdFormatFilteredHTML的话公式图片将存储为gif格式，而且目测可以看出用wdFormatFilteredHTML生成的HTML 明显比wdFormatHTML要干净许多。
当然你也可以用任意一种语言通过com来调用office API.
25 Nov 2009
Python标准库手册 - 2. 内置函数 - 1
2. 内置函数 - 1:A-H
Python解释器有一系列永远可用的内置函数,这些函数在下面以字母顺序列出.
abs(x)
返回数字的绝对值.参数可能是简单或者长整型,或者浮点数.如果参数是复数,返回它的模.
all(iterable)
返回True,如果iterable的所有元素都为true(或者iterable为空). 等价于:
def all(iterable): for element in iterable: if not element: return False return True
Python2.5新增
any(iterable)
如果iterable的任一元素为true,返回Ture.如果iterable为空则返回False.等价于:
def any(iterable): for element in iterable: if element: return True return False
Python2.5新增
basestring()
这个抽象类型是str和unicode的超类.它不能被调用或者实例化,但是可以被用来测试某个对象是否是str或者unicode的实例. isinstance(obj, basestring)等价于 isinstance(obj, (str, unicode)).
Python2.3新增
bin(x)
将整数转换为二进制字符串,结果是有效的python表达式.如果x不是Python中的整型,必须定义一个返回整型的__index__()方法.
Python2.6新增
bool([x])
转换x为布尔值,按照标准真值检测过程.如果x是flase或省略,返回False; 否则返回True. bool也是一个类,是int的子类.bool类不能再被子类化,它仅有的实例是False和True.
Python2.2.1新增
2.3版改动: 如果指明参数,该函数返回False.
callable(object)
如果对象参数可以被调用返回True,否则返回Flase.如果返回true,仍然可能调用失败,但是如果返回false,调用则永远不会成功.注意类是可调用的(调用一个类返回一个新的实例);类实例也可以被调用如果它们有__call__()方法.
chr(i)
返回整型i对应的ASCII字符.例如chr(97)返回字符'a'.这是ord()的逆函数.参数必须属于[0,255];如果超出这个范围,ValueError异常会被抛出.参看unichr().
classmethod(function)
返回function的类方法.
类方法接受类自身作为隐含的第一参数,就好像实例方法接受实例本身.声明类方法采用如下习惯:
class C: @classmethod def f(cls, arg1, arg2, ...): ...
@classmethod形式是函数修饰符 - 参考函数定义描述.
该函数可以被类调用(如C.f())或者类的实例调用(如C().f()),作为类的实例,实例将被忽略.如果一个类方法被衍生类调用,衍生类对象作为隐含的第一参数被传递.
类方法不同于C++或者Java的静态方法.如果你想要静态方法,参看本节的staticmethod()函数.
查阅标准类型层次文档可以看到更多关于类方法的信息.
2.2版本新增
2.4版本改变:增加函数修饰语法
cmp(x, y)
比较2个对象x和y,并且根据其结果返回一个整型.如果x<y返回负数;如果x==y返回0,正数如果x>y.
compile(source, filename, mode[, flags[, dont_inherit]])
编译source为代码或AST对象.代码对象可被exec语句执行或者调用eval()执行.source可以是一个字符串或者AST对象.关于如何使用AST对象,请参看ast模块文档.
参数filename指定了代码从何处读读取,如果不是从文件读入,应该传入一些可被识别的值.
参数mode指定何种代码会被编译:
exec: source包含一系列语句
eval: 单独表达式
single: 单独的交互式语句.
最后一种情况下,表达式语句会被执行,返回非None的结果并打印.
可选参数flags和dont_inherit控制哪些未来版本语句会影响source编译.如果都未指定(或者均为0),代码会连同现有的(目前包含且生效的)的未来版本语句一起编译;如果flags给定而dont_inherit没有指定(或为0),那么被flags指定的未来版本语句会被强制使用;如果dont_inherit是非零整数,则现行的未来版本语句会被忽略.
未来版本语句由位来控制,这些位联合在一起可以控制多条语句.用来指定一个给定未来版本语句的位阀可以参考__future__模块中_Feature实例的compiler_flag属性.
如果被编译的source无效,这个函数会抛出SyntaxError,如果source包含空字节,会抛出TypeError.
注意:
当用多行语句编译一个字符串是,行结束符必需由一个新行字符('\n')表示,并且输入必需由至少一个行结束符结束.如果行结束符由('\r\n')表示,可以用str.replace()替换为'\n'.
2.3版本改动: 加入flags和dont_inherit参数
2.6版本改动: 支持编译AST对象.
complex([real[, imag]])
创建一个复数,其值为 real + imag*j 或者将字符串或数字转换为复数.如果第一个参数为字符串,会被当做复数对待,不能再输入第二个参数.第二个参数永远不能字符串.每个参数可以使任意的数值类型(包括复数).如果省略imag参数,默认为0,此时该函数相当于一个数值转换函数int(), long()或者float().如果2个参数均省略,返回0j.
复数类型在数值类型中有描述 - int, float, long, complex.
delattr(object, name)
这是setattr()的近亲.参数为一个对象和一个字符串.字符串必须是该对象某一属性的名称.该函数会删除对象的对应属性,如果对象允许删除.例如delattr(x, 'foobar')等价于del x.foobar.
dict([arg])
创建一个新数据字典,其元素来自于可选参数arg.字典类型 - dict - 在影射类型中有描述.
其他容器可参看内置的列表(list),集合(set), 元组(tuple)类,或者集合(collections)模块.
dir([object])
没有参数,会返回当前局部作用域内的名称列表.如果有输入参数,会尝试返回object的有效属性列表.
如果object有名为__dir__()的方法,会调用该方法且必须返回属性列表.这样会允许用户定制对象的__getattr__()和__getattribute__()方法以改变dir()返回其属性列表.
如果object没有提供__dir__()方法,该函数会尝试从object的__dict__属性(如果存在的话)和他的类型对象收集尽可能多的信息.当object的__getattr__()方法被改写时,结果列表可能不完整,或者不准确.
dir()的默认行为根据对象类型的不同而不同,因为它总是试图返回最相关的,而非最完整的信息:
* 如果object是模块,结果包含该模块的属性的名称.
* 如果object是类,结果包含该类的属性,以及递归式回溯得到的其基类的属性.
* 否则,结果将包含object的名称,其所属类的属性的名称,和递归回溯直至其基类的属性之名称.
结果列表以字母顺序排列,例如:
>>> import struct >>> dir() # doctest: +SKIP ['__builtins__', '__doc__', '__name__', 'struct'] >>> dir(struct) # doctest: +NORMALIZE_WHITESPACE ['Struct', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into', 'unpack', 'unpack_from'] >>> class Foo(object): ... def __dir__(self): ... return ["kan", "ga", "roo"] ... >>> f = Foo() >>> dir(f) ['ga', 'kan', 'roo']
注意:
由于dir()主要是为了在交互式命令提示符下提供方便,所以它会尝试返回一系列有意义的名称集合,而并非最完整或者定义一致的名称集合.而且其具体的机制也会根据发行版本不同而不同.例如,当参数是一个类时,元类属性不会出现在结果列表中.
divmod(a, b)
返回2个数(非复数)的商和余数(使用长除法).对于混合操作数类型,会应用二元算术运算规则.对于整型和长整形,结果与(a // b, a % b)相同;对于浮点数,结果等价于(q, a % b),其中q等于常用的除法math.floor(a / b)但是可能会比这个结果少1. 无论在何种情况之下, q * b + a % b都跟a非常接近, 如果a % b结果非零,则结果与b的符号相同,并且0 <= abs(a % b) < abs(b).
2.3版本改动:弃用复数的divmod().
enumerate(sequence[, start=0])
返回枚举对象.sequence必须是一个序列,迭代器或者其他支持迭代的对象.由enumerate()返回的迭代器的next()方法,将返回一个包含计数器(默认从0开始)和对应值的元组.enumerate()对于获得有索引的序列非常有效: (0, seq[0]), (1, seq[1]), (2, seq[2]), ... 例如:
>>> for i, season in enumerate(['Spring', 'Summer', 'Fall', 'Winter']): ... print i, season 0 Spring 1 Summer 2 Fall 3 Winter
2.3版本新增.
2.6版本改动: 新增start参数.
eval(expression[, globals[, locals]])
参数为一个字符串,可选参数包括globals和locals.如果提供了可选参数,globals必须是一个字典,locals可以是任意的映射对象.
2.4改动: locals正式要求为一个字典.
expression参数被当做Python表达式(技术上来讲,是条件列表)分析和执行,globals和locals会作为全局和局部命名空间.如果globals字典存在并缺少__builtins__,当前的globals会在表达式被分析前复制到globals.这意味着expression一般对标准的__builtin__模块拥有完全访问权限,限制环境也会被遗传.如果locals字典被省略,它默认等于globals字典.如果均被省略,expression会在调用eval()的环境下被执行.返回值是执行expression的记过.语法错误会作为异常报告.例如:
>>> x = 1
>>> print eval('x+1')
2这个函数也可以被用来执行任意的代码对象(例如由compile()创建的).在这种情况下,要传递一个代码对象而不是字符串.如果代码对象已经被exec作为kind参数编译,eval()将返回None.
提示:exec语句支持动态执行语句,execfile()函数支持动态执行文件.globals()和locals()将相应的返回当前全局和局部字典,这些参数可以传递给eval()或execfile().
execfile(filename[, globals[, locals]])
该函数类似于exec语句,唯一的区别就是分析一个文件而非字符串.但由于它不使用模块管理,所以不同于import语句 - 它无条件读取一个文件而且不会创建一个新的模块.-脚注1-
参数包含文件名和2个可选的字典.文件会以globals和locals作为全局和局部命名空间,当做一系列Python语句(类似于模块)被分析和执行.如果有locals参数,它可以使任意的映射对象.
2.4版本改动:正式要求locals是一个字典.
如果locals字典被省略,默认等于globals字典.如果都被省略,该函数会在execfile()被调用的环境下执行,返回值是None.
注意:
默认的locals()函数的行为如下:
一般不应尝试修改默认的locals字典.如果你需要看到局部代码被execfile()执行后返回的效果,可以传递一个明确的locals字典.使用execfile()修改函数的locals参数是不可信的.
file(filename[, mode[, bufsize]])
文件类型的构造函数,在文件对象一节有详细描述.构造器的参数与下面描述的内置函数open()相同.
当打开一个文件时,最好使用open()而不是直接调用此构造函数.file更适合被用来做类型测试(例如,isinstance(f, file)).
2.2版本新增
filter(function, iterable)
构造一个列表,其元素是以iterable的元素为参数执行function时返回true的元素.iterable必须是序列,支持迭代的容器或者迭代器.如果iterable是一个字符串或者元组,结果也是相应的类型;否则永远是列表.如果function是None,则认为是恒等函数,则iterable的所有是false的元素会被删除.
注意:如果function不是None,filter(function, iterable)等价于[item for item in iterable if function(item)];如果function是None,则它等价于[item for item in iterable if item].
参考它的互补函数itertools.filterfalse(),该函数会返回以iterable的元素为参数执行function时返回false的元素.
float([x])
将一个字符串或者数字转换为浮点数.如果参数是字符串,则必须包含白空格的有正负号的十进制或者浮点数.参数也可以是[+|-]nan或者[+|-]inf.否则,参数可能是整型,长整形或者浮点数,会返回一个等值的浮点数(在Python的浮点数精度下).如果无参数,返回0.0.
注意:
当传递一个字符串时,可能返回NaN或者Infinity,这依赖于底层的C库函数.对于NaN,float接受字符串nan, inf和-inf;对于infinity,有正无穷和负无穷.对于NaN来说,+和-会被忽略,float永远将NaN和infinity表示为nan, inf和-inf.
浮点类型在数值类型一节有详细描述 - int, float, long, complex.
format(value[, format_spec])
将value转换为由format_spec指定的格式化表达方式.其中format_spec取决于value参数的类型.但是,仍然有一个被大部分内置类型采用的标准格式化语法:格式化简短说明(参看8.1.3.1)
注意:format(value, format_spec)只不过是调用value.__format__(format_spec)而已.
2.6新增
frozenset([iterable])
返回一个frozenset类型,如果有可选参数iterable,元素来自于iterable.frozenset类型的说明参看集合类型 - Set, frozenset(参考6.7).
其他的容器参考内置类dict, list, tuple和collections模块.
2.4版本新增
getattr(object, name[, default])
返回对象的对应属性的值.name必须是字符串.如果该字符串是object某一属性的名称,返回该属性的值.例如getattr(x, 'foobar')等价于x.foobar.如果该属性不存在,返回default.如果未提供default参数,抛出AttributeError异常.
globals()
以字典形式返回当前全局符号表,结果永远是当前模块的字典(在一个函数或者方法内部,是它被定义的模块,而非调用它的模块).
hasattr(object, name)
参数是一个对象和一个字符串.如果字符串是对象的某个属性名称返回True,否则返回False.(另一个办法是调用getattr(object, name)看它是否抛出异常.)
hash(object)
返回object的哈希值(如果有).哈希值是整数,在搜索字典时被用来快速比较字典键值.相同的数值拥有相同的哈希值(即使它们类型不同,例如1和1.0).
help([object])
调用内置的帮助系统.(该函数主要用于交互式环境)如果未指明参数,解释器命令行的交互式帮助系统会.如果参数是字符串,会以该字符串为名称搜索模块,函数,类,方法,关键字或者文档题目,然后打印帮助页面.如果参数是其他任意对象,会生成关于该对象的帮助页面.
该函数被site模块加入内置命名空间.
2.2版本新增
hex(x)
将一个整数(任意大小)转换为十六进制字符串,结果是一个有效的Python表达式.
注意:
如果要得到浮点数的十六进制字符串表达式,可以用float.hex()方法.
2.4版本改动:正式只返回无符号表达式
<<1. 简介 >>目录 >>2. 内置函数-2:I-R
Python Tips - 正则表达式
python的正则表达式运用
1、re对象的方法
2、要使group(s)方法，应该在pattern中对想要在tuples中的部分加上括号，例如“123-45”，想匹配这个string，但是只想获得前三个数字，则可以使用这样的pattern,"(\d{3})-\d{2}"
,注意前面使用了括号，再调用groups方法会得到tuples,("123",)
。group(s)是SRE_Match object 的方法，通常使用方法为reobject.search(string).group(s)
3、要匹配任意单个字符使用"."，任意个字符使用".*"(包括0个)，或者".+"(至少一个)。
4、括号的多种用法
5、特殊序列
6、匹配后返回的对象的start()和end()方法，参数为组ID，返回值分别为匹配到的子字符串的开头和结尾在原字符串中的index。
问题：如何匹配不在开头的一个substring，如"2341254"，要匹配"254"而不是开头的"234"
解决方法：re.search("(?<=.)2.4", s)，同样要匹配不在结尾的一个substring，可以这样re.search("2.4(?=.)", s)
1、re对象的方法
match Match a regular expression pattern to the beginning of a string.
search re.search(pattern, string, flags) flags:re.I re.M re.X re.S re.L re.U
sub Substitute occurrences of a pattern found in a string.
subn Same as sub, but also return the number of substitutions made.
split Split a string by the occurrences of a pattern.
findall Find all occurrences of a pattern in a string.
finditer Return an iterator yielding a match object for each match.
>>iter = re.finditer("23", "123423523")
>>for i in iter:
print i.span()
compile 将一个pattern编译成一个RegexObject.
re对象的使用方法，reobject = re.complie(pattern)，从reobject获得pattern的方法，使用reobject.pattern属性
如果一个reobject要多次使用，最好使用compile方法提高性能，否则可以直接按这种方式使用，re.search(pattern, string)
purge Clear the regular expression cache.
escape Backslash all non-alphanumerics in a string.
2、要使group(s)方法，应该在pattern中对想要在tuples中的部分加上括号，例如“123-45”，想匹配这个string，但是只想获得前三个数字，则可以使用这样的pattern,"(\d{3})-\d{2}"
,注意前面使用了括号，再调用groups方法会得到tuples,("123",)
。group(s)是SRE_Match object 的方法，通常使用方法为reobject.search(string).group(s)
3、要匹配任意单个字符使用"."，任意个字符使用".*"(包括0个)，或者".+"(至少一个)。
4、括号的多种用法
(?:)不放入groups中
(?iLmsux) 为pattern加入I,L,M,S,U,X标志
(?P<name>) 为group的一项加入别名
(?P=name) 匹配在之前用name表示的部分表达式所匹配到的内容
(?#comment) 注释
test1(?=test2) 如果test1后面跟着test2，则匹配test1
test1(?!test2) 如果test1后面跟着的不是test2，则匹配test1
(?<=test1)test2 如果test2前面匹配到test1,则将test2放入group
(?<!=test1)test2 如果test2前面没匹配到test1,则将test2放入group
(?(id/name)yes-pattern|no-pattern) 如果id/name所指的项匹配到了，则执行yes，否则执行no
5、特殊序列
\b 匹配空字符，比如\bare\b匹配完整的单词are，\bare匹配在单词开头的are，而are\b则匹配在单词结尾的are
\B 与\b相反，\Bare匹配不在单词开头的are，而are\B匹配不在单词结尾的are
\d 匹配任何数字，相当于class [0-9]。
\D 匹配任何非数字，相当于class [^0-9]。
\s 匹配任何空白，相当于class [ \t\n\r\f\v]。
\S 匹配任何非空白，相当于class [^ \t\n\r\f\v]。
\w 匹配任何或数字，相当于class [a-zA-Z0-9_]。如果定义了re.L标志，则还包括当前LOCALE的一些字符。
\W 匹配\w的补集。
\\ 匹配反斜杠。
6、匹配后返回的对象的start()和end()方法，参数为组ID，返回值分别为匹配到的子字符串的开头和结尾在原字符串中的index。
问题：如何匹配不在开头的一个substring，如"2341254"，要匹配"254"而不是开头的"234"
解决方法：re.search("(?<=.)2.4", s)，同样要匹配不在结尾的一个substring，可以这样re.search("2.4(?=.)", s)
23 Nov 2009
Python标准库手册 - 1. 简介
1. 简介
Python库包含许多不同种类的组件.
它包含了普遍被认为是某种语言核心的数据类型,例如数字和列表.对于这些类型, Python语言核定义了变量的形式,并对其语意定义了一些限制,但并非完全定义.(另一方面,语言和定义了语法特性例如拼写和运算优先级.)
库也包含了内置函数和异常 - 这些对象可被所有Python代码使用而无需导入.其中某些对象由语言核定义,但是其他许多对象对于核心语法而言并非必须,因此只是在此描述.
库的大部分内容是模块的集合,剖析这个集合有很多方法.某些模块由C语言编写并作为Python解释器的内置模块;其他的由Python编写并以源码的形式导入.某些模块提供了Python特有的接口,例如打印一个栈跟踪;有些提供某些特定操作系统特有的借口,如访问特定硬件;其他的则提供特定应用程域所特有的接口,例如互联网(WWW).某些模块可用于所有版本和各种配置的Python,而某些模块则仅当Python编译和安装时特定的配置选项被选择时才可用.
本手册的组织是"由内而外"的.首先描述了内置数据类型,然后是内置函数和异常,最后是以章节为组的相关模块.章节顺序,包括每个模块介绍章节的内部顺序,简单讲都是从最常用到最不重要排列.
这意味着如果你从开始阅读本手册,当你觉得无聊而直接跳到下一章节,你会看到适当的关于可用模块和Python库支持的应用领域的概览.当然你不必像读小说一样阅读本手册 - 你可以浏览一下目录(手册最开始),或者从索引寻找某一特定函数,模块或者术语(手册最后). 最终,如果你喜欢随意阅读,你可以任意选择一个页码(参看random模块)阅读一两个片段.不管你阅读本手册的顺序如何,从内置函数开始是很有用的,因手册的其余部分都是假定读者对这些内容非常熟悉.
让我们开始吧!
>>目录 >>2. 内置函数 -1:A-H
Python标准库参考手册
*********************************************
* 日期: 2009年11月23日 - *
* 版本: v 0.0.1 *
* 平台: python 2.6 *
* 翻译: xenos *
* 邮件: xenoszh@gmail.com *
* 版权: 欢迎转载,请保留署名. *
*全手工翻译,个人学习之用,如果有错误,欢迎指正*
*********************************************
google也不知道搞个置顶功能,为了置顶个帖子,还要改成将来时间.得了,既然玛雅人预言2012年12月21日黑夜降临后,22日白昼永不到来,人类也将在22日那天灭绝.我就改成2009年12月23日吧.21日永夜,22日灭绝,23日该新生了吧.
Python标准库参考手册
版本: Python 2.6
日期: 2009年11月23日
翻译: xenoszh@gmail.com
Python语言参考手册描述了Python的确切语法和Python语言的定义，这个Python标准库参考手册描述了随Python分发的标准库。另外,它也介绍了那些经常在Python发行时包括一些可选组件。
Python标准库涵盖内容非常广泛，如下面这个很长的目录列表显示。该库包含内置的模块（C语言编写），如文件输入输出，为Python程序员提供访问系统功能；也包含了Python编写解决编程时经常碰到的很多问题的标准解决方法。库中的一些模块明确将一些平台相关的APIs抽象出来，代之以平台原生APIs，旨在加强Python程序的可移植性。
Windows平台的Python的安装通常包括整个标准库，而且还包含许多其他组件。对于Unix-like操作系统的Python通常作为软件包而提供，因此它可能需要使用操作系统提供的包安装工具来获取部分或所有的可选组件。
除了标准库，还有成千上万与日俱增的软件包组件（从单独的程序和模块到整个程序开发框架），这些可从Python软件包目录获得。
* 1. 简介
* 2. 内置函数 1:A-H 2:I-R 3:S-Z
* 3. 次要内置函数
* 4. 内置常量
o 4.1. site模块增加的内置常量
* 5. 内置对象
* 6. 内置类型
o 6.1. 真值检测
o 6.2. 布尔运算符 — and, or, not
o 6.3. 比较运算
o 6.4. 数值类型 — int, float, long, complex
o 6.5. 迭代类型
o 6.6. 序列类型 — str, unicode, list, tuple, buffer, xrange
o 6.7. 集合类型 — set, frozenset
o 6.8. 映射类型 — dict
o 6.9. 文件对象
o 6.10. 上下文管理类型
o 6.11. 其他内置类型
o 6.12. 特殊属性
* 7. 内置异常
o 7.1. 异常层次结构
* 8. 字符串服务
o 8.1. string — 常用字符串操作
o 8.2. re — 正则表达式操作
o 8.3. struct — 用二进制数据包表示字符串
o 8.4. difflib — 帮助监测程序变化
o 8.5. StringIO — 象文件一样读写字符串
o 8.6. cStringIO — StringIO的高速(效率?)版本
o 8.7. textwrap — 文本折叠和填充
o 8.8. codecs — 基类和编解码注册
o 8.9. unicodedata — Unicode数据库
o 8.10. stringprep — 网络字符串预备
o 8.11. fpformat — 浮点转换
* 9. 数据类型
o 9.1. datetime — 基本时间日期类型
o 9.2. calendar — 通用日期相关函数
o 9.3. collections — 高性能容器数据类型
o 9.4. heapq — 堆队列算法
o 9.5. bisect — 数组分半算法
o 9.6. array — 高效数值数组
o 9.7. sets — 元素具有唯一性的无序集合
o 9.8. sched — 事件调度
o 9.9. mutex — 互斥现象的支持
o 9.10. queue — 同步队列类
o 9.11. weakref — 弱引用
o 9.12. UserDict — 字典对象的wrapper类
o 9.13. UserList — 列表对象的wrapper类
o 9.14. UserString — 字符串对象的wrapper类
o 9.15. types — 内置类型的名称
o 9.16. new — 运行时内部对象的创建
o 9.17. copy — 深拷贝和浅拷贝
o 9.18. pprint — 数据的优美打印
o 9.19. repr — repr()的替代实现
* 10. 数值与数学模块
o 10.1. numbers — 数值抽象基类
o 10.2. math — 数学计算函数
o 10.3. cmath — 复数数学计算函数
o 10.4. decimal — 十进制定点与浮点运算
o 10.5. fractions — 有理数
o 10.6. random — 生成伪随机数
o 10.7. itertools — 高效循环迭代函数
o 10.8. functools — 可调用对象的高阶函数与运算
o 10.9. operator — 标准运算符的函数样式
* 11. 文件与目录存取
o 11.1. os.path — 常用路径操作
o 11.2. fileinput — 遍历多个输入流
o 11.3. stat — 解释stat()结果
o 11.4. statvfs — os.statvfs()使用的常量
o 11.5. filecmp — 文件与目录比较
o 11.6. tempfile — 生成临时文件与目录
o 11.7. glob — Unix类型的路径格式扩展
o 11.8. fnmatch — Unix类型的文件名格式匹配
o 11.9. linecache — 文本行的随机存取
o 11.10. shutil — 高级文件操作符
o 11.11. dircache — 缓存的目录列表
o 11.12. macpath — Mac OS 9路径处理函数
* 12. 数据持久化
o 12.1. pickle — Python对象序列化
o 12.2. cPickle — 快速(高效?)的pickle
o 12.3. copy_reg — 注册pickle支持函数
o 12.4. shelve — Python对象持久化
o 12.5. marshal — Python内部对象序列化
o 12.6. anydbm — 访问DBM类型数据库
o 12.7. whichdb — 猜测数据库的DBM模块
o 12.8. dbm — 简明数据库接口
o 12.9. gdbm — GNU的dbm解释
o 12.10. dbhash — BSD数据库库的DBM类型接口
o 12.11. bsddb — Berkeley DB库的接口
o 12.12. dumbdbm — 轻便的DBM实现
o 12.13. sqlite3 — SQLite数据库的DB-API 2.0接口
* 13. 数据压缩与归档
o 13.1. zlib — 兼容gzip的压缩方法
o 13.2. gzip — 支持gzip文件
o 13.3. bz2 — 兼容bzip2的压缩方法
o 13.4. zipfile — 处理ZIP档案文件
o 13.5. tarfile — 读写tar档案文件
* 14. 文件格式
o 14.1. csv — CSV文件读写
o 14.2. ConfigParser — 配置文件分析
o 14.3. robotparser — robots.txt分析
o 14.4. netrc — netrc文件处理
o 14.5. xdrlib — XDR数据编解码
o 14.6. plistlib — Mac OS X .plist文件的生成与分析
* 15. 密码服务
o 15.1. hashlib — 安全哈希表与消息摘要
o 15.2. hmac — 消息认证的Keyed-Hashing
o 15.3. md5 — MD5消息摘要算法
o 15.4. sha — SHA-1消息摘要算法
* 16. 通用操作系统服务
o 16.1. os — 庞杂的操作系统接口
o 16.2. io — 流处理的核心工具
o 16.3. time — 时间处理和转换
o 16.4. optparse — 更强的命令行参数分析
o 16.5. getopt — 命令行参数分析
o 16.6. logging — Python的日志功能
o 16.7. getpass — 轻便的密码输入
o 16.8. curses — 字符元显示的终端处理器
o 16.9. curses.textpad — curses程序的文本输入部件
o 16.10. curses.wrapper — curses程序的终端处理器
o 16.11. curses.ascii — ASCII字符应用
o 16.12. curses.panel — curses的面板堆栈扩展
o 16.13. platform — 操作系统底层数据访问
o 16.14. errno — 标准errno系统符号
o 16.15. ctypes — Python的外部函数库
* 17. 可选的操作系统服务
o 17.1. select — 等待I/O完成
o 17.2. threading — 高级线程接口
o 17.3. thread — 多线程控制
o 17.4. dummy_threading — threading模块的简易替代
o 17.5. dummy_thread — thread模块的简易替代
o 17.6. multiprocessing — 基于处理器的threading接口
o 17.7. mmap — 内存映射文件支持
o 17.8. readline — GNU行 readline接口
o 17.9. rlcompleter — GNU readline的完整函数
* 18. 进程间通讯与网络
o 18.1. subprocess — 子进程管理
o 18.2. socket — 底层网络接口
o 18.3. ssl — socket对象的SSL包
o 18.4. signal — 设置异步事件处理器
o 18.5. popen2 — 可存取的I/O流子进程
o 18.6. asyncore — 异步socket处理器
o 18.7. asynchat — 异步socket命令/应答处理器
* 19. 网络数据处理
o 19.1. email — 邮件与MIME处理包
o 19.2. json — JSON编码器与解码器
o 19.3. mailcap — Mailcap文件处理
o 19.4. mailbox — 操作多种格式邮件箱
o 19.5. mhlib — 存取MH邮件箱
o 19.6. mimetools — MIME消息分析工具
o 19.7. mimetypes — 映射文件名到MIME格式
o 19.8. MimeWriter — 通用MIME文件写入
o 19.9. mimify — MIME处理邮件消息
o 19.10. multifile — 包含多个部分的文件支持
o 19.11. rfc822 — 分析RFC 2822邮件头
o 19.12. base64 — RFC 3548: Base16, Base32, Base64数据编码
o 19.13. binhex — 编/解码binhex4文件
o 19.14. binascii — 二进制与ASCII转换
o 19.15. quopri — 编/解码MIME编码数据
o 19.16. uu — 编/解码uuencode文件
* 20. 结构化标记处理工具
o 20.1. HTMLParser — 简易HTML/XHTML分析器
o 20.2. sgmllib — 简易SGML分析器
o 20.3. htmllib — HTML文档分析器
o 20.4. htmlentitydefs — HTML通用实体定义
o 20.5. xml.parsers.expat — 利用Expat实现快速XML分析
o 20.6. xml.dom — 文件对象模型API
o 20.7. xml.dom.minidom — 轻量级DOM实现
o 20.8. xml.dom.pulldom — 建立DOM子树的支持
o 20.9. xml.sax — SAX2分析器支持
o 20.10. xml.sax.handler — SAX处理器的基类
o 20.11. xml.sax.saxutils — SAX工具
o 20.12. xml.sax.xmlreader — XML分析器接口
o 20.13. xml.etree.ElementTree — ElementTree XML API
* 21. 网络通讯协议与支持
o 21.1. webbrowser — 方便的网络浏览器控制器
o 21.2. cgi — CGI支持
o 21.3. cgitb — CGI脚本回溯管理器
o 21.4. wsgiref — WSGI功用与参考实现
o 21.5. urllib — 根据URL打开任意资源
o 21.6. urllib2 — 打开URLs的可扩展库
o 21.7. httplib — HTTP协议客户端
o 21.8. ftplib — FTP协议客户端
o 21.9. poplib — POP3协议客户端
o 21.10. imaplib — IMAP4协议客户端
o 21.11. nntplib — NNTP协议客户端
o 21.12. smtplib — SMTP协议客户端
o 21.13. smtpd — SMTP服务
o 21.14. telnetlib — Telnet客户端
o 21.15. uuid — UUID对象(参照RFC 4122)
o 21.16. urlparse — 分析URLs得到不同部分
o 21.17. SocketServer — 网络服务框架
o 21.18. BaseHTTPServer — 基础HTTP服务
o 21.19. SimpleHTTPServer — 简易HTTP请求处理器
o 21.20. CGIHTTPServer — 兼容CGI的HTTP请求处理器
o 21.21. cookielib — HTTP客户端的Cookie处理
o 21.22. Cookie — HTTP状态管理
o 21.23. xmlrpclib — XML-RPC客户端存取
o 21.24. SimpleXMLRPCServer — 基础XML-RPC服务
o 21.25. DocXMLRPCServer — 自我文档化的XML-RPC服务
* 22. 多媒体服务
o 22.1. audioop — 操作原始音频数据
o 22.2. imageop — 操作原始图像数据
o 22.3. aifc — 读写AIFF和AIFC文件
o 22.4. sunau — 读写Sun AU文件
o 22.5. wave — 读写WAV文件
o 22.6. chunk — 读取IFF块数据
o 22.7. colorsys — 不同颜色系统之间转换
o 22.8. imghdr — 确定图像类型
o 22.9. sndhdr — 确定声音文件类型
o 22.10. ossaudiodev — 访问OSS兼容的音频设备
* 23. 国际化
o 23.1. gettext — 多种语言的国际化服务
o 23.2. locale — 国际化服务
* 24. 程序框架
o 24.1. cmd — 面向行的命令解释程序支持
o 24.2. shlex — 简易语法分析
* 25. 图形用户接口(GUI) - Tk
o 25.1. Tkinter — Tcl/Tk的Python接口
o 25.2. Tix — Tk的扩充部件
o 25.3. ScrolledText — 卷动文本部件
o 25.4. turtle — Tk的海龟图(?)
o 25.5. IDLE
o 25.6. 其他图形用户接口包
* 26. 开发工具
o 26.1. pydoc — 文档生成器宇在线帮助系统
o 26.2. doctest — 测试交互式Pythono例子
o 26.3. unittest — 单元测试框架
o 26.4. 2to3 — 自动转化Python 2代码到Python 3
o 26.5. test — Python的回归测试包
o 26.6. test.test_support — 测试的效用函数
* 27. 调试与程序概要分析
o 27.1. bdb — 调试器框架
o 27.2. pdb — Python调试器
o 27.3. 调试器命令
o 27.4. Python分析器
o 27.5. hotshot — 高性能日志分析器
o 27.6. timeit — 测量小代码段的执行时间
o 27.7. trace — Python语句执行跟踪
* 28. Python运行时服务
o 28.1. sys — 系统相关的参数和函数
o 28.2. __builtin__ — 内置对象
o 28.3. future_builtins — Python 3内置
o 28.4. __main__ — 顶层脚本环境
o 28.5. warnings — 警告控制
o 28.6. contextlib — with语句上下文应用
o 28.7. abc — 抽象基类
o 28.8. atexit — Exit处理器
o 28.9. traceback — 打印或检索栈回溯
o 28.10. __future__ — 未来版本的语句定义
o 28.11. gc — 垃圾回收接口
o 28.12. inspect — 审查活动对象
o 28.13. site — 站点相关配置钩子
o 28.14. user — 用户相关配置钩子
o 28.15. fpectl — 浮点异常控制
* 29. 定制Python解释器
o 29.1. code — 解释器基类
o 29.2. codeop — 编译Python代码
* 30. 限制执行
o 30.1. rexec — 限制执行框架
o 30.2. Bastion — 对象的限定访问
* 31. 导入模块
o 31.1. imp — 访问import内部
o 31.2. imputil — 导入功能
o 31.3. zipimport — 从zip归档文件导入模块
o 31.4. pkgutil — 包扩展功能
o 31.5. modulefinder — 搜索脚本使用的模块
o 31.6. runpy — 定位/执行Python模块
* 32. Python语言服务
o 32.1. parser — 访问Python分析树
o 32.2. 抽象语法树
o 32.3. symtable — 访问编译器符号表
o 32.4. symbol — Python分析树使用的常量
o 32.5. token — Python分析树使用的常量
o 32.6. keyword — Python关键字检测
o 32.7. tokenize — Python源文件语法分析器
o 32.8. tabnanny — 缩进检测
o 32.9. pyclbr — Python类浏览支持
o 32.10. py_compile — 编译Python源文件
o 32.11. compileall — 字节编译Python库
o 32.12. dis — 反编译Python字节码
o 32.13. pickletools — pickle开发人员工具
o 32.14. distutils — 建立/安装Python模块
* 33. Python编译器包
o 33.1. 基础接口
o 33.2. 局限
o 33.3. Python抽象语法
o 33.4. 利用访问模式漫步ASTs
o 33.5. 生成字节码
* 34. 其他服务
o 34.1. formatter — 通用输出格式化
* 35. 微软Windows系统特殊服务
o 35.1. msilib — 读写微软安装文件
o 35.2. msvcrt — 来自微软VC++运行时的有用程序
o 35.3. _winreg — Windows注册表访问
o 35.4. winsound — Windows声音播放接口
* 36. Unix系统特殊服务 (是否翻译待定)
o 36.1. posix — 最常用的POSIX系统调用
o 36.2. pwd — 密码数据库
o 36.3. spwd — 隐藏式密码数据库
o 36.4. grp — 群组数据库
o 36.5. crypt — Unix密码检测函数
o 36.6. dl — 在共享对象中调用C函数
o 36.7. termios — POSIX风格的tty控制
o 36.8. tty — 终端控制函数
o 36.9. pty — 伪终端功能
o 36.10. fcntl — fcntl()和ioctl()系统调用
o 36.11. pipes — 管道共享接口
o 36.12. posixfile — 类文件对象锁定支持
o 36.13. resource — 资源利用信息
o 36.14. nis — Sun’s NIS (黄页)接口
o 36.15. syslog — Unix系统日志库程序
o 36.16. commands — 命令执行功能
* 37. Mac OS X系统特殊服务 (是否翻译待定)
o 37.1. ic — 访问Mac OS X网络配置
o 37.2. MacOS — 访问Mac OS解释器特性
o 37.3. macostools — 方便的文件操作程序
o 37.4. findertools — finder的苹果事件接口
o 37.5. EasyDialogs — 基础苹果对话框
o 37.6. FrameWork — 交互式程序框架
o 37.7. autoGIL — 事件循环的全局解释器锁定处理
o 37.8. Mac OS工具箱模块
o 37.9. ColorPicker — 颜色选择对话框
* 38. MacPython OSA模块 (是否翻译待定)
o 38.1. gensuitemodule — 生成OSA stub包
o 38.2. aetools — OSA客户端支持
o 38.3. aepack — Python变量与AppleEvent数据容器的互相转换
o 38.4. aetypes — AppleEvent对象
o 38.5. MiniAEFrame — 开放式脚本架构服务支持
* 39. SGI IRIX系统特殊服务 (是否翻译待定)
o 39.1. al — SGI上的音频函数
o 39.2. AL — al模块使用的常量
o 39.3. cd — SGI系统的CD-ROM访问
o 39.4. fl — 图形用户接口的窗体库
o 39.5. FL — fl模块使用的常量
o 39.6. flp — 加载已存的窗体设计函数
o 39.7. fm — 字体管理接口
o 39.8. gl — 图形库接口
o 39.9. DEVICE — gl模块使用的常量
o 39.10. GL — gl模块使用的常量
o 39.11. imgfile — SGI系统的imglib文件支持
o 39.12. jpeg — 读写JPEG文件
* 40. SunOS系统特殊服务 (是否翻译待定)
o 40.1. sunaudiodev — 访问Sun音频硬件
o 40.2. SUNAUDIODEV — sunaudiodev模块使用的常量
* 41. 未公开模块
o 41.1. 大量的实用功能
o 41.2. 平台相关的模块
o 41.3. 多媒体
o 41.4. 未公开的Mac OS模块
o 41.5. 过时的
o 41.6. SGI相关的特殊模块
* 日期: 2009年11月23日 - *
* 版本: v 0.0.1 *
* 平台: python 2.6 *
* 翻译: xenos *
* 邮件: xenoszh@gmail.com *
* 版权: 欢迎转载,请保留署名. *
*全手工翻译,个人学习之用,如果有错误,欢迎指正*
*********************************************
google也不知道搞个置顶功能,为了置顶个帖子,还要改成将来时间.得了,既然玛雅人预言2012年12月21日黑夜降临后,22日白昼永不到来,人类也将在22日那天灭绝.我就改成2009年12月23日吧.21日永夜,22日灭绝,23日该新生了吧.
Python标准库参考手册
版本: Python 2.6
日期: 2009年11月23日
翻译: xenoszh@gmail.com
Python语言参考手册描述了Python的确切语法和Python语言的定义，这个Python标准库参考手册描述了随Python分发的标准库。另外,它也介绍了那些经常在Python发行时包括一些可选组件。
Python标准库涵盖内容非常广泛，如下面这个很长的目录列表显示。该库包含内置的模块（C语言编写），如文件输入输出，为Python程序员提供访问系统功能；也包含了Python编写解决编程时经常碰到的很多问题的标准解决方法。库中的一些模块明确将一些平台相关的APIs抽象出来，代之以平台原生APIs，旨在加强Python程序的可移植性。
Windows平台的Python的安装通常包括整个标准库，而且还包含许多其他组件。对于Unix-like操作系统的Python通常作为软件包而提供，因此它可能需要使用操作系统提供的包安装工具来获取部分或所有的可选组件。
除了标准库，还有成千上万与日俱增的软件包组件（从单独的程序和模块到整个程序开发框架），这些可从Python软件包目录获得。
Python标准库参考手册
* 1. 简介
* 2. 内置函数 1:A-H 2:I-R 3:S-Z
* 3. 次要内置函数
* 4. 内置常量
o 4.1. site模块增加的内置常量
* 5. 内置对象
* 6. 内置类型
o 6.1. 真值检测
o 6.2. 布尔运算符 — and, or, not
o 6.3. 比较运算
o 6.4. 数值类型 — int, float, long, complex
o 6.5. 迭代类型
o 6.6. 序列类型 — str, unicode, list, tuple, buffer, xrange
o 6.7. 集合类型 — set, frozenset
o 6.8. 映射类型 — dict
o 6.9. 文件对象
o 6.10. 上下文管理类型
o 6.11. 其他内置类型
o 6.12. 特殊属性
* 7. 内置异常
o 7.1. 异常层次结构
* 8. 字符串服务
o 8.1. string — 常用字符串操作
o 8.2. re — 正则表达式操作
o 8.3. struct — 用二进制数据包表示字符串
o 8.4. difflib — 帮助监测程序变化
o 8.5. StringIO — 象文件一样读写字符串
o 8.6. cStringIO — StringIO的高速(效率?)版本
o 8.7. textwrap — 文本折叠和填充
o 8.8. codecs — 基类和编解码注册
o 8.9. unicodedata — Unicode数据库
o 8.10. stringprep — 网络字符串预备
o 8.11. fpformat — 浮点转换
* 9. 数据类型
o 9.1. datetime — 基本时间日期类型
o 9.2. calendar — 通用日期相关函数
o 9.3. collections — 高性能容器数据类型
o 9.4. heapq — 堆队列算法
o 9.5. bisect — 数组分半算法
o 9.6. array — 高效数值数组
o 9.7. sets — 元素具有唯一性的无序集合
o 9.8. sched — 事件调度
o 9.9. mutex — 互斥现象的支持
o 9.10. queue — 同步队列类
o 9.11. weakref — 弱引用
o 9.12. UserDict — 字典对象的wrapper类
o 9.13. UserList — 列表对象的wrapper类
o 9.14. UserString — 字符串对象的wrapper类
o 9.15. types — 内置类型的名称
o 9.16. new — 运行时内部对象的创建
o 9.17. copy — 深拷贝和浅拷贝
o 9.18. pprint — 数据的优美打印
o 9.19. repr — repr()的替代实现
* 10. 数值与数学模块
o 10.1. numbers — 数值抽象基类
o 10.2. math — 数学计算函数
o 10.3. cmath — 复数数学计算函数
o 10.4. decimal — 十进制定点与浮点运算
o 10.5. fractions — 有理数
o 10.6. random — 生成伪随机数
o 10.7. itertools — 高效循环迭代函数
o 10.8. functools — 可调用对象的高阶函数与运算
o 10.9. operator — 标准运算符的函数样式
* 11. 文件与目录存取
o 11.1. os.path — 常用路径操作
o 11.2. fileinput — 遍历多个输入流
o 11.3. stat — 解释stat()结果
o 11.4. statvfs — os.statvfs()使用的常量
o 11.5. filecmp — 文件与目录比较
o 11.6. tempfile — 生成临时文件与目录
o 11.7. glob — Unix类型的路径格式扩展
o 11.8. fnmatch — Unix类型的文件名格式匹配
o 11.9. linecache — 文本行的随机存取
o 11.10. shutil — 高级文件操作符
o 11.11. dircache — 缓存的目录列表
o 11.12. macpath — Mac OS 9路径处理函数
* 12. 数据持久化
o 12.1. pickle — Python对象序列化
o 12.2. cPickle — 快速(高效?)的pickle
o 12.3. copy_reg — 注册pickle支持函数
o 12.4. shelve — Python对象持久化
o 12.5. marshal — Python内部对象序列化
o 12.6. anydbm — 访问DBM类型数据库
o 12.7. whichdb — 猜测数据库的DBM模块
o 12.8. dbm — 简明数据库接口
o 12.9. gdbm — GNU的dbm解释
o 12.10. dbhash — BSD数据库库的DBM类型接口
o 12.11. bsddb — Berkeley DB库的接口
o 12.12. dumbdbm — 轻便的DBM实现
o 12.13. sqlite3 — SQLite数据库的DB-API 2.0接口
* 13. 数据压缩与归档
o 13.1. zlib — 兼容gzip的压缩方法
o 13.2. gzip — 支持gzip文件
o 13.3. bz2 — 兼容bzip2的压缩方法
o 13.4. zipfile — 处理ZIP档案文件
o 13.5. tarfile — 读写tar档案文件
* 14. 文件格式
o 14.1. csv — CSV文件读写
o 14.2. ConfigParser — 配置文件分析
o 14.3. robotparser — robots.txt分析
o 14.4. netrc — netrc文件处理
o 14.5. xdrlib — XDR数据编解码
o 14.6. plistlib — Mac OS X .plist文件的生成与分析
* 15. 密码服务
o 15.1. hashlib — 安全哈希表与消息摘要
o 15.2. hmac — 消息认证的Keyed-Hashing
o 15.3. md5 — MD5消息摘要算法
o 15.4. sha — SHA-1消息摘要算法
* 16. 通用操作系统服务
o 16.1. os — 庞杂的操作系统接口
o 16.2. io — 流处理的核心工具
o 16.3. time — 时间处理和转换
o 16.4. optparse — 更强的命令行参数分析
o 16.5. getopt — 命令行参数分析
o 16.6. logging — Python的日志功能
o 16.7. getpass — 轻便的密码输入
o 16.8. curses — 字符元显示的终端处理器
o 16.9. curses.textpad — curses程序的文本输入部件
o 16.10. curses.wrapper — curses程序的终端处理器
o 16.11. curses.ascii — ASCII字符应用
o 16.12. curses.panel — curses的面板堆栈扩展
o 16.13. platform — 操作系统底层数据访问
o 16.14. errno — 标准errno系统符号
o 16.15. ctypes — Python的外部函数库
* 17. 可选的操作系统服务
o 17.1. select — 等待I/O完成
o 17.2. threading — 高级线程接口
o 17.3. thread — 多线程控制
o 17.4. dummy_threading — threading模块的简易替代
o 17.5. dummy_thread — thread模块的简易替代
o 17.6. multiprocessing — 基于处理器的threading接口
o 17.7. mmap — 内存映射文件支持
o 17.8. readline — GNU行 readline接口
o 17.9. rlcompleter — GNU readline的完整函数
* 18. 进程间通讯与网络
o 18.1. subprocess — 子进程管理
o 18.2. socket — 底层网络接口
o 18.3. ssl — socket对象的SSL包
o 18.4. signal — 设置异步事件处理器
o 18.5. popen2 — 可存取的I/O流子进程
o 18.6. asyncore — 异步socket处理器
o 18.7. asynchat — 异步socket命令/应答处理器
* 19. 网络数据处理
o 19.1. email — 邮件与MIME处理包
o 19.2. json — JSON编码器与解码器
o 19.3. mailcap — Mailcap文件处理
o 19.4. mailbox — 操作多种格式邮件箱
o 19.5. mhlib — 存取MH邮件箱
o 19.6. mimetools — MIME消息分析工具
o 19.7. mimetypes — 映射文件名到MIME格式
o 19.8. MimeWriter — 通用MIME文件写入
o 19.9. mimify — MIME处理邮件消息
o 19.10. multifile — 包含多个部分的文件支持
o 19.11. rfc822 — 分析RFC 2822邮件头
o 19.12. base64 — RFC 3548: Base16, Base32, Base64数据编码
o 19.13. binhex — 编/解码binhex4文件
o 19.14. binascii — 二进制与ASCII转换
o 19.15. quopri — 编/解码MIME编码数据
o 19.16. uu — 编/解码uuencode文件
* 20. 结构化标记处理工具
o 20.1. HTMLParser — 简易HTML/XHTML分析器
o 20.2. sgmllib — 简易SGML分析器
o 20.3. htmllib — HTML文档分析器
o 20.4. htmlentitydefs — HTML通用实体定义
o 20.5. xml.parsers.expat — 利用Expat实现快速XML分析
o 20.6. xml.dom — 文件对象模型API
o 20.7. xml.dom.minidom — 轻量级DOM实现
o 20.8. xml.dom.pulldom — 建立DOM子树的支持
o 20.9. xml.sax — SAX2分析器支持
o 20.10. xml.sax.handler — SAX处理器的基类
o 20.11. xml.sax.saxutils — SAX工具
o 20.12. xml.sax.xmlreader — XML分析器接口
o 20.13. xml.etree.ElementTree — ElementTree XML API
* 21. 网络通讯协议与支持
o 21.1. webbrowser — 方便的网络浏览器控制器
o 21.2. cgi — CGI支持
o 21.3. cgitb — CGI脚本回溯管理器
o 21.4. wsgiref — WSGI功用与参考实现
o 21.5. urllib — 根据URL打开任意资源
o 21.6. urllib2 — 打开URLs的可扩展库
o 21.7. httplib — HTTP协议客户端
o 21.8. ftplib — FTP协议客户端
o 21.9. poplib — POP3协议客户端
o 21.10. imaplib — IMAP4协议客户端
o 21.11. nntplib — NNTP协议客户端
o 21.12. smtplib — SMTP协议客户端
o 21.13. smtpd — SMTP服务
o 21.14. telnetlib — Telnet客户端
o 21.15. uuid — UUID对象(参照RFC 4122)
o 21.16. urlparse — 分析URLs得到不同部分
o 21.17. SocketServer — 网络服务框架
o 21.18. BaseHTTPServer — 基础HTTP服务
o 21.19. SimpleHTTPServer — 简易HTTP请求处理器
o 21.20. CGIHTTPServer — 兼容CGI的HTTP请求处理器
o 21.21. cookielib — HTTP客户端的Cookie处理
o 21.22. Cookie — HTTP状态管理
o 21.23. xmlrpclib — XML-RPC客户端存取
o 21.24. SimpleXMLRPCServer — 基础XML-RPC服务
o 21.25. DocXMLRPCServer — 自我文档化的XML-RPC服务
* 22. 多媒体服务
o 22.1. audioop — 操作原始音频数据
o 22.2. imageop — 操作原始图像数据
o 22.3. aifc — 读写AIFF和AIFC文件
o 22.4. sunau — 读写Sun AU文件
o 22.5. wave — 读写WAV文件
o 22.6. chunk — 读取IFF块数据
o 22.7. colorsys — 不同颜色系统之间转换
o 22.8. imghdr — 确定图像类型
o 22.9. sndhdr — 确定声音文件类型
o 22.10. ossaudiodev — 访问OSS兼容的音频设备
* 23. 国际化
o 23.1. gettext — 多种语言的国际化服务
o 23.2. locale — 国际化服务
* 24. 程序框架
o 24.1. cmd — 面向行的命令解释程序支持
o 24.2. shlex — 简易语法分析
* 25. 图形用户接口(GUI) - Tk
o 25.1. Tkinter — Tcl/Tk的Python接口
o 25.2. Tix — Tk的扩充部件
o 25.3. ScrolledText — 卷动文本部件
o 25.4. turtle — Tk的海龟图(?)
o 25.5. IDLE
o 25.6. 其他图形用户接口包
* 26. 开发工具
o 26.1. pydoc — 文档生成器宇在线帮助系统
o 26.2. doctest — 测试交互式Pythono例子
o 26.3. unittest — 单元测试框架
o 26.4. 2to3 — 自动转化Python 2代码到Python 3
o 26.5. test — Python的回归测试包
o 26.6. test.test_support — 测试的效用函数
* 27. 调试与程序概要分析
o 27.1. bdb — 调试器框架
o 27.2. pdb — Python调试器
o 27.3. 调试器命令
o 27.4. Python分析器
o 27.5. hotshot — 高性能日志分析器
o 27.6. timeit — 测量小代码段的执行时间
o 27.7. trace — Python语句执行跟踪
* 28. Python运行时服务
o 28.1. sys — 系统相关的参数和函数
o 28.2. __builtin__ — 内置对象
o 28.3. future_builtins — Python 3内置
o 28.4. __main__ — 顶层脚本环境
o 28.5. warnings — 警告控制
o 28.6. contextlib — with语句上下文应用
o 28.7. abc — 抽象基类
o 28.8. atexit — Exit处理器
o 28.9. traceback — 打印或检索栈回溯
o 28.10. __future__ — 未来版本的语句定义
o 28.11. gc — 垃圾回收接口
o 28.12. inspect — 审查活动对象
o 28.13. site — 站点相关配置钩子
o 28.14. user — 用户相关配置钩子
o 28.15. fpectl — 浮点异常控制
* 29. 定制Python解释器
o 29.1. code — 解释器基类
o 29.2. codeop — 编译Python代码
* 30. 限制执行
o 30.1. rexec — 限制执行框架
o 30.2. Bastion — 对象的限定访问
* 31. 导入模块
o 31.1. imp — 访问import内部
o 31.2. imputil — 导入功能
o 31.3. zipimport — 从zip归档文件导入模块
o 31.4. pkgutil — 包扩展功能
o 31.5. modulefinder — 搜索脚本使用的模块
o 31.6. runpy — 定位/执行Python模块
* 32. Python语言服务
o 32.1. parser — 访问Python分析树
o 32.2. 抽象语法树
o 32.3. symtable — 访问编译器符号表
o 32.4. symbol — Python分析树使用的常量
o 32.5. token — Python分析树使用的常量
o 32.6. keyword — Python关键字检测
o 32.7. tokenize — Python源文件语法分析器
o 32.8. tabnanny — 缩进检测
o 32.9. pyclbr — Python类浏览支持
o 32.10. py_compile — 编译Python源文件
o 32.11. compileall — 字节编译Python库
o 32.12. dis — 反编译Python字节码
o 32.13. pickletools — pickle开发人员工具
o 32.14. distutils — 建立/安装Python模块
* 33. Python编译器包
o 33.1. 基础接口
o 33.2. 局限
o 33.3. Python抽象语法
o 33.4. 利用访问模式漫步ASTs
o 33.5. 生成字节码
* 34. 其他服务
o 34.1. formatter — 通用输出格式化
* 35. 微软Windows系统特殊服务
o 35.1. msilib — 读写微软安装文件
o 35.2. msvcrt — 来自微软VC++运行时的有用程序
o 35.3. _winreg — Windows注册表访问
o 35.4. winsound — Windows声音播放接口
* 36. Unix系统特殊服务 (是否翻译待定)
o 36.1. posix — 最常用的POSIX系统调用
o 36.2. pwd — 密码数据库
o 36.3. spwd — 隐藏式密码数据库
o 36.4. grp — 群组数据库
o 36.5. crypt — Unix密码检测函数
o 36.6. dl — 在共享对象中调用C函数
o 36.7. termios — POSIX风格的tty控制
o 36.8. tty — 终端控制函数
o 36.9. pty — 伪终端功能
o 36.10. fcntl — fcntl()和ioctl()系统调用
o 36.11. pipes — 管道共享接口
o 36.12. posixfile — 类文件对象锁定支持
o 36.13. resource — 资源利用信息
o 36.14. nis — Sun’s NIS (黄页)接口
o 36.15. syslog — Unix系统日志库程序
o 36.16. commands — 命令执行功能
* 37. Mac OS X系统特殊服务 (是否翻译待定)
o 37.1. ic — 访问Mac OS X网络配置
o 37.2. MacOS — 访问Mac OS解释器特性
o 37.3. macostools — 方便的文件操作程序
o 37.4. findertools — finder的苹果事件接口
o 37.5. EasyDialogs — 基础苹果对话框
o 37.6. FrameWork — 交互式程序框架
o 37.7. autoGIL — 事件循环的全局解释器锁定处理
o 37.8. Mac OS工具箱模块
o 37.9. ColorPicker — 颜色选择对话框
* 38. MacPython OSA模块 (是否翻译待定)
o 38.1. gensuitemodule — 生成OSA stub包
o 38.2. aetools — OSA客户端支持
o 38.3. aepack — Python变量与AppleEvent数据容器的互相转换
o 38.4. aetypes — AppleEvent对象
o 38.5. MiniAEFrame — 开放式脚本架构服务支持
* 39. SGI IRIX系统特殊服务 (是否翻译待定)
o 39.1. al — SGI上的音频函数
o 39.2. AL — al模块使用的常量
o 39.3. cd — SGI系统的CD-ROM访问
o 39.4. fl — 图形用户接口的窗体库
o 39.5. FL — fl模块使用的常量
o 39.6. flp — 加载已存的窗体设计函数
o 39.7. fm — 字体管理接口
o 39.8. gl — 图形库接口
o 39.9. DEVICE — gl模块使用的常量
o 39.10. GL — gl模块使用的常量
o 39.11. imgfile — SGI系统的imglib文件支持
o 39.12. jpeg — 读写JPEG文件
* 40. SunOS系统特殊服务 (是否翻译待定)
o 40.1. sunaudiodev — 访问Sun音频硬件
o 40.2. SUNAUDIODEV — sunaudiodev模块使用的常量
* 41. 未公开模块
o 41.1. 大量的实用功能
o 41.2. 平台相关的模块
o 41.3. 多媒体
o 41.4. 未公开的Mac OS模块
o 41.5. 过时的
o 41.6. SGI相关的特殊模块
Subscribe to:
Posts
(
Atom
)