I am LAZY bones ? all linux

分类: '编程相关' 的归档

几个连接数据库用的python模块

工作中,经常会有用python访问各种数据库的需求,比如从oracle读点配置文件或者往mysql写点结果信息之类的。
这里列一下可能用到的各个模块。

sqlite3: 内置模块
用sqlite,有时候确实很方便,我觉得它确实做到了宣称的“零配置”。python自2.5版以来,就内置了对sqlite3的支持,使用也非常简单,按照文档上来:

#打开db文件,获得连接
conn = sqlite3.connect('数据文件名')
#获得游标
c = conn.cursor()
#执行SQL
c.execute('''SQL 片段''')
#如果有对数据的修改操作,那就需要commit一下
conn.commit()
#关闭游标
c.close()
#关闭连接
conn.close()

另外,关于sqlite在C和bash下的用法,可以参考为以前的文章

oracle: cx_Oracle
其实,前面先介绍sqlite3,除了它确实是个小数据库以外,还有一个原因:其他数据库在python下的操作,其实基本上和sqlite3的操作是一样的,也就是说,python其实已经几乎统一了数据库的接口。
打开cx_Oracle的文档页面,你会发现其风格也和python文档很像,因为他们都是用 Sphinx 做的。模块的使用方法就更像了,把上面的代码里,获得连接的那行,换成这样:

conn = cx_Oracle.connect('username/password@TNSname')

就可以了。只要把用户名、密码、TNS组成一个字符串,传进去,就可以得到一个oracle的连接了。

mysql: MySQLdb
和前两个非常类似,连接的时候用以下两个语法之一:

conn = MySQLdb.connect('host', 'username', 'password', 'database')
conn = MySQLdb.connect(host="host", user="username", passwd="password", db="database")

接下来,也把它当成sqlite用就好了。

excel: pyExcelerator
好吧,我承认excel不算数据库,只是写在这里充数而已,哈哈。因为偶尔还是要取下别人发来的excel里的数据的。
其实,用pyExcelerator来读取文件也是很简单的:

sheets=pyExcelerator.parse_xls('xxx.xls')

这样出来以后,sheets就是整个工作薄了,它是工作表组成的list,而一个工作表对应于一个tuple,格式是: ('工作表名', 内容),而内容又是一个dict,key是一个(行数, 列数)的tuple,value才是正在的对应格子的内容。看起来确实比较绕,好在处理excel的应用也不多,将就吧。
另外,其实pyExcelerator还支持写入数据到excel的,如果有把查询结果保存成excel的需求的话,可以试试看,我还是尽量不用这种格式了,哈哈。

对老域名用PHP写了个301重定向

之前,这里的域名一直都是 li2z.cn ,但是,被CNNIC逼得走投无路以后,我终于把域名换成 luy.li 了。其实准确的说,不是“换”,是加了一个域名,并射成默认了而已,因此用 li2z.cn 还是可以访问的,甚至连301都没有做,之前我的做法只是把两个域名的后台路径指向同一个了而已(题外话:由于两个站的内容完全一致,所以被google惩罚了,li2z.cn 的PR瞬间就变成0了,所以在意PR的站长千万别这么干哦~)。
现在,时间也过去这么久了,大多数的流量已经是新域名下的了,但是老域名的流量也还有不少,于是我就想能不能在不影响访问的同时,统计一下老域名的每次http请求的来路。
方法自然是把所有request用301重定向到 luy.li 的对应地址,然后在日志里记录refer了(不明白301和refer的请自行google基础知识)。
这个用我三脚猫的php都很容易搞定,就几行代码,index.php如下:

<?php
header("HTTP/1.1 301 Moved Permanently");
header("Location: http://luy.li".$_SERVER['REQUEST_URI']);
date_default_timezone_set('Etc/GMT-8');
$msg = date('Y-m-d H:i:s').' '.$_SERVER['HTTP_REFERER'].' '.$_SERVER['REQUEST_URI']."\n";
file_put_contents('log.txt',$msg,FILE_APPEND);
?>

然后,建个 .htaccess 把域名下的所有请求都指向 index.php:

<IfModule mod_rewrite.c>
RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . index.php [L]
</IfModule>

测试一下,对get请求,可以完整地转到新的域名了:

$ curl -v "http://li2z.cn/abc?xxx=yyy"
* About to connect() to li2z.cn port 80 (#0)
* Trying 66.147.240.158… connected
* Connected to li2z.cn (66.147.240.158) port 80 (#0)
> GET /abc?xxx=yyy HTTP/1.1
> User-Agent: curl/7.21.1 (i686-pc-linux-gnu) libcurl/7.21.1 GnuTLS/2.10.2 zlib/1.2.5
> Host: li2z.cn
> Accept: */*
>
< HTTP/1.1 301 Moved Permanently < Date: Sat, 02 Oct 2010 12:05:53 GMT < Server: Apache < X-Powered-By: PHP/5.2.14 < Location: http://luy.li/abc?xxx=yyy
< Cache-Control: max-age=1 < Expires: Sat, 02 Oct 2010 12:05:54 GMT < Vary: Accept-Encoding < Content-Length: 0 < Content-Type: text/html < * Connection #0 to host li2z.cn left intact * Closing connection #0 然后在后台目录里会生成一个 log.txt ,里面会有所有访问的时间、refer和uri,这样日后就可以方便地查出老域名的所有来路和受访页面了,最重要的是,由于有301,还不会对正常访问造成影响哦~

python编程细节──遍历dict的两种方法比较

python以其优美的语法和方便的内置数据结构,赢得了不少程序员的亲睐。
其中有个很有用的数据结构,就是字典(dict),使用非常简单。说到遍历一个dict结构,我想大多数人都会想到 for key in dictobj 的方法,确实这个方法在大多数情况下都是适用的。但是并不是完全安全,请看下面这个例子:

#这里初始化一个dict
>>> d = {'a':1, 'b':0, 'c':1, 'd':0}
#本意是遍历dict,发现元素的值是0的话,就删掉
>>> for k in d:
...   if d[k] == 0:
...     del(d[k])
... 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: dictionary changed size during iteration
#结果抛出异常了,两个0的元素,也只删掉一个。
>>> d
{'a': 1, 'c': 1, 'd': 0}
 
>>> d = {'a':1, 'b':0, 'c':1, 'd':0}
#d.keys() 是一个下标的数组
>>> d.keys()
['a', 'c', 'b', 'd']
#这样遍历,就没问题了,因为其实其实这里遍历的是d.keys()这个list常量。
>>> for k in d.keys():
...   if d[k] == 0:
...     del(d[k])
... 
>>> d
{'a': 1, 'c': 1}
#结果也是对的
>>>

其实,这个例子是我简化过的,我是在一个多线程的程序里发现这个问题的,所以,我的建议是:遍历dict的时候,养成使用 for k in d.keys() 的习惯。
不过,如果是多线程的话,这样就绝对安全吗?也不见得:当两个线程都取完d.keys()以后,如果两个线程都去删同一个key的话,先删的会成功,后删的那个肯定会报 KeyError ,这个看来只能通过其他方式来保证了。

设置python的stdout为无缓存模式

考虑以下python程序:

#!/usr/bin/env python
 
import sys
 
sys.stdout.write("stdout1 ")
sys.stderr.write("stderr1 ")
sys.stdout.write("stdout2 ")
sys.stderr.write("stderr2 ")

其中的sys.stdout.write也可以换成print。
运行这程序,你觉得会输出什么?试验一下,就会发现,其实输出并不是

stdout1 stderr1  stdout2 stderr2

而是:

stderr1 stderr2 stdout1  stdout2

究其原因,是因为缓存:虽然stderr和stdout默认都是指向屏幕的,但是stderr是无缓存的,程序往stderr输出一个字符,就会在屏幕上显示一个;而stdout是有缓存的,只有遇到换行或者积累到一定的大小,才会显示出来。这就是为什么上面的会显示两个stderr的原因了。
然而,有时候,你可能还是希望stdout的行为和stderr一样,能不能实现呢?当然是可以的,而且对于python,实现起来还特别方便,以下是两个方法:

python -u stderr_stdout.py
PYTHONUNBUFFERED=1 python stderr_stdout.py

第一种方法是给python指定 -u 参数,第二种方法是在python运行时,指定 PYTHONUNBUFFERED 环境变量,这两种方法其实是等效的。
当然,也可以在程序的第一行指定 #!/usr/bin/python -u 然后程序加可执行权限来运行,或者把 export PYTHONUNBUFFERED=1 写到 .bashrc 里去。

为什么python里要 if __name__ == ‘__main__’:

尽管python允许你像shell脚本一样,把大段的代码堆积着写,但是,很多python入门的书,都会建议你把代码写成一个函数,然后在最后面统一调用,例如这样:

def main():
    #具体代码
 
if __name__ == '__main__':
    main()

很多文章都会说这个是由于代码风格之类的原因,但是其实,不这样写,有时候也是会直接导致出错的。
举个例子,打开《A Byte of Python》的类变量那节,可以这里看在线版本,然后把中间的那示例代码复制下来,运行,可以看到,确实能得到预期正确的结果。
但是,现在把那代码里的所有“swaroop”换成“xxx1”,再把所有“kalam”换成“yyy1”,再运行,就会在程序运行的最后时刻,得到这么一个奇怪的错误(Python 2.6.5下实验):
Exception AttributeError: "'NoneType' object has no attribute 'population'" in > ignored
也就是说,换了个变量名,程序就出错了。。。
究其原因,应该是python在最后析构所有类和对象的时候,并没有处理这些对象之间的依赖关系,而是根据变量名来决定某种顺序操作了。从而导致Person类本身,先于yyy2被干掉了,所以在解构yyy2的时候,执行它的__del__()方法,却发现父类都已经没有了~~
这应该确实算是python解析器的bug,但是,如果那把这个例子里的所有class Person以外的代码,写到一个main()函数里,再通过上述方法调用的话,就不会发生这种错误了。
所以,大家最好还是别太在意多几行代码,养成这个好习惯吧。

要深究此错误的原因,可以看官方文档里的描述,并在这里讨论。

python中的socket代理

说socket代理之前,先来说说http代理,python的urllib2是自带http代理功能的,可以用如下代码实现:

proxy_handler = urllib2.ProxyHandler({'http' : 'http://地址:端口'})
opener = urllib2.build_opener(proxy_handler, urllib2.HTTPHandler)
urllib2.install_opener(opener)

如此,接下来用urllib2来urlopen的时候,就会自动使用这个代理了。

但是,在我们疯狂的天朝,有时候,http代理并不能满足要求,也许你还想使用更底层的socket代理,于是python里似乎就没有直接的方法了(python3不知道有没有内置,未研究)。这时候,你可能需要这个包:SocksiPy – A Python SOCKS module,下载解压以后,除了文档也就一个 socks.py 文件,很方便使用,给出示例代码:

import socks, socket
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, "地址", 端口)
socket.socket = socks.socksocket

接下来,你就可以照常使用socket了,一切都会悄悄地通过代理出去的~

python的正则表达式 re

延伸阅读:python的 内建函数subprocess 。此文是本系列的第三篇文章了,和之前一样,内容出自官方文档,但是会有自己的理解,并非单纯的翻译。所以,如果我理解有误,欢迎指正,谢谢。

本模块提供了和Perl里的正则表达式类似的功能,不关是正则表达式本身还是被搜索的字符串,都可以是Unicode字符,这点不用担心,python会处理地和Ascii字符一样漂亮。
正则表达式使用反斜杆(\)来转义特殊字符,使其可以匹配字符本身,而不是指定其他特殊的含义。这可能会和python字面意义上的字符串转义相冲突,这也许有些令人费解。比如,要匹配一个反斜杆本身,你也许要用'\\\\'来做为正则表达式的字符串,因为正则表达式要是\\,而字符串里,每个反斜杆都要写成\\
你也可以在字符串前加上 r 这个前缀来避免部分疑惑,因为 r 开头的python字符串是 raw 字符串,所以里面的所有字符都不会被转义,比如r'\n'这个字符串就是一个反斜杆加上一字母n,而'\n'我们知道这是个换行符。因此,上面的'\\\\'你也可以写成r'\\',这样,应该就好理解很多了。可以看下面这段:

>>> import re
>>> s = '\x5c'  #0x5c就是反斜杆
>>> print s
\
>>> re.match('\\\\', s)  #这样可以匹配
<_sre.SRE_Match object at 0xb6949e20>
>>> re.match(r'\\', s)  #这样也可以
<_sre.SRE_Match object at 0x80ce2c0>
>>> re.match('\\', s)  #但是这样不行
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python2.6/re.py", line 137, in match
    return _compile(pattern, flags).match(string)
  File "/usr/lib/python2.6/re.py", line 245, in _compile
    raise error, v # invalid expression
sre_constants.error: bogus escape (end of line)
>>>

另外值得一提的是,re模块的方法,大多也就是RegexObject对象的方法,两者的区别在于执行效率。这个在最后再展开吧。

正则表达式语法

正则表达式(RE)指定一个与之匹配的字符集合;本模块所提供的函数,将可以用来检查所给的字符串是否与指定的正则表达式匹配。
正则表达式可以被连接,从而形成新的正则表达式;例如A和B都是正则表达式,那么AB也是正则表达式。一般地,如果字符串p与A匹配,q与B匹配的话,那么字符串pq也会与AB匹配,但A或者B里含有边界限定条件或者命名组操作的情况除外。也就是说,复杂的正则表达式可以用简单的连接而成。
正则表达式可以包含特殊字符和普通字符,大部分字符比如'A''a''0'都是普通字符,如果做为正则表达式,它们将匹配它们本身。由于正则表达式可以连接,所以连接多个普通字符而成的正则表达式last也将匹配'last'。(后面将用不带引号的表示正则表达式,带引号的表示字符串)

下面就来介绍正则表达式的特殊字符:

'.'
点号,在普通模式,它匹配除换行符外的任意一个字符;如果指定了 DOTALL 标记,匹配包括换行符以内的任意一个字符。

'^'
尖尖号,匹配一个字符串的开始,在 MULTILINE 模式下,也将匹配任意一个新行的开始。

'$'
美元符号,匹配一个字符串的结尾或者字符串最后面的换行符,在 MULTILINE 模式下,也匹配任意一行的行尾。也就是说,普通模式下,foo.$去搜索'foo1\nfoo2\n'只会找到’foo2’,但是在 MULTILINE 模式,还能找到 ‘foo1’,而且就用一个 $ 去搜索'foo\n'的话,会找到两个空的匹配:一个是最后的换行符,一个是字符串的结尾,演示:

>>> re.findall('(foo.$)', 'foo1\nfoo2\n')
['foo2']
>>> re.findall('(foo.$)', 'foo1\nfoo2\n', re.MULTILINE)
['foo1', 'foo2']
>>> re.findall('($)', 'foo\n')
['', '']

'*'
星号,指定将前面的RE重复0次或者任意多次,而且总是试图尽量多次地匹配。

'+'
加号,指定将前面的RE重复1次或者任意多次,而且总是试图尽量多次地匹配。

'?'
问号,指定将前面的RE重复0次或者1次,如果有的话,也尽量匹配1次。

*?+???
从前面的描述可以看到'*''+''?'都是贪婪的,但这也许并不是我们说要的,所以,可以在后面加个问号,将策略改为非贪婪,只匹配尽量少的RE。示例,体会两者的区别:

>>> re.findall('<(.*)>', '<H1>title</H1>')
['H1>title</H1']
>>> re.findall('<(.*?)>', '<H1>title</H1>')
['H1', '/H1']

{m}
m是一个数字,指定将前面的RE重复m次。

{m,n}
m和n都是数字,指定将前面的RE重复m到n次,例如a{3,5}匹配3到5个连续的a。注意,如果省略m,将匹配0到n个前面的RE;如果省略n,将匹配n到无穷多个前面的RE;当然中间的逗号是不能省略的,不然就变成前面那种形式了。

{m,n}?
前面说的{m,n},也是贪婪的,a{3,5}如果有5个以上连续a的话,会匹配5个,这个也可以通过加问号改变。a{3,5}?如果可能的话,将只匹配3个a。

'\'
反斜杆,转义'*''?'等特殊字符,或者指定一个特殊序列(下面会详述)
由于之前所述的原因,强烈建议用raw字符串来表述正则。

[]
方括号,用于指定一个字符的集合。可以单独列出字符,也可以用'-'连接起止字符以表示一个范围。特殊字符在中括号里将失效,比如[akm$]就表示字符'a''k''m',或'$',在这里$也变身为普通字符了。[a-z]匹配任意一个小写字母,[a-zA-Z0-9]匹配任意一个字母或数字。如果你要匹配']''-'本身,你需要加反斜杆转义,或者是将其置于中括号的最前面,比如[]]可以匹配']'
你还可以对一个字符集合取反,以匹配任意不在这个字符集合里的字符,取反操作用一个'^'放在集合的最前面表示,放在其他地方的'^'将不会起特殊作用。例如[^5]将匹配任意不是'5'的字符;[^^]将匹配任意不是'^'的字符。
注意:在中括号里,+*()这类字符将会失去特殊含义,仅作为普通字符。反向引用也不能在中括号内使用。

'|'
管道符号,A和B是任意的RE,那么A|B就是匹配A或者B的一个新的RE。任意个数的RE都可以像这样用管道符号间隔连接起来。这种形式可以被用于中(后面将详述)。对于目标字符串,被'|'分割的RE将自左至右一一被测试,一旦有一个测试成功,后面的将不再被测试,即使后面的RE可能可以匹配更长的串,换句话说,'|'操作符是非贪婪的。要匹配字面意义上的'|',可以用反斜杆转义:\|,或是包含在反括号内:[|]

(...)
匹配圆括号里的RE匹配的内容,并指定的开始和结束位置。组里面的内容可以被提取,也可以采用\number这样的特殊序列,被用于后续的匹配。要匹配字面意义上的'('')',可以用反斜杆转义:\(\),或是包含在反括号内:[(][)]

(?...)
这是一个表达式的扩展符号。'?'后的第一个字母决定了整个表达式的语法和含义,除了(?P...)以外,表达式不会产生一个新的组。下面介绍几个目前已被支持的扩展:

(?iLmsux)
'i''L''m''s''u''x'里的一个或多个字母。表达式不匹配任何字符,但是指定相应的标志:re.I(忽略大小写)、re.L(依赖locale)、re.M(多行模式)、re.S(.匹配所有字符)、re.U(依赖Unicode)、re.X(详细模式)。关于各个模式的区别,下面会有专门的一节来介绍的。使用这个语法可以代替在re.compile()的时候或者调用的时候指定flag参数。
例如,上面举过的例子,可以改写成这样(和指定了re.MULTILINE是一样的效果):

>>> re.findall('(?m)(foo.$)', 'foo1\nfoo2\n')
['foo1', 'foo2']

另外,还要注意(?x)标志如果有的话,要放在最前面。

(?:...)
匹配内部的RE所匹配的内容,但是不建立

(?P<name>...)
和普通的圆括号类似,但是子串匹配到的内容将可以用命名的name参数来提取。组的name必须是有效的python标识符,而且在本表达式内不重名。命名了的组和普通组一样,也用数字来提取,也就是说名字只是个额外的属性。
演示一下:

>>> m=re.match('(?P<var>[a-zA-Z_]\w*)', 'abc=123')
>>> m.group('var')
'abc'
>>> m.group(1)
'abc'

(?P=name)
匹配之前以name命名的组里的内容。
演示一下:

>>> re.match('<(?P<tagname>\w*)>.*</(?P=tagname)>', '<h1>xxx</h2>')  #这个不匹配
>>> re.match('<(?P<tagname>\w*)>.*</(?P=tagname)>', '<h1>xxx</h1>')  #这个匹配
<_sre.SRE_Match object at 0xb69588e0>

(?#...)
注释,圆括号里的内容会被忽略。

(?=...)
如果 ... 匹配接下来的字符,才算匹配,但是并不会消耗任何被匹配的字符。例如 Isaac (?=Asimov) 只会匹配后面跟着 'Asimov''Isaac ',这个叫做“前瞻断言”。

(?!...)
和上面的相反,只匹配接下来的字符串匹配 ... 的串,这叫做“反前瞻断言”。

(?<=...)
只有当当前位置之前的字符串匹配 ... ,整个匹配才有效,这叫“后顾断言”。字符串'abcdef'可以匹配正则(?<=abc)def,因为会后向查找3个字符,看是否为abc。所以内置的子RE,需要是固定长度的,比如可以是abca|b,但不能是a*a{3,4}。注意这种RE永远不会匹配到字符串的开头。举个例子,找到连字符('-')后的单词:

>>> m = re.search('(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'

(?<!...)
同理,这个叫做“反后顾断言”,子RE需要固定长度的,含义是前面的字符串不匹配 ... 整个才算匹配。

(?(id/name)yes-pattern|no-pattern)
如有由id或者name指定的组存在的话,将会匹配yes-pattern,否则将会匹配no-pattern,通常情况下no-pattern也可以省略。例如:(<)?(\w+@\w+(?:\.\w+)+)(?(1)>)可以匹配 '<user@host.com>''user@host.com',但是不会匹配 '<user@host.com'

下面列出以'\'开头的特殊序列。如果某个字符没有在下面列出,那么RE的结果会只匹配那个字母本身,比如,\$只匹配字面意义上的'$'

\number
匹配number所指的组相同的字符串。组的序号从1开始。例如:(.+) \1可以匹配'the the''55 55',但不匹配'the end'。这种序列在一个正则表达式里最多可以有99个,如果number以0开头,或是有3位以上的数字,就会被当做八进制表示的字符了。同时,这个也不能用于方括号内。

\A
只匹配字符串的开始。

\b
匹配单词边界(包括开始和结束),这里的“单词”,是指连续的字母、数字和下划线组成的字符串。注意,\b的定义是\w\W的交界,所以精确的定义有赖于UNICODELOCALE这两个标志位。

\B
\b相反,\B匹配非单词边界。也依赖于UNICODELOCALE这两个标志位。

\d
未指定UNICODE标志时,匹配数字,等效于:[0-9]。指定了UNICODE标志时,还会匹配其他Unicode库里描述为字符串的符号。便于理解,举个例子(好不容易找的例子啊,呵呵):

#\u2076\和u2084分别是上标的6和下标的4,属于unicode的DIGIT
>>> unistr = u'\u2076\u2084abc'
>>> print unistr
⁶₄abc
>>> print re.findall('\d+', unistr, re.U)[0]
⁶₄

\D
\d相反,不多说了。

\s
当未指定UNICODELOCALE这两个标志位时,匹配任何空白字符,等效于[ \t\n\r\f\v]。如果指定了LOCALE,则还要加LOCALE相关的空白字符;如果指定了UNICODE,还要加上UNICODE空白字符,如较常见的空宽度连接空格(\uFEFF)、零宽度非连接空格(\u200B)等。

\S
\s相反,也不多说。

\w
当未指定UNICODELOCALE这两个标志位时,等效于[a-zA-Z0-9_]。当指定了LOCALE时,为[0-9_]加上当前LOCAL指定的字母。当指定了UNICODE时,为[0-9_]加上UNICODE库里的所有字母。

\W
\w相反,不多说。

\Z
只匹配字符串的结尾。

匹配之于搜索

python提供了两种基于正则表达式的操作:匹配(match)从字符串的开始检查字符串是否个正则匹配。而搜索(search)检查字符串任意位置是否有匹配的子串(perl默认就是如此)。
注意,即使search的正则以'^'开头,match和search也还是有许多不同的。

>>> re.match("c", "abcdef")  # 不匹配
>>> re.search("c", "abcdef") # 匹配
<_sre.SRE_Match object at ...>

模块的属性和方法

re.compile(pattern[, flags])
把一个正则表达式pattern编译成正则对象,以便可以用正则对象的matchsearch方法。
得到的正则对象的行为(也就是模式)可以用flags来指定,值可以由几个下面的值OR得到。
以下两段内容在语法上是等效的:

prog = re.compile(pattern)
result = prog.match(string)
result = re.match(pattern, string)

区别是,用了re.compile以后,正则对象会得到保留,这样在需要多次运用这个正则对象的时候,效率会有较大的提升。再用上面用过的例子来演示一下,用相同的正则匹配相同的字符串,执行100万次,就体现出compile的效率了(数据来自我那1.86G CPU的神舟本本):

>>> timeit.timeit(
...     setup='''import re; reg = re.compile('<(?P<tagname>\w*)>.*</(?P=tagname)>')''',
...     stmt='''reg.match('<h1>xxx</h1>')''',
...     number=1000000)
1.2062149047851562
>>> timeit.timeit(
...     setup='''import re''',
...     stmt='''re.match('<(?P<tagname>\w*)>.*</(?P=tagname)>', '<h1>xxx</h1>')''',
...     number=1000000)
4.4380838871002197

re.I
re.IGNORECASE
让正则表达式忽略大小写,这样一来,[A-Z]也可以匹配小写字母了。此特性和locale无关。

re.L
re.LOCALE
\w\W\b\B\s\S依赖当前的locale。

re.M
re.MULTILINE
影响'^''$'的行为,指定了以后,'^'会增加匹配每行的开始(也就是换行符后的位置);'$'会增加匹配每行的结束(也就是换行符前的位置)。

re.S
re.DOTALL
影响'.'的行为,平时'.'匹配除换行符以外的所有字符,指定了本标志以后,也可以匹配换行符。

re.U
re.UNICODE
\w\W\b\B\d\D\s\S依赖Unicode库。

re.X
re.VERBOSE
运用这个标志,你可以写出可读性更好的正则表达式:除了在方括号内的和被反斜杠转义的以外的所有空白字符,都将被忽略,而且每行中,一个正常的井号后的所有字符也被忽略,这样就可以方便地在正则表达式内部写注释了。也就是说,下面两个正则表达式是等效的:

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")

re.search(pattern, string[, flags])
扫描string,看是否有个位置可以匹配正则表达式pattern。如果找到了,就返回一个MatchObject的实例,否则返回None,注意这和找到长度为0的子串含义是不一样的。搜索过程受flags的影响。

re.match(pattern, string[, flags])
如果字符串string的开头和正则表达式pattern匹配的话,返回一个相应的MatchObject的实例,否则返回None

注意:要在字符串的任意位置搜索的话,需要使用上面的search()

re.split(pattern, string[, maxsplit=0])
用匹配pattern的子串来分割string,如果pattern里使用了圆括号,那么被pattern匹配到的串也将作为返回值列表的一部分。如果maxsplit不为0,则最多被分割为maxsplit个子串,剩余部分将整个地被返回。

>>> re.split('\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split('(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split('\W+', 'Words, words, words.', 1)
['Words', 'words, words.']

如果正则有圆括号,并且可以匹配到字符串的开始位置的时候,返回值的第一项,会多出一个空字符串。匹配到字符结尾也是同样的道理:

>>> re.split('(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']

注意,split不会被零长度的正则所分割,例如:

>>> re.split('x*', 'foo')
['foo']
>>> re.split("(?m)^$", "foo\n\nbar\n")
['foo\n\nbar\n']

re.findall(pattern, string[, flags])
以列表的形式返回string里匹配pattern的不重叠的子串。string会被从左到右依次扫描,返回的列表也是从左到右一次匹配到的。如果pattern里含有的话,那么会返回匹配到的组的列表;如果pattern里有多个组,那么各组会先组成一个元组,然后返回值将是一个元组的列表。
由于这个函数不会涉及到MatchObject之类的概念,所以,对新手来说,应该是最好理解也最容易使用的一个函数了。下面就此来举几个简单的例子:

#简单的findall
>>> re.findall('\w+', 'hello, world!')
['hello', 'world']
#这个返回的就是元组的列表
>>> re.findall('(\d+)\.(\d+)\.(\d+)\.(\d+)', 'My IP is 192.168.0.2, and your is 192.168.0.3.')
[('192', '168', '0', '2'), ('192', '168', '0', '3')]

re. finditer(pattern, string[, flags])
和上面的findall()类似,但返回的是MatchObject的实例的迭代器。
还是例子说明问题:
>>> for m in re.finditer('\w+', 'hello, world!'):
... print m.group()
...
hello
world

re.sub(pattern, repl, string[, count])
替换,将string里,匹配pattern的部分,用repl替换掉,最多替换count次(剩余的匹配将不做处理),然后返回替换后的字符串。如果string里没有可以匹配pattern的串,将被原封不动地返回。repl可以是一个字符串,也可以是一个函数(也可以参考我以前的例子)。如果repl是个字符串,则其中的反斜杆会被处理过,比如 \n 会被转成换行符,反斜杆加数字会被替换成相应的组,比如 \6 表示pattern匹配到的第6个组的内容。
例子:

>>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):',
...        r'static PyObject*\npy_\1(void)\n{',
...        'def myfunc():')
'static PyObject*\npy_myfunc(void)\n{'

如果repl是个函数,每次pattern被匹配到的时候,都会被调用一次,传入一个匹配到的MatchObject对象,需要返回一个字符串,在匹配到的位置,就填入返回的字符串。
例子:

>>> def dashrepl(matchobj):
...     if matchobj.group(0) == '-': return ' '
...     else: return '-'
>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')
'pro--gram files'

零长度的匹配也会被替换,比如:

>>> re.sub('x*', '-', 'abcxxd')
'-a-b-c-d-'

特殊地,在替换字符串里,如果有\g这样的写法,将匹配正则的命名组(前面介绍过的,(?P...)这样定义出来的东西)。\g这样的写法,也是数字的组,也就是说,\g<2>一般和\2是等效的,但是万一你要在\2后面紧接着写上字面意义的0,你就不能写成\20了(因为这代表第20个组),这时候必须写成\g<2>0,另外,\g<0>代表匹配到的整个子串。
例子:

>>> re.sub('-(\d+)-', '-\g<1>0\g<0>', 'a-11-b-22-c')
'a-110-11-b-220-22-c'

re.subn(pattern, repl, string[, count])
跟上面的sub()函数一样,只是它返回的是一个元组 (新字符串, 匹配到的次数)
,还是用例子说话:

>>> re.subn('-(\d+)-', '-\g<1>0\g<0>', 'a-11-b-22-c')
('a-110-11-b-220-22-c', 2)

re.escape(string)
string中,除了字母和数字以外的字符,都加上反斜杆。

>>> print re.escape('abc123_@#$')
abc123\_\@\#\$

exception re.error
如果字符串不能被成功编译成正则表达式或者正则表达式在匹配过程中出错了,都会抛出此异常。但是如果正则表达式没有匹配到任何文本,是不会抛出这个异常的。

正则对象

正则对象由re.compile()返回。它有如下的属性和方法。

match(string[, pos[, endpos]])
作用和模块的match()函数类似,区别就是后面两个参数。
pos是开始搜索的位置,默认为0。endpos是搜索的结束位置,如果endpospos还小的话,结果肯定是空的。也就是说只有posendpos-1 位置的字符串将会被搜索。
例子:

>>> pattern = re.compile("o")
>>> pattern.match("dog")      # 开始位置不是o,所以不匹配
>>> pattern.match("dog", 1)   # 第二个字符是o,所以匹配
<_sre.SRE_Match object at ...>

search(string[, pos[, endpos]])
作用和模块的search()函数类似,posendpos参数和上面的match()函数类似。

split(string[, maxsplit=0])
findall(string[, pos[, endpos]])
finditer(string[, pos[, endpos]])
sub(repl, string[, count=0])
subn(repl, string[, count=0])
这几个函数,都和模块的相应函数一致。

flags
编译本RE时,指定的标志位,如果未指定任何标志位,则为0。

>>> pattern = re.compile("o", re.S|re.U)
>>> pattern.flags
48

groups
RE所含有的组的个数。

groupindex
一个字典,定义了命名组的名字和序号之间的关系。
例子:

这个正则有3个组,如果匹配到,第一个叫区号,最后一个叫分机号,中间的那个未命名
>>> pattern = re.compile("(?P<quhao>\d+)-(\d+)-(?P<fenjihao>\d+)")
>>> pattern.groups
3
>>> pattern.groupindex
{'fenjihao': 3, 'quhao': 1}

pattern
建立本RE的原始字符串,相当于源代码了,呵呵。
还是上面这个正则,可以看到,会原样返回:

>>> print pattern.pattern
(?P<quhao>\d+)-(\d+)-(?P<fenjihao>\d+)

Match对象

re.MatchObject被用于布尔判断的时候,始终返回True,所以你用 if 语句来判断某个 match() 是否成功是安全的。
它有以下方法和属性:

expand(template)
template做为模板,将MatchObject展开,就像sub()里的行为一样,看例子:

>>> m = re.match('a=(\d+)', 'a=100')
>>> m.expand('above a is \g<1>')
'above a is 100'
>>> m.expand(r'above a is \1')
'above a is 100'

group([group1, ...])
返回一个或多个子组。如果参数为一个,就返回一个子串;如果参数有多个,就返回多个子串注册的元组。如果不传任何参数,效果和传入一个0一样,将返回整个匹配。如果某个groupN未匹配到,相应位置会返回None。如果某个groupN是负数或者大于group的总数,则会抛出IndexError异常。

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m.group(0)       # 整个匹配
'Isaac Newton'
>>> m.group(1)       # 第一个子串
'Isaac'
>>> m.group(2)       # 第二个子串
'Newton'
>>> m.group(1, 2)    # 多个子串组成的元组
('Isaac', 'Newton')

如果有其中有用(?P...)这种语法命名过的子串的话,相应的groupN也可以是名字字符串。例如:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'

如果某个组被匹配到多次,那么只有最后一次的数据,可以被提取到:

>>> m = re.match(r"(..)+", "a1b2c3")  # 匹配到3次
>>> m.group(1)                        # 返回的是最后一次
'c3'

groups([default])
返回一个由所有匹配到的子串组成的元组。default参数,用于给那些没有匹配到的组做默认值,它的默认值是None
例如:

>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
>>> m.groups()
('24', '1632')

default的作用:

>>> m = re.match(r"(\d+)\.?(\d+)?", "24")
>>> m.groups()      # 第二个默认是None
('24', None)
>>> m.groups('0')   # 现在默认是0了
('24', '0')

groupdict([default])
返回一个包含所有命名组的名字和子串的字典,default参数,用于给那些没有匹配到的组做默认值,它的默认值是None,例如:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.groupdict()
{'first_name': 'Malcolm', 'last_name': 'Reynolds'}

start([group])
end([group])
返回的是:被组group匹配到的子串在原字符串中的位置。如果不指定groupgroup指定为0,则代表整个匹配。如果group未匹配到,则返回 -1
对于指定的m和g,m.group(g)m.string[m.start(g):m.end(g)]等效。
注意:如果group匹配到空字符串,m.start(group)m.end(group)将相等。
例如:

>>> m = re.search('b(c?)', 'cba')
>>> m.start(0)
1
>>> m.end(0)
2
>>> m.start(1)
2
>>> m.end(1)
2

下面是一个把email地址里的“remove_this”去掉的例子:

>>> email = "tony@tiremove_thisger.net"
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
'tony@tiger.net'

span([group])
返回一个元组: (m.start(group), m.end(group))

pos
就是传给RE对象的search()match()方法的参数pos,代表RE开始搜索字符串的位置。

endpos
就是传给RE对象的search()match()方法的参数endpos,代表RE搜索字符串的结束位置。

lastindex
最后一次匹配到的组的数字序号,如果没有匹配到,将得到None
例如:(a)b((a)(b))((ab))正则去匹配'ab'的话,得到的lastindex为1。而用(a)(b)去匹配'ab'的话,得到的lastindex为2。

lastgroup
最后一次匹配到的组的名字,如果没有匹配到或者最后的组没有名字,将得到None

re
得到本Match对象的正则表达式对象,也就是执行search()match()的对象。

string
传给search()match()的字符串。

后面的例子就略了吧,文中已经加了很多我自己的例子了,需要更多例子的话,参照英文原文吧。
最后,感谢我的老婆辛苦地帮我校对,哈哈。

python程序,在windows下调用子进程,不产生cmd窗口的办法

python写的GTK程序,会有这样一个怪现象,本来在cmd下用 python xxx.py 启动,还好好的,但是用py2exe编译以后,再用subprocess调用命令行程序的时候,就发现一个黑乎乎的cmd窗口跳出来了,特别难看,要消除它其实也还比较容易,但是要使用startupinfo这个windows only的参数,以下代码是linux和windows通用的例子:

if os.name == 'nt':
    startupinfo = subprocess.STARTUPINFO()
    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
    startupinfo.wShowWindow = subprocess.SW_HIDE
else:
    startupinfo = None
subprocess.Popen(要运行的命令, startupinfo=startupinfo)

经过今天的修改,gmbox 0.2.4 beta 已经基本能在win下运行了,哈哈。

PS:贴一个ultraedit的python语法高亮文件,偶尔在win下改改代码可能会用到,在这里

python中的子进程 subprocess

此文和python 内建函数一样,内容全部出自python官方文档,但是会有自己的理解,并非单纯的翻译。所以,如果我理解有误,欢迎指正,谢谢。

从python2.4版本开始,你就可以用可以用subprocess这个模块来产生子进程,并连接到子进程的标准输入/输出/错误中去,还可以得到子进程的返回值。subprocess意在替代其他几个老的模块或者函数,比如:

os.system
os.spawn*
os.popen*
popen2.*
commands.*

下面将一一介绍如何用subprocess来替代这些函数或者模块。

使用subprocess模块

本模块定义了一个类: Popen

class subprocess.Popen(args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=False, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0)

各参数含义如下:

args需要是一个字符串,或者包含程序参数的列表。要执行的程序一般就是这个列表的第一项,或者是字符串本身。但是也可以用executable参数来明确指出。当executable参数不为空时,args里的第一项仍被认为是程序的“命令名”,不同于真正的可执行文件的文件名,这个“命令名”是一个用来显示的名称,例如执行*nix下的 ps 命令,显示出来的就是这个“命令名”。

在*nix下,当shell=False(默认)时,Popen使用os.execvp()来执行子程序。args一般要是一个列表。如果args是个字符串的话,会被当做是可执行文件的路径,这样就不能传入任何参数了。

注意:
shlex.split()可以被用于序列化复杂的命令参数,比如:

>>> import shlex, subprocess
>>> command_line = raw_input()
/bin/vikings -input eggs.txt -output "spam spam.txt" -cmd "echo '$MONEY'"
>>> args = shlex.split(command_line)
>>> print args
['/bin/vikings', '-input', 'eggs.txt', '-output', 'spam spam.txt', '-cmd', "echo '$MONEY'"]
>>> p = subprocess.Popen(args) # 成功执行!

可以看到,空格分隔的选项(如-input)和参数(如eggs.txt)会被分割为列表里独立的项,但引号里的或者转义过的空格不在此列。这也有点像大多数shell的行为。

在*nix下,当shell=True时,如果args是个字符串,就使用shell来解释执行这个字符串。如果args是个列表,则第一项被视为命令,其余的都视为是给shell本身的参数。也就是说,等效于:

Popen(['/bin/sh', '-c', args[0], args[1], ...])

在windows下,Popen使用接受字符串参数的CreateProcess()来执行子程序。如果args是个列表,它会被先用list2cmdline()转换成字符串。

如果指定了bufsize参数,作用就和内建函数open()一样:0表示不缓冲,1表示行缓冲,其他正数表示近似的缓冲区字节数,负数表示使用系统默认值。默认是0。

executable参数指定要执行的程序。它很少会被用到:一般程序可以由args参数指定。如果shell=Trueexecutable可以用于指定用哪个shell来执行(比如bash、csh、zsh等)。*nix下,默认是 /bin/sh ,windows下,就是环境变量 COMSPEC 的值。windows下,只有当你要执行的命令确实是shell内建命令(比如dircopy等)时,你才需要指定shell=True,而当你要执行一个基于命令行的批处理脚本的时候,不需要指定此项。

stdinstdoutstderr分别表示子程序的标准输入、标准输出和标准错误。可选的值有PIPE(见下面的描述)或者一个有效的文件描述符(其实是个正整数)或者一个文件对象,还有None。如果是PIPE,则表示需要创建一个新的管道,如果是None,不会做任何重定向工作,子进程的文件描述符会继承父进程的。另外,stderr的值还可以是STDOUT(见下),表示子进程的标准错误也输出到标准输出。

如果把preexec_fn设置为一个可调用的对象(比如函数),就会在子进程被执行前被调用。(仅限*nix)

如果把close_fds设置成True,*nix下会在开子进程前把除了0、1、2以外的文件描述符都先关闭。在Windows下也不会继承其他文件描述符。

如果把shell设置成True,指定的命令会在shell里解释执行,这个前面已经说得比较详细了。

如果cwd不是None,则会把cwd做为子程序的当前目录。注意,并不会把该目录做为可执行文件的搜索目录,所以不要把程序文件所在目录设置为cwd

如果env不是None,则子程序的环境变量由env的值来设置,而不是默认那样继承父进程的环境变量。注意,即使你只在env里定义了某一个环境变量的值,也会阻止子程序得到其他的父进程的环境变量(也就是说,如果env里只有1项,那么子进程的环境变量就只有1个了)。例如:

>>> subprocess.Popen('env', env={'xxx':'123', 'yyy':'zzz'})
<subprocess.Popen object at 0xb694112c>
>>> xxx=123
yyy=zzz

如果把universal_newlines设置成True,则子进程的stdout和stderr被视为文本对象,并且不管是*nix的行结束符('\n'),还是老mac格式的行结束符('\r'),还是windows格式的行结束符('\r\n')都将被视为 '\n'

如果指定了startupinfocreationflags,将会被传递给后面的CreateProcess()函数,用于指定子程序的各种其他属性,比如主窗口样式或者是子进程的优先级等。(仅限Windows)

介绍完Popen的各参数,再来看下两个小东西:

subprocess.PIPE
一个可以被用于Popen的stdinstdoutstderr3个参数的特输值,表示需要创建一个新的管道。

subprocess.STDOUT
一个可以被用于Popen的stderr参数的特输值,表示子程序的标准错误汇合到标准输出。

方便的函数

subprocess.call(*popenargs, **kwargs)
执行命令,并等待命令结束,再返回子进程的返回值。参数同Popen,因为打开 /usr/lib/python2.6/subprocess.py 你就知道,去掉文档,其实是这样的:

def call(*popenargs, **kwargs):
    return Popen(*popenargs, **kwargs).wait()

subprocess.check_call(*popenargs, **kwargs)
执行上面的call命令,并检查返回值,如果子进程返回非0,则会抛出CalledProcessError异常,这个异常会有个returncode属性,记录子进程的返回值。

>>> subprocess.check_call('false')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python2.6/subprocess.py", line 498, in check_call
    raise CalledProcessError(retcode, cmd)
subprocess.CalledProcessError: Command 'false' returned non-zero exit status 1

异常

子进程里抛出的异常,会在父进程中再次抛出。并且,异常会有个叫child_traceback的额外属性,这是个包含子进程错误traceback信息的字符串。

遇到最多的错误回是 OSError,比如执行了一个并不存在的子程序就会产生OSError。

另外,如果使用错误的参数调用Popen,会抛出ValueError。

当子程序返回非0时,check_call()还会产生CalledProcessError异常。

安全性

不像其他的popen函数,本模块不会偷偷地调用/bin/sh来解释命令,也就是说,命令中的每一个字符都会被安全地传递到子进程里。

Popen对象

Popen对象有以下方法:

Popen.poll()
检查子进程是否已结束,设置并返回 returncode 属性。

Popen.wait()
等待子进程结束,设置并返回 returncode 属性。

注意:如果子进程输出了大量数据到stdout或者stderr的管道,并达到了系统pipe的缓存大小的话,子进程会等待父进程读取管道,而父进程此时正wait着的话,将会产生传说中的死锁,后果是非常严重滴。建议使用communicate()来避免这种情况的发生。

Popen.communicate(input=None)
和子进程交互:发送数据到stdin,并从stdout和stderr读数据,直到收到EOF。等待子进程结束。可选的input如有有的话,要为字符串类型。
此函数返回一个元组: (stdoutdata, stderrdata) 。
注意,要给子进程的stdin发送数据,则Popen的时候,stdin要为PIPE;同理,要可以收数据的话,stdout或者stderr也要为PIPE。

注意:读到的数据会被缓存在内存里,所以数据量非常大的时候要小心了。

Popen.send_signal(signal)
给子进程发送signal信号量。

注意:windows下目前只支持发送SIGTERM,等效于下面的terminate()

Popen.terminate()
停止子进程。Posix下是发送SIGTERM信号。windows下是调用TerminateProcess()这个API。

Popen.kill()
杀死子进程。Posix下是发送SIGKILL信号。windows下和terminate()无异。

Popen.stdin
如果stdin参数是PIPE,此属性就是一个文件对象,否则为None

Popen.stdout
如果stdout参数是PIPE,此属性就是一个文件对象,否则为None

Popen.stderr
如果stderr参数是PIPE,此属性就是一个文件对象,否则为None

Popen.pid
子进程的进程号。注意,如果shell参数为True,这属性指的是子shell的进程号。

Popen.returncode
子程序的返回值,由poll()或者wait()设置,间接地也由communicate()设置。
如果为None,表示子进程还没终止。
如果为负数-N的话,表示子进程被N号信号终止。(仅限*nux)

用subprocess来代替其他函数

在这节里,举一些常用的例子,都可以用subprocess来完成,我们假定是用 “from subprocess import *” 来导入模块的:

代替shell命令:

output=`mycmd myarg`
等效于
output = Popen([“mycmd”, “myarg”], stdout=PIPE).communicate()[0]

代替shell管道:

output=`dmesg | grep hda`
等效于
p1 = Popen([“dmesg”], stdout=PIPE)
p2 = Popen([“grep”, “hda”], stdin=p1.stdout, stdout=PIPE)
output = p2.communicate()[0]

代替os.system()

sts = os.system(“mycmd” + ” myarg”)
等效于
p = Popen(“mycmd” + ” myarg”, shell=True)
sts = os.waitpid(p.pid, 0)[1]

注意:

  • 通常并不需要用shell来调用程序。
  • 用subprocess可以更方便地得到子程序的返回值。

其实,更真实的替换是:

try:
retcode = call(“mycmd” + ” myarg”, shell=True)
if retcode < 0: print >>sys.stderr, “Child was terminated by signal”, -retcode
else:
print >>sys.stderr, “Child returned”, retcode
except OSError, e:
print >>sys.stderr, “Execution failed:”, e

代替os.spawn系列
P_NOWAIT的例子

pid = os.spawnlp(os.P_NOWAIT, “/bin/mycmd”, “mycmd”, “myarg”)
等效于
pid = Popen([“/bin/mycmd”, “myarg”]).pid

P_WAIT的例子

retcode = os.spawnlp(os.P_WAIT, “/bin/mycmd”, “mycmd”, “myarg”)
等效于
retcode = call([“/bin/mycmd”, “myarg”])

Vector的例子

os.spawnvp(os.P_NOWAIT, path, args)
等效于
Popen([path] + args[1:])

关于环境变量的例子

os.spawnlpe(os.P_NOWAIT, “/bin/mycmd”, “mycmd”, “myarg”, env)
等效于
Popen([“/bin/mycmd”, “myarg”], env={“PATH”: “/usr/bin”})

代替os.popen(), os.popen2(), os.popen3()

pipe = os.popen(“cmd”, ‘r’, bufsize)
等效于
pipe = Popen(“cmd”, shell=True, bufsize=bufsize, stdout=PIPE).stdout

pipe = os.popen(“cmd”, ‘w’, bufsize)
等效于
pipe = Popen(“cmd”, shell=True, bufsize=bufsize, stdin=PIPE).stdin

(child_stdin, child_stdout) = os.popen2(“cmd”, mode, bufsize)
等效于
p = Popen(“cmd”, shell=True, bufsize=bufsize, stdin=PIPE, stdout=PIPE, close_fds=True)
(child_stdin, child_stdout) = (p.stdin, p.stdout)

(child_stdin, child_stdout, child_stderr) = os.popen3(“cmd”, mode, bufsize)
等效于
p = Popen(“cmd”, shell=True, bufsize=bufsize, stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True)
(child_stdin, child_stdout, child_stderr) = (p.stdin, p.stdout, p.stderr)

(child_stdin, child_stdout_and_stderr) = os.popen4(“cmd”, mode, bufsize)
等效于
p = Popen(“cmd”, shell=True, bufsize=bufsize, stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)
(child_stdin, child_stdout_and_stderr) = (p.stdin, p.stdout)

*nix下,os.popen2, os.popen3, os.popen4 也可以接受一个列表做为执行的命令,这时参数会被直接传给程序,而不经过shell的解释转换。如下:

(child_stdin, child_stdout) = os.popen2([“/bin/ls”, “-l”], mode, bufsize)
等效于
p = Popen([“/bin/ls”, “-l”], bufsize=bufsize, stdin=PIPE, stdout=PIPE)
(child_stdin, child_stdout) = (p.stdin, p.stdout)

返回值处理:

pipe = os.popen(“cmd”, ‘w’)

rc = pipe.close()
if rc != None and rc % 256:
print “There were some errors”
等效于
process = Popen(“cmd”, ‘w’, shell=True, stdin=PIPE)

process.stdin.close()
if process.wait() != 0:
print “There were some errors”

代替popen2模块里的函数:

(child_stdout, child_stdin) = popen2.popen2(“somestring”, bufsize, mode)
等效于
p = Popen([“somestring”], shell=True, bufsize=bufsize, stdin=PIPE, stdout=PIPE, close_fds=True)
(child_stdout, child_stdin) = (p.stdout, p.stdin)

*nix下,popen2 也可以接受一个列表做为执行的命令,这时参数会被直接传给程序,而不经过shell的解释转换。如下:

(child_stdout, child_stdin) = popen2.popen2([“mycmd”, “myarg”], bufsize, mode)
等效于
p = Popen([“mycmd”, “myarg”], bufsize=bufsize, stdin=PIPE, stdout=PIPE, close_fds=True)
(child_stdout, child_stdin) = (p.stdout, p.stdin)

popen2.Popen3 and popen2.Popen4 基本上也能用 subprocess.Popen 代替,除了以下几点要注意:

  • 执行失败的时候Popen会抛出异常
  • capturestderr参数用stderr代替
  • stdin=PIPEstdout=PIPE 必须要指定
  • popen2默认会关掉所有文件描述符,而Popen要指定close_fds=True

用“函数属性”来避免C中格式化字符串时可能存在的错误

为了说明这个问题,先来看下这个简单的C程序:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <stdarg.h>
 
void writeLogInfo(const char *sFormat, ...){
	char sOutBuffer[4196];
	va_list lvalist;
 
	va_start(lvalist, sFormat);
	vsnprintf(sOutBuffer, sizeof(sOutBuffer)-2, sFormat, lvalist);
	va_end(lvalist);
 
	printf("log: %s\n", sOutBuffer);
}
 
int main(){
    writeLogInfo("int=%s", 123);
    return 0;
}

这程序用gcc编译,即使是用 -Wall 打开所有的警告,也是不会有任何报错的。
但是执行结果是什么呢?由于 writeLogInfo 的是一个参数里指定的是 %s ,而第二个参数确是整型数字 123。所以程序义无反顾地出现了“段错误”而崩溃掉。这种问题在项目代码超过万行以后,要debug起来,也是会浪费很多时间的。
有的人会发现,如果把main里的writeLogInfo直接换成printf,那么在编译的时候,gcc会报一个警告:“警告:格式‘%s’需要类型‘char *’,但实参 2 的类型为‘int’”(Gcc4.x默认就会报,Gcc3.x要加 -Wall 选项才报),如果我们自己的定义的writeLogInfo函数也能有这个警告,那么这种bug将在编译的时候就可以完美解决了。
那么具体怎么实现呢?先来看下面这段代码,功能是和上面的完全一样的,连错误都一样,呵呵:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h>
#include <stdarg.h>
 
#ifndef __GNUC__
#  define  __attribute__(x)  /*NOTHING*/
#endif
 
void writeLogInfo(const char *sFormat, ...){
	char sOutBuffer[4196];
	va_list lvalist;
 
	va_start(lvalist, sFormat);
	vsnprintf(sOutBuffer, sizeof(sOutBuffer)-2, sFormat, lvalist);
	va_end(lvalist);
 
	printf("log: %s\n", sOutBuffer);
}
void writeLogInfo(const char *sFormat, ...) __attribute__((format(printf,1,2)));
 
int main(){
    writeLogInfo("int=%s", 123);
    return 0;
}

当你尝试用gcc编译这个文件的时候,你就可以看到警告了,哈哈。
可以看到,这里的关键就是“__attribute__((format(printf,1,2)))” ,这句话的作用就是告诉编译器,前面这个函数呢,参数类型是类似printf的,格式化字符串在参数的第1个位置,扩展参数从第2个位置开始,然后编译器就明白了~
然后,上面的4~6行呢,是为了兼容非Gcc的编译器而加的,这样其他的编译器就会直接无视整个 __attribute__ 了,这样至少不会报错。
其实,这个检查格式化字串的功能(format),只是“函数属性”的一个而已,另外还有许多有用又有意思的属性,比如函数的别名啊(alias),是否已经过时啊(deprecated),等等~要了解这些用法的话,建议去看看官方文档