Question

如何在请求

之后使用库requests（在python中）

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import requests
bot = requests.session()
bot.get('http://google.com')

将所有Cookie保留在文件中，然后从文件中恢复Cookie。

Answer 1

没有直接的方法可以这样做，但这并不难。

您可以通过CookieJar从会话中获取session.cookies对象，您可以使用pickle将其存储到文件中。

一个完整的例子：

import requests, pickle
session = requests.session()
# Make some calls
with open('somefile', 'wb') as f:
    pickle.dump(session.cookies, f)

然后加载：

session = requests.session()  # or an existing session

with open('somefile', 'rb') as f:
    session.cookies.update(pickle.load(f))

请求库使用requests.cookies.RequestsCookieJar() subclass，它明确支持pickling和类似dict的API，你可以使用RequestsCookieJar.update() method更新现有的会话cookie jar和从pickle文件加载的会话cookie jar

Answer 2

在r = requests.get()之类的通话后，r.cookies将返回RequestsCookieJar，您可以直接pickle，即

import pickle
def save_cookies(requests_cookiejar, filename):
    with open(filename, 'wb') as f:
        pickle.dump(requests_cookiejar, f)

def load_cookies(filename):
    with open(filename, 'rb') as f:
        return pickle.load(f)

#save cookies
r = requests.get(url)
save_cookies(r.cookies, filename)

#load cookies and do a request
requests.get(url, cookies=load_cookies(filename))

如果您想以人类可读的格式保存Cookie，您必须做一些工作才能将RequestsCookieJar提取到LWPCookieJar。

import cookielib
def save_cookies_lwp(cookiejar, filename):
    lwp_cookiejar = cookielib.LWPCookieJar()
    for c in cookiejar:
        args = dict(vars(c).items())
        args['rest'] = args['_rest']
        del args['_rest']
        c = cookielib.Cookie(**args)
        lwp_cookiejar.set_cookie(c)
    lwp_cookiejar.save(filename, ignore_discard=True)

def load_cookies_from_lwp(filename):
    lwp_cookiejar = cookielib.LWPCookieJar()
    lwp_cookiejar.load(filename, ignore_discard=True)
    return lwp_cookiejar

#save human-readable
r = requests.get(url)
save_cookies_lwp(r.cookies, filename)

#you can pass a LWPCookieJar directly to requests
requests.get(url, cookies=load_cookies_from_lwp(filename))

Answer 3

扩展@miracle2k的答案，请求Session为documented，可与任何cookielib CookieJar一起使用。 LWPCookieJar（和MozillaCookieJar）可以在文件中保存和加载Cookie。这是一个完整的代码片段，它将为请求会话保存和加载cookie。 ignore_discard参数用于测试httpbin，但您可能不希望将其包含在实际代码中。

import os
from cookielib import LWPCookieJar

import requests


s = requests.Session()
s.cookies = LWPCookieJar('cookiejar')
if not os.path.exists('cookiejar'):
    # Create a new cookies file and set our Session's cookies
    print('setting cookies')
    s.cookies.save()
    r = s.get('http://httpbin.org/cookies/set?k1=v1&k2=v2')
else:
    # Load saved cookies from the file and use them in a request
    print('loading saved cookies')
    s.cookies.load(ignore_discard=True)
    r = s.get('http://httpbin.org/cookies')
print(r.text)
# Save the session's cookies back to the file
s.cookies.save(ignore_discard=True)

Answer 4

这将完成这项工作：

session.cookies = LWPCookieJar('cookies.txt')

CookieJar API要求您手动调用load（）和save（）。如果你不关心cookies.txt格式，我有一个ShelvedCookieJar实现，它将在更改时持续存在。

Answer 5

我发现其他答案有问题：

他们不适用于会议。
他们没有正确保存和加载。只保存了cookie名称和值，失效日期，域名等都丢失了。

这个答案解决了这两个问题：

import requests.cookies

def save_cookies(session, filename):
    if not os.path.isdir(os.path.dirname(filename)):
        return False
    with open(filename, 'w') as f:
        f.truncate()
        pickle.dump(session.cookies._cookies, f)


def load_cookies(session, filename):
    if not os.path.isfile(filename):
        return False

    with open(filename) as f:
        cookies = pickle.load(f)
        if cookies:
            jar = requests.cookies.RequestsCookieJar()
            jar._cookies = cookies
            session.cookies = jar
        else:
            return False

然后只需致电save_cookies(session, filename)保存或load_cookies(session, filename)加载即可。就这么简单。

Answer 6

我通过json提供一种方式：

# to save cookie
import json
with open('cookie.txt', 'w') as f:
    json.dump(requests.utils.dict_from_cookiejar(bot.cookies), f)

和

# to load cookie
import json
with open('cookie.txt', 'r') as f:
    cookie = requests.utils.cookiejar_from_dict(json.load(f))

Answer 7

除了这个，dtheodor的答案得到了95％：

session = requests.session(cookies=cookies)

对我来说，这引发了一个例外，说session（）不接受参数。

我通过获取cookie.get_dict上的键/值并使用以下方法手动将它们添加到会话中来解决这个问题：

session.cookies.set(cookies.keys()[n],cookies.values()[n])

Answer 8

您可以直接挑选cookies对象：

cookies = pickle.dumps(session.cookies)

dict表示错过了很多信息：expiration，domain，path ......

这取决于您打算使用cookie的用途，但是如果您没有关于过期的信息，您应该实施逻辑来手动跟踪过期。

挑选库返回的对象可以让您轻松地重建状态，然后您可以继续库实现。

显然，这样，pickle对象的使用者需要使用相同的库

Answer 9

将cookie转换为字典列表并保存到json或db的简单方法。这是具有session属性的类方法。

def dump_cookies(self):
    cookies = []
    for c in self.session.cookies:
        cookies.append({
            "name": c.name,
            "value": c.value,
            "domain": c.domain,
            "path": c.path,
            "expires": c.expires
        })
    return cookies

def load_cookies(self, cookies):
    for c in cookies:
        self.session.cookies.set(**c)

我们需要的是五个参数，例如：name，value，domain，path，expires

Answer 10

Python 3的代码

请注意，Internet上的大多数cookie是Netscape cookie。因此，如果您想以Mozilla cookies.txt文件格式（Lynx和Netscape浏览器也使用该格式）将cookie保存到磁盘，请使用MozillaCookieJar

func randomElement() -> Bound?

如果该文件已经存在，则将其覆盖，从而清除其中包含的所有cookie。以后可以使用load（）或revert（）方法来还原已保存的Cookie。

请注意，save（）方法无论如何都不会保存会话cookie，除非您可以通过传递一个真正的ignore_discard参数来提出其他要求。

randomElement()

使用加载方法：

从文件加载cookie。

保留旧Cookie，除非被新加载的Cookie覆盖。

let range = -70 ..< -50
let randomNumber = range.randomElement()
print(randomNumber) // prints: Optional(-64)

使用还原方法：

清除所有cookie并从已保存的文件中重新加载cookie。

from http.cookiejar import MozillaCookieJar
import requests

s = requests.Session()
s.cookies = MozillaCookieJar('cookies.txt')
# or s.cookies = MozillaCookieJar() and later use s.cookies.filename = 'cookies.txt' or pass the file name to save method.

response = s.get('https://www.msn.com')

s.cookies.save()

您可能还需要在load或revert方法中传递一个真正的ignore_discard参数。

有关使用MozillaCookieJar的说明：

注意：这将丢失有关RFC 2965 cookie以及有关较新的或非标准的cookie属性，例如port。

如何将请求（python）cookie保存到文件？

10 个答案: