精华内容
下载资源
问答
  • 文章目录requestsrequests基础requests模块发送get请求response响应对象response.text 和response.content的区别解决中文乱码response响应对象的其它常用属性或方法requests实操requests模块发送请求发送带参数的...

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

    在这里插入图片描述

    记得安装快速第三方库,Python经常需要安装第三方库,原始的下载速度很慢,使用国内的镜像就很快啦

    pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名
    

    快速下载模块

    官方网址:

    1. Requests: 让 HTTP 服务人类
    2. Beautiful Soup 4.4.0 文档
    3. Selenium官网
    4. 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()) # 注意这里!
    
    1. response.text是requests模块按照chardet模块推测出的编码字符集进行解码的结果
    2. 网络传输的字符串都是bytes类型的,所以response.text = response.content.decode(‘推测出的编码字符集’)
    3. 我们可以在网页源码中搜索charset,尝试参考该编码字符集,注意存在不准确的情况

    response.text 和response.content的区别

    1. response.text
      • 类型:str
      • 解码类型: requests模块自动根据HTTP 头部对响应的编码作出有根据的推测,推测的文本编码
    2. 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的使用

    在平时网上冲浪的过程中,我们经常会遇到网络波动,这个时候,一个请求等了很久可能任然没有结果。

    在爬虫中,一个请求很久没有结果,就会让整个项目的效率变得非常低,这个时候我们就需要对请求进行强制要求,让他必须在特定的时间内返回结果,否则就报错。

    1. 超时参数timeout的使用方法

      response = requests.get(url, timeout=3)

    2. 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']
    

    可以遍历的字符串

    1. 字符串常被包含在tag内.Beautiful Soup用 NavigableString 类来包装tag中的字符串:
    tag.string
    
    'Extremely bold'
    
    type(tag.string)
    
    bs4.element.NavigableString
    
    1. 一个 NavigableString 字符串与Python中的Unicode字符串相同,
      并且还支持包含在遍历文档树 和 搜索文档树 中的一些特性.
      通过 unicode() 方法可以直接将 NavigableString 对象转换成Unicode字符串:

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

    tag.string.replace_with("No longer bold")
    tag
    
    <blockquote id="1">No longer bold</blockquote>
    

    注释及特殊字符串

    1. 文档的注释部分
    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
    
    1. 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/

    1. Tableau数据分析-Chapter01条形图、堆积图、直方图
    2. Tableau数据分析-Chapter02数据预处理、折线图、饼图
    3. Tableau数据分析-Chapter03基本表、树状图、气泡图、词云
    4. Tableau数据分析-Chapter04标靶图、甘特图、瀑布图
    5. Tableau数据分析-Chapter05数据集合并、符号地图
    6. Tableau数据分析-Chapter06填充地图、多维地图、混合地图
    7. Tableau数据分析-Chapter07多边形地图、背景地图
    8. Tableau数据分析-Chapter08数据分层、数据分组、数据集
    9. Tableau数据分析-Chapter09粒度、聚合与比率
    10. Tableau数据分析-Chapter10 人口金字塔、漏斗图、箱线图
    11. Tableau数据分析-Chapter11 范围-线图、倾斜图
    12. Tableau数据分析-Chapter12 网络图、弧线图
    13. Tableau数据分析-Chapter13雷达图、凹凸图
    14. Tableau数据分析-Chapter14线性回归、时间序列分析
    展开全文
  • Requests

    千次阅读 2020-07-02 16:05:21
    安装 Requests 打开终端,使用pip安装 pip install requests 如果你没有安装 pip (啧啧),那就看下面的 点这个链接下载包 或者执行以下命令获取包 curl -OL https://github.com/requests/requests/tarball/master ...

    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 值必须是 stringbytestring 或者 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 "", line 1, in 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

    报错信息

    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

     

     

     

     
    展开全文
  • 两万字博文教你python爬虫requests库【详解篇】

    万次阅读 多人点赞 2021-07-12 09:00:11
      Requests的请求不再像urllib一样需要去构造各种Request、opener和handler,直接使用Requests构造的方法,并在其中传入需要的参数即可。 源码: def request(method, url,params=None, data=None, headers=None,...

     👻上一篇博文一篇万字博文带你入坑爬虫这条不归路(你还在犹豫什么&抓紧上车) 【❤️熬夜整理&建议收藏❤️】被众多爬虫爱好者/想要学习爬虫的小伙伴们阅读之后,很多小伙伴私信我说——大佬搞爬虫都是用的socket套接字嘛?👻

     😬(苦笑)“那肯定不是啊!python为我们封装了那么多伟大而又简单实用的爬虫库,”不过我想说的是,“ 学啥技术都是从底层抓起,万丈高楼平地起,它也是基于地基稳! 所以在入坑文中简单地介绍使用了下底层爬虫库——socket!”😬

     😜而本文,本博主就带领小伙伴们认真地学习一下Python中一大广为使用的爬虫库——Requests——专为人类而构建;有史以来下载次数最多的Python软件包之一!😜

    在这里插入图片描述


                 重点来啦!重点来啦!! 💗💗💗

      相信有不少小伙伴已经通过我的上篇博文入坑爬虫,而本篇文讲解的Requests库也是学习爬虫之路的一大最为重要的知识点,在我们日后的爬虫开发中使用的最多的也是它哦!

    学好Requests,你的爬虫之路日后将畅通无阻!!!


    在这里插入图片描述

    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

    在这里插入图片描述

    1. 什么是代理?
      代理IP是一个ip ,指的是一个代理服务器。

    2. 要晓得正向代理和反向代理是啥?
      知不知道服务器的地址做为判断标准:知道就是正向代理,不知道就是反向代理。

    在这里插入图片描述
    3. 代理ip的分类(常见有两大分类依据:匿名度&&协议)
      ①匿名度:
       透明代理 :目标服务器可以通过代理找到你的ip;
       匿名代理 :两者之间;
       高匿代理 :在爬虫中经常使用,目标服务器无法获取你的ip。
      ②协议:(根据网站使用的协议不同,需要使用响应的协议代理服务)
       http代理:目标的url为http协议;
       https代理:目标url为https协议;
       socks代理 :只是简单的传递数据包,不关心是何种协议,比http和HTTPS代理消耗小, 可以转发http和https的请求。

    1. 为何使用代理?
      (1)让服务器以为不是同一个客户端在请求;
      (2)防止我们的真实地址被泄露,防止被追究。

    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模块(刷新)一起使用的!
    1. 使用retrying模块提供的retry方法
    2. 通过装饰器的方式,让被装饰的函数反复执行
    3. 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!

    在这里插入图片描述

    从现在做起,坚持下去,一天进步一小点,不久的将来,你会感谢曾经努力的你!

    本博主会持续更新爬虫基础分栏及爬虫实战分栏,认真仔细看完本文的小伙伴们,可以点赞收藏并评论出你们的读后感。并可关注本博主,在今后的日子里阅读更多爬虫文!

    	如有错误或者言语不恰当的地方可在评论区指出,谢谢!
    	如转载此文请联系我说明用以意并标注出处及本博主名,谢谢!
    
    展开全文
  • Python-第三方库requests详解

    万次阅读 多人点赞 2016-03-16 11:45:15
    Requests 是用Python语言编写,基于 urllib,采用 Apache2 ...Requests 的哲学是以 PEP 20 的习语为中心开发的,所以它比 urllib 更加 Pythoner。更重要的一点是它支持 Python3 哦! 希望我的博客对您有用。 阿...
  • 知识点讲解二:关于requests里的timeout()

    万次阅读 多人点赞 2018-08-18 22:29:18
    在默认情况下,除非显式指定了 timeout 值,requests 是不会自动进行超时处理的。如果没有 timeout,你的代码可能会挂起若干分钟甚至更长时间。 连接超时指的是在你的客户端实现到远端机器端口的连接时(对应...
  • Pycharm 报No module named ‘requests‘错的解决办法

    万次阅读 多人点赞 2019-07-01 15:32:22
    1、首先检查是否安装了requests l安装命令: pip install requests 如果出现了Requirement already satisfied代表安装成功 l或pip list显示安装 2、PyCharm配置问题(项目的解释器配置问题) ①解决办法:...
  • requests 安装包

    2016-11-17 14:25:17
    requests安装包
  • 【Python3】requests设置代理

    万次阅读 2018-05-14 19:54:21
    import requests proxies = {'http': 'http://localhost:8888', 'https': 'http://localhost:8888'} requests.post(url, data=body, headers=myouheader, proxies=proxies, verify=False) #verify是否验证服务器的...
  • 文章目录一、环境与工具二、学爬虫必备知识三、requests体验四、get 请求3.1 基础讲解一3.3 基础讲解二3.2 基础讲解三3.4 获取cookie3.5 获取请求头3.6 添加请求头3.5 知乎爬取+反扒技术3.6 抓取二进制数据3.6.1 ...
  • Requests简明教程

    万次阅读 2021-03-30 09:07:00
    本教程基于Requests V2.18.1文档汇编、整理。 一、简介 Requests是一个基于urllib3的开源Python HTTP库,项目以Apache2协议发布。 二、安装 $ pip install requests 三、快速上手 3.1 发送请求 # 导入requests >&...
  • Python requests timeout 分析

    万次阅读 2020-09-26 12:58:28
    最近在搞爬虫,很多小组件里面都使用了 Python 的 requests 库,很好用,很强大。 但最近发现很多任务总是莫名其妙的卡住,不报错,但是就是不继续执行。 排查了一圈,最后把问题锁定在 requests 的 timeout 机制上...
  • pip install requests 之后依然提示 Python ImportError: No module named 'requests' 经过文件搜索和提示,发现是因为安装目录不正确。 一定要切到Python的主目录下安装。如果已经安装,那么找到现在的安装...
  • 网络库requests 其实,我们有专门的网络库进行直接的网络请求与处理,它就是requests库。在我们开始讲解与使用之前,需要通过如下命令进行安装: pip install requests 首先,我们先来看看requests库可以进行哪些...
  • Python requests 模块

    2020-12-22 09:23:42
    文章目录requests安装 requests上手 requests发送请求响应内容二进制响应内容JSON 响应内容传递 URL 参数定义请求头POST 请求timeout 参数参考资料来源 requests Python 的内置 urllib 模块,可以用于访问资源,...
  • Requests安装

    千次阅读 2019-07-15 02:18:00
    Requests安装 pipenv安装 ​ 点击这里跳转URL pip安装 windows pip install requests linux sudo pip install requests
  • ModuleNotFoundError: No module named 'requests'

    万次阅读 多人点赞 2019-08-06 10:54:19
    Python: ImportRequestsError: No module named 'requests'解决方法 运行Python程序时,出现下面错误: import requests ModuleNotFoundError: No module named ‘requests’ 原因:没有导入requests库 解决...
  • requests模块

    千次阅读 2018-10-06 15:47:35
    requests 响应内容的处理 requests异常的处理 requests requests库是 python中非常优秀的第三方库(python2和python3中均有requests库),它使用 Apache2 Licensed 许可证的 HTTP 库,用 Python 编写。requests ...
  • Requests基础用法

    万次阅读 2018-09-26 14:56:11
    目录 发送请求 传递 URL 参数 响应内容 文本响应内容 二进制响应内容 JSON 响应内容 原始响应内容 ...使用 Requests 发送网络请求非常简单,支持的 HTTP 请求类型:GET,POST,PUT,DELE...
  • 今天小编就为大家分享一篇解决已经安装requests,却依然提示No module named 'requests'问题,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 用了些requests模块,主要是requests.request、requests.get和requests.post import json import requests url='http://localhost:8888/' response=requests.get(url) #打印响应内容 print('response.text:',...
  • REQUESTS库文档

    2017-11-05 13:51:43
    python Requests库文档,PDF版本,作者在官网上发布的。
  • python爬虫 requests异常requests.exceptions.ConnectionError: HTTPSConnectionPool Max retries exceeded   错误提示: requests.exceptions.ConnectionError: HTTPSConnectionPool(host='baike.baidu.com',...
  • import requests

    千次阅读 2019-03-22 23:28:06
    requests是python实现...pip install requests 安装完成后import一下,正常则说明可以开始使用了。 基本用法: requests.get()用于请求目标网站,类型是一个HTTPresponse类型 import requests response = requests...
  • Python requests

    2016-06-28 14:37:36
    Python requests包,经测试可以使用
  • 浅析Python requests 模块

    2020-12-16 21:57:01
    Python requests 模块  requests 模块是我们使用的 python爬虫 模块 可以完成市场进80%的爬虫需求。 安装 pip install requests 使用 requests模块代码编写的流程: – 指定url – 发起请求 – 获取响应对象中...
  • requests-html

    2018-05-09 09:47:54
    github上的大神封装,都不需要伪装useragent了,它都帮你伪装了。里面还使用了异步,亲测:特别是在循环中开启时,比单独用requests发送请求快了三分一以上。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 480,359
精华内容 192,143
关键字:

requests