精华内容
下载资源
问答
  • Python构建代理ip池
    千次阅读
    2022-01-18 09:42:52

    概述

    用爬虫时,大部分网站都有一定的反爬措施,有些网站会限制每个 IP 的访问速度或访问次数,超出了它的限制你的 IP 就会被封掉。对于访问速度的处理比较简单,只要间隔一段时间爬取一次就行了,避免频繁访问;而对于访问次数,就需要使用代理 IP 来帮忙了,使用多个代理 IP 轮换着去访问目标网址可以有效地解决问题。

    目前网上有很多的代理服务网站提供代理服务,也提供一些免费的代理,但可用性较差,如果需求较高可以购买付费代理,可用性较好。

    因此我们可以自己构建代理池,从各种代理服务网站中获取代理 IP,并检测其可用性(使用一个稳定的网址来检测,最好是自己将要爬取的网站),再保存到数据库中,需要使用的时候再调用。

    提供免费代理的网站

    厂商名称地址
    66代理http://www.66ip.cn/
    西刺代理https://www.xicidaili.com
    全网代理http://www.goubanjia.com
    云代理http://www.ip3366.net
    IP海http://www.iphai.com
    快代理https://www.kuaidaili.com
    免费代理IP库http://ip.jiangxianli.com
    小幻代理https://ip.ihuan.me/

    本次使用的案例是小幻代理

    代码

    导包

    import loguru, requests, random, time  # 发送请求,记录日志,等
    from lxml import etree  # 分析数据
    from concurrent.futures import ThreadPoolExecutor  # 线程池
    

    网站页面的url

    由于小幻代理的每个页面的url没有规律,所以需要一一获取

    def get_url():  # 得到存放ip地址的网页
        print("正在获取ip池", ",不要着急!")
        for i in range(random.randint(10, 20)):  # 爬取随机页数
            time.sleep(1)
            if i == 0:
                url = "https://ip.ihuan.me/"
            else:
                url = url_list[-1]
            try:
                resp = requests.get(url=url, headers=headers_test, timeout=10)
            except Exception as e:
                print(e)
                break
            html = etree.HTML(resp.text)
            ul = html.xpath('//ul[@class="pagination"]')
            ul_num = html.xpath('//ul[@class="pagination"]/li')
            for j in range(len(ul_num)):
                if j != 0 and j != len(ul_num) - 1:
                    a = ul[0].xpath(f"./li[{j}+1]/a/@href")[0]
                    url_list.append("https://ip.ihuan.me/" + a)  # 得到许多的代理ip网址
            loguru.logger.info(f"over,{url}")
    

    ip地址

    def get_ip():
        for i in url_list:
            time.sleep(1)
            resp = requests.get(url=i, headers=headers)
            html = etree.HTML(resp.text)
            td = html.xpath("//tbody/tr")
            for i in td:
                ip = i.xpath("./td[1]//text()")[0]  # 地址
                pt = i.xpath("./td[2]//text()")[0]  # 端口
                tp = "http" if i.xpath("./td[5]//text()")[0] == "不支持" else "https"  # 访问类型
                ip_list.append({"type": tp, "proxy": f"{ip}:{pt}"})
        loguru.logger.info("ip地址获取完成")
    

    检测

    def test_ip(ip):
        proxy_test = {
            "http": f"{ip}",
            "https": f"{ip}"
            # 注意:如果请求的ip是https类型的,但代理的ip是只支持http的,那么还是使用本机的ip,如果请求的ip是http类型的,那么代理的ip一定要是http的,前面不能写成https,否则使用本机IP地址
        }
        resp = requests.get(url=url_test, headers=headers, proxies=proxy_test, timeout=6)
        if resp.json()["origin"] == ip.split(":")[0]:
            ip = {"type": url.strip(":")[0], "proxy": ip}  # 格式化ip,便于后期处理,是的其有http/https标识
            temp_ip.append(ip)  # 符合条件的添加,不符合条件的抛弃
    

    整理

    def set_ip(url) -> "动态构建ip池":  # 要传入需要爬取网页的url
        try:
            f = open('./app/ip.txt', "r")
            for j in eval(f.read()):
                temp_ip.append(j)
            f.close()
        except Exception as e:
            print("没有ip,正在构造ip池,请稍等")
    
        if not temp_ip:  # 判断是否有ip地址
            print("没有ip地址,正在获取")
            get_url()
        else:
            for i in temp_ip:
                ip_list.append(i)  # 将已有的ip添加到测试ip中
            temp_ip.clear()
    
        get_ip()  # 得到大量ip地址
        with open('./app/ip.txt', "w") as file:
            file.write(ip_list)
        ip_able = list(set(j["proxy"] for j in ip_list if j["type"] == url.split(":")[0]))  # 存放符合要求的ip字符串,同时利用字典去重
        url_test = "http://httpbin.org/ip" if url.split(":")[0] == "http" else ""  # 测试ip地址是否有用
    
        def test_ip(ip):
            proxy_test = {
                "http": f"{ip}",
                "https": f"{ip}"
                # 注意:如果请求的ip是https类型的,但代理的ip是只支持http的,那么还是使用本机的ip,如果请求的ip是http类型的,那么代理的ip一定要是http的,前面不能写成https,否则使用本机IP地址
            }
            resp = requests.get(url=url_test, headers=headers, proxies=proxy_test, timeout=6)
            if resp.json()["origin"] == ip.split(":")[0]:
                ip = {"type": url.strip(":")[0], "proxy": ip}  # 格式化ip,便于后期处理,是的其有http/https标识
                temp_ip.append(ip)  # 符合条件的添加,不符合条件的抛弃
    
        with ThreadPoolExecutor(50) as pool:  # 使用多线程测试
            pool.map(test_ip, ip_able)
    
        pool.join()
    
        print("测试完毕")
    
        if temp_ip:
            i = random.choice(temp_ip)
            proxy = {
                "http": f"{i['proxy']}",
                "https": f"{i['proxy']}"
            }
            return proxy
        else:
            set_ip(url=url)
    

    必要参数

    # 参数
    
    headers = {
        'User-Agent': "Mozilla / 5.0(Windows NT 10.0;Win64;x64) AppleWebKit / 537.36(KHTML, likeGecko) Chrome / 96.0.4664 .93 Safari / 537.36",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9"
    }
    headers_test = {
        'User-Agent': "Mozilla / 5.0(Windows NT 10.0;Win64;x64) AppleWebKit / 537.36(KHTML, likeGecko) Chrome / 96.0.4664 .93 Safari / 537.36",
        "accept-encoding": "gzip, deflate, br",
        "cookie": "Hm_lvt_8ccd0ef22095c2eebfe4cd6187dea829=1642389014,1642412091",
        "Referer": "https://ip.ihuan.me/"
    }
    url_list, ip_list, temp_ip = ["https://ip.ihuan.me/"], [], []  # 存放url, 存放ip地址, 有用的ip地址
    

    总代码

    import loguru, requests, random, time
    from lxml import etree
    from concurrent.futures import ThreadPoolExecutor
    
    
    def get_url():  # 得到存放ip地址的网页
        print("正在获取ip池", ",不要着急!")
        for i in range(random.randint(10, 20)):  # 爬取随机页数
            time.sleep(1)
            if i == 0:
                url = "https://ip.ihuan.me/"
            else:
                url = url_list[-1]
            try:
                resp = requests.get(url=url, headers=headers_test, timeout=10)
            except Exception as e:
                print(e)
                break
            html = etree.HTML(resp.text)
            ul = html.xpath('//ul[@class="pagination"]')
            ul_num = html.xpath('//ul[@class="pagination"]/li')
            for j in range(len(ul_num)):
                if j != 0 and j != len(ul_num) - 1:
                    a = ul[0].xpath(f"./li[{j}+1]/a/@href")[0]
                    url_list.append("https://ip.ihuan.me/" + a)  # 得到许多的代理ip网址
            loguru.logger.info(f"over,{url}")
    
    
    def get_ip():
        for i in url_list:
            time.sleep(1)
            resp = requests.get(url=i, headers=headers)
            html = etree.HTML(resp.text)
            td = html.xpath("//tbody/tr")
            for i in td:
                ip = i.xpath("./td[1]//text()")[0]  # 地址
                pt = i.xpath("./td[2]//text()")[0]  # 端口
                tp = "http" if i.xpath("./td[5]//text()")[0] == "不支持" else "https"  # 访问类型
                ip_list.append({"type": tp, "proxy": f"{ip}:{pt}"})
        loguru.logger.info("ip地址获取完成")
    
    
    def set_ip(url) -> "动态构建ip池":  # 要传入需要爬取网页的url
        try:
            f = open('./app/ip.txt', "r")
            for j in eval(f.read()):
                temp_ip.append(j)
            f.close()
        except Exception as e:
            print("没有ip,正在构造ip池,请稍等")
    
        if not temp_ip:  # 判断是否有ip地址
            print("没有ip地址,正在获取")
            get_url()
        else:
            for i in temp_ip:
                ip_list.append(i)  # 将已有的ip添加到测试ip中
            temp_ip.clear()
    
        get_ip()  # 得到大量ip地址
        with open('./app/ip.txt', "w") as file:
            file.write(ip_list)
        ip_able = list(set(j["proxy"] for j in ip_list if j["type"] == url.split(":")[0]))  # 存放符合要求的ip字符串,同时利用集合去重
        url_test = "http://httpbin.org/ip" if url.split(":")[0] == "http" else ""  # 测试ip地址是否有用
    
        def test_ip(ip):
            proxy_test = {
                "http": f"{ip}",
                "https": f"{ip}"
                # 注意:如果请求的ip是https类型的,但代理的ip是只支持http的,那么还是使用本机的ip,如果请求的ip是http类型的,那么代理的ip一定要是http的,前面不能写成https,否则使用本机IP地址
            }
            resp = requests.get(url=url_test, headers=headers, proxies=proxy_test, timeout=6)
            if resp.json()["origin"] == ip.split(":")[0]:
                ip = {"type": url.strip(":")[0], "proxy": ip}  # 格式化ip,便于后期处理,是的其有http/https标识
                temp_ip.append(ip)  # 符合条件的添加,不符合条件的抛弃
    
        with ThreadPoolExecutor(50) as pool:  # 使用多线程测试
            pool.map(test_ip, ip_able)
    
        pool.join()
    
        print("测试完毕")
    
        if temp_ip:
            i = random.choice(temp_ip)
            proxy = {
                "http": f"{i['proxy']}",
                "https": f"{i['proxy']}"
            }
            return proxy
        else:
            set_ip(url=url)
    
    
    # 参数
    
    headers = {
        'User-Agent': "Mozilla / 5.0(Windows NT 10.0;Win64;x64) AppleWebKit / 537.36(KHTML, likeGecko) Chrome / 96.0.4664 .93 Safari / 537.36",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9"
    }
    headers_test = {
        'User-Agent': "Mozilla / 5.0(Windows NT 10.0;Win64;x64) AppleWebKit / 537.36(KHTML, likeGecko) Chrome / 96.0.4664 .93 Safari / 537.36",
        "accept-encoding": "gzip, deflate, br",
        "cookie": "Hm_lvt_8ccd0ef22095c2eebfe4cd6187dea829=1642389014,1642412091",
        "Referer": "https://ip.ihuan.me/"
    }
    url_list, ip_list, temp_ip = ["https://ip.ihuan.me/"], [], []  # 存放url, 存放ip地址, 有用的ip地址
    
    if __name__ == '__main__':
        proxy = set_ip(url="https://www.baidu.com")  # 得到代理ip
        print(proxy)
    

    总结

    如果安装了数据库的话,可以使用数据库存储得到的ip,代码中使用的是本地的文件存储数据,同时,要尽量避免本机ip被封

    更多相关内容
  • 数据时代,数据最贵,爬虫是最需要掌握的技术之一,代理IP则是爬虫最大的代价。自建代理IP池管理系统,自己来掌控代理IP,物尽其用,节约成本,还可以抓取公开、免费的代理IP放入系统中,供自己使用。
  • java多线程代理IP池

    2017-11-30 09:35:46
    多线程代理IP池,一直看到有关这方面的技术,最近实现了一个。简单的来说,启动后,会一直定时的获取代理ip,并自动检测代理ip的活跃度。运用多线程的技术,在极短的时间内获取大量的ip进行筛选。架构也比较清楚,...
  • 要排除代理 ip 的影响,通常的做法是建一个代理 ip ,每次请求前来池子取一个 ip,用完之后归还,保证池子里的 ip 都是可用的。本文接下来就探讨一下,如何使用 Redis 构建代理 ip ,实现自动更新,自动择优。 ...
  • 使用爬虫时,大部分网站都有一定的反爬...因此我们可以自己构建代理池,从各种代理服务网站中获取代理 IP,并检测其可用性(使用一个稳定的网址来检测,最好是自己将要爬取的网站),再保存到数据库中,需要使用的时候
  • 包括UA伪装、代理网站的爬取、代理ip的分析检测、Python与MySQL数据库的交互、爬取内容的持久化存储。运行环境:Python 3.8.6 开发环境:PyCharm 2019.2.4
  • 动态代理ip池 架构图 说明:爬取模块将会爬取免费代理,免费代理的可用性低,如需获取高效的代理ip,请购买付费代理()。 安装Python 3.5+ 安装Redis,并启动服务 # mac os安装 pip install redis # 启动redis ...
  • 主要介绍了Python搭建代理IP池实现接口设置与整体调度,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 上一文写了如何从代理服务网站提取 IP,本文就讲解如何存储 IP,毕竟...Python搭建代理IP池(一)- 获取 IP Python搭建代理IP池(三)- 检测 IP Python搭建代理IP池(四)- 接口设置与整体调度 使用的库:pymysql 定义
  • 搭建免费代理IP池

    多人点赞 2022-05-03 22:29:41
    等等一系列的问题都要想清楚,要先将思路理清了,做起事来才能事半功倍 下面是我做这个项目的思路,可能并不是很好,有更好的想法欢迎留言讨论 代理IP池: 自身: 能采集代理IP(用爬虫抓取网站即可) 采集到的IP...

    👨‍💻博客主页:i新木优子👀
    🎉欢迎关注🔍点赞👍收藏⭐留言📝
    🧚‍♂️寄语:成功的秘诀就是每天都比别人多努力一点👣
    ✨有任何疑问欢迎评论探讨

    先声明一下:免费的代理稳定性都不高,即使经过层层筛选有些可能还是不能用,就像矮子里拔高的,即使已经是矮子里最高的,可是还是改变不了是矮子的本质

    在做任何事情之前我们都需要先思考,要如何实现?需要用到什么?等等一系列的问题都要想清楚,要先将思路理清了,做起事来才能事半功倍


    🎯下面是我做这个项目的思路,可能并不是很好,有更好的想法欢迎留言讨论
    代理IP池:
    自身:

    • 能采集代理IP(用爬虫抓取网站即可)
      采集到的IP我们的将它存储起来,这就有一个问题我们要将这些IP存储到哪里?
      Mysql?MongoDB?还是Redis?
      Mysql:它当然可以存储IP,可是它也有它的局限性,Mysql不能去重,因为有时我们采集到的IP可能一样,还有一个问题就是Mysql查询效率低
      MongoDB:也可以存储IP,但它也不能去重
      Redis:最合适,首先它的查询效率最高,还有良好的去重的集合(zset)
      为什么要用zset呢?
      zset有一个特性,他有一个分值(score),我们可以通过控制分值的高低就可以将稳定性高的IP取出来,从而提高免费IP的可用性
      不了解Redis基本用法的小伙伴可以去看一下我的上一篇博客哦
    • 能验证IP的有效性
      先将每个IP定一个初始分值(50),然后对每个IP都进行校验,如果这个IP可用那么就将这个IP的分值拉满(100),如果不可用就进行扣分(10),直到IP变成0分,就将这个IP删除

    对外:

    • 提供免费的可用的代理IP

    思路理清了,接下来就是如何写程序了

    采集:写爬虫抓取IP,将IP存储到Redis
    校验:从Redis中取出IP,用IP简单发送一个请求,如果可以正常返回,证明该IP可用
    提供:写api接口,将可用的IP提供给用户

    如果我们按照单线程去完成上面的步骤,就有局限性,只有每次将IP提供给用户,才可以继续采集IP,而我们希望的是这三个步骤互不影响,不管采集、校验还是给用户提供IP,都应该是一直进行,在提供IP的时候也可以继续采集、校验
    三个独立的程序,我们就可以用多进程
    下图就是IP代理池的模型:
    在这里插入图片描述
    仔细观察上图,三个操作都用到了Redis,所以就先写Redis涉及到的各种操作,再写其他三个功能就可以游刃有余了
    1️⃣Redis的各种操作

    • 连接Redis
    • zset存储
      判断IP存不存在,不存在就新增
    • 查询所有IP(校验IP时要用到)
    • 将分值拉满(IP可用)
    • 将分值降低(IP不可用)
    • 查询可用的IP
      先给满分的,没有满分的给51-99分的
    # redis的各种操作
    
    from redis import Redis
    from settings import *
    
    
    class ProxyRedis:
    
        # 连接redis
        def __init__(self):
            self.red = Redis(
                host=REDIS_HOST,
                port=REDIS_PORT,
                db=REDIS_DB,
                password=REDIS_PASSWORD,
                decode_responses=True
            )
    
        # 存储ip
        def add_proxy_ip(self, ip):
            # 判断是否有ip
            if not self.red.zscore(REDIS_KEY, ip):
                self.red.zadd(REDIS_KEY, {ip: DEFAULT_SCORE})
                print("采集到了IP地址了", ip)
            else:
                print("采集到了IP地址了", ip, "但是已经存在")
    
        # 查询所有ip
        def get_all_proxy(self):
            return self.red.zrange(REDIS_KEY, 0, -1)
    
        # 将分值拉满
        def set_max_score(self, ip):
            self.red.zadd(REDIS_KEY, {ip: MAX_SCORE})
    
        # 降低分值
        def reduce_score(self, ip):
            # 查询分值
            score = self.red.zscore(REDIS_KEY, ip)
            # 如果有分值,扣分
            if score > 0:
                self.red.zincrby(REDIS_KEY, -10, ip)
            else:  # 分值没有则删除
                self.red.zrem(REDIS_KEY, ip)
    
        # 查询可用ip
        def get_avail_proxy(self):
            lis = []
            ips = self.red.zrangebyscore(REDIS_KEY, MAX_SCORE, MAX_SCORE, 0, -1)
            if ips:
                lis.append(ips)
                return lis
            else:
                ips = self.red.zrangebyscore(REDIS_KEY, DEFAULT_SCORE + 1, MAX_SCORE - 1, 0, -1)
                if ips:
                    lis.append(ips)
                    return lis
                else:
                    print("没有可用ip")
                    return None
    

    2️⃣采集IP
    这里我爬取了三个网站,当然感觉不够用的自己还可以加
    快代理:https://www.kuaidaili.com/free/intr/1/
    高可用全球免费代理IP库:https://ip.jiangxianli.com/?page=1
    66免费代理网:http://www.66ip.cn/areaindex_1/1.html
    爬取这些网站很简单,基本都没有什么反爬,页面也都差不多,直接用xpath解析就可以得到想要的IP

    # 代理IP的采集
    from proxy_redis import ProxyRedis
    import requests
    from lxml import etree
    import time
    
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36"
    }
    
    # 采集快代理
    def get_kuai_ip(red):
            url = "https://www.kuaidaili.com/free/intr/1/"
            resp = requests.get(url, headers=headers)
            tree = etree.HTML(resp.text)
            trs = tree.xpath("//table/tbody/tr")
            for tr in trs:
                ip = tr.xpath("./td[1]/text()")  # ip地址
                port = tr.xpath("./td[2]/text()")  # 端口
                if not ip:
                    continue
                ip = ip[0]
                port = port[0]
                proxy_ip = ip + ":" + port
    
                red.add_proxy_ip(proxy_ip)  # 增加ip地址
    
    
    # 采集66免费代理网
    def get_66_ip(red):
        url = "http://www.66ip.cn/areaindex_1/1.html"
        resp = requests.get(url, headers=headers)
        tree = etree.HTML(resp.text)
        trs = tree.xpath("//table//tr")[1:]
        for tr in trs:
            ip = tr.xpath("./td[1]/text()")  # ip地址
            port = tr.xpath("./td[2]/text()")  # 端口
            if not ip:
                continue
            ip = ip[0]
            port = port[0]
            proxy_ip = ip + ":" + port
    
            red.add_proxy_ip(proxy_ip)  # 增加ip地址
    
    # 采集高可用全球免费代理IP库
    def get_quan_ip(red):
        url = "https://ip.jiangxianli.com/?page=1"
        resp = requests.get(url, headers=headers)
        tree = etree.HTML(resp.text)
        trs = tree.xpath("//table//tr")
        for tr in trs:
            ip = tr.xpath("./td[1]/text()")  # ip地址
            port = tr.xpath("./td[2]/text()")  # 端口
            if not ip:
                continue
            ip = ip[0]
            port = port[0]
            proxy_ip = ip + ":" + port
    
            red.add_proxy_ip(proxy_ip)  # 增加ip地址
    
    
    def run():
        red = ProxyRedis()  # 创建redis存储
        while True:
            try:
                get_kuai_ip(red)  # 采集快代理
                get_66_ip(red)  # 采集66免费代理
                get_quan_ip(red)  # 采集全球免费ip代理库
            except:
                print("出错了")
            time.sleep(60)  # 每分钟跑一次
    
    
    if __name__ == '__main__':
        run()
    

    3️⃣校验IP可用性

    • 查询所有的IP
    • 每一个IP都发送一个请求,可用分值拉满,不用可扣分
      这里如果我们采集的IP比较多的话,用单线程就比较慢了,所以为了提高效率,这里我采用协程
    # 代理IP的验证
    from proxy_redis import ProxyRedis
    from settings import *
    import asyncio
    import aiohttp
    import time
    
    
    async def verify_one(ip, sem, red):
        print(f"开始检测{ip}")
        timeout = aiohttp.ClientTimeout(total=10)  # 设置超时时间,超过10秒就报错
        try:
            async with sem:
                async with aiohttp.ClientSession() as session:
                    async with session.get("http://www.baidu.com/", proxy="http://" + ip, timeout=timeout) as resp:  # 简单发送一个请求
                        page_source = await resp.text()
                        if resp.status in [200, 302]:  # 验证状态码
                            # 将分值拉满
                            red.set_max_score(ip)
                            print(f"检测到{ip}是可用的")
                        else:
                            red.reduce_score(ip)
                            print(f"检测到{ip}是不可用的, 扣10分")
        except Exception as E:
            print("ip检验时出错了", E)
            red.reduce_score(ip)
            print(f"检测到{ip}是不可用的, 扣10分")
    
    
    async def main(red):
        # 查询全部ip
        all_proxy = red.get_all_proxy()
        sem = asyncio.Semaphore(SEM_COUNT)  # 控制并发量
        tasks = []
        for ip in all_proxy:
            tasks.append(asyncio.create_task(verify_one(ip, sem, red)))
        if tasks:
            await asyncio.wait(tasks)
    
    
    def run():
        red = ProxyRedis()
        time.sleep(10)
        while True:
            try:
                asyncio.run(main(red))
                time.sleep(100)
            except Exception as e:
                print("校验时报错了", e)
                time.sleep(100)
    
    
    if __name__ == '__main__':
        run()
    

    4️⃣提供api

    • 给用户提供一个http接口,用户通过访问http://xxx.xxx.xxx.xxx:xxxx/get_proxy就可获取到IP
      安装提供api接口的模块
    pip install sanic
    pip install sanic_cors  # 防止出现跨域的模块
    
    # 代理的IP的api接口
    from proxy_redis import ProxyRedis
    from sanic import Sanic, json
    from sanic_cors import CORS
    
    # 1. 创建app
    app = Sanic("ip")
    # 2. 解决跨域
    CORS(app)
    
    red = ProxyRedis()
    
    # 3. 准备处理http请求的函数
    @app.route("/get_proxy")  # 路由配置
    def dispose(rep):
        ip_list = red.get_avail_proxy()
        return json({"ip": ip_list})  # 返回给客户端
    
    
    def run():
        app.run(host="127.0.0.1", port=5800)
    
    
    if __name__ == '__main__':
        run()
    

    5️⃣启动采集IP、校验IP、提供api
    将三个功能串在一起,每一个功能开一个进程

    from ip_api import run as api_run
    from ip_collection import run as col_run
    from ip_verify import run as ver_run
    from multiprocessing import Process
    
    
    def run():
        # 启动三个进程
        p1 = Process(target=api_run)
        p2 = Process(target=col_run)
        p3 = Process(target=ver_run)
    
        p1.start()
        p2.start()
        p3.start()
    
    
    if __name__ == '__main__':
        run()
    

    下面代码是代理IP池的配置文件,想要修改参数的直接修改配置文件中的就行

    # 配置文件
    
    # proxy_redis
    # redis主机ip地址
    REDIS_HOST = "127.0.0.1"
    # redis端口号
    REDIS_PORT = 6379
    # redis数据库编号
    REDIS_DB = 2
    # redis的密码
    REDIS_PASSWORD = "123456"
    
    # redis的key
    REDIS_KEY = "proxy_ip"
    
    # 默认的ip分值
    DEFAULT_SCORE = 50
    # 满分
    MAX_SCORE = 100
    
    # ip_verify
    # 一次检测ip的数量
    SEM_COUNT = 30
    
    

    6️⃣到这里我们的IP代理池就已经完成了
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    我们可以看到程序可以正常执行
    然后去看一下我们的Redis中是否有IP
    在这里插入图片描述
    我们访问http://127.0.0.1:5800/get_proxy检测用户是否可以拿到IP
    在这里插入图片描述

    7️⃣检验IP代理池中的IP是否可用
    免费IP代理池已经搭建好了,接下来就从IP代理池中取出来IP,检测IP是否可以使用

    我们的IP有很多,使用这些IP最好的方法是将存放IP的列表进行循环,每拿一个IP访问一次或多次就换一个IP在访问,所以就需要写一个生成器

    import requests
    
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36"
    }
    
    
    def get_proxy():
        url = "http://127.0.0.1:5800/get_proxy"
        resp = requests.get(url, headers=headers)
        ips = resp.json()
        for ip in ips["ip"][0]:
            yield ip  # 生成器
    
    
    def spider():
        url = "http://www.baidu.com/"
        while True:
            try:
                proxy_ip = next(gen)
                proxy = {
                    "http:": "http:" + proxy_ip,
                    "https:": "http:" + proxy_ip
                }
                resp = requests.get(url, proxies=proxy, headers=headers)
                resp.encoding = "utf-8"
                return resp.text
            except:
                print("代理失效了")
    
    
    if __name__ == '__main__':
        gen = get_proxy()
        page_source = spider()
        print(page_source)
    

    可以拿到页面源代码表示我们的代理IP可用
    在这里插入图片描述

    展开全文
  • 主要介绍了Python搭建代理IP池实现检测IP的方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 在公司做分布式深网爬虫,搭建了一套稳定的代理服务,为上千个爬虫提供有效的代理,保证各个爬虫拿到的都是对应网站有效的代理IP,从而保证爬虫快速稳定的运行,当然在公司做的东西不能开源出来。不过呢,闲暇...
  • Pandas一键爬取解析代理IP与代理IP池的维护

    万次阅读 多人点赞 2021-07-04 00:16:51
    大家好,我是小小明,今天我们计划搭建一个代理Ip池。当然相对爬取免费的代理IP自己搭建代理IP池,本人更推荐大家直接购买付费的代理IP,相对而言稳定而且省心好用。 那么对于穷人而言,为了训练一下自己的技术并省...

    大家好,我是小小明,今天我们计划搭建一个代理Ip池。当然相对爬取免费的代理IP自己搭建代理IP池,本人更推荐大家直接购买付费的代理IP,相对而言稳定而且省心好用。

    那么对于穷人而言,为了训练一下自己的技术并省下几块钱,咱们还是决定自己搭建一个玩玩。

    要搭建一个代理ip池,我的思路:

    1. 爬虫定期爬取代理IP,验证代理iP有效性,有效则存入Redis数据库
    2. 一个线程或进程定期检查代理ip池的有效性,无效则从中删除

    代理IP的爬取与解析

    下面,首先去选择几个免费代理ip的网址去爬一下,这里我选择了快代理。

    快代理提供了高匿代理和普通代理两个页面供爬取,网址是:

    image-20210703213148816

    爬取高匿测试一下:

    import requests
    import pandas as pd
    
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.106 Safari/537.36'
    }
    
    i = 1
    url = f'https://www.kuaidaili.com/free/inha/{i}/'
    r = requests.get(url, headers=headers)
    r.encoding = 'u8'
    ip_df, = pd.read_html(r.text)
    ip_df
    

    image-20210703213523080

    代理IP爬了,但是是否真的能用呢?

    代理IP的校验

    我们需要验证一下,有个不错的测试网站是httpbin.org,我们可以通过它来读取自己的ip地址:

    r = requests.get(f"http://httpbin.org/ip")
    r.json()
    

    结果大致形式:

    {'origin': '116.xx.xx.xxx'}
    

    然后以如下形式访问代理ip:

    r = requests.get(f"http://httpbin.org/ip",
                     proxies={'http': "175.42.158.226:9999"})
    r.json()
    

    若抛出异常:

    image-20210703220018359

    说明代理失效。

    在我们的机器有公网IP时,我们也可以搭建自己的服务器用于校验代理IP有效性,flask代码:

    from flask import *
    
    app = Flask(__name__)
    
    
    @app.route('/')
    def index():
        return request.remote_addr
    
    
    if __name__ == '__main__':
        app.run(host="0.0.0.0", port=8088)
    

    基于此我们可以写一个校验代理IP的方法:

    def proxie_ip_validity_check(proxie_ip, proxie_type='http', timeout=1):
        try:
            r = requests.get(f"{proxie_type}://httpbin.org/ip", headers=headers,
                             proxies={proxie_type: proxie_ip}, timeout=timeout)
            if r.status_code == 200:
                return True
            return False
        except Exception as e:
            return False
    

    经过我个人测试,高匿代理似乎没有一个是可以用的,所以这次我们只爬取普通代理ip。

    批量爬取普通代理ip

    设置超时时间为2秒,取7页数据:

    import requests
    import pandas as pd
    
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.106 Safari/537.36'
    }
    
    http_ip_pool = []
    https_ip_pool = []
    for page in range(1, 8):
        print("当前爬取页面数:", page)
        url = f'https://www.kuaidaili.com/free/intr/{page}'
        r = requests.get(url, headers=headers)
        r.encoding = 'u8'
        ip_df, = pd.read_html(r.text)
        for ip, port, proxie_type in ip_df[["IP", "PORT", "类型"]].values:
            pool = http_ip_pool if proxie_type.lower() == 'http' else https_ip_pool
            proxie_ip = f"{ip}:{port}"
            if proxie_ip_validity_check(proxie_ip, proxie_type.lower(), 2):
                pool.append(proxie_ip)
    len(http_ip_pool), len(https_ip_pool)
    

    经测试爬到26个有效的代理ip,全部都是http类型:

    image-20210703222103037

    写入到Redis服务器

    为了方便其他爬虫程序使用,我们将爬到的代理IP写入到Redis数据库中。

    首先需要安装Redis,下载地址:https://github.com/MicrosoftArchive/redis/releases

    我的是Windows平台选择了:https://github.com/microsoftarchive/redis/releases/download/win-3.0.504/Redis-x64-3.0.504.zip

    解压后直接双击redis-server.exe即可启动Redis服务器:

    image-20210625120410449

    安装让Python操作redis的库:

    pip install redis
    

    基本使用:

    import redis
    
    r = redis.Redis(host='192.168.3.31', port=6379, db=0)
    r.set('name', 'zhangsan')  # 添加
    print(r.get('name'))
    
    b'zhangsan'
    

    考虑将代理IP存入Redis的set集合中,因为可以自动去重,测试一下:

    r.sadd("proxie_ip", "ip1", "ip2")
    r.sadd("proxie_ip", "ip2", "ip3")
    r.smembers("proxie_ip")
    
    {b'ip1', b'ip2', b'ip3'}
    

    于是我们可以通过以下命令一次性存入Redis中:

    if len(http_ip_pool)>0:
        r.sadd("proxie_ip_http", *http_ip_pool)
    if len(https_ip_pool)>0:
        r.sadd("proxie_ip_https", *https_ip_pool)
    

    存入Redis数据库后,Redis就已经相当于一个代理IP池,下面我们另外启动一个尝试,常识使用这些代理IP:

    从代理Ip池中获取代理IP并使用

    读取代理IP:

    import redis
    
    with redis.Redis(host='192.168.3.31', port=6379, db=0) as r:
        http_ip_bytes = r.smembers("proxie_ip_http")
        http_ip_pool = list(map(bytes.decode, http_ip_bytes))
    http_ip_pool
    
    ['139.9.25.69:3128',
     '119.3.235.101:3128',
     '122.51.207.244:8888',
     '106.58.191.24:8888',
     '222.74.202.229:9999',
     '47.111.71.29:8081',
     '222.74.202.229:80',
     '222.74.202.244:80',
     '106.58.191.218:8888',
     '222.74.202.229:8080']
    

    然后可以拿来模拟爬百度:

    import requests
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.106 Safari/537.36'
    }
    
    for ip in http_ip_pool:
        try:
            r = requests.get(f"http://www.baidu.com/",
                             headers=headers, proxies={'http': ip}, timeout=1)
            print(r.status_code)
        except Exception as e:
            print(e)
    
    HTTPConnectionPool(host='139.9.25.69', port=3128): Max retries exceeded with url: http://www.baidu.com/ (Caused by ConnectTimeoutError(<urllib3.connection.HTTPConnection object at 0x0000028D6A993248>, 'Connection to 139.9.25.69 timed out. (connect timeout=1)'))
    200
    200
    HTTPConnectionPool(host='106.58.191.24', port=8888): Max retries exceeded with url: http://www.baidu.com/ (Caused by ConnectTimeoutError(<urllib3.connection.HTTPConnection object at 0x0000028D6B59C2C8>, 'Connection to 106.58.191.24 timed out. (connect timeout=1)'))
    200
    HTTPConnectionPool(host='47.111.71.29', port=8081): Max retries exceeded with url: http://www.baidu.com/ (Caused by ProxyError('Cannot connect to proxy.', RemoteDisconnected('Remote end closed connection without response')))
    200
    200
    HTTPConnectionPool(host='106.58.191.218', port=8888): Max retries exceeded with url: http://www.baidu.com/ (Caused by ConnectTimeoutError(<urllib3.connection.HTTPConnection object at 0x0000028D6A9C2F88>, 'Connection to 106.58.191.218 timed out. (connect timeout=1)'))
    200
    

    可以看到只有一半的代理IP能在指定时间内成功访问百度,说明免费的代理IP就是不如收费的稳定。

    定期爬取并清除失效的代理IP

    只要再完成这部分,我们的代理IP池就能够初见雏形,冲!

    最终完成代码:

    import requests
    import pandas as pd
    import redis
    from threading import Timer
    import time
    
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.106 Safari/537.36'
    }
    
    
    def proxie_ip_validity_check(proxie_ip, proxie_type='http', timeout=2):
        try:
            r = requests.get(f"{proxie_type}://httpbin.org/ip",
                             proxies={proxie_type: proxie_ip}, timeout=timeout)
            if r.status_code == 200:
                return True
            return False
        except:
            return False
    
    
    redis_conn = redis.Redis(host='192.168.3.31', port=6379)
    
    
    def crawl_proxy_ip2redis():
        for page in range(1, 20):
            print("当前爬取页面:", page)
            url = f'https://www.kuaidaili.com/free/intr/{page}'
            r = requests.get(url, headers=headers)
            r.encoding = 'u8'
            ip_df, = pd.read_html(r.text)
            for ip, port, proxie_type in ip_df[["IP", "PORT", "类型"]].values:
                proxie_ip = f"{ip}:{port}"
                proxie_type = proxie_type.lower()
                if proxie_ip_validity_check(proxie_ip, proxie_type, 2):
                    redis_conn.sadd(f"proxie_ip_{proxie_type}", proxie_ip)
    
    
    def get_proxy_ip_pool(proxie_type='http'):
        http_ip_bytes = redis_conn.smembers(f"proxie_ip_{proxie_type}")
        http_ip_pool = list(map(bytes.decode, http_ip_bytes))
        return http_ip_pool
    
    
    def clear_invalid_proxie_ip():
        print("开始清空失效代理ip:")
        for proxie_type in ['http', 'https']:
            for ip in get_proxy_ip_pool(proxie_type):
                if not proxie_ip_validity_check(ip, proxie_type, 2):
                    print(proxie_type, ip, "失效")
                    redis_conn.srem(f"proxie_ip_{proxie_type}", ip)
    
    
    crawl_proxy_ip2redis()
    while True:
        # 5分钟后清空一次失效的代理ip
        Timer(5 * 60, clear_invalid_proxie_ip, ()).start()
        # 10分钟后下载一次代理ip
        Timer(10 * 60, crawl_proxy_ip2redis, ()).start()
        # 每隔10分钟一个周期
        time.sleep(10 * 60)
    

    目前测试,这个Redis代理IP池还算好使,作为一个雏形勉强能用。

    可以通过Redis图形化工具查看代理IP池的存储情况:

    image-20210704000800695

    我使用的工具叫Redis Desktop Manager,可以百度下载。

    目前我个人还算满意。

    总结

    通过本文讲解了:

    1. pandas超简代码带请求头解析表格
    2. 查看访问IP的方法
    3. 搭建简易检验代理Ip的网站
    4. Redis数据库的基本操作
    5. 代理ip在request库中的使用方法
    6. Timer定时器的使用
    7. Redis 图形化工具的使用介绍

    我是小小明,希望你有所收获。

    展开全文
  • 搭建代理IP池

    千次阅读 2021-07-30 20:46:38
    目录 爬取前的准备 爬取有IP内容 检查IP的可用性 ...通常来说,搭建代理IP池,就是爬取代理IP网站,然后做成一个IP的形式,最后在requests请求访问网站的时候proxies指定IP去访问。 爬取前的准备 有很多...

    目录

    爬取前的准备

    爬取有IP内容

    检查IP的可用性


            上一期讲到在爬取豆瓣电影Top250时,出现ip被封的情况,解决方案给出了两种:

                    1. 换个WiFi或者热点;

                    2. 搭建代理IP池。

            那么这期就来搭建代理IP池。通常来说,搭建代理IP池,就是爬取代理IP网站,然后做成一个IP的形式,最后在requests请求访问网站的时候proxies指定IP去访问。

    爬取前的准备

            有很多免费代理IP网站:

    免费代理IP http://ip.yqie.com/ipproxy.htm
    66免费代理网 http://www.66ip.cn/
    89免费代理 http://www.89ip.cn/
    无忧代理 http://www.data5u.com/
    云代理 http://www.ip3366.net/
    快代理 https://www.kuaidaili.com/free/
    极速专享代理 http://www.superfastip.com/
    HTTP代理IP https://www.xicidaili.com/wt/
    小舒代理 http://www.xsdaili.com
    西拉免费代理IP http://www.xiladaili.com/
    小幻HTTP代理 https://ip.ihuan.me/
    全网代理IP http://www.goubanjia.com/
    飞龙代理IP http://www.feilongip.com/

    我爬取的是快代理这个网站。点击进入快代理网站,如下图:

     

            观察到每页15个数据,第一页的网站 https://www.kuaidaili.com/free/inha/1 后面依次加一。我爬取的150个数据也就是10页的内容,但是这150个数据并不是都有用的。因为IP会过期,人家付费的代理IP可用率也不可能达到100%,白嫖就更不要想了,哈哈哈哈哈哈哈。

    爬取有IP内容

            搭建代理IP池,我们只需要爬取的是IP和PORT。

            值得注意的是IP的格式为  {'HTTP': 'IP:port', 'HTTPS': 'https://IP:port'} 。例如: {'HTTP': '106.45.104.146:3256', 'HTTPS': 'https://106.45.104.146:3256'}。

            由于爬取的上一期已经讲了,而且这里爬取的非常简单,这里就直接贴代码了。

    import requests
    from bs4 import BeautifulSoup
    import time
    
    
    list_ip = []
    list_port = []
    list_headers_ip = []
    
    for start in range(1,11):
    
        url = 'https://www.kuaidaili.com/free/inha/{}/'.format(start)       # 每页15个数据,共爬取10页
        print("正在处理url: ",url)
    
        headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.164 Safari/537.36 Edg/91.0.864.71'}
        response = requests.get(url=url, headers=headers)
    
        soup = BeautifulSoup(response.text, 'html.parser')
    
        ip = soup.select('#list > table > tbody > tr > td:nth-child(1)')
        port = soup.select('#list > table > tbody > tr > td:nth-child(2)')
    
        for i in ip:
            list_ip.append(i.get_text())
    
        for i in port:
            list_port.append(i.get_text())
    
        time.sleep(1)       # 防止爬取太快,数据爬取不全
    
    # 代理ip的形式:        'http':'http://119.14.253.128:8088'
    
    for i in range(150):
        IP_http = '{}:{}'.format(list_ip[i],list_port[i])
        IP_https = 'https://{}:{}'.format(list_ip[i],list_port[i])
        proxies = {
            'HTTP':IP_http,
            'HTTPS':IP_https
        }
        list_headers_ip.append(proxies)
        # print(proxies)
    
    print(list_headers_ip)

            这里就把150个代理IP爬取下来了,刚才说的有一部分的IP是无用的,所以我们需要对代理IP进行有效性分析,简单的来说就是去访问一个网站看是否可行。

    检查IP的可用性

            使用proxies,指定一个IP去访问网站,另外这里设置了一个时间段。整体意思是,如在3秒内,使用ip去访问url这个网站,成功就说明访问成功,IP可以用。反之不可以用。

    response = requests.get(url=url,headers=headers,proxies=ip,timeout=3)  

             我用的是豆瓣电影做的检测IP的网站。更简单的是,我们完全可以用自己需要爬取的网站做检测,而不需要找其它网站,检测出可以用就直接使用了,反之放弃就是。

    # 检查IP的可用性
    def check_ip(list_ip):
        headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.164 Safari/537.36 Edg/91.0.864.71',
                   'Connection': 'close'}
        # url = 'https://www.baidu.com'  # 以百度为例,检测IP的可行性
        url = 'https://movie.douban.com/subject/1292052/'
    
        can_use = []
        for ip in list_ip:
            try:
                response = requests.get(url=url,headers=headers,proxies=ip,timeout=3)      # 在0.1秒之内请求百度的服务器
                if response.status_code == 200:
                    can_use.append(ip)
            except Exception as e:
                print(e)
    
        return can_use
    
    can_use = check_ip(list_headers_ip)
    print('能用的代理IP为:',can_use)
    # for i in can_use:
    #     print(i)
    print('能用的代理IP数量为:',len(can_use))
    
    fo = open('IP代理池.txt','w')
    for i in can_use:
        fo.write(str(i)+'\n')
    
    fo.close()

             运行的结果其中就有10个IP不可用。

             将可用的IP写进txt文件中,需要时可以直接读取文件。然后使用,使用的方法和检测IP可用的方法一致。

            总结:搭建代理IP的方法主要就是爬虫爬取代理网站,以及requests请求网站用proxies指定IP。

            希望能给大家好处,有问题可以直接在评论区问,我会尽我最大的努力为大家解答的。

     

    展开全文
  • 创建代理池 import requests from lxml import etree import time def get_ip(url): headers = {'User-Agent' : 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623....
  • Python爬虫代理IP池,根据自己需求数量搭建代理IP池保存到本地,调用方法返回池中随机一条可用IP信息,随用随取,十分方便
  • Python之爬虫 搭建代理ip池

    千次阅读 2022-01-29 14:19:33
    文章目录前言一、User-...下面就开始来简单地介绍一下爬取免费的代理ip来搭建自己的代理ip池: 本次爬取免费ip代理的网址:http://www.ip3366.net/free/ 提示:以下是本篇文章正文内容,下面案例可供参考 一、User-Ag
  • 动态代理IP池 通过定时抓取的代理IP数据,并定时验证IP有效性来实现一个动态代理IP池 用法 运行 main.py 即可 Docker # 下载镜像 $ docker pull zlikun/proxy-ip-pool # 启动容器,依赖redis服务 # 如果redis非...
  • 一键建立属于自己的高匿代理IP池;爬虫再也不用担心IP地址被封了,国内高匿https、http代理获取。拥有一个属于自己的代理IP池,从此爬虫畅行无阻。
  • 代理池 ProxyPool的作用:从网络上获取免费的IP代理数据。先用爬虫程序抓取代理数据,再检查代理是否可用,可用的话就存放到数据库中。每隔重复重复执行这个过程。 ProxyPool的技术:Spring Boot + RxJava2.x + ...
  • 如何建立爬虫代理ip池

    万次阅读 2019-04-10 09:08:20
    一、为什么需要建立爬虫代理ip池 二、如何建立一个爬虫代理ip池 原文地址:https://www.cnblogs.com/TurboWay/p/8172246.html 一、为什么需要建立爬虫代理ip池 在众多的网站防爬措施中,有一种是根据ip的访问...
  • 什么是代理ip池

    千次阅读 2022-04-08 17:48:09
    什么是代理ip池? 通俗地比喻一下,它就是一个池子,里面装了很多代理ip。它有如下的行为特征: 1.池子里的ip是有生命周期的,它们将被定期验证,其中失效的将被从池子里面剔除。 2.池子里的ip是有补充渠道的,会有...
  • 爬虫的小伙伴,肯定经常遇到ip被封的情况,而现在网络上的代理ip免费的已经很难找了,那么现在就用python的requests库从爬取代理ip,创建一个ip代理,以备使用。 本代码包括ip的爬取,检测是否可用,可用保存,通过...
  • ProxyPool 爬虫代理IP池(分享)

    千次阅读 2022-04-07 13:45:17
    GitHub - jhao104/proxy_pool: Python爬虫代理IP池(proxy pool)https://github.com/jhao104/proxy_pool/ProxyPool 爬虫代理IP池项目,主要功能为定时采集网上发布的免费代理验证入库,定时验证入库的代理保证代理的...
  • Python爬虫实战(二):爬取快代理构建代理IP池

    千次阅读 多人点赞 2021-11-15 14:31:47
    第一篇:Python爬虫实战(一):翻页爬取数据存入SqlServer 第二篇:Python爬虫实战(二):爬取快代理构建代理IP池 点赞收藏博主更有创作动力哟,以后常更!!! 构建IP池的目的 使用爬虫时,大部分网站都有一定的...
  • 教你创建一个免费的代理IP池(txt存储版本) 很多人可能会为爬虫被ban,IP被封等反爬机制苦恼,接下来我就教给大家如何白嫖做一个代理IP池。 准备工作 首先是准备工作,因为是第一个版本,因此我打算先用txt存储爬取...
  • Python搭建代理IP池(一)- 获取 IP

    万次阅读 多人点赞 2019-10-13 21:57:41
    而对于访问次数,就需要使用代理 IP 来帮忙了,使用多个代理 IP 轮换着去访问目标网址可以有效地解决问题。 目前网上有很多的代理服务网站可以提供代理服务,也提供一些免费的代理,但可用性较差,如果需...
  • 建立爬虫代理ip池

    2020-12-30 07:37:16
    在爬取网站信息的过程中,有些网站...所以建立并维护好一个有效的代理ip池也是爬虫的一个准备工作。网上提供免费代理ip的网址很多,下面我们以西刺网站为例来建立一个有效的代理ip池。项目流程:第一步:构造请求...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,915
精华内容 21,966
关键字:

代理ip池

友情链接: js焦点图代码.rar