Python爬虫：scrapy框架请求参数meta、headers、cookies一探究竟

最新推荐文章于 2024-07-27 10:27:01 发布
最新推荐文章于 2024-07-27 10:27:01 发布
阅读量1w 收藏 34
点赞数 10
分类专栏： Python scrapy
本文为博主原创文章，欢迎转载，请注明出处
本文链接：https://blog.csdn.net/mouday/article/details/81159416
版权
Python 同时被 2 个专栏收录
614 篇文章 36 订阅
订阅专栏
scrapy
35 篇文章 2 订阅
订阅专栏

对于scrapy请参数，会经常用到，不过没有深究

今天我就来探索下scrapy请求时所携带的3个重要参数headers, cookies, meta

原生参数

首先新建myscrapy项目，新建my_spider爬虫

通过访问：http://httpbin.org/get 来测试请求参数

将爬虫运行起来

# -*- coding: utf-8 -*-

from scrapy import Spider, Request
import logging


class MySpider(Spider):
    name = 'my_spider'
    allowed_domains = ['httpbin.org']
    start_urls = [
        'http://httpbin.org/get'
    ]

    def parse(self, response):
        self.write_to_file("*" * 40)
        self.write_to_file("response text: %s" % response.text)
        self.write_to_file("response headers: %s" % response.headers)
        self.write_to_file("response meta: %s" % response.meta)
        self.write_to_file("request headers: %s" % response.request.headers)
        self.write_to_file("request cookies: %s" % response.request.cookies)
        self.write_to_file("request meta: %s" % response.request.meta)

    def write_to_file(self, words):
        with open("logging.log", "a") as f:
            f.write(words)


if __name__ == '__main__':
    from scrapy import cmdline
    cmdline.execute("scrapy crawl my_spider".split())

保存到文件中的信息如下：

response text: 
{
    "args":{},
    "headers":{
        "Accept":"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
        "Accept-Encoding":"gzip,deflate",
        "Accept-Language":"en",
        "Connection":"close",
        "Host":"httpbin.org",
        "User-Agent":"Scrapy/1.5.1 (+https://scrapy.org)"
    },
    "origin":"223.72.90.254",
    "url":"http://httpbin.org/get"
}

response headers: 
{
    b'Server': [b'gunicorn/19.8.1'], 
    b'Date': [b'Sun, 22 Jul 2018 10:03:15 GMT'], 
    b'Content-Type': [b'application/json'], 
    b'Access-Control-Allow-Origin': [b'*'], 
    b'Access-Control-Allow-Credentials': [b'true'], 
    b'Via': [b'1.1 vegur']
}

response meta: 
{
    'download_timeout': 180.0, 
    'download_slot': 'httpbin.org', 
    'download_latency': 0.5500118732452393
}

request headers: 
{
    b'Accept': [b'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'], b'Accept-Language': [b'en'], 
    b'User-Agent': [b'Scrapy/1.5.1 (+https://scrapy.org)'], 
    b'Accept-Encoding': [b'gzip,deflate']
}

request cookies: 
{}

request meta: 
{
    'download_timeout': 180.0, 
    'download_slot': 'httpbin.org', 
    'download_latency': 0.5500118732452393
}

meta

通过上面的输出比较，发现 response 和 request 的meta参数是一样的，meta的功能就是从request携带信息，将其传递给response的

修改下代码，测试下传递效果

# -*- coding: utf-8 -*-

from scrapy import Spider, Request
import logging


class MySpider(Spider):
    name = 'my_spider'
    allowed_domains = ['httpbin.org']
    start_urls = [
        'http://httpbin.org/get'
    ]

    def start_requests(self):
        for url in self.start_urls:
            yield Request(url, meta={"uid": "this is uid of meta"})

    def parse(self, response):
        print("request meta: %s" % response.request.meta.get("uid"))
        print("response meta: %s" % response.meta.get("uid"))

输出如下

request meta: this is uid of meta
response meta: this is uid of meta

看来获取request中meta这两种方式都可行，这里的meta类似字典，可以按照字典获取key-value的形式获取对应的值
当然代理设置也是通过meta的
以下是一个代理中间件的示例

import random


class ProxyMiddleware(object):       
    def process_request(self, request, spider):
        proxy=random.choice(proxies)
        request.meta["proxy"] = proxy

headers

按照如下路径，打开scrapy的default_settings文件

from scrapy.settings import default_settings

发现是这么写的

USER_AGENT = 'Scrapy/%s (+https://scrapy.org)' % import_module('scrapy').__version__

DEFAULT_REQUEST_HEADERS = {
    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
    'Accept-Language': 'en',
}

修改下请求头，看服务器返回的信息

# -*- coding: utf-8 -*-

from scrapy import Spider, Request
import logging


class MySpider(Spider):
    name = 'my_spider'
    allowed_domains = ['httpbin.org']
    start_urls = [
        'http://httpbin.org/get',
    ]

    def start_requests(self):
        for url in self.start_urls:
            yield Request(url, headers={"User-Agent": "Chrome"})

    def parse(self, response):
        logging.debug("*" * 40)
        logging.debug("response text: %s" % response.text)
        logging.debug("response headers: %s" % response.headers)
        logging.debug("request headers: %s" % response.request.headers)


if __name__ == '__main__':
    from scrapy import cmdline
    cmdline.execute("scrapy crawl my_spider".split())

输出如下

response text: 
{
    "args":{},
    "headers":
    {
        "Accept":"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
        "Accept-Encoding":"gzip,deflate",
        "Accept-Language":"en",
        "Connection":"close",
        "Host":"httpbin.org",
        "User-Agent":"Chrome"
    },
    "origin":"122.71.64.121",
    "url":"http://httpbin.org/get"
}

response headers: 
{
    b'Server': [b'gunicorn/19.8.1'], 
    b'Date': [b'Sun, 22 Jul 2018 10:29:26 GMT'], 
    b'Content-Type': [b'application/json'], 
    b'Access-Control-Allow-Origin': [b'*'], 
    b'Access-Control-Allow-Credentials': [b'true'], 
    b'Via': [b'1.1 vegur']
}


request headers: 
{
    b'User-Agent': [b'Chrome'], 
    b'Accept': [b'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'], b'Accept-Language': [b'en'], 
    b'Accept-Encoding': [b'gzip,deflate']
}

看到 request 和 服务器接收到并返回的的 headers（User-Agent）变化了，说明已经把默认的User-Agent修改了

看到default_settings中默认使用了中间件UserAgentMiddleware

'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': 500,

源码如下


class UserAgentMiddleware(object):
    """This middleware allows spiders to override the user_agent"""

    def __init__(self, user_agent='Scrapy'):
        self.user_agent = user_agent

    @classmethod
    def from_crawler(cls, crawler):
        o = cls(crawler.settings['USER_AGENT'])
        crawler.signals.connect(o.spider_opened, signal=signals.spider_opened)
        return o

    def spider_opened(self, spider):
        self.user_agent = getattr(spider, 'user_agent', self.user_agent)

    def process_request(self, request, spider):
        if self.user_agent:
            request.headers.setdefault(b'User-Agent', self.user_agent)

仔细阅读源码，发现无非就是对User-Agent读取和设置操作，仿照源码写自己的中间件

这里使用fake_useragent库来随机获取请求头，详情可参看：
https://blog.csdn.net/mouday/article/details/80476409

middlewares.py 编写自己的中间件

from fake_useragent import UserAgent


class UserAgentMiddleware(object):
    def process_request(self, request, spider):
        ua = UserAgent()
        user_agent = ua.chrome
        request.headers.setdefault(b'User-Agent', user_agent)

settings.py 用自己的中间件替换默认中间件

DOWNLOADER_MIDDLEWARES = {
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,
    'myscrapy.middlewares.UserAgentMiddleware': 500
}

输出如下：

request headers: 
{
    b'Accept': [b'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'], b'Accept-Language': [b'en'], 
    b'User-Agent': [b'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/27.0.1453.93 Safari/537.36'], 
    b'Accept-Encoding': [b'gzip,deflate']
}

关于scrapy请求头设置，可以参考我之前的文章：
https://blog.csdn.net/mouday/article/details/80776030

cookies

上面的信息中少了个response.cookies，如果添加上回报错：

AttributeError: 'TextResponse' object has no attribute 'cookies'

说明响应是不带cookies参数的

通过 http://httpbin.org/cookies 测试cookies

# -*- coding: utf-8 -*-

from scrapy import Spider, Request
import logging


class MySpider(Spider):
    name = 'my_spider'
    allowed_domains = ['httpbin.org']
    start_urls = [
        'http://httpbin.org/cookies'
    ]


    def start_requests(self):
        for url in self.start_urls:
            yield Request(url, cookies={"username": "pengshiyu"})

    def parse(self, response):
        logging.debug("*" * 40)
        logging.debug("response text: %s" % response.text)
        logging.debug("request headers: %s" % response.request.headers)
        logging.debug("request cookies: %s" % response.request.cookies)


if __name__ == '__main__':
    from scrapy import cmdline
    cmdline.execute("scrapy crawl my_spider".split())

返回值如下：

response text: 
{
    "cookies":
        {
        "username":"pengshiyu"
        }
}

request headers: 
{
    b'Accept': [b'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'], b'Accept-Language': [b'en'], 
    b'User-Agent': [b'Scrapy/1.5.1 (+https://scrapy.org)'], 
    b'Accept-Encoding': [b'gzip,deflate'], 
    b'Cookie': [b'username=pengshiyu']
}

request cookies: 
{
    'username': 'pengshiyu'
}

服务器端已经接收到我的cookie值了，不过request的headers也包含了相同的cookie，保存到了键为Cookie下面

其实并没有什么cookie，浏览器请求的·cookies·被包装到了·headers·中发送给服务器端
既然这样，在headers中包含Cookie试试

 def start_requests(self):
        for url in self.start_urls:
            yield Request(url, headers={"Cookie": {"username": "pengshiyu"}})

返回结果

response text: 
{
    "cookies":{}
}

request headers: 
{
    b'Accept': [b'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'], b'Accept-Language': [b'en'], 
    b'User-Agent': [b'Scrapy/1.5.1 (+https://scrapy.org)'], 
    b'Accept-Encoding': [b'gzip,deflate']
}


request cookies: 
{}

cookies 是空的，设置失败

我们找到 default_settings 中的cookie中间件

'scrapy.downloadermiddlewares.cookies.CookiesMiddleware': 700

class CookiesMiddleware(object):
    """This middleware enables working with sites that need cookies"""

    def __init__(self, debug=False):
        self.jars = defaultdict(CookieJar)
        self.debug = debug

    @classmethod
    def from_crawler(cls, crawler):
        if not crawler.settings.getbool('COOKIES_ENABLED'):
            raise NotConfigured
        return cls(crawler.settings.getbool('COOKIES_DEBUG'))

    def process_request(self, request, spider):
        if request.meta.get('dont_merge_cookies', False):
            return

        cookiejarkey = request.meta.get("cookiejar")
        jar = self.jars[cookiejarkey]
        cookies = self._get_request_cookies(jar, request)
        for cookie in cookies:
            jar.set_cookie_if_ok(cookie, request)

        # set Cookie header
        request.headers.pop('Cookie', None)
        jar.add_cookie_header(request)
        self._debug_cookie(request, spider)

    def process_response(self, request, response, spider):
        if request.meta.get('dont_merge_cookies', False):
            return response

        # extract cookies from Set-Cookie and drop invalid/expired cookies
        cookiejarkey = request.meta.get("cookiejar")
        jar = self.jars[cookiejarkey]
        jar.extract_cookies(response, request)
        self._debug_set_cookie(response, spider)

        return response

    def _debug_cookie(self, request, spider):
        if self.debug:
            cl = [to_native_str(c, errors='replace')
                  for c in request.headers.getlist('Cookie')]
            if cl:
                cookies = "\n".join("Cookie: {}\n".format(c) for c in cl)
                msg = "Sending cookies to: {}\n{}".format(request, cookies)
                logger.debug(msg, extra={'spider': spider})

    def _debug_set_cookie(self, response, spider):
        if self.debug:
            cl = [to_native_str(c, errors='replace')
                  for c in response.headers.getlist('Set-Cookie')]
            if cl:
                cookies = "\n".join("Set-Cookie: {}\n".format(c) for c in cl)
                msg = "Received cookies from: {}\n{}".format(response, cookies)
                logger.debug(msg, extra={'spider': spider})

    def _format_cookie(self, cookie):
        # build cookie string
        cookie_str = '%s=%s' % (cookie['name'], cookie['value'])

        if cookie.get('path', None):
            cookie_str += '; Path=%s' % cookie['path']
        if cookie.get('domain', None):
            cookie_str += '; Domain=%s' % cookie['domain']

        return cookie_str

    def _get_request_cookies(self, jar, request):
        if isinstance(request.cookies, dict):
            cookie_list = [{'name': k, 'value': v} for k, v in \
                    six.iteritems(request.cookies)]
        else:
            cookie_list = request.cookies

        cookies = [self._format_cookie(x) for x in cookie_list]
        headers = {'Set-Cookie': cookies}
        response = Response(request.url, headers=headers)

        return jar.make_cookies(response, request)

观察源码，发现以下几个方法

# process_request
jar.add_cookie_header(request)   # 添加cookie到headers

# process_response
jar.extract_cookies(response, request)  # 提取出cookie

# _debug_cookie 
request.headers.getlist('Cookie')  # 从headers获取cookie

# _debug_set_cookie
response.headers.getlist('Set-Cookie')  # 从headers获取Set-Cookie

几个参数：

# settings
COOKIES_ENABLED
COOKIES_DEBUG

# meta
dont_merge_cookies
cookiejar

# headers
Cookie
Set-Cookie

使用最开始cookie部分的代码，为了看的清晰，我删除了headers中其他参数，下面逐个做测试

1、COOKIES_ENABLED

COOKIES_ENABLED = True (默认)

response text: 
{
    "cookies":{"username":"pengshiyu"}
}

request headers: 
{
    b'Cookie': [b'username=pengshiyu']
}

request cookies: 
{
    'username': 'pengshiyu'
}

一切ok
COOKIES_ENABLED = False 

response text: 
{
    "cookies":{}
}

request headers: 
{}

request cookies: 
{
    'username': 'pengshiyu'
}

虽然request的cookies有内容，不过headers没有加进去，所以服务器端没有获取到cookie

注意：查看请求的真正cookie，应该在request的header中查看

2、COOKIES_DEBUG
COOKIES_DEBUG = False (默认)

DEBUG: Crawled (200) <GET http://httpbin.org/cookies> (referer: None)

COOKIES_DEBUG = True
多输出了下面一句，可以看到我设置的cookie

[scrapy.downloadermiddlewares.cookies] DEBUG: Sending cookies to: <GET http://httpbin.org/cookies>
Cookie: username=pengshiyu

当然，debug模式下服务器肯定能正常接收我的cookie

3、dont_merge_cookies
设置meta={"dont_merge_cookies": True} 默认为 False

response text: 
{
    "cookies":{}
}

request headers: 
{}

request cookies: 
{
    'username': 'pengshiyu'
}

服务器并没有接收到我的cookie

4、cookiejar
直接通过response.request.meta.get("cookiejar")获取


response text: 
{"cookies":{"username":"pengshiyu"}}

request headers: 
{b'Cookie': [b'username=pengshiyu']}

request cookies: 
{'username': 'pengshiyu'}

request cookiejar: 
None

啥也没有

5、Cookie
直接获取：response.request.headers.get("Cookie"))

headers Cookie: 
b'username=pengshiyu'

看来这里已经被处理成字节串了

修改Request请求参数
cookies={"username": "pengshiyu", "password": "123456"}

# response.request.headers.get("Cookie"))
headers Cookie: 
b'username=pengshiyu; password=123456'

# request.headers.getlist('Cookie')
headers Cookies: 
[b'username=pengshiyu; password=123456']

很明显，两个获取方式，一个获取的是字符串，一个获取的是列表

6、Set-Cookie

同样，我通过以下

response.headers.get("Set-Cookie")
response.headers.getlist("Set-Cookie")

还是啥都没有

headers Set-Cookie: None
headers Set-Cookies: []

不过，到目前为止，cookie设置的大概流程应该如下：

request cookies: {'username': 'pengshiyu', 'password': '123456'}
request cookiejar: None
request Cookie: b'username=pengshiyu; password=123456'
response text: {"cookies":{"password":"123456","username":"pengshiyu"}}
response Set-Cookie: None
response Set-Cookies: []

7、接收服务器传递过来的cookie

将请求链接改为 ：’http://httpbin.org/cookies/set/key/value’
开启 COOKIES_DEBUG
在debug中看到如下变化

Sending cookies to: <GET http://httpbin.org/cookies/set/key/value>
Cookie: username=pengshiyu; password=123456

Received cookies from: <302 http://httpbin.org/cookies/set/key/value>
Set-Cookie: key=value; Path=/

Redirecting (302) to <GET http://httpbin.org/cookies> from <GET http://httpbin.org/cookies/set/key/value>

Sending cookies to: <GET http://httpbin.org/cookies>
Cookie: key=value; username=pengshiyu; password=123456

日志看出他进行了两次请求，看到中间的cookie变化：

发送 -> 接收 -> 发送

第二次发送的cookie包含了第一次请求时服务器端传递过来的cookie，说明scrapy对服务器端和客户端的cookie进行了管理

最后的cookie输出

request cookies: {'username': 'pengshiyu', 'password': '123456'}
request cookiejar: None
request Cookie: b'key=value; username=pengshiyu; password=123456'
response text: {"cookies":{"key":"value","password":"123456","username":"pengshiyu"}}
response Set-Cookie: None

request的cookies并没有变化，而request.headers.get(“Cookie”)已经发生了变化

8、接收服务器传递过来的 同key键cookie
将请求链接换为：httpbin.org/cookies/set/username/pengpeng

Sending cookies to: <GET http://httpbin.org/cookies/set/username/pengpeng>
Cookie: username=pengshiyu

Received cookies from: <302 http://httpbin.org/cookies/set/username/pengpeng>
Set-Cookie: username=pengpeng; Path=/

Redirecting (302) to <GET http://httpbin.org/cookies> from <GET http://httpbin.org/cookies/set/username/pengpeng>

Sending cookies to: <GET http://httpbin.org/cookies>
Cookie: username=pengshiyu

发现虽然收到了username=pengpeng但是，第二次发请求的时候，又发送了原来的的cookieusername=pengshiyu

这说明客户端设置的cookie优先级高于服务器端传递过来的cookie

9、取消使用中间件CookiesMiddleware

DOWNLOADER_MIDDLEWARES = {
    'scrapy.downloadermiddlewares.cookies.CookiesMiddleware': None
}

请求链接：http://httpbin.org/cookies

request cookies: {'username': 'pengshiyu'}
request cookiejar: None
request Cookie: None
response text: {"cookies":{}}
response Set-Cookie: None
response Set-Cookies: []

这个效果类似COOKIES_ENABLED = False

10、自定义cookie池

class RandomCookiesMiddleware(object):
    def process_request(self, request, spider):
        cookies = []
        cookie = random.choice(cookies)
        request.cookies = cookie

同样需要设置

DOWNLOADER_MIDDLEWARES = {
    'myscrapy.middlewares.RandomCookiesMiddleware': 600
}

注意到scrapy的中间件CookiesMiddleware值是700,为了cookie设置生效，需要在这个中间件启用之前就设置好自定义的cookie，优先级按照从小到大的顺序执行，所以我们自己自定义的cookie中间件需要小于 < 700

'scrapy.downloadermiddlewares.cookies.CookiesMiddleware': 700,

总结

参数设置获取说明
metaRequest(url, meta={“uid”: “100”}) request.meta[“uid”] = “100”response.request.meta.get(“uid”) response.meta.get(“uid”)携带request参数给response,或设置代理
headersRequest(url, headers={“User-Agent”: “chrome”}) request.headers[“User-Agent”]=”chrome” USER_AGENT=”chrome”response.request.headers.get(“User-Agent”)设置客户端请求头参数
cookiesRequest(url, cookies={“username”: “pengshiyu”} ) request.cookies = {“username”: “pengshiyu”}response.request.cookies response.request.headers.get(“Cookie”) response.headers.get(‘Set-Cookie’)客户端请求头中的Cookie参数，管理客户端与服务器端之间的会话识别

常用的中间件如下

import random
from fake_useragent import UserAgent


class RandomUserAgentMiddleware(object):
    def process_request(self, request, spider):
        ua = UserAgent()
        user_agent = ua.chrome
        request.headers.setdefault(b'User-Agent', user_agent)


class RandomProxyMiddleware(object):
    def process_request(self, request, spider):
        proxies = []
        proxy = random.choice(proxies)
        request.meta["proxy"] = proxy


class RandomCookiesMiddleware(object):
    def process_request(self, request, spider):
        cookies = []
        cookie = random.choice(cookies)
        request.cookies = cookie

当然，cookies 和 proxies 需要结合自己的情况补全

彭世瑜
关注
专栏目录
Scrapy设置随机请求头
JunsIr的技术栈
10-16 2042
Python3反反爬虫之Scrapy设置随机请求头 基本介绍 设置随机请求头是应对反爬虫的一种手段，如果某个相同的请求头对目标网站频繁进行访问，可能会被封禁。 故此我们在爬虫的时候最好随机更改我们的请求头，我将在Scrapy的下载器中间件上进行随机更改请求头 常见备选请求头User-Agent Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535...
python的scrapy爬虫模块间进行传参_scrapy爬虫:scrapy.FormRequest中formdata参数详解
weixin_39921689的博客
12-14 876
1. 背景在网页爬取的时候，有时候会使用scrapy.FormRequest向目标网站提交数据(表单提交)。参照scrapy官方文档的标准写法是：# header信息unicornHeader = {'Host': 'www.example.com','Referer': 'http://www.example.com/',}# 表单需要提交的数据myFormData = {'name': 'Jo...
scrapy提交参数请求
m0_46780416的博客
07-17 194
【代码】scrapy提交参数请求。
scrapy中间件-随机请求头
最新发布
克里斯蒂亚诺更新的博客
07-27 137
在settings中原本是一个USER_AGENT,现在增加USER_AGENT_LIST列表，目的是每次爬虫一个网址的时候，不用总用同一个User-Agent。此时已经完成了 每次爬取网址的时候使用不同的User-Agent的处理。可以在def parse中打印response的值即可。如果要查看每次用了哪些User-Agent?
Python爬虫：关于scrapy模块的请求头
彭世瑜的博客
06-22 2万+
内容简介 使用scrapy写爬虫的时候，会莫名其妙的被目标网站拒绝，很大部分是浏览器请求头的原因，现在一起来看看scrapy的请求头 工具准备 开发环境python2.7 + scrapy 1.1.2 测试请求头网站：https://httpbin.org/get?show_env=1 json在线解析：https://www.json.cn/ 浏览器请求头大全： http://w...
scrapy各种请求参数
wang785994599的博客
10-10 3334
get请求 查询字符串 1.使用FormRequest start_urls = ['https://careers.tencent.com/tencentcareer/api/post/Query?'] def start_requests(self): for url in self.start_urls: params = { "timestamp": str(int(time.time() * 1000)),
Scrapy发送POST请求携带Request Payload参数
木子的博客
09-18 1078
首先我们来看看我的辛酸历程，各种报错 报错1：服务器居然回个500来骗我说服务器故障，不得不说开发人员真的是太坏了，不过我就喜欢这样的。 报错2：没有足够的值解包，需要的是2个，结果只有1个，难道问题在这？我们再往下看 报错3：说无法解压缩，不可编辑的int对象，这是啥，莫非是我传的参数有问题？反复检查，怀疑人生中...... 报错4：返回405，并且是一个GET请求，？？？，FormRequest不是POST请求吗，怎么变成了GET请求？又是一顿检查，各种修改，然后怀疑人生...... ..
Python中Scrapy框架
既然选择远方，便只顾风雨兼程！
04-15 4228
文章目录Scrapy 框架一、 简介1、 介绍2、 环境配置3、 常用命令4、 运行原理4.1 流程图4.2 部件简介4.3 运行流程二、 创建项目1、 修改配置2、 创建一个项目3、 定义数据4、 编写并提取数据5、 存储数据6、 运行文件三、 日志打印1、 日志信息2、 logging 模块四、 全站爬取1、 使用request排序入队2、 继承crawlspider五、 二进制文件1、 图片下载六、 middlewares1、下载中间件2、 爬虫中间件七、 模拟登录1、 cookie2、 直接登录八、
爬虫--06：scrapy框架
Rhymeplot__JDQS的博客
05-05 1051
Crawler-06: Scrapy Framework scrapy框架基础一、scrapy框架的介绍二、scrapy框架的工作流程 scrapy框架基础 一、scrapy框架的介绍 Scrapy是一个为了爬取网站数据，提取结构性数据而编写的应用框架，我们只需要实现少量的代码，就能够快速的抓取 Scrapy使用了Twisted异步网络框架，可以加快我们的下载速度 异步：调用在发出之后，这个调用就直接返回，不管有无结果 非阻塞：关注的是程序在等待调用结果时的状态，指在不能立刻得到结果之前，该调用不会阻塞当
爬虫框架 Scrapy 详解
m0_67403076的博客
07-31 1万+
Scrapy是适用于Python的一个快速、高层次的屏幕抓取和web抓取框架，用于抓取web站点并从页面中提取结构化的数据。Scrapy用途广泛，可以用于数据挖掘、监测和自动化测试。Scrapy是一个框架，可以根据需求进行定制。它也提供了多种类型爬虫的基类，如BaseSpider、sitemap爬虫等，最新版本又提供了web2.0爬虫的支持。...
Python爬虫Scrapy框架：关于scrapy中scrapy.Request中的属性
Python-全栈开发教程-入门到精通
12-18 259
一.源码 def __init__(self, url, callback=None, method='GET', headers=None, body=None, cookies=None, meta=None, encoding='utf-8', priority=0, dont_filter=False, errba...
scrapy中的headers，Request，response
12-22
文章目录headersRequestresponse headers 为了让程序请求模仿的更像浏览器，需要在headers请求头上添加一些参数 headers请求头的部分重要参数： Host (主机和端口号) Connection (链接类型) Upgrade-Insecure-Requests (升级为HTTPS请求) User-Agent (浏览器名称) Accept (传输文件类型) Referer (页面跳转处) Accept-Encoding（文件编解码格式） Cookie （Cookie） x-requested-with :XMLHttpRequest (是Ajax 异步请求)
scrapy:请求传参
weixin_41391619的博客
12-27 1346
使用场景：需要的数据不能在同一个parse函数中获得（比如在起始页面通过parse1函数拿到了压缩包名称和压缩包详细信息的detail_url,要对detail_url发起请求并通过parse2函数解析才能获得压缩包的下载链接download_url） 方法：通过scrapy.Request对detail_url发送请求时，添加一个meta参数：meta={‘item’:item}；将meta传递给Request对应的回调函数（即parse2函数） 爬虫文件中的代码: import scra..
scrapy-设置请求头
热门推荐
后青春诗ing
08-02 2万+
当我们大量使用scrapy 请求一个网站的时候我们知道scrapy默认的请求头是： 可以看到默认的请求头就是scrapy，这样就很容易导致浏览器封掉的可能，这个时候我们就需要给请求加一个请求头来模拟浏览器，一般的可以这样做： 可以直接在spider文件中添加custom_settings 这个设置，代码如下： custom_settings = { 'LOG_LEVEL'...
scrapy带参数的命令
步步拾遗
07-15 1564
带请求头使用shell：scrapy     shell     -s    USER_AGENT="content"     url输出信息：使用self.log()函数ItemLoader的使用：ItemLoader在每个字段都包含了一个输入处理器和一个输出处理器， 输入处理器收到数据时立刻提取数据 (通过 add_xpath(), add_css() 或者 add_value() 方法) 之...
scrapy请求， 只返回头部信息
haipengdai的博客
12-29 8360
公司的网站最近一直在导数据， 经常没有注意到的时候就出来一些404， 对网站不利， 所以需要检测网站的404， 最简单的就是全站爬一遍了， 但是如果用scrapy去爬的话， 遇到ajax请求这些的还得单写， 所以最终的方案是由后台的同事给出他们计算出来的所有slug的列表， 从这些slug列表中抽出一些进行404检查， 包括这些slug内部的链接也拿出来检查， check的效果还行， 就是速度实在
爬虫 - Scrapy请求传参
qq_33962481的博客
05-07 687
文章目录二、使用步骤1.引入库2.读入数据总结 # 一、请求传参 - 使用场景 : 如果爬取解析的数据不在同一张页面中 - d 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warnings warnings.filterwarnings('ignore') import ssl ssl._create_d
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值