入门Python爬虫

为了爬新浪体育直播间往年的直播和战报自学了Python爬虫，学习期间碰到了很多奇奇怪怪的网页报错，所以总结了一篇常用的http状态码（参见我另一篇博客），根据这个状态码可以轻松发现是网页打开过程中的那一块出了问题，现在把整个入门Python爬虫的过程总结如下：

概述

1.什么是爬虫

爬虫，即网络爬虫，大家可以理解为在网络上爬行的一直蜘蛛，互联网就比作一张大网，而爬虫便是在这张网上爬来爬去的蜘蛛咯，如果它遇到资源，那么它就会抓取下来。想抓取什么？这个由你来控制它咯。

比如它在抓取一个网页，在这个网中他发现了一条道路，其实就是指向网页的超链接，那么它就可以爬到另一张网上来获取数据。这样，整个连在一起的大网对这之蜘蛛来说触手可及，分分钟爬下来不是事儿。

2.浏览网页的过程

在用户浏览网页的过程中，我们可能会看到许多好看的图片，比如 http://image.baidu.com/ ，我们会看到几张的图片以及百度搜索框，这个过程其实就是用户输入网址之后，经过DNS服务器，找到服务器主机，向服务器发出一个请求，服务器经过解析之后，发送给用户的浏览器 HTML、JS、CSS 等文件，浏览器解析出来，用户便可以看到形形色色的图片了。

因此，用户看到的网页实质是由 HTML 代码构成的，爬虫爬来的便是这些内容，通过分析和过滤这些 HTML 代码，实现对图片、文字等资源的获取。

3.URL的含义

URL，即统一资源定位符，也就是我们说的网址，统一资源定位符是对可以从互联网上得到的资源的位置和访问方法的一种简洁的表示，是互联网上标准资源的地址。互联网上的每个文件都有一个唯一的URL，它包含的信息指出文件的位置以及浏览器应该怎么处理它。

URL的格式由三部分组成：
①第一部分是协议(或称为服务方式)。
②第二部分是存有该资源的主机IP地址(有时也包括端口号)。
③第三部分是主机资源的具体地址，如目录和文件名等。

爬虫爬取数据时必须要有一个目标的URL才可以获取数据，因此，它是爬虫获取数据的基本依据，准确理解它的含义对爬虫学习有很大帮助。

4. 环境的配置

学习Python，当然少不了环境的配置，最初我用的是Notepad++，不过发现它的提示功能实在是太弱了，于是，在Windows下我用了 PyCharm。并同时装上了python2和3两种环境预备使用。

Urllib库的使用

1.分分钟扒一个网页下来

怎样扒网页呢？其实就是根据URL来获取它的网页信息，虽然我们在浏览器中看到的是一幅幅优美的画面，但是其实是由浏览器解释才呈现出来的，实质它是一段HTML代码，加 JS、CSS，如果把网页比作一个人，那么HTML便是他的骨架，JS便是他的肌肉，CSS便是它的衣服。所以最重要的部分是存在于HTML中的，如下是个例子来扒一个网页下来。

import urllib2response = urllib2.urlopen("http://www.baidu.com")
print response.read()

2.分析扒网页的方法

那么我们来分析这两行代码，第一行

response = urllib2.urlopen("http://www.baidu.com")

首先我们调用的是urllib2库里面的urlopen方法，传入一个URL，这个网址是百度首页，协议是HTTP协议，当然你也可以把HTTP换做FTP,FILE,HTTPS 等等，只是代表了一种访问控制协议，urlopen一般接受三个参数，它的参数如下：

urlopen(url, data, timeout)

第一个参数url即为URL，第二个参数data是访问URL时要传送的数据，第三个timeout是设置超时时间。

第二三个参数是可以不传送的，data默认为空None，timeout默认为 socket._GLOBAL_DEFAULT_TIMEOUT

第一个参数URL是必须要传送的，在这个例子里面我们传送了百度的URL，执行urlopen方法之后，返回一个response对象，返回信息便保存在这里面。

print response.read()

response对象有一个read方法，可以返回获取到的网页内容。

如果不加read直接打印会是什么？答案如下：

<addinfourl at 139728495260376 whose fp = <socket._fileobject object at 0x7f1513fb3ad0>>

直接打印出了该对象的描述，所以记得一定要加read方法，否则它不出来内容可就不怪我咯！

3.构造Requset

其实上面的urlopen参数可以传入一个request请求,它其实就是一个Request类的实例，构造时需要传入Url,Data等等的内容。比如上面的两行代码，我们可以这么改写

import urllib2 request = urllib2.Request("http://www.baidu.com")response = urllib2.urlopen(request)print response.read()

运行结果是完全一样的，只不过中间多了一个request对象，推荐大家这么写，因为在构建请求时还需要加入好多内容，通过构建一个request，服务器响应请求得到应答，这样显得逻辑上清晰明确。

4.POST和GET数据传送

上面的程序演示了最基本的网页抓取，不过，现在大多数网站都是动态网页，需要你动态地传递参数给它，它做出对应的响应。所以，在访问时，我们需要传递数据给它。最常见的情况是什么？对了，就是登录注册的时候呀。

把数据用户名和密码传送到一个URL，然后你得到服务器处理之后的响应，这个该怎么办？下面让我来为小伙伴们揭晓吧！

数据传送分为POST和GET两种方式，两种方式有什么区别呢？

最重要的区别是GET方式是直接以链接形式访问，链接中包含了所有的参数，当然如果包含了密码的话是一种不安全的选择，不过你可以直观地看到自己提交了什么内容。POST则不会在网址上显示所有的参数，不过如果你想直接查看提交了什么就不太方便了，大家可以酌情选择。

POST方式：

上面我们说了data参数是干嘛的？对了，它就是用在这里的，我们传送的数据就是这个参数data，下面演示一下POST方式。

import urllibimport urllib2values = {"username":"1016903103@qq.com","password":"XXXX"}
data = urllib.urlencode(values)
url = "https://passport.csdn.net/account/login?from=http://my.csdn.net/my/mycsdn"
request = urllib2.Request(url,data)
response = urllib2.urlopen(request)
print response.read()

我们引入了urllib库，现在我们模拟登陆CSDN，当然上述代码可能登陆不进去，因为还要做一些设置头部header的工作，或者还有一些参数没有设置全，还没有提及到在此就不写上去了，在此只是说明登录的原理。我们需要定义一个字典，名字为values，参数我设置了username和 password，下面利用urllib的urlencode方法将字典编码，命名为data，构建request时传入两个参数，url和data，运行程序，即可实现登陆，返回的便是登陆后呈现的页面内容。当然你可以自己搭建一个服务器来测试一下。

注意上面字典的定义方式还有一种，下面的写法是等价的

import urllib
import urllib2values = {}
values['username'] = "1016903103@qq.com"
values['password'] = "XXXX"
data = urllib.urlencode(values)
url = "http://passport.csdn.net/account/login?from=http://my.csdn.net/my/mycsdn"
request = urllib2.Request(url,data)
response = urllib2.urlopen(request)
print response.read()

以上方法便实现了POST方式的传送

GET方式：

至于GET方式我们可以直接把参数写到网址上面，直接构建一个带参数的URL出来即可。

import urllib
import urllib2 values={}
values['username'] = "1016903103@qq.com"
values['password']="XXXX"
data = urllib.urlencode(values)
url = "http://passport.csdn.net/account/login"
geturl = url + "?"+data
request = urllib2.Request(geturl)
response = urllib2.urlopen(request)
print response.read()

你可以print geturl，打印输出一下url，发现其实就是原来的url加？然后加编码后的参数

http://passport.csdn.net/account/login?username=1016903103%40qq.com&password=XXXX

和我们平常GET访问方式一模一样，这样就实现了数据的GET方式传送。

正则表达式（re）

正则表达式是用来简洁表达一组字符串的表达式，

编译：将符合正则表达式语法的字符串转换成正则表达式特征

操作符  说明                            实例
.      表示任何单个字符
[ ]    字符集，对单个字符给出取值范围     [abc]表示a、b、c，[a‐z]表示a到z单个字符
[^ ]   非字符集，对单个字符给出排除范围   [^abc]表示非a或b或c的单个字符
*      前一个字符0次或无限次扩展          abc* 表示ab、abc、abcc、abccc等
+      前一个字符1次或无限次扩展          abc+ 表示abc、abcc、abccc等
?      前一个字符0次或1次扩展             abc? 表示ab、abc
|      左右表达式任意一个                abc|def 表示abc、def
{m}    扩展前一个字符m次                 ab{2}c表示abbc
{m,n}  扩展前一个字符m至n次（含n）        ab{1,2}c表示abc、abbc
^      匹配字符串开头                   ^abc表示abc且在一个字符串的开头
$      匹配字符串结尾                   abc$表示abc且在一个字符串的结尾
( )    分组标记，内部只能使用| 操作符     (abc)表示abc，(abc|def)表示abc、def
\d     数字，等价于[0‐9]
\w     单词字符，等价于[A‐Za‐z0‐9_]123456789101112131415

正则表达式              对应字符串
P(Y|YT|YTH|YTHO)?N    'PN'、'PYN'、'PYTN'、'PYTHN'、'PYTHON'
PYTHON+               'PYTHON'、'PYTHONN'、'PYTHONNN' …
PY[TH]ON              'PYTON'、'PYHON'
PY[^TH]?ON            'PYON'、'PYaON'、'PYbON'、'PYcON'…
PY{:3}N               'PN'、'PYN'、'PYYN'、'PYYYN'…123456

re库的主要功能函数

re库是Python的标准库，主要用于字符串匹配
re库采用raw string类型表示正则表达式，表示为：r’text’，raw string是不包含对转义符再次转义的字符串。

re.search()     在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象
re.match()      从一个字符串的开始位置起匹配正则表达式，返回match对象
re.findall()    搜索字符串，以列表类型返回全部能匹配的子串
re.split()      将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
re.finditer()   搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
re.sub()        在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串123456

re.match

match()函数从字符串的起始位置开始匹配。
如果匹配成功，则返回match对象；否则返回None。
可以用匹配对象的group()方法来显示成功匹配的对象。
语法：

re.match(pattern, string, flags=0)1

pattern : 正则表达式的字符串或原生字符串表示
string : 待匹配字符串
flags : 正则表达式使用时的控制标记

>>> import re
>>> m = re.match('hello','helloworld')
>>> m.group()
'hello'1234

为了保险起见，可以这样写：

>>> import re
>>> m = re.match('hello','helloworld')
>>> if m is not None:  # if match:m.group()
'hello'12345

也可以充分利用Python的面向对象特性，间接省略中间结果：

>>> import re
>>> re.match('hello','helloworld').group()
'hello'123

但match()函数从字符串的起始位置开始匹配，下面这种情况匹配不到初学者想要的结果：

>>> import re
>>> m = re.match(r'[1-9]\d{5}', 'BIT 100081')
>>> m.group
Traceback (most recent call last):File "<pyshell#16>", line 1, in <module>m.group
AttributeError: 'NoneType' object has no attribute 'group'1234567

这可如何是好，且看下一节的search()函数。

re.search

语法：

re.search(pattern, string, flags=0)1

在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象
参数：
- pattern : 正则表达式的字符串或原生字符串表示
- string : 待匹配字符串
- flags : 正则表达式使用时的控制标记

re.search的常用标记

常用标记	说明
re.I re.IGNORECASE	忽略正则表达式的大小写，[A‐Z]能够匹配小写字符
re.M re.MULTILINE	正则表达式中的^操作符能够将给定字符串的每行当作匹配开始
re.S re.DOTALL	正则表达式中的.操作符能够匹配所有字符，默认匹配除换行外的所有字符

>>> import re
>>> m = re.search(r'[1-9]\d{5}', 'BIT 100081')
>>> m.group
'100081'1234

re.findall()

findall()函数用来搜索字符串，以列表类型返回全部能匹配的子串。

re.findall(pattern, string, flags=0)1

输入参数：
- pattern : 正则表达式的字符串或原生字符串表示
- string : 待匹配字符串
- flags : 正则表达式使用时的控制标记

>>> import re
>>> ls = re.findall(r'[1-9]\d{5}', 'BIT100081 TSU100084')
>>> ls
['100081', '100084']1234

re.split()

将一个字符串按照正则表达式匹配结果进行分割，返回列表类型。

语法：

re.split(pattern, string, maxsplit=0, flags=0)1

输入参数：
- pattern : 正则表达式的字符串或原生字符串表示
- string : 待匹配字符串
- maxsplit: 最大分割数，剩余部分作为最后一个元素输出
- flags : 正则表达式使用时的控制标记

>>> import re
>>> re.split(r'[1-9]\d{5}', 'BIT100081 TSU100084')
['BIT', ' TSU', '']
>>> re.split(r'[1-9]\d{5}', 'BIT100081 TSU100084', maxsplit=1)
['BIT', ' TSU100084']
>>> re.split(r'[1-9]\d{5}', 'BIT100081 TSU100084', maxsplit=2)
['BIT', ' TSU', '']
>>> re.split(r'[1-9]\d{5}', 'BIT100081 TSU100084', maxsplit=3)
['BIT', ' TSU', '']123456789

finditer()

搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
语法：

re.finditer(pattern, string, flags=0)1

pattern : 正则表达式的字符串或原生字符串表示
string : 待匹配字符串
flags : 正则表达式使用时的控制标记

>>> import re
>>> for m in re.finditer(r'[1-9]\d{5}', 'BIT100081 TSU100084'):if m:print(m.group(0))100081
1000841234567

sub()

在一个字符串中替换所有匹配正则表达式的子串, 返回替换后的字符串.
语法：

re.sub(pattern, repl, string, count=0, flags=0)1

输入参数:
- pattern : 正则表达式的字符串或原生字符串表示
- repl : 替换匹配字符串的字符串
- string : 待匹配字符串
- count : 匹配的最大替换次数
- flags : 正则表达式使用时的控制标记

>>> import re
>>> re.sub(r'[1-9]\d{5}', ':zipcode', 'BIT100081 TSU100084')
'BIT:zipcode TSU:zipcode'123

compile()

将正则表达式的字符串形式编译成正则表达式对象
语法：

regex = re.compile(pattern, flags=0)1

输入参数：
- pattern : 正则表达式的字符串或原生字符串表示
- flags : 正则表达式使用时的控制标记

re库的另一种等价用法

函数式用法：一次性操作

>>> m = re.search(r'[1-9]\d{5}', 'BIT 100081')1

面向对象用法：编译后的多次操作

>>> regex = re.compile(r'[1-9]\d{5}')
>>> rst = regex.search('BIT 100081')12

re库的match对象

Match对象是一次匹配的结果，包含匹配的很多信息

match对象的属性

属性       说明
.string   待匹配的文本
.re       匹配时使用的patter对象（正则表达式）
.pos      正则表达式搜索文本的开始位置
.endpos   正则表达式搜索文本的结束位置12345

match对象的方法

方法        说明
.group(0)  获得匹配后的字符串
.start()   匹配字符串在原始字符串的开始位置
.end()     匹配字符串在原始字符串的结束位置
.span()    返回(.start(), .end())12345

re库的贪婪匹配和最小匹配

贪婪匹配

Re库默认采用贪婪匹配，即输出匹配最长的子串

>>> match = re.search(r'PY.*N', 'PYANBNCNDN')
>>> match.group(0)
'PYANBNCNDN'123

最小匹配

操作符   说明
*?      前一个字符0次或无限次扩展，最小匹配
+?      前一个字符1次或无限次扩展，最小匹配
??      前一个字符0次或1次扩展，最小匹配
{m,n}?  扩展前一个字符m至n次（含n），最小

BeautifulSoup的使用

简单来说，Beautiful Soup是python的一个库，最主要的功能是从网页抓取数据。官方解释如下：

Beautiful Soup提供一些简单的、python式的函数用来处理导航、搜索、修改分析树等功能。它是一个工具箱，通过解析文档为用户提供需要抓取的数据，因为简单，所以不需要多少代码就可以写出一个完整的应用程序。

Beautiful Soup自动将输入文档转换为Unicode编码，输出文档转换为utf-8编码。你不需要考虑编码方式，除非文档没有指定一个编码方式，这时，Beautiful Soup就不能自动识别编码方式了。然后，你仅仅需要说明一下原始编码方式就可以了。

Beautiful Soup已成为和lxml、html6lib一样出色的python解释器，为用户灵活地提供不同的解析策略或强劲的速度。

安装bs4即可

创建对象

导入库：

from bs4 import BeautifulSoup

创建实例：

url='http://www.baidu.com'
resp=urllib2.urlopen(url)
html=resp.read()

创建对象：

bs=BeautifulSoup(html)

格式化输出内容：

print bs.prettify()

对象种类

BeautifulSoup将复杂的html文档转换为树形结构，每一个节点都是一个对象，这些对象可以归纳为几种：

（1）Tag

Tag相当于html种的一个标签：

#提取Tag
print bs.title
print type(bs.title)

结果：

<title>百度一下，你就知道</title>
<class 'bs4.element.Tag'>

对于Tag，有几个重要的属性：

name:每个Tag对象的name就是标签本省的名称；
attrs:每个Tag对象的attrs就是一个字典，包含了标签的全部属性。

print bs.a.name
print bs.a.attrs

输出：

a
{u'href': u'/', u'id': u'result_logo', u'onmousedown': u"return c({'fm':'tab','tab':'logo'})"}

（2）NavigableString

Comment是一种特殊的NavigableString，对应的是注释的内容，但是其输出不包含注释符。看这样的一个例子：

#coding:utf-8from bs4 import BeautifulSouphtml='''
<a class="css" href="http://example.com/test" id="test"><!--test --></a>
'''
bs=BeautifulSoup(html,"html.parser")
print bs.a
print bs.a.string

运行结果：

<a class="css" href="http://example.com/test" id="test"><!--def --></a>

a标签的内容是注释，但是使用.string仍然输出了。这种情况下，我们需要做下判断：

#判断是否是注释
if type(bs.a.string)==element.Comment:print bs.a.string

再看下面的例子：

<a class="css1" href="http://example.com/cdd" id="css">abc<!--def -->gh</a>

内容是注释和字符串混合，此时可以用contents获取全部对象：

for i in bs.a.contents:print i

如果需要忽略注释内容的话，可以利用get_text()或者.text：

print bs.a.get_text()

如果想在BeautifulSoup之外使用 NavigableString 对象，需要调用unicode()方法，将该对象转换成普通的Unicode字符串，否则就算BeautifulSoup已方法已经执行结束，该对象的输出也会带有对象的引用地址，这样会浪费内存。

搜索文档树

重点介绍下find_all()方法：

find_all( name , attrs , recursive , text , **kwargs )

（1）name参数

name参数可以查找所有名字为name的Tag，字符串对象自动忽略掉。

print bs.find_all('a')

传列表：

print bs.find_all(['a','b'])

传入正则表达式：

print bs.find_all(re.compile('^b'))

所有以b开头的标签对象都会被找到。
传递方法：

def has_class_but_not_id(tag):return tag.has_attr('class') and not tag.has_attr('id')
print bs.find_all(has_class_but_not_id)

（2）kwyowrds关键字

print bs.find_all(id='css')
print bs.find_all(id=re.compile('^a'))

还可以混合使用：

print bs.find_all(id='css',href=re.compile('^ex'))

可以使用class作为过滤，但是class是Python中的关键字，可以使用class_代替，或者采用字典的形式传输参数：

print bs.find_all(class_='css')
print bs.find_all(attrs={'class':'css'})

（3）text参数

用来搜索文档中的字符串内容，text参数也接收字符串、正则表达式、列表、True等参数。

print bs.find_all(text=re.compile('^abc'))

（4）limit参数

限制返回对象的个数，与数据库SQL查询类似。

（5）recursive参数

调用tag的find_all()方法时，BeautifulSoup会检索当前tag的所有子孙节点，如果只想搜索tag的直接子节点，可以使用参数 recursive=False。

CSS选择器

可以采用CSS的语法格式来筛选元素：

#标签选择器
print bs.select('a')
#类名选择器
print bs.select('.css')
#id选择器
print bs.select('#css')
#属性选择器
print bs.select('a[class="css"]')
#遍历
for tag in bs.select('a'):print tag.get_text()

对于喜欢用CSS语法的人来说，这种方式非常方便。如果你仅仅需要CSS选择器的功能，那么直接使用 lxml 也可以，而且速度更快，支持更多的CSS选择器语法，但Beautiful Soup整合了CSS选择器的语法和自身方便使用API。