转几个Python的连接，自己参考

最近用到Python，不是很熟练。

转几个连接，自己参考一下。

==== python 的日志logging模块学习
http://www.cnblogs.com/dkblog/archive/2011/08/26/2155018.html

=== python学习——python中执行shell命令
http://zhou123.blog.51cto.com/4355617/1312791

=== Python实战之Oracle数据库操作
http://blog.csdn.net/kongxx/article/details/7107661

=== Python正则表达式指南
http://www.cnblogs.com/huxi/archive/2010/07/04/1771073.html

python 的日志logging模块学习

1.简单的将日志打印到屏幕

 

import logging logging.debug('This is debug message') logging.info('This is info message') logging.warning('This is warning message')   屏幕上打印: WARNING:root:This is warning message

默认情况下，logging将日志打印到屏幕，日志级别为WARNING；
日志级别大小关系为：CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET，当然也可以自己定义日志级别。

2.通过logging.basicConfig函数对日志的输出格式及方式做相关配置

import logging logging.basicConfig(level=logging.DEBUG,                 format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',                 datefmt='%a, %d %b %Y %H:%M:%S',                 filename='myapp.log',                 filemode='w')      logging.debug('This is debug message') logging.info('This is info message') logging.warning('This is warning message')   ./myapp.log文件中内容为: Sun, 24 May 2009 21:48:54 demo2.py[line:11] DEBUG This is debug message Sun, 24 May 2009 21:48:54 demo2.py[line:12] INFO This is info message Sun, 24 May 2009 21:48:54 demo2.py[line:13] WARNING This is warning message

logging.basicConfig函数各参数:
filename: 指定日志文件名
filemode: 和file函数意义相同，指定日志文件的打开模式，'w'或'a'
format: 指定输出的格式和内容，format可以输出很多有用信息，如上例所示:
 %(levelno)s: 打印日志级别的数值
 %(levelname)s: 打印日志级别名称
 %(pathname)s: 打印当前执行程序的路径，其实就是sys.argv[0]
 %(filename)s: 打印当前执行程序名
 %(funcName)s: 打印日志的当前函数
 %(lineno)d: 打印日志的当前行号
 %(asctime)s: 打印日志的时间
 %(thread)d: 打印线程ID
 %(threadName)s: 打印线程名称
 %(process)d: 打印进程ID
 %(message)s: 打印日志信息
datefmt: 指定时间格式，同time.strftime()
level: 设置日志级别，默认为logging.WARNING
stream: 指定将日志的输出流，可以指定输出到sys.stderr,sys.stdout或者文件，默认输出到sys.stderr，当stream和filename同时指定时，stream被忽略

3.将日志同时输出到文件和屏幕

import logging logging.basicConfig(level=logging.DEBUG,                 format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',                 datefmt='%a, %d %b %Y %H:%M:%S',                 filename='myapp.log',                 filemode='w') ################################################################################################# #定义一个StreamHandler，将INFO级别或更高的日志信息打印到标准错误，并将其添加到当前的日志处理对象# console = logging.StreamHandler() console.setLevel(logging.INFO) formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s') console.setFormatter(formatter) logging.getLogger('').addHandler(console) ################################################################################################# logging.debug('This is debug message') logging.info('This is info message') logging.warning('This is warning message')   屏幕上打印: root        : INFO     This is info message root        : WARNING  This is warning message ./myapp.log文件中内容为: Sun, 24 May 2009 21:48:54 demo2.py[line:11] DEBUG This is debug message Sun, 24 May 2009 21:48:54 demo2.py[line:12] INFO This is info message Sun, 24 May 2009 21:48:54 demo2.py[line:13] WARNING This is warning message

4.logging之日志回滚

import logging from logging.handlers import RotatingFileHandler ################################################################################################# #定义一个RotatingFileHandler，最多备份5个日志文件，每个日志文件最大10M Rthandler = RotatingFileHandler('myapp.log', maxBytes=10*1024*1024,backupCount=5) Rthandler.setLevel(logging.INFO) formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s') Rthandler.setFormatter(formatter) logging.getLogger('').addHandler(Rthandler) ################################################################################################

从上例和本例可以看出，logging有一个日志处理的主对象，其它处理方式都是通过addHandler添加进去的。
logging的几种handle方式如下：

 

logging.StreamHandler: 日志输出到流，可以是sys.stderr、sys.stdout或者文件 logging.FileHandler: 日志输出到文件 日志回滚方式，实际使用时用RotatingFileHandler和TimedRotatingFileHandler logging.handlers.BaseRotatingHandler logging.handlers.RotatingFileHandler logging.handlers.TimedRotatingFileHandler logging.handlers.SocketHandler: 远程输出日志到TCP/IP sockets logging.handlers.DatagramHandler:  远程输出日志到UDP sockets logging.handlers.SMTPHandler:  远程输出日志到邮件地址 logging.handlers.SysLogHandler: 日志输出到syslog logging.handlers.NTEventLogHandler: 远程输出日志到Windows NT/2000/XP的事件日志 logging.handlers.MemoryHandler: 日志输出到内存中的制定buffer logging.handlers.HTTPHandler: 通过"GET"或"POST"远程输出到HTTP服务器

 

由于StreamHandler和FileHandler是常用的日志处理方式，所以直接包含在logging模块中，而其他方式则包含在logging.handlers模块中，
上述其它处理方式的使用请参见python2.5手册！

5.通过logging.config模块配置日志

#logger.conf ############################################### [loggers] keys=root,example01,example02 [logger_root] level=DEBUG handlers=hand01,hand02 [logger_example01] handlers=hand01,hand02 qualname=example01 propagate=0 [logger_example02] handlers=hand01,hand03 qualname=example02 propagate=0 ############################################### [handlers] keys=hand01,hand02,hand03 [handler_hand01] class=StreamHandler level=INFO formatter=form02 args=(sys.stderr,) [handler_hand02] class=FileHandler level=DEBUG formatter=form01 args=('myapp.log', 'a') [handler_hand03] class=handlers.RotatingFileHandler level=INFO formatter=form02 args=('myapp.log', 'a', 10*1024*1024, 5) ############################################### [formatters] keys=form01,form02 [formatter_form01] format=%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s datefmt=%a, %d %b %Y %H:%M:%S [formatter_form02] format=%(name)-12s: %(levelname)-8s %(message)s datefmt=

上例3：

import logging import logging.config logging.config.fileConfig("logger.conf") logger = logging.getLogger("example01") logger.debug('This is debug message') logger.info('This is info message') logger.warning('This is warning message')

上例4：

import logging import logging.config logging.config.fileConfig("logger.conf") logger = logging.getLogger("example02") logger.debug('This is debug message') logger.info('This is info message') logger.warning('This is warning message')

6.logging是线程安全的

from:http://blog.csdn.net/yatere/article/details/6655445

python学习——python中执行shell命令

这里介绍一下python执行shell命令的四种方法：

1、os模块中的os.system()这个函数来执行shell命令

>>> os.system( 'ls' )
anaconda - ks.cfg  install.log  install.log.syslog  send_sms_service.py  sms.py
0

注，这个方法得不到shell命令的输出。

2、popen()#这个方法能得到命令执行后的结果是一个字符串，要自行处理才能得到想要的信息。

>>>  import   os
>>>  str   =   os.popen( "ls" ).read()
>>> a  =   str .split( "\n" )
>>>  for   b  in   a:
        print   b

这样得到的结果与第一个方法是一样的。

3、commands模块#可以很方便的取得命令的输出（包括标准和错误输出）和执行状态位

import   commands
a,b  =   commands.getstatusoutput( 'ls' )
a是退出状态
b是输出的结果。
>>>  import   commands
>>> a,b  =   commands.getstatusoutput( 'ls' )
>>>  print   a
0
>>>  print   b
anaconda - ks.cfg
install.log
install.log.syslog

commands.getstatusoutput(cmd)返回（status,output)

commands.getoutput(cmd)只返回输出结果

commands.getstatus(file)返回ls -ld file 的执行结果字符串，调用了getoutput，不建议使用这个方法。

4、subprocess模块

使用subprocess模块可以创建新的进程，可以与新建进程的输入/输出/错误管道连通，并可以获得新建进程执行的返回状态。使用subprocess模块的目的是替代os.system()、os.popen*()、commands.*等旧的函数或模块。

import subprocess

1、subprocess.call(command, shell=True)

#会直接打印出结果。

2、subprocess.Popen(command, shell=True) 也可以是subprocess.Popen(command, stdout=subprocess.PIPE, shell=True) 这样就可以输出结果了。

如果command不是一个可执行文件，shell=True是不可省略的。

shell=True意思是shell下执行command

这四种方法都可以执行shell命令。

本文出自 “linux学习” 博客，请务必保留此出处http://zhou123.blog.51cto.com/4355617/1312791

Python实战之Oracle数据库操作

本文地址：http://blog.csdn.net/kongxx/article/details/7107661

1. 要想使Python可以操作Oracle数据库，首先需要安装cx_Oracle包，可以通过下面的地址来获取安装包

http://cx-oracle.sourceforge.net/

2. 另外还需要oracle的一些类库，此时需要在运行python的机器上安装Oracle Instant Client软件包，可以通过下面地址获得

http://www.oracle.com/technetwork/database/features/instant-client/index-097480.html

找到符合自己平台的包，然后安装，这里我使用的是rpm包，所以使用以下命令安装

$ sudo rpm -ivh  oracle-instantclient11.2-basic-11.2.0.3.0-1.i386.rpm

装完毕后还需要设置一下环境变量，如下

$ export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:/usr/lib/oracle/11.2/client/lib

3. 创建一个简单的python文件，测试安装是否成功

import cx_Oracle

conn = cx_Oracle.connect('fkong/[email protected]/orcl')  
cursor = conn.cursor ()
cursor.execute ("select * from dual")
row = cursor.fetchone ()
print row[0]

cursor.close ()
conn.close ()

4. 下面看一个数据库建表和插入操作

import cx_Oracle

conn = cx_Oracle.connect('fkong/[email protected]/orcl')  
cursor = conn.cursor ()

cursor.execute ("CREATE TABLE TEST(ID INT, COL1 VARCHAR(32), COL2 VARCHAR(32), COL3 VARCHAR(32))")

cursor.execute ("INSERT INTO TEST (ID, COL1, COL2, COL3)VALUES(1, 'a', 'b', 'c')")
cursor.execute ("INSERT INTO TEST (ID, COL1, COL2, COL3)VALUES(2, 'aa', 'bb', 'cc')")
cursor.execute ("INSERT INTO TEST (ID, COL1, COL2, COL3)VALUES(3, 'aaa', 'bbb', 'ccc')")
conn.commit()

cursor.close ()
conn.close ()

5. 下面再来看看查询，查询通常有两种方式：一种是使用cursor.fetchall（）获取所有查询结果，然后再一行一行的迭代；另一种每次通过cursor.fetchone()获取一条记录，直到获取的结果为空为止。看一下下面的例子：

import cx_Oracle

conn = cx_Oracle.connect('fkong/[email protected]/orcl')  
cursor = conn.cursor ()

cursor.execute ("SELECT * FROM TEST")
rows = cursor.fetchall()
for row in rows:
	print "%d, %s, %s, %s" % (row[0], row[1], row[2], row[3])

print "Number of rows returned: %d" % cursor.rowcount

cursor.execute ("SELECT * FROM TEST")
while (1):
	row = cursor.fetchone()
	if row == None:
		break
	print "%d, %s, %s, %s" % (row[0], row[1], row[2], row[3])
	
print "Number of rows returned: %d" % cursor.rowcount

cursor.close ()
conn.close ()

Python正则表达式指南

本文介绍了Python对于正则表达式的支持，包括正则表达式基础以及Python正则表达式标准库的完整介绍及使用示例。本文的内容不包括如何编写高效的正则表达式、如何优化正则表达式，这些主题请查看其他教程。

注意：本文基于Python2.4完成；如果看到不明白的词汇请记得百度谷歌或维基，whatever。

尊重作者的劳动，转载请注明作者及原文地址 >.<html

1. 正则表达式基础

1.1. 简单介绍

正则表达式并不是Python的一部分。正则表达式是用于处理字符串的强大工具，拥有自己独特的语法以及一个独立的处理引擎，效率上可能不如str自带的方法，但功能十分强大。得益于这一点，在提供了正则表达式的语言里，正则表达式的语法都是一样的，区别只在于不同的编程语言实现支持的语法数量不同；但不用担心，不被支持的语法通常是不常用的部分。如果已经在其他语言里使用过正则表达式，只需要简单看一看就可以上手了。

下图展示了使用正则表达式进行匹配的流程： 

正则表达式的大致匹配过程是：依次拿出表达式和文本中的字符比较，如果每一个字符都能匹配，则匹配成功；一旦有匹配不成功的字符则匹配失败。如果表达式中有量词或边界，这个过程会稍微有一些不同，但也是很好理解的，看下图中的示例以及自己多使用几次就能明白。

下图列出了Python支持的正则表达式元字符和语法：   

1.2. 数量词的贪婪模式与非贪婪模式

正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符。例如：正则表达式"ab*"如果用于查找"abbbc"，将找到"abbb"。而如果使用非贪婪的数量词"ab*?"，将找到"a"。

1.3. 反斜杠的困扰

与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\"表示。同样，匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。

1.4. 匹配模式

正则表达式提供了一些可用的匹配模式，比如忽略大小写、多行匹配等，这部分内容将在Pattern类的工厂方法re.compile(pattern[, flags])中一起介绍。

2. re模块

2.1. 开始使用re

Python通过re模块提供对正则表达式的支持。使用re的一般步骤是先将正则表达式的字符串形式编译为Pattern实例，然后使用Pattern实例处理文本并获得匹配结果（一个Match实例），最后使用Match实例获得信息，进行其他的操作。

# encoding: UTF-8
import   re

# 将正则表达式编译成Pattern对象
pattern =   re. compile (r 'hello' )

# 使用Pattern匹配文本，获得匹配结果，无法匹配时将返回None
match =   pattern.match( 'hello world!' )

if   match:
    # 使用Match获得分组信息
    print   match.group()

### 输出 ###
# hello

re.compile(strPattern[, flag]):

这个方法是Pattern类的工厂方法，用于将字符串形式的正则表达式编译为Pattern对象。 第二个参数flag是匹配模式，取值可以使用按位或运算符'|'表示同时生效，比如re.I | re.M。另外，你也可以在regex字符串中指定模式，比如re.compile('pattern', re.I | re.M)与re.compile('(?im)pattern')是等价的。 
可选值有：

• re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
• M(MULTILINE): 多行模式，改变'^'和'$'的行为（参见上图）
• S(DOTALL): 点任意匹配模式，改变'.'的行为
• L(LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
• U(UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性
• X(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提供了众多模块方法用于完成正则表达式的功能。这些方法可以使用Pattern实例的相应方法替代，唯一的好处是少写一行re.compile()代码，但同时也无法复用编译后的Pattern对象。这些方法将在Pattern类的实例方法部分一起介绍。如上面这个例子可以简写为：

m =   re.match(r 'hello' , 'hello world!' )
print   m.group()

re模块还提供了一个方法escape(string)，用于将string中的正则表达式元字符如*/+/?等之前加上转义符再返回，在需要大量匹配元字符时有那么一点用。

2.2. Match

Match对象是一次匹配的结果，包含了很多关于此次匹配的信息，可以使用Match提供的可读属性或方法来获取这些信息。

属性：

1. string: 匹配时使用的文本。
2. re: 匹配时使用的Pattern对象。
3. pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
4. endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
5. lastindex: 最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组，将为None。
6. lastgroup: 最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组，将为None。

方法：

1. group([group1, …]): 
   获得一个或多个分组截获的字符串；指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名；编号0代表整个匹配的子串；不填写参数时，返回group(0)；没有截获字符串的组返回None；截获了多次的组返回最后一次截获的子串。
2. groups([default]): 
   以元组形式返回全部分组截获的字符串。相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代，默认为None。
3. groupdict([default]): 
   返回以有别名的组的别名为键、以该组截获的子串为值的字典，没有别名的组不包含在内。default含义同上。
4. start([group]): 
   返回指定的组截获的子串在string中的起始索引（子串第一个字符的索引）。group默认值为0。
5. end([group]): 
   返回指定的组截获的子串在string中的结束索引（子串最后一个字符的索引+1）。group默认值为0。
6. span([group]): 
   返回(start(group), end(group))。
7. expand(template): 
   将匹配到的分组代入template中然后返回。template中可以使用\id或\g<id>、\g<name>引用分组，但不能使用编号0。\id与\g<id>是等价的；但\10将被认为是第10个分组，如果你想表达\1之后是字符'0'，只能使用\g<1>0。

import   re
m =   re.match(r '(\w+) (\w+)(?P<sign>.*)' , 'hello world!' )

print   "m.string:" , m.string
print   "m.re:" , m.re
print   "m.pos:" , m.pos
print   "m.endpos:" , m.endpos
print   "m.lastindex:" , m.lastindex
print   "m.lastgroup:" , m.lastgroup

print   "m.group(1,2):" , m.group( 1 , 2 )
print   "m.groups():" , m.groups()
print   "m.groupdict():" , m.groupdict()
print   "m.start(2):" , m.start( 2 )
print   "m.end(2):" , m.end( 2 )
print   "m.span(2):" , m.span( 2 )
print   r "m.expand(r'\2 \1\3'):" , m.expand(r '\2 \1\3' )

### output ###
# m.string: hello world!
# m.re: <_sre.SRE_Pattern object at 0x016E1A38>
# m.pos: 0
# m.endpos: 12
# m.lastindex: 3
# m.lastgroup: sign
# m.group(1,2): ('hello', 'world')
# m.groups(): ('hello', 'world', '!')
# m.groupdict(): {'sign': '!'}
# m.start(2): 6
# m.end(2): 11
# m.span(2): (6, 11)
# m.expand(r'\2 \1\3'): world hello!

2.3. Pattern

Pattern对象是一个编译好的正则表达式，通过Pattern提供的一系列方法可以对文本进行匹配查找。

Pattern不能直接实例化，必须使用re.compile()进行构造。

Pattern提供了几个可读属性用于获取表达式的相关信息：

1. pattern: 编译时用的表达式字符串。
2. flags: 编译时用的匹配模式。数字形式。
3. groups: 表达式中分组的数量。
4. groupindex: 以表达式中有别名的组的别名为键、以该组对应的编号为值的字典，没有别名的组不包含在内。

import   re
p =   re. compile (r '(\w+) (\w+)(?P<sign>.*)' , re.DOTALL)

print   "p.pattern:" , p.pattern
print   "p.flags:" , p.flags
print   "p.groups:" , p.groups
print   "p.groupindex:" , p.groupindex

### output ###
# p.pattern: (\w+) (\w+)(?P<sign>.*)
# p.flags: 16
# p.groups: 3
# p.groupindex: {'sign': 3}

实例方法[ | re模块方法]：

1. match(string[, pos[, endpos]]) | re.match(pattern, string[, flags]): 
   这个方法将从string的pos下标处起尝试匹配pattern；如果pattern结束时仍可匹配，则返回一个Match对象；如果匹配过程中pattern无法匹配，或者匹配未结束就已到达endpos，则返回None。 
   pos和endpos的默认值分别为0和len(string)；re.match()无法指定这两个参数，参数flags用于编译pattern时指定匹配模式。 
   注意：这个方法并不是完全匹配。当pattern结束时若string还有剩余字符，仍然视为成功。想要完全匹配，可以在表达式末尾加上边界匹配符'$'。 
   示例参见2.1小节。
2. search(string[, pos[, endpos]]) | re.search(pattern, string[, flags]): 
   这个方法用于查找字符串中可以匹配成功的子串。从string的pos下标处起尝试匹配pattern，如果pattern结束时仍可匹配，则返回一个Match对象；若无法匹配，则将pos加1后重新尝试匹配；直到pos=endpos时仍无法匹配则返回None。 
   pos和endpos的默认值分别为0和len(string))；re.search()无法指定这两个参数，参数flags用于编译pattern时指定匹配模式。 
   

   # encoding: UTF-8
   import   re
   
   # 将正则表达式编译成Pattern对象
   pattern =   re. compile (r 'world' )
   
   # 使用search()查找匹配的子串，不存在能匹配的子串时将返回None
   # 这个例子中使用match()无法成功匹配
   match =   pattern.search( 'hello world!' )
   
   if   match:
       # 使用Match获得分组信息
       print   match.group()
   
   ### 输出 ###
   # world

3. split(string[, maxsplit]) | re.split(pattern, string[, maxsplit]): 
   按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数，不指定将全部分割。 
   

   import   re
   
   p =   re. compile (r '\d+' )
   print   p.split( 'one1two2three3four4' )
   
   ### output ###
   # ['one', 'two', 'three', 'four', '']

4. findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags]): 
   搜索string，以列表形式返回全部能匹配的子串。 
   

   import   re
   
   p =   re. compile (r '\d+' )
   print   p.findall( 'one1two2three3four4' )
   
   ### output ###
   # ['1', '2', '3', '4']

5. finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags]): 
   搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。 
   

   import   re
   
   p =   re. compile (r '\d+' )
   for   m in   p.finditer( 'one1two2three3four4' ):
       print   m.group(),
   
   ### output ###
   # 1 2 3 4

6. sub(repl, string[, count]) | re.sub(pattern, repl, string[, count]): 
   使用repl替换string中每一个匹配的子串后返回替换后的字符串。 
   当repl是一个字符串时，可以使用\id或\g<id>、\g<name>引用分组，但不能使用编号0。 
   当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。 
   count用于指定最多替换次数，不指定时全部替换。 
   

   import   re
   
   p =   re. compile (r '(\w+) (\w+)' )
   s =   'i say, hello world!'
   
   print   p.sub(r '\2 \1' , s)
   
   def   func(m):
       return   m.group( 1 ).title() +   ' '   +   m.group( 2 ).title()
   
   print   p.sub(func, s)
   
   ### output ###
   # say i, world hello!
   # I Say, Hello World!

7. subn(repl, string[, count]) |re.sub(pattern, repl, string[, count]): 
   返回 (sub(repl, string[, count]), 替换次数)。 
   

   import   re
   
   p =   re. compile (r '(\w+) (\w+)' )
   s =   'i say, hello world!'
   
   print   p.subn(r '\2 \1' , s)
   
   def   func(m):
       return   m.group( 1 ).title() +   ' '   +   m.group( 2 ).title()
   
   print   p.subn(func, s)
   
   ### output ###
   # ('say i, world hello!', 2)
   # ('I Say, Hello World!', 2)

以上就是Python对于正则表达式的支持。熟练掌握正则表达式是每一个程序员必须具备的技能，这年头没有不与字符串打交道的程序了。笔者也处于初级阶段，与君共勉，^_^

另外，图中的特殊构造部分没有举出例子，用到这些的正则表达式是具有一定难度的。有兴趣可以思考一下，如何匹配不是以abc开头的单词，^_^

全文结束