首先我们需要安装python3环境，下载地址 https://www.python.org/downloads/，选择适合自己系统的python3版本。

下载之后，傻瓜式安装，安装步骤中应该是有一个把python加入到环境变量中，如果没有则手动添加（记得把pip放到环境变量中）。

requests : Requests 唯一的一个非转基因的 Python HTTP 库，人类可以安全享用
selenium : Selenium测试直接运行在浏览器中，就像真正的用户在操作一样
beautifulsoup4 : Beautiful Soup 是一个可以从HTML或XML文件中提取数据的Python库
lxml : Python 标准库中自带了 xml 模块，但是性能不够好，而且缺乏一些人性化的 API，相比之下，第三方库 lxml 是用 Cython 实现的，而且增加了很多实用的功能，可谓爬虫处理网页数据的一件利器。

import requests

url = 'http://www.baidu.com/s?'

headers = {
        'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36'
}

params = {'wd':'杨幂'}
#发起get请求
response = requests.get(url=url, headers=headers, params=params)
#返回解释码内容
content = response.text
#获取响应内容
print(content)
#返回二进制内容
content = response.content
#返回响应码
print(response.status_code)
#请求头
print(response.request.headers)
#返回当前编码格式
print(response.encoding)

with open('baidu.html', 'w') as f:
    f.write(content.decode('utf-8'))

from selenium import webdriver

driver = webdriver.Chrome(
    executable_path='/home/fs/下载/chromedriver'
)

driver.get('http://www.baidu.com/')
driver.save_screenshot('baidu.png')

with open('baidu.html', 'w') as f:
    f.write(driver.page_source)

XPath是XML路径语言，它是一种用来确定XML文档中某部分位置的语言。
在python爬虫方面的学习中，xpath至关重要，它与正则相比具有明显的优势。下面将介绍在python中xpath的简单使用。
安装方法不必多说，与其他第三方库的安装方法一样，使用pip安装。
使用方式
首先需要导入库

import lxml.html

接下来就是使用了，话不多说，上代码

import requests
from lxml import etree
import json

class qiushi():
    def __init__(self):
        self.pg = 1
        self.url = 'https://www.qiushibaike.com/text/page/'
        self.headers = {
            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36'
        }

    def loadpage(self, url):
        response = requests.get(url=url, headers=self.headers)

        html = response.content.decode()
        content = etree.HTML(html)
        parent = content.xpath('//div[@id="content-left"]/div')
        # print(parent)
        #模糊
        #parent = content.xpath(//div[contains(@id,"qiushi_tag_")])
        for son in parent:
            name = son.xpath('.//h2/text()')[0]
            qcontent = '.'.join(son.xpath('.//div[@class="content"]/span[1]/text()'))[0]
            smile = son.xpath('.//div[@class="stats"]/span/i/text()')[0]
            comments = son.xpath('.//div[@class="stats"]/span[@class="stats-comments"]//i[@class="number"]/text()')[0]
            # print(name)
            dict = {
                'name': name.strip(),
                'content': qcontent.strip(),
                'smile': smile,
                'comments': comments,
            }
            # print(dict)
            self.save(dict)
        page = content.xpath('//ul[@class="pagination"]/li[last()-1]//span/text()')[0]
        if self.pg < int(page):
            self.pg += 1
            self.start()

    def save(self, content):
        with open('qiushi.json', 'a') as f:
            f.write(json.dumps(content, ensure_ascii=False) + "\n")

    def start(self):
        full_url = self.url + str(self.pg) + '/'
        print(full_url)
        self.loadpage(full_url)


if __name__ == '__main__':
    q = qiushi()
    q.start()

bs4

bs4可以说是别人将xpath再进行了封装，然后供我们使用的更简单的方法，当然，它跟xpath相比运用更简单，但是没有xpath功能全。在实际的爬虫运用中，一些简单的网站爬取不需要用xpath，当然更不需要用正则，这个时候我们可以使用bs4。

导入方法

from bs4 import BeautifulSoup

基本运用

import requests
import json
from bs4 import BeautifulSoup


def tenxun():
    url = 'https://hr.tencent.com/position.php?&start=0'
    headers = {
        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36'
    }
    reponse = requests.get(url=url, headers=headers)
    html = reponse.content.decode()
    bs = BeautifulSoup(html)

    tr = bs.find_all('tr', class_='even')
    tr1 = bs.find_all('tr', class_='odd')

    result = tr+tr1

    for job in result:
        name = job.select('td a')[0].get_text()
        #取属性
        # name = job.select('td a')[0].get('href')
        # name = job.select('td a')[0].attrs['href']

        type = job.select('td')[1].get_text()
        num = job.select('td')[2].get_text()
        address = job.select('td')[3].get_text()
        time = job.select('td')[4].get_text()

        dic ={
            'name': name,
            'type': type,
            'num': num,
            'addresss': address,
            'time': time,
        }
        save(dic)

def save(content):
    with open('tengxun.json', 'a') as f:
        f.write(json.dumps(content, ensure_ascii=False)+'\n')



if __name__ == '__main__':
    tenxun()

单字符匹配

. 除换行符之外的任意字符
\d 表示数字
\D 匹配非数字
\w 匹配单词字符[a-z,A-Z,0-9]
\W 匹配非单词字符
\s 匹配空白字符，空格，\n   \t…
\S 匹配非空白字符
^  匹配以…开头
$  匹配以…结尾
[0-9] => \d 匹配0-9

多字符匹配（贪婪匹配）

* 匹配*前面的字符任意次数
+ 匹配+前面的字符至少一次
？匹配？前面的字符0-1次
{n,m}匹配{n,m}前面的字符n-m次

多字符匹配（非贪婪匹配）

*？
+？
？？

其他

（）分组
|逻辑或
\转义字符

re模块下的方法

re.compile()：构建正则表达式对象
re.match():从起始位开始匹配，单次匹配，如果匹配到结果立即返回，反之，返回None
re.search():在整个字符串中进行匹配，单次匹配，如果匹配到结果立即返回，反之，返回None
re.findall():匹配出整个字符串中，所有符合正则规则的结果，返回一个列表
re.finditer():匹配出整个字符串中，所有符合正则规则的结果，返回的是一个可迭代对象
re.sub()：根据正则表达式进行字符串替换
re.split():根据正则表达式进行分割

正则的用法

def get_rank_data(url='http://top.hengyan.com/dianji/default.aspx?p=1'):
    #构建请求头
    headers = {
        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36',
    }
    # url, \目标url
    # data=None, \默认为None表示是get请求,如果不为None说明是get请求
    # timeout 设置请求的超时时间
    # cafile=None, capath=None, cadefault=False,:证书相关参数
    # context=None :忽略证书认证
    #urlopen不能添加请求头
    # response = request.urlopen(url=url,timeout=10)

    #添加请求头
    req = request.Request(url=url,headers=headers)
    response = request.urlopen(req,timeout=10)

    #响应状态码
    code = response.status
    #当前请求的url地址
    url = response.url
    print(code,url)

    b_content = response.read()
    # bytes -> str: decode
    # str -> bytes: encode
    # print(b_content)
    html = b_content.decode('utf-8')
    # print(html)
    # #文件操作
    # """
    # w:    w+:    wb:    wb+    a:    a+:    ab:    ab+:    r:    rb:
    # """
    # with open('hengyan.html','w') as file:
    #     file.write(html)

    #证据正则表达式解析数据
    # re.S 修饰：表示.可以匹配换行符

    pattern = re.compile('<div\sclass="list">(.*?)</div>',re.S)
    ul_str = re.findall(pattern,html)[0]

    pattern1 = re.compile('<ul.*?>(.*?)</ul>',re.S)
    li_strs = re.findall(pattern1,ul_str)[1:]

    for li_str in li_strs:
        # print(li_str)
        pattern = re.compile(
            '<li\sclass="num">(.*?)</li>'+
            '.*?<a.*?>(.*?)</a>'+
            '.*?<li.*?>(.*?)</li>'+
            '.*?<li.*?>(.*?)</li>'+
            '.*?<li.*?>(.*?)</li>'+
            '.*?<li.*?>(.*?)</li>',
            re.S
        )

        data = re.findall(pattern=pattern,string=li_str)[0]
        print(data)

    #提取下一页：
    if '下一页' in html:
        #说明还存在下一页
        pattern = re.compile('<span\sclass="pageBarCurrentStyle">(.*?)</span>',re.S)
        current_page = int(re.findall(pattern,html)[0])
        next_page = current_page+1
        #构造下一页的URL地址
        next_page_url = re.sub('\d+',str(next_page),url)
        print(next_page_url)
        get_rank_data(next_page_url)
    else:
        print('数据提取完毕')

if __name__ == '__main__':

    get_rank_data()

欢迎各位积极评论，本人刚开始做爬虫，希望与各位共同学习，共同进步。