精华内容
下载资源
问答
  • C# 利用代理爬虫网页 实现代码: // yanggang@mimvp.com // http://proxy.mimvp.com // 2015-11-09 using System; using System.IO; using System.Net; using System.Text; namespace ConsoleApplication1 { class...
  • Python实现的异步代理爬虫及代理池

    千次阅读 2020-03-23 21:59:32
    本文主要介绍了Python实现异步代理爬虫及代理池的相关知识,具有很好的参考价值,下面跟着小编一起来看下吧 使用python asyncio实现了一个异步代理池,根据规则爬取代理网站上的免费代理,在验证其有效后存入redis中...

    本文主要介绍了Python实现异步代理爬虫及代理池的相关知识,具有很好的参考价值,下面跟着小编一起来看下吧
    使用python asyncio实现了一个异步代理池,根据规则爬取代理网站上的免费代理,在验证其有效后存入redis中,定期扩展代理的数量并检验池中代理的有效性,移除失效的代理。同时用aiohttp实现了一个server,其他的程序可以通过访问相应的url来从代理池中获取代理。
    源码
    Github
    环境
    Python 3.5+
    Redis
    PhantomJS(可选)
    Supervisord(可选)
    因为代码中大量使用了asyncio的async和await语法,它们是在Python3.5中才提供的,所以最好使用Python3.5及以上的版本,我使用的是Python3.6。
    依赖
    redis
    aiohttp
    bs4
    lxml
    requests
    selenium
    selenium包主要是用来操作PhantomJS的。
    下面来对代码进行说明。

    1. 爬虫部分
      核心代码
    async def start(self):
     for rule in self._rules:
     parser = asyncio.ensure_future(self._parse_page(rule)) # 根据规则解析页面来获取代理
     logger.debug('{0} crawler started'.format(rule.__rule_name__))
     if not rule.use_phantomjs:
      await page_download(ProxyCrawler._url_generator(rule), self._pages, self._stop_flag) # 爬取代理网站的页面
     else:
      await page_download_phantomjs(ProxyCrawler._url_generator(rule), self._pages,
    rule.phantomjs_load_flag, self._stop_flag) # 使用PhantomJS爬取
     await self._pages.join()
     parser.cancel()
     logger.debug('{0} crawler finished'.format(rule.__rule_name__))
    

    上面的核心代码实际上是一个用asyncio.Queue实现的生产-消费者模型,下面是该模型的一个简单实现:

    import asyncio
    from random import random
    async def produce(queue, n):
     for x in range(1, n + 1):
     print('produce ', x)
     await asyncio.sleep(random())
     await queue.put(x) # 向queue中放入item
    async def consume(queue):
     while 1:
     item = await queue.get() # 等待从queue中获取item
     print('consume ', item)
     await asyncio.sleep(random())
     queue.task_done() # 通知queue当前item处理完毕 
    async def run(n):
     queue = asyncio.Queue()
     consumer = asyncio.ensure_future(consume(queue))
     await produce(queue, n) # 等待生产者结束
     await queue.join() # 阻塞直到queue不为空
     consumer.cancel() # 取消消费者任务,否则它会一直阻塞在get方法处
    def aio_queue_run(n):
     loop = asyncio.get_event_loop()
     try:
     loop.run_until_complete(run(n)) # 持续运行event loop直到任务run(n)结束
     finally:
     loop.close()
    if __name__ == '__main__':
     aio_queue_run(5)
    

    运行上面的代码,一种可能的输出如下:

    produce 1
    produce 2
    consume 1
    produce 3
    produce 4
    consume 2
    produce 5
    consume 3
    consume 4
    consume 5
    

    爬取页面

    async def page_download(urls, pages, flag):
     url_generator = urls
     async with aiohttp.ClientSession() as session:
     for url in url_generator:
      if flag.is_set():
      break
      await asyncio.sleep(uniform(delay - 0.5, delay + 1))
      logger.debug('crawling proxy web page {0}'.format(url))
      try:
      async with session.get(url, headers=headers, timeout=10) as response:
       page = await response.text()
       parsed = html.fromstring(decode_html(page)) # 使用bs4来辅助lxml解码网页:http://lxml.de/elementsoup.html#Using only the encoding detection
       await pages.put(parsed)
       url_generator.send(parsed) # 根据当前页面来获取下一页的地址
      except StopIteration:
      break
      except asyncio.TimeoutError:
      logger.error('crawling {0} timeout'.format(url))
      continue # TODO: use a proxy
      except Exception as e:
      logger.error(e)
    

    使用aiohttp实现的网页爬取函数,大部分代理网站都可以使用上面的方法来爬取,对于使用js动态生成页面的网站可以使用selenium控制PhantomJS来爬取——本项目对爬虫的效率要求不高,代理网站的更新频率是有限的,不需要频繁的爬取,完全可以使用PhantomJS。

    解析代理

    最简单的莫过于用xpath来解析代理了,使用Chrome浏览器的话,直接通过右键就能获得选中的页面元素的xpath:在这里插入图片描述
    安装Chrome的扩展“XPath Helper”就可以直接在页面上运行和调试xpath,十分方便:在这里插入图片描述
    BeautifulSoup不支持xpath,使用lxml来解析页面,代码如下:

    async def _parse_proxy(self, rule, page):
     ips = page.xpath(rule.ip_xpath) # 根据xpath解析得到list类型的ip地址集合
     ports = page.xpath(rule.port_xpath) # 根据xpath解析得到list类型的ip地址集合
     if not ips or not ports:
     logger.warning('{2} crawler could not get ip(len={0}) or port(len={1}), please check the xpaths or network'.
      format(len(ips), len(ports), rule.__rule_name__))
     return
     proxies = map(lambda x, y: '{0}:{1}'.format(x.text.strip(), y.text.strip()), ips, ports)
     if rule.filters: # 根据过滤字段来过滤代理,如“高匿”、“透明”等
     filters = []
     for i, ft in enumerate(rule.filters_xpath):
      field = page.xpath(ft)
      if not field:
      logger.warning('{1} crawler could not get {0} field, please check the filter xpath'.
       format(rule.filters[i], rule.__rule_name__))
      continue
      filters.append(map(lambda x: x.text.strip(), field))
     filters = zip(*filters)
     selector = map(lambda x: x == rule.filters, filters)
     proxies = compress(proxies, selector)
    for proxy in proxies:
    await self._proxies.put(proxy) # 解析后的代理放入asyncio.Queue中
    

    爬虫规则

    网站爬取、代理解析、滤等等操作的规则都是由各个代理网站的规则类定义的,使用元类和基类来管理规则类。基类定义如下:

    class CrawlerRuleBase(object, metaclass=CrawlerRuleMeta):
     start_url = None
     page_count = 0
     urls_format = None
     next_page_xpath = None
     next_page_host = ''
     use_phantomjs = False
     phantomjs_load_flag = None
     filters = ()
     ip_xpath = None
     port_xpath = None
     filters_xpath = ()
    

    各个参数的含义如下:

    start_url(必需)

    爬虫的起始页面。

    ip_xpath(必需)

    爬取IP的xpath规则。

    port_xpath(必需)

    爬取端口号的xpath规则。

    page_count

    爬取的页面数量。

    urls_format

    页面地址的格式字符串,通过urls_format.format(start_url, n)来生成第n页的地址,这是比较常见的页面地址格式。

    next_page_xpath,next_page_host

    由xpath规则来获取下一页的url(常见的是相对路径),结合host得到下一页的地址:next_page_host + url。

    use_phantomjs, phantomjs_load_flag

    use_phantomjs用于标识爬取该网站是否需要使用PhantomJS,若使用,需定义phantomjs_load_flag(网页上的某个元素,str类型)作为PhantomJS页面加载完毕的标志。

    filters

    过滤字段集合,可迭代类型。用于过滤代理。

    爬取各个过滤字段的xpath规则,与过滤字段按顺序一一对应。

    元类CrawlerRuleMeta用于管理规则类的定义,如:如果定义use_phantomjs=True,则必须定义phantomjs_load_flag,否则会抛出异常,不在此赘述。

    目前已经实现的规则有西刺代理、快代理、360代理、66代理和 秘密代理。新增规则类也很简单,通过继承CrawlerRuleBase来定义新的规则类YourRuleClass,放在proxypool/rules目录下,并在该目录下的__init__.py中添加from . import YourRuleClass(这样通过CrawlerRuleBase.subclasses()就可以获取全部的规则类了),重启正在运行的proxy pool即可应用新的规则。

    1. 检验部分

    免费的代理虽然多,但是可用的却不多,所以爬取到代理后需要对其进行检验,有效的代理才能放入代理池中,而代理也是有时效性的,还要定期对池中的代理进行检验,及时移除失效的代理。

    这部分就很简单了,使用aiohttp通过代理来访问某个网站,若超时,则说明代理无效。

    async def validate(self, proxies):
     logger.debug('validator started')
     while 1:
     proxy = await proxies.get()
     async with aiohttp.ClientSession() as session:
      try:
      real_proxy = 'http://' + proxy
      async with session.get(self.validate_url, proxy=real_proxy, timeout=validate_timeout) as resp:
       self._conn.put(proxy)
      except Exception as e:
      logger.error(e)
     proxies.task_done()
    
    1. server部分

    使用aiohttp实现了一个web server,启动后,访问http://host:port即可显示主页:在这里插入图片描述
    访问http://host:port/get来从代理池获取1个代理,如:‘127.0.0.1:1080’;
    访问http://host:port/get/n来从代理池获取n个代理,如:"[‘127.0.0.1:1080’, ‘127.0.0.1:443’, ‘127.0.0.1:80’]";
    访问http://host:port/count来获取代理池的容量,如:‘42’。
    因为主页是一个静态的html页面,为避免每来一个访问主页的请求都要打开、读取以及关闭该html文件的开销,将其缓存到了redis中,通过html文件的修改时间来判断其是否被修改过,如果修改时间与redis缓存的修改时间不同,则认为html文件被修改了,则重新读取文件,并更新缓存,否则从redis中获取主页的内容。

    返回代理是通过aiohttp.web.Response(text=ip.decode(‘utf-8’))实现的,text要求str类型,而从redis中获取到的是bytes类型,需要进行转换。返回的多个代理,使用eval即可转换为list类型。

    返回主页则不同,是通过aiohttp.web.Response(body=main_page_cache, content_type=‘text/html’) ,这里body要求的是bytes类型,直接将从redis获取的缓存返回即可,conten_type='text/html’必不可少,否则无法通过浏览器加载主页,而是会将主页下载下来——在运行官方文档中的示例代码的时候也要注意这点,那些示例代码基本上都没有设置content_type。

    这部分不复杂,注意上面提到的几点,而关于主页使用的静态资源文件的路径,可以参考之前的博客《aiohttp之添加静态资源路径》。

    1. 运行

    将整个代理池的功能分成了3个独立的部分:

    proxypool

    定期检查代理池容量,若低于下限则启动代理爬虫并对代理检验,通过检验的爬虫放入代理池,达到规定的数量则停止爬虫。

    proxyvalidator

    用于定期检验代理池中的代理,移除失效代理。

    proxyserver

    启动server。

    这3个独立的任务通过3个进程来运行,在Linux下可以使用supervisod来=管理这些进程,下面是supervisord的配置文件示例:

    ; supervisord.conf
    [unix_http_server]
    file=/tmp/supervisor.sock 
     
    [inet_http_server]  
    port=127.0.0.1:9001
     
    [supervisord]
    logfile=/tmp/supervisord.log 
    logfile_maxbytes=5MB
    logfile_backups=10 
    loglevel=debug  
    pidfile=/tmp/supervisord.pid 
    nodaemon=false  
    minfds=1024  
    minprocs=200  
     
    [rpcinterface:supervisor]
    supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
     
    [supervisorctl]
    serverurl=unix:///tmp/supervisor.sock
     
    [program:proxyPool]
    command=python /path/to/ProxyPool/run_proxypool.py  
    redirect_stderr=true
    stdout_logfile=NONE
     
    [program:proxyValidator]
    command=python /path/to/ProxyPool/run_proxyvalidator.py
    redirect_stderr=true  
    stdout_logfile=NONE
     
    [program:proxyServer]
    command=python /path/to/ProxyPool/run_proxyserver.py
    autostart=false
    redirect_stderr=true  
    stdout_logfile=NONE
    

    因为项目自身已经配置了日志,所以这里就不需要再用supervisord捕获stdout和stderr了。通过supervisord -c supervisord.conf启动supervisord,proxyPool和proxyServer则会随之自动启动,proxyServer需要手动启动,访问http://127.0.0.1:9001即可通过网页来管理这3个进程了:
    在这里插入图片描述
    supervisod的官方文档说目前(版本3.3.1)不支持python3,但是我在使用过程中没有发现什么问题,可能也是由于我并没有使用supervisord的复杂功能,只是把它当作了一个简单的进程状态监控和启停工具了。
    最后给大家推荐一个口碑不错的python聚集地【点击进入】,这里有很多的老前辈学习技巧,学习心得,面试技巧,职场经历等分享,更为大家精心准备了零基础入门资料,实战项目资料,每天都有程序员定时讲解Python技术,分享一些学习的方法和需要留意的小细节

    展开全文
  • 通过Java网络爬虫爬取指定代理ip网上的ip,利用了jsoup、httpclient技术实现
  • 有时需要爬取一个目标网站过多数据的时候,python会在短时间内多次访问,如果目标网站有反扒措施,则IP地址有可能被禁止访问,造成程序失败,可以用IP池做IP代理,headers池伪装不同浏览器,从而更搞笑的爬取数据
  • 在编写爬虫时,设置在字典中两个IP地址,结果出现如下图所示的错误: [WinError 10061] 由于目标计算机积极拒绝,无法连接。 设置代理IP为: proxy_handler = ProxyHandler({ 'http': '127.0.0.0:4973', '...

    在编写爬虫时,设置在字典中两个IP地址,结果出现如下图所示的错误:

    [WinError 10061] 由于目标计算机积极拒绝,无法连接。

    设置代理IP为:

    proxy_handler = ProxyHandler({
        'http': '127.0.0.0:4973',
        'https': '127.0.0.1:4973'
    
    })
    opener = build_opener(proxy_handler)

    后来查阅了一些资料后,其实只用设置一种代理IP地址即可,https简单点说就是http的安全版,因此只需设置一种IP。

    将此行:'https': '127.0.0.1:4973'代码删掉就能解决此错误了!

    附上通过代理IP爬取网页的代码,不对之处请多多指教!!!

    from urllib.error import URLError          #异常处理模块,捕获错误
    from urllib.request import ProxyHandler, build_opener   #代理IP模块
    
    #设置代理IP
    proxy_handler = ProxyHandler({
        'http': '127.0.0.0:4973'
    
    })
    opener = build_opener(proxy_handler)   #通过proxy_handler来构建opener
    #请求网站
    try:
        response = opener.open('https://www.douban.com/')  #此处的open方法同urllib的urlopen方法
        print(response.read().decode('utf-8'))
    except URLError as e:
        print(e.reason)
    

     

    展开全文
  • requests模块中经常使用到的headers和proxies,随机代理ip和请求头可以实现更加高效的爬取操作。 文件中给出从网上收集到的代理,下方也给出了筛选可用代理的方法。
  • 什么是隧道代理:客户计算机通过专线网络链接固定代理服务器(固定IP),固定...什么是爬虫代理爬虫代理通过固定云代理服务地址,建立专线网络链接,代理平台自动实现毫秒级代理IP切换,保证了网络稳定性和速度...

    什么是隧道代理:客户计算机通过专线网络链接固定代理服务器(固定IP),固定服务器再通过随机端口将数据通过其他线路服务器向目标网站(服务器)转发。因此目标网站(服务器)只能看到随机线路的IP,不可能看到固定代理服务器IP,实际效果与公网IP(外网IP)一样,并且网络更加稳定。
    什么是爬虫代理:爬虫代理通过固定云代理服务地址,建立专线网络链接,代理平台自动实现毫秒级代理IP切换,保证了网络稳定性和速度,避免爬虫客户在代理IP策略优化上投入精力。

    展开全文
  • Python爬虫代理池搭建

    万次阅读 多人点赞 2019-05-13 15:37:19
    一、为什么要搭建爬虫代理池 二、搭建思路 三、代码实现 ipproxy.py settings.py proxy_queue.py proxy_util.py proxy_crawlers.py run.py 四、代理测试 一、为什么要搭建爬虫代理池 在众多的网站防爬...

     

    目录

    一、为什么要搭建爬虫代理池

    二、搭建思路

    三、代码实现

    ipproxy.py

    settings.py

    proxy_util.py

    proxy_queue.py

    proxy_crawlers.py

    run.py

    四、代理测试


    一、为什么要搭建爬虫代理池

    在众多的网站防爬措施中,有一种是根据ip的访问频率进行限制,即在某一时间段内,当某个ip的访问次数达到一定的阀值时,该ip就会被拉黑、在一段时间内禁止访问。

    应对的方法有两种:

    1. 降低爬虫的爬取频率,避免IP被限制访问,缺点显而易见:会大大降低爬取的效率。

    2. 搭建一个IP代理池,使用不同的IP轮流进行爬取。

    二、搭建思路

    1、从代理网站(如:西刺代理、快代理、云代理、无忧代理)爬取代理IP;

    2、验证代理IP的可用性(使用代理IP去请求指定URL,根据响应验证代理IP是否生效);

    3、将可用的代理IP保存到数据库;

    常用代理网站:西刺代理 、云代理 、IP海 、无忧代理 、飞蚁代理 、快代理

    三、代码实现

    工程结构如下:

    ipproxy.py

    IPProxy代理类定义了要爬取的IP代理的字段信息和一些基础方法。

    # -*- coding: utf-8 -*-
    import re
    import time
    from settings import PROXY_URL_FORMATTER
    
    schema_pattern = re.compile(r'http|https$', re.I)
    ip_pattern = re.compile(r'^([0-9]{1,3}.){3}[0-9]{1,3}$', re.I)
    port_pattern = re.compile(r'^[0-9]{2,5}$', re.I)
    
    class IPProxy:
        '''
        {
            "schema": "http", # 代理的类型
            "ip": "127.0.0.1", # 代理的IP地址
            "port": "8050", # 代理的端口号
            "used_total": 11, # 代理的使用次数
            "success_times": 5, # 代理请求成功的次数
            "continuous_failed": 3, # 使用代理发送请求,连续失败的次数
            "created_time": "2018-05-02" # 代理的爬取时间
        }
        '''
    
        def __init__(self, schema, ip, port, used_total=0, success_times=0, continuous_failed=0,
                     created_time=None):
            """Initialize the proxy instance"""
            if schema == "" or schema is None:
                schema = "http"
            self.schema = schema.lower()
            self.ip = ip
            self.port = port
            self.used_total = used_total
            self.success_times = success_times
            self.continuous_failed = continuous_failed
            if created_time is None:
                created_time = time.strftime('%Y-%m-%d', time.localtime(time.time()))
            self.created_time = created_time
    
        def _get_url(self):
            ''' Return the proxy url'''
            return PROXY_URL_FORMATTER % {'schema': self.schema, 'ip': self.ip, 'port': self.port}
    
        def _check_format(self):
            ''' Return True if the proxy fields are well-formed,otherwise return False'''
            if self.schema is not None and self.ip is not None and self.port is not None:
                if schema_pattern.match(self.schema) and ip_pattern.match(self.ip) and port_pattern.match(self.port):
                    return True
            return False
    
        def _is_https(self):
            ''' Return True if the proxy is https,otherwise return False'''
            return self.schema == 'https'
    
        def _update(self, successed=False):
            ''' Update proxy based on the result of the request's response'''
            self.used_total = self.used_total + 1
            if successed:
                self.continuous_failed = 0
                self.success_times = self.success_times + 1
            else:
                print(self.continuous_failed)
                self.continuous_failed = self.continuous_failed + 1
    
    if __name__ == '__main__':
        proxy = IPProxy('HTTPS', '192.168.2.25', "8080")
        print(proxy._get_url())
        print(proxy._check_format())
        print(proxy._is_https())

    settings.py

    settings.py中汇聚了工程所需要的配置信息。

    # 指定Redis的主机名和端口
    REDIS_HOST = 'localhost'
    REDIS_PORT = 6379
    
    # 代理保存到Redis key 格式化字符串
    PROXIES_REDIS_FORMATTER = 'proxies::{}'
    # 已经存在的HTTP代理和HTTPS代理集合
    PROXIES_REDIS_EXISTED = 'proxies::existed'
    
    # 最多连续失败几次
    MAX_CONTINUOUS_TIMES = 3
    # 代理地址的格式化字符串
    PROXY_URL_FORMATTER = '%(schema)s://%(ip)s:%(port)s'
    
    USER_AGENT_LIST = [
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.1 (KHTML, like Gecko) Chrome/22.0.1207.1 Safari/537.1",
        "Mozilla/5.0 (X11; CrOS i686 2268.111.0) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.57 Safari/536.11",
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.6 (KHTML, like Gecko) Chrome/20.0.1092.0 Safari/536.6",
        "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.6 (KHTML, like Gecko) Chrome/20.0.1090.0 Safari/536.6",
        "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.1 (KHTML, like Gecko) Chrome/19.77.34.5 Safari/537.1",
        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.9 Safari/536.5",
        "Mozilla/5.0 (Windows NT 6.0) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.36 Safari/536.5",
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
        "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_0) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1062.0 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1062.0 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
        "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1061.0 Safari/536.3",
        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.24 (KHTML, like Gecko) Chrome/19.0.1055.1 Safari/535.24",
        "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/535.24 (KHTML, like Gecko) Chrome/19.0.1055.1 Safari/535.24"
    ]
    # 爬取到的代理保存前先检验是否可用,默认True
    PROXY_CHECK_BEFOREADD = True
    # 检验代理可用性的请求地址,支持多个
    PROXY_CHECK_URLS = {'https':['https://icanhazip.com'],'http':['http://icanhazip.com']}
    

    proxy_util.py

    proxy_util.py 中主要定义了一些实用方法,例如:proxy_to_dict(proxy)用来将IPProxy代理实例转换成字典;proxy_from_dict(d)用来将字典转换为IPProxy实例;request_page()用来发送请求;_is_proxy_available()用来校验代理IP是否可用。

    # -*- coding: utf-8 -*-
    import random
    import logging
    import requests
    from ipproxy import IPProxy
    from settings import USER_AGENT_LIST, PROXY_CHECK_URLS
    
    # Setting logger output format
    logging.basicConfig(level=logging.INFO,
                        format='[%(asctime)-15s] [%(levelname)8s] [%(name)10s ] - %(message)s (%(filename)s:%(lineno)s)',
                        datefmt='%Y-%m-%d %T'
                        )
    logger = logging.getLogger(__name__)
    
    
    def proxy_to_dict(proxy):
        d = {
            "schema": proxy.schema,
            "ip": proxy.ip,
            "port": proxy.port,
            "used_total": proxy.used_total,
            "success_times": proxy.success_times,
            "continuous_failed": proxy.continuous_failed,
            "created_time": proxy.created_time
        }
        return d
    
    
    def proxy_from_dict(d):
        return IPProxy(schema=d['schema'], ip=d['ip'], port=d['port'], used_total=d['used_total'],
                       success_times=d['success_times'], continuous_failed=d['continuous_failed'],
                       created_time=d['created_time'])
    
    
    # Truncate header and tailer blanks
    def strip(data):
        if data is not None:
            return data.strip()
        return data
    
    
    base_headers = {
        'Accept-Encoding': 'gzip, deflate, br',
        'Accept-Language': 'en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7'
    }
    
    
    def request_page(url, options={}, encoding='utf-8'):
        """send a request,get response"""
        headers = dict(base_headers, **options)
        if 'User-Agent' not in headers.keys():
            headers['User-Agent'] = random.choice(USER_AGENT_LIST)
    
        logger.info('正在抓取: ' + url)
        try:
            response = requests.get(url, headers=headers)
            if response.status_code == 200:
                logger.info('抓取成功: ' + url)
                return response.content.decode(encoding=encoding)
        except ConnectionError:
            logger.error('抓取失败' + url)
            return None
    
    def _is_proxy_available(proxy, options={}):
        """Check whether the Proxy is available or not"""
        headers = dict(base_headers, **options)
        if 'User-Agent' not in headers.keys():
            headers['User-Agent'] = random.choice(USER_AGENT_LIST)
        proxies = {proxy.schema: proxy._get_url()}
        check_urls = PROXY_CHECK_URLS[proxy.schema]
        for url in check_urls:
            try:
                response = requests.get(url=url, proxies=proxies, headers=headers, timeout=5)
            except BaseException:
                logger.info("< " + url + " > 验证代理 < " + proxy._get_url() + " > 结果: 不可用  ")
            else:
                if response.status_code == 200:
                    logger.info("< " + url + " > 验证代理 < " + proxy._get_url() + " > 结果: 可用  ")
                    return True
                else:
                    logger.info("< " + url + " > 验证代理 < " + proxy._get_url() + " > 结果: 不可用  ")
        return False
    
    
    if __name__ == '__main__':
        headers = dict(base_headers)
        if 'User-Agent' not in headers.keys():
            headers['User-Agent'] = random.choice(USER_AGENT_LIST)
        proxies = {"https": "https://163.125.255.154:9797"}
        response = requests.get("https://www.baidu.com", headers=headers, proxies=proxies, timeout=3)
        print(response.content)

    proxy_queue.py

    代理队列用来保存并对外提供 IP代理,不同的代理队列内代理IP的保存和提取策略可以不同。在这里, BaseQueue 是所有代理队列的基类,其中声明了所有代理队列都需要实现的保存代理IP、提取代理IP、查看代理IP数量等接口。示例的 FifoQueue 是一个先进先出队列,底层使用 Redis 列表实现,为了确保同一个代理IP只能被放入队列一次,这里使用了一个Redis proxies::existed 集合进行入队前重复校验。

    # -*- coding: utf-8 -*-
    from proxy_util import logger
    import json
    import redis
    from ipproxy import IPProxy
    from proxy_util import proxy_to_dict, proxy_from_dict, _is_proxy_available
    from settings import PROXIES_REDIS_EXISTED, PROXIES_REDIS_FORMATTER, MAX_CONTINUOUS_TIMES, PROXY_CHECK_BEFOREADD
    
    """
    Proxy Queue Base Class
    """
    class BaseQueue(object):
    
        def __init__(self, server):
            """Initialize the proxy queue instance
    
            Parameters
            ----------
            server : StrictRedis
                Redis client instance
            """
            self.server = server
    
        def _serialize_proxy(self, proxy):
            """Serialize proxy instance"""
            return proxy_to_dict(proxy)
    
        def _deserialize_proxy(self, serialized_proxy):
            """deserialize proxy instance"""
            return proxy_from_dict(eval(serialized_proxy))
    
        def __len__(self, schema='http'):
            """Return the length of the queue"""
            raise NotImplementedError
    
        def push(self, proxy, need_check):
            """Push a proxy"""
            raise NotImplementedError
    
        def pop(self, schema='http', timeout=0):
            """Pop a proxy"""
            raise NotImplementedError
    
    
    class FifoQueue(BaseQueue):
        """First in first out queue"""
    
        def __len__(self, schema='http'):
            """Return the length of the queue"""
            return self.server.llen(PROXIES_REDIS_FORMATTER.format(schema))
    
        def push(self, proxy, need_check=PROXY_CHECK_BEFOREADD):
            """Push a proxy"""
            if need_check and not _is_proxy_available(proxy):
                return
            elif proxy.continuous_failed < MAX_CONTINUOUS_TIMES and not self._is_existed(proxy):
                key = PROXIES_REDIS_FORMATTER.format(proxy.schema)
                self.server.rpush(key, json.dumps(self._serialize_proxy(proxy),ensure_ascii=False))
    
        def pop(self, schema='http', timeout=0):
            """Pop a proxy"""
            if timeout > 0:
                p = self.server.blpop(PROXIES_REDIS_FORMATTER.format(schema.lower()), timeout)
                if isinstance(p, tuple):
                    p = p[1]
            else:
                p = self.server.lpop(PROXIES_REDIS_FORMATTER.format(schema.lower()))
            if p:
                p = self._deserialize_proxy(p)
                self.server.srem(PROXIES_REDIS_EXISTED, p._get_url())
                return p
    
        def _is_existed(self, proxy):
            added = self.server.sadd(PROXIES_REDIS_EXISTED, proxy._get_url())
            return added == 0
    
    
    if __name__ == '__main__':
        r = redis.StrictRedis(host='localhost', port=6379)
        queue = FifoQueue(r)
        proxy = IPProxy('http', '218.66.253.144', '80')
        queue.push(proxy)
        proxy = queue.pop(schema='http')
        print(proxy._get_url())

    proxy_crawlers.py

    ProxyBaseCrawler 是所有代理爬虫的基类,其中只定义了一个 _start_crawl() 方法用来从搜集到的代理网站爬取代理IP。

    # -*- coding: utf-8 -*-
    from lxml import etree
    from ipproxy import IPProxy
    from proxy_util import strip, request_page, logger
    
    
    class ProxyBaseCrawler(object):
    
        def __init__(self, queue=None, website=None, urls=[]):
            self.queue = queue
            self.website = website
            self.urls = urls
    
        def _start_crawl(self):
            raise NotImplementedError
    
    
    class KuaiDailiCrawler(ProxyBaseCrawler):  # 快代理
        def _start_crawl(self):
            for url_dict in self.urls:
                logger.info("开始爬取 [ " + self.website + " ] :::> [ " + url_dict['type'] + " ]")
                has_more = True
                url = None
                while has_more:
                    if 'page' in url_dict.keys() and str.find(url_dict['url'], '{}') != -1:
                        url = url_dict['url'].format(str(url_dict['page']))
                        url_dict['page'] = url_dict['page'] + 1
                    else:
                        url = url_dict['url']
                        has_more = False
                    html = etree.HTML(request_page(url))
                    tr_list = html.xpath("//table[@class='table table-bordered table-striped']/tbody/tr")
                    for tr in tr_list:
                        ip = tr.xpath("./td[@data-title='IP']/text()")[0] if len(
                            tr.xpath("./td[@data-title='IP']/text()")) else None
                        port = tr.xpath("./td[@data-title='PORT']/text()")[0] if len(
                            tr.xpath("./td[@data-title='PORT']/text()")) else None
                        schema = tr.xpath("./td[@data-title='类型']/text()")[0] if len(
                            tr.xpath("./td[@data-title='类型']/text()")) else None
                        proxy = IPProxy(schema=strip(schema), ip=strip(ip), port=strip(port))
                        if proxy._check_format():
                            self.queue.push(proxy)
                    if tr_list is None:
                        has_more = False
    
    
    class FeiyiDailiCrawler(ProxyBaseCrawler):  # 飞蚁代理
        def _start_crawl(self):
            for url_dict in self.urls:
                logger.info("开始爬取 [ " + self.website + " ] :::> [ " + url_dict['type'] + " ]")
                has_more = True
                url = None
                while has_more:
                    if 'page' in url_dict.keys() and str.find(url_dict['url'], '{}') != -1:
                        url = url_dict['url'].format(str(url_dict['page']))
                        url_dict['page'] = url_dict['page'] + 1
                    else:
                        url = url_dict['url']
                        has_more = False
                    html = etree.HTML(request_page(url))
                    tr_list = html.xpath("//div[@id='main-content']//table/tr[position()>1]")
                    for tr in tr_list:
                        ip = tr.xpath("./td[1]/text()")[0] if len(tr.xpath("./td[1]/text()")) else None
                        port = tr.xpath("./td[2]/text()")[0] if len(tr.xpath("./td[2]/text()")) else None
                        schema = tr.xpath("./td[4]/text()")[0] if len(tr.xpath("./td[4]/text()")) else None
                        proxy = IPProxy(schema=strip(schema), ip=strip(ip), port=strip(port))
                        if proxy._check_format():
                            self.queue.push(proxy)
                    if tr_list is None:
                        has_more = False
    
    
    class WuyouDailiCrawler(ProxyBaseCrawler):  # 无忧代理
        def _start_crawl(self):
            for url_dict in self.urls:
                logger.info("开始爬取 [ " + self.website + " ] :::> [ " + url_dict['type'] + " ]")
                has_more = True
                url = None
                while has_more:
                    if 'page' in url_dict.keys() and str.find(url_dict['url'], '{}') != -1:
                        url = url_dict['url'].format(str(url_dict['page']))
                        url_dict['page'] = url_dict['page'] + 1
                    else:
                        url = url_dict['url']
                        has_more = False
                    html = etree.HTML(request_page(url))
                    ul_list = html.xpath("//div[@class='wlist'][2]//ul[@class='l2']")
                    for ul in ul_list:
                        ip = ul.xpath("./span[1]/li/text()")[0] if len(ul.xpath("./span[1]/li/text()")) else None
                        port = ul.xpath("./span[2]/li/text()")[0] if len(ul.xpath("./span[2]/li/text()")) else None
                        schema = ul.xpath("./span[4]/li/text()")[0] if len(ul.xpath("./span[4]/li/text()")) else None
                        proxy = IPProxy(schema=strip(schema), ip=strip(ip), port=strip(port))
                        if proxy._check_format():
                            self.queue.push(proxy)
                    if ul_list is None:
                        has_more = False
    
    
    class IPhaiDailiCrawler(ProxyBaseCrawler):  # IP海代理
        def _start_crawl(self):
            for url_dict in self.urls:
                logger.info("开始爬取 [ " + self.website + " ] :::> [ " + url_dict['type'] + " ]")
                has_more = True
                url = None
                while has_more:
                    if 'page' in url_dict.keys() and str.find(url_dict['url'], '{}') != -1:
                        url = url_dict['url'].format(str(url_dict['page']))
                        url_dict['page'] = url_dict['page'] + 1
                    else:
                        url = url_dict['url']
                        has_more = False
                    html = etree.HTML(request_page(url))
                    tr_list = html.xpath("//table//tr[position()>1]")
                    for tr in tr_list:
                        ip = tr.xpath("./td[1]/text()")[0] if len(tr.xpath("./td[1]/text()")) else None
                        port = tr.xpath("./td[2]/text()")[0] if len(tr.xpath("./td[2]/text()")) else None
                        schema = tr.xpath("./td[4]/text()")[0] if len(tr.xpath("./td[4]/text()")) else None
                        proxy = IPProxy(schema=strip(schema), ip=strip(ip), port=strip(port))
                        if proxy._check_format():
                            self.queue.push(proxy)
                    if tr_list is None:
                        has_more = False
    
    
    class YunDailiCrawler(ProxyBaseCrawler):  # 云代理
        def _start_crawl(self):
            for url_dict in self.urls:
                logger.info("开始爬取 [ " + self.website + " ] :::> [ " + url_dict['type'] + " ]")
                has_more = True
                url = None
                while has_more:
                    if 'page' in url_dict.keys() and str.find(url_dict['url'], '{}') != -1:
                        url = url_dict['url'].format(str(url_dict['page']))
                        url_dict['page'] = url_dict['page'] + 1
                    else:
                        url = url_dict['url']
                        has_more = False
                    html = etree.HTML(request_page(url, encoding='gbk'))
                    tr_list = html.xpath("//table/tbody/tr")
                    for tr in tr_list:
                        ip = tr.xpath("./td[1]/text()")[0] if len(tr.xpath("./td[1]/text()")) else None
                        port = tr.xpath("./td[2]/text()")[0] if len(tr.xpath("./td[2]/text()")) else None
                        schema = tr.xpath("./td[4]/text()")[0] if len(tr.xpath("./td[4]/text()")) else None
                        proxy = IPProxy(schema=strip(schema), ip=strip(ip), port=strip(port))
                        if proxy._check_format():
                            self.queue.push(proxy)
                    if tr_list is None:
                        has_more = False
    
    
    class XiCiDailiCrawler(ProxyBaseCrawler):  # 西刺代理
        def _start_crawl(self):
            for url_dict in self.urls:
                logger.info("开始爬取 [ " + self.website + " ] :::> [ " + url_dict['type'] + " ]")
                has_more = True
                url = None
                while has_more:
                    if 'page' in url_dict.keys() and str.find(url_dict['url'], '{}') != -1:
                        url = url_dict['url'].format(str(url_dict['page']))
                        url_dict['page'] = url_dict['page'] + 1
                    else:
                        url = url_dict['url']
                        has_more = False
                    html = etree.HTML(request_page(url))
                    tr_list = html.xpath("//table[@id='ip_list']//tr[@class!='subtitle']")
                    for tr in tr_list:
                        ip = tr.xpath("./td[2]/text()")[0] if len(tr.xpath("./td[2]/text()")) else None
                        port = tr.xpath("./td[3]/text()")[0] if len(tr.xpath("./td[3]/text()")) else None
                        schema = tr.xpath("./td[6]/text()")[0] if len(tr.xpath("./td[6]/text()")) else None
                        if schema.lower() == "http" or schema.lower() == "https":
                            proxy = IPProxy(schema=strip(schema), ip=strip(ip), port=strip(port))
                            if proxy._check_format():
                                self.queue.push(proxy)
                    if tr_list is None:
                        has_more = False

    run.py

    通过run.py启动各个代理网站爬虫。

    # -*- coding: utf-8 -*-
    import redis
    from proxy_queue import FifoQueue
    from settings import REDIS_HOST, REDIS_PORT
    from proxy_crawlers import WuyouDailiCrawler, FeiyiDailiCrawler, KuaiDailiCrawler, IPhaiDailiCrawler, YunDailiCrawler, \
        XiCiDailiCrawler
    
    r = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT)
    fifo_queue = FifoQueue(r)
    
    
    def run_kuai():
        kuaidailiCrawler = KuaiDailiCrawler(queue=fifo_queue, website='快代理[国内高匿]',
                                            urls=[{'url': 'https://www.kuaidaili.com/free/inha/{}/', 'type': '国内高匿',
                                                   'page': 1},
                                                  {'url': 'https://www.kuaidaili.com/free/intr/{}/', 'type': '国内普通',
                                                   'page': 1}])
        kuaidailiCrawler._start_crawl()
    
    
    def run_feiyi():
        feiyidailiCrawler = FeiyiDailiCrawler(queue=fifo_queue, website='飞蚁代理',
                                              urls=[{'url': 'http://www.feiyiproxy.com/?page_id=1457', 'type': '首页推荐'}])
        feiyidailiCrawler._start_crawl()
    
    
    def run_wuyou():
        wuyoudailiCrawler = WuyouDailiCrawler(queue=fifo_queue, website='无忧代理',
                                              urls=[{'url': 'http://www.data5u.com/free/index.html', 'type': '首页推荐'},
                                                    {'url': 'http://www.data5u.com/free/gngn/index.shtml', 'type': '国内高匿'},
                                                    {'url': 'http://www.data5u.com/free/gnpt/index.shtml', 'type': '国内普通'}])
        wuyoudailiCrawler._start_crawl()
    
    
    def run_iphai():
        crawler = IPhaiDailiCrawler(queue=fifo_queue, website='IP海代理',
                                    urls=[{'url': 'http://www.iphai.com/free/ng', 'type': '国内高匿'},
                                          {'url': 'http://www.iphai.com/free/np', 'type': '国内普通'},
                                          {'url': 'http://www.iphai.com/free/wg', 'type': '国外高匿'},
                                          {'url': 'http://www.iphai.com/free/wp', 'type': '国外普通'}])
        crawler._start_crawl()
    
    
    def run_yun():
        crawler = YunDailiCrawler(queue=fifo_queue, website='云代理',
                                  urls=[{'url': 'http://www.ip3366.net/free/?stype=1&page={}', 'type': '国内高匿', 'page': 1},
                                        {'url': 'http://www.ip3366.net/free/?stype=2&page={}', 'type': '国内普通', 'page': 1},
                                        {'url': 'http://www.ip3366.net/free/?stype=3&page={}', 'type': '国外高匿', 'page': 1},
                                        {'url': 'http://www.ip3366.net/free/?stype=4&page={}', 'type': '国外普通', 'page': 1}])
        crawler._start_crawl()
    
    
    def run_xici():
        crawler = XiCiDailiCrawler(queue=fifo_queue, website='西刺代理',
                                   urls=[{'url': 'https://www.xicidaili.com/', 'type': '首页推荐'},
                                         {'url': 'https://www.xicidaili.com/nn/{}', 'type': '国内高匿', 'page': 1},
                                         {'url': 'https://www.xicidaili.com/nt/{}', 'type': '国内普通', 'page': 1},
                                         {'url': 'https://www.xicidaili.com/wn/{}', 'type': '国外高匿', 'page': 1},
                                         {'url': 'https://www.xicidaili.com/wt/{}', 'type': '国外普通', 'page': 1}])
        crawler._start_crawl()
    
    
    if __name__ == '__main__':
        run_xici()
        run_iphai()
        run_kuai()
        run_feiyi()
        run_yun()
        run_wuyou()

    爬取西刺代理时,后台日志示例如下:

    Redis数据库中爬取到的代理IP的数据结构如下:

    四、代理测试

     接下来,使用爬取好的代理来请求 http://icanhazip.com 进行测试,代码如下:

    # -*- coding: utf-8 -*-
    import random
    import requests
    from proxy_util import logger
    from run import fifo_queue
    from settings import USER_AGENT_LIST
    from proxy_util import base_headers
    
    # 测试地址
    url = 'http://icanhazip.com'
    
    # 获取代理
    proxy = fifo_queue.pop(schema='http')
    proxies = {proxy.schema:proxy._get_url()}
    
    # 构造请求头
    headers = dict(base_headers)
    if 'User-Agent' not in headers.keys():
        headers['User-Agent'] = random.choice(USER_AGENT_LIST)
    
    response = None
    successed = False
    try:
        response = requests.get(url,headers=headers,proxies = proxies,timeout=5)
    except BaseException:
        logger.error("使用代理< "+proxy._get_url()+" > 请求 < "+url+" > 结果: 失败 ")
    else:
        if (response.status_code == 200):
            logger.info(response.content.decode())
            successed = True
            logger.info("使用代理< " + proxy._get_url() + " > 请求 < " + url + " > 结果: 成功 ")
        else:
            logger.info(response.content.decode())
            logger.info("使用代理< " + proxy._get_url() + " > 请求 < " + url + " > 结果: 失败 ")
    
    # 根据请求的响应结果更新代理
    proxy._update(successed)
    # 将代理返还给队列,返还时不校验可用性
    fifo_queue.push(proxy,need_check=False)

     使用 http://218.66.253.144:80 代理请求成功后将代理重新放回队列,并将 Redis 中该代理的 used_total 、success_times 、continuous_failed三个字段信息进行了相应的更新。

    项目地址:https://github.com/pengjunlee/ipproxy_pool.git

    展开全文
  • HtmlAgilityPack+C#做IP代理爬虫(二)

    千次阅读 2019-04-26 21:36:34
    一、查找资料并进可能多的...由于网站的IP地址需要实时更新,并且程序需要对数据库中的爬虫IP数据需要及时筛选,并插入到新表中。 1、检测IP代理是否可用 public static void SelectIP(object ip) //分配端口数据 ...
  • 使用python编写的,可以免费获取ip地址,用于爬虫使用,希望大家能用到,谢谢大家的支持和关注。也希望有更好的方法的提供参考。
  • 本博客仅用于技术讨论,若有侵权,联系笔者...由于一个IP重复请求多次后服务器会不响应,所以此处笔者采用代理IP的方式。代码如下: #获取代理IP列表 def get_ip_list(url_now, headers): web_data = requests.g...
  • Python爬虫方式抓取免费http代理IP

    千次阅读 2019-07-23 16:37:43
    我们新手在练手的时候,常常需要一些代理IP进行爬虫抓取,但是因为学习阶段,对IP质量要求不高,主要是弄懂原理,所以花钱购买爬虫代理IP就显得没必要(大款忽略),今天跟大家分享一下,如果使用爬虫抓取免费的代理...
  • 如果需要匿名代理,还需要如下配置: # 关闭via  via off  # 设置不修改http_forwarded_for  forwarded_for transparent 创建squid交换目录 cd /usr/sbin/ ./squid - 启动squid, 并查看端口状态...
  • 在公司做分布式深网爬虫,搭建了一套稳定的代理池服务,为上千个爬虫提供有效的代理,保证各个爬虫拿到的都是对应网站有效的代理IP,从而保证爬虫快速稳定的运行,当然在公司做的东西不能开源出来。不过呢,闲暇...
  • 主要介绍了Python使用requests xpath 并开启多线程爬取西刺代理ip实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 爬虫之使用代理ip爬取

    千次阅读 2020-11-21 23:39:11
    爬虫代理ip的应用 ​ 在爬虫的过程中,我们经常会遇见很多网站采取了防爬虫技术,或者说因为自己采集网站信息的强度和采集速度太大,给对方服务器带去了太多的压力。 ​ 如果一直用同一个代理ip爬取这个网页,很有...
  • golang语言也是爬虫中的一种框架语言。当然很多网络爬虫新手都会面临选择什么语言适合于爬虫。一般很多爬虫用户都会选择python和java框架语言来写爬虫程序从而进行采集数据。其实除了python和java框架语言还有很多...
  • 在使用代理时 urllib.error.URLError 弹出[Errno 111] Connection refused 拒绝连接 解决方法:
  • 爬虫的初级阶段,添加headers和ip代理可以解决很多问题。 本人自己在爬取豆瓣读书的时候,就以为爬取次数过多,直接被封了IP.后来就研究了代理IP的问题. (当时不知道什么情况,差点心态就崩了…),下面给大家介绍一下...
  • C#攻克反爬虫代理IP爬取

    千次阅读 2019-10-27 10:14:31
    此时我们就需要用到代理IP来突破限制,此篇我们介绍通过DotnetSpider框架爬取西刺高匿代理IP的过程。 DotnetSpider框架简介 DotnetSpider是.net core开发的开源爬虫项目,基本开箱即用,对于爬虫各个部分的封装已经...
  • Python多个爬虫库使用代理IP

    千次阅读 多人点赞 2019-10-24 07:30:16
    使用爬虫时,如果目标网站对访问的速度或次数要求较高,那么你的 IP 就很容易被封掉,也就意味着在一段时间内无法再进行下一步的工作。这时候代理 IP 能够给我们带来很大的便利,不管网站怎么封,只要能找到一个新的...
  • 三、 在爬虫中为何要使用代理 如果我们使用爬虫对一个网站在一段时间内发起一个高频请求,该网站会检测出这个异常的现象,并将异常的请求 IP 获取,将 IP 加入到黑名单,然后改 IP 在近期就无法再次对该网站进行...
  • 原文地址:http://www.cnblogs.com/bbcar/p/3424790.html 侵删 #coding:utf-8 import urllib2 def url_user_agent(url): #设置使用代理 proxy = {'http':'27.24.158.155:84'} proxy_support = urllib2.ProxyHa
  • 爬虫代理常用的三种方式

    千次阅读 2019-06-20 15:50:10
    selenium加上代理,selenium主要是实现自动化登录验证等操作 1.Selenium调用代理  from selenium import webdriver  proxy='123.58.10.36:8080'  chrome_options=webdriver.ChromeOptions()  chrome_...
  • 爬虫,加代理的三种方式

    千次阅读 2019-03-26 18:20:40
    selenium加上代理,selenium主要是实现自动化登录验证等操作 1.Selenium调用代理  from selenium import webdriver  proxy='123.58.10.36:8080'  chrome_options=webdriver.ChromeOptions()  chrome_...
  • 在浏览器中输入: chrome://version 找到用户代理,将代理复制到Request
  • 对于requests来说,代理设置加简单,我们只需要传入proxies参数即可 import requests url = 'http://ip.tool.chinaz.com/' headers = { 'Host': "ip.tool.chinaz.com", 'User-Agent': "Mozilla/5.0 (Windows NT ...
  • // 设置通过代理访问目标页面 HttpURLConnection connection = (HttpURLConnection) url.openConnection(proxy); // 设置Proxy-Tunnel // Random random = new Random(); // int tunnel = random.nextInt(10000...
  • 使用代理服务器去爬虫的原因: 使用同一个IP去爬取同一个网站上的网页,久了之后会被该网站服务器屏蔽。这个时候我们就可以使用代理服务器。因为使用代理服务器去爬取某个网站的时候,在对方的网站上,显示的不是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,904
精华内容 19,561
关键字:

代理爬虫

爬虫 订阅