整理回顾了一下一篇四年前（2016年4月）写的Python爬虫博客主要内容是当时从崔庆才大佬的网站上整理出来的现在时代变了，网站基本上都有了混淆或者一些接口加了很多加密参数所以后面应该会补上一篇总结 JavaScript 逆向和 App 逆向技术结合Python爬虫解决实际问题的文章

开发爬虫的步骤

确定目标
分析目标，形成抓取策略
- URL格式
- 数据格式
- 网页编码
编写代码
执行爬虫

Python网页下载器

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

urllib2的使用方法

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

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

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

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

添加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和GET数据传送
#POST方法
>>> import urllib
>>> import urllib2
>>> valuse = {'username':'123@qq.com','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'] = '123@qq.com'
>>> 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对象，返回信息便保存在这里面。

添加特殊的情景处理器

#需要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/")

对付反盗链

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

1
2

>>>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)'}

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)

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

1
2
3

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

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)

使用 Debug Log 可以通过下面的方法把 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、模糊匹配：正则表达式（最后单独介绍） 2、结构化解析：html.parser、Beautiful Soup、lxml，结构化解析—DOM（Document Object Model）树是W3C组织官方定义的解析网页的接口。

beautifulsoup4

安装

在C:，确认pip.exe文件是存在的情况下，pip安装即可。

1	`pip install beautifulsoup4`

使用 BeautifulSoup

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

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()

Python的正则表达式

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

正则表达式的大致匹配过程是：

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

正则表达式相关注解

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

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

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

反斜杠问题

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

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

Python的re模块

pattern

#返回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,例如：

1	`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，那么在下面的方法中就不需要传入这个参数了

re.match()

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!

re.search()

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

re.split()

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', '']

re.findall()

re.findall(pattern, string[, flags]) 以列表返回所有正则搜索string，以列表形式返回全部能匹配的子串。我们通过这个例子来感受一下

1
2
3

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

re.finditer()

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

re.sub()

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!

re.subn()

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)

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', '']

正则部分的内容整理自了此链接

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)

输出

1	`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

输出：

1 2	`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

获取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

## 将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文件中。

从文件中获取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()

一个用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()

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

转载

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议，转载请注明出处！

Python异常处理上一篇

剑指offer 面试题05. 替换空格（易）下一篇

Python爬虫入门