Python爬虫常用库总结：requests、beautifulsoup、selenium、xpath总结
 
 


 
文章目录
 
requests
requests基础
requests模块发送get请求
response响应对象
response.text 和response.content的区别
解决中文乱码
response响应对象的其它常用属性或方法
   
requests实操
requests模块发送请求
发送带参数的请求
超时参数timeout的使用
requests发送post请求的方法
  
  
BeautifulSoup
常见解释器的优缺点
常用操作
几个简单的浏览结构化数据的方法
从文档中找到所有的< a>标签的链接
在文档中获取所有的文字内容
   
通过标签和属性获取
Name属性
多个属性
多值属性
可以遍历的字符串
注释及特殊字符串
遍历文档树
子节点
find_all方法
.contents和.children
  
  
selenium
selenium介绍
chrome浏览器的运行效果
phantomjs无界面浏览器的运行效果
selenium的作用和工作原理
   
selenium的安装以及简单使用
selenium的简单使用
  
lxml

 
 
 
记得安装快速第三方库，Python经常需要安装第三方库，原始的下载速度很慢，使用国内的镜像就很快啦
 
 
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名
 
快速下载模块
 
官方网址：
 
Requests: 让 HTTP 服务人类
Beautiful Soup 4.4.0 文档
Selenium官网
lxml - XML and HTML with Python
 
requests
 
 
 
requests官方文档 https://docs.python-requests.org/zh_CN/latest/
 
 
 
 
 
进行爬虫，首先要对网址进行请求，这个时候就要用刀我们的requests模块了。requests是python的一个HTTP客户端库，跟urllib，urllib2类似。与urllib，urllib2相比，requests模块语法更加简单。正如他的官网所说：
 
 
 
 
 
requests模块介绍
 
 
发送http请求，获取响应数据
 
requests模块是一个第三方模块，需要在你的python(虚拟)环境中额外安装
 
pip/pip3 install requests
 
requests基础
 
requests模块发送get请求
 
#https://beishan.blog.csdn.net/
import requests 
# 目标url
url = 'https://www.baidu.com' 
# 向目标url发送get请求
response = requests.get(url)
# 打印响应内容
print(response.text)
 
response响应对象
 
 
 
观察上边代码运行结果发现，有好多乱码；这是因为编解码使用的字符集不同早造成的；我们尝试使用下边的办法来解决中文乱码问题
 
 
import requests 
url = 'https://www.baidu.com' 
# 向目标url发送get请求
response = requests.get(url)
# 打印响应内容
# print(response.text)
print(response.content.decode()) # 注意这里！
 
response.text是requests模块按照chardet模块推测出的编码字符集进行解码的结果
网络传输的字符串都是bytes类型的，所以response.text = response.content.decode(‘推测出的编码字符集’)
我们可以在网页源码中搜索charset，尝试参考该编码字符集，注意存在不准确的情况
 
response.text 和response.content的区别
 
response.text 
  
类型：str
解码类型： requests模块自动根据HTTP 头部对响应的编码作出有根据的推测，推测的文本编码
 
response.content 
  
类型：bytes
解码类型： 没有指定
 
 
解决中文乱码
 
通过对response.content进行decode，来解决中文乱码
 
response.content.decode() 默认utf-8
response.content.decode("GBK")
常见的编码字符集 
  
utf-8
gbk
gb2312
ascii （读音：阿斯克码）
iso-8859-1
 
 
response响应对象的其它常用属性或方法
 
#https://beishan.blog.csdn.net/
# 1.2.3-response其它常用属性
import requests

# 目标url
url = 'https://www.baidu.com'

# 向目标url发送get请求
response = requests.get(url)

# 打印响应内容
# print(response.text)
# print(response.content.decode()) 			# 注意这里！
print(response.url)							# 打印响应的url
print(response.status_code)					# 打印响应的状态码
print(response.request.headers)				# 打印响应对象的请求头
print(response.headers)						# 打印响应头
print(response.request._cookies)			# 打印请求携带的cookies
print(response.cookies)						# 打印响应中携带的cookies
 
requests实操
 
requests模块发送请求
 
发送带header的请求
 
 
 
我们先写一个获取百度首页的代码
 
 
import requests
url = 'https://www.baidu.com'
response = requests.get(url)
print(response.content.decode())
# 打印响应对应请求的请求头信息
print(response.request.headers)
 
 
 
从浏览器中复制User-Agent，构造headers字典；完成下面的代码后，运行代码查看结果
 
 
import requests

url = 'https://www.baidu.com'

headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36"}

# 在请求头中带上User-Agent，模拟浏览器发送请求
response = requests.get(url, headers=headers) 

print(response.content)

# 打印请求头信息
print(response.request.headers)
 
 
发送带参数的请求
 
 
 
我们在使用百度搜索的时候经常发现url地址中会有一个 ?，那么该问号后边的就是请求参数，又叫做查询字符串
 
 
在url携带参数，直接对含有参数的url发起请求
 
import requests

headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36"}

url = 'https://www.baidu.com/s?wd=python'

response = requests.get(url, headers=headers)

 
通过params携带参数字典
 
​ 1.构建请求参数字典
 
​ 2.向接口发送请求的时候带上参数字典，参数字典设置给params
 
import requests

headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36"}

# 这是目标url
# url = 'https://www.baidu.com/s?wd=python'

# 最后有没有问号结果都一样
url = 'https://www.baidu.com/s?'

# 请求参数是一个字典 即wd=python
kw = {'wd': 'python'}

# 带上请求参数发起请求，获取响应
response = requests.get(url, headers=headers, params=kw)

print(response.content)
 
从浏览器中复制User-Agent和Cookie
浏览器中的请求头字段和值与headers参数中必须一致
headers请求参数字典中的Cookie键对应的值是字符串
 
import requests

url = 'https://github.com/USER_NAME'

# 构造请求头字典
headers = {
    # 从浏览器中复制过来的User-Agent
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.87 Safari/537.36',
    # 从浏览器中复制过来的Cookie
    'Cookie': 'xxx这里是复制过来的cookie字符串'
}

# 请求头参数字典中携带cookie字符串
resp = requests.get(url, headers=headers)

print(resp.text)
 
超时参数timeout的使用
 
 
 
在平时网上冲浪的过程中，我们经常会遇到网络波动，这个时候，一个请求等了很久可能任然没有结果。
 
 
 
 
在爬虫中，一个请求很久没有结果，就会让整个项目的效率变得非常低，这个时候我们就需要对请求进行强制要求，让他必须在特定的时间内返回结果，否则就报错。
 
 
 
超时参数timeout的使用方法
 
response = requests.get(url, timeout=3)
 
 
timeout=3表示：发送请求后，3秒钟内返回响应，否则就抛出异常
 
 
import requests


url = 'https://twitter.com'
response = requests.get(url, timeout=3)     # 设置超时时间

 
requests发送post请求的方法
 
 
response = requests.post(url, data)
 
 
data参数接收一个字典
 
 
requests模块发送post请求函数的其它参数和发送get请求的参数完全一致
 
 
BeautifulSoup
 
 
 
BeautifulSoup官方文档 https://beautifulsoup.readthedocs.io/zh_CN/v4.4.0/
 
 
 
 
Beautiful Soup 是一个可以从HTML或XML文件中提取数据的Python库.它能够通过你喜欢的转换器实现惯用的文档导航,查找,修改文档的方式.Beautiful Soup会帮你节省数小时甚至数天的工作时间.
 
 
 
常见解释器的优缺点
 
 
常用操作
 
 
 
安装方法
 
 
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple beautifulsoup4  
 
 
 
导入即可
 
 
from bs4 import BeautifulSoup
 
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title"><b>The Dormouse's story</b></p>

<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>

<p class="story">...</p>
"""
 
soup = BeautifulSoup(html_doc,"lxml")
 
几个简单的浏览结构化数据的方法
 
soup.title
 
<title>The Dormouse's story</title>
 
soup.title.name
 
'title'
 
soup.title.string
 
"The Dormouse's story"
 
soup.title.text
 
"The Dormouse's story"
 
soup.title.parent.name
 
'head'
 
soup.p
 
<p class="title"><b>The Dormouse's story</b></p>
 
soup.p.name
 
'p'
 
soup.p["class"]
 
['title']
 
soup.a
 
<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>
 
soup.find("a")
 
<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>
 
soup.find_all("a")
 
[<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
 
从文档中找到所有的< a>标签的链接
 
for link in soup.find_all("a"):
    print(link.get("href"))
 
http://example.com/elsie
http://example.com/lacie
http://example.com/tillie
 
在文档中获取所有的文字内容
 
print(soup.get_text())
 
The Dormouse's story

The Dormouse's story
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.
...
 
​
 
通过标签和属性获取
 
Tag有很多方法和属性,在 遍历文档树 和 搜索文档树 中有详细解释.现在介绍一下tag中最重要的属性: name和attributes
 
soup = BeautifulSoup('<b class="boldest">Extremely bold</b>')
tag  = soup.b
tag
 
<b class="boldest">Extremely bold</b>
 
type(tag)
 
bs4.element.Tag
 
Name属性
 
每个tag都有自己的名字,通过 .name 来获取:
 
tag.name
 
'b'
 
如果改变了tag的name,那将影响所有通过当前Beautiful Soup对象生成的HTML文档
 
tag.name = "blockquote"
tag
 
<blockquote class="boldest">Extremely bold</blockquote>
 
多个属性
 
一个tag可能有很多个属性.tag  有一个 “class” 的属性,值为 “boldest” . tag的属性的操作方法与字典相同:
 
tag["class"]
 
['boldest']
 
tag.attrs
 
{'class': ['boldest']}
 
tag的属性可以被添加,删除或修改. 再说一次, tag的属性操作方法与字典一样
 
tag["class"] = "verybold"
tag["id"] = 1
tag
 
<blockquote class="verybold" id="1">Extremely bold</blockquote>
 
del tag["class"]
tag
 
<blockquote id="1">Extremely bold</blockquote>
 
多值属性
 
css_soup = BeautifulSoup('<p class="body strikeout"></p>')
css_soup.p['class']
 
['body', 'strikeout']
 
css_soup = BeautifulSoup('<p class="body"></p>')
css_soup.p['class']
 
['body']
 
可以遍历的字符串
 
字符串常被包含在tag内.Beautiful Soup用 NavigableString 类来包装tag中的字符串:
 
tag.string
 
'Extremely bold'
 
type(tag.string)
 
bs4.element.NavigableString
 
 
一个 NavigableString 字符串与Python中的Unicode字符串相同,
 并且还支持包含在遍历文档树 和 搜索文档树 中的一些特性.
 通过 unicode() 方法可以直接将 NavigableString 对象转换成Unicode字符串:
 
 
tag中包含的字符串不能编辑，但是可以被替换成其他的字符串，用replace_with()方法
 
 
tag.string.replace_with("No longer bold")
tag
 
<blockquote id="1">No longer bold</blockquote>
 
注释及特殊字符串
 
文档的注释部分
 
markup = "<b><!--Hey, buddy. Want to buy a used parser?--></b>"
soup = BeautifulSoup(markup)
comment = soup.b.string
comment
 
'Hey, buddy. Want to buy a used parser?'
 
type(comment)
 
bs4.element.Comment
 
Comment 对象是一个特殊类型的 NavigableString 对象:
 
comment
 
'Hey, buddy. Want to buy a used parser?'
 
但是当它出现在HTML文档中时, Comment 对象会使用特殊的格式输出:
 
print(soup.prettify())
 
<html>
 <body>
  <b>
   <!--Hey, buddy. Want to buy a used parser?-->
  </b>
 </body>
</html>
 
from bs4 import CData
cdata = CData("A CDATA block")
comment.replace_with(cdata)
print(soup.b.prettify())
 
<b>
 <![CDATA[A CDATA block]]>
</b>
 
遍历文档树
 
html_doc = """
<html><head><title>The Dormouse's story</title></head>
    <body>
<p class="title"><b>The Dormouse's story</b></p>

<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>

<p class="story">...</p>
"""
 
from bs4 import BeautifulSoup
 
soup = BeautifulSoup(html_doc,"html.parser")
 
子节点
 
一个Tag可能包含多个字符串或其它的Tag,这些都是这个Tag的子节点.Beautiful Soup提供了许多操作和遍历子节点的属性.
 
soup.head
 
<head><title>The Dormouse's story</title></head>
 
soup.title
 
<title>The Dormouse's story</title>
 
这是个获取tag的小窍门,可以在文档树的tag中多次调用这个方法.下面的代码可以获取标签中的第一个标签:
 
soup.body.b
 
<b>The Dormouse's story</b>
 
通过点取属性的方式只能获得当前名字的第一个tag:
 
soup.a
 
<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>
 
find_all方法
 
如果想要得到所有的标签,或是通过名字得到比一个tag更多的内容的时候,就需要用到 Searching the tree 中描述的方法,比如: find_all()
 
soup.find_all("a")
 
[<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
 
.contents和.children
 
head_tag = soup.head
head_tag
 
<head><title>The Dormouse's story</title></head>
 
head_tag.contents
 
[<title>The Dormouse's story</title>]
 
head_tag.contents[0]
 
<title>The Dormouse's story</title>
 
head_tag.contents[0].contents
 
["The Dormouse's story"]
 
selenium
 
 
 
 
selenium官方文档 https://www.selenium.dev/selenium/docs/api/py/api.html
 
 
selenium介绍
 
chrome浏览器的运行效果
 
 
 
在下载好chromedriver以及安装好selenium模块后，执行下列代码并观察运行的过程
 
 
from selenium import webdriver 

# 如果driver没有添加到了环境变量，则需要将driver的绝对路径赋值给executable_path参数
# driver = webdriver.Chrome(executable_path='/home/worker/Desktop/driver/chromedriver')

# 如果driver添加了环境变量则不需要设置executable_path
driver = webdriver.Chrome()

# 向一个url发起请求
driver.get("http://www.itcast.cn/")

# 把网页保存为图片，69版本以上的谷歌浏览器将无法使用截图功能
# driver.save_screenshot("itcast.png")

print(driver.title) # 打印页面的标题

# 退出模拟浏览器
driver.quit() # 一定要退出！不退出会有残留进程！
 
phantomjs无界面浏览器的运行效果
 
 
 
PhantomJS 是一个基于Webkit的“无界面”(headless)浏览器，它会把网站加载到内存并执行页面上的 JavaScript。下载地址：http://phantomjs.org/download.html
 
 
from selenium import webdriver 

# 指定driver的绝对路径
driver = webdriver.PhantomJS(executable_path='/home/worker/Desktop/driver/phantomjs') 
# driver = webdriver.Chrome(executable_path='/home/worker/Desktop/driver/chromedriver')

# 向一个url发起请求
driver.get("http://www.itcast.cn/")

# 把网页保存为图片
driver.save_screenshot("itcast.png")

# 退出模拟浏览器
driver.quit() # 一定要退出！不退出会有残留进程！
 
无头浏览器与有头浏览器的使用场景
 
通常在开发过程中我们需要查看运行过程中的各种情况所以通常使用有头浏览器
在项目完成进行部署的时候，通常平台采用的系统都是服务器版的操作系统，服务器版的操作系统必须使用无头浏览器才能正常运行
 
selenium的作用和工作原理
 
 
 
利用浏览器原生的API，封装成一套更加面向对象的Selenium WebDriver API，直接操作浏览器页面里的元素，甚至操作浏览器本身（截屏，窗口大小，启动，关闭，安装插件，配置证书之类的）
 
 
selenium的安装以及简单使用
 
 
 
以edge浏览器为例 参见这个blog哦，驱动chrome浏览器同理
 selenium驱动edge浏览器
 
 
chromedriver环境的配置 
  
windows环境下需要将 chromedriver.exe 所在的目录设置为path环境变量中的路径
linux/mac环境下，将 chromedriver 所在的目录设置到系统的PATH环境值中
 
 
selenium的简单使用
 
 
 
接下来我们就通过代码来模拟百度搜索
 
 
import time
from selenium import webdriver

# 通过指定chromedriver的路径来实例化driver对象，chromedriver放在当前目录。
# driver = webdriver.Chrome(executable_path='./chromedriver')
# chromedriver已经添加环境变量
driver = webdriver.Chrome()

# 控制浏览器访问url地址
driver.get("https://www.baidu.com/")

# 在百度搜索框中搜索'python'
driver.find_element_by_id('kw').send_keys('python')
# 点击'百度搜索'
driver.find_element_by_id('su').click()

time.sleep(6)
# 退出浏览器
driver.quit()
 
webdriver.Chrome(executable_path='./chromedriver')中executable参数指定的是下载好的chromedriver文件的路径
driver.find_element_by_id('kw').send_keys('python')定位id属性值是’kw’的标签，并向其中输入字符串’python’
driver.find_element_by_id('su').click()定位id属性值是su的标签，并点击 
  
click函数作用是：触发标签的js的click事件
 
 
值是’kw’的标签，并向其中输入字符串’python’
 
driver.find_element_by_id('su').click()定位id属性值是su的标签，并点击
click函数作用是：触发标签的js的click事件
 
 
 
使用xpath来提取数据，爬取数据的简单语法。
 
 
lxml
 
 
 
 
requests官方文档 https://lxml.de/
 
 
pip install lxml
 
导入模块
 
from lxml import etree
 
利用xpath获取text或者href内容
 
/li/a/@href 这样取的应该是href的内容
/li/a/text() 这样取得是text内容
 
etree的使用
 
h=etree.HTML(response.text)#response.text是网页的源码
h.xpath('//img')  #寻找所有的img结点,
h.xpath('//div').xpath('.//img')#寻找所有div下的所有img结点

xpath的语法
 
符号
 XPath 使用路径表达式在 XML 文档中选取节点。节点是通过沿着路径或者 step 来选取的。
 

 
表达式
描述
/
从根节点选取
//
从匹配选择的当前节点选择文档中的节点，而不考虑它们的位置。
.
选取当前节点。
. .
选取当前节点的父节点。
@
选取属性。
|
在两个中结点中选择
（）
用()来包含|
*
包含所有元素
not
取反
 
实例
 

 
路径表达式
结果
bookstore
选取 bookstore 元素的所有子节点。
/bookstore
选取根元素 bookstore。注释：假如路径起始于正斜杠( / )，则此路径始终代表到某元素的绝对路径！
bookstore/book
选取属于 bookstore 的子元素的所有 book 元素。
//book
选取所有 book 子元素，而不管它们在文档中的位置。
bookstore//book
选择属于 bookstore 元素的后代的所有 book 元素，而不管它们位于 bookstore 之下的什么位置。
//@lang
选取名为 lang 的所有属性。
//*[@class]
选取带有class属性的所有元素
//div[@*]
匹配任意属性的div元素
//a[not(@class)]
匹配没有class属性的a元素
 
谓语
 带谓语的路径表达式
 

 
路径表达式
结果
/bookstore/book[1]
选取属于 bookstore 子元素的第一个 book 元素。
/bookstore/book[last()]
选取属于 bookstore 子元素的最后一个 book 元素。
/bookstore/book[last()-1]
选取属于 bookstore 子元素的倒数第二个 book 元素。
/bookstore/book[position()< 3]
选取最前面的两个属于 bookstore 元素的子元素的 book 元素。
//title[@lang]
选取所有拥有名为 lang 的属性的 title 元素。
//title[@lang=‘eng’]
选取所有 title 元素，且这些元素拥有值为 eng 的 lang 属性。
/bookstore/book[price>35.00]
选取 bookstore 元素的所有 book 元素，且其中的 price 元素的值须大于 35.00。
/bookstore/book[price>35.00]/title
选取 bookstore 元素中的 book 元素的所有 title 元素，且其中的 price 元素的值须大于 35.00。
 

 

 
 
 
 
到这里就结束了，如果对你有帮助你。当然学无止境，这些只是爬虫的基础，更多姿势需要你自己去探索呦。https://beishan.blog.csdn.net/
 
 
Tableau数据分析-Chapter01条形图、堆积图、直方图
Tableau数据分析-Chapter02数据预处理、折线图、饼图
Tableau数据分析-Chapter03基本表、树状图、气泡图、词云
Tableau数据分析-Chapter04标靶图、甘特图、瀑布图
Tableau数据分析-Chapter05数据集合并、符号地图
Tableau数据分析-Chapter06填充地图、多维地图、混合地图
Tableau数据分析-Chapter07多边形地图、背景地图
Tableau数据分析-Chapter08数据分层、数据分组、数据集
Tableau数据分析-Chapter09粒度、聚合与比率
Tableau数据分析-Chapter10 人口金字塔、漏斗图、箱线图
Tableau数据分析-Chapter11 范围-线图、倾斜图
Tableau数据分析-Chapter12 网络图、弧线图
Tableau数据分析-Chapter13雷达图、凹凸图
Tableau数据分析-Chapter14线性回归、时间序列分析

Requests: 让 HTTP 服务人类
 
安装 Requests
 
打开终端,使用pip安装
 
pip install requests
 
这可能会比较慢或者失败，如果失败可以尝试下面这个
 
pip install requests -i https://pypi.tuna.tsinghua.edu.cn/simple
 
如果你没有安装 pip （啧啧）,那就看下面的
 
下载zip包
 git地址
 
获得源码之后可以解压到 python 包里，或者安装到你的 site-packages然后回到终端，切换到该目录执行 python setup.py install
 
Requests基本使用
 
发送请求
 
>>>import requests
>>>r = requests.get('https://api.github.com/events')
>>>r = requests.post('http://httpbin.org/post', data = {'key':'value'})
>>>r = requests.put('http://httpbin.org/put', data = {'key':'value'})
>>>r = requests.delete('http://httpbin.org/delete')
>>>r = requests.head('http://httpbin.org/get')
>>>r = requests.options('http://httpbin.org/get')
 
传递 URL 参数
 
>>>payload = {'key1': 'value1', 'key2': 'value2'}#值为None则不添加
>>>r = requests.get("http://httpbin.org/get",params=payload)
>>>r.url
#http://httpbin.org/get?key2=value2&key1=value1
 
响应内容
 
>>>import requests
>>>r = requests.get('https://api.github.com/events')
>>>r.text
#u'[{"repository":{"open_issues":0,"url":"https://github.com/...
>>>r.encoding#查看编码
#'utf-8'
>>>r.encoding = 'ISO-8859-1'#设置编码，每次相应都以设置的编码响应
>>>r.content #二进制响应内容
>>>r.json()#JSON相应内容
>>>r.raw #原始响应内容
>>>r.status_code#响应状态码
>>> r.status_code == requests.codes.ok
>>> r.raise_for_status()#如果是错误请求(一个 4XX 客户端错误，或者 5XX 服务器错误响应)则抛出异常
 
定制请求头
 
header 值必须是 string、bytestring 或者 unicode
 
>>>url = 'https://api.github.com/some/endpoint'
>>>headers = {'user-agent': 'my-app/0.0.1'}
>>>r = requests.get(url, headers=headers)
 
响应头
 
>>> r.headers#查看响应头
>>> r.headers['Content-Type']
#'application/json'
>>> r.headers.get('content-type')
#'application/json
 
Cookie
 
>>> url = 'http://example.com/some/cookie/setting/url'
>>> r = requests.get(url)
>>> r.cookies['example_cookie_name']
'example_cookie_value'
>>> url = 'http://httpbin.org/cookies'
>>> cookies = dict(cookies_are='working')#设置
>>> r = requests.get(url, cookies=cookies)#发送
>>> r.text
'{"cookies": {"cookies_are": "working"}}'
 
超时
 
>>> requests.get('http://github.com', timeout=1)
 
timeout 仅对连接过程有效，与响应体的下载无关
 
错误与异常
 
遇到网络问题（如：DNS 查询失败、拒绝连接等）时，Requests 会抛出一个 ConnectionError 异常
 
如果 HTTP 请求返回了不成功的状态码， Response.raise_for_status() 会抛出一个 HTTPError 异常
 
若请求超时，则抛出一个 Timeout异常
 
若请求超过了设定的最大重定向次数，则会抛出一个 TooManyRedirects 异常
 
所有Requests显式抛出的异常都继承自 requests.exceptions.RequestException

报错信息
 
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "D:\python\lib\site-packages\requests-2.18.3-py2.7.egg\requests\api.py", line 72, in get
return request('get', url, params=params, **kwargs)
File "D:\python\lib\site-packages\requests-2.18.3-py2.7.egg\requests\api.py", line 58, in request
return session.request(method=method, url=url, **kwargs)
File "D:\python\lib\site-packages\requests-2.18.3-py2.7.egg\requests\sessions.py", line 508, in request
resp = self.send(prep, **send_kwargs)
File "D:\python\lib\site-packages\requests-2.18.3-py2.7.egg\requests\sessions.py", line 640, in send
history = [resp for resp in gen] if allow_redirects else []
File "D:\python\lib\site-packages\requests-2.18.3-py2.7.egg\requests\sessions.py", line 218, in resolve_redirects
**adapter_kwargs
File "D:\python\lib\site-packages\requests-2.18.3-py2.7.egg\requests\sessions.py", line 618, in send
r = adapter.send(request, **kwargs)
File "D:\python\lib\site-packages\requests-2.18.3-py2.7.egg\requests\adapters.py", line 506, in send
raise SSLError(e, request=request)
requests.exceptions.SSLError: HTTPSConnectionPool(host='www.baidu.com', port=443): Max retries exceeded with url: / (Caused by SSLError(SSLError(1, u'[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed (_ssl.c:581)'),))
 
 
 
 
 
 
 
 
 
 
 
过程
 
测试1
 
不指定headers时GET:
 
>>> import requests
>>> requests.get('http://www.baidu.com/')
<Response [200]>
>>> requests.get('http://www.baidu.com/')
<Response [200]>
>>> requests.get('http://www.baidu.com/')
<Response [200]>
>>> header = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:40.0) Gecko/20100101 Firefox/40.1',}
>>> requests.get('http://www.baidu.com/', headers = header)
<Response [200]>
 
 
 
 
 
 
 
 
 
 
测试2
 
当指定headers的User-Agent为火狐浏览器时:
 
>>> header = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:40.0) Gecko/20100101 Firefox/40.1',}
>>> requests.get('http://www.baidu.com/', headers = header)
<Response [200]>
>>> requests.get('http://www.baidu.com/', headers = header)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "D:\python\lib\site-packages\requests-2.18.3-py2.7.egg\requests\api.py", line 72, in get
return request('get', url, params=params, **kwargs)
File "D:\python\lib\site-packages\requests-2.18.3-py2.7.egg\requests\api.py", line 58, in request
return session.request(method=method, url=url, **kwargs)
File "D:\python\lib\site-packages\requests-2.18.3-py2.7.egg\requests\sessions.py", line 508, in request
resp = self.send(prep, **send_kwargs)
File "D:\python\lib\site-packages\requests-2.18.3-py2.7.egg\requests\sessions.py", line 640, in send
history = [resp for resp in gen] if allow_redirects else []
File "D:\python\lib\site-packages\requests-2.18.3-py2.7.egg\requests\sessions.py", line 218, in resolve_redirects
**adapter_kwargs
File "D:\python\lib\site-packages\requests-2.18.3-py2.7.egg\requests\sessions.py", line 618, in send
r = adapter.send(request, **kwargs)
File "D:\python\lib\site-packages\requests-2.18.3-py2.7.egg\requests\adapters.py", line 506, in send
raise SSLError(e, request=request)
requests.exceptions.SSLError: HTTPSConnectionPool(host='www.baidu.com', port=443): Max retries exceeded with url: / (Caused by SSLError(SSLError(1, u'[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed (_ssl.c:581)'),))
 
 
 
 
 
 
 
 
 
 
分析
 
现象:第一次GET时正常,第二次GET时,会报错.
 
不同点:User-Agent不相同
 
分析:由于报错SSL证书验证失败,所以这次的访问应该是https协议.但是我们明明使用的是http,所以,猜测访问该网站后,被重定向到了https://www.baidu.com/
 
验证
 
首先,进行GET时,关闭证书验证.因为,如果不关闭,请求总是失败,不能获取到重定向的信息.
 
>>> response = requests.get('http://www.baidu.com/', headers = header, verify=False)
D:\python\lib\site-packages\urllib3\connectionpool.py:858: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings
InsecureRequestWarning)
>>> response.history
[<Response [302]>]
>>> response.url
u'https://www.baidu.com/'
 
 
 
 
 
 
 
 
 
 
当不指定User-Agent时
 
>>> response = requests.get('http://www.baidu.com/', verify=False)
>>> response.history
[]
>>> response.url
u'http://www.baidu.com/'
 
 
 
 
 
 
 
 
 
 
结论
 
当指定headers的User-Agent时,baidu的服务器会重定向到https的网址.因此报出SSL验证失败的错误.
 
解决方法
 
方法1:
 
在进行GET时,指定SSL证书.详情见附件
 
方法2:
 
关闭证书验证. 详情见附件
 
 
 
附件
 
[各浏览器的User-Agent]  http://www.useragentstring.com/pages/useragentstring.php
 
[SSL 证书验证]  https://requests.readthedocs.io/zh_CN/latest/user/advanced.html#ssl
 
 
 
 
 
 
 
 
 

   
 
 

 👻上一篇博文一篇万字博文带你入坑爬虫这条不归路（你还在犹豫什么&抓紧上车） 【❤️熬夜整理&建议收藏❤️】被众多爬虫爱好者/想要学习爬虫的小伙伴们阅读之后，很多小伙伴私信我说——大佬搞爬虫都是用的socket套接字嘛？👻
 
 😬（苦笑）“那肯定不是啊！python为我们封装了那么多伟大而又简单实用的爬虫库，”不过我想说的是，“ 学啥技术都是从底层抓起，万丈高楼平地起，它也是基于地基稳！ 所以在入坑文中简单地介绍使用了下底层爬虫库——socket！”😬
 
 😜而本文，本博主就带领小伙伴们认真地学习一下Python中一大广为使用的爬虫库——Requests——专为人类而构建；有史以来下载次数最多的Python软件包之一！😜
 
 
 
             重点来啦！重点来啦！！ 💗💗💗
 
  相信有不少小伙伴已经通过我的上篇博文入坑爬虫，而本篇文讲解的Requests库也是学习爬虫之路的一大最为重要的知识点，在我们日后的爬虫开发中使用的最多的也是它哦！
学好Requests，你的爬虫之路日后将畅通无阻！！！
 
 


 
❤️两万字Requests库详解❤️
 
1.简介
2.发起请求
参数详解：
（1）请求方法method：
（2）统一资源定位符url
（3）传递url参数params
（4）传递form表单数据——data
（5）传递json数据——json
（6）自定义headers
（7）自定义cookies
①获取cookies：
②使用Cookie维持登录状态的两种方法：
    
（8）设置代理proxies
（9）重定向allow_redirects
（10）禁止证书验证vertify
（11）设置超时timeout
拓展：
    
（12）文件上传
（13）Prepared Request
   
总结：
  
3.接收响应
（1）响应内容
（2）字符编码
（3）二进制数据
（4）json数据
（5）状态码
（6）响应报头
（7）服务器返回的cookies
（8）查看响应的url
总结：
  
4.使用requests库进行实战：
（1）基操 之 实战项目一：进行百度贴吧指定搜索内容获取到的html源码头5页的爬取！
①上代码：
②实现效果：
   
（2）升级版操作 之 实战项目二：使用session实现人人网登录状态维持
①上代码：
②实现效果：
  
  
5.In The End！

 
 
1.简介
 
Requests是一个优雅而简单的Python HTTP库，专为人类而构建。
 
Requests是有史以来下载次数最多的Python软件包之一，每天下载量超过400,000次。
 
  之前的urllib（后面会更新文章讲解哦——敬请期待！）做为Python的标准库，因为历史原因，使用的方式可以说是非常的麻烦而复杂的，而且官方文档也十分的简陋，常常需要去查看源码。与之相反的是，Requests的使用方式非常的简单、直观、人性化，让程序员的精力完全从库的使用中解放出来。
 
  Requests的官方文档同样也非常的完善详尽，而且少见的有中文官方文档&&英文官方文档。
 
 
2.发起请求
 
根据入坑文可知爬虫：模拟浏览器发送请求，获取响应。那么首先我们就要学会使用Requests发起请求！
 
  Requests的请求不再像urllib一样需要去构造各种Request、opener和handler，直接使用Requests构造的方法，并在其中传入需要的参数即可。
 
源码：
def request(method, url,params=None, data=None, headers=None, cookies=None,
    timeout=None, allow_redirects=True, proxies=None,verify=None,  json=None):
 
参数详解：
 
（1）请求方法method：
 
每一个请求方法都有一个对应的API，比如GET请求就可以使用get()方法：
 
 而POST请求就可以使用post()方法，并且将需要提交的数据传递给data参数即可：
 
 而其他的请求类型，都有各自对应的方法：
 
 
知识点补给站——POST请求方法的小知识点：
	应用场景：登录注册
	需要传输大文本内容的时候使用（post请求对长度没有要求）。
 
 
（2）统一资源定位符url
 
URL（Universal Resource Locator），即统一资源定位符。
 
 
（3）传递url参数params
 
  传递URL参数也不用再像urllib中那样需要去拼接URL，而是简单的，构造一个字典，并在请求时将其传递给params参数：
 
import requests
params = {'key': 'value1', 'key2': 'value2'}
resp = requests.get("http://httpbin.org/get", params=params)
print(resp.url)
 
 
小知识点：
   有时候我们会遇到相同的url参数名，但有不同的值，而python的字典又不支持键的重名，那么我们可以把键的值用列表表示：
 
import requests
params = {'key': 'value1', 'key2': ['value2', 'value3']}
resp = requests.get("http://httpbin.org/get", params=params)
print(resp.url)
 
 
知识点补给站：
	本文大多使用的URL站点是httpbin.org，它可以提供HTPP请求测试哦！
 
（4）传递form表单数据——data
 
  将放进data的数据转换为form表单数据,同时不能传json数据，json数据为null。（注意：json和data二者只能同时存在其一）
 
 
（5）传递json数据——json
 
  将json对应的数据放进json参数里。
 
 
（6）自定义headers
 
是不是很熟悉，这就是反爬第一阶段常用套路！
 
  如果想自定义请求的Headers，同样的将字典数据传递给headers参数。
 
 
（7）自定义cookies
 
 
①获取cookies：
 
第一种方法：
 
import requests
from fake_useragent import UserAgent

r = requests.get('https://www.baidu.com',headers = {'User-Agent': UserAgent().random})
print(r.cookies)

print('*'*25)
print(r.cookies.items())
print('*'*25)

for key,value in r.cookies.items():
    print(key + "=" + value)
 
 
  此处我们首先调用cookies属性即可成功得到cookies，可以发现他是个RequestsCookieJar类型。然后用items()方法将其转化为元组组成的列表，遍历输出每一个Cookie的名称和值，实现Cookie的遍历解析。
 
 
第二种方法：
 
  使用requests.utils.dict_from_cookiejar:把cookiejar对象转化为字典。
 
import requests
from fake_useragent import UserAgent

url = 'http://www.baidu.com'
response = requests.get(url=url, headers ={'user-agent': UserAgent().random})
cookie = requests.utils.dict_from_cookiejar(response.cookies)
print(cookie)

"""
输出：
{'BAIDUID_BFESS': '52EB4182E0877DFD9DBA8E0793772027:FG=1', 'H_PS_PSSID': '33802_34222_31254_33848_34112_34107_26350_34093', 'BDSVRTM': '0', 'BD_HOME': '1'}
"""
 
 
②使用Cookie维持登录状态的两种方法：
 
  第一种方法： 请求头中加入网页复制的cookie来维持登录状态！
 
实战之以QQ空间为例来说明：
 （如何在网页中获取Cookie：首先登录QQ空间，将Headers中的Cookie内容复制即可！）
 
import requests

headers = {
    'cookie': '此处换为你自己的Cookie即可！',
    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.89 Safari/537.36'
}

r = requests.get('https://user.qzone.qq.com/这里写上要登录的QQ号/infocenter', headers=headers)
print(r.text)

 
我们发现，结果中包含了登录后的结果，说明我们登录成功！
 
 
  第二种方法： 通过cookies参数来设置，直接将cookies构造字典传入即可！
 
 
（8）设置代理proxies
 
 
 
什么是代理？
 代理IP是一个ip ,指的是一个代理服务器。
 
 
要晓得正向代理和反向代理是啥？
 知不知道服务器的地址做为判断标准：知道就是正向代理，不知道就是反向代理。
 
 

 3. 代理ip的分类（常见有两大分类依据：匿名度&&协议）
   ①匿名度：
    透明代理 ：目标服务器可以通过代理找到你的ip；
    匿名代理 ：两者之间；
    高匿代理 ：在爬虫中经常使用，目标服务器无法获取你的ip。
   ②协议：（根据网站使用的协议不同，需要使用响应的协议代理服务）
    http代理：目标的url为http协议；
    https代理：目标url为https协议；
    socks代理 ：只是简单的传递数据包，不关心是何种协议，比http和HTTPS代理消耗小， 可以转发http和https的请求。
 
 
为何使用代理？
 （1）让服务器以为不是同一个客户端在请求；
 （2）防止我们的真实地址被泄露，防止被追究。
 
 
用法：
   当我们需要使用代理时，同样构造代理字典，传递给proxies参数。
 
 
 
（9）重定向allow_redirects
 
  在网络请求中，我们常常会遇到状态码是3开头的重定向问题，在Requests中是默认开启允许重定向的，即遇到重定向时，会自动继续访问。
 
 
（10）禁止证书验证vertify
 
 
  有时候我们使用了抓包工具，这个时候由于抓包工具提供的证书并不是由受信任的数字证书颁发机构颁发的（比如，之前12306的整数就没有被官方CA机构信任，就会出现证书验证错误的结果！），所以证书的验证会失败，这时我们就需要关闭证书验证。
 
  解决方法：在请求的时候把verify参数设置为False就可以关闭证书验证了。
 小拓展：
   但是关闭验证后，会有一个比较烦人的warning，它建议我们给它指定证书。我们可以通过设置忽略警告的方式来屏蔽它：
 
 
（11）设置超时timeout
 
  为了防止服务器不能及时响应，而设置一个超时时间，即超过了这个时间还没有得到响应，那就报错！
   设置访问超时——设置timeout参数即可。（这个时间的计算是发出请求到服务器返回响应的时间）
   实际上：请求分为两个阶段，即连接（connect）和读取（read）。下面设置的timeout将用作连接和读取这二者的timeout总合。如果分别指定，就可以传入一个元组：timeout=(5,11,30)。
 
 
拓展：
 
实际上，我们在多数爬虫开发中——超时参数timeout是和retrying模块（刷新）一起使用的！ 
 
使用retrying模块提供的retry方法
通过装饰器的方式，让被装饰的函数反复执行
retry中可以传入参数 stop_max_attempt_number，让函数报错后继续重新执行，达到最大执行次数的上限，如果每次都报错，整个函数报错，如果中间有一个成功，程序继续往后执行
 
①代码讲解：
 
import requests
from retrying import retry

headers = {"User-Agent":"Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/532.2 (KHTML, like Gecko) Chrome/4.0.222.3 "}

@retry(stop_max_attempt_number=3)   # stop_max_attempt_number=3最大执行3次，还不成功就报错
def _parse_url(url):                                            # 前面加_代表此函数，其他地方不可调用
    print("*"*100)
    response = requests.get(url, headers=headers, timeout=3)    # timeout=3超时参数，3s内
    assert response.status_code == 200                          # assert断言，此处断言状态码是200，不是则报错
    return response.content.decode()


def parse_url(url):
    try:
        html_str = _parse_url(url)
    except Exception as e:
        print(e)
        html_str = None
    return html_str

if __name__ == '__main__':
    # url = "www.baidu.com"         # 这样是会报错的！
    url = "http://www.baidu.com"
    print(parse_url(url))
 
②实现效果一：无法爬取到的情况：url = “www.baidu.com”!
 
 
②实现效果二：正确爬取到的情况：url = “http://www.baidu.com”!
 
 
（12）文件上传
 
  假如有的网站需要上传文件，我们也可以使用requests实现！
 
当前脚本的同一目录下有个名为1.jpg的文件：
 
import requests

files = {'file': open('1.jpg','rb')}
r = requests.post("http://httpbin.org/post", files=files)
print(r.text)
 

 
   这个网站会返回响应，里面包含files这个字段，而form字段是空的，这证明文件上传部分会单独有个files字段来标识。
 
（13）Prepared Request
 
  我们知道在urllib中可以将请求表示为数据结构，其中各个参数都可以通过一个Request对象来表示。这在requests中同样可以做到，这个数据结构叫做Prepared Request。如下：
 
from requests import Request,Session

url = 'http://httpbin.org/post'
data = {
    'name':'peter'
}
headers = {
    'User-Agent':'Mozilla/5.0 (Windows; U; Windows NT 5.2; en-US) AppleWebKit/525.13 (KHTML, like Gecko) Chrome/0.2.149.29 Safari/525.13'
}

s = Session()
req = Request('POST', url, data=data, headers=headers)
prepped = s.prepare_request(req)
r = s.send(prepped)
print(r.text)
 
  先用url,data,headers参数构造了一个Request对象，这时需要再调用Session的prepare_request()方法将其转换为一个Prepared Request对象，然后调用send()方法发送即可！
 

   使用较少，但是这样使用的好处是：有了Request这个对象，就可以将请求当作独立的对象来看待，这样在进行队列调度时会非常方便！
 
 
总结：
 
import requests

# res=requests.get("http://httpbin.org/get")       #功能：发起完整的网络请求

'''
源码：
def request(method, url,params=None, data=None, headers=None, cookies=None,
    timeout=None, allow_redirects=True, proxies=None,verify=None,  json=None):
'''

#1.method
# res=requests.post("http://httpbin.org")
# res=requests.delete("http://httpbin.org")

# url  字符串  统一资源定位符

# params    将放进params里的字典数据变为url的请求参数(如果是中文会自动编码)
# test_url="http://httpbin.org/get"
# params={"name":"allen","name2":"哈哈"}
# res=requests.get(url=test_url,params=params)
# print(res.text)

# data   将放进data的数据转换为form表单数据,同时不能传json数据，json数据为null
# test_url="http://httpbin.org/post"            #post提交数据
# data={"stu":"丸子","worker":"鲸落"}
# res=requests.post(url=test_url,data=data)
# print(res.text)

# json      将json对应的数据放进json数据里
# test_url="http://httpbin.org/post"               #post提交数据
# json={"name":"selffly"}    #'{"name":"selffly"}' json串形式也可以传，字典也可以传
# res=requests.post(url=test_url,json=json)
# print(res.text)

# 添加头部信息headers       添加cookies     添加timeout     设置代理proxies=None      verify=False安全验证(为False是忽略证书)
# test_url="http://httpbin.org/get"
# headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36"}
# cookies={"sessionid":"dfsdaaagdgagdf"}
# proxies={'http':"127.0.0.1:8888"}           #这个代理胡写的，不可用
# res=requests.get(url=test_url,headers=headers,cookies=cookies,timeout=10,proxies=proxies)
# print(res.text)

# 测试重定向allow_redirects    如果为True就可以进行重定向；反之不可以
# res_bd=requests.get("http://www.baidu.com",allow_redirects=False)
# print(res_bd.text)
 
 
3.接收响应
 
根据入坑文可知爬虫：模拟浏览器发送请求，获取响应。使用requests发送请求我们OK了，下面我们要做的就是获取响应！
 
  通过Requests发起请求获取到的，是一个requests.models.Response对象。通过这个对象我们可以很方便的获取响应的内容。
 
（1）响应内容
 
requests通过text属性，可以获得字符串格式的响应内容。
 
 
（2）字符编码
 
  Requests会自动的根据响应的报头来猜测网页的编码是什么，然后根据猜测的编码来解码网页内容，基本上大部分的网页都能够正确的被解码。而如果发现text解码不正确的时候，就需要我们自己手动的去指定解码的编码格式。
 
 
（3）二进制数据
 
而如果你需要获得原始的二进制数据，那么使用content属性即可。
 
 
（4）json数据
 
如果我们访问之后获得的数据是JSON格式的，那么我们可以使用json()方法，直接获取转换成字典格式的数据。
 
 
（5）状态码
 
通过status_code属性获取响应的状态码
 
 
应用：
   状态码常用来判断请求是否成功，而requests还提供了一个内置的状态码查询对象requests.codes，如下。这里通过比较返回码和内置的成功的返回码，来保证请求得到了正常响应，输出成功请求的消息，否则程序终止，这里我们用requests.codes.ok得到的是成功的状态码200。其实我们直接和200判断就好了！不过像下面这样写B格高！
 
import requests
r = requests.get('https://www.baidu.com')
print('内置的成功的返回码：',requests.codes.ok)
print('状态码：',r.status_code)
exit() if not r.status_code == requests.codes.ok else print('Request Successfully')
 
 
（6）响应报头
 
通过headers属性获取响应的报头
 
 
（7）服务器返回的cookies
 
通过cookies属性获取服务器返回的cookies
 
 
（8）查看响应的url
 
还可以使用url属性查看访问的url。
 
 
总结：
 
import requests

res=requests.get("http://www.baidu.com")	#发起完整的网络请求
print(res.content)      #字节码格式   图片，视频数据等
res.encoding="utf-8"    #乱码需要解码，修改编码方式
print(res.text)         #字符串格式  非字节码
print(res.status_code)  #状态码
print(res.url)          #获取响应的url
print(res.cookies)      #获取cookies

res=requests.get("http://httpbin.org/get")
print(res.json()["headers"]["User-Agent"])      #使用json()方法将数据变为字典格式
print(res.headers)    #获取响应报头

# 拓展：还可以使用方法获取请求的一些数据：
print("请求头：",res.request.headers)
print("请求的url",res.request.url)
print("请求的cookie",res.request._cookie)    # 返回cookiejar类型
 
 
4.使用requests库进行实战：
 
（1）基操 之 实战项目一：进行百度贴吧指定搜索内容获取到的html源码头5页的爬取！
 
①上代码：
 
import os
import requests

'''
为了构造正确的url！！！
进入百度贴吧进行测试，任意搜索一个信息，通过不同页更换，观察url找寻规律：
https://tieba.baidu.com/f?kw=美食&ie=utf-8&pn=0
https://tieba.baidu.com/f?kw=美食&ie=utf-8&pn=50
https://tieba.baidu.com/f?kw=美食&ie=utf-8&pn=100
https://tieba.baidu.com/f?kw=美食&ie=utf-8&pn=150
'''

class TiebaSpider:
    def __init__(self,tieba_name):
        self.tieba_name = tieba_name
        self.url_temp = "https://tieba.baidu.com/f?kw="+tieba_name+"&ie=utf-8&pn={}"
        self.headers = {"User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.89 Safari/537.36"}

    # 构造url列表
    def get_url_list(self):
        return [self.url_temp.format(i*50) for i in range(5)]

    # 发送请求，获取响应
    def parse_url(self,url):
        response = requests.get(url,headers=self.headers)
        return response.content.decode()

    # 保存
    def save_html_str(self, html_str, page_num):
        file_path = "{}_第{}页.html".format(self.tieba_name, page_num)
        dir = 'ceshi'
        if not os.path.exists(dir):
            os.mkdir(dir)
        file_path = dir + '/' + file_path
        with open(file_path, "w", encoding='utf-8') as f:
            f.write(html_str)
        print("保存成功！")

    # 实现主要逻辑
    def run(self):
        # 构造url列表
        url_list = self.get_url_list()
        # 发送请求，获取响应
        for url in url_list:
            html_str = self.parse_url(url)
            # 保存
            page_num = url_list.index(url)+1
            self.save_html_str(html_str, page_num)

if __name__ == '__main__':
    name_date = input("请输入你想知道的内容：")
    tieba_spider = TiebaSpider(name_date)
    tieba_spider.run()
 
②实现效果：
 
 
 
（2）升级版操作 之 实战项目二：使用session实现人人网登录状态维持
 
requests模拟登陆的三种方法：
 
					   1.session：
					        实例化对象
					        session.get(url) #cookie保存在session中
					        session.get(url) #带上保存在session中cookie
					
					   2.cookie方法在headers中
					   3.cookie传递给cookies参数：
					        cookie = {"cookie 的name的值":"cookie 的value对应的值"}
 
①上代码：
 
import requests

# 1.实例化session
session = requests.Session()

# 2. 使用session发送post请求，对方服务器会把cookie设置在session中
headers = {"User-Agent":"Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/532.2 (KHTML, like Gecko) Chrome/4.0.222.3 "}
post_url = "http://www.renren.com/PLogin.do"
post_data = {"email":"自己的账号","password":"自己的密码"}

session.post(post_url,data=post_data,headers=headers)

# 3.请求个人主页，会带上之前的cookie，能够请求成功
profile_url = "http://www.renren.com/自己进自己主页会有的/profile"
response = session.get(profile_url,headers=headers)

with open("renren.html", "w", encoding="utf-8") as f:
    f.write(response.content.decode())

 
②实现效果：
 
 
5.In The End！
 
 
从现在做起，坚持下去，一天进步一小点，不久的将来，你会感谢曾经努力的你！
 
 本博主会持续更新爬虫基础分栏及爬虫实战分栏，认真仔细看完本文的小伙伴们，可以点赞收藏并评论出你们的读后感。并可关注本博主，在今后的日子里阅读更多爬虫文！
 
	如有错误或者言语不恰当的地方可在评论区指出，谢谢！
	如转载此文请联系我说明用以意并标注出处及本博主名，谢谢！