要学爬虫，你总得学会数据的提取，所以这波我就研究下如何提取数据。

xpath-一个超级好用的东东

什么是XPath？

xpath（XML Path Language）是一门在XML和HTML文档中查找信息的语言，可用来在XML和HTML文档中对元素和属性进行遍历。一般用chrome或火狐来开发。

XPath语法

选取节点：

XPath 使用路径表达式来选取 XML 文档中的节点或者节点集。这些路径表达式和我们在常规的电脑文件系统中看到的表达式非常相似。

表达式 描述 示例 结果
nodename 选取此节点的所有子节点 bookstore 选取bookstore下所有的子节点
/ 如果是在最前面，代表从根节点选取。否则选择某节点下的某个节点 /bookstore 选取根元素下所有的bookstore节点
// 从全局节点中选择节点，随便在哪个位置 //book 从全局节点中找到所有的book节点
@ 选取某个节点的属性 //book[@price] 选择所有拥有price属性的book节点
. 当前节点 ./a 选取当前节点下的a标签

谓语：

谓语用来查找某个特定的节点或者包含某个指定的值的节点，被嵌在方括号中。
在下面的表格中，我们列出了带有谓语的一些路径表达式，以及表达式的结果：

路径表达式 描述
/bookstore/book[1] 选取bookstore下的第一个子元素
/bookstore/book[last()] 选取bookstore下的倒数第二个book元素。
bookstore/book[position()<3] 选取bookstore下前面两个子元素。
//book[@price] 选取拥有price属性的book元素
//book[@price=10] 选取所有属性price等于10的book元素

通配符

*表示通配符。

通配符 描述 示例 结果
* 匹配任意节点 /bookstore/* 选取bookstore下的所有子元素。
@* 匹配节点中的任何属性 //book[@*] 选取所有带有属性的book元素。

选取多个路径：

通过在路径表达式中使用“|”运算符，可以选取若干个路径。
示例如下：

  1. //bookstore/book | //book/title
  2. # 选取所有book元素以及book元素下所有的title元素

lxml库

lxml 是 一个HTML/XML的解析器，主要的功能是如何解析和提取 HTML/XML 数据。
lxml和正则一样，也是用 C 实现的，是一款高性能的 Python HTML/XML 解析器，我们可以利用之前学习的XPath语法，来快速的定位特定元素以及节点信息。
lxml python 官方文档：http://lxml.de/index.html
需要安装C语言库，可使用 pip 安装：pip install lxml

基本使用：

我们可以利用他来解析HTML代码，并且在解析HTML代码的时候，如果HTML代码不规范，他会自动的进行补全。示例代码如下：

  1. # 使用 lxml 的 etree 库
  2. from lxml import etree 
  3. text = '''
  4. <div>
  5.     <ul>
  6.          <li class="item-0"><a href="link1.html">first item</a></li>
  7.          <li class="item-1"><a href="link2.html">second item</a></li>
  8.          <li class="item-inactive"><a href="link3.html">third item</a></li>
  9.          <li class="item-1"><a href="link4.html">fourth item</a></li>
  10.          <li class="item-0"><a href="link5.html">fifth item</a> # 注意，此处缺少一个 </li> 闭合标签
  11.      </ul>
  12.  </div>
  13. '''
  14. #利用etree.HTML，将字符串解析为HTML文档
  15. html = etree.HTML(text) 
  16. # 按字符串序列化HTML文档
  17. result = etree.tostring(html) 
  18. print(result)

输入结果如下：

  1. <html><body>
  2. <div>
  3.     <ul>
  4.          <li class="item-0"><a href="link1.html">first item</a></li>
  5.          <li class="item-1"><a href="link2.html">second item</a></li>
  6.          <li class="item-inactive"><a href="link3.html">third item</a></li>
  7.          <li class="item-1"><a href="link4.html">fourth item</a></li>
  8.          <li class="item-0"><a href="link5.html">fifth item</a></li>
  9. </ul>
  10.  </div>
  11. </body></html>

可以看到。lxml会自动修改HTML代码。例子中不仅补全了li标签，还添加了body，html标签。

从文件中读取html代码：

除了直接使用字符串进行解析，lxml还支持从文件中读取内容。我们新建一个hello.html文件：

  1. <!-- hello.html -->
  2. <div>
  3.     <ul>
  4.          <li class="item-0"><a href="link1.html">first item</a></li>
  5.          <li class="item-1"><a href="link2.html">second item</a></li>
  6.          <li class="item-inactive"><a href="link3.html"><span class="bold">third item</span></a></li>
  7.          <li class="item-1"><a href="link4.html">fourth item</a></li>
  8.          <li class="item-0"><a href="link5.html">fifth item</a></li>
  9.      </ul>
  10.  </div>

然后利用etree.parse()方法来读取文件。示例代码如下：

  1. from lxml import etree
  2. # 读取外部文件 hello.html
  3. html = etree.parse('hello.html')
  4. result = etree.tostring(html, pretty_print=True)
  5. print(result)

输出结果和之前是相同的。

在lxml中使用XPath语法：

  1. 获取所有li标签：

    1. from lxml import etree
    2. html = etree.parse('hello.html')
    3. print type(html)  # 显示etree.parse() 返回类型
    4. result = html.xpath('//li')
    5. print(result)  # 打印<li>标签的元素集合

  2. 获取所有li元素下的所有class属性的值：

    1. from lxml import etree
    2. html = etree.parse('hello.html')
    3. result = html.xpath('//li/@class')
    4. print(result)

  3. 获取li标签下href为www.baidu.com的a标签：

    1. from lxml import etree
    2. html = etree.parse('hello.html')
    3. result = html.xpath('//li/a[@href="www.baidu.com"]')
    4. print(result)

  4. 获取li标签下所有span标签：

    1. from lxml import etree
    2. html = etree.parse('hello.html')
    3. #result = html.xpath('//li/span')
    4. #注意这么写是不对的：
    5. #因为 / 是用来获取子元素的，而 <span> 并不是 <li> 的子元素，所以，要用双斜杠
    6. result = html.xpath('//li//span')
    7. print(result)

  5. 获取li标签下的a标签里的所有class：

    1. from lxml import etree
    2. html = etree.parse('hello.html')
    3. result = html.xpath('//li/a//@class')
    4. print(result)

  6. 获取最后一个li的a的href属性对应的值：

    1. from lxml import etree
    2. html = etree.parse('hello.html')
    3. result = html.xpath('//li[last()]/a/@href')
    4. # 谓语 [last()] 可以找到最后一个元素
    5. print(result)

  7. 获取倒数第二个li元素的内容：

    1. from lxml import etree
    2. html = etree.parse('hello.html')
    3. result = html.xpath('//li[last()-1]/a')
    4. # text 方法可以获取元素内容
    5. print(result[0].text)

  8. 获取倒数第二个li元素的内容的第二种方式：

    1. from lxml import etree
    2. html = etree.parse('hello.html')
    3. result = html.xpath('//li[last()-1]/a/text()')
    4. print(result)

  9. 还有一点也很重要模糊匹配

  1. details_url = html.xpath("//tbody[contains(@id,'normalthread')]/tr/th/a[2]/@href")

这里用了模糊匹配，可以做到匹配到相相应的包含标签

使用requests和xpath爬取电影天堂

示例代码如下：

  1. import requests
  2. from lxml import etree
  3. BASE_DOMAIN = 'http://www.dytt8.net'
  4. HEADERS = {
  5.     'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.100 Safari/537.36',
  6.     'Referer': 'http://www.dytt8.net/html/gndy/dyzz/list_23_2.html'
  7. }
  8. def spider():
  9.     url = 'http://www.dytt8.net/html/gndy/dyzz/list_23_1.html'
  10.     resp = requests.get(url,headers=HEADERS)
  11.     # resp.content：经过编码后的字符串
  12.     # resp.text：没有经过编码，也就是unicode字符串
  13.     # text：相当于是网页中的源代码了
  14.     text = resp.content.decode('gbk')
  15.     # tree：经过lxml解析后的一个对象，以后使用这个对象的xpath方法，就可以
  16.     # 提取一些想要的数据了
  17.     tree = etree.HTML(text)
  18.     # xpath/beautifulsou4
  19.     all_a = tree.xpath("//div[@class='co_content8']//a")
  20.     for a in all_a:
  21.         title = a.xpath("text()")[0]
  22.         href = a.xpath("@href")[0]
  23.         if href.startswith('/'):
  24.             detail_url = BASE_DOMAIN + href
  25.             crawl_detail(detail_url)
  26.             break
  27. def crawl_detail(url):
  28.     resp = requests.get(url,headers=HEADERS)
  29.     text = resp.content.decode('gbk')
  30.     tree = etree.HTML(text)
  31.     create_time = tree.xpath("//div[@class='co_content8']/ul/text()")[0].strip()
  32.     imgs = tree.xpath("//div[@id='Zoom']//img/@src")
  33.     # 电影海报
  34.     cover = imgs[0]
  35.     # 电影截图
  36.     screenshoot = imgs[1]
  37.     # 获取span标签下所有的文本
  38.     infos = tree.xpath("//div[@id='Zoom']//text()")
  39.     for index,info in enumerate(infos):
  40.         if info.startswith("◎年　　代"):
  41.             year = info.replace("◎年　　代","").strip()
  42.         if info.startswith("◎豆瓣评分"):
  43.             douban_rating = info.replace("◎豆瓣评分",'').strip()
  44.             print(douban_rating)
  45.         if info.startswith("◎主　　演"):
  46.             # 从当前位置，一直往下面遍历
  47.             actors = [info]
  48.             for x in range(index+1,len(infos)):
  49.                 actor = infos[x]
  50.                 if actor.startswith("◎"):
  51.                     break
  52.                 actors.append(actor.strip())
  53.             print(",".join(actors))
  54. if __name__ == '__main__':
  55.     spider()

很cool的爬取了dytt的好看的电影，其实吧，上面的代码写麻烦了，年代那些，以为返回的是一个列表，直接找到相应的列表的索引就可以的了，没必要startswiths啥的有点麻烦。这个爬虫可以改成其他爬取一些不含ajax的或者反爬虫的一些简单的网站，一些你懂的网站。所以，还是很有用的，稍微改一下就行。

beautifulsoap—不太喜欢的索引方法（个人喜好）

BeautifulSoup4库

和 lxml 一样，Beautiful Soup 也是一个HTML/XML的解析器，主要的功能也是如何解析和提取 HTML/XML 数据。
lxml 只会局部遍历，而Beautiful Soup 是基于HTML DOM（Document Object Model）的，会载入整个文档，解析整个DOM树，因此时间和内存开销都会大很多，所以性能要低于lxml。BeautifulSoup 用来解析 HTML 比较简单，API非常人性化，支持CSS选择器、Python标准库中的HTML解析器，也支持 lxml 的 XML解析器。

安装和文档：

  1. 安装：pip install bs4。
  2. 中文文档：https://www.crummy.com/software/BeautifulSoup/bs4/doc/index.zh.html

    几大解析工具对比：

    | 解析工具 | 解析速度 | 使用难度 | | —- | —- | —- | | BeautifulSoup | 最慢 | 最简单 | | lxml | 快 | 简单 | | 正则 | 最快 | 最难 |

简单使用：

  1. from bs4 import BeautifulSoup
  2. html = """
  3. <html><head><title>The Dormouse's story</title></head>
  4. <body>
  5. <p class="title" name="dromouse"><b>The Dormouse's story</b></p>
  6. <p class="story">Once upon a time there were three little sisters; and their names were
  7. <a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>,
  8. <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
  9. <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
  10. and they lived at the bottom of a well.</p>
  11. <p class="story">...</p>
  12. """
  13. #创建 Beautiful Soup 对象
  14. # 使用lxml来进行解析
  15. soup = BeautifulSoup(html,"lxml")
  16. print(soup.prettify())

四个常用的对象：

Beautiful Soup将复杂HTML文档转换成一个复杂的树形结构,每个节点都是Python对象,所有对象可以归纳为4种:

  1. Tag
  2. NavigatableString
  3. BeautifulSoup
  4. Comment

    1. Tag：

    Tag 通俗点讲就是 HTML 中的一个个标签。示例代码如下：
    1. from bs4 import BeautifulSoup
    2. html = """
    3. <html><head><title>The Dormouse's story</title></head>
    4. <body>
    5. <p class="title" name="dromouse"><b>The Dormouse's story</b></p>
    6. <p class="story">Once upon a time there were three little sisters; and their names were
    7. <a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>,
    8. <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
    9. <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
    10. and they lived at the bottom of a well.</p>
    11. <p class="story">...</p>
    12. """
    13. #创建 Beautiful Soup 对象
    14. soup = BeautifulSoup(html,'lxml')
    15. print soup.title
    16. # <title>The Dormouse's story</title>
    17. print soup.head
    18. # <head><title>The Dormouse's story</title></head>
    19. print soup.a
    20. # <a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>
    21. print soup.p
    22. # <p class="title" name="dromouse"><b>The Dormouse's story</b></p>
    23. print type(soup.p)
    24. # <class 'bs4.element.Tag'>
    我们可以利用 soup 加标签名轻松地获取这些标签的内容，这些对象的类型是bs4.element.Tag。但是注意，它查找的是在所有内容中的第一个符合要求的标签。如果要查询所有的标签，后面会进行介绍。
    对于Tag，它有两个重要的属性，分别是name和attrs。示例代码如下：
    1. print soup.name
    2. # [document] #soup 对象本身比较特殊，它的 name 即为 [document]
    3. print soup.head.name
    4. # head #对于其他内部标签，输出的值便为标签本身的名称
    5. print soup.p.attrs
    6. # {'class': ['title'], 'name': 'dromouse'}
    7. # 在这里，我们把 p 标签的所有属性打印输出了出来，得到的类型是一个字典。
    8. print soup.p['class'] # soup.p.get('class')
    9. # ['title'] #还可以利用get方法，传入属性的名称，二者是等价的
    10. soup.p['class'] = "newClass"
    11. print soup.p # 可以对这些属性和内容等等进行修改
    12. # <p class="newClass" name="dromouse"><b>The Dormouse's story</b></p>

    2. NavigableString：

    如果拿到标签后，还想获取标签中的内容。那么可以通过tag.string获取标签中的文字。示例代码如下：
    1. print soup.p.string
    2. # The Dormouse's story
    3. print type(soup.p.string)
    4. # <class 'bs4.element.NavigableString'>thon

    3. BeautifulSoup：

    BeautifulSoup 对象表示的是一个文档的全部内容.大部分时候,可以把它当作 Tag 对象,它支持 遍历文档树 和 搜索文档树 中描述的大部分的方法.
    因为 BeautifulSoup 对象并不是真正的HTML或XML的tag,所以它没有name和attribute属性.但有时查看它的 .name 属性是很方便的,所以 BeautifulSoup 对象包含了一个值为 “[document]” 的特殊属性 .name
    1. soup.name
    2. # '[document]'

    4. Comment：

    Tag , NavigableString , BeautifulSoup 几乎覆盖了html和xml中的所有内容,但是还有一些特殊对象.容易让人担心的内容是文档的注释部分:
    1. markup = "<b><!--Hey, buddy. Want to buy a used parser?--></b>"
    2. soup = BeautifulSoup(markup)
    3. comment = soup.b.string
    4. type(comment)
    5. # <class 'bs4.element.Comment'>
    Comment 对象是一个特殊类型的 NavigableString 对象:
    1. comment
    2. # 'Hey, buddy. Want to buy a used parser'

    遍历文档树：

    1. contents和children：

    1. html_doc = """
    2. <html><head><title>The Dormouse's story</title></head>
    3. <p class="title"><b>The Dormouse's story</b></p>
    4. <p class="story">Once upon a time there were three little sisters; and their names were
    5. <a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
    6. <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
    7. <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
    8. and they lived at the bottom of a well.</p>
    9. <p class="story">...</p>
    10. """
    11. from bs4 import BeautifulSoup
    12. soup = BeautifulSoup(html_doc,'lxml')
    13. head_tag = soup.head
    14. # 返回所有子节点的列表
    15. print(head_tag.contents)
    16. # 返回所有子节点的迭代器
    17. for child in head_tag.children:
    18.  print(child)

    2. strings 和 stripped_strings

    如果tag中包含多个字符串 [2] ,可以使用 .strings 来循环获取：
    1. for string in soup.strings:
    2.  print(repr(string))
    3.  # u"The Dormouse's story"
    4.  # u'\n\n'
    5.  # u"The Dormouse's story"
    6.  # u'\n\n'
    7.  # u'Once upon a time there were three little sisters; and their names were\n'
    8.  # u'Elsie'
    9.  # u',\n'
    10.  # u'Lacie'
    11.  # u' and\n'
    12.  # u'Tillie'
    13.  # u';\nand they lived at the bottom of a well.'
    14.  # u'\n\n'
    15.  # u'...'
    16.  # u'\n'
    输出的字符串中可能包含了很多空格或空行,使用 .stripped_strings 可以去除多余空白内容：
    1. for string in soup.stripped_strings:
    2.  print(repr(string))
    3.  # u"The Dormouse's story"
    4.  # u"The Dormouse's story"
    5.  # u'Once upon a time there were three little sisters; and their names were'
    6.  # u'Elsie'
    7.  # u','
    8.  # u'Lacie'
    9.  # u'and'
    10.  # u'Tillie'
    11.  # u';\nand they lived at the bottom of a well.'
    12.  # u'...'

    搜索文档树：

    1. find和find_all方法：

    搜索文档树，一般用得比较多的就是两个方法，一个是find，一个是find_all。find方法是找到第一个满足条件的标签后就立即返回，只返回一个元素。find_all方法是把所有满足条件的标签都选到，然后返回回去。使用这两个方法，最常用的用法是出入name以及attr参数找出符合要求的标签。
    1. soup.find_all("a",attrs={"id":"link2"})
    或者是直接传入属性的的名字作为关键字参数：
    1. soup.find_all("a",id='link2')

    2. select方法：

    使用以上方法可以方便的找出元素。但有时候使用css选择器的方式可以更加的方便。使用css选择器的语法，应该使用select方法。以下列出几种常用的css选择器方法：

    （1）通过标签名查找：

    1. print(soup.select('a'))

    （2）通过类名查找：

    通过类名，则应该在类的前面加一个.。比如要查找class=sister的标签。示例代码如下：
    1. print(soup.select('.sister'))

    （3）通过id查找：

    通过id查找，应该在id的名字前面加一个＃号。示例代码如下：
    1. print(soup.select("#link1"))

    （4）组合查找：

    组合查找即和写 class 文件时，标签名与类名、id名进行的组合原理是一样的，例如查找 p 标签中，id 等于 link1的内容，二者需要用空格分开：
    1. print(soup.select("p #link1"))
    直接子标签查找，则使用 > 分隔：
    1. print(soup.select("head > title"))

    （5）通过属性查找：

    查找时还可以加入属性元素，属性需要用中括号括起来，注意属性和标签属于同一节点，所以中间不能加空格，否则会无法匹配到。示例代码如下：
    1. print(soup.select('a[href="http://example.com/elsie"]'))

    （6）获取内容

    以上的 select 方法返回的结果都是列表形式，可以遍历形式输出，然后用 get_text() 方法来获取它的内容。
    1. soup = BeautifulSoup(html, 'lxml')
    2. print type(soup.select('title'))
    3. print soup.select('title')[0].get_text()
    4. for title in soup.select('title'):
    5.  print title.get_text()
    确实感觉没有xpath好，先存着，以后想看可以看下。