1. 背景

最近在工作中有需求运用到爬虫的当地，需求依据 Gitlab + Python 完成一套守时爬取数据的工具，所以借此机会，针对 Python 爬虫方面的常识进行了学习，也算 Python 爬虫入门了。
需求了解的常识点：

  • Python 根底语法
  • Python 网络恳求，requests 模块的根本运用
  • BeautifulSoup 库的运用
  • 正则表达式
  • Selenium 的根本运用

下面针对上面的每部分做个简略的介绍。

2. Python 根底语法

学习任何一门编程言语都有必要掌握其语法常识，Python 也不例外。假如有其它变成言语根底，上手 Python 仍是十分快的。

2.1 变量

在 Python 中，界说一个变量的操作分为两步：首要要为变量起一个姓名，称为变量的命名；然后要为变量指定其所代表的数据，称为变量的赋值。这两个步骤在同一行代码中完结。

version = '1'

Python 中的变量命名标准与其它开发言语差不多，根本的规矩如下：

  • 变量名能够由恣意数量的字母、数字、下划线组合而成，可是有必要以字母或下划线最初，不能以数字最初。
  • 不要用 Python 的保留字或内置函数来命名变量。例如，不要用 import 来命名变量，由于它是 Python 的保留字，有特殊的意义。
  • 变量名对英文字母区别大小写。例如，D 和 d 是两个不同的变量。

2.2 数据类型

Python 中有 6 种根本数据类型：数字（Numbers）、字符串（String）、列表（List）、字典（Dictionary）、元组（Tuple）和调集。

2.2.1 数据类型

在 Python 中界说变量后需求及时指明对应的数据类型。同时也能够运用 del 变量名 删去目标引用。

num = 0
pi = 3.14
name = "abc"
# 界说列表 []，列表元素能够修正
list = [12, 2, 212, 44, 5, 6]
dic = {
    "k1": "v1",
    "k2": "v2",
}
# 调集类型用 set 标识, 创建运用 { } 或许 set() 
s1 = {1, 2, 3, 3, 2, 2, 2, 1, "1"}
# 元组用 () 表明，元组的元素不能修正
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
del s1

对于每种数据类型，都有一些常用的办法：

数据类型 办法
字符串
– [ : ]：截取字符串中的一部分（切片），遵从左闭右开准则；
– []：经过索引获取字符串中字符；
– in：假如字符串中包含给定的字符回来 True；
– not in：成员运算符 – 假如字符串中不包含给定的字符回来 True
– capitalize()：将字符串的榜首个字符转换为大写；
– endswith(suffix, beg=0, end=len(string))：检查字符串是否以指定的字符串结束，假如是，回来 True，否则回来 False；
– find(str, beg=0, end=len(string))：检测 str 是否包含在字符串中，假如包含，回来开端的索引值，否则回来-1；
– index(str, beg=0, end=len(string))：跟find()办法一样，只不过假如str不在字符串中会报一个反常；
– len(string)：回来字符串长度；
– replace(old, new [, max])：把将字符串中的 old 替换成 new,假如 max 指定，则替换不超越 max 次；
– rstrip()：删去字符串结束的空格或指定字符；
– split(str=””, num=string.count(str))：以 str 为分隔符截取字符串，假如 num 有指定值，则仅截取 num+1 个子字符串。
列表/元组
– len(list)：列表元素个数；
– list(seq)：将序列（元组，调集等）转换为列表；
– list.append(obj)：在列表结束增加新的目标；
– list.index(obj)：从列表中找出某个值榜首个匹配项的索引方位；
– list.remove(obj)：移除列表中某个值的榜首个匹配项；
– list.clear()：清空列表。
字典
– len(dict)：计算字典元素个数，即键的总数；
– key in dict：假如键在字典dict里回来true，否则回来false；
– radiansdict.items()：以列表回来可遍历的(键, 值) 元组数组；
– radiansdict.keys()：以列表回来一个字典一切的键；
– radiansdict.values()：以列表回来字典中的一切值。

2.2.2 类型转换

字符串类型转换经过 str() 函数能够将一个变量转换为字符串类型。

  • int(x) 将x转换为一个整数。
  • float(x) 将x转换到一个浮点数。
  • complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
  • complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
  • str(x) 将目标 x 转换为字符串。

2.3 根底运算符

在 Python 中运算符根本与其它开发言语一致，常用的运算符有算术运算符、字符串运算符、比较运算符、赋值运算符和逻辑运算符。
算术运算符

Python 爬虫快速入门

比较运算符
Python 爬虫快速入门

逻辑运算符
Python 爬虫快速入门

2.4 操控句子

Python 的操控句子分为条件句子和循环句子，前者为 if 句子，后者为 for 句子和 while 句子。

2.4.1 if 句子

if 句子主要用于条件判断，满足特定条件履行句子。

if 条件:  # 留意不要遗失冒号
    代码1  # 留意代码前要有缩进
else:  # 留意不要遗失冒号
    代码2  # 留意代码前要有缩进

一个简略的示例：

grade = 60
if grade >= 60:
    print("及格")
else:
    print("不及格")

2.4.2 for 循环

for 句子常用于完结指定次数的重复操作

for i in 序列:  # 留意不要遗失冒号
      要重复履行的代码  # 留意代码前要有缩进

简略示例：

numbers = [12, 2, 212, 44, 5, 6]
for item in numbers:
    print(item)

2.4.3 while 句子

while 句子用于在指定条件成立时重复履行操作。

while 条件:  # 留意不要遗失冒号
        要重复履行的代码  # 留意代码前要有缩进

简略示例：

a = 60
while a < 70:
        print(a)
        a = a + 1

2.5 函数

Python 供给了诸多的内置函数，比方 str()、int() 等，可是在开发时，也需求经常用到自界说函数。
在 Python 中运用 def 关键字界说一个函数。

def 函数名(参数):
　　　完成函数功用的代码

假如需求回来值，则需求运用 return 进行回来。

def data_transform():
    # 具体的完成逻辑
    return True

2.6 模块导入

要运用模块，就需求装置和导入模块。模块的两种导入办法：import 句子导入法和 from句子导入法。

  • import 语法会导入模块内一切办法，一般假如用包的办法较多能够挑选；
  • from 模块名 import 函数名：导入某块中某个函数，
import math  # 导入math模块
import turtle  # 导入turtle模块
from math import sqrt  # 导入math模块中的单个函数
from turtle import forward, backward, right, left  # 导入turtle模块中的多个函数

模块的装置运用 pip install 指令：

pip install "SomeProject"

3. 网络恳求与数据解析

爬虫必定需求了解根底的网络恳求和根底的 HTML 常识，能够知道根底的 HTML 标签。

3.1 requests 包

requests 包能够模仿浏览器建议 HTTP 或 HTTPS 协议的网络恳求，从而获取网页源代码。
运用也比较简略，先装置模块：pip3 install requests.
get 恳求
比方抓取百度主页的信息。

import requests
response = requests.get(url='https://www.baidu.com')
print(response.text)

输出如下：

Python 爬虫快速入门

**post **恳求

# 测验恳求地址
req_url = "https://juejin.org/post"
# 表单数据
formdata = {
    'username': 'admin',
    'password': 'a123456',
}
# 增加恳求头
req_header = {
    'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36',
}
# 建议恳求
response = requests.post(
    req_url,
    data=formdata,
    headers=req_header
)
print(response.text)

经过 requests 模块发送网络恳求，十分简略，容易上手。

3.2 BeautifulSoup 数据解析

BeautifulSoup 模块是一个 HTML/XML 解析器，主要用于解析和提取 HTML/XML 文档中的数据。该模块不仅支撑 Python 标准库中的 HTML 解析器 lxml，而且支撑许多功用强壮的第三方解析器。
在运用前先经过 pip 指令装置模块：pip install beautifulsoup4 。

3.2.1 简略运用

以恳求百度主页为例。

if __name__ == '__main__':
    url = "https://www.baidu.com"
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'lxml')
    print(soup.prettify())

打印输出以下信息：

<!DOCTYPE html>
<!--STATUS OK-->
<html>
 <head>
  <meta content="text/html;charset=utf-8" http-equiv="content-type"/>
  <meta content="IE=Edge" http-equiv="X-UA-Compatible"/>
  <meta content="always" name="referrer"/>
  <link href="https://ss1.bdstatic.com/5eN1bjq8AAUYm2zgoY3K/r/www/cache/bdorz/baidu.min.css" rel="stylesheet" type="text/css"/>
  <title>
    
  </title>
 </head>
 <body link="#0000cc">
  <div id="wrapper">
   <div id="head">
    <div class="head_wrapper">
     <div class="s_form">
      <div class="s_form_wrapper">
       <div id="lg">
        <img height="129" hidefocus="true" src="https://www.baidu.com/img/bd_logo1.png" width="270"/>
       </div>
       <form action="//www.baidu.com/s" class="fm" id="form" name="f">
        <input name="bdorz_come" type="hidden" value="1"/>
        <input name="ie" type="hidden" value="utf-8"/>
        <input name="f" type="hidden" value="8"/>
        <input name="rsv_bp" type="hidden" value="1"/>
        <input name="rsv_idx" type="hidden" value="1"/>
        <input name="tn" type="hidden" value="baidu"/>
        <span class="bg s_ipt_wr">
         <input autocomplete="off" autofocus="autofocus" class="s_ipt" id="kw" maxlength="255" name="wd" value=""/>
        </span>
        <span class="bg s_btn_wr">
         <input autofocus="" class="bg s_btn" id="su" type="submit" value=""/>
        </span>
       </form>
      </div>
     </div>
     ...
    </div>
   </div>
  </div>
 </body>
</html>

经过 BeautifulSoup 库能够将恳求的网址信息依照标签进行转换展现。下面学习 BeautifulSoup 供给的标签操作办法。

3.2.2 查找标签

依照上一节中的百度主页为例，下面分别介绍 BeautifulSoup 中常用的办法。

查找指定标签名

在网页源码中，存在许多类型的标签。经过标签名进行定位只能回来其间的榜首个标签。
比方咱们查找定位 标签。

if __name__ == '__main__':
    url = "https://www.baidu.com"
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'lxml')
    print(soup.input)

输出结果：

<input name="bdorz_come" type="hidden" value="1"/>
查找指定特点的标签

标签的特点有：name、class、id 等，咱们运用 find 或 find_all 办法查找标签对应的一切特点。

import requests
from bs4 import BeautifulSoup
if __name__ == '__main__':
    url = "https://www.baidu.com"
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'lxml')
    # print(soup.prettify())
    # 查找 class 特点为 bg s_ipt_wr 的标签
    bg_tags = soup.find_all(class_='bg s_ipt_wr')
    for tag in bg_tags:
        print(tag)  # 输出 <span class="bg s_ipt_wr"><input autocomplete="off" autofocus="autofocus" class="s_ipt" id="kw" maxlength="255" name="wd" value=""/></span>
    # 查找 name = rsv_idx
    idx = soup.find(attrs={'name': 'rsv_idx'})
    print(idx)  # 输出 <input name="rsv_idx" type="hidden" value="1"/>

在上面的示例中，咱们经过 find_all 办法查找一切 class_= 'bg s_ipt_wr'的标签。由于 class 这个单词自身是 Python 的保留字，所以 BeautifulSoup 模块中的 class 特点在结束增加了下划线来进行区别。其他标签特点，如 id 特点，则没有增加下划线。

经过标签名+特点查找

经过指定标签名 + 特点值能够完成更准确的查找。

if __name__ == '__main__':
    url = "https://www.baidu.com"
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'lxml')
    # print(soup.prettify())
    # 查找 input 标签且特点 name = rsv_idx
    idx = soup.find('input', attrs={'name': 'rsv_idx'})
    print(idx)  # 输出 <input name="rsv_idx" type="hidden" value="1"/>

3.2.3 挑选标签

在上一小节中介绍了 find 办法用于查找标签，运用 select() 函数能够依据指定的挑选器回来一切契合条件的标签。常用的挑选器有 id 挑选器、class 挑选器、标签挑选器和层级挑选器。

1. 标签挑选器

依据指定的标签进行挑选。在 find 中依据指定标签名查找时只会回来榜首个匹配项。运用 select 标签回来一切。

if __name__ == '__main__':
    url = "https://www.baidu.com"
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'lxml')
    # print(soup.prettify())
    input_tag = soup.select('input')
    print(input_tag)
    # 输出 [<input name="bdorz_come" type="hidden" value="1"/>, <input name="ie" type="hidden" value="utf-8"/>]

在 select 中直接查找对应的标签名，会输出一切的标签。

2. id 挑选器

id 挑选器是依据 id 值查找对应的标签。格局 ‘#id值’

if __name__ == '__main__':
    url = "https://www.baidu.com"
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'lxml')
    # print(soup.prettify())
    input_tag = soup.select('#kw')
    print(input_tag)
    # 输出 [<input autocomplete="off" autofocus="autofocus" class="s_ipt" id="kw" maxlength="255" name="wd" value=""/>]

上面的示例中，查找 id 值为 kw 的标签。留意输出是列表方式。

3. class 挑选器

class 挑选器依据 class 特点值查找对应的标签，格局为 ‘.class特点值’

if __name__ == '__main__':
    url = "https://www.baidu.com"
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'lxml')
    # print(soup.prettify())
    input_tag = soup.select('.s_ipt')
    print(input_tag)
    # 输出 [<input autocomplete="off" autofocus="autofocus" class="s_ipt" id="kw" maxlength="255" name="wd" value=""/>]

上面的示例中，查找 class 值为 s_ipt 的标签。留意输出是列表方式。

4. 层级挑选器

在 HTML 中标签嵌套很常见，标签在不同的层级形成嵌套结构。经过 标签>标签这种指向结构来定位。

<div class="s_form_wrapper">
   <div id="lg">
    <img height="129" hidefocus="true" src="https://www.baidu.com/img/bd_logo1.png" width="270"/>
   </div>
   <form action="//www.baidu.com/s" class="fm" id="form" name="f">
    <input name="bdorz_come" type="hidden" value="1"/>
    <input name="ie" type="hidden" value="utf-8"/>
    <input name="f" type="hidden" value="8"/>
    <input name="rsv_bp" type="hidden" value="1"/>
    <input name="rsv_idx" type="hidden" value="1"/>
    <input name="tn" type="hidden" value="baidu"/>
    <span class="bg s_ipt_wr">
     <input autocomplete="off" autofocus="autofocus" class="s_ipt" id="kw" maxlength="255" name="wd" value=""/>
    </span>
    <span class="bg s_btn_wr">
     <input autofocus="" class="bg s_btn" id="su" type="submit" value=""/>
    </span>
   </form>
</div>

运用上面的示例数据，咱们来验证。

if __name__ == '__main__':
    url = "https://www.baidu.com"
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'lxml')
    # 查找一切 <div> 标签下 <div> 标签的 id 特点值为 lg 的标签
    div_tag = soup.select('div>div>#lg')
    # 输出结果 [<div id="lg"> <img  hidefocus="true" src="https://www.baidu.com/img/bd_logo1.png" /> </div>]
    print(div_tag)
    # 查找 <form> 标签下一切的 input 标签
    input_tag = soup.select('form>input')
    print(input_tag)
    # 输出结果 [<input name="bdorz_come" type="hidden" value="1"/>, <input name="ie" type="hidden" value="utf-8"/>, <input name="f" type="hidden" value="8"/>, <input name="rsv_bp" type="hidden" value="1"/>, <input name="rsv_idx" type="hidden" value="1"/>, <input name="tn" type="hidden" value="baidu"/>]
    form_tag = soup.select('div>form span')
    print(form_tag)

“>” 在层级挑选器中表明向下找一个层级，中心不能有其他层级。假如中心有空格表明中心能够有多个层级。

3.2.4 提取内容和特点

找到标签后，咱们需求读取标签对应的内容或许特点。

提取标签内容

获取标签后咱们需求查找标签中的内容，能够运用 string 或 text 来提取。string 特点回来的是指定标签的直系文本，即直接存在于该标签中的文本，而不是存在于该标签下的其他标签中的文本。text 特点回来的则是指定标签下的一切文本。

if __name__ == '__main__':
    url = "https://www.baidu.com"
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'lxml')
    # 查找一切 <div> 标签下 <div> 标签的 id 特点值为 lg 的标签
    div_tag = soup.select('div>a')
    print(div_tag[0].string)
    print(div_tag[0].text)
从标签中提取特点

对于找到的标签，提取特点直接运用 tag['特点表']即可。

if __name__ == '__main__':
    url = "https://www.baidu.com"
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'lxml')
    div_tag = soup.select('form>input') # [<input name="bdorz_come" type="hidden" value="1"/>]
    print(div_tag[0]['name']) # bdorz_come 
    print(div_tag[0]['type']) # hidden

至此，咱们根本完结了对 beautifulSoup 库的学习。

4. 正则表达式

正则表达式是一种用于匹配和操作文本的强壮工具，它是由一系列字符和特殊字符组成的形式，用于描绘要匹配的文本形式。正则表达对网页源代码的字符串进行匹配，从而提取出需求的数据。

4.1 一般字符

一般字符包含没有显式指定为元字符的一切可打印和不可打印字符。这包含一切大写和小写字母、一切数字、一切标点符号和一些其他符号。

符号 描绘
\W 匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。
\w 匹配包含下划线的任何单词字符。等价于“[A-Za-z0-9_]”。
\s 匹配任何空白字符，包含空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。
\S 匹配任何非空白字符。等价于[^ \f\n\r\t\v]。
\d 匹配一个数字字符。等价于[0-9]。
\D 匹配一个非数字字符。等价于[^0-9]。

示例代码：

if __name__ == '__main__':
    str = 'kdd199ok98 a123 343'
    print(re.findall('\W', str))    # 匹配任何非单词字符，[' ', ' ']
    print(re.findall('\w', str))    # 匹配任何单词字符，['k', 'd', 'd', '1', '9', '9', 'o', 'k', '9', '8', 'a', '1', '2', '3', '3', '4', '3']
    print(re.findall('\S', str))    # 匹配任何非空白字符，['k', 'd', 'd', '1', '9', '9', 'o', 'k', '9', '8', 'a', '1', '2', '3', '3', '4', '3']
    print(re.findall('\s', str))    # 匹配空白字符，[' ', ' ']
    print(re.findall('\D', str))    # 匹配非数字，['k', 'd', 'd', 'o', 'k', ' ', 'a', ' ']
    print(re.findall('\d', str))    # 匹配数字，['1', '9', '9', '9', '8', '1', '2', '3', '3', '4', '3']

4.2 元字符

元字符是正则表达式中有特殊意义的字符，能够设置字符的匹配形式。

符号 描绘
$ 匹配输入字符串的结束方位。假如设置了 RegExp 目标的 Multiline 特点，则 也匹配′n′或′r′。要匹配也匹配 ‘\\n’ 或 ‘\\r’。要匹配 字符自身，请运用 \$。
( ) 标记一个子表达式的开端和结束方位。子表达式能够获取供以后运用。要匹配这些字符，请运用 \( 和 \)。
* 匹配前面的子表达式零次或屡次。要匹配 * 字符，请运用 \*。
+ 匹配前面的子表达式一次或屡次。要匹配 + 字符，请运用 \+。
. 匹配除换行符 \n 之外的任何单字符。要匹配 . ，请运用 \. 。
[ 标记一个中括号表达式的开端。要匹配 [，请运用 \[。
? 匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请运用 \?。
\ 将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， ‘n’ 匹配字符 ‘n’。’\n’ 匹配换行符。序列 ‘\\’ 匹配 “\”，而 ‘\(‘ 则匹配 “(“。
匹配输入字符串的开端方位，除非在方括号表达式中运用，当该符号在方括号表达式中运用时，表明不接受该方括号表达式中的字符调集。要匹配 ^ 字符自身，请运用 \^。
{n} n 是一个非负整数。匹配确认的 n 次。
{n,} n 是一个非负整数。至少匹配n 次。
{n,m} m 和 n 均为非负整数，其间 n <= m。最少匹配 n 次且最多匹配 m 次。

示例代码：

if __name__ == '__main__':
    str = 'akdd1d199ok98 d123 3438'
    print(re.findall('8$', str))    # 匹配以 8 结束的字符，['8']
    print(re.findall('3$', str))    # 匹配以 3 结束的字符，[]
    print(re.findall('^a', str))    # 匹配以 a 最初的字符，['a']
    print(re.findall('^d', str))    # 匹配以 d 最初的字符，[]
    print(re.findall('(d1)?', str))    # 匹配 d1 零次或一次的字符，['', '', 'd1', '', '', '', '', '', '', '', 'd1', '', '', '', '', '', '', '', '']
    print(re.findall('(d1)+', str))    # 匹配 d1 一次或屡次的字符，['d1', 'd1']
    print(re.findall('(d1)*', str))    # 匹配 d1 零次或屡次的字符，['', '', 'd1', '', '', '', '', '', '', '', 'd1', '', '', '', '', '', '', '', '']
    print(re.findall('(d1){2,}', str))    # 匹配 d1 最少 2 次的字符，['d1']
    print(re.findall('(d1){1,2}', str))    # 匹配 d1 最少 1 次，最多 2 次的字符，['d1', 'd1']
    print(re.findall('(d.d)', str))    # 匹配 (d.d) 的字符，['d1d']
    print(re.findall('(d?d)', str))    # 匹配 (d?d) 的字符，['dd', 'd', 'd']
    print(re.findall('[ad]', str))    # 匹配字符调集 [ad] 的字符，['a', 'd', 'd', 'd', 'd']
    print(re.findall('(ad)', str))    # 匹配表达式 ad ，[]

正在表达式根底，可是想灵活运用起来还需求多加练习，太灵活能够拼装许多形式。

5. Selenium 的根本运用

经过 requests 模块能够完成对一些静态网页的恳求，对于一些动态与浏览器需求交互的地址则不能满足。而 Selenium 模块则能操控浏览器发送恳求，并和获取到的网页中的元素进行交互，因此，只要是浏览器发送恳求能得到的数据，Selenium 模块也能直接得到。

5.1 环境装置

运用 Selenium 模块需求先下载和装置浏览器驱动程序，然后在编程时经过 Selenium 模块实例化一个浏览器目标，再经过浏览器目标拜访网页和操作网页元素。

5.1.1 装置 Selenium 模块

装置比较简略，直接运用 pip install selenium装置就行了。比较重要的是装置浏览器驱动程序。

2.1.2 装置浏览器驱动程序

在网址 chromedriver.storage.googleapis.com/index.html 中能够下载对应版别的浏览器驱动程序。
查看自己浏览器版别，在浏览器中输入：chrome://version/

Python 爬虫快速入门

挑选对应的电脑端体系，比方我是 Mac 体系，下载对应的即可。解压之后放到环境路径或许项目中都行，只要在运用时指定对应的环境即可。

5.1.3 翻开页面

这里已翻开百度网站为例。我将 webdriver 放到项目路径中。

from selenium import webdriver
if __name__ == '__main__':
    browser = webdriver.Chrome(executable_path='./chromedriver_mac64/chromedriver')
    browser.get('https://www.baidu.com')

5.2 常见 API

5.2.1 浏览器操作

webdriver 回来的 browser 目标中，供给了丰富的 API 用于操作浏览器。

browser.maximize_window() 最大化浏览器
browser.current_url 当时网页 url
browser.get_cookie() 当时网页用到的 cookie 信息
browser.name 当时浏览器驱动称号
browser.title 当时网页标题
browser.page_source 获取当时网页源代码
browser.current_window_handle 获取当时网页的窗口
browser.refresh() 刷新当时网页
browser.quit() 封闭浏览器
browser.close() 封闭当时网页
browser.back() 回来上一页

5.2.2 查找标签

完结了网页的拜访后，假如需求模仿用户操作网页元素，则需求先经过标签来定位网页元素。
find_element(self, by=By.ID, value=None)� 查找元素，其间 By.ID 是枚举类型：

  • ID：经过元素 id 定位；
  • XPATH：经过 xpath 表达式定位；
  • LINK_TEXT：经过完好超链接定位；
  • PARTIAL_LINK_TEXT：经过含糊超链接定位；
  • NAME：经过元素 name 定位；
  • TAG_NAME：经过标签定位；
  • CLASS_NAME：经过 class 进行定位；
  • CSS_SELECTOR：经过 css 挑选器进行定位。

运用示例：

from selenium import webdriver
from selenium.webdriver.common.by import By
if __name__ == '__main__':
    browser = webdriver.Chrome(executable_path='./chromedriver_mac64/chromedriver')
    browser.get('https://www.baidu.com')
    tag1 = browser.find_element(by=By.ID, value='form')
    print(tag1.get_attribute("class"))

找到标签后，就能够经过 get_attribute 办法获取对应的特点值。

5.3 模仿鼠标操作

常用的鼠标操作有单击、双击、右击、长按、拖动、移动等，模仿这些操作需求用到 Selenium 模块中的ActionChains 类。它供给了以下办法：

  • click()：模仿点击；
  • double_click()：模仿双击；
  • click_and_hold()：鼠标长按；
  • click_and_hold()：开释鼠标按；

下面以翻开百度主页的图片链接为例：

from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By
if __name__ == '__main__':
    browser = webdriver.Chrome(executable_path='./chromedriver_mac64/chromedriver')
    browser.get('https://www.baidu.com')
    # 找到图片链接
    alink = browser.find_element(by=By.LINK_TEXT, value='图片')
    print(alink.get_attribute("href"))
    actions = ActionChains(browser)
    actions.click(alink).perform()

运转成功后，会首要翻开百度主页，然后跳转到百度图片页面。

Python 爬虫快速入门

6. 总结

在本次的实践过程中，体会到运用 Python 爬虫的方便性，在学习的过程中主要参照《零根底学Python爬虫、数据剖析与可视化从入门到精通》这本书，总体也算作快速入门了。
参阅链接：

  • www.runoob.com/regexp/rege…