Python 16 爬虫（二）

最新推荐文章于 2024-05-07 18:46:52 发布
最新推荐文章于 2024-05-07 18:46:52 发布
阅读量130 收藏
点赞数
文章标签： 爬虫 python 数据库
原文链接：http://www.cnblogs.com/yinwenjie/p/10853710.html
版权

内容概要：

1、安装及基本使用

2、起始请求定制

3、解析器/选择器

4、cookie及请求头处理

5、pipeline持久化

6、去重规则

7、深度和优先级

8、中间件

9、定制命令

10、信号

11、scrapy-redis

 

https://www.cnblogs.com/wupeiqi/articles/6229292.html

scrapy的组件及执行流程：

-引擎找到要执行的爬虫，并执行爬虫的start_requests方法，并得到一个生成器，里面是Request对象，封装了要访问的url和回调函数。

-循环生成器，将url经过去重后放到调度器中等待下载。

-下载器去调度器中获取要下载的任务（Request对象），下载完成后执行回调函数。

-回到spider的回调函数中，

　　如果 yield Request（），则继续放到调度器中。

　　如果 yield Item（），则执行pipelines处理爬取到的数据。

 

一、安装和基本使用

windows下scrapy的安装比较麻烦，分为4部，参照https://baijiahao.baidu.com/s?id=1597465401467369572&wfr=spider&for=pc

Linux：

1 pip install scrapy

windows:

1 pip install wheel
2 下载twisted http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted
3 进入下载目录，执行 pip3 install Twisted‑17.1.0‑cp35‑cp35m‑win_amd64.whl
4 pip3 install scrapy
5 下载并安装pywin32：https://sourceforge.net/projects/pywin32/files/

 

twisted：是基于事件循环的异步非阻塞网络框架

 

1、创建项目

scrapy startproject 项目名称
    - 在当前目录中创建中创建一个项目文件（类似于Django）

scrapy genspider [-t template] <name> <domain>
    - 穿件爬虫应用
    如：scrapy gensipider -t basic oldboy oldboy.com
          scrapy gensipider -t xmlfeed autohome autohome.com.cn

查看所有命令：scrapy gensipider -l
查看模板命令：scrapy gensipider -d 模板名称

scrapy list
    - 展示爬虫应用列表

scrapy crawl 爬虫应用名称
    - 运行单独爬虫应用

 

2、项目结构以及爬虫应用简介

创建scrapy后会有一个完整的项目框架：

文件说明：

  • scrapy.cfg  项目的主配置信息。（真正与爬虫相关的配置在settings.py中）
  • items.py  设置数据存储模板，用于结构化数据。如Django中的Model
  • pipelines.py  数据处理行为，如一般结构化的数据持久化。
  • settings.py  配置文件。如递归的层数、并发数、延迟下载等。
  • spiders  爬虫目录

 

以抽屉为例编写第一个爬虫：

import scrapy


class ChoutiSpider(scrapy.Spider):
    name = 'chouti'  # 外部scrapy调用的爬虫应用名称
    allowed_domains = ['chouti.com']  # 允许的域名
    start_urls = ['http://dig.chouti.com/']  # 起始url

    def parse(self, response):  # 访问起始url并获取结果后的回调函数
        print(response.text)  # response就是返回结果

注意：

1、在这里默认情况下是打印不出东西的，因为settings里面ROBOTSTXT_OBEY = True，默认遵从协议，所以把这里改成False才行。

2、windows环境下可能会遇到编码问题：

import sys,os
sys.stdout=io.TextIOWrapper(sys.stdout.buffer,encoding='gb18030')

如上，需要在抽屉网中抓去热榜的所有标题，图中的框已经标好，从content-list入手，抓取每一个item中class为part2的share-title

class ChoutiSpider(scrapy.Spider):
    name = 'chouti'
    allowed_domains = ['chouti.com']
    start_urls = ['http://dig.chouti.com/']

    def parse(self, response):
        """
        1.获取想要的内容
        2.如果分页，继续下载内容

        :param response:
        :return:
        """
        # 获取当前页的内容
        item_list = response.xpath('//div[@id="content-list"]/div[@class="item"]')
        # /子标签
        # //起始位置时，是在全局进行查找；非起始位置是在当前标签的子子孙孙内部找
        # ./当前对象下面找

        # 获取index为0的对象中的第一个满足条件的文本
        # obj = item_list[0].xpath('./div[@class="news-content"]//div[@class="part2"]/@share-title').extract_first()
        obj_list = item_list.xpath('./div[@class="news-content"]//div[@class="part2"]/@share-title').extract()
        print(obj_list)  # 获取的结果是列表
        
        #如果获取的是文本内容不是属性的话
        obj = item_list[0].xpath('./div[@class="news-content"]//div[@class="show-content"]/text()').extract()

执行命令：

scrapy crawl chouti --nolog

 

如果分页的内容也要爬取：

import scrapy


class ChoutiSpider(scrapy.Spider):
    name = 'chouti'
    allowed_domains = ['chouti.com']
    start_urls = ['http://www.chouti.com/']

    def parse(self, response):
        f = open("news.txt","a+")
        item_list = response.xpath("//div[@id='content-list']/div[@class='item']")
        for item in item_list:
            text = item.xpath(".//a/text()").extract_first()
            href = item.xpath(".//a/@href").extract_first()
            f.write(href+"\n")
        f.close()

        page_list = response.xpath("//div[@id='dig_lcpage']//a/@href").extract()
        for page in page_list:
            url = "https://dig.chouti.com" + page
            print(url)
            from scrapy.http import Request
            yield Request(url=url, callback=self.parse)

 

二、起始请求定制

方式一：源码中的方式

class ChoutiSpider(scrapy.Spider):
    name = 'chouti'
    allowed_domains = ['chouti.com']
    start_urls = ['http://www.chouti.com/']
    cookie_dict = {}

    def start_requests(self):
        for url in self.start_urls:
            yield Request(url=url)

方式二：可以自定义

def start_requests(self):
    url_list = []
    for url in self.start_urls:
        url_list.append(Request(url=url))
    return url_list

方式一返回一个生成器，方式二返回一个可迭代对象，都能够实现，其内部是使用了iter（）方法，不管是生成器还是可迭代对象，都转换成生成器。

1. 调用start_request方法并获取返回值

2. v = iter(返回值)

3. v.__next__拿到所有结果

4. 放到调度器中

 

三、选择器 / 解析器

 

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 from scrapy.selector import Selector, HtmlXPathSelector
 4 from scrapy.http import HtmlResponse
 5 html = """<!DOCTYPE html>
 6 <html>
 7     <head lang="en">
 8         <meta charset="UTF-8">
 9         <title></title>
10     </head>
11     <body>
12         <ul>
13             <li class="item-"><a id='i1' href="link.html">first item</a></li>
14             <li class="item-0"><a id='i2' href="llink.html">first item</a></li>
15             <li class="item-1"><a href="llink2.html">second item<span>vv</span></a></li>
16         </ul>
17         <div><a href="llink2.html">second item</a></div>
18     </body>
19 </html>
20 """
21 response = HtmlResponse(url='http://example.com', body=html,encoding='utf-8')
22 # hxs = HtmlXPathSelector(response)
23 # print(hxs)
24 # hxs = Selector(response=response).xpath('//a')
25 # print(hxs)
26 # hxs = Selector(response=response).xpath('//a[2]')
27 # print(hxs)
28 # hxs = Selector(response=response).xpath('//a[@id]')
29 # print(hxs)
30 # hxs = Selector(response=response).xpath('//a[@id="i1"]')
31 # print(hxs)
32 # hxs = Selector(response=response).xpath('//a[@href="link.html"][@id="i1"]')
33 # print(hxs)
34 # hxs = Selector(response=response).xpath('//a[contains(@href, "link")]')
35 # print(hxs)
36 # hxs = Selector(response=response).xpath('//a[starts-with(@href, "link")]')
37 # print(hxs)
38 # hxs = Selector(response=response).xpath('//a[re:test(@id, "i\d+")]')
39 # print(hxs)
40 # hxs = Selector(response=response).xpath('//a[re:test(@id, "i\d+")]/text()').extract()
41 # print(hxs)
42 # hxs = Selector(response=response).xpath('//a[re:test(@id, "i\d+")]/@href').extract()
43 # print(hxs)
44 # hxs = Selector(response=response).xpath('/html/body/ul/li/a/@href').extract()
45 # print(hxs)
46 # hxs = Selector(response=response).xpath('//body/ul/li/a/@href').extract_first()
47 # print(hxs)
48  
49 # ul_list = Selector(response=response).xpath('//body/ul/li')
50 # for item in ul_list:
51 #     v = item.xpath('./a/span')
52 #     # 或
53 #     # v = item.xpath('a/span')
54 #     # 或
55 #     # v = item.xpath('*/a/span')
56 #     print(v)
View Code

 

 抽屉自动点赞项目链接：https://www.cnblogs.com/yinwenjie/p/10861855.html

 

四、cookie和请求头

方式一：

 1 class ChoutiSpider(scrapy.Spider):
 2     name = 'chouti'
 3     allowed_domains = ['chouti.com']
 4     start_urls = ['http://www.chouti.com/']
 5     cookie_dict = {}
 6 
 7     def parse(self, response):
 8         from scrapy.http.cookies import CookieJar
 9 
10         cookie_jar = CookieJar()
11         cookie_jar.extract_cookies(response, response.request)
12 
13         # 去对象中将cookie解析到字典
14         for k, v in cookie_jar._cookies.items():
15             for i, j in v.items():
16                 for m, n in j.items():
17                     self.cookie_dict[m] = n.value
18 
19         from scrapy.http import Request
20         yield Request(
21             url="https://dig.chouti.com/login",
22             method='POST',   #默认是GET
23             headers={        
24                 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
25                 'user-agent': 'xxxx'
26             },
27             body="phone=8613121758648&password=woshiniba&oneMonth=1",         #可以通过urlencode模块把字典自动解析成这样的格式
28             cookies=self.cookie_dict
29         )

在配置中自动设置请求头中的user-agent：

1 USER_AGENT = 'xxxxxx'

urlencode模块解析字典：

1 from urllib.parse import urlencode
2 data = {'k1': 'v1', 'k2': 'v2'}
3 body = urlencode(data)
4 #得到结果："k1=v1&k2=v2"

 

方式二：

#在需要获取cookie值的请求中
Request(url=url, meta={"cookiejar": True})

#在需要用这个cookie值的请求中
Request(url=url, meta={"cookiejar": response.meta["cookiejar"]})

 

五、pipeline实现持久化（格式化处理）

上面这个程序在每次循环都要打开一次文件，利用pipeline可以实现只打开一次文件，在结尾关闭文件。

chouti.py：

import scrapy
from scrapy1.items import Scrapy1Item

class ChoutiSpider(scrapy.Spider):
    name = 'chouti'
    allowed_domains = ['chouti.com']
    start_urls = ['http://www.chouti.com/']

    def parse(self, response):
        # f = open("news.txt","a+")
        item_list = response.xpath("//div[@id='content-list']/div[@class='item']")
        for item in item_list:
            text = item.xpath(".//a/text()").extract_first()
            href = item.xpath(".//a/@href").extract_first()
            yield Scrapy1Item(text=text, href=href)

items.py：

import scrapy
class Scrapy1Item(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    text = scrapy.Field()
    href = scrapy.Field()

pipelines.py：

from scrapy.exceptions import DropItem

class Scrapy1Pipeline(object):
    def __init__(self, path):  #如果不使用定义from_crawler方法就不能传参数
        self.f = None
        self.path = path

    @classmethod
    def from_crawler(cls, crawler):
        #初始化是用于创建pipeline对象，可以传参数
        path = crawler.settings.get("HREF_FILE_PATH")
        return cls(path)

    def open_spider(self, spider):
        self.f = open(self.path, "w+")

    def process_item(self, item, spider):
        self.f.write(item["href"] + "\n")
        #raise DropItem()  #如果不让后续的pipeline运行就引出异常
        return item  #把item交给下一个pipeline的process_item方法

    def close_spider(self, spider):
        self.f.close()

pipelines对所有爬虫生效，如果想单独设置，可以通过spider.name来设置条件。

还需要在settings中配置一下，默认这项是被注释的：

ITEM_PIPELINES = {
    'xdb.pipelines.XdbPipeline': 300,  #数值是优先级，小的先执行
}

 

六、去重规则

scrapy自动有去重功能，在'scrapy.dupefilters'文件中的BaseDupeFilter和RFPDuperFilter中

自定义一个去重功能：

from scrapy.dupefilters import BaseDupeFilter
from scrapy.utils.request import request_fingerprint

def ChoutiDupeFilter(BaseDupeFilter):
    def __init__(self):
        self.visited_fd = set()

    @classmethod
    def from_settings(cls,settings):
        return cls()

    def request_seen(self,request):
        fd = request_fingerprint(request=request)
        if fd in self.visited_fd:
            return True
        self.visited_fd.add(fd)

    def open(self):
        print('开始')

    def close(self,reason):
        print('结束')

配置文件：

DUPEFILTER_CLASS = 'scrapy1.dupefilters.ChoutiDupeFilter'

 

七、深度和优先级

深度配置文件：

DEPTH_LIMIT = 3
response.meta.get("depth",0)   #获取当前深度，第一次请求取不到，赋值0

第一个请求到来，depth赋值为0，后面每次的深度在上一个请求的基础上+1

 

优先级

DEPTH_PRIORITY = XX

优先级 = 原来的优先级 - depth * 优先级，结果是负值，越来越小，优先级也越来越低。

 

八、中间件

1.下载中间件

当调度器把Request对象送给下载器下载时经过中间件。

有三种不常用的返回值：

  1. return HtmlResponse(url="xxx", status=200, headers=None, body=b'xxx')  不去下载器中下载，直接伪造一个响应结果，并走到第一个process_response
  2. return Request(url="xxx") 重新返回到调度器中，这样不会有结果，因为调度器接收后到达中间件时又会返回到调度器，陷入循环。
  3. raise IgnoreRequest  报错，执行process_exception

一般使用下载中间件对请求进行加工。比如在settings中有一个USER_AGENT，设置之后请求会在动在请求头中加上，就是利用的中间件添加的。

配置：

DOWNLOADER_MIDDLEWARES = {
    "chouti.middlewares.xxxxx": 100,
    "chouti.middlewares.xxxxx": 120
}# 数值越小，优先级越高

 

2.爬虫中间件

 配置：

SPIDER_MIDDLEWARES = {
    XXXXXX
}

 

代理中间件

方式一：自带的代理

在httpproxy.py文件的HttpProxyMiddleware类中定义里代理，在爬虫启动时在os.environ中设置即可，os.environ保存着进程的相关信息。

import os
os.environ["HTTPS_PROXIES"] = "https://root:mima@192.168.1.1:9999/"
os.environ["HTTP_PROXIES"] = "19.11.2.12"

或者可以用meta传参

yield Request(url=url, callback=xxx, meta={"proxy":"19.12.2.1"})

由于内置的代理只能使用一个代理，如果频率太快会被封，所以需要自定义代理，实现每次随机使用一个代理。

方式二：自定义代理

 

九、定制命令

单爬虫运行：

#在文件夹下创建一个py文件from scrapy.cmdline import execute

if __name__ == "__main__":
    execute(["scrapy". "crawl", "chouti", "--nolog"])

 

多爬虫运行：

  • 在spider的同级目录下创建任意目录，如：commands
  • 在其中创建crawlall.py文件（文件名就是自定制的命令），如果创建了多个文件，就是创建了多个命令 
     1 from scrapy.commands import ScrapyCommand
 2 from scrapy.utils.project import get_project_settings
 3 
 4 
 5     class Command(ScrapyCommand):
 6 
 7         requires_project = True
 8 
 9         def syntax(self):
10             return '[options]'
11 
12         def short_desc(self):
13             return 'Runs all of the spiders'
14 
15         def run(self, args, opts):
16             spider_list = self.crawler_process.spiders.list()  # 去spiders文件夹下获取所有的爬虫文件
17             for name in spider_list:
18                 self.crawler_process.crawl(name, **opts.__dict__)  # 为所有的爬虫创建任务
19             self.crawler_process.start()  # 并发的开始执行
20 
21 crawlall.py
    View Code
  • 在settings中配置 
    COMMANDS_MODULE = 'chouti.commands'
  • 执行 scrapy crawlall（就是执行文件里的run方法）

 

十、信号

信号是框架给用户提供的可扩展部分，可以在请求开始前、结束时、报错时等等情况下添加一些功能。

 1 from scrapy import signals
 2 
 3 class MyExtension(object):
 4     def __init__(self, value):
 5         self.value = value
 6 
 7     @classmethod
 8     def from_crawler(cls, crawler):
 9         self = cls()
10 
11         crawler.signals.connect(ext.openn, signal=signals.spider_opened)
12         crawler.signals.connect(ext.closee, signal=signals.spider_closed)
13 
14         return self
15 
16     def openn(self, spider):
17         print('open')
18 
19     def closee(self, spider):
20         print('close')
EXTENSIONS = {
    'chouti.ext.MyExtension' : 666
}
"""
Scrapy signals

These signals are documented in docs/topics/signals.rst. Please don't add new
signals here without documenting them there.
"""

engine_started = object()
engine_stopped = object()
spider_opened = object()
spider_idle = object()
spider_closed = object()
spider_error = object()
request_scheduled = object()
request_dropped = object()
response_received = object()
response_downloaded = object()
item_scraped = object()
item_dropped = object()

# for backwards compatibility
stats_spider_opened = spider_opened
stats_spider_closing = spider_closed
stats_spider_closed = spider_closed

item_passed = item_scraped

request_received = request_scheduled
scrapy所有信号

 

十一、、scrapy-redis（分布式爬虫的组件）

1、redis连接配置

REDIS_HOST = '140.143.227.206'  # 主机名
REDIS_PORT = 8888  # 端口
REDIS_PARAMS = {'password': 'beta'}  # Redis连接参数         默认：REDIS_PARAMS = {'socket_timeout': 30,'socket_connect_timeout': 30,'retry_on_timeout': True,'encoding': REDIS_ENCODING,}）
REDIS_ENCODING = "utf-8"
# REDIS_URL = 'redis://user:pass@hostname:9001'       # 连接URL（优先于以上配置）

2、在redis中保存去重记录：

DUPEFILTER_KEY = 'dupefilter:%(timestamp)s'
DUPEFILTER_CLASS = 'scrapy_redis.dupefilter.RFPDupeFilter'

但是默认的去重，在把url保存到redis中时，使用的key是用时间戳拼接的，造成key值不确定，所以可以通过自定制的方式，定制一个确定的key方便取值：

from scrapy_redis.dupefilter import RFPDupeFilter
from scrapy_redis.connection import get_redis_from_settings
from scrapy_redis import defaults

class RedisDupeFilter(RFPDupeFilter):
    @classmethod
    def from_settings(cls, settings):
        server = get_redis_from_settings(settings)
        key = defaults.DUPEFILTER_KEY % {'timestamp': 'xxx'}
        debug = settings.getbool('DUPEFILTER_DEBUG')
        return cls(server, key=key, debug=debug)

scrapy-redis的去重是把访问过的链接放在redis中一个key为 "duperfilter:xxx" 的字典中，字典中维护一个集合，如果已有该链接则返回0，如果没有则返回1。

3、将调度器放到redis中

SCHEDULER = "scrapy_redis.scheduler.Scheduler"

DEPTH_PRIORITY = 1  # 广度优先
# DEPTH_PRIORITY = -1 # 深度优先
SCHEDULER_QUEUE_CLASS = 'scrapy_redis.queue.PriorityQueue'  # 默认使用优先级队列（默认），其他：PriorityQueue（有序集合），FifoQueue（列表）、LifoQueue（列表）

# 广度优先
# SCHEDULER_QUEUE_CLASS = 'scrapy_redis.queue.FifoQueue'  # 默认使用优先级队列（默认），其他：PriorityQueue（有序集合），FifoQueue（列表）、LifoQueue（列表）
# 深度优先
# SCHEDULER_QUEUE_CLASS = 'scrapy_redis.queue.LifoQueue'  # 默认使用优先级队列（默认），其他：PriorityQueue（有序集合），FifoQueue（列表）、LifoQueue（列表）
SCHEDULER_QUEUE_KEY = '%(spider)s:requests'  # 调度器中请求存放在redis中的key

SCHEDULER_SERIALIZER = "scrapy_redis.picklecompat"  # 对保存到redis中的数据进行序列化，默认使用pickle

SCHEDULER_PERSIST = False  # 是否在关闭时候保留原来的调度器和去重记录，True=保留，False=清空
SCHEDULER_FLUSH_ON_START = True  # 是否在开始之前清空 调度器和去重记录，True=清空，False=不清空
# SCHEDULER_IDLE_BEFORE_CLOSE = 10  # 去调度器中获取数据时，如果为空，最多等待时间（最后没数据，未获取到）。


SCHEDULER_DUPEFILTER_KEY = '%(spider)s:dupefilter'  # 去重规则，在redis中保存时对应的key

# 优先使用DUPEFILTER_CLASS，如果么有就是用SCHEDULER_DUPEFILTER_CLASS
SCHEDULER_DUPEFILTER_CLASS = 'scrapy_redis.dupefilter.RFPDupeFilter'  # 去重规则对应处理的类

4、起始url放到redis中 

 

源码流程：

1、scrapy crawl chouti --nolog

2、找到 SCHEDULER = "scrapy_redis.scheduler.Scheduler"配置，并实例化调度器对象。

#执行Scheduler.from_crawler
    @classmethod
    def from_crawler(cls, crawler):
        instance = cls.from_settings(crawler.settings)
        instance.stats = crawler.stats
        return instance

#执行Scheduler.from_settings
- 读取配置文件：
SCHEDULER_PERSIST  # 是否在关闭时候保留原来的调度器和去重记录，True=保留，False=清空
SCHEDULER_FLUSH_ON_START  # 是否在开始之前清空 调度器和去重记录，True=清空，False=不清空
SCHEDULER_IDLE_BEFORE_CLOSE  # 去调度器中获取数据时，如果为空，最多等待时间（最后没数据，未获取到）。
- 读取配置文件：
SCHEDULER_QUEUE_KEY  # %(spider)s:requests
SCHEDULER_QUEUE_CLASS  # scrapy_redis.queue.FifoQueue
SCHEDULER_DUPEFILTER_KEY  # '%(spider)s:dupefilter'
DUPEFILTER_CLASS  # 'scrapy_redis.dupefilter.RFPDupeFilter'
SCHEDULER_SERIALIZER  # "scrapy_redis.picklecompat"

- 读取配置文件：
REDIS_HOST = '140.143.227.206'  # 主机名
REDIS_PORT = 8888  # 端口
REDIS_PARAMS = {
   'password': 'beta'}  # Redis连接参数             默认：REDIS_PARAMS = {'socket_timeout': 30,'socket_connect_timeout': 30,'retry_on_timeout': True,'encoding': REDIS_ENCODING,}）
REDIS_ENCODING = "utf-8"
- 实例化Scheduler对象
Scheduler实例化

3、爬虫开始执行起始url

#调用Scheduler.enqueue_request()

def enqueue_request(self, request):
    #判断请求是否需要过滤
    #判断去重规则是否已经存在
    if not request.dont_filter and self.df.request_seen(request):
        self.df.log(request, self.spider)
        return Flase  #已经访问过，不需要再访问
    if self.stats:
        self.stats.inc_value('scheduler/enqueued/redis', spider=self.spider)
    self.queue.push(request)
    return True
Scheduler.enqueue_request

4、下载器去调度器中获取任务

    def next_request(self):
        block_pop_timeout = self.idle_before_close
        request = self.queue.pop(block_pop_timeout)
        if request and self.stats:
            self.stats.inc_value('scheduler/dequeued/redis', spider=self.spider)
        return request
Scheduler.next_request

 相关问题：

 

十二、其他配置文件

 

转载于:https://www.cnblogs.com/yinwenjie/p/10853710.html

weixin_33889245
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python爬虫20个案例
03-25
讲诉python爬虫的20个案例 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
Python 万能代码模版：爬虫代码篇
AI悦创·编程私教1v1
09-14 11万+
你好，我是悦创。 很多同学一听到 Python 或编程语言，可能条件反射就会觉得“很难”。但今天的 Python 课程是个例外，因为今天讲的 **Python 技能，不需要你懂计算机原理，也不需要你理解复杂的编程模式。**即使是非开发人员，只要替换链接、文件，就可以轻松完成。 并且这些几个实用技巧，简直是 Python 日常帮手的最佳实践。比如： 爬取文档，爬表格，爬学习资料； 玩转图表，生成数据可视化； 批量命名文件，实现自动化办公； 批量搞图，加水印、调尺寸。 接下来，我们就逐一用 Python 实
Python爬虫详解（一看就懂）
我的博客
06-21 9万+
爬虫简单的来说就是用程序获取网络上数据这个过程的一种名称。如果要获取网络上数据，我们要给爬虫一个网址（程序中通常叫URL），爬虫发送一个HTTP请求给目标网页的服务器，服务器返回数据给客户端（也就是我们的爬虫），爬虫再进行数据解析、保存等一系列操作。爬虫可以节省我们的时间，比如我要获取豆瓣电影 Top250 榜单，如果不用爬虫，我们要先在浏览器上输入豆瓣电影的 URL ，客户端（浏览器）通过解析查到豆瓣电影网页的服务器的 IP 地址，然后与它建立连接，浏览器再创造一个 HTTP 请求发送给豆瓣电影的服务器，
Python爬虫系列（一）——手把手教你写Python爬虫
cun的博客
10-23 3万+
适合初学者快速上手入门，以爬取CSDN和百度图片为例。
python异步爬虫之线程池
yy
10-05 3250
单线程不足之处 当对多个url发送请求时，只有请求完第一个url才会接着请求第二个url（requests是一个阻塞的操作），比如下载图片，这种一个个执行的方式称为单线程。其存在等待的时间，这样效率是很低的。那我们能不能在发送请求等待的时候，为其单独开启进程或者线程以异步的方式进行，继续请求下一个url，执行并行请求呢？这样看起来相当于同时下载很多张图片一样，速度明显提升。 异步爬虫 有如下基于异步爬虫的方案 多线程或多进程（不建议） 好处：可以为相关阻塞的操作单独开启线程或者进程，阻塞操作就可以异
Python 反爬虫与反反爬虫
小嗷犬的博客
09-08 2635
网络爬虫（又称为网页蜘蛛，网络机器人，在FOAF社区中间，更经常的称为网页追逐者），是一种按照一定的规则，自动地抓取万维网信息的程序或者脚本。另外一些不常使用的名字还有蚂蚁、自动索引、模拟程序或者蠕虫。大家可以理解为在网络上爬行的一只蜘蛛，互联网就比作一张大网，而爬虫便是在这张网上爬来爬去的蜘蛛，如果它遇到自己的猎物（所需要的资源），那么它就会将其抓取下来。比如它在抓取一个网页，在这个网中他发现了一条道路，其实就是指向网页的链接，那么它就可以爬到另一张网上来获取数据。
Python爬虫实战（二）：爬取构建代理IP池
努力让自己发光，对的人才能迎着光而来
11-28 2万+
啦啦啦
python爬虫入门教程：爬取网页图片
qq_46145027的博客
04-05 7万+
在现在这个信息爆炸的时代，要想高效的获取数据，爬虫是非常好用的。而用python做爬虫也十分简单方便，下面通过一个简单的小爬虫程序来看一看写爬虫的基本过程： 准备工作 语言：python IDE：pycharm 首先是要用到的库，因为是刚入门最简单的程序，我们主要就用到下面这两： import requests //用于请求网页 import re //正则表达式，用于解析筛选网页中的信息 其中re是python自带的，requests库需要我们自己安装，在命令行中输入pip install
python爬虫Request
Ve2dle的博客
09-12 1411
python爬虫request
Python爬虫实战（五）：根据关键字爬取某度图片批量下载到本地（附上完整源码）
热门推荐
努力让自己发光，对的人才能迎着光而来
08-21 14万+
Python爬虫实战（五）：根据关键字爬取某度图片批量下载到本地（附上完整源码）
python自动化爬虫实战
qq_50661854的博客
05-09 5465
偶尔的一次复习一下爬虫
Python网络爬虫实战.pdf
07-12
本书共8章，涵盖的内容有Python语言的基本语法、Python常用IDE的使用、Python第三方模块的导入使用、Python爬虫常用模块、Scrapy爬虫、Beautiful Soup爬虫、Mechanize模拟浏览器和Selenium模拟浏览器。本书所有源...
python进行爬虫小记
01-15
python进行爬虫小记，主要用于python快速入门理解。
python爬虫基础python爬虫基础
12-28
python爬虫基础python爬虫基础python爬虫基础python爬虫基础python爬虫基础python爬虫基础python爬虫基础python爬虫基础python爬虫基础python爬虫基础python爬虫基础python爬虫基础python爬虫基础python爬虫基础...
Python网络爬虫与数据采集
03-29
Python网络爬虫与数据采集
python爬虫（二） 之 42号网汽车文章爬虫
weixin_46294086的博客
05-07 190
今天在咸鱼上有个买家找我一个42号网汽车文章的爬虫，目前需求已经做完了，现在将这部分代码开源，供大家参考。爬虫能够抓取到网站上所有文章的数据，大概一小时左右就能将这个网站上的数据吃干抹尽。下面是程序的运行结果，最终抓取的数据放在同级目录下的。
Python urllib 爬虫入门（1）
json_li的博客
04-30 616
本文主要为Python urllib类库函数和属性介绍及一些简单示例。
Python爬虫--爬取糗事百科段子
余十步的博客
05-03 402
代码跟之前几乎一样，只是正则不同，应该不需要怎么介绍了。是匹配不了的，需要使用模式修饰符。标签 之间有很多空行。如果怕请求出错的话，
python爬虫学习------scrapy第三部分（第三十一天）
最新发布
喔的嘛呀的博客
05-07 679
如果现有的扩展无法满足你的需求，你可以编写自定义的扩展来扩展Scrapy的功能。编写自定义扩展需要一定的编程技能和对Scrapy框架的深入理解。你可以通过继承Scrapy提供的基类，并实现相应的方法来处理特定的逻辑。例如，你可以编写一个自定义的中间件来处理特定的请求头或响应数据，或者编写一个自定义的Item Pipeline来处理爬取到的数据。
python selenuim爬虫
04-02
Python selenium爬虫是一种使用Python编写的网络爬虫，它利用selenium库来模拟浏览器的行为，实现对网页的自动化操作和数据提取[^1][^2]。 下面是一个简单的示例，演示了如何使用Python selenium爬虫来获取网页内容： ```python from selenium import webdriver # 创建一个浏览器实例 driver = webdriver.Chrome() # 打开网页 driver.get("https://www.example.com") # 获取网页内容 content = driver.page_source # 关闭浏览器 driver.quit() # 打印网页内容 print(content) ``` 这个示例中，我们首先导入了selenium库的webdriver模块，然后创建了一个Chrome浏览器实例。接着，我们使用`get()`方法打开了一个网页，并使用`page_source`属性获取了网页的内容。最后，我们关闭了浏览器实例，并打印了网页内容。 需要注意的是，使用Python selenium爬虫时，需要安装相应的浏览器驱动程序，比如Chrome浏览器需要下载并配置ChromeDriver。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值