利用全局变量和类方法、静态方法实现获取动态ip代理

Python

发布日期: 2019-07-22

import datetime
from dateutil.parser import parse

class Change_ip(object):
    
    # 为了避免刚开始运行就出现小于5分钟的情况
    # 填加此变量进行判断
    v_num = 0
    
    def __init__(self):
        pass
        # 此处可以写自己的数据库链接操作
    
    @classmethod
    def get_database_ips(cls):
        global old_Time
        # 获取所有ip返回列表
        result = {"123.123.10.101":"8000","111.110.08.90":"808"}
        ips = []
        for k, v in result.items():
            ip = k + ":" + v
            ips.append(ip)
        list_ip = ips
        old_Time = datetime.datetime.now()
        # print('当前时间:', dongtai_time)
        print('获取ip成功')
        return list_ip

    @staticmethod
    def get_ip(database_time):
        '''
        获取ip代理保存为old_list_ip
        返回一个 ip代理的列表，需要使用的地方
        需要进行随机返回一个的处理
        :param database_time:
        :return:
        '''
        global old_list_ip
        global old_Time
        # 如果数据库时间为空
        # 则获取一次 返回列表
        if database_time == '' and Change_ip.v_num <= 0:
            old_Time = datetime.datetime.now()
            # 执行获取IP的函数
            old_list_ip = Change_ip.get_database_ips()
            Change_ip.v_num += 1
            # return random.choice(old_list_ip)
            return old_list_ip
        # 若不为空,则判断时间是否大于5分钟
        # 若大于则更新一次数据库
        # 不大于则返回原先的代理
        else:
            # 若程序刚开始运行,出现小于5分钟的情况
            # 则获取一次ip，并将值转换+1,下次就不会进入到次入口
            if Change_ip.v_num == 0:
                print('初次运行小于10分钟的情况')
                old_list_ip = Change_ip.get_database_ips()
                Change_ip.v_num += 1
            # 这个是获取全局变量中动态时间的值
            # 将其转换为字符串格式与当前时间进行比较
            old_time = datetime.datetime.strftime(old_Time, '%Y-%m-%d %H:%M:%S')
            current_time = datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d %H:%M:%S')
            # 让2个字符串进行时间互减,得到相差的秒数,/60得到分钟数
            num = abs(((parse(current_time) - parse(old_time)).total_seconds()))
            # print('num:',num)
            if num / 60 >= 1:
                #大于1分钟获取一次 为了进行测试
                old_list_ip = Change_ip.get_database_ips()
                # return random.choice(old_list_ip)
                return old_list_ip
            else:
                # print('小于10分钟,忽略','TIme:', old_time)
                # 小于10分钟则保持不变
                # return random.choice(old_list_ip)
                return old_list_ip

    # 获取所有ip返回列表
    def get_ip_2(self):
        # 获取ip
        # 测试用直接返回一个字典
        return {"123.123.10.101":"8000","111.110.08.90":"808"}
if __name__ == "__main__":
    c = Change_ip()
    ip = c.get_ip('2019-07-20 23:39:10')
    print(ip)

初次运行小于10分钟的情况
获取ip成功
['123.123.10.101:8000', '111.110.08.90:808']

class Down(object):
    proxy_list = []
    def parse_html(self, time_str):
        self.__class__.proxy_list = Change_ip().get_ip(time_str)
        print('proxy_list', self.__class__.proxy_list )

if __name__ == "__main__":
    d = Down()
    # 模拟三次
    for i in ["2019-07-21 00:01:10","2019-07-21 00:01:33","2019-07-21 00:09:06"]:
        d.parse_html(i)
        import time
        time.sleep(31)

proxy_list ['123.123.10.101:8000', '111.110.08.90:808']
proxy_list ['123.123.10.101:8000', '111.110.08.90:808']
获取ip成功
proxy_list ['123.123.10.101:8000', '111.110.08.90:808']

只有在时间达到了超过1分钟的时候，他才会重新获取一次，并且赋值给新的列表
主要原理是每次循环用时间值和当前时间做对比，前提必须要给时间指定全局变量，
这样才会在每次获取一次新ip时，将时间更新！
其实就是全局变量+静态方法，类方法的应用静态方法可以在调用时免去类的一些
初始化的传参，从而减少了复杂度