Python爬虫开发

开发爬虫的步骤

1、确定目标

2、分析目标，形成抓取策略

1)、URL格式

2)、数据格式

3)、网页编码

3、编写代码

4、执行爬虫

常用的Python网页下载器主要包括两种：

urllib2：这是Python的官方基础模块
requests：这是一个更强大的第三方包

urllib2的使用方法：

1)、将url传入到urllib2.urlopen(url)，这样就会直接得到一个网页的数据,这是最简洁的方法。

import urllib2
#直接请求
response = urllib2.urlopen('http://www.baidu.com')

#利用response的getcode()方法来获取状态码，如果是200就表示成功
print response.getcode()

#读取内容
cont = response.read()

2)、添加data、http header

#使用request方法做请求更为合理，符合网络请求的逻辑。
import urllib2
request = urllib2.Request(url) #生成Request对象
request.add_data('a','1') #添加数据
request.add_header('User-Agent','Mozilla/5.0') #添加http的header，将爬虫伪装成Mozilla浏览器
response = urllib2.urlopen(request) #发送请求获取结果
#也可以这样做
user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
values = {'username' : 'cqc',  'password' : 'XXXX' }  
headers = { 'User-Agent' : user_agent }  #添加http的header，将爬虫伪装成Mozilla浏览器
data = urllib.urlencode(values)  
request = urllib2.Request(url, data, headers) #将用户信息和header信拼装进request
response = urllib2.urlopen(request)  
page = response.read() 

#POST和GET数据传送
#POST方法
>>> import urllib
>>> import urllib2
>>> valuse = {'username':'[email protected]','password':'123'}
>>> data = urllib.urlencode(valuse) #准备账号密码
>>> url = "http://passport.csdn.net/account/login?from=http://my.csdn.net/my/mycsdn" #准备url
>>> request = urllib2.Request(url,data) #生成request 在把data传进去之前，我们要先使用urllib的urlencode方法生成有账户密码等信息的data
>>> response = urllib2.urlopen(request) #获取response 
>>> print response.read()

#urlopen用POST方法传账户密码的逻辑顺序：账号密码信息存到一个dict（valuse）里面 ---> 用urllib的urlencode方法把dict（valuse）里面的账户、密码信息封装到data里面 ---> 用urllib2的Request以目标url和data为参数生成一个request ---> 调用urllib2的urlopen方法以request为参数获得response

#GET方法
>>> values = {}
>>> valuse['username'] = '[email protected]'
>>> valuse['password'] = '123'
>>> data = urllib.urlencode(valuse)
>>> url = "http://passport.csdn.net/account/login"
>>> geturl = url + '?' + data
>>> print geturl
http://passport.csdn.net/account/login?username=123%40qq.com&password=123
>>> request = urllib2.Request(geturl)
>>> response = urllib2.urlopen(request)

urlopen(url, data, timeout)
第一个参数url即为URL，第二个参数data是访问URL时要传送的数据，第三个timeout是设置超时时间。
第二三个参数是可以不传送的，data默认为空None，timeout默认为 socket._GLOBAL_DEFAULT_TIMEOUT
第一个参数URL是必须要传送的，执行urlopen方法之后，返回一个response对象，返回信息便保存在这里面。

3)、添加特殊的情景处理器

#需要cookie才能访问的网页：HTTPCookieProcessor
#需要代理才能访问的网页：ProxyHandler
#使用Https加密协议访问的网页：HTTPSHandler
#有页面跳转的网页：HTTPRedirectHandler
import utllib2, cookielib
#创建cookie容器
cj = cookielib.CookieJar()

'''创建1个opener，HTTPCookieProcessor()以cj为参数是一个cookie处理器，生成一个Handler，再将这个Handler传给urllib2的build_opener()函数来生成一个opener对象'''
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))

# 给urllib2openner
urllib2.install_opener(opner)

#使用带有cookie的urllib2访问网页
response = urllib2.urlopen("http://www.baidu.com/")

4)、对付反盗链

对付”反盗链”的方式，对付防盗链，服务器会识别headers中的referer是不是它自己，如果不是，有的服务器不会响应，所以我们还可以在headers中加入referer

>>>headers = {'Referer': 'http://www.zhihu.com/articles', 'User-Agent': 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'}
headers = {'Referer': 'http://www.zhihu.com/articles', 'User-Agent': 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'}

5)、urllib2 默认会使用环境变量 http_proxy 来设置 HTTP Proxy。假如一个网站它会检测某一段时间某个IP 的访问次数，如果访问次数过多，它会禁止你的访问。所以你可以设置一些代理服务器来帮助你做工作，每隔一段时间换一个代理，网站君都不知道是谁在访问。

import urllib2
enable_proxy = True
proxy_handler = urllib2.ProxyHandler({"http" : 'http://some-proxy.com:8080'})
null_proxy_handler = urllib2.ProxyHandler({})
if enable_proxy:
    opener = urllib2.build_opener(proxy_handler)
else:
    opener = urllib2.build_opener(null_proxy_handler)
urllib2.install_opener(opener)

6)、Timeout 设置

urlopen方法了，第三个参数就是timeout的设置，可以设置等待多久超时，为了解决一些网站实在响应过慢而造成的影响。

import urllib2
response = urllib2.urlopen('http://www.baidu.com', timeout=10)
response = urllib2.urlopen('http://www.baidu.com',data,10)

7)、使用 HTTP 的 PUT 和 DELETE 方法

http协议有六种请求方法，get,head,put,delete,post,options，我们有时候需要用到PUT方式或者DELETE方式请求

***PUT：这个方法比较少见。HTML表单也不支持这个。本质上来讲， PUT和POST极为相似，都是向服务器发送数据，但它们之间有一个重要区别，PUT通常指定了资源的存放位置，而POST则没有，POST的数据存放位置由服务器自己决定。
DELETE：删除某一个资源。基本上这个也很少见，不过还是有一些地方比如amazon的S3云服务里面就用的这个方法来删除资源。*

如果要使用 HTTP PUT 和 DELETE ，只能使用比较低层的 httplib 库。虽然如此，我们还是能通过下面的方式，使 urllib2 能够发出 PUT 或DELETE 的请求，不过用的次数的确是少，在这里提一下。

import urllib2
request = urllib2.Request(url,data)
request.get_method = lambda: 'PUT' # or 'DELET'
response = urllib2.urlopen(request)

8)、使用DebugLog
可以通过下面的方法把 Debug Log 打开，这样收发包的内容就会在屏幕上打印出来，方便调试，这个也不太常用，仅提一下

import urllib2
httpHandler = urllib2.HTTPHandler(debuglevel=1)
httpsHandler = urllib2.HTTPSHandler(debuglevel=1)
opener = urllib2.build_opener(httpHandler, httpsHandler)
urllib2.install_opener(opener)
response = urllib2.urlopen('http://www.baidu.com')

网页解析器

1、种类

1)、模糊匹配：正则表达式
2)、结构化解析：html.parser、Beautiful Soup、lxml
结构化解析—DOM(Document Object Model)树是W3C组织官方定义的解析网页的接口

2、安装beautifulsoup4

在C:\Python27\Scripts目录下打开Dos窗口，确认pip.exe文件是存在的情况下，输入：
pip install beautifulsoup4
完成安装

3、使用BeautifulSoup

1）、由Html网页创建beautifulsoup对象
2）、搜索节点find_all、find：
3）、访问节点名称、属性、文字

from bs4 import BeautifulSoup
#根据HTML网页创建BeautifulSoup对象
soup = BeautifulSoup(
                    html_doc,            #Html文档字符串
                    'html.parser'        #Html解析器
                    from_encoding='utf-8'#Html文档的编码
                    )
#搜索节点（find_all，find）
#方法：find_all(name, attrs, string)
#查找所有标签为a的节点
soup.find_all('a')

#查找所有标签为a，链接符合/view/123.html形式的节点
soup.find_all('a',herf='/view/123.html')
#利用正则表达式来模糊匹配
soup.find_all('a',href=re.compile(r'/view/\d+\.html'))

#查找所有标签为div,class为abc，文字为Python的节点,因为Python是有class关键字的，所以用class_代表html中的class
soup.find_all('div', class_='abc',string='Python')

#访问得到的节点
#获取查找到的节点的标签名
node.name

#获取查找到的a节点的href属性。
node['href']

#获取查找到的a节点的链接文字
node.get_txt()

实例源码

#coding:utf-8
from bs4 import BeautifulSoup
import sys
import re

type = sys.getfilesystemencoding()

html_doc = """ <html><head><title>The Dormouse's story</title></head> <body> <p class="title"><b>The Dormouse's story</b></p> <p class="story">Once upon a time there were three little sisters; and their names were <a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>, <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>; and they lived at the bottom of a well.</p> <p class="story">...</p> """
soup = BeautifulSoup(html_doc, 'html.parser', from_encoding='utf-8')

print '获取所有的链接'.decode('UTF-8').encode(type)
links = soup.find_all('a')
for link in links:
    print link.name, link['href'], link.get_text()

print '获取lacie的链接'.decode('UTF-8').encode(type)
link_node = soup.find('a', href='http://example.com/lacie')
print link_node.name, link_node['href'], link_node.get_text()

print '正则匹配'.decode('UTF-8').encode(type)
link_node = soup.find('a', href=re.compile(r"ill"))
print link_node.name, link_node['href'], link_node.get_text()

print '获取P段落文字'.decode('UTF-8').encode(type)
#因为Python是有class关键字的，所以用class_代表html中的class
p_node = soup.find('p', class_='title')
print p_node.name, p_node.get_text()

URLError异常处理

首先解释下URLError可能产生的原因：
1、网络无连接，即本机无法上网
2、连接不到特定的服务器
3、服务器不存在

import urllib2 
request = urllib2.Request('http://www.xxdsafasdxx.com/')
try:
    response = urllib2.urlopen(request)
    print response.getcode()
except urllib2.URLError as err:
    print 'Error is '+str(err) 

输出

Error is <urlopen error [Errno 10060] >

HTTP状态码表示HTTP协议所返回的响应的状态。下面将状态码归结如下：
100：继续 客户端应当继续发送请求。客户端应当继续发送请求的剩余部分，或者如果请求已经完成，忽略这个响应。
101： 转换协议 在发送完这个响应最后的空行后，服务器将会切换到在Upgrade 消息头中定义的那些协议。只有在切换新的协议更有好处的时候才应该采取类似措施。
102：继续处理 由WebDAV（RFC 2518）扩展的状态码，代表处理将被继续执行。
200：请求成功 处理方式：获得响应的内容，进行处理
201：请求完成，结果是创建了新资源。新创建资源的URI可在响应的实体中得到 处理方式：爬虫中不会遇到
202：请求被接受，但处理尚未完成 处理方式：阻塞等待
204：服务器端已经实现了请求，但是没有返回新的信 息。如果客户是用户代理，则无须为此更新自身的文档视图。 处理方式：丢弃
300：该状态码不被HTTP/1.0的应用程序直接使用， 只是作为3XX类型回应的默认解释。存在多个可用的被请求资源。 处理方式：若程序中能够处理，则进行进一步处理，如果程序中不能处理，则丢弃
301：请求到的资源都会分配一个永久的URL，这样就可以在将来通过该URL来访问此资源 处理方式：重定向到分配的URL
302：请求到的资源在一个不同的URL处临时保存 处理方式：重定向到临时的URL
304：请求的资源未更新 处理方式：丢弃
400：非法请求 处理方式：丢弃
401：未授权 处理方式：丢弃
403：禁止 处理方式：丢弃
404：没有找到 处理方式：丢弃
500：服务器内部错误 服务器遇到了一个未曾预料的状况，导致了它无法完成对请求的处理。一般来说，这个问题都会在服务器端的源代码出现错误时出现。
501：服务器无法识别 服务器不支持当前请求所需要的某个功能。当服务器无法识别请求的方法，并且无法支持其对任何资源的请求。
502：错误网关 作为网关或者代理工作的服务器尝试执行请求时，从上游服务器接收到无效的响应。
503：服务出错 由于临时的服务器维护或者过载，服务器当前无法处理请求。这个状况是临时的，并且将在一段时间以后恢复。

HTTPError实例产生后会有一个code属性，这就是是服务器发送的相关错误号。
因为urllib2可以为你处理重定向，也就是3开头的代号可以被处理，并且100-299范围的号码指示成功，所以你只能看到400-599的错误号码。

req = urllib2.Request('http://blog.csdn.net/cqcre')
try:
    urllib2.urlopen(req)
except urllib2.HTTPError, e:
    print e.code
    print e.reason

输出：

403
Forbidden

HTTPError的父类是URLError，根据编程经验，父类的异常应当写到子类异常的后面，如果子类捕获不到，那么可以捕获父类的异常，所以上述的代码可以这么改写

import urllib2
req = urllib2.Request('http://blog.csdn.net/cqcre')
try:
    urllib2.urlopen(req)
except urllib2.HTTPError, e:
    print e.code
except urllib2.URLError, e:
    print e.reason
else:
    print "OK"

cookie的使用

Cookie，指某些网站为了辨别用户身份、进行session跟踪而储存在用户本地终端上的数据（通常经过加密）

比如说有些网站需要登录后才能访问某个页面，在登录之前，你想抓取某个页面内容是不允许的。那么我们可以利用Urllib2库保存我们登录的Cookie，然后再抓取其他页面就达到目的了。

当你获取一个URL你使用一个opener(一个urllib2.OpenerDirector的实例)。在前面，我们都是使用的默认的opener，也就是urlopen。它是一个特殊的opener，可以理解成opener的一个特殊实例，传入的参数仅仅是url，data，timeout。

如果我们需要用到Cookie，只用这个opener是不能达到目的的，所以我们需要创建更一般的opener来实现对Cookie的设置。

cookielib模块的主要作用是提供可存储cookie的对象，以便于与urllib2模块配合使用来访问Internet资源。Cookielib模块非常强大，我们可以利用本模块的
类的对象来捕获cookie并在后续连接请求时重新发送，比如可以实现模拟登录功能。该模块主要的对象有CookieJar、FileCookieJar、MozillaCookieJar、LWPCookieJar。

它们的关系：CookieJar —-派生—->FiCookieJarleCookieJar —-派生—–>MozillaCookieJar和LWPCookieJar

1)、获取cookie保存到变量

import urllib2
import cookielib

cookie = cookielib.CookieJar() #声明一个CookieJar对象实例来保存cookie

handler=urllib2.HTTPCookieProcessor(cookie) #利用urllib2库的HTTPCookieProcessor对象来创建cookie处理器

opener = urllib2.build_opener(handler) #通过handler来构建opener

response = opener.open('http://www.baidu.com') #此处的open方法同urllib2的urlopen方法，也可以传入request

for item in cookie:
    print 'Name = '+item.name
    print 'Value = '+item.value

输出

Name = BAIDUID
Value = 3CDE78A0F326492D542AE1C3FE209D68:FG=1
Name = BIDUPSID
Value = 3CDE78A0F326492D542AE1C3FE209D68
Name = H_PS_PSSID
Value = 18881_19719_1443_19671_19721_19781_17948_19803_19806_19558_19808_18559_15466_12397_10632
Name = PSTM
Value = 1461513550
Name = BDSVRTM
Value = 0
Name = BD_HOME
Value = 0

2)、将cookie保存到文件

使用FileCookieJar的子类MozillaCookieJar来实现Cookie的保存

import urllib2
filename = 'cookie.txt' #设置保存cookie的文件，同级目录下的cookie.txt

cookie = cookielib.MozillaCookieJar(filename) #声明一个MozillaCookieJar对象实例来保存cookie，之后写入文件

handler = urllib2.HTTPCookieProcessor(cookie) #利用urllib2库的HTTPCookieProcessor对象来创建cookie处理器

opener = urllib2.build_opener(handler) #通过handler来构建opener，和上面的那句话可以合并来写，opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookie))

response = opener.open('http://www.baidu.com') #创建一个请求，原理同urllib2的urlopen

cookie.save(ignore_discard=True, ignore_expires=True) #保存到cookie文件中

关于最后save方法的两个参数在此说明一下：
ignore_discard的意思是即使cookies将被丢弃也将它保存下来，
ignore_expires的意思是如果在该文件中cookies已经存在，则覆盖原文件写入，
我们将这两个全部设置为True。运行之后，cookies将被保存到cookie.txt文件中。

3)、从文件中获取Cookie并访问

以后要访问一个网站的话，可以从文件中把cookie读取出来再访问网站。

import urllib2

cookie = cookielib.MozillaCookieJar() #创建MozillaCookieJar实例对象，为保存取出来的cookie做准备

cookie.load('cookie.txt', ignore_discard=True, ignore_expires=True) #调用cookie的load方法，从文件中读取cookie内容到变量

request = urllib2.Request("http://www.baidu.com") #创建请求的request 

opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookie)) #利用urllib2的build_opener方法创建一个opener

response = opener.open(request)

print response.read()

4)、一个用cookie模拟登陆的实例

import urllib
import urllib2
import cookielib

filename = 'cookie.txt'

cookie = cookielib.MozillaCookieJar(filename) #声明一个MozillaCookieJar对象实例来保存cookie，之后写入文件

opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookie)) #在这里openner已经拥有了cookiie属性了

postdata = urllib.urlencode({
            'stuid':'201200131012',
            'pwd':'23342321'
        }) #录入账号密码等信息

loginUrl = 'http://jwxt.sdu.edu.cn:7890/pls/wwwbks/bks_login2.login' #登录教务系统的URL

result = opener.open(loginUrl,postdata) #模拟登录，并把cookie保存到变量

cookie.save(ignore_discard=True, ignore_expires=True) #保存cookie到cookie.txt中

gradeUrl = 'http://jwxt.sdu.edu.cn:7890/pls/wwwbks/bkscjcx.curscopre' #利用cookie请求访问另一个网址，此网址是成绩查询网址

result = opener.open(gradeUrl) #请求访问成绩查询网址

print result.read()

5)、opener.open方法和urlopen用POST方法比较

#opener.open方法传递账号密码的逻辑顺序：将账户密码等信息存到一个dict（postdata）里面 ---> 利用opener.open方法以登录url和dict（postdata）为参数得到一个result ---> print result.read()


#urlopen用POST方法传账户密码的逻辑顺序：账号密码信息存到一个dict（valuse）里面 ---> 用urllib的urlencode方法把dict（valuse）里面的账户、密码信息封装到data里面 ---> 用urllib2的Request以目标url和data为参数生成一个request ---> 调用urllib2的urlopen方法以request为参数获得response ---> response.read()

Python的正则表达式

1、正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。

*正则表达式的大致匹配过程是：
1.依次拿出表达式和文本中的字符比较，
2.如果每一个字符都能匹配，则匹配成功；一旦有匹配不成功的字符则匹配失败。
3.如果表达式中有量词或边界，这个过程会稍微有一些不同。*

2、正则表达式相关注解

（1）数量词的贪婪模式与非贪婪模式

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

注：我们一般使用非贪婪模式来提取。

（2）反斜杠问题

与大多数编程语言相同，正则表达式里使用”\”作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符”\”，那么使用编程语言表示的正则表达式里将需要4个反斜杠”\\”：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。

Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r”\”表示。同样，匹配一个数字的”\d”可以写成r”\d”。有了原生字符串，妈妈也不用担心是不是漏写了反斜杠，写出来的表达式也更直观勒。

3、Python的re模块

#返回pattern对象
re.compile(string[,flag])  
#以下为匹配所用函数
re.match(pattern, string[, flags])
re.search(pattern, string[, flags])
re.split(pattern, string[, maxsplit])
re.findall(pattern, string[, flags])
re.finditer(pattern, string[, flags])
re.sub(pattern, repl, string[, count])
re.subn(pattern, repl, string[, count])

pattern可以理解为一个匹配模式，利用re.compile方法就可以获得一个pattern,例如：

pattern = re.compile(r'Hello') #注意hello前面的r的意思是“原生字符串”

在参数中我们传入了原生字符串对象，通过compile方法编译生成一个pattern对象，然后我们利用这个对象来进行进一步的匹配。re.compile(string[,flag])，另外一个参数flag是匹配模式，取值可以使用按位或运算符’|’表示同时生效，比如re.I | re.M。可选值有：

 • re.I(全拼：IGNORECASE): 忽略大小写（括号内是完整写法，下同）
 • re.M(全拼：MULTILINE): 多行模式，改变'^'和'$'的行为（参见上图） • re.S(全拼：DOTALL): 点任意匹配模式，改变'.'的行为 • re.L(全拼：LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定 \w表示任意字母或数字 \d表示任意数字 • re.U(全拼：UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性 • re.X(全拼：VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。

注：以下七个方法中的flags同样是代表匹配模式的意思，如果在pattern生成时已经指明了flags，那么在下面的方法中就不需要传入这个参数了

（1）re.match(pattern, string[, flags]) #必须从开头匹配正则

match匹配必须从目标字符串的开头就开始匹配，如果开头不是目标字符串

# -*- coding: utf-8 -*-
''' Created on 2016年4月25日 @author: Tony '''
#导入re模块
import re

# 将正则表达式编译成Pattern对象，注意hello前面的r的意思是“原生字符串”
pattern = re.compile(r'helo')

# 使用re.match匹配文本，获得匹配结果，无法匹配时将返回None
result1 = re.match(pattern,'hello')
result2 = re.match(pattern,'helloo CQC!')
result3 = re.match(pattern,'helo CQC!')
result4 = re.match(pattern,'hello CQC!')

#如果1匹配成功
if result1:
    # 使用Match获得分组信息
    print result1.group()
else:
    print '1匹配失败！'


#如果2匹配成功
if result2:
    # 使用Match获得分组信息
    print result2.group()
else:
    print '2匹配失败！'


#如果3匹配成功
if result3:
    # 使用Match获得分组信息
    print result3.group()
else:
    print '3匹配失败！'

#如果4匹配成功
if result4:
    # 使用Match获得分组信息
    print result4.group()
else:
    print '4匹配失败！'

运行结果：

hello
hello
3匹配失败！
hello

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、\g引用分组，但不能使用编号0。\id与\g是等价的；但\10将被认为是第10个分组，如果你想表达\1之后是字符’0’，只能使用\g0。

举个例子：

# -*- coding: utf-8 -*-
#一个简单的match实例

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():", m.group()
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'\g \g\g'):", m.expand(r'\2 \1\3')

### output ###
# m.string: hello world!
# m.re: 
# 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）re.search(pattern, string[, flags]) #全文搜索正则

search方法与match方法极其类似，区别在于match()函数只检测re是不是在string的开始位置匹配，search()会扫描整个string查找匹配，match（）只有在0位置匹配成功的话才有返回，如果不是开始位置匹配成功的话，match()就返回None。同样，search方法的返回对象同样match()返回对象的方法和属性。我们用一个例子感受一下

import re

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

（3）re.split(pattern, string[, maxsplit]) #分割正则

按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数，不指定将全部分割。我们通过下面的例子感受一下。

import re

pattern = re.compile(r'\s+') #\s是空格的意思
print re.split(pattern,'one1 tw o2three3fo ur4')

### 输出 ###
# ['one', 'two', 'three', 'four', '']

（4）re.findall(pattern, string[, flags]) //以列表返回所有正则

搜索string，以列表形式返回全部能匹配的子串。我们通过这个例子来感受一下

>>> pattern = re.compile(r'\d+')
>>> print re.findall(pattern,'one1two2three3four4')
['1', '2', '3', '4']

（5）re.finditer(pattern, string[, flags]) //以迭代器返回所有

搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。我们通过下面的例子来感受一下

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

（6）re.sub(pattern, repl, string[, count]) //替换正则

使用repl替换string中每一个匹配到了的子串后返回替换后的字符串。
当repl是一个字符串时，可以使用\id或\g、\g引用分组，但不能使用编号0。
当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。
count用于指定最多替换次数，不指定时全部替换。

>>> import re
>>> pattern = re.compile(r'(\w+) (\w+)')
>>> s = 'i say,hello worlrd!'
#下面这句话是先按照pattern匹配s，得到group(1)：say i和group(2)：worlrd hello,然后用（r'\2 \1'）来替换匹配到的内容，替换的结果就是前后互换。
>>> print re.sub(pattern,r'\2 \1',s) #\1、\2等表示查找里面各个括号对应的匹配内容，也就是具体搜索到的内容，这里是将\2 和\1互换位置
say i,worlrd hello!
>>> def func(m):
    return m.group(1).title()+' '+m.group(2).title()
>>> print re.sub(pattern,func,s)
I Say,Hello Worlrd!

（7）re.subn(pattern, repl, string[, count]) //替换并统计次数正则

返回 (sub(repl, string[, count]), 替换次数)。
也就是说，使用subn时，会返回替换的次数。

>>> pattern = re.compile(r'(\w+) (\w+)')
>>> s = 'i say,hello world'
>>> print re.subn(pattern,r'\2 \1',s)
('say i,world hello', 2)
>>> def funccopy(m):
    return m.group(1).title()+' '+m.group(2).title()

>>> print re.subn(pattern,funccopy(),s)
('I Say,Hello World', 2)

3、Python的模块的另一种使用方法

可以通过pattern.match，pattern.search调用，这样调用便不用将pattern作为第一个参数传入了，大家想怎样调用皆可。

 match(string[, pos[, endpos]]) | re.match(pattern, string[, flags])
 search(string[, pos[, endpos]]) | re.search(pattern, string[, flags])
 split(string[, maxsplit]) | re.split(pattern, string[, maxsplit])
 findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags])
 finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags])
 sub(repl, string[, count]) | re.sub(pattern, repl, string[, count])
 subn(repl, string[, count]) |re.sub(pattern, repl, string[, count])

#举例说明
>>> pattern = re.compile(r'(\w+) (\w+)')
>>> s = 'i say,hello world'
>>> print pattern.subn(r'\2 \1',s)
('say i,world hello', 2)
#或者
>>> pattern = re.compile(r'\d+')
>>> s = 'one1two2three3four4'
>>> print pattern.split(s)
['one', 'two', 'three', 'four', '']

内容整理自了此链接