代理ip 订阅
代理服务器(Proxy Server)的功能是代理网络用户去取得网络信息。形象地说,它是网络信息的中转站,是个人网络和Internet服务商之间的中间代理机构,负责转发合法的网络信息,对转发进行控制和登记。 [1]  代理服务器作为连接Internet与Intranet的桥梁,在实际应用中发挥着极其重要的作用,它可用于多个目的,最基本的功能是连接,此外还包括安全性、缓存、内容过滤、访问控制管理等功能。更重要的是,代理服务器是Internet链路级网关所提供的一种重要的安全功能,它的工作主要在开放系统互联(OSI)模型的对话层。 [1] 展开全文
代理服务器(Proxy Server)的功能是代理网络用户去取得网络信息。形象地说,它是网络信息的中转站,是个人网络和Internet服务商之间的中间代理机构,负责转发合法的网络信息,对转发进行控制和登记。 [1]  代理服务器作为连接Internet与Intranet的桥梁,在实际应用中发挥着极其重要的作用,它可用于多个目的,最基本的功能是连接,此外还包括安全性、缓存、内容过滤、访问控制管理等功能。更重要的是,代理服务器是Internet链路级网关所提供的一种重要的安全功能,它的工作主要在开放系统互联(OSI)模型的对话层。 [1]
信息
性能指标
吞吐量、最大并发连接数、丢包率等
外文名
Proxy Server
作    用
充当防火墙、节省IP开销等
中文名
代理服务器
功    能
代理网络用户去取得网络信息
属    性
一种计算机应用软件
代理服务器简介
随着Internet与Intranet的飞速发展,作为连接Internet与Intranet的的桥梁,代理服务器在实际应用中发挥着极其重要的作用。 [2]  代理服务器是网络信息的中转站。一般情况下,使用网络浏览器直接去链接其它Internet站点并取得网络信息时,须送出请求信号来得到应答,然后对方再把信息传送回来。代理服务器是介于浏览器和Web服务器之间的一台服务器,有了它之后,浏览器不是直接到Web服务器去取回网页而是向代理服务器发出请求,请求信号会先送到代理服务器,由代理服务器来取回浏览器所需要的信息并传送给你的浏览器。而且,大部分代理服务器都具有缓冲的功能,就好像一个大的Cache,它不断将新取得数据包存到它本机的存储器上,如果浏览器所请求的数据在它本机的存储器上已经存在而且是最新的,那么它就不重新从Web服务器取数据,而直接将存储器上的数据传送给用户的浏览器,这样就能显著提高浏览速度和效率。代理服务器不仅可以实现提高浏览速度和效率的功能,它还可以实现网络的安全过滤、流量控制(减少Internet使用费用)、用户管理等功能,因此它既是一种网络防火墙技术,同时也可以解决许多单位连接Internet引起IP地址不足的问题。
收起全文
精华内容
下载资源
问答
  • 在Jsoup.jar中集成代理ip的设置功能,方便用户使用, 例:Jsoup.connect("http://1212.ip138.com/ic.asp").proxy("test.proxy.mayidaili.com", 8123, null).header("Proxy-Authorization", authHeader).get();
  • Pandas一键爬取解析代理IP代理IP池的维护

    万次阅读 多人点赞 2021-07-04 00:16:51
    当然相对爬取免费的代理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 图形化工具的使用介绍

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

    展开全文
  • C# webbrowser控件设置代理IP访问网站

    千次下载 热门讨论 2014-10-15 16:57:49
    C#:webbrowser控件设置代理IP访问网站
  • 简易代理IP池的搭建

    千次阅读 2019-05-11 17:09:42
    简易代理IP池搭建

    一、导论

    这段时间在学习代理的相关知识。在爬虫的过程中,经常会遇到目标网站对同一IP的访问频率设置了限制,而设置代理是应对反爬虫的重要有效手段。目前互联网上也有不少免费的代理网站,比如西刺代理、快代理、66ip等等。但是笔者在使用过程中,发现几个问题:一是免费代理确实可用率太低;二是免费代理网站本身也部署了反爬虫的措施,并且对于部分网站比如西刺代理,使用该网站自身的高匿代理也无法进行访问,应该是设置了屏蔽。于是乎笔者谋生了自己搭建一个代理IP池的想法。

    二、程序结构

    本程序属于简易的IP代理池搭建,适合小规模的爬虫。整个程序分为三个模块:爬取代理模块、存储模块、测试模块。

    1.存储模块

    本程序存储代理IP的数据库选用的MongoDB,MongoDB是一个非关系型数据库,存取速度都很快。Python中操作MongoDB的第三方模块是pymongo。存储模块包括了存储IP和取出IP两个函数。

    # 存储
    def insert_to_MongoDB(ip, score):
        if myCol.find_one({"IP": ip}) == None: #重复ip不存储
            myCol.insert_one({"IP": ip, "Score": score})
    
    
    # 取出
    def get_from_MongoDB(n = 0):
        """
        :param n: 要返回的ip个数,默认为0取出全部
        :return:
        """
        r = myCol.find().sort("Score", -1).limit(n)
        return r
    

    2.爬取代理模块

    本模块是整个程序的核心,用于在多个代理网站爬取代理IP。这里只有西刺代理和快代理两个代理网站,可以根据需求扩展更多的代理网站。

    在获取页面源代码函数(get_html)函数中可以看到,对于访问免费代理网站也被封IP的情况,采取了使用IP池已有的高匿代理进行尝试的措施。因为现有的免费代理网站,根据笔者的观察基本上都对同一IP的访问次数进行了限制,采取这种措施也是提高了代理IP的获取成功率。

    各代理网站的爬取,是使用多线程并发运行,在后续的主程序中将可以看到。

    # 获取页面源码
    def get_html(url):
        headers = {"User-Agent": ua.random}
        try:
            response = requests.get(url=url, headers=headers, timeout=5)
            if response.status_code == 200:
                return response.text
        except Exception:
            pass # 获取源码失败
        # 如果不能访问,则使用ip池的代理ip进行尝试
        proxy_ips = get_from_MongoDB()
        for proxy_ip in proxy_ips:
            proxies = {"http": "http://" + proxy_ip["IP"], "https": "https://" + proxy_ip["IP"]}
            try:
                response_proxy = requests.get(url=url, headers=headers, proxies=proxies, timeout=5)
                if response_proxy.status_code == 200:
                    return response_proxy.text
            except Exception:
                pass
        return "" # 若所有代理均不能成功访问,则返回空字符串
    
    # 西刺代理
    def xicidaili():
        page = 3 # 要爬取的页数
        ip_list = [] # 临时存储爬取下来的ip
        for p in range(page+1):
            url = "https://www.xicidaili.com/nn/" + str(p+1)
            html = get_html(url)
            if html != "":
                soup = BeautifulSoup(html, 'lxml')
                ips = soup.find_all('tr', class_='odd')
                for i in ips:
                    tmp = i.find_all('td')
                    ip = tmp[1].text + ':' + tmp[2].text
                    ip_list.append(ip)
                    print('线程{}爬取ip:{}'.format(threading.current_thread().name, ip))
                time.sleep(3)
            else:
                print('西刺代理获取失败!')
                break
        for item in ip_list:
            queue_lock.acquire()
            insert_to_MongoDB(item, 10)
            queue_lock.release()
    
    # 快代理
    def kuaidaili():
        page = 10 # 要爬取的页数
        ip_list = [] # 临时存储爬取下来的ip
        for p in range(page+1):
            url = "https://www.kuaidaili.com/free/inha/{}/".format(p+1)
            html = get_html(url)
            if html != "":
                soup = BeautifulSoup(html, 'lxml')
                ips = soup.select('td[data-title="IP"]')
                ports = soup.select('td[data-title="PORT"]')
                for i in range(len(ips)):
                    ip = ips[i].text + ':' + ports[i].text
                    ip_list.append(ip)
                    print('线程{}爬取ip:{}'.format(threading.current_thread().name, ip))
                time.sleep(3)
            else:
                print('快代理获取失败!')
                break
        for item in ip_list:
            queue_lock.acquire()
            insert_to_MongoDB(item, 10)
            queue_lock.release()
    

    3.测试模块

    爬取下来的代理IP需要进行验证是否可用。由于需要检测的IP数量比较多,而每一次检测有几秒的等待时间,所以这里采用了aiohttp实现高并发的请求。aiohttp是基于asyncio实现的 HTTP 框架,专门用于异步处理 HTTP 的请求。而asyncio是 Python 3.4 版本引入的标准库,功能是实现单线程并发,使用协同执行 I/O 操作。

    # 评分调整
    def adjust_score(ip, myType):
        """
        验证成功的直接评分变为100,未验证成功的减1,评分为0的直接删除
        :param ip:
        :param type: 1 加分,-1 减分
        :return:
        """
        if myType == 1:
            query_ip = {"IP": ip}
            new_value = {"$set": {"Score": 100}}
            myCol.update_one(query_ip, new_value)
        elif myType == -1:
            query_ip = {"IP": ip}
            current_score = myCol.find_one(query_ip)["Score"]
            if current_score == 1:
                myCol.delete_one(query_ip)
            else:
                new_value = {"$set": {"Score": current_score-1}}
                myCol.update_one(query_ip, new_value)
    
    
    async def ip_test(url, headers, proxy):
        test_proxy = "http://" + proxy
        conn = aiohttp.TCPConnector(ssl=False)
        async with aiohttp.ClientSession(connector=conn) as session:
            try:
                async with session.get(url=url, headers=headers, proxy=test_proxy) as resp:
                    if resp.status == 200:
                        adjust_score(proxy, 1)
                    else:
                        adjust_score(proxy, -1)
            except:
                adjust_score(proxy, -1)
    
    
    # ip池测试
    def pool_test():
        COUNTS = 100 # 每次测试100个ip
        ua = UserAgent()
        proxy_ips = list(get_from_MongoDB())
        test_url = "http://www.baidu.com" # 可替换为要爬取的网址
        for i in range(0, len(proxy_ips), COUNTS):
            tasks = [ip_test(test_url, {"User-Agent": ua.random}, proxy["IP"]) for proxy in proxy_ips[i:i+COUNTS]]
            loop = asyncio.get_event_loop()
            loop.run_until_complete(asyncio.wait(tasks))
            print("共{}个,已测试{}个".format(len(proxy_ips) + 1, COUNTS + i))
            time.sleep(5)
    

    本程序对于代理IP是否可用的评分,是出自崔庆才老师的《Python 3网络爬虫开发实战》中《代理池的维护》这一节的思路。具体实现方法是对于测试可用的IP,直接评分为100;测试不可用的IP,评分减1,如果评分为0的就从数据库中删除;新爬取添加进库的,由于不可用的几率比较高,统一评分为10。从MongoDB中取出代理IP时,也是按评分从高到低的顺序进行提取。

    4.主程序

    每次爬取和检测完所有代理IP后,间隔5分钟再次执行爬取和检测,不断补充新的代理IP和淘汰不可用的代理IP。

    from fake_useragent import UserAgent
    import requests
    from bs4 import BeautifulSoup
    import pymongo
    import threading
    import aiohttp
    import asyncio
    import time
    
    
    if __name__ == '__main__':
        # 连接MongoDB数据库
        myClient = pymongo.MongoClient("mongodb://localhost:27017/")
        myDB = myClient["IPpool"]
        myCol = myDB["pool"]
    
        # 伪装用户代理
        ua = UserAgent()
    
        # 间隔5分钟爬取和测试一次
        while 1:
            # 爬取模块线程
            queue_lock = threading.Lock()
            threads = []
            proxy_dict = {"kuaidaili": kuaidaili, "xicidaili": xicidaili}
            crawler_start(proxy_dict)
    
            # 测试模块线程
            print("代理ip爬取完毕,开始进行测试!")
            pool_test()
            print("测试完毕!")
            time.sleep(300)
    

    其中爬虫多线程的启动封装在crawler_start()函数里

    # 爬取代理ip线程启动
    def crawler_start(proxy_dict):
        global threads
        for proxy in proxy_dict.keys():
            thread = threading.Thread(target=proxy_dict[proxy], name=proxy)
            thread.start()
            threads.append(thread)
        for t in threads:  # 等待所有线程完成
            t.join()
    

    这个地方要给大家推荐一个很好用的库,fake_useragent,它包含了很多User-Agent,使用UserAgent().random可以给你提供一个随机选择的User-Agent,非常实用方便。本程序所有headers中的User-Agent都是用的这个。

    三、完整代码

    from fake_useragent import UserAgent
    import requests
    from bs4 import BeautifulSoup
    import pymongo
    import threading
    import aiohttp
    import asyncio
    import time
    
    # 存储
    def insert_to_MongoDB(ip, score):
        if myCol.find_one({"IP": ip}) == None: #重复ip不存储
            myCol.insert_one({"IP": ip, "Score": score})
    
    # 取出
    def get_from_MongoDB(n = 0):
        """
        :param n: 要返回的ip个数,默认为0取出全部
        :return:
        """
        r = myCol.find().sort("Score", -1).limit(n)
        return r
    
    
    # 获取页面源码
    def get_html(url):
        headers = {"User-Agent": ua.random}
        try:
            response = requests.get(url=url, headers=headers, timeout=5)
            if response.status_code == 200:
                return response.text
        except Exception:
            pass # 获取源码失败
        # 如果不能访问,则使用ip池的代理ip进行尝试
        proxy_ips = get_from_MongoDB()
        for proxy_ip in proxy_ips:
            proxies = {"http": "http://" + proxy_ip["IP"], "https": "https://" + proxy_ip["IP"]}
            try:
                response_proxy = requests.get(url=url, headers=headers, proxies=proxies, timeout=5)
                if response_proxy.status_code == 200:
                    return response_proxy.text
            except Exception:
                pass
        return "" # 若所有代理均不能成功访问,则返回空字符串
    
    # 西刺代理
    def xicidaili():
        page = 3 # 要爬取的页数
        ip_list = [] # 临时存储爬取下来的ip
        for p in range(page+1):
            url = "https://www.xicidaili.com/nn/" + str(p+1)
            html = get_html(url)
            if html != "":
                soup = BeautifulSoup(html, 'lxml')
                ips = soup.find_all('tr', class_='odd')
                for i in ips:
                    tmp = i.find_all('td')
                    ip = tmp[1].text + ':' + tmp[2].text
                    ip_list.append(ip)
                    print('线程{}爬取ip:{}'.format(threading.current_thread().name, ip))
                time.sleep(3)
            else:
                print('西刺代理获取失败!')
                break
        for item in ip_list:
            queue_lock.acquire()
            insert_to_MongoDB(item, 10)
            queue_lock.release()
    
    # 快代理
    def kuaidaili():
        page = 10 # 要爬取的页数
        ip_list = [] # 临时存储爬取下来的ip
        for p in range(page+1):
            url = "https://www.kuaidaili.com/free/inha/{}/".format(p+1)
            html = get_html(url)
            if html != "":
                soup = BeautifulSoup(html, 'lxml')
                ips = soup.select('td[data-title="IP"]')
                ports = soup.select('td[data-title="PORT"]')
                for i in range(len(ips)):
                    ip = ips[i].text + ':' + ports[i].text
                    ip_list.append(ip)
                    print('线程{}爬取ip:{}'.format(threading.current_thread().name, ip))
                time.sleep(3)
            else:
                print('快代理获取失败!')
                break
        for item in ip_list:
            queue_lock.acquire()
            insert_to_MongoDB(item, 10)
            queue_lock.release()
    
    
    # 评分调整
    def adjust_score(ip, myType):
        """
        验证成功的直接评分变为100,未验证成功的减1,评分为0的直接删除
        :param ip:
        :param type: 1 加分,-1 减分
        :return:
        """
        if myType == 1:
            query_ip = {"IP": ip}
            new_value = {"$set": {"Score": 100}}
            myCol.update_one(query_ip, new_value)
        elif myType == -1:
            query_ip = {"IP": ip}
            current_score = myCol.find_one(query_ip)["Score"]
            if current_score == 1:
                myCol.delete_one(query_ip)
            else:
                new_value = {"$set": {"Score": current_score-1}}
                myCol.update_one(query_ip, new_value)
               
    async def ip_test(url, headers, proxy):
        test_proxy = "http://" + proxy
        conn = aiohttp.TCPConnector(ssl=False)
        async with aiohttp.ClientSession(connector=conn) as session:
            try:
                async with session.get(url=url, headers=headers, proxy=test_proxy) as resp:
                    if resp.status == 200:
                        adjust_score(proxy, 1)
                    else:
                        adjust_score(proxy, -1)
            except:
                adjust_score(proxy, -1)
    
    # ip池测试
    def pool_test():
        COUNTS = 100 # 每次测试100个ip
        ua = UserAgent()
        proxy_ips = list(get_from_MongoDB())
        test_url = "http://www.baidu.com" # 可替换为要爬取的网址
        for i in range(0, len(proxy_ips), COUNTS):
            tasks = [ip_test(test_url, {"User-Agent": ua.random}, proxy["IP"]) for proxy in proxy_ips[i:i+COUNTS]]
            loop = asyncio.get_event_loop()
            loop.run_until_complete(asyncio.wait(tasks))
            print("共{}个,已测试{}个".format(len(proxy_ips) + 1, COUNTS + i))
            time.sleep(5)
    
    
    # 爬取代理ip线程启动
    def crawler_start(proxy_dict):
        global threads
        for proxy in proxy_dict.keys():
            thread = threading.Thread(target=proxy_dict[proxy], name=proxy)
            thread.start()
            threads.append(thread)
        for t in threads:  # 等待所有线程完成
            t.join()
    
    
    if __name__ == '__main__':
        # 连接MongoDB数据库
        myClient = pymongo.MongoClient("mongodb://localhost:27017/")
        myDB = myClient["IPpool"]
        myCol = myDB["pool"]
    
        # 伪装用户代理
        ua = UserAgent()
    
        # 间隔5分钟爬取和测试一次
        while 1:
            # 爬取模块线程
            queue_lock = threading.Lock()
            threads = []
            proxy_dict = {"kuaidaili": kuaidaili, "xicidaili": xicidaili}
            crawler_start(proxy_dict)
    
            # 测试模块线程
            print("代理ip爬取完毕,开始进行测试!")
            pool_test()
            print("测试完毕!")
            time.sleep(300)
    

    程序跑起来后,其他需要用到代理IP的爬虫程序,就可以从MongoDB数据库里选取代理IP了,实测还是挺好用的。

    参考文献:
    [1]崔庆才.《Python 3网络爬虫开发实战》.人民邮电出版社,2018.04

    展开全文
  • 爬虫代理IP的使用+建立代理IP代理IP的使用建立代理IP池完整代码 代理IP的使用 先了解一下百度百科定义的IP 为什么要使用代理IP? 反爬(反网络爬虫) 示例: 测试网址 http://httpbin.org/get 浏览器先...

    爬虫代理IP的使用+建立代理IP池

    代理IP的使用

    • 先了解一下百度百科定义的IP
      ???

    • 为什么要使用代理IP?
      反爬(反网络爬虫)

    • 示例:
      测试网址

    http://httpbin.org/get

    • 用浏览器先访问测试网址下看看
      test

    • 再用我们写的代码简单请求一下网页看看

    import requests
    url='http://httpbin.org/get'
    
    html=requests.get(url=url).text
    print(html)
    """
    {
      "args": {},
      "headers": {
        "Accept": "*/*",
        "Accept-Encoding": "gzip, deflate",
        "Host": "httpbin.org",
        "User-Agent": "python-requests/2.23.0",
        "X-Amzn-Trace-Id": "Root=1-5ff704d4-3841771516040beb29f6066f"
      },
      "origin": "1.192.244.128",
      "url": "http://httpbin.org/get"
    }
    """
    

    疑惑???

    “User-Agent”: “python-requests/2.23.0”

    网站如何来判定是人类正常访问还是爬虫程序访问? —> 检查请求头!!!
    我们是不是需要发送请求时重构一下User-Agent???
    添加 headers参数!!!

    那就使用fake_useragent 模块
    让它伪造一个出来再试试

    import requests
    from fake_useragent import UserAgent
    url='http://httpbin.org/get'
    
    headers={'User-Agent':UserAgent().random}
    
    html=requests.get(url=url,headers=headers).text
    print(html)
    """
    {
      "args": {},
      "headers": {
        "Accept": "*/*",
        "Accept-Encoding": "gzip, deflate",
        "Host": "httpbin.org",
        "User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:17.0) Gecko/20100101 Firefox/17.0.6",
        "X-Amzn-Trace-Id": "Root=1-5ff7a4de-05f8d7bf49dfe85e3be31d79"
      },
      "origin": "1.192.244.128",
      "url": "http://httpbin.org/get"
    }
    """
    

    “User-Agent”: “Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:17.0) Gecko/20100101 Firefox/17.0.6”

    添加好headers的参数就可以了吗?
    这还不行吗!!!
    study

    一些网站不但检测 请求头
    一个IP 异常请求频繁(访问频率过多) 封禁?

    “origin”: “1.192.244.128”

    这是一项就是博主的IP, 我怎么确定这就是我的IP呢?
    查询一下:果真如此
    在这里插入图片描述
    找个免费的代理IP来包装下

    1. 定义
      代替你原来的IP地址去对接网络的IP地址
    2. 作用
      隐藏自身真实IP, 避免被封
    3. 获取代理IP网站
      快代理、全网代理、代理精灵、… …

    这次加上代理IP再去请求下

    import requests
    from fake_useragent import UserAgent
    url='http://httpbin.org/get'
    headers={'User-Agent':UserAgent().random}
    
    # 参数类型
    # proxies
    # proxies = {'协议': '协议://IP:端口号'}
    proxies = {
                'http': 'http://{}'.format('8.129.28.247:8888'),
                'https': 'https://{}'.format('8.129.28.247:8888'),
            }
    
    html=requests.get(url=url,headers=headers,proxies=proxies).text
    print(html)
    """
    {
      "args": {},
      "headers": {
        "Accept": "*/*",
        "Accept-Encoding": "gzip, deflate",
        "Host": "httpbin.org",
        "User-Agent": "Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/32.0.1667.0 Safari/537.36",
        "X-Amzn-Trace-Id": "Root=1-5ff7a71d-10b181340f8dc04f7514dfba"
      },
      "origin": "8.129.28.247",
      "url": "http://httpbin.org/get"
    }
    """
    

    “origin”: “8.129.28.247”

    这次和我们加入的IP一样, 而不是我们自己的IP直接去请求了
    但这一个够用吗?
    ???
    别着急往下看啦~~~

    建立代理IP

    构建一个IP
    每次让它随机提供一个来请求不就解决一个IP请求频繁而导致封掉了
    这样就达到我们想要的结果了

    • 定义一个测试函数
    import requests
    from fake_useragent import UserAgent
    
    test_url = 'http://httpbin.org/get'
    
    headers = {'User-Agent': UserAgent().random}
    
    #                      参数 IP 地址
    def test_proxy(proxy):
        '''测试代理IP是否可用'''
        proxies = {
            'http': 'http://{}'.format(proxy),
            'https': 'https://{}'.format(proxy),
        }
        # 参数类型
        # proxies
        # proxies = {'协议': '协议://IP:端口号'}
        # timeout 超时设置 网页响应时间3秒 超过时间会抛出异常
        try:
            resp = requests.get(url=test_url, proxies=proxies, headers=headers, timeout=3)
            
            # 查看状态码   
            if resp.status_code == 200:
                print(proxy, '\033[31m可用\033[0m')
                
            else:
                print(proxy, '不可用')
    
    
        except Exception as e:
            print(proxy, '不可用')
    

    get一下HTTP状态码

    完整代码

    • 本次涉及到xpath对此不了解的同学可以去了解博主之前的博客
    • 也可以去菜鸟教程自行了解一下
    • 本次以 快代理 提供的免费IP 获取为例
    # 建立属于自己的开放代理IP池
    import requests
    import random
    import time
    from lxml import etree
    from fake_useragent import UserAgent
    
    class IpPool:
        def __init__(self):
            # 测试ip是否可用url
            self.test_url = 'http://httpbin.org/get'
            # 获取IP的 目标url
            self.url = 'https://www.89ip.cn/index_{}.html'
    
            self.headers = {'User-Agent': UserAgent().random}
            # 存储可用ip
            self.file = open('ip_pool.txt', 'wb')
    
        def get_html(self, url):
            '''获取页面'''
            html = requests.get(url=url, headers=self.headers).text
    
            return html
    
        def get_proxy(self, url):
         	'''数据处理  获取ip 和端口''' 
            html = self.get_html(url=url)
            # print(html)
           
            elemt = etree.HTML(html)
            
            ips_list = elemt.xpath('//table/tbody/tr/td[1]/text()')
            ports_list = elemt.xpath('//table/tbody/tr/td[2]/text()')
    
            for ip, port in zip(ips_list, ports_list):
                # 拼接ip与port
                proxy = ip.strip() + ":" + port.strip()
                # print(proxy)
                
                # 175.44.109.195:9999
                self.test_proxy(proxy)
    
        def test_proxy(self, proxy):
            '''测试代理IP是否可用'''
            proxies = {
                'http': 'http://{}'.format(proxy),
                'https': 'https://{}'.format(proxy),
            }
            # 参数类型
            # proxies
            # proxies = {'协议': '协议://IP:端口号'}
            # timeout 超时设置 网页响应时间3秒 超过时间会抛出异常
            try:
                resp = requests.get(url=self.test_url, proxies=proxies, headers=self.headers, timeout=3)
               # 获取 状态码为200 
                if resp.status_code == 200:
                    print(proxy, '\033[31m可用\033[0m')
                    # 可以的IP 写入文本以便后续使用
                    self.file.write(proxy)
                    
                else:
                    print(proxy, '不可用')
    
            except Exception as e:
                print(proxy, '不可用')
    
        def crawl(self):
            '''执行函数'''
            # 快代理每页url 的区别
            # https://www.kuaidaili.com/free/inha/1/
            # https://www.kuaidaili.com/free/inha/2/
            # .......
    		# 提供的免费ip太多
            # 这里只获取前100页提供的免费代理IP测试
            for i in range(1, 101):
                # 拼接完整的url
                page_url = self.url.format(i)
                # 注意抓取控制频率
                time.sleep(random.randint(1, 4))
                self.get_proxy(url=page_url)
    
            # 执行完毕关闭文本
            self.file.close()
    
    
    if __name__ == '__main__':
        ip = IpPool()
        ip.crawl()
    

    测试完这里博主的脸可能比较黑吧, 竟没几个可以用的!!!
    由于提供的免费IP可用的机率很小
    想构建自己的IP池的小伙伴, 可以去获取其它代理, 提供的免费代理IP.

    这里给大家提供几个博主当时测试时可以使用的IP
    nice

    159.203.44.177:3128

    203.202.245.62:80

    8.210.88.234:3128

    89.187.177.106:80

    89.187.177.106:80

    96.113.165.182:3128

    IP的响应速度根据你机器所在的地理位置不同而有差异

    作者:淮南子.
    来源:CSDN
    版权声明:本文为博主原创文章,原创不易,请尊重原创转载请附上博文链接!
    在这里插入图片描述

    展开全文
  • Python搭建代理IP池(一)- 获取 IP

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

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

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

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

    代码地址https://github.com/Stevengz/Proxy_pool

    另外三篇
    Python搭建代理IP池(二)- 存储 IP
    Python搭建代理IP池(三)- 检测 IP
    Python搭建代理IP池(四)- 接口设置与整体调度


    本文介绍的则是构建代理 IP 池的第一步:获取 IP

    使用的库:requestspyquery

    几个能提供免费代理的代理服务网站(排名不分先后):

    厂商名称地址
    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

    代理服务网站 Crawler

    代理获取的相关代码,把从每个网站提取 IP 的方法都放到一起,然后运行时只要调用相关方法即可

    为了实现灵活,将获取代理的一个个方法统一定义一个规范,如统一定义以 crawl 开头,这样扩展的时候只需要添加 crawl 开头的方法即可

    在这里实现了几个示例,如抓取代理 66、西刺代理、云代理、快代理 四个免费代理网站,这些方法都定义成生成器,通过 yield 返回。首先将网页获取,然后用 PyQuery 解析,解析出 IP 加端口形式的代理再返回

    crawler.py

    import json
    import re
    from utils import get_page
    from pyquery import PyQuery as pq
    
    # 元类
    class ProxyMetaclass(type):
        def __new__(cls, name, bases, attrs):
            count = 0
            attrs['__CrawlFunc__'] = []
            for k, v in attrs.items():
                if 'crawl_' in k:
                    attrs['__CrawlFunc__'].append(k)
                    count += 1
            attrs['__CrawlFuncCount__'] = count
            return type.__new__(cls, name, bases, attrs)
    
    class Crawler(object, metaclass=ProxyMetaclass):
        def get_proxies(self, callback):
            proxies = []
            for proxy in eval("self.{}()".format(callback)):
                print('成功获取到代理', proxy)
                proxies.append(proxy)
            return proxies
    
        def crawl_daili66(self, page_count=4):
            start_url = 'http://www.66ip.cn/{}.html'
            urls = [start_url.format(page) for page in range(1, page_count + 1)]
            for url in urls:
                print('Crawling', url)
                html = get_page(url)
                if html:
                    doc = pq(html)
                    trs = doc('.containerbox table tr:gt(0)').items()
                    for tr in trs:
                        ip = tr.find('td:nth-child(1)').text()
                        port = tr.find('td:nth-child(2)').text()
                        yield ':'.join([ip, port])
    
        def crawl_xicidaili(self):
            for i in range(1, 3):
                start_url = 'http://www.xicidaili.com/nn/{}'.format(i)
                headers = {
                    'Accept':'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
                    'Host':'www.xicidaili.com',
                    'Referer':'http://www.xicidaili.com/nn/3',
                    'Upgrade-Insecure-Requests':'1',
                }
                html = get_page(start_url, options=headers)
                if html:
                    find_trs = re.compile('<tr class.*?>(.*?)</tr>', re.S)
                    trs = find_trs.findall(html)
                    for tr in trs:
                        find_ip = re.compile('<td>(\d+\.\d+\.\d+\.\d+)</td>') 
                        re_ip_address = find_ip.findall(tr)
                        find_port = re.compile('<td>(\d+)</td>')
                        re_port = find_port.findall(tr)
                        for address,port in zip(re_ip_address, re_port):
                            address_port = address+':'+port
                            yield address_port.replace(' ','')
    
        def crawl_ip3366(self):
            for i in range(1, 4):
                start_url = 'http://www.ip3366.net/?stype=1&page={}'.format(i)
                html = get_page(start_url)
                if html:
                    find_tr = re.compile('<tr>(.*?)</tr>', re.S)
                    trs = find_tr.findall(html)
                    for s in range(1, len(trs)):
                        find_ip = re.compile('<td>(\d+\.\d+\.\d+\.\d+)</td>')
                        re_ip_address = find_ip.findall(trs[s])
                        find_port = re.compile('<td>(\d+)</td>')
                        re_port = find_port.findall(trs[s])
                        for address,port in zip(re_ip_address, re_port):
                            address_port = address+':'+port
                            yield address_port.replace(' ','')
    
        def crawl_kuaidaili(self):
            for i in range(1, 4):
                start_url = 'http://www.kuaidaili.com/free/inha/{}/'.format(i)
                html = get_page(start_url)
                if html:
                    ip_address = re.compile('<td data-title="IP">(.*?)</td>') 
                    re_ip_address = ip_address.findall(html)
                    port = re.compile('<td data-title="PORT">(.*?)</td>')
                    re_port = port.findall(html)
                    for address,port in zip(re_ip_address, re_port):
                        address_port = address+':'+port
                        yield address_port.replace(' ','')
    

    定义了一个 ProxyMetaclassCrawl 类将它设置为元类,元类中实现了 new() 方法,遍历 attrs 变量即可获取类的所有方法信息,判断方法名前面是否是 crawl,是则将其加入到 CrawlFunc 属性中

    代理网站的添加非常灵活,不仅可以添加免费代理,也可以添加付费代理,一些付费代理的提取方式类似,也通过 Web 的形式获取再进行解析,解析方式可能更加简单,如解析纯文本或 Json,解析之后以同样的方式返回,可以自行扩展

    utils.py

    import requests
    from requests.exceptions import ConnectionError
    
    base_headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.120 Safari/537.36',
        'Accept-Encoding': 'gzip, deflate, sdch',
        'Accept-Language': 'en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7'
    }
    
    def get_page(url, options={}):
    
        headers = dict(base_headers, **options)
        print('正在抓取', url)
        try:
            response = requests.get(url, headers=headers)
            print('抓取成功', url, response.status_code)
            if response.status_code == 200:
                return response.text
        except ConnectionError:
            print('抓取失败', url)
            return None
    

    抓取网页内容的方法,访问链接成功后返回整个网页 HTML 内容,便于后续对网页具体内容的提取。封装成一个方法,让上面的 crawler 在抓取各个网站时调用


    进行抓取

    getter.py

    from crawler import Crawler
    from setting import *
    import sys
    
    class Getter():
        def __init__(self):
            self.crawler = Crawler()
        
        def run(self):
            print('获取器开始执行')
            for callback_label in range(self.crawler.__CrawlFuncCount__):
                callback = self.crawler.__CrawlFunc__[callback_label]
                # 获取代理
                all_ip = self.crawler.get_proxies(callback)
    
    if __name__ == '__main__':
        get = Getter()
        get.run()
    

    运行结果:
    在这里插入图片描述
    网站上的免费 IP 就被成功抓取下来了,至于能不能用,就有待验证了

    整个过程其实就是一个普通的爬虫,而且没什么反爬措施,能到用代理 IP 的地步,代码里面的访问、抓取部分的细节应该都看得懂

    展开全文
  • 国内最新免费HTTP代理IP

    千次阅读 2021-07-07 13:42:20
    110.86.177.154:9999 [未知代理ip] 中国福建省莆田市 电信免费HTTP 175.146.102.146:9999 [普匿代理ip] 中国辽宁省鞍山市 联通免费HTTP 112.123.40.232:9999 [高匿代理ip] 中国安徽省池州市 联通免费HTTP 114.238....
  • 如何建立爬虫代理ip

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

    热门讨论 2012-09-24 19:12:17
    本程序可以获取代理ip地址并加入了导出功能,获取完后右键点击列表项选择相关操作。由于程序由易语言编写,所以在运行时可能会报毒,请大家放心使用,程序内绝对没有木马病毒。
  • 付费代理ip的使用

    千次阅读 2019-09-03 14:54:43
    相对免费代理来说,付费代理的稳定性更高,故本篇只介绍下市面上主流代理IP运营商的产品分类和使用。。 一、付费代理分类 付费代理分为两类: 一类提供接口获取海量代理,按天或者按量收费; 一类搭建了代理隧道,...
  • 为大家提供19个代理IP网站,我用这个免费代理IP

    千次阅读 多人点赞 2021-06-24 15:05:54
    最近准备搭建一个属于自己的代理IP池,整理了目前市面上提供免费代理IP的网站(详情请见下表),所列站点均经过手动验证请放松使用。
  • 获取代理ip

    万次阅读 2018-11-06 10:42:31
    切换代理ip一直是我们在反反爬虫过程中常用的手段,但是目前各大ip代理网站的优质ip的价格都十分高昂,用于个人不太划算。好在有些网站提供免费的ip,经过测试,他们响应速度较为良好。如果我们将他们爬取下来并加以...
  • 如何构建一个自己的代理ip

    万次阅读 多人点赞 2019-02-21 18:09:19
    这种时候,我们就需要一个代理ip池。 什么是代理ip池? 通俗地比喻一下,它就是一个池子,里面装了很多代理ip。它有如下的行为特征: 1.池子里的ip是有生命周期的,它们将被定期验证,其中失效的将被从池子里面...
  • Python 免费代理ip的批量获取

    千次阅读 2018-07-29 09:28:08
    Python 免费代理ip的批量获取 简介 网络爬虫的世界,向来都是一场精彩的攻防战。现在许多网站的反爬虫机制在不断的完善,其中最令人头疼的,莫过于直接封锁你的ip。但是道高一尺魔高一丈,在爬取网页的时候,...
  • Java语言HttpClient使用代理IP

    千次阅读 2019-12-19 10:01:03
    在访问一个网站时,有时我们不想让对方获取到我们的真实IP,这种情况下,就可以使用代理IP进行访问。 1、maven依赖 <dependency> <groupId>org.apache.httpcomponents</groupId> <...
  • 代理ip最新识别方法以及代理ip有效性检测方法 一、代理ip常见的一些功能 1.突破自身ip访问限制,现在有许多的网站都对ip地址访问进行了限制,这时则可以通过代理ip来突破限制,让自己进入网站。 2.提高访问速度,...
  • 高匿代理ip获取工具v2.0.exe 高匿代理ip获取
  • 代理ip

    千次阅读 2016-12-08 18:03:05
    1、使用ip代理的原因 ...1)、由于ip代理池需要被多个爬虫使用,所以ip代理池应该作为一种服务来被使用(全局共享代理ip)。 2)、不同使用方的使用要求不一样,所以ip代理池应该根据使用方的需求提供最佳
  • 1. 代理ip设置 1.1 代理设置格式 1.proxies在你访问http时用http的设置,访问https时用https的设置,所以你的proxy需要同时包含http及https的配置,这样才能生效。 2.如果访问http网站时,可你的proxies={“https”:...
  • vps搭建代理ip服务

    千次阅读 2021-07-26 10:00:23
    本文记录centos7.6拨号搭建代理ip服务器的过程。 一、购买拨号服务器。 在服务器测试拨号是否正常用到下面两个命令 pppoe-start pppoe-stop 如果拨号不正常则需要配置 pppoe-setup 具体步骤自查。 二、部署 首先安装...
  • 获取代理IP地址

    万次阅读 2018-06-29 10:36:42
    很多时候,需要用到代理IP。比如在开发爬虫程序的时候,为了反爬,需要使用代理IP。 首先给出程序实现的功能,然后再来说明开发思路: 完整代码下载地址: https://github.com/yooongchun/ProxyIP 功能: 从...
  • Python爬虫方式抓取免费http代理IP

    千次阅读 2019-07-23 16:37:43
    我们新手在练手的时候,常常需要一些代理IP进行爬虫抓取,但是因为学习阶段,对IP质量要求不高,主要是弄懂原理,所以花钱购买爬虫代理IP就显得没必要(大款忽略),今天跟大家分享一下,如果使用爬虫抓取免费的代理...
  • 常见的国内最新代理ip有哪些

    千次阅读 2021-03-02 17:13:37
    市场上代理ip的种类很多,按照不同的方式,可以分为多种类型。其中包括HTTP(s)代理ip,socks5代理ip,动态代理ip,静态代理ip,独占ip池和共享ip池。很难确定哪个更好,因为每个人的业务场景不同,对代理ip的需求也...
  • 文章目录使用Python爬取xici代理的高匿代理ip使用Python爬取快代理的高匿代理ip 有时候需要做一些代理ip.常见的xici和快代理.下面是爬取他们的代码 使用requests进行爬取 使用Python爬取xici代理的高匿代理ip import...
  • 182.109.215.119:8080#HTTP中国-江西-宜春--电信高速代理ip 182.38.125.131:9999#HTTP中国-山东-威海--电信高速代理ip 121.233.226.129:9999#HTTP中国-江苏-扬州--电信高速代理ip 180.111.137.62:8888#HTTP中国-江苏...
  • 前言:常爬爬网站,总有些害怕突然返回一个不是200的状态码,不是网不好,就是被反爬了,不过大多数网站还是蛮“友好”的,但难免还是会被网站封了IP,于是乎想到了前辈们说的代理ip池,咱学习学习,自己也整一个,...
  • ip是上网需要唯一的身份地址,身份凭证,而代理ip就是我们上网过程中的一个中间平台,是由你的电脑先访问代理ip,之后再由代理ip访问你点开的页面,所以在这个页面的访问记录里留下的是就是代理ip的地址,而不是你的...
  • 500个HTTPS代理ip最新分享

    万次阅读 2021-02-20 13:36:11
    大部分人使用代理ip无非就是想要实现三个功能,首先是有需求要隐藏自己的真实ip的,另外就是希望自己上网速度会快一点,完善浏览体验的,最后还有一些对海外网站憧憬的,可以上一些无法浏览的网站等等,但是网站内含...
  • Python搭建代理IP池实现获取IP的方法

    千次阅读 2020-07-03 17:32:20
    而对于访问次数,就需要使用代理 IP 来帮忙了,使用多个代理 IP 轮换着去访问目标网址可以有效地解决问题。 目前网上有很多的代理服务网站提供代理服务,也提供一些免费的代理,但可用性较差,如果需求较高可以购买...
  • 目前市场上代理IP的提供商如雨后春笋般,一夜之间冒出了诸多。商家提供的产品和服务差不多,但是还是有各自的优缺点,品质嘛也是值得讨论的。对于越来越被应用的代理IP,咱们到底该怎么选?百度排名靠前的商家的可靠...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 390,874
精华内容 156,349
关键字:

代理ip