Python爬虫知识点总结（详解）

目录

一.什么是Python爬虫

二.HTML文件格式

2.1 HTML格式的基本结构

2.2 HTML标签

2.2.1 HTML基本标签

2.2.1.1 HTML标签

2.2.1.2 head标签

2.2.2 段落与文字

2.2.2.1 段落与文字标签 

​2.2.2.2 文字格式化标签

2.2.3 列表

2.2.4 链接

2.2.5 图片

2.2.6 表格

2.2.6.1 表格基本标签

2.2.6.2 表格结构标签

2.2.6.3 表格基本结构

2.2.6.4 表格的完整结构

​三.requests库

3.1 request使用

3.1.1 request安装

3.1.2 request响应

3.1.3 request请求

3.1.3.1 get方法

3.1.3.1.1 get方法使用

3.1.3.1.2 get方法中常用参数

3.1.3.2 post方法

3.1.3.2.1 post方法使用

3.1.3.2.2 post方法中常用参数

3.1.3.3 request方法

3.1.3.4 headers方法

四.Re正则表达式

4.1 正则表达式的结构

4.1.1 普通字符

4.1.2 元字符

4.1.3 反义字符

4.1.4 量词

4.1.5 转义字符

4.1.6 字符分枝

4.1.7 字符分组

4.1.8 贪婪匹配和懒惰匹配

4.2 Python使用正则表达式

4.2.1 导入正则表达式模块

4.2.2 常用re模块函数

五.Beautifulsoup

5.1 Beautiful Soup安装

5.1.1 软件包管理安装

5.1.2 pip或easy_install命令安装

5.1.3 安装包安装

5.2 解析器安装

5.2.1 lxml解析器安装

5.2.2 html5lib8解析器安装

5.2.3 主要解析器分析

5.3 Beautiful Soup使用

5.3.1 创建Beautiful Soup对象

5.3.2 对象的种类

5.3.2.1 tag

5.3.2.2 NavigableString 

5.3.2.3 BeautifulSoup 

5.3.2.4 Comment

5.3.3 搜索文档树

5.3.3.1 find_all()

5.3.3.2 find

5.3.3.3 find_parents() 和 find_parent()

5.3.3.4 find_next_siblings() 和 find_next_sibling()

5.3.3.5 find_previous_siblings() 和 find_previous_sibling()

5.3.3.6 find_all_next() 和 find_next()

5.3.3.7 find_all_previous() 和 find_previous()

六.Xpath

6.1 XPath解析原理

6.2 实例化etree的对象

6.3 节点

6.3.1 父节点

6.3.2 子节点

6.3.3 兄弟节点

6.4 XPath的规则

6.4.1 选取节点

6.4.2 谓语

6.4.3 选取未知节点

6.4.4 选取若干路径

七.异步爬虫

7.1 多线程

7.2 多进程

7.3 协程

7.3.1 aiohttp多任务异步协程

八.selenium

8.1 搭建环境

8.1.1 selenium安装

8.1.2 浏览器驱动安装

8.2 selenium 使用

8.2.1 元素定位

8.2.2 元素操作

8.2.3 浏览器操作方法

8.2.4 获取元素信息操作

8.2.5 鼠标操作

8.2.5.1 鼠标右键及双击

8.2.5.2 鼠标拖拽

8.2.5.3 鼠标悬停

8.2.6 键盘操作

8.2.7 窗口切换

8.2.8 截图操作

8.3 超级鹰搞定验证码

8.3.1 简介

8.3.2 使用 

九.scrapy

9.1 Scrapy基本模块

9.1.1 调度器(Scheduler)

9.1.2 下载器(Downloader)

9.1.3 爬虫（Spider） 

9.1.4 实体管道(Item Pipeline)      

9.1.5 Scrapy引擎(Scrapy Engine)

9.1.6 中间件

9.2 Scrapy工作流程

9.3 Scrapy框架安装

9.4 Scrapy的使用 

9.4.1 基本步骤

9.4.2 程序运行

9.4.3 Scrapy文件

---

一.什么是Python爬虫

        Python爬虫是使用Python编程语言编写的程序，用于自动化地获取互联网上的数据。它通过模拟浏览器的行为，发送HTTP请求并获取网页的HTML内容，然后从HTML中提取所需信息，并进行数据处理和存储。

二.HTML文件格式

        Python爬虫可以获取网页的HTML格式内容，并对其进行解析和处理。HTML（Hypertext Markup Language）是一种用于创建网页结构和内容的标记语言。接下来为大家简单的讲解一下HTML文件。

以下是一个简单的HTML文档示例：

    


    
欢迎来到我的网页
    
这是一个示例段落。
    
    点击这里访问示例网站

在上面的例子中：

• ：这是文档类型声明，指定了HTML版本。
• ：这是HTML文档的根元素，它包含整个HTML内容。
• ：这个部分包含有关文档的元信息，例如标题、字符集设置和链接到外部资源等。

• 欢迎使用Beautiful Soup!

  这是一个示例页面。

  • 列表项1
  • 列表项2
  • 列表项3
  """

  创建beautiful soup对象

  方式一：在程序中有html格式的字符串，可在程序中进行创建对象。

  soup = BeautifulSoup(html_doc,'lxml')  #创建 beautifulsoup 对象

  方式二：可用本地文件创建对象。

  soup = BeautifulSoup(open('index.html'))  #用本地 HTML 文件来创建对象

  方法三：利用python内置模块进行创建对象。

  soup = BeautifulSoup(html_doc, 'html.parser')

  5.3.2 对象的种类

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

  

  5.3.2.1 tag

          Tag 对象与XML或HTML原生文档中的tag相同:

  soup = BeautifulSoup('Extremely bold')
  tag = soup.b
  type(tag)
  # 

          Tag有很多方法和属性,在 遍历文档树 和 搜索文档树 中有详细解释.现在介绍一下tag中最重要的属性: name和attributes

  name属性：

          每个tag都有自己的名字,通过 .name 来获取:

  tag.name
  # u'b'

          如果改变了tag的name,那将影响所有通过当前Beautiful Soup对象生成的HTML文档:

  tag.name = "blockquote"
  tag
  # 
  Extremely bold

  attributes属性：

          一个tag可能有很多个属性. tag  有一个 “class” 的属性,值为 “boldest” . tag的属性的操作方法与字典相同:

  tag['class']
  # u'boldest'

          也可以直接”点”取属性, 比如: .attrs :

  tag.attrs
  # {u'class': u'boldest'}

          tag的属性可以被添加,删除或修改. 再说一次, tag的属性操作方法与字典一样

  tag['class'] = 'verybold'
  tag['id'] = 1
  tag
  # 
  Extremely bold
  
  del tag['class']
  del tag['id']
  tag
  # 
  Extremely bold
  
  tag['class']
  # KeyError: 'class'
  print(tag.get('class'))
  # None

  5.3.2.2 NavigableString 

          获得了标签可用xx.string方法来获取标签内的字符串，得到的类型是NavigableString类型。

  tag.string
  # u'Extremely bold'
  type(tag.string)
  # 

          一个 NavigableString 字符串与Python中的Unicode字符串相同,并且还支持包含在 遍历文档树 和 搜索文档树 中的一些特性. 通过 unicode() 方法可以直接将 NavigableString 对象转换成Unicode字符串:

  unicode_string = unicode(tag.string)
  unicode_string
  # u'Extremely bold'
  type(unicode_string)
  # 

          tag中包含的字符串不能编辑,但是可以被替换成其它的字符串,用 replace_with() 方法:

  tag.string.replace_with("No longer bold")
  tag
  # 
  No longer bold

          NavigableString 对象支持 遍历文档树 和 搜索文档树 中定义的大部分属性, 并非全部.尤其是,一个字符串不能包含其它内容(tag能够包含字符串或是其它tag),字符串不支持 .contents 或 .string 属性或 find() 方法.

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

  5.3.2.3 BeautifulSoup 

          BeautifulSoup 对象表示的是一个文档的全部内容.大部分时候,可以把它当作 Tag 对象,它支持 遍历文档树 和 搜索文档树 中描述的大部分的方法.

          因为 BeautifulSoup 对象并不是真正的HTML或XML的tag,所以它没有name和attribute属性.但有时查看它的 .name 属性是很方便的,所以 BeautifulSoup 对象包含了一个值为 “[document]” 的特殊属性 .name

  soup.name
  # u'[document]'

  5.3.2.4 Comment

          Tag , NavigableString , BeautifulSoup 几乎覆盖了html和xml中的所有内容,但是还有一些特殊对象.容易让人担心的内容是文档的注释部分:

  markup = ""
  soup = BeautifulSoup(markup)
  comment = soup.b.string
  type(comment)
  # 

          Comment 对象是一个特殊类型的 NavigableString 对象:

  comment
  # u'Hey, buddy. Want to buy a used parser'

          但是当它出现在HTML文档中时, Comment 对象会使用特殊的格式输出:

  print(soup.b.prettify())
  # 
  #  
  # 

  5.3.3 搜索文档树

  5.3.3.1 find_all()

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

          find_all() 方法搜索当前tag的所有tag子节点,并判断是否符合过滤器的条件.这里有几个例子:

  soup.find_all("title")
  # []
  
  soup.find_all("p", "title")
  # [
  The Dormouse's story
  ]
  
  soup.find_all("a")
  # [Elsie,
  #  Lacie,
  #  Tillie]
  
  soup.find_all(id="link2")
  # [Lacie]
  
  import re
  soup.find(text=re.compile("sisters"))
  # u'Once upon a time there were three little sisters; and their names were\n'

          有几个方法很相似,还有几个方法是新的,参数中的 text 和 id 是什么含义? 为什么 find_all("p", "title") 返回的是CSS Class为”title”的

  标签? 我们来仔细看一下 find_all() 的参数

  • name参数

          name 参数可以查找所有名字为 name 的tag,字符串对象会被自动忽略掉.

  简单的用法如下:

  soup.find_all("title")
  # []

          重申: 搜索 name 参数的值可以使任一类型的 过滤器 ,字符窜,正则表达式,列表,方法或是 True .

  • keyword参数

          如果一个指定名字的参数不是搜索内置的参数名,搜索时会把该参数当作指定名字tag的属性来搜索,如果包含一个名字为 id 的参数,Beautiful Soup会搜索每个tag的”id”属性.

  soup.find_all(id='link2')
  # [Lacie]

          如果传入 href 参数,Beautiful Soup会搜索每个tag的”href”属性:

  soup.find_all(href=re.compile("elsie"))
  # [Elsie]

          搜索指定名字的属性时可以使用的参数值包括 字符串 , 正则表达式 , 列表, True .

          下面的例子在文档树中查找所有包含 id 属性的tag,无论 id 的值是什么:

  soup.find_all(id=True)
  # [Elsie,
  #  Lacie,
  #  Tillie]

          使用多个指定名字的参数可以同时过滤tag的多个属性:

  soup.find_all(href=re.compile("elsie"), id='link1')
  # [three]

          有些tag属性在搜索不能使用,比如HTML5中的 data-* 属性:

  data_soup = BeautifulSoup('
  foo!
  ')
  data_soup.find_all(data-foo="value")
  # SyntaxError: keyword can't be an expression

          但是可以通过 find_all() 方法的 attrs 参数定义一个字典参数来搜索包含特殊属性的tag:

  data_soup.find_all(attrs={"data-foo": "value"})
  # [
  foo!
  ]

  • 按CSS搜索

          按照CSS类名搜索tag的功能非常实用,但标识CSS类名的关键字 class 在Python中是保留字,使用 class 做参数会导致语法错误.从Beautiful Soup的4.1.1版本开始,可以通过 class_ 参数搜索有指定CSS类名的tag:

  soup.find_all("a", class_="sister")
  # [Elsie,
  #  Lacie,
  #  Tillie]

          class_ 参数同样接受不同类型的 过滤器 ,字符串,正则表达式,方法或 True :

  soup.find_all(class_=re.compile("itl"))
  # [
  The Dormouse's story
  ]
  
  def has_six_characters(css_class):
      return css_class is not None and len(css_class) == 6
  
  soup.find_all(class_=has_six_characters)
  # [Elsie,
  #  Lacie,
  #  Tillie]

          tag的 class 属性是 多值属性 .按照CSS类名搜索tag时,可以分别搜索tag中的每个CSS类名:

  css_soup = BeautifulSoup('
  ')
  css_soup.find_all("p", class_="strikeout")
  # [
  ]
  
  css_soup.find_all("p", class_="body")
  # [
  ]

          搜索 class 属性时也可以通过CSS值完全匹配:

  css_soup.find_all("p", class_="body strikeout")
  # [
  ]

          完全匹配 class 的值时,如果CSS类名的顺序与实际不符,将搜索不到结果:

  soup.find_all("a", attrs={"class": "sister"})
  # [Elsie,
  #  Lacie,
  #  Tillie]

  • text参数

          通过 text 参数可以搜搜文档中的字符串内容.与 name 参数的可选值一样, text 参数接受 字符串 , 正则表达式 , 列表, True . 看例子:

  soup.find_all(text="Elsie")
  # [u'Elsie']
  
  soup.find_all(text=["Tillie", "Elsie", "Lacie"])
  # [u'Elsie', u'Lacie', u'Tillie']
  
  soup.find_all(text=re.compile("Dormouse"))
  [u"The Dormouse's story", u"The Dormouse's story"]
  
  def is_the_only_string_within_a_tag(s):
      ""Return True if this string is the only child of its parent tag.""
      return (s == s.parent.string)
  
  soup.find_all(text=is_the_only_string_within_a_tag)
  # [u"The Dormouse's story", u"The Dormouse's story", u'Elsie', u'Lacie', u'Tillie', u'...']

          虽然 text 参数用于搜索字符串,还可以与其它参数混合使用来过滤tag.Beautiful Soup会找到 .string 方法与 text 参数值相符的tag.下面代码用来搜索内容里面包含“Elsie”的标签:

  soup.find_all("a", text="Elsie")
  # [Elsie]

  • limit参数

          find_all() 方法返回全部的搜索结构,如果文档树很大那么搜索会很慢.如果我们不需要全部结果,可以使用 limit 参数限制返回结果的数量.效果与SQL中的limit关键字类似,当搜索到的结果数量达到 limit 的限制时,就停止搜索返回结果.

          文档树中有3个tag符合搜索条件,但结果只返回了2个,因为我们限制了返回数量:

  soup.find_all("a", limit=2)
  # [Elsie,
  #  Lacie]

  • recursive 参数

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

  一段简单的文档:

  
   
    
   
  ...

          是否使用 recursive 参数的搜索结果:

  soup.html.find_all("title")
  # []
  
  soup.html.find_all("title", recursive=False)
  # []

  像调用 find_all() 一样调用tag

          find_all() 几乎是Beautiful Soup中最常用的搜索方法,所以我们定义了它的简写方法. BeautifulSoup 对象和 tag 对象可以被当作一个方法来使用,这个方法的执行结果与调用这个对象的 find_all() 方法相同,下面两行代码是等价的:

  soup.find_all("a")
  soup("a")

          这两行代码也是等价的:

  soup.title.find_all(text=True)
  soup.title(text=True)

  5.3.3.2 find

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

          find_all() 方法将返回文档中符合条件的所有tag,尽管有时候我们只想得到一个结果.比如文档中只有一个标签,那么使用 find_all() 方法来查找标签就不太合适, 使用 find_all 方法并设置 limit=1 参数不如直接使用 find() 方法.下面两行代码是等价的:

  soup.find_all('title', limit=1)
  # []
  
  soup.find('title')
  # 

          唯一的区别是 find_all() 方法的返回结果是值包含一个元素的列表,而 find() 方法直接返回结果.

  find_all() 方法没有找到目标是返回空列表, find() 方法找不到目标时,返回 None .

  print(soup.find("nosuchtag"))
  # None

          soup.head.title 是 tag的名字 方法的简写.这个简写的原理就是多次调用当前tag的 find() 方法:

  soup.head.title
  # 
  
  soup.find("head").find("title")
  # 

  5.3.3.3 find_parents() 和 find_parent()

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

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

          我们已经用了很大篇幅来介绍 find_all() 和 find() 方法,Beautiful Soup中还有10个用于搜索的API.它们中的五个用的是与 find_all() 相同的搜索参数,另外5个与 find() 方法的搜索参数类似.区别仅是它们搜索文档的不同部分.

          记住: find_all() 和 find() 只搜索当前节点的所有子节点,子孙节点等. find_parents() 和 find_parent() 用来搜索当前节点的父辈节点,搜索方法与普通tag的搜索方法相同,搜索文档搜索文档包含的内容. 我们从一个文档中的一个叶子节点开始:

  a_string = soup.find(text="Lacie")
  a_string
  # u'Lacie'
  
  a_string.find_parents("a")
  # [Lacie]
  
  a_string.find_parent("p")
  # 
  Once upon a time there were three little sisters; and their names were
  #  Elsie,
  #  Lacie and
  #  Tillie;
  #  and they lived at the bottom of a well.
  
  a_string.find_parents("p", class_="title")
  # []

          文档中的一个标签是是当前叶子节点的直接父节点,所以可以被找到.还有一个

  标签,是目标叶子节点的间接父辈节点,所以也可以被找到.包含class值为”title”的

  标签不是不是目标叶子节点的父辈节点,所以通过 find_parents() 方法搜索不到.

          find_parent() 和 find_parents() 方法会让人联想到 .parent 和 .parents 属性.它们之间的联系非常紧密.搜索父辈节点的方法实际上就是对 .parents 属性的迭代搜索.

  5.3.3.4 find_next_siblings() 和 find_next_sibling()

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

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

          这2个方法通过 .next_siblings 属性对当tag的所有后面解析 [5] 的兄弟tag节点进行迭代, find_next_siblings() 方法返回所有符合条件的后面的兄弟节点, find_next_sibling() 只返回符合条件的后面的第一个tag节点.

  first_link = soup.a
  first_link
  # Elsie
  
  first_link.find_next_siblings("a")
  # [Lacie,
  #  Tillie]
  
  first_story_paragraph = soup.find("p", "story")
  first_story_paragraph.find_next_sibling("p")
  # 
  ...

  5.3.3.5 find_previous_siblings() 和 find_previous_sibling()

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

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

          这2个方法通过 .previous_siblings 属性对当前tag的前面解析 [5] 的兄弟tag节点进行迭代, find_previous_siblings() 方法返回所有符合条件的前面的兄弟节点, find_previous_sibling() 方法返回第一个符合条件的前面的兄弟节点:

  last_link = soup.find("a", id="link3")
  last_link
  # Tillie
  
  last_link.find_previous_siblings("a")
  # [Lacie,
  #  Elsie]
  
  first_story_paragraph = soup.find("p", "story")
  first_story_paragraph.find_previous_sibling("p")
  # 
  The Dormouse's story

  5.3.3.6 find_all_next() 和 find_next()

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

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

          这2个方法通过 .next_elements 属性对当前tag的之后的 [5] tag和字符串进行迭代, find_all_next() 方法返回所有符合条件的节点, find_next() 方法返回第一个符合条件的节点:

  first_link = soup.a
  first_link
  # Elsie
  
  first_link.find_all_next(text=True)
  # [u'Elsie', u',\n', u'Lacie', u' and\n', u'Tillie',
  #  u';\nand they lived at the bottom of a well.', u'\n\n', u'...', u'\n']
  
  first_link.find_next("p")
  # 
  ...

          第一个例子中,字符串 “Elsie”也被显示出来,尽管它被包含在我们开始查找的标签的里面.第二个例子中,最后一个

  标签也被显示出来,尽管它与我们开始查找位置的标签不属于同一部分.例子中,搜索的重点是要匹配过滤器的条件,并且在文档中出现的顺序而不是开始查找的元素的位置.

  5.3.3.7 find_all_previous() 和 find_previous()

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

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

          这2个方法通过 .previous_elements 属性对当前节点前面 [5] 的tag和字符串进行迭代, find_all_previous() 方法返回所有符合条件的节点, find_previous() 方法返回第一个符合条件的节点.

  first_link = soup.a
  first_link
  # Elsie
  
  first_link.find_all_previous("p")
  # [
  Once upon a time there were three little sisters; ...
  ,
  #  
  The Dormouse's story
  ]
  
  first_link.find_previous("title")
  # 

          find_all_previous("p") 返回了文档中的第一段(class=”title”的那段),但还返回了第二段,

  标签包含了我们开始查找的标签.不要惊讶,这段代码的功能是查找所有出现在指定标签之前的

  标签,因为这个

  标签包含了开始的标签,所以

  标签一定是在之前出现的.

  六.Xpath

          XPath（XML Path Language）是一种用于在XML文档中定位和选择节点的查询语言。它是一种非常强大的工具，用于在XML文档中进行导航和提取信息。XPath可以用于在XML文档中选择节点、属性和文本，以及根据特定的条件进行过滤和定位。

          XPath使用一种路径表达式来描述节点的位置，类似于文件系统中的路径。路径表达式可以从根节点开始，通过节点名称、属性、层级关系等来定位目标节点。XPath还支持使用逻辑运算符、比较运算符和函数来创建更复杂的查询。

  6.1 XPath解析原理

  1. 实现标签的定位：实例化一个etree的对象，且需要将被解析的页面源码数据加载到该对象中。
  2. 调用etree对象中的xpath方法结合着xpath表达式实现标签的定位和内容的捕获。

  6.2 实例化etree的对象

          要在Python中实例化一个etree对象，通常需要使用第三方库，如lxml。lxml是一个功能强大且高性能的XML和HTML处理库，它提供了etree模块来操作和处理XML文档。以下是在Python中实例化一个etree对象的步骤：

  1. 安装lxml库：
     首先，你需要确保已经安装了lxml库。你可以使用以下命令通过pip安装它：

     pip install lxml
     

  2. 导入模块：
     在Python代码中，你需要导入etree模块：

     from lxml import etree
     

  3. 实例化etree对象

          分为两种方式去实例化etree对象，一种是通过文件路径去找到html文件去实例化，另一种是通过源码数据去实例化。

  • 将本地的html文档中的源码数据加载到etree对象中:

  etree. parse(filePath)#你的文件路径
  

  • 可以将从互联网上获取的源码数据加载到该对象中

  etree.HtML('page_ text')#page_ text互联网中响应的数据

  6.3 节点

  6.3.1 父节点

          在XPath中，父节点（Parent Node）指的是一个元素节点的直接包含它的上层元素节点。换句话说，父节点是包含当前节点的那个元素节点。在XML文档的层级结构中，每个元素节点都可以有一个父节点，除了根节点（顶层节点），它没有父节点。

          使用之前的XML片段作为例子：

  
     
        
        J.K. Rowling
     
     
        
        J.R.R. Tolkien
     
  
  

  在这个示例中：

  •  元素节点的父节点是  元素节点。
  • J.K. Rowling J.R.R. Tolkien

            在这个示例中， 元素节点有两个子节点 。每个  元素节点又有两个子节点  J.K. Rowling J.R.R. Tolkien

    在这个示例中：

    •  元素节点之间互为兄弟节点，因为它们都是  元素节点的子节点。