精华内容
参与话题
问答
  • python request的使用

    千次阅读 2019-06-21 11:20:15
    requests库的宣言是 HTTP for Humans (给人用的 HTTP 库) 我们首先来验证一下。 在网络编程中,最最基本的任务包含: 发送请求 登录 获取数据 解析数据 反序列化打印内容 我们以 GitHub 为例,先看一下...

    初识 requests

    requests 库的宣言是

    HTTP for Humans (给人用的 HTTP 库)

    我们首先来验证一下。

    在网络编程中,最最基本的任务包含:

    • 发送请求
    • 登录
    • 获取数据
    • 解析数据
    • 反序列化打印内容

    我们以 GitHub 为例,先看一下使用 urllib2 要怎么做。为了把事情弄简单点,我们假设实现已经知道,GET 请求 https://api.github.com/ 返回的内容是个 JSON 格式的数据(实际上通过 content-type 也能判断)。

    复制

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    
    import urllib2
    import json
    
    gh_url  = 'https://api.github.com'
    cs_user = 'user'
    cs_psw  = 'password'
    
    req = urllib2.Request(gh_url)
    
    password_manager = urllib2.HTTPPasswordMgrWithDefaultRealm()
    password_manager.add_password(None, gh_url, cs_user, cs_psw)
    
    auth_manager = urllib2.HTTPBasicAuthHandler(password_manager)
    opener = urllib2.build_opener(auth_manager)
    
    urllib2.install_opener(opener)
    
    handler = urllib2.urlopen(req)
    
    if handler.getcode() == requests.codes.ok:
        text = handler.read()
        d_text = json.loads(text)
        for k, v in d_text.items():
            print k, v
    

    如果运行正确,那么代码应该返回:

    复制

    1
    2
    3
    4
    5
    6
    7
    
    issues_url https://api.github.com/issues
    current_user_repositories_url https://api.github.com/user/repos{?type,page,per_page,sort}
    rate_limit_url https://api.github.com/rate_limit
    repository_url https://api.github.com/repos/{owner}/{repo}
    ...
    user_repositories_url https://api.github.com/users/{user}/repos{?type,page,per_page,sort}
    team_url https://api.github.com/teams
    

    同样的效果,用 requests 库则有如下代码:

    复制

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    
    import requests
    
    cs_url  = 'https://api.github.com'
    cs_user = 'user'
    cs_psw  = 'password'
    
    r = requests.get(cs_url, auth=(cs_user, cs_psw))
    
    if r.status_code == requests.codes.ok
        for k, v in r.json().items():
            print k, v
    

    溢美之词就不用说了,读到这里的你心里肯定只有一声「卧槽,这才是 Python 该有的样子」。那么,接下来我们看看 requests 都有哪些黑魔法。

    安装

    最推荐的方式,是直接安装推荐过的 Anaconda

    如果你不想安装 Anaconda,那么建议你使用 pip 安装;只需在命令行下执行:

    复制

    1
    
    pip install requests
    

    基本用法

    requests 的基本用法,呃,真是不能再基本了。最基本的操作,就是以某种 HTTP 方法向远端服务器发送一个请求而已;而 requests 库就是这么做的。

    复制

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    
    import requests
    
    cs_url = 'http://httpbin.org'
    
    r = requests.get("%s/%s" % (cs_url, 'get'))
    r = requests.post("%s/%s" % (cs_url, 'post'))
    r = requests.put("%s/%s" % (cs_url, 'put'))
    r = requests.delete("%s/%s" % (cs_url, 'delete'))
    r = requests.patch("%s/%s" % (cs_url, 'patch'))
    r = requests.options("%s/%s" % (cs_url, 'get'))
    

    从语法上看,requests 库设计的非常自然。所谓 requests.get,就是以 GET 方式发送一个 REQUEST,得到一个 Response 类的结果,保存为 r

    你可以在 r 中取得所有你想得到的和 HTTP 有关的信息。下面,我们以 GET 方法为例,依次介绍。

    URL 传参 / 获取请求的 URL

    如果你经常上网(废话,看到这里的都上过网吧……),一定见过类似下面的链接:

    https://encrypted.google.com/search?q=hello

    即:

    复制

    1
    
    <协议>://<域名>/<接口>?<键1>=<值1>&<键2>=<值2>
    

    requests 库提供的 HTTP 方法,都提供了名为 params 的参数。这个参数可以接受一个 Python 字典,并自动格式化为上述格式。

    复制

    1
    2
    3
    4
    5
    6
    7
    
    import requests
    
    cs_url = 'http://www.so.com/s'
    param  = {'ie':'utf-8', 'q':'query'}
    
    r = requests.get (cs_url, params = param)
    print r.url
    

    运行将得到:

    复制

    1
    
    http://www.so.com/s?q=query&ie=utf-8
    

    HTTP 状态码 / 重定向跳转

    requests 库定义的 Response 类可以方便地获取请求的 HTTP 状态码和重定向状态。

    360 公司的搜索引擎,原名「好搜」,现在改为「360 搜索」;域名也从 www.haosou.com 改成了 www.so.com。如果你在地址栏输入 www.haosou.com,那么会经由 302 跳转到 www.so.com。我们借此来演示。

    复制

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    
    import requests
    
    cs_url = 'http://www.so.com/s'
    param  = {'ie':'utf-8', 'q':'query'}
    r = requests.get (cs_url, params = param)
    print r.url, r.status_code
    
    cs_url = 'http://www.haosou.com/s'
    r = requests.get (cs_url, params = param)
    print r.url, r.status_code, r.history
    

    结果是:

    复制

    1
    2
    
    http://www.so.com/s?q=query&ie=utf-8 200
    http://www.so.com/s?q=query&ie=utf-8 200 [<Response [302]>]
    

    我们发现,requests 默认自动地处理了 302 跳转。在经过跳转的请求中,返回的 URL 和状态码都是跳转之后的信息;唯独在 history 中,用 Python 列表记录了跳转情况。

    大多数情况下,自动处理是挺好的。不过,有时候我们也想单步追踪页面跳转情况。此时,可以给请求加上 allow_redirects = False 参数。

    复制

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    
    import requests
    
    cs_url = 'http://www.so.com/s'
    param  = {'ie':'utf-8', 'q':'query'}
    r = requests.get (cs_url, params = param)
    print r.url, r.status_code
    
    cs_url = 'http://www.haosou.com/s'
    r = requests.get (cs_url, params = param, allow_redirects = False)
    print r.url, r.status_code, r.history
    

    输出结果:

    复制

    1
    2
    
    http://www.so.com/s?q=query&ie=utf-8 200
    http://www.haosou.com/s?q=query&ie=utf-8 302 []
    

    不允许 requests 自动处理跳转后,返回的 URL 和状态码都符合预期了。

    超时设置

    requests 的超时设置以为单位。例如,对请求加参数 timeout = 5 即可设置超时为 5 秒。

    复制

    1
    2
    3
    4
    5
    
    # a very short timeout is set intentionally
    import requests
    
    cs_url = 'http://www.zhihu.com'
    r = requests.get (cs_url, timeout = 0.000001)
    

    返回报错:

    复制

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    
    Traceback (most recent call last):
      File "D:\test\py\test.py", line 6, in <module>
        r = requests.get (cs_url, timeout = 0.000001)
      File "C:\Users\username\AppData\Local\Continuum\Anaconda\lib\site-packages\requests\api.py", line 69, in get
        return request('get', url, params=params, **kwargs)
      File "C:\Users\username\AppData\Local\Continuum\Anaconda\lib\site-packages\requests\api.py", line 50, in request
        response = session.request(method=method, url=url, **kwargs)
      File "C:\Users\username\AppData\Local\Continuum\Anaconda\lib\site-packages\requests\sessions.py", line 465, in request
        resp = self.send(prep, **send_kwargs)
      File "C:\Users\username\AppData\Local\Continuum\Anaconda\lib\site-packages\requests\sessions.py", line 573, in send
        r = adapter.send(request, **kwargs)
      File "C:\Users\username\AppData\Local\Continuum\Anaconda\lib\site-packages\requests\adapters.py", line 419, in send
        raise ConnectTimeout(e, request=request)
    requests.exceptions.ConnectTimeout: HTTPConnectionPool(host='www.zhihu.com', port=80): Max retries exceeded with url: / (Caused by ConnectTimeoutError(<requests.packages.urllib3.connection.HTTPConnection object at 0x0000000002AFABE0>, 'Connection to www.zhihu.com timed out. (connect timeout=1e-06)'))
    

    请求头

    我们利用 httpbin 这个网站,先来看一下 requests 发出的 HTTP 报文默认的请求头是什么样子的。

    复制

    1
    2
    3
    4
    5
    
    import requests
    
    cs_url = 'http://httpbin.org/get'
    r = requests.get (cs_url)
    print r.content
    

    返回结果:

    复制

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    
    {
      "args": {},
      "headers": {
        "Accept": "*/*",
        "Accept-Encoding": "gzip, deflate",
        "Host": "httpbin.org",
        "User-Agent": "python-requests/2.7.0 CPython/2.7.10 Windows/7"
      },
      "origin": "xx.xx.xx.xx",
      "url": "http://httpbin.org/get"
    }
    

    注意,这里使用 r.content 来查看请求头部是因为 httpbin 这个网站的特殊性——它什么也不干,就把请求的内容返回给请求者。在 requests当中,应当使用 r.request.headers 来查看请求的头部。

    通常我们比较关注其中的 User-Agent 和 Accept-Encoding。如果我们要修改 HTTP 头中的这两项内容,只需要将一个合适的字典参数传给 headers即可。

    复制

    1
    2
    3
    4
    5
    6
    
    import requests
    
    my_headers = {'User-Agent' : 'From Liam Huang', 'Accept-Encoding' : 'gzip'}
    cs_url = 'http://httpbin.org/get'
    r = requests.get (cs_url, headers = my_headers)
    print r.content
    

    返回:

    复制

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    
    {
      "args": {},
      "headers": {
        "Accept": "*/*",
        "Accept-Encoding": "gzip",
        "Host": "httpbin.org",
        "User-Agent": "From Liam Huang"
      },
      "origin": "xx.xx.xx.xx",
      "url": "http://httpbin.org/get"
    }
    

    可以看到,UA 和 AE 都已经被修改了。

    响应头

    作为 HTTP 请求的响应,返回的内容中也有 HTTP 头。它是一个反序列化为 Python 字典的数据结构,可以通过 Response.headers 来查看。

    复制

    1
    2
    3
    4
    5
    
    import requests
    
    cs_url = 'http://httpbin.org/get'
    r = requests.get (cs_url)
    print r.headers
    

    返回:

    复制

    1
    2
    3
    4
    5
    6
    7
    8
    9
    
    {
        "content-length": "263",
        "server": "nginx",
        "connection": "keep-alive",
        "access-control-allow-credentials": "true",
        "date": "Fri, 26 Feb 2016 10:26:17 GMT",
        "access-control-allow-origin": "*",
        "content-type": "application/json"
    }
    

    响应内容

    字节模式 / 自动解包

    长期以来,互联网都存在带宽有限的情况。因此,网络上传输的数据,很多情况下都是经过压缩的。经由 requests 发送的请求,当收到的响应内容经过 gzip 或 deflate 压缩时,requests 会自动为我们解包。我们可以用 Response.content 来获得以字节形式返回的相应内容。

    复制

    1
    2
    3
    4
    5
    6
    7
    
    import requests
    
    cs_url = 'http://www.zhihu.com'
    r = requests.get (cs_url)
    
    if r.status_code == requests.codes.ok:
        print r.content
    

    这相当于 urllib2.urlopen(url).read()

    如果相应内容不是文本,而是二进制数据(比如图片),那么上述打印结果可能会糊你一脸。这里以图片为例,示例一下该怎么办。

    复制

    1
    2
    3
    4
    5
    6
    7
    8
    9
    
    import requests
    from PIL import Image
    from StringIO import StringIO
    
    cs_url = 'http://liam0205.me/uploads/avatar/avatar-2.jpg'
    r = requests.get (cs_url)
    
    if r.status_code == requests.codes.ok:
        Image.open(StringIO(r.content)).show()
    

    运行无误的话,能看到我和我爱人的照片。

    文本模式 / 编码

    如果响应返回是文本,那么你可以用 Response.text 获得 Unicode 编码的响应返回内容。

    复制

    1
    2
    3
    4
    5
    6
    7
    
    import requests
    
    cs_url = 'http://www.zhihu.com'
    r = requests.get (cs_url)
    
    if r.status_code == requests.codes.ok:
        print r.text
    

    要获得 Unicode 编码的结果,意味着 requests 会为我们做解码工作。那么 requests 是按照何种编码去对返回结果解码的呢?

    requests 会读取 HTTP header 中关于字符集的内容。如果获取成功,则会依此进行解码;若不然,则会根据响应内容对编码进行猜测。具体来说,我们可以用 Response.encoding 来查看/修改使用的编码。

    复制

    1
    2
    3
    4
    5
    6
    7
    
    import requests
    
    cs_url = 'http://www.zhihu.com'
    r = requests.get (cs_url)
    
    if r.status_code == requests.codes.ok:
        print r.encoding
    

    反序列化 JSON 数据

    开篇给出的第一个 requests 示例中,特别吸引人的一点就是 requests 无需任何其他库,就能解析序列化为 JSON 格式的数据。

    我们以 IP 查询 Google 公共 DNS 为例:

    复制

    1
    2
    3
    4
    5
    6
    7
    8
    
    import requests
    
    cs_url   = 'http://ip.taobao.com/service/getIpInfo.php'
    my_param = {'ip':'8.8.8.8'}
    
    r = requests.get(cs_url, params = my_param)
    
    print r.json()['data']['country'].encode('utf-8')
    

    结果将输出:

    复制

    1
    
    美国
    

    模拟登录 GitHub 看看

    HTTP 协议是无状态的。因此,若不借助其他手段,远程的服务器就无法知道以前和客户端做了哪些通信。Cookie 就是「其他手段」之一。

    Cookie 一个典型的应用场景,就是用于记录用户在网站上的登录状态。

    1. 用户登录成功后,服务器下发一个(通常是加密了的)Cookie 文件。
    2. 客户端(通常是网页浏览器)将收到的 Cookie 文件保存起来。
    3. 下次客户端与服务器连接时,将 Cookie 文件发送给服务器,由服务器校验其含义,恢复登录状态(从而避免再次登录)。

    Cookie? 你说的是小甜点吧!

    别忘了,requests 是给人类设计的 Python 库。想想使用浏览器浏览网页的时候,我们没有手工去保存、重新发送 Cookie 对吗?浏览器都为我们自动完成了。

    在 requests 中,也是这样

    当浏览器作为客户端与远端服务器连接时,远端服务器会根据需要,产生一个 SessionID,并附在 Cookie 中发给浏览器。接下来的时间里,只要 Cookie 不过期,浏览器与远端服务器的连接,都会使用这个 SessionID;而浏览器会自动与服务器协作,维护相应的 Cookie。

    在 requests 中,也是这样。我们可以创建一个 requests.Session,尔后在该 Session 中与远端服务器通信,其中产生的 Cookie,requests 会自动为我们维护好

    POST 表单

    POST 方法可以将一组用户数据,以表单的形式发送到远端服务器。远端服务器接受后,依照表单内容做相应的动作。

    调用 requests 的 POST 方法时,可以用 data 参数接收一个 Python 字典结构。requests 会自动将 Python 字典序列化为实际的表单内容。例如:

    复制

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    
    import requests
    
    cs_url    = 'http://httpbin.org/post'
    my_data   = {
        'key1' : 'value1',
        'key2' : 'value2'
    }
    
    r = requests.post (cs_url, data = my_data)
    print r.content
    

    返回:

    复制

    1
    2
    3
    4
    5
    6
    7
    8
    
    {
      ...
      "form": {
        "key1": "value1",
        "key2": "value2"
      },
      ...
    }
    

    实际模拟登录 GitHub 试试看

    模拟登录的第一步,首先是要搞清楚我们用浏览器登录时都发生了什么。

    GitHub 登录页面是 https://github.com/login。我们首先清空浏览器 Cookie 记录,然后用 Chrome 打开登录页面。

    填入 Username 和 Password 之后,我们打开 Tamper Chrome 和 Chrome 的元素审查工具(找到 Network 标签页),之后点登录按钮。

    在 Tamper Chrome 中,我们发现:虽然登录页面是 https://github.com/login,但实际接收表单的是 https://github.com/session。若登录成功,则跳转到 https://github.com/ 首页,返回状态码 200

    而在 Chrome 的审查元素窗口中,我们可以看到提交给 session 接口的表单信息。内里包含

    • commit
    • utf8
    • authenticity_token
    • login
    • password

    其中,commit 和 utf8 两项是定值;login 和 password 分别是用户名和密码,这很好理解。唯独 authenticity_token 是一长串无规律的字符,我们不清楚它是什么。

    POST 动作发生在与 session 接口交互之前,因此可能的信息来源只有 login 接口。我们打开 login 页面的源码,试着搜索 authenticity_token 就不难发现有如下内容:

    复制

    1
    
    <input name="authenticity_token" type="hidden" value="......" />
    

    原来,所谓的 authenticity_token 是明白卸载 HTML 页面里的,只不过用 hidden 模式隐藏起来了。为此,我们只需要使用 Python 的正则库解析一下,就好了。

    这样一来,事情就变得简单起来,编码吧!

    复制

    模拟登录 GitHub

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    
    import requests
    import re
    
    cs_url  = 'https://github.com/login'
    cs_user = 'user'
    cs_psw  = 'psw'
    my_headers = {
        'User-Agent' : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.116 Safari/537.36',
        'Accept' : 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
        'Accept-Encoding' : 'gzip',
        'Accept-Language' : 'zh-CN,zh;q=0.8,en;q=0.6,zh-TW;q=0.4'
    }
    sss     = requests.Session()
    r       = sss.get(cs_url, headers = my_headers)
    reg     = r'<input name="authenticity_token" type="hidden" value="(.*)" />'
    pattern = re.compile(reg)
    result  = pattern.findall(r.content)
    token   = result[0]
    my_data = {
        'commit' : 'Sign in',
        'utf8' : '%E2%9C%93',
        'authenticity_token' : token,
        'login' : cs_user,
        'password' : cs_psw
    }
    cs_url  = 'https://github.com/session'
    r       = sss.post(cs_url, headers = my_headers, data = my_data)
    print r.url, r.status_code, r.history
    

    输出:

    复制

    1
    
    https://github.com/ 200 [<Response [302]>]
    

    代码很好理解,其实只是完全地模拟了浏览器的行为。

    首先,我们准备好了和 Chrome 一致的 HTTP 请求头部信息。具体来说,其中的 User-Agent 是比较重要的。而后,仿照浏览器与服务器的通信,我们创建了一个 requests.Session。接着,我们用 GET 方法打开登录页面,并用正则库解析到 authenticity_token。随后,将所需的数据,整备成一个 Python 字典备用。最后,我们用 POST 方法,将表单提交到 session 接口。

    最终的结果也是符合预期的:经由 302 跳转,打开了(200)GitHub 首页。

    展开全文
  • 数据爬虫(三):python中requests库使用方法详解

    万次阅读 多人点赞 2018-02-02 04:55:41
    一、什么是Requests Requests 是⽤Python语⾔编写,基于urllib,采⽤Apache2 Licensed开源协议的 HTTP 库。它⽐ urllib 更加⽅便,... ... 二、安装Requests库 进入命令行win+R执行 命令:pip install requests ...

    一、什么是Requests

    Requests 是⽤Python语⾔编写,基于urllib,采⽤Apache2 Licensed开源协议的 HTTP 库。它⽐ urllib 更加⽅便,可以节约我们⼤量的⼯作,完全满⾜HTTP测试需求。

    ⼀句话——Python实现的简单易⽤的HTTP库

    二、安装Requests库

    进入命令行win+R执行

    命令:pip install requests

    项目导入:import requests

    三、各种请求方式

    直接上代码,不明白可以查看我的urllib的基本使用方法

    import requests
    requests.post('http://httpbin.org/post')
    requests.put('http://httpbin.org/put')
    requests.delete('http://httpbin.org/delete')
    requests.head('http://httpbin.org/get')
    requests.options('http://httpbin.org/get')

    这么多请求方式,都有什么含义,所以问下度娘:

    1. GET: 请求指定的页面信息,并返回实体主体。
    2. HEAD: 只请求页面的首部。
    3. POST: 请求服务器接受所指定的文档作为对所标识的URI的新的从属实体。
    4. PUT: 从客户端向服务器传送的数据取代指定的文档的内容。
    5. DELETE: 请求服务器删除指定的页面。
    6. get 和 post比较常见 GET请求将提交的数据放置在HTTP请求协议头中
    7. POST提交的数据则放在实体数据中

    (1)、基本的GET请求

    import requests
    
    response = requests.get('http://httpbin.org/get')
    print(response.text)

    返回值:

    {
      "args": {}, 
      "headers": {
        "Accept": "*/*", 
        "Accept-Encoding": "gzip, deflate", 
        "Connection": "close", 
        "Host": "httpbin.org", 
        "User-Agent": "python-requests/2.18.4"
      }, 
      "origin": "183.64.61.29", 
      "url": "http://httpbin.org/get"
    }
    

    (2)、带参数的GET请求

    将name和age传进去

    import requests
    response = requests.get("http://httpbin.org/get?name=germey&age=22")
    print(response.text)
    {
      "args": {
        "age": "22", 
        "name": "germey"
      }, 
      "headers": {
        "Accept": "*/*", 
        "Accept-Encoding": "gzip, deflate", 
        "Connection": "close", 
        "Host": "httpbin.org", 
        "User-Agent": "python-requests/2.18.4"
      }, 
      "origin": "183.64.61.29", 
      "url": "http://httpbin.org/get?name=germey&age=22"
    }
    

    或者使用params的方法:

    import requests
    
    data = {
     'name': 'germey',
     'age': 22
    }
    response = requests.get("http://httpbin.org/get", params=data)
    print(response.text)

    返回值一样

    (3)、解析json

    将返回值已json的形式展示:

    import requests
    import json
    
    response = requests.get("http://httpbin.org/get")
    print(type(response.text))
    print(response.json())
    print(json.loads(response.text))
    print(type(response.json()))

    返回值:

    <class 'str'>
    {'args': {}, 'headers': {'Accept': '*/*', 'Accept-Encoding': 'gzip, deflate', 'Connection': 'close', 'Host': 'httpbin.org', 'User-Agent': 'python-requests/2.18.4'}, 'origin': '183.64.61.29', 'url': 'http://httpbin.org/get'}
    {'args': {}, 'headers': {'Accept': '*/*', 'Accept-Encoding': 'gzip, deflate', 'Connection': 'close', 'Host': 'httpbin.org', 'User-Agent': 'python-requests/2.18.4'}, 'origin': '183.64.61.29', 'url': 'http://httpbin.org/get'}
    <class 'dict'>

    (4)、获取二进制数据

    记住返回值.content就ok了

    import requests
    
    response = requests.get("https://github.com/favicon.ico")
    print(type(response.text), type(response.content))
    print(response.text)
    print(response.content)

    返回值为二进制不必再进行展示,

    (5)、添加headers

    有些网站访问时必须带有浏览器等信息,如果不传入headers就会报错,如下

    import requests
    
    response = requests.get("https://www.zhihu.com/explore")
    print(response.text)

    返回值:

    <html><body><h1>500 Server Error</h1>
    An internal server error occured.
    </body></html>

    当传入headers时:

    import requests
    
    headers = {
     'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36'
    }
    response = requests.get("https://www.zhihu.com/explore", headers=headers)
    print(response.text)

    成功返回网页源代码不做展示

    (6)、基本POST请求

    不明白见我博文urllib的使用方法

    import requests
    
    data = {'name': 'germey', 'age': '22'}
    response = requests.post("http://httpbin.org/post", data=data)
    print(response.text)

    返回:

    {
      "args": {}, 
      "data": "", 
      "files": {}, 
      "form": {
        "age": "22", 
        "name": "germey"
      }, 
      "headers": {
        "Accept": "*/*", 
        "Accept-Encoding": "gzip, deflate", 
        "Connection": "close", 
        "Content-Length": "18", 
        "Content-Type": "application/x-www-form-urlencoded", 
        "Host": "httpbin.org", 
        "User-Agent": "python-requests/2.18.4"
      }, 
      "json": null, 
      "origin": "183.64.61.29", 
      "url": "http://httpbin.org/post"
    }
    

    三、响应

    response属性

    import requests
    
    response = requests.get('http://www.jianshu.com')
    print(type(response.status_code), response.status_code)
    print(type(response.headers), response.headers)
    print(type(response.cookies), response.cookies)
    print(type(response.url), response.url)
    print(type(response.history), response.history)

    return:

    <class 'int'> 200
    <class 'requests.structures.CaseInsensitiveDict'> {'Date': 'Thu, 01 Feb 2018 20:47:08 GMT', 'Server': 'Tengine', 'Content-Type': 'text/html; charset=utf-8', 'Transfer-Encoding': 'chunked', 'X-Frame-Options': 'DENY', 'X-XSS-Protection': '1; mode=block', 'X-Content-Type-Options': 'nosniff', 'ETag': 'W/"9f70e869e7cce214b6e9d90f4ceaa53d"', 'Cache-Control': 'max-age=0, private, must-revalidate', 'Set-Cookie': 'locale=zh-CN; path=/', 'X-Request-Id': '366f4cba-8414-4841-bfe2-792aeb8cf302', 'X-Runtime': '0.008350', 'Content-Encoding': 'gzip', 'X-Via': '1.1 gjf22:8 (Cdn Cache Server V2.0), 1.1 PSzqstdx2ps251:10 (Cdn Cache Server V2.0)', 'Connection': 'keep-alive'}
    <class 'requests.cookies.RequestsCookieJar'> <RequestsCookieJar[<Cookie locale=zh-CN for www.jianshu.com/>]>
    <class 'str'> https://www.jianshu.com/
    <class 'list'> [<Response [301]>]

    状态码判断:常见的网页状态码:

    100: ('continue',),
    101: ('switching_protocols',),
    102: ('processing',),
    103: ('checkpoint',),
    122: ('uri_too_long', 'request_uri_too_long'),
    200: ('ok', 'okay', 'all_ok', 'all_okay', 'all_good', '\\o/', '✓'),
    201: ('created',),
    202: ('accepted',),
    203: ('non_authoritative_info', 'non_authoritative_information'),
    204: ('no_content',),
    205: ('reset_content', 'reset'),
    206: ('partial_content', 'partial'),
    207: ('multi_status', 'multiple_status', 'multi_stati', 'multiple_stati'),
    208: ('already_reported',),
    226: ('im_used',),
    
    # Redirection.
    300: ('multiple_choices',),
    301: ('moved_permanently', 'moved', '\\o-'),
    302: ('found',),
    303: ('see_other', 'other'),
    304: ('not_modified',),
    305: ('use_proxy',),
    306: ('switch_proxy',),
    307: ('temporary_redirect', 'temporary_moved', 'temporary'),
    308: ('permanent_redirect',
     'resume_incomplete', 'resume',), # These 2 to be removed in 3.0
    
    # Client Error.
    400: ('bad_request', 'bad'),
    401: ('unauthorized',),
    402: ('payment_required', 'payment'),
    403: ('forbidden',),
    404: ('not_found', '-o-'),
    405: ('method_not_allowed', 'not_allowed'),
    406: ('not_acceptable',),
    407: ('proxy_authentication_required', 'proxy_auth', 'proxy_authentication'),
    408: ('request_timeout', 'timeout'),
    409: ('conflict',),
    410: ('gone',),
    411: ('length_required',),
    412: ('precondition_failed', 'precondition'),
    413: ('request_entity_too_large',),
    414: ('request_uri_too_large',),
    415: ('unsupported_media_type', 'unsupported_media', 'media_type'),
    416: ('requested_range_not_satisfiable', 'requested_range', 'range_not_satisfiable'),
    417: ('expectation_failed',),
    418: ('im_a_teapot', 'teapot', 'i_am_a_teapot'),
    421: ('misdirected_request',),
    422: ('unprocessable_entity', 'unprocessable'),
    423: ('locked',),
    424: ('failed_dependency', 'dependency'),
    425: ('unordered_collection', 'unordered'),
    426: ('upgrade_required', 'upgrade'),
    428: ('precondition_required', 'precondition'),
    429: ('too_many_requests', 'too_many'),
    431: ('header_fields_too_large', 'fields_too_large'),
    444: ('no_response', 'none'),
    449: ('retry_with', 'retry'),
    450: ('blocked_by_windows_parental_controls', 'parental_controls'),
    451: ('unavailable_for_legal_reasons', 'legal_reasons'),
    499: ('client_closed_request',),
    
    # Server Error.
    500: ('internal_server_error', 'server_error', '/o\\', '✗'),
    501: ('not_implemented',),
    502: ('bad_gateway',),
    503: ('service_unavailable', 'unavailable'),
    504: ('gateway_timeout',),
    505: ('http_version_not_supported', 'http_version'),
    506: ('variant_also_negotiates',),
    507: ('insufficient_storage',),
    509: ('bandwidth_limit_exceeded', 'bandwidth'),
    510: ('not_extended',),
    511: ('network_authentication_required', 'network_auth', 'network_authentication'),

    四、高级操作

    (1)、文件上传

    使用 Requests 模块,上传文件也是如此简单的,文件的类型会自动进行处理:

    实例:

    import requests
    
    files = {'file': open('cookie.txt', 'rb')}
    response = requests.post("http://httpbin.org/post", files=files)
    print(response.text)

    这是通过测试网站做的一个测试,返回值如下:

    {
      "args": {}, 
      "data": "", 
      "files": {
        "file": "#LWP-Cookies-2.0\r\nSet-Cookie3: BAIDUID=\"D2B4E137DE67E271D87F03A8A15DC459:FG=1\"; path=\"/\"; domain=\".baidu.com\"; path_spec; domain_dot; expires=\"2086-02-13 11:15:12Z\"; version=0\r\nSet-Cookie3: BIDUPSID=D2B4E137DE67E271D87F03A8A15DC459; path=\"/\"; domain=\".baidu.com\"; path_spec; domain_dot; expires=\"2086-02-13 11:15:12Z\"; version=0\r\nSet-Cookie3: H_PS_PSSID=25641_1465_21087_17001_22159; path=\"/\"; domain=\".baidu.com\"; path_spec; domain_dot; discard; version=0\r\nSet-Cookie3: PSTM=1516953672; path=\"/\"; domain=\".baidu.com\"; path_spec; domain_dot; expires=\"2086-02-13 11:15:12Z\"; version=0\r\nSet-Cookie3: BDSVRTM=0; path=\"/\"; domain=\"www.baidu.com\"; path_spec; discard; version=0\r\nSet-Cookie3: BD_HOME=0; path=\"/\"; domain=\"www.baidu.com\"; path_spec; discard; version=0\r\n"
      }, 
      "form": {}, 
      "headers": {
        "Accept": "*/*", 
        "Accept-Encoding": "gzip, deflate", 
        "Connection": "close", 
        "Content-Length": "909", 
        "Content-Type": "multipart/form-data; boundary=84835f570cfa44da8f4a062b097cad49", 
        "Host": "httpbin.org", 
        "User-Agent": "python-requests/2.18.4"
      }, 
      "json": null, 
      "origin": "183.64.61.29", 
      "url": "http://httpbin.org/post"
    }

    (2)、获取cookie

    当需要cookie时,直接调用response.cookie:(response为请求后的返回值)

    import requests
    
    response = requests.get("https://www.baidu.com")
    print(response.cookies)
    for key, value in response.cookies.items():
     print(key + '=' + value)

    输出结果:

    <RequestsCookieJar[<Cookie BDORZ=27315 for .baidu.com/>]>
    BDORZ=27315

    (3)、会话维持、模拟登陆

    如果某个响应中包含一些Cookie,你可以快速访问它们:

    import requests
     
    r = requests.get('http://www.google.com.hk/')
    print(r.cookies['NID'])
    print(tuple(r.cookies))

    要想发送你的cookies到服务器,可以使用 cookies 参数:

    import requests
     
    url = 'http://httpbin.org/cookies'
    cookies = {'testCookies_1': 'Hello_Python3', 'testCookies_2': 'Hello_Requests'}
    # 在Cookie Version 0中规定空格、方括号、圆括号、等于号、逗号、双引号、斜杠、问号、@,冒号,分号等特殊符号都不能作为Cookie的内容。
    r = requests.get(url, cookies=cookies)
    print(r.json())

    (4)、证书验证

    因为12306有一个错误证书,我们那它的网站做测试会出现下面的情况,证书不是官方证书,浏览器会识别出一个错误

    import requests
    
    response = requests.get('https://www.12306.cn')
    print(response.status_code)

    返回值:

    怎么正常进入这样的网站了,代码如下:

    import requests
    from requests.packages import urllib3
    urllib3.disable_warnings()
    response = requests.get('https://www.12306.cn', verify=False)
    print(response.status_code)

    将verify设置位False即可,返回的状态码为200

    urllib3.disable_warnings()这条命令主要用于消除警告信息

    (5)、代理设置

    在进行爬虫爬取时,有时候爬虫会被服务器给屏蔽掉,这时采用的方法主要有降低访问时间,通过代理ip访问,如下:

    import requests
    
    proxies = {
     "http": "http://127.0.0.1:9743",
     "https": "https://127.0.0.1:9743",
    }
    
    response = requests.get("https://www.taobao.com", proxies=proxies)
    print(response.status_code)

    ip可以从网上抓取,或者某宝购买

    如果代理需要设置账户名和密码,只需要将字典更改为如下:
    proxies = {
    "http":"http://user:password@127.0.0.1:9999"
    }
    如果你的代理是通过sokces这种方式则需要pip install "requests[socks]"
    proxies= {
    "http":"socks5://127.0.0.1:9999",
    "https":"sockes5://127.0.0.1:8888"
    }

    (6)、超时设置

    访问有些网站时可能会超时,这时设置好timeout就可以解决这个问题

    import requests
    from requests.exceptions import ReadTimeout
    try:
     response = requests.get("http://httpbin.org/get", timeout = 0.5)
     print(response.status_code)
    except ReadTimeout:
     print('Timeout')

    正常访问,状态吗返回200

    (7)、认证设置

    如果碰到需要认证的网站可以通过requests.auth模块实现

    import requests
    
    from requests.auth import HTTPBasicAuth
    
    response = requests.get("http://120.27.34.24:9001/",auth=HTTPBasicAuth("user","123"))
    print(response.status_code)

    当然这里还有一种方式

    import requests
    
    response = requests.get("http://120.27.34.24:9001/",auth=("user","123"))
    print(response.status_code)

    (8)、异常处理

    遇到网络问题(如:DNS查询失败、拒绝连接等)时,Requests会抛出一个ConnectionError 异常。

    遇到罕见的无效HTTP响应时,Requests则会抛出一个 HTTPError 异常。

    若请求超时,则抛出一个 Timeout 异常。

    若请求超过了设定的最大重定向次数,则会抛出一个 TooManyRedirects 异常。

    所有Requests显式抛出的异常都继承自 requests.exceptions.RequestException 。

    weiker原创,转载请附上链接:http://mathlabs.cn

     

     

    展开全文
  • requests库的使用

    千次阅读 2019-01-11 02:36:53
    简介 Requests是一个优雅而简单的Python HTTP,专为人类而构建 Requests是有史以来下载次数最多的Python软件包之一,每天下载量...相反,Requests的使用方式非常的简单,直观,人性化,让程序员的精力完全从的...

    简介

    • Requests是一个优雅而简单的Python HTTP库,专为人类而构建
    • Requests是有史以来下载次数最多的Python软件包之一,每天下载量超过400000次
    • 之前的urllib作为Python的标准库,因为历史原因,使用方式可以说是非常的麻烦而复杂的,而且官方文档也十分的简陋,常常需要去查看源码
    • 相反,Requests的使用方式非常的简单,直观,人性化,让程序员的精力完全从库的使用中解放出来
    • Requests的官方文档同样也非常的完善详尽,而且少见的有中文官方文档:http://cn.python-requests.org/zh_CN/latest/
    • 英文文档:http://docs.python-requests.org/en/master/api/
    • 作者:Kenneth Reitz
    • 中文文档:http://2.python-requests.org/zh_CN/latest/

    例1

    • 可以说Requests最大的特性就是其风格的简单直接优雅,无论是请求方法,还是响应结果的处理,还有cookies,url参数,post提交数据,都体现出了这种风格
    import requests
    response = requests.get('http://www.baidu.com')
    print(response.request.url) # 等同于response.url
    print(response.status_code)
    #请求头是请求头,响应头是响应头
    print(response.headers['content-type'])	#不区分大小写
    print(response.encoding)
    print(response.text)		 #获取文本,一般情况自动解码可能会和自己想要的有偏差
    print(response.content)	#获取字节格式的
    print(response.content.decode('utf8'))	#获取文本,手动解码,免得自动解码有偏差
    #200
      text/html
      ISO-8859-1
      <!DOCTYPE html>
      <!--STATUS OK--><html> <head><meta h.....
    

    例2

    import requests
    
    headers = {
        'User-Agent': 'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)'
    }
    kw = {
        'wd': '星爷'
    }
    # 不加 cookie 会获取不到
    s = requests.Session()
    s.get('http://www.baidu.com/s',params=kw,headers=headers,timeout=3)
    cookie = s.cookies
    resp = s.get('http://www.baidu.com/s',params=kw,headers=headers,timeout=3)	#将字典放入 params 中,requests 自动帮我们转换成编码,不用像 urllib 用 parse.urlencode() 手动转换
    print(resp.content.decode('utf8'))
    

    特性

    • Req目前基本上完全满足web请求的所有要求,以下是Requests的特性:
      • Keep-Alive&连接池
      • 国际化域名和URL
      • 带持久cookie的会话
      • 浏览器式的SSL认证
      • 自动内容解码
      • 基本/摘要式的身份认证
      • 优雅的key/value cookie
      • 自动解压
      • Unicode响应体
      • HTTP(S)代理
      • 文件分块上传
      • 流下载
      • 连接超时
      • 分块请求
      • 支持.netrc

    发起请求

    请求方法

    • Requests的请求不再像urllib一样需要去构造各种Request,opener和handler,使用Requests构造的方法,并在其中传入需要的参数即可
    • 每一个请求方法都有一个对应的API,比如GET请求就可以使用get()方法
    • POST请求就可以使用post()方法,并且将需要提交的数据传递给data参数即可
    • 而其他的请求类型,都有各自对应的方法:
      import requests
      response = requests.get(‘https://httpbin.org/get’)
      response = requests.post(‘http://gttpbin.org/post’,data={‘key’:‘value’})
      - post请求四种传送正文方式:
        - 请求正文是application/x-www-form-urlencoded
        - 请求正文是multipart/form-data
        - 请求正文是raw
        - 请求正文是binary
      response = requests.put(‘http://httpbin.org/put’,data={‘key’:‘value’})
      response = requests.delete(‘http://httpbin.org/delete’)
      response = requests.head('http://httpbin.org/get‘)
      response = requests.options(‘http://httpbin.org/get’)
      非常简单直观明了

    传递URL参数

    • 传递URL参数也不用再像urllib中那样需要去拼接URL,而是简单的构造一个字典,并在请求时将其传递给params参数
      import requests
      params = {‘key1’:‘value1’,‘key2’:‘value2’}
      response = requests.get(‘http://httpbin.org/get’,params=params)
    • 有时候我们会遇到相同的url参数名,但又不同的值,而Python的字典又不支持键的重名,可以把键的值用列表表示
      params = {‘key1’:‘value1’,‘key2’:[‘value2’,‘value3’]}
      response = requests.get(‘http://httpbin.org/get’,params=params)
      print(response.url)
      #http://httpbin.org/get?key1=value1&key2=value2&key2=value3

    自定义Headers

    • 如果想自定义请求的Headers,同样的将字典数据传递给headers参数
      url = ‘http://api.github.com/some/endpoint’
      headers = {‘user-agent’:‘my-app/0.0.1’} #自定义headers
      response = requests.get(url,headers=headers)
      print(response.headers)

    自定义cookies

    • Requests中自定义cookies也不用再去构造CookieJar对象,直接将字典递给cookies参数
      url = ‘http://httpbin.org/cookies’
      co = {‘cookies_are’:‘working’}
      response = requests.get(url,cookies=co)
      print(response.text) #{“cookies”: {“cookies_are”: “working”}}
    s = requests.Session()
    s.get(url,headers=headers,timeout=3)
    cookie = s.cookies
    

    设置代理

    • 当我们需要使用代理时,同样构造代理字典,传递给proxies参数
      import requests
      proxies = {
      ‘http’:‘http://10.10.1.10:3128’,
      ‘https’:‘https://10.10.1.10:1080’
      }
      requests.get(‘http://httpbin.org/ip’,proxies=proxy)
      print(response.text)

    重定向

    • 在网络请求中,我们常常会遇到状态码是3开头的重定向问题,在Requests中是默认开启允许重定向的,即遇到重定向时,会自动继续访问
      response = requests.get(‘http://github.com’,allow_redirects=False)
      print(response.url) #http://github.com/
      print(response.headers)
      #{‘Content-length’: ‘0’, ‘Location’: ‘https://github.com/’}
      print(response.status_code) #301

    禁止证书验证

    • 有时候我们使用了抓包工具,这个时候由于抓包工具提供的证书并不是由受信任的数字证书颁发机构颁发的,所以证书的验证会失败,所以我们就需要关闭证书验证
    • 在请求的时候把verify参数设置为False就可以关闭证书验证了
      response = requests.get(‘http://httpbin.org/post’,verify=False)
    • 但是关闭验证后,会有一个比较烦人的warning,可以使用以下方法关闭警告
      from requests.packages.urllib3.exceptions import InsecureRequestWarning
      requests.packages.urllib3.disable_warnings(InsecureRequestWarning)

    设置超时

    • 设置访问超时,设置timeout参数即可
      requests.get(‘http://github.com’,timeout=0.01)

    接收响应

    响应内容

    • 通过Requests发起请求获取到的,是一个requests.models.Response对象,通过这个对象我们可以很方便的获取响应的内容
    • 之前通过urllib获取的响应,读取的内容都是bytes的二进制格式,需要我们去将结果decode()一次转换成字符串数据
    • 而Requests通过text属性,就可以获得字符串格式的响应内容

    字符编码

    • Requests会自动的跟据响应的报头来猜测网页的编码是什么,然后根据猜测的编码来解码网页内容,基本上大部分的网页都能够正确的被解码
    • 如果发现text解码不正确的时候,就需要我们自己手动的去指定解码的编码格式
      response = requests.get(‘https://api.github.com/events’)
      response.encoding = ‘utf-8’
      print(response.text)

    二进制数据

    • 如果需要获得原始的二进制数据,使用content属性即可
      response = requests.get(‘https://api.github.com/events’)
      print(response.content)

    json数据

    • 如果我们访问之后获得的是json格式的,那么可以使用json()方法,直接获取转换成字典格式的数据
      response = requests.get(‘https://api.github.com/events’)
      print(response.json())

    状态码

    • 通过status_code属性获取响应的状态码
      response = requests.get(‘http://httpbin.org/get’)
      print(response.status_code)

    响应报头

    print(response.headers)
    #{
    'Cache-Control': 'private, no-cache, no-store, proxy-revalidate, no-transform', 
    'Connection': 'Keep-Alive', 
    'Content-Encoding': 'gzip',
     'Content-Type': 'text/html', 
     'Date': 'Thu, 10 Jan 2019 16:48:04 GMT', 
     'Last-Modified': 'Mon, 23 Jan 2017 13:27:36 GMT',
      'Pragma': 'no-cache',
       'Server': 'bfe/1.0.8.18', 
      'Set-Cookie': 'BDORZ=27315; max-age=86400; domain=.baidu.com; path=/', 
      'Transfer-Encoding': 'chunked'
      }
    

    服务器返回的cookies

    • 通过cookies属性获取服务器返回的cookies
      url = ‘http://example.com/some/cookie/setting/url’
      response = requests.get(url)
      print(response.cookies[‘example_cookie_name’])

    url

    • 还可以使用url属性查看访问的url
      params = {‘key1’:‘value1’,‘key2’:[‘value2’,‘value3’]}
      response = requests.get(‘http://httpbin.org/get’,params=params)
      print(response.url)
      #http://httpbin.org/get?key1=value1&key2=value2&key2=value3

    session对象

    • 在Requests中,实现了session(会话)功能,当我们使用session时,能够像浏览器一样,在没有关闭浏览器时,能够保持住访问的状态
    • 这个功能常常被我们用于登陆之后的数据获取,使我们不用再一又一次的传递cookies
      import requests
      session = requests.Session()
      session.get(‘http://httpbin.org/cookies/set/sessioncookie/123456789’)
      response = session.get(‘http://httpbin.org/cookies’)
      print(response.text)
      #{“cookies”: {“sessioncookie”: “123456789”}}
    • 首先我们需要去生成一个Session对象,然后用这个Session对象来发起访问,发起访问的方法与正常的请求是一摸一样的
    • 同时需要注意的是,如果是我们在get()方法中传入headers和cookies等数据,那么这些数据只能在当前这一次请求中有效
    • 如果想要让一个headers在Session的整个生命周期内都有效的话,需要用以下的方式来进行设置
      #设置整个headers
      session.hraders = {
      ‘user-agent’:‘my-app/0.0.1’
      }
      #增加一条headers
      session.headers.update({‘x-test’:‘true’})

    登录豆瓣

    - 一个会话123
    #1.访问首页面	cookie
    #2.验证用户名和密码	携带上一次的cookie
    #3.根据验证,携带上一次的cookie
    import requests
    login_url = 'https://www.douban.com/accounts/login'
    headers = {
    'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36'
    }
    form_data = {
        'source': 'index_nav',
        'form_email': '*******',		#账号
        'form_password': '*********'		#密码
    }
    response = requests.post(login_url,data=form_data,headers=headers)
    print(response.text)
    print(response.url)
    

    校验12306

    用cookie

    import requests
    import base64
    import re
    def get_point_by_index(indexs):
        """
        根据图片的序号快速获取坐标
        :param insexs:1,2
        :return:111,111,222,222
        """
        map = {
            '1':'39,43',
            '2':'109,43',
            '3':'185,43',
            '4':'253,43',
            '5':'39,121',
            '6':'109,121',
            '7':'185,121',
            '8':'253,121',
        }
        indexs = indexs.split(',')
        temp = []
        for index in indexs:
            temp.append(map[index])
        return ','.join(temp)
    cookies = None	#需要cookie做标记,每一步都要带上
    #1.访问首页面
    login_page_url = 'https://kyfw.12306.cn/otn/resources/login.html'
    headers = {
        'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36'
    }
    response = requests.get(login_page_url,headers)
    cookies = response.cookies
    #2.下载图片 验证码
    captcha_url = 'https://kyfw.12306.cn/passport/captcha/captcha-image64?login_site=E&module=login&rand=sjrand&1547303075115&callback=jQuery19106706322143238805_1547303062080&_=154730'
    captcha_response = requests.get(captcha_url,headers=headers,cookies=cookies)
    #获取图片信息
    img_data = re.findall(b'"image":"(.*?)"',captcha_response.content)[0]
    res = base64.b64decode(img_data)
    with open('captcha.jpg','wb') as f:
        f.write(base64.b64decode(img_data)) #解码后的验证码图片信息
    cookies = captcha_response.cookies
    #3.验证验证码
    check_captcha_api = 'https://kyfw.12306.cn/passport/captcha/captcha-check'
    args = {
        'callback':'jQuery191032014987830377206_1547304492627',
        'answer':get_point_by_index(input("请输入正确的图片坐标:")),
        'rand':'sjrand',
        'login_site':'E',
        '_':'1547304492633',    #只是为了防止浏览器的缓存,爬虫可以不管
    }
    check_response = requests.get(check_captcha_api,params=args,headers=headers,cookies=cookies)
    print(check_response.text)
    

    用session

    import requests
    import base64
    import re
    def get_point_by_index(indexs):
        """
        根据图片的序号快速获取坐标
        :param insexs:1,2
        :return:111,111,222,222
        """
        map = {
            '1':'39,43',
            '2':'109,43',
            '3':'185,43',
            '4':'253,43',
            '5':'39,121',
            '6':'109,121',
            '7':'185,121',
            '8':'253,121',
        }
        indexs = indexs.split(',')
        temp = []
        for index in indexs:
            temp.append(map[index])
        return ','.join(temp)
    headers = {
        'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36'
    }
    session = requests.Session()
    #添加请求头
    session.headers.update(headers)
    #1.访问首页面
    login_page_url = 'https://kyfw.12306.cn/otn/resources/login.html'
    response = session.get(login_page_url)
    #2.下载图片 验证码
    captcha_url = 'https://kyfw.12306.cn/passport/captcha/captcha-image64?login_site=E&module=login&rand=sjrand&1547303075115&callback=jQuery19106706322143238805_1547303062080&_=154730'
    captcha_response = session.get(captcha_url)
    #获取图片信息
    img_data = re.findall(b'"image":"(.*?)"',captcha_response.content)[0]
    res = base64.b64decode(img_data)
    with open('captcha.jpg','wb') as f:
        f.write(base64.b64decode(img_data)) #解码后的验证码图片信息
    cookies = captcha_response.cookies
    #3.验证验证码
    check_captcha_api = 'https://kyfw.12306.cn/passport/captcha/captcha-check'
    args = {
        'callback':'jQuery191032014987830377206_1547304492627',
        'answer':get_point_by_index(input("请输入正确的图片坐标:")),
        'rand':'sjrand',
        'login_site':'E',
        '_':'1547304492633',    #只是为了防止浏览器的缓存,爬虫可以不管
    }
    check_response = session.get(check_captcha_api,params=args)
    print(check_response.text)
    

    小例子

    • 百度图片"星爷"的前20张图片
    import requests
    import re
    request_url = 'https://image.baidu.com/search/index?tn=baiduimage&ipn=r&ct=201326592&cl=2&lm=-1&st=-1&fm=result&fr=&sf=1&fmq=1574482313106_R&pv=&ic=&nc=1&z=&hd=&latest=&copyright=&se=1&showtab=0&fb=0&width=&height=&face=0&istype=2&ie=utf-8&ctd=1574482313108%5E00_1400X216&sid=&word=%E6%98%9F%E7%88%B7'    #查看对应的 Request URL
    headers = {
        'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.97 Safari/537.36'
        '''
        Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/14.0.835.163 Safari/535.1
        Mozilla/5.0 (Windows NT 6.1; WOW64; rv:6.0) Gecko/20100101 Firefox/6.0
        Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/534.50 (KHTML, like Gecko) Version/5.1 Safari/534.50
        Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0; .NET CLR 2.0.50727; SLCC2; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; InfoPath.3; .NET4.0C; Tablet PC 2.0; .NET4.0E)
        Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; WOW64; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; InfoPath.3)
        Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; WOW64; Trident/5.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; InfoPath.3; .NET4.0C; .NET4.0E) QQBrowser/6.9.11079.201
        Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; InfoPath.3; .NET4.0C; .NET4.0E)
        '''
    }
    response = requests.get(request_url,headers)
    img_urls = re.findall(r'data-imgurl="(.*?)"',response.text)
    for index,image_url in enumerate(img_urls):
        image_response = requests.get(image_url)
        image_filename = '%s.%s.jpg' % (index,(image_url.split(',')[-1]).split('.')[0])
        with open(image_filename,'wb') as f:
            f.write(image_response.content)
    

    在这里插入图片描述

    展开全文
  • Python-第三方库requests详解

    万次阅读 多人点赞 2016-03-16 11:45:15
    Requests 是用Python语言编写,基于 urllib,采用 Apache2 Licensed 开源协议的 HTTP 。它比 urllib 更加方便,可以节约我们大量的工作,完全满足 HTTP 测试需求。Requests 的哲学是以 PEP 20 的习语为中心开发的...

    Requests 是用Python语言编写,基于 urllib,采用 Apache2 Licensed 开源协议的 HTTP 库。它比 urllib 更加方便,可以节约我们大量的工作,完全满足 HTTP 测试需求。Requests 的哲学是以 PEP 20 的习语为中心开发的,所以它比 urllib 更加 Pythoner。更重要的一点是它支持 Python3 哦!

    希望我的博客对您有用。

    阿里云最高1888通用代金券,送给你!

    • Beautiful is better than ugly.(美丽优于丑陋)
    • Explicit is better than implicit.(清楚优于含糊)
    • Simple is better than complex.(简单优于复杂)
    • Complex is better than complicated.(复杂优于繁琐)
    • Readability counts.(重要的是可读性)

    一、安装 Requests

    通过pip安装

    pip install requests

    或者,下载代码后安装:

    $ git clone git://github.com/kennethreitz/requests.git
    $ cd requests
    $ python setup.py install

    再懒一点,通过IDE安装吧,如pycharm!

    二、发送请求与传递参数

    先来一个简单的例子吧!让你了解下其威力:

    复制代码

    import requests
     
    r = requests.get(url='http://www.itwhy.org')    # 最基本的GET请求
    print(r.status_code)    # 获取返回状态
    r = requests.get(url='http://dict.baidu.com/s', params={'wd':'python'})   #带参数的GET请求
    print(r.url)
    print(r.text)   #打印解码后的返回数据

    复制代码

    很简单吧!不但GET方法简单,其他方法都是统一的接口样式哦!

    requests.get(‘https://github.com/timeline.json’) #GET请求
    requests.post(“http://httpbin.org/post”) #POST请求
    requests.put(“http://httpbin.org/put”) #PUT请求
    requests.delete(“http://httpbin.org/delete”) #DELETE请求
    requests.head(“http://httpbin.org/get”) #HEAD请求
    requests.options(“http://httpbin.org/get”) #OPTIONS请求

    PS:以上的HTTP方法,对于WEB系统一般只支持 GET 和 POST,有一些还支持 HEAD 方法。
    带参数的请求实例:

    import requests
    requests.get('http://www.dict.baidu.com/s', params={'wd': 'python'})    #GET参数实例
    requests.post('http://www.itwhy.org/wp-comments-post.php', data={'comment': '测试POST'})    #POST参数实例

    POST发送JSON数据:

    import requests
    import json
     
    r = requests.post('https://api.github.com/some/endpoint', data=json.dumps({'some': 'data'}))
    print(r.json())

    定制header:

    复制代码

    import requests
    import json
     
    data = {'some': 'data'}
    headers = {'content-type': 'application/json',
               'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:22.0) Gecko/20100101 Firefox/22.0'}
     
    r = requests.post('https://api.github.com/some/endpoint', data=data, headers=headers)
    print(r.text)

    复制代码

    三、Response对象

    使用requests方法后,会返回一个response对象,其存储了服务器响应的内容,如上实例中已经提到的 r.text、r.status_code……
    获取文本方式的响应体实例:当你访问 r.text 之时,会使用其响应的文本编码进行解码,并且你可以修改其编码让 r.text 使用自定义的编码进行解码。

    r = requests.get('http://www.itwhy.org')
    print(r.text, '\n{}\n'.format('*'*79), r.encoding)
    r.encoding = 'GBK'
    print(r.text, '\n{}\n'.format('*'*79), r.encoding)

    其他响应:

    r.status_code #响应状态码
    r.raw #返回原始响应体,也就是 urllib 的 response 对象,使用 r.raw.read() 读取
    r.content #字节方式的响应体,会自动为你解码 gzip 和 deflate 压缩
    r.text #字符串方式的响应体,会自动根据响应头部的字符编码进行解码
    r.headers #以字典对象存储服务器响应头,但是这个字典比较特殊,字典键不区分大小写,若键不存在则返回None
    #*特殊方法*#
    r.json() #Requests中内置的JSON解码器
    r.raise_for_status() #失败请求(非200响应)抛出异常

    案例之一:

    复制代码

    import requests
     
    URL = 'http://ip.taobao.com/service/getIpInfo.php'  # 淘宝IP地址库API
    try:
        r = requests.get(URL, params={'ip': '8.8.8.8'}, timeout=1)
        r.raise_for_status()    # 如果响应状态码不是 200,就主动抛出异常
    except requests.RequestException as e:
        print(e)
    else:
        result = r.json()
        print(type(result), result, sep='\n')

    复制代码

    四、上传文件

    使用 Requests 模块,上传文件也是如此简单的,文件的类型会自动进行处理:

    复制代码

    import requests
     
    url = 'http://127.0.0.1:5000/upload'
    files = {'file': open('/home/lyb/sjzl.mpg', 'rb')}
    #files = {'file': ('report.jpg', open('/home/lyb/sjzl.mpg', 'rb'))}     #显式的设置文件名
     
    r = requests.post(url, files=files)
    print(r.text)

    复制代码

    更加方便的是,你可以把字符串当着文件进行上传:

    复制代码

    import requests
     
    url = 'http://127.0.0.1:5000/upload'
    files = {'file': ('test.txt', b'Hello Requests.')}     #必需显式的设置文件名
     
    r = requests.post(url, files=files)
    print(r.text)

    复制代码

    五、身份验证

    基本身份认证(HTTP Basic Auth):

    import requests
    from requests.auth import HTTPBasicAuth
     
    r = requests.get('https://httpbin.org/hidden-basic-auth/user/passwd', auth=HTTPBasicAuth('user', 'passwd'))
    # r = requests.get('https://httpbin.org/hidden-basic-auth/user/passwd', auth=('user', 'passwd'))    # 简写
    print(r.json())

    另一种非常流行的HTTP身份认证形式是摘要式身份认证,Requests对它的支持也是开箱即可用的:

    requests.get(URL, auth=HTTPDigestAuth('user', 'pass'))

    六、Cookies与会话对象

    如果某个响应中包含一些Cookie,你可以快速访问它们:

    import requests
     
    r = requests.get('http://www.google.com.hk/')
    print(r.cookies['NID'])
    print(tuple(r.cookies))

    要想发送你的cookies到服务器,可以使用 cookies 参数:

    复制代码

    import requests
     
    url = 'http://httpbin.org/cookies'
    cookies = {'testCookies_1': 'Hello_Python3', 'testCookies_2': 'Hello_Requests'}
    # 在Cookie Version 0中规定空格、方括号、圆括号、等于号、逗号、双引号、斜杠、问号、@,冒号,分号等特殊符号都不能作为Cookie的内容。
    r = requests.get(url, cookies=cookies)
    print(r.json())

    复制代码

    会话对象让你能够跨请求保持某些参数,最方便的是在同一个Session实例发出的所有请求之间保持cookies,且这些都是自动处理的,甚是方便。
    下面就来一个真正的实例,如下是快盘签到脚本:

    复制代码

    import requests
     
    headers = {'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
               'Accept-Encoding': 'gzip, deflate, compress',
               'Accept-Language': 'en-us;q=0.5,en;q=0.3',
               'Cache-Control': 'max-age=0',
               'Connection': 'keep-alive',
               'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:22.0) Gecko/20100101 Firefox/22.0'}
     
    s = requests.Session()
    s.headers.update(headers)
    # s.auth = ('superuser', '123')
    s.get('https://www.kuaipan.cn/account_login.htm')
     
    _URL = 'http://www.kuaipan.cn/index.php'
    s.post(_URL, params={'ac':'account', 'op':'login'},
           data={'username':'****@foxmail.com', 'userpwd':'********', 'isajax':'yes'})
    r = s.get(_URL, params={'ac':'zone', 'op':'taskdetail'})
    print(r.json())
    s.get(_URL, params={'ac':'common', 'op':'usersign'})

    复制代码

    七、超时与异常

    timeout 仅对连接过程有效,与响应体的下载无关。

    >>> requests.get('http://github.com', timeout=0.001)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    requests.exceptions.Timeout: HTTPConnectionPool(host='github.com', port=80): Request timed out. (timeout=0.001)

    所有Requests显式抛出的异常都继承自 requests.exceptions.RequestException:ConnectionError、HTTPError、Timeout、TooManyRedirects。

    转自:http://www.itwhy.org/%E8%BD%AF%E4%BB%B6%E5%B7%A5%E7%A8%8B/python/python-%E7%AC%AC%E4%B8%89%E6%96%B9-http-%E5%BA%93-requests-%E5%AD%A6%E4%B9%A0.html

     

    requests是python的一个HTTP客户端库,跟urllib,urllib2类似,那为什么要用requests而不用urllib2呢?官方文档中是这样说明的:

    python的标准库urllib2提供了大部分需要的HTTP功能,但是API太逆天了,一个简单的功能就需要一大堆代码。

    我也看了下requests的文档,确实很简单,适合我这种懒人。下面就是一些简单指南。

    插播个好消息!刚看到requests有了中文翻译版,建议英文不好的看看,内容也比我的博客好多了,具体链接是:http://cn.python-requests.org/en/latest/(不过是v1.1.0版,另抱歉,之前贴错链接了)。

    1. 安装

    安装很简单,我是win系统,就在这里下载了安装包(网页中download the zipball处链接),然后$ python setup.py install就装好了。
    当然,有easy_installpip的朋友可以直接使用:easy_install requests或者pip install requests来安装。
    至于linux用户,这个页面还有其他安装方法。
    测试:在IDLE中输入import requests,如果没提示错误,那说明已经安装成功了!

    2. 小试牛刀

    >>>import requests
    >>> r = requests.get('http://www.zhidaow.com')  # 发送请求
    >>> r.status_code  # 返回码 
    200
    >>> r.headers['content-type']  # 返回头部信息
    'text/html; charset=utf8'
    >>> r.encoding  # 编码信息
    'utf-8'
    >>> r.text  #内容部分(PS,由于编码问题,建议这里使用r.content)
    u'<!DOCTYPE html>\n<html xmlns="http://www.w3.org/1999/xhtml"...'
    ...
    

    是不是很简单?比urllib2和urllib简单直观的多?!那请接着看快速指南吧。

    3. 快速指南

    3.1 发送请求

    发送请求很简单的,首先要导入requests模块:

    >>>import requests
    

    接下来让我们获取一个网页,例如我个人博客的首页:

    >>>r = requests.get('http://www.zhidaow.com')
    

    接下来,我们就可以使用这个r的各种方法和函数了。
    另外,HTTP请求还有很多类型,比如POST,PUT,DELETE,HEAD,OPTIONS。也都可以用同样的方式实现:

    >>> r = requests.post("http://httpbin.org/post")
    >>> r = requests.put("http://httpbin.org/put")
    >>> r = requests.delete("http://httpbin.org/delete")
    >>> r = requests.head("http://httpbin.org/get")
    >>> r = requests.options("http://httpbin.org/get")
    

    因为目前我还没用到这些,所以没有深入研究。

    3.2 在URLs中传递参数

    有时候我们需要在URL中传递参数,比如在采集百度搜索结果时,我们wd参数(搜索词)和rn参数(搜素结果数量),你可以手工组成URL,requests也提供了一种看起来很NB的方法:

    >>> payload = {'wd': '张亚楠', 'rn': '100'}
    >>> r = requests.get("http://www.baidu.com/s", params=payload)
    >>> print r.url
    u'http://www.baidu.com/s?rn=100&wd=%E5%BC%A0%E4%BA%9A%E6%A5%A0'
    

    上面wd=的乱码就是“张亚楠”的转码形式。(好像参数按照首字母进行了排序。)

    3.3 获取响应内容

    可以通过r.text来获取网页的内容。

    >>> r = requests.get('https://www.zhidaow.com')
    >>> r.text
    u'<!DOCTYPE html>\n<html xmlns="http://www.w3.org/1999/xhtml"...'
    

    文档里说,requests会自动将内容转码。大多数unicode字体都会无缝转码。但我在cygwin下使用时老是出现UnicodeEncodeError错误,郁闷。倒是在python的IDLE中完全正常。
    另外,还可以通过r.content来获取页面内容。

    >>> r = requests.get('https://www.zhidaow.com')
    >>> r.content
    b'<!DOCTYPE html>\n<html xmlns="http://www.w3.org/1999/xhtml"...'
    

    文档中说r.content是以字节的方式去显示,所以在IDLE中以b开头。但我在cygwin中用起来并没有,下载网页正好。所以就替代了urllib2的urllib2.urlopen(url).read()功能。(基本上是我用的最多的一个功能。)

    3.4 获取网页编码

    可以使用r.encoding来获取网页编码。

    >>> r = requests.get('http://www.zhidaow.com')
    >>> r.encoding
    'utf-8'
    

    当你发送请求时,requests会根据HTTP头部来猜测网页编码,当你使用r.text时,requests就会使用这个编码。当然你还可以修改requests的编码形式。

    >>> r = requests.get('http://www.zhidaow.com')
    >>> r.encoding
    'utf-8'
    >>>r.encoding = 'ISO-8859-1'
    

    像上面的例子,对encoding修改后就直接会用修改后的编码去获取网页内容。

    3.5 json

    像urllib和urllib2,如果用到json,就要引入新模块,如jsonsimplejson,但在requests中已经有了内置的函数,r.json()。就拿查询IP的API来说:

    >>>r = requests.get('http://ip.taobao.com/service/getIpInfo.php?ip=122.88.60.28')
    >>>r.json()['data']['country']
    '中国'
    

    3.6 网页状态码

    我们可以用r.status_code来检查网页的状态码。

    >>>r = requests.get('http://www.mengtiankong.com')
    >>>r.status_code
    200
    >>>r = requests.get('http://www.mengtiankong.com/123123/')
    >>>r.status_code
    404
    >>>r = requests.get('http://www.baidu.com/link?url=QeTRFOS7TuUQRppa0wlTJJr6FfIYI1DJprJukx4Qy0XnsDO_s9baoO8u1wvjxgqN')
    >>>r.url
    u'http://www.zhidaow.com/
    >>>r.status_code
    200
    

    前两个例子很正常,能正常打开的返回200,不能正常打开的返回404。但第三个就有点奇怪了,那个是百度搜索结果中的302跳转地址,但状态码显示是200,接下来我用了一招让他原形毕露:

    >>>r.history
    (<Response [302]>,)
    

    这里能看出他是使用了302跳转。也许有人认为这样可以通过判断和正则来获取跳转的状态码了,其实还有个更简单的方法:

    >>>r = requests.get('http://www.baidu.com/link?url=QeTRFOS7TuUQRppa0wlTJJr6FfIYI1DJprJukx4Qy0XnsDO_s9baoO8u1wvjxgqN', allow_redirects = False)
    >>>r.status_code
    302
    

    只要加上一个参数allow_redirects,禁止了跳转,就直接出现跳转的状态码了,好用吧?我也利用这个在最后一掌做了个简单的获取网页状态码的小应用,原理就是这个。

    3.7 响应头内容

    可以通过r.headers来获取响应头内容。

    >>>r = requests.get('http://www.zhidaow.com')
    >>> r.headers
    {
        'content-encoding': 'gzip',
        'transfer-encoding': 'chunked',
        'content-type': 'text/html; charset=utf-8';
        ...
    }
    

    可以看到是以字典的形式返回了全部内容,我们也可以访问部分内容。

    >>> r.headers['Content-Type']
    'text/html; charset=utf-8'
    
    >>> r.headers.get('content-type')
    'text/html; charset=utf-8'
    

    3.8 设置超时时间

    我们可以通过timeout属性设置超时时间,一旦超过这个时间还没获得响应内容,就会提示错误。

    >>> requests.get('http://github.com', timeout=0.001)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    requests.exceptions.Timeout: HTTPConnectionPool(host='github.com', port=80): Request timed out. (timeout=0.001)
    

    3.9 代理访问

    采集时为避免被封IP,经常会使用代理。requests也有相应的proxies属性。

    import requests
    
    proxies = {
      "http": "http://10.10.1.10:3128",
      "https": "http://10.10.1.10:1080",
    }
    
    requests.get("http://www.zhidaow.com", proxies=proxies)
    

    如果代理需要账户和密码,则需这样:

    proxies = {
        "http": "http://user:pass@10.10.1.10:3128/",
    }
    

    3.10 请求头内容

    请求头内容可以用r.request.headers来获取。

    >>> r.request.headers
    {'Accept-Encoding': 'identity, deflate, compress, gzip',
    'Accept': '*/*', 'User-Agent': 'python-requests/1.2.3 CPython/2.7.3 Windows/XP'}
    

    3.11 自定义请求头部

    伪装请求头部是采集时经常用的,我们可以用这个方法来隐藏:

    r = requests.get('http://www.zhidaow.com')
    print r.request.headers['User-Agent']
    #python-requests/1.2.3 CPython/2.7.3 Windows/XP
    
    headers = {'User-Agent': 'alexkh'}
    r = requests.get('http://www.zhidaow.com', headers = headers)
    print r.request.headers['User-Agent']
    #alexkh
    

    3.12 持久连接keep-alive

    requests的keep-alive是基于urllib3,同一会话内的持久连接完全是自动的。同一会话内的所有请求都会自动使用恰当的连接。

    也就是说,你无需任何设置,requests会自动实现keep-alive。

    4. 简单应用

    4.1 获取网页返回码

    def get_status(url):
        r = requests.get(url, allow_redirects = False)
        return r.status_code
    
    print get_status('http://www.zhidaow.com') 
    #200
    print get_status('http://www.zhidaow.com/hi404/')
    #404
    print get_status('http://mengtiankong.com')
    #301
    print get_status('http://www.baidu.com/link?url=QeTRFOS7TuUQRppa0wlTJJr6FfIYI1DJprJukx4Qy0XnsDO_s9baoO8u1wvjxgqN')
    #302
    print get_status('http://www.huiya56.com/com8.intre.asp?46981.html')
    #500
    

    后记

    1、官方文档
    requests的具体安装过程请看:http://docs.python-requests.org/en/latest/user/install.html#install
    requests的官方指南文档:http://docs.python-requests.org/en/latest/user/quickstart.html
    requests的高级指南文档:http://docs.python-requests.org/en/latest/user/advanced.html#advanced
    2、本文内容部分翻译自官方文档,部分自己归纳。
    3、大多数用的IDLE格式,累死了,下次直接用编辑器格式,这样更符合我的习惯。
    4、还是那句话,有问题留言或email。
    5、图注:requests官方文档上的一只老鳖。

    转载出处:http://www.zhidaow.com/post/python-requests-install-and-brief-introduction

    如果我的博客对您有用,请您务必扫码,您得红包,我也能得红包!谢谢!

    希望我的博客对您有用。

    阿里云最高1888通用代金券,送给你!

    展开全文
  • python爬虫入门--Requests库介绍及实例

    万次阅读 多人点赞 2017-03-18 21:06:11
    1、Requests库基础知识 Requests库的get()方法 Requests库的Response对象: Response对象包含服务器返回的所有信息,也包含请求的Request信息。 运行截图如下所示: 2、Requests库实例 (1)京东商品的...
  • python第三方库Requests库基本介绍

    千次阅读 2019-05-16 22:19:39
    虽然Python的标准中 urllib 模块已经包含了平常我们使用的大多数功能,但是它的 API 使用起来让人感觉不太好,而 Requests 自称 "HTTP for Humans",说明使用更简洁方便。 Requests 唯一的一个非转基因的 Python ...
  • requests库(一):

    2020-11-20 23:16:50
    安装 pip install requests 官方文档 http://docs.python-requests.org/zh-CN/latest/index.html 官方中文文档...还可以在pycharm中安装第三方 file->settings->project->+ ...
  • Requests库简单介绍

    2019-04-13 17:56:59
    Requests库的作用就是请求网站获取网页数据的。 (一)打印网页源代码 #获得网页的源代码 import requests res = requests.get('http://bj.xiaozhu.com/')#网站为小猪短租北京地区网址 print(res) ...
  • Requests库 更新中

    2019-06-13 14:51:00
    1.获取网页内容 ---requests库 《需理解HTTP协议》 >requests库的7个主要方法 方法 说明 requests.requests() 构造一个请求,支撑一下个方法的基础方法 requests...
  • 使用Requests库来进行爬虫的详解

    千次阅读 2018-10-17 16:52:53
    Requests是用Python编写,基于urllib,采用Apache2 Licensed开源协议的HTTP。它比urllib更方便,可以节约我们大量的工作,完全满足HTTP测试需求。 安装: pip3 install requests 使用 实例: import requests...
  • requests库的详细安装过程

    万次阅读 2018-08-02 18:17:53
    requests库的详细安装过程 1.进入python安装目录,查看Scripts文件夹中有无pip.exe,如果有直接cmd,输入命令 pip install requests 2.若是空文件夹,去https://pypi.org/project/pip/#files此网站下载(红框为需要...
  • requests库

    2018-05-07 14:38:28
    安装依赖pip install requestsrequest对象的常用请求方法request 其他六个方法,底层调用该方法get 从服务器获取资源post 将资源提交到服务(不可覆盖)put 修改服务器资源(可覆盖)head 获取服务器资源的部分信息...
  • Requests库基本使用

    千次阅读 2019-01-17 21:54:55
    Requests 是一个非常容易上手的 python 爬虫,相比于 urllib requests 非常简洁。下面是我在看视频教程的过程中,记录的一些笔记。 get() 方法 requests 基本的 get 方法 首先来看一下 requests 下 get ...
  • python3安装requests库

    千次阅读 2019-03-21 08:03:56
    安装requests库: 在终端直接输入命令:pip3 install requests 检查是否安装成功:在终端输入命令:python3 切换到 python3环境 输入命令·import requests 如果不报错 就证明安装好了 如果报错就是安装失败 ...
  • Requests库与response属性

    2020-04-24 22:48:30
    Requests库的基本使用一、安装二、原理三、 方法 一、安装 requests是Python第三方库,不会自带,需要额外安装 pip install requests 二、原理 模拟浏览器,向服务器发送请求,获得服务器响应 三、 方法 返回网页原...
  • REQUESTS库文档

    2017-11-05 13:51:43
    python Requests库文档,PDF版本,作者在官网上发布的。
  • Python Requests库简明使用教程

    万次阅读 多人点赞 2016-07-08 00:26:13
    Requests是一常用的http请求,它使用python语言编写,可以方便地发送http请求,以及方便地处理响应结果。一、安装1.1 使用PIP进行安装要安装requests,最方便快捷发方法的使用pip进行安装。 pip install requests...
  • Requests库的基本用法

    千次阅读 2018-07-06 11:33:54
    Request的基本用法爬虫首先 Request 基本方法介绍方法说明requests.request()构造一个请求,支撑一下各方法的基础方法requests.get()获取HTML网页的主要方法,对应于HTTP的GETrequests.head()获取HTML网页头信息...
  • python-requests 使用

    千次阅读 2019-01-05 22:23:46
    python-requests 使用 """ 安装 pip install requests """ # 使用 import requests response = requests.get('https://www.baidu.com/') print(type(response)) # &lt;class '...
  • requests库入门-1-安装requests库

    万次阅读 2017-08-20 23:31:43
    我在实现了Python+requests+unittest+HTMLTestRunner这个接口自动化测试框架demo之前,做了一些接口测试方法和工具的调研,主要写了如何一步一步用Postman进行接口测试、常见接口测试工具的调研,例如JMeter,soupUI...
  • Python需要的requests库

    2016-02-29 10:59:47
    python需要的requests库,需要就拿走吧,不用谢,有正在学PYTHON的来一起学习啊
  • python ,requests,爬虫框架,适合人类的爬虫框架,适合新手入门,也适合用来随时查询APi
  • Python之requests库的基本使用(填坑)

    千次阅读 2018-08-19 00:50:17
    答案是有的,那就是第三方库requests,这个库的作者是大名鼎鼎的kennethreitz,创作这个库的原因就是想让python开发者更加容易地发起请求,处理请求。里面还有个名字:HTTP for Humans,顾名思义,就是用来请求http的...
  • requests库官方文档

    2018-10-19 18:20:42
    requests 2.19.1最新版官方文档使用教程(原版)。
  • Python 网络爬虫从0到1 (1):Requests库入门详解   网络爬虫中,网络请求是基础部分。没有网络请求以及响应,网络爬虫的后续数据分析也就失去了意义。Python中的网络请求,主要由Requests库来完成,本篇,我们...
  • python中关于requests库的安装

    万次阅读 2019-08-03 11:28:16
    python中的requests库是对于python爬虫非常重要的工具。我们可以通过系统的“cmd”进行自动的安装。 0. win+r ,之后输入cmd ,即可打开命令行窗口。 1. 首先先检查下是否安装有pip,或者是easy_pip。这两个一般...
  • requests库的安装

    千次阅读 2017-03-14 16:38:15
    本文是基于 中国大学MOOC教程 中《Python网络爬虫与信息提取》 做的学习笔记,笔者在这里做一个分享 Request 库是python的第三方库,它也是目前公认...一、requests库的安装 step 1:用管理员权限启动cmd控制台(wind
  • 学习笔记之——单元1:Requests库入门一、Requests库的安装1. Windows下Requests的安装二、HTTP协议1. HTTP基本概念2. HTTP协议对资源的操作三、Response对象的属性、异常处理及通用爬虫代码框架四、Requests库的...
  • Python Requests库详解

    2018-08-24 16:00:44
    Python Requests库详解,pdf版本,适用于爬虫初学者。
  • python爬虫——requests库使用代理

    万次阅读 多人点赞 2020-01-14 11:27:40
    让我们先安装上requests库, pip install requests 先来看下文档,看看requests的介绍,用python自带的help命令 import requests help(requests) output: Help on package requests: NAME ...

空空如也

1 2 3 4 5 ... 20
收藏数 395,492
精华内容 158,196
关键字:

requests库