精华内容
下载资源
问答
  • 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技术,分享一些学习的方法和需要留意的小细节

    展开全文
  • 爬虫为什么要设置代理?写爬虫,大家都知道,抓的网站和数据多了,如果爬虫抓取速度过快,免不了触发网站的防爬机制,几乎用的同一招就是封IP。解决方案有2个:1 同一IP,放慢速度(爬取速度慢)2 使用代理IP访问...

    一 爬虫为什么要设置代理?

    写爬虫,大家都知道,抓的网站和数据多了,如果爬虫抓取速度过快,免不了触发网站的防爬机制,几乎用的同一招就是封IP。解决方案有2个:

    1 同一IP,放慢速度(爬取速度慢)

    2 使用代理IP访问(推荐)

    第一种方案牺牲的就是时间和速度,那肯定是我们所不能忍受的。所以第二种方案是推荐的,那么从哪里能找到这么多代理IP呢?今天无意中发现了一个网站国内高匿代理IP,经测试,发现可用性蛮高的。

    二 爬取代码

    我用的requests和Beautifulsoup爬的,最后写入文本文件。代码如下:

    import requests

    import os

    from bs4 import BeautifulSoup

    os.chdir(r'C:\Users\Administrator\Desktop\scrapy\proxy')

    headers = {'User-Agent':'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Mobile Safari/537.36'}

    url = 'http://www.xicidaili.com/nn/1'

    s = requests.get(url,headers = headers)

    soup = BeautifulSoup(s.text,'lxml')

    ips = soup.select('#ip_list tr')

    fp = open('host.txt','w')

    for i in ips:

    try:

    ipp = i.select('td')

    ip = ipp[1].text

    host = ipp[2].text

    fp.write(ip)

    fp.write('\t')

    fp.write(host)

    fp.write('\n')

    except Exception as e :

    print ('no ip !')

    fp.close()

    最后类似这种

    QQ截图20170228180121.png

    三 代理检验

    有很多ip是不可用的,我们可以检验下,代码如下:

    import requests

    import os

    from bs4 import BeautifulSoup

    os.chdir(r'C:\Users\Administrator\Desktop\scrapy\proxy')

    # headers = {'User-Agent':'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Mobile Safari/537.36'}

    url = 'https://www.baidu.com'

    fp = open('host.txt','r')

    ips = fp.readlines()

    proxys = list()

    for p in ips:

    ip =p.strip('\n').split('\t')

    proxy = 'http:\\' + ip[0] + ':' + ip[1]

    proxies = {'proxy':proxy}

    proxys.append(proxies)

    for pro in proxys:

    try :

    s = requests.get(url,proxies = pro)

    print (s)

    except Exception as e:

    print (e)

    结果如下:

    QQ截图20170228180922.png

    从结果看,可用的还是蛮多的。

    爬虫代理上手

    养兵千日用兵一时,有了代理以后,终于可以派上用场了,我把代理加到了我的爬虫中,代码如下:

    def get_detail(cols,book,sheet,proxys):

    index = 1

    headers = {'User-Agent':'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Mobile Safari/537.36'}

    for url in cols:

    print (url)

    print (random.choice(proxys))

    try:

    s = requests.get(url,headers = headers,proxies=random.choice(proxys))

    soup = BeautifulSoup(s.text,'lxml')

    details = soup.select('.con-txt > li')

    person = details[0].text.split(':')[1]

    phone = details[1].text.split(':')[1]

    name = details[2].text.split(':')[1]

    address = details[5].text.split(':')[1]

    write_excel(book,sheet,index,name,address,person,phone)

    index = index + 1

    print ('查询成功!')

    except Exception as e:

    print ('爬取网页失败!')

    book.save('./2.xls')

    之前爬取时因爬取速度过快被拒的情况,现在不会发生了

    QQ截图20170301094452.png

    五 总结

    以后爬虫的时候,遇到服务器限制访问次数的时候,就可以使用代理了,先从类似国内高匿代理IP等网站爬取最新的代理ip,保存到本地,当然要进行检验,把无效的ip删掉,我们就可以在我们的代码中使用代理了。

    展开全文
  • python爬虫requests使用代理ip一、总结一句话总结:a、请求时,先将请求发给代理服务器,代理服务器请求目标服务器,然后目标服务器将数据传给代理服务器,代理服务器再将数据给爬虫。b、代理服务器是经常变化的,...

    python爬虫requests使用代理ip

    一、总结

    一句话总结:

    a、请求时,先将请求发给代理服务器,代理服务器请求目标服务器,然后目标服务器将数据传给代理服务器,代理服务器再将数据给爬虫。

    b、代理服务器是经常变化的,使用代理服务器时传一个参数:proxy,是一个字典的形式。

    importrequests

    proxy={'http':'58.87.98.150:1080'}

    response=requests.get("http://httpbin.org/ip",proxies=proxy)print(response.text)

    二、python爬虫requests使用代理ip

    转自或参考:python爬虫(十) requests使用代理ip - 方木Fengl - 博客园

    https://www.cnblogs.com/zhaoxinhui/p/12383760.html

    请求时,先将请求发给代理服务器,代理服务器请求目标服务器,然后目标服务器将数据传给代理服务器,代理服务器再将数据给爬虫。

    代理服务器是经常变化的

    使用代理服务器时传一个参数:proxy。是一个字典的形式。

    通过网址:httpbin.org/ip可以看到当前请求得ip地址:

    再快代理官网,点击开放代理可以找到一个代理:

    在选第一个ip时,报错超时,说明这个ip已经不能用了,再选第二个

    importrequests

    proxy={'http':'58.87.98.150:1080'}

    response=requests.get("http://httpbin.org/ip",proxies=proxy)print(response.text)

    此时得结果就是代理ip

    展开全文
  • 06-代理爬虫实战

    2020-08-24 10:55:39
    爬虫代理概述 在爬虫中,所谓的代理指的就是代理服务器 代理服务器的作用就是用来转发请求和响应 如果我们的爬虫在短时间内对服务器发起高频的请求,那么服务器会检测到这样的一个异常行为请求,就会将该请求对应...

    爬虫代理概述

    • 在爬虫中,所谓的代理指的就是代理服务器
    • 代理服务器的作用就是用来转发请求和响应
    • 如果我们的爬虫在短时间内对服务器发起高频的请求,那么服务器会检测到这样的一个异常行为请求,就会将该请求对应设备的ip进行封禁,设备就无法对服务器再次进行请求发送了
    • 使用代理服务器进行信息爬取,可以很好的解决IP限制的问题
      一般模式: 客户端 ----> 服务器端
      代理模式: 客户端----> 代理 -----> 服务器端
    • 我们浏览信息的时候,先向代理服务器发出请求,然后又代理服务向互联网获取信息,再返回给我们
    • 代理服务器分为不同的匿名度
      • 透明代理:如果使用了该形式的代理,服务器端知道你使用了代理机制也知道你真是ip
      • 匿名代理:知道你使用代理,但是不知道你的真实ip
      • 高匿代理:不知道你使用代理,也不知道你真实ip
    • 代理的类型:
      • https: 代理只能转发https协议的请求
      • http:转发http的请求
    • 购买代理服务器:
      • 快代理
      • 西祠代理
      • goubanjia
      • 代理精灵(推荐):http://http.zhiliandaili.cn
        在这里插入图片描述
        在这里插入图片描述
        在这里插入图片描述
    # -*- coding: utf-8 -*-
    import requests
    from lxml import etree
    import random
    
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36"
    
    } #模仿浏览器UA头
    
    # 封装代理池提取代理api链接里面的代理ip端口
    url = "http://t.ipjldl.com/index.php/api/entry?method=proxyServer.generate_api_url&packid=1&fa=0&fetch_key=&groupid=0&qty=5&time=1&pro=&city=&port=1&format=html&ss=5&css=&dt=1&specialTxt=3&specialJson=&usertype=15"
    page_text =requests.get(url,headers=headers).text
    tree =etree.HTML(page_text)
    proxy_list = tree.xpath('//body//text()')
    http_proxy = []#代理池
    for proxy in proxy_list:
        dic = {
            "https":proxy
        } #封装成一个  http/https : 代理ip 的字典
        http_proxy.append(dic) #把结果追加到16行定义的代理池列表中
    print(http_proxy)
    

    在这里插入图片描述
    在这里插入图片描述

    # -*- coding: utf-8 -*-
    import requests
    from lxml import etree
    import random
    
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36"
    
    } #模仿浏览器UA头
    
    # 封装代理池提取代理api链接里面的代理ip端口
    url = "http://ip.ipjldl.com/index.php/api/entry?method=proxyServer.generate_api_url&packid=1&fa=0&fetch_key=&groupid=0&qty=10&time=1&pro=&city=&port=1&format=html&ss=5&css=&dt=1&specialTxt=3&specialJson=&usertype=15"
    page_text =requests.get(url,headers=headers).text
    tree =etree.HTML(page_text)
    proxy_list = tree.xpath('//body//text()')
    http_proxy = []#代理池
    for proxy in proxy_list:
        dic = {
            "https":proxy
        } #封装成一个  http/https : 代理ip 的字典
        http_proxy.append(dic) #把结果追加到16行定义的代理池列表中
    print(http_proxy)
    url2 = "https://weixin.sogou.com/weixin?query=风景&page=%d"+"&ie=utf8" ##定义通用翻页url
    for pg in range(1,100):
        new_url = format(url2%pg) ##定义通用翻页url
        print(new_url)
        html2 = requests.get(url=new_url,headers=headers,proxies=random.choice(http_proxy)).text
        tree2 = etree.HTML(html2)
        title = tree2.xpath("//div[@class='txt-box']/h3/a//text()")
        print(title)
        nr = tree2.xpath("//div[@class='txt-box']/p//text()")
        print(nr)
    

    在这里插入图片描述

    使用代理爬取搜狗商品
    在这里插入图片描述

    # -*- coding: utf-8 -*-
    import requests
    from lxml import etree
    import random
    
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36"
    
    } #模仿浏览器UA头
    #封装代理池提取代理api链接里面的代理ip端口
    url = "http://t.ipjldl.com/index.php/api/entry?method=proxyServer.generate_api_url&packid=1&fa=0&fetch_key=&groupid=0&qty=200&time=1&pro=&city=&port=1&format=html&ss=5&css=&dt=1&specialTxt=3&specialJson=&usertype=15"
    page_text =requests.get(url,headers=headers).text
    tree =etree.HTML(page_text)
    proxy_list = tree.xpath('//body//text()')
    http_proxy = []#代理池
    for proxy in proxy_list:
        dic = {
            "https":proxy
        } #封装成一个  http/https : 代理ip 的字典
        http_proxy.append(dic) #把结果追加到定义的代理池列表中
    print(http_proxy)
    
    url2 = "https://gouwu.sogou.com/shop?ie=utf8&query=2020&p=40251501&sourceid=sr_bpage&page=%d" ##定义通用翻页url
    for pg in range(1,100):
        new_url = format(url2%pg) ##定义通用翻页url
        print(new_url)
        html2 = requests.get(url=new_url,headers=headers,proxies=random.choice(http_proxy)).text#携带代理池
        tree2 = etree.HTML(html2)
        title = tree2.xpath('//h4/a//text()')
        for title1 in title:
            print(title1)
    
    

    在这里插入图片描述

    展开全文
  • 原文地址: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
  • 免费代理爬虫遭遇JavaScript

    千次阅读 2017-10-28 04:58:03
    爬虫过程经常会遇到JavaScript反爬虫,如果JavaScript代码可读性强,那么写出相应的python代码,效率是最高的。如果JavaScript代码可读性非常差,也可以考虑使用基于selenium的phantomjs。本文采用的是第一种。
  • 历时大致两个月,到现在终于完成了分布式代理抓取爬虫,目前开源在了Github上。写这个项目的原因主要有两点,一是自己平时的部分工作需要和爬虫打交道,代理IP在有的时候可以发挥非常重要的作用,调研过一些开源的...
  • 有时需要爬取一个目标网站过多数据的时候,python会在短时间内多次访问,如果目标网站有反扒措施,则IP地址有可能被禁止访问,造成程序失败,可以用IP池做IP代理,headers池伪装不同浏览器,从而更搞笑的爬取数据
  • 如何使用ip代理爬虫

    千次阅读 2017-03-08 14:55:19
    import urllib import socket import urllib2 import time from bs4 import BeautifulSoup url = 'http://www.xicidaili.com/nn/' target="https://msdn.microsoft.com" dirt={} proxy = {'http': '223.15.151.149
  • 吐槽作为一名小白,初次写的爬虫,对于性能、耗时等等完全不在意。但是之前写的验证100个proxyIp的有效性话的时间是在无法接受470秒,在被逼无奈的情况下,用多进程改进,但是途中闹了很多笑话,这里记录一下。 背景...
  • HtmlAgilityPack+C#做IP代理爬虫(二)

    千次阅读 2019-04-26 21:36:34
    一、查找资料并进可能多的...由于网站的IP地址需要实时更新,并且程序需要对数据库中的爬虫IP数据需要及时筛选,并插入到新表中。 1、检测IP代理是否可用 public static void SelectIP(object ip) //分配端口数据 ...
  • python IP代理爬虫,download 代理IP

    千次阅读 2013-08-13 18:24:31
    本人小白,自己写来试试的,打算以后做个自动切换HTTP代理的Python程序那,第一次写博客,大家多包涵哈。#-*- coding: utf-8 -*- import re import urllib2 import sys import time import os def search_url_1...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,629
精华内容 3,451
关键字:

代理爬虫

爬虫 订阅