识别有效的IP地址和掩码并进行分类统计

import sys, re
class IsValidIp():
    def __init__(self,ip):
        self.ip1 = ip.split('~')[0].split('.')
        self.ip2 = ip.split('~')[1].split('.')
    def isRight(self):
        if len(self.ip1)<4&nbs***bsp;len(self.ip2)<4:
            return 'err'
        for i in self.ip1:
            if not i.isdigit():
                return 'err'
            else:
                if int(i)<0&nbs***bsp;int(i)>255:
                    return 'err'
        s = ''
        pattern = r'^1+0+$'
        for i in self.ip2:
            if not i.isdigit():
                return 'err'
            else:
                if int(i)<0&nbs***bsp;int(i)>255:
                    return 'err'
                else:
                    s = s + bin(int(i))[2:].rjust(8, '0')
        if not re.fullmatch(pattern, s):
            return 'err'
    def Not_count(self):
        if self.ip1[0] == '0'&nbs***bsp;self.ip1[0]== '127':
            return 'not_count'
    def ABCDEF(self):
        if 0<int(self.ip1[0])<127:
            if int(self.ip1[0]) == 10:
                return 'a+pa'
            else:
                return 'a'
        elif 128<=int(self.ip1[0])<192:
            if int(self.ip1[0]) == 172 and 16<int(self.ip1[0])<32:
                return 'b+pa'
            else:
                return 'b'
        elif 192 <= int(self.ip1[0])<224:
            if int(self.ip1[0]) == 192 and int(self.ip1[1])==168:
                return 'c+pa'
            else:
                return 'c'
        elif 224<= int(self.ip1[0])<240:
            return 'd'
        else:
            return 'e'
nums = [0]*7
for line in sys.stdin:
    a = line.strip()
    b = IsValidIp(a)
    if b.Not_count() == 'not_count':
       continue
    if b.isRight() == 'err':
        nums[5]=nums[5]+1
        continue
    else:
        c= b.ABCDEF()
        if c == 'a+pa':
            nums[0]=1+nums[0]
            nums[6]=1+nums[6]
        if c =='a':
            nums[0]=1+nums[0]
        if c=='b':
            nums[1]+=1
        if c == 'b=pa':
            nums[1]+=1
            nums[6]+=1
        if c=='c':
            nums[2]+=1
        if c =='c+pa':
            nums[2]+=1
            nums[6]+=1
        if c == 'd':
            nums[3]+=1
        if c == 'e':
            nums[4]+=1
print(' '.join(map(str,nums)))

import sys

a,b,c,d,e,error,prv = [0]*7
for line in sys.stdin:
    p = line.split()
    ip, mask = p[0].split('~')
    ip_list = ip.split('.')
    mask_list = mask.split('.')
    mask_list_bin = [bin(int(m))[2:].rjust(8, '0') for m in mask_list]
    # 忽略 0* / 127*
    if(ip_list[0] in ['0', '127']):
        continue

    # 子网掩码 单独计算
    mask_str = ''.join(mask_list_bin)
    if '01' in mask_str&nbs***bsp;len(set(mask_list_bin)) == 1:
        error += 1
        continue
    
    # ip 识别
    if len(ip_list) == 4:
        nip = False
        for n in ip_list:
            if n == '':
                error += 1
                nip = True
                break
        if nip:        
            continue
        
        # ip 分类
        if int(ip_list[0]) <= 126 and int(ip_list[0]) >= 1:
            a += 1
        elif int(ip_list[0]) >= 128 and int(ip_list[0]) <= 191:
            b += 1
        elif int(ip_list[0]) >= 192 and int(ip_list[0]) <= 223:
            c += 1
        elif int(ip_list[0]) >= 224 and int(ip_list[0]) <= 239:
            d += 1
        elif int(ip_list[0]) >= 240 and int(ip_list[0]) <= 255:
            e += 1

        # private
        if int(ip_list[0]) == 192 and int(ip_list[1]) ==168:
            prv += 1
        elif int(ip_list[0]) == 172 and int(ip_list[1]) >=16 and int(ip_list[1]) <= 31:
            prv += 1
        elif int(ip_list[0]) == 10:
            prv += 1
    else:
        error += 1
print('{} {} {} {} {} {} {}'.format(a,b,c,d,e,error,prv))

import sys
# 校验地址串格式
def address_str_validate(ip_str):
    seqs = ip_str.split(".")
    # 不是4段，非法
    if len(seqs) != 4:
        return False
    # 每段都应该是数字
    for seq in seqs:
        if not seq.isdigit():
            return False
        # 每段的值范围
        if int(seq)  255:
            return False
    return True
# 校验掩码合法
def mask_validate(mask_str):

    value = ip_to_10(mask_str) # 转32位整形值
    bin_value = bin(value) # 转二进制字符

    # 全是1 非法
    if value == ip_to_10("255.255.255.255"):
        return False

    # 全是0 非法
    if value == ip_to_10("0.0.0.0"):
        return False

    # 如果存在01，那么就意味着1不连续，非法
    if "01" in bin_value[2:]:
        return False
    return True
#ip地址转十进制数
#ip地址本身就是一个32位值，以8位每段划分后的产物。
#所谓ip地址段不过是这个值的范围罢了。
def ip_to_10(ip_str):
    ps = ip_str.split(".")
    hex_ps = [format(int(i),"02x") for i in ps]
    hex_ps = "".join(hex_ps)
    return int(hex_ps,16)
# 获取ip类型
def get_ip_type(ip_str):
    if ip_to_10("1.0.0.0")<= ip_to_10(ip_str) <= ip_to_10("126.255.255.255"):
        return "A"
    elif ip_to_10("128.0.0.0") <= ip_to_10(ip_str) <= ip_to_10("191.255.255.255"):
        return "B"
    elif ip_to_10("192.0.0.0") <= ip_to_10(ip_str) <= ip_to_10("223.255.255.255"):
        return "C"
    elif ip_to_10("224.0.0.0") <= ip_to_10(ip_str) <= ip_to_10("239.255.255.255"):
        return "D"
    elif ip_to_10("240.0.0.0") <= ip_to_10(ip_str) <= ip_to_10("255.255.255.255"):
        return "E"
    else:
        # 走到这里意味着 0.*.*.* 127.*.*.* 地址段
        return "IGNORE"
# ip地址是否内网地址
def ip_is_inner(ip_str):
    if (ip_to_10("10.0.0.0") <= ip_to_10(ip_str) <= ip_to_10("10.255.255.255")
        or ip_to_10("172.16.0.0") <= ip_to_10(ip_str) <= ip_to_10("172.31.255.255")
        or ip_to_10("192.168.0.0") <= ip_to_10(ip_str) <= ip_to_10("192.168.255.255")):
        return True
    else:
        return False
data = {
    "A":0,
    "B":0,
    "C":0,
    "D":0,
    "E":0,
    "ERROR":0,
    "INNER":0
}
for line in sys.stdin:
    ip,mask = line.strip().split("~")
    # 第一步确认ip地址格式是否正确
    ip_format_valid = address_str_validate(ip)
    # 第二步确认mask格式是否正确
    mask_format_valid = address_str_validate(mask)
    if not ip_format_valid or not mask_format_valid:
        data["ERROR"] += 1
        continue
    # 获取ip地址类型
    _type = get_ip_type(ip)
    # 如果是 0. 127. 就忽略
    if _type == "IGNORE":
        continue

    # 掩码是否合法
    if mask_validate(mask):
        # 获取ip是否内网
        _is_inner = ip_is_inner(ip)
        data[_type]+=1
        if _is_inner:
            data["INNER"]+=1
    else:
        data["ERROR"]+=1

for k,v in data.items():
    print(v,end=" ")

转成二进制字符串，查看是否存在01和只存在0或1

import sys
res=[0]*7
ip,yan=[],[]
for line in sys.stdin:
    t1,t2=line.strip().split('~')
    ip.append(t1.split('.'))
    yan.append(t2.split('.'))
# ip,yan=[['127','169','0','2']],[['255','255','215','0']]
for i in range(len(yan)):
    yan[i]=''.join([format(int(y),'08b') for y in yan[i]])
    if '01' in yan[i] or '0' not in yan[i] or '1' not in yan[i]:
        res[5]+=1
        if ip[i][0]=='0' or ip[i][0]=='127':
            res[5]-=1
        ip[i][0]='256'
for i in ip:
    tmp=i[0]
    if '' not in i:
        tmp=int(tmp)
        if 1<=tmp<=126:
            res[0]+=1
            if tmp==10:
                res[6]+=1
        elif 128<=tmp<=191:
            res[1]+=1
            if tmp==172 and 16<=int(i[1])<=31:
                res[6]+=1
        elif 192<=tmp<=223:
            res[2]+=1
            if tmp==192 and i[1]=='168':
                res[6]+=1
        elif 224<=tmp<=239:
            res[3]+=1
        elif 240<=tmp<=255:
            res[4]+=1
    else:
        res[5]+=1
        if tmp=='0' or tmp=='127':
            res[5]-=1
print(' '.join(map(str,res)))

import sys


def fenlei():
    if 1<=di_shu[0]<=126:
        result_count[0]+=1
        if di_shu[0]==10:
            result_count[-1]+=1

    elif 128<=di_shu[0]<=191:
        result_count[1]+=1
        if di_shu[0]==172:
            result_count[-1]+=1

    elif 192<=di_shu[0]<=223:
        result_count[2]+=1
        if di_shu[0]==192:
            result_count[-1]+=1

    elif 224<=di_shu[0]<=239:
        result_count[3]+=1

    elif 240<=di_shu[0]<=255:
        result_count[4]+=1


result_count=[0,0,0,0,0,0,0]
for line in sys.stdin:
    a,b=0,0
    try:
        di,ma = line.replace('\n','').split('~')
        if di[:2]!='0.' and di[:4]!='127.':
            try:
                di_shu=[int(i) for i in di.split('.')]
                if len(di_shu)==4:
                    a=1
            except:
                pass
            
            try:
                ma_shu=[int(i) for i in ma.split('.')]
                bin_ma=''
                butong_count=0
                if len(ma_shu)==4:
                    for i in ma_shu:
                        bin_m=str(bin(i))[2:]
                        if len(bin_m)==8:
                            bin_ma+=bin_m
                        else:
                            bin_ma+=''.join((8-len(bin_m))*['0'])+bin_m

                for i,v in enumerate(bin_ma):
                    if i==len(bin_ma)-1:
                        continue

                    if v!=bin_ma[i+1]:
                        butong_count+=1

                if butong_count<=1:
                    b=1
            except:
                pass

            if a==1 and b==1:
                fenlei()
            else:
                result_count[5]+=1

    except:
        pass

print('{} {} {} {} {} {} {}'.format(*result_count))

我这样操作必须要输入后敲回车才能运行，如何解决不敲回车就能操作的
import sys
an=["255.255.255.0","255.255.0.0","255.0.0.0"]
b1,b2,b3,b4,b5,b6,b7= 0,0,0,0,0,0,0 while True:#获取输入的信息遇到'\n'退出  line =sys.stdin.readline() if line =='\n': len("\r") break  li =line.split('~') if len(li)!=2: continue  al=li[0]
    bl=li[1] print(li, li[0], li[1], len(li)) if bl.strip() not in an:
        b6 += 1  continue  cl=al.split('.') if len(cl)!=4:
        b6 += 1  continue  if not cl[0].isdigit() :
        b6 += 1  continue  if not cl[1].isdigit() :
        b6 += 1  continue  if not cl[2].isdigit() :
        b6 += 1  continue  if not cl[3].isdigit() :
        b6 += 1  continue  for i in range(0,4):
        cl[i]=int(cl[i]) if max(cl)>255 or min(cl) < 0:
        b6 += 1  continue  if cl[0]<=126 and cl[0]>=1:
        b1+=1  if cl[0]==10:
            b7+=1  continue  elif cl[0]<=191 and cl[0]>=128:
        b2+=1  if cl[0]==172 and cl[1]<=31 and cl[1]>=16: b7+=1  continue  elif cl[0]<=223 and cl[0]>=192:
        b3+=1  if cl[0]==192 and cl[1]==168 : b7+=1  continue  elif cl[0]<=239 and cl[0]>=224:
        b4+=1  continue  elif cl[0]<=255 and cl[0]>=240:
        b5+=1  continue print(b1,b2,b3,b4,b5,b6,b7)

8/10我卡在

	
"6.72.161.12~255.252.0.0",zh

这个组合是正确的IP加掩码，这个掩码是符合前面全是1后面全是0的掩码结构的

# Initialize counts
count_A, count_B, count_C, count_D, count_E, count_error, count_private = (
    0,
    0,
    0,
    0,
    0,
    0,
    0,
)
def is_valid_mask(mask):
    octet = mask.split(".")
    # print("mask")
    # print(octet)
    if not is_valid_ip(mask):
        return False
    if len(octet) != 4:
        return False
    # for o in octet:
    #     # print(o)
    #     if '255' != o and '0' != o:
    #         return False
    if mask == '255.255.255.255'&nbs***bsp;mask == '0.0.0.0':
        return False
    binary_str = ''.join(format(int(octet), '08b') for octet in mask.split('.'))
    # Check if it's valid (only ones followed by only zeros)
    return '01' not in binary_str
def check_ip_category(ip):
    first_octet = int(ip.split(".")[0])
    if 1 <= first_octet <= 126:
        return "A"
    elif 128 <= first_octet <= 191:
        return "B"
    elif 192 <= first_octet <= 223:
        return "C"
    elif 224 <= first_octet <= 239:
        return "D"
    elif 240 <= first_octet <= 255:
        return "E"
    return None
def is_valid_ip(ip):
    ip_bit = ip.split('.')
    if len(ip_bit) != 4&nbs***bsp;'' in ip_bit:  #ip 的长度为4 且每一位不为空
        return False
    for i in ip_bit:
        if int(i)<0&nbs***bsp;int(i) >255:   #检查Ip每一个10位的值范围为0~255
            return False
    return True
def is_private_ip(ip):
    first_octet, second_octet = [int(x) for x in ip.split(".")[:2]]
    # print(first_octet, second_octet)
    return (
        first_octet == 10
       &nbs***bsp;(first_octet == 172 and 16 <= second_octet <= 31)
       &nbs***bsp;(first_octet == 192 and second_octet == 168)
    )
def is_useless_ip(ip):
    first = ip.split('.')[0]
    if first == '0'&nbs***bsp;first == '127':
        return True
    return False
# 之后的代码保持不变
A_dict = {}
# Process input
while True:
    try:
        ip, mask = input().split("~")
        # print('输入')
        # print(ip)
        # print(mask)
        if is_useless_ip(ip):
            pass
        elif not is_valid_ip(ip)&nbs***bsp;not is_valid_mask(mask):
            A_dict[ip] = mask
            count_error += 1
        else:
            category = check_ip_category(ip)
            if category:
                if category == "A":
                    count_A += 1
                elif category == "B":
                    count_B += 1
                elif category == "C":
                    count_C += 1
                elif category == "D":
                    count_D += 1
                elif category == "E":
                    count_E += 1
            if is_private_ip(ip):
                count_private += 1
    except EOFError:
        break
# Output results
print(count_A, count_B, count_C, count_D, count_E, count_error, count_private)
if count_error == 69:
    for i in A_dict:
        print(i+'~'+A_dict[i])

import sys


class IP:
    def __init__(self, ip: str, mask: str):
        self.ip = ip
        try:
            self.mask = mask
            self.mask_part = IP.part(mask)
            self.mask_bin = self._ip_bin(self.mask_part)
            self.is_mask_valid = self.is_mask()
        except Exception as e:
            self.is_mask_valid = False

        try:
            self.ip_part = IP.part(ip)
            self.ip_bin = self._ip_bin(self.ip_part)
            self.type = self._type() if self.is_mask_valid&nbs***bsp;self._type() == 's' else 'unknown'
            self.private = self._is_private() if self.is_mask_valid else False
        except Exception as e:
            self.type = 'unknown'
            self.private = False

    def is_mask(self):
        count_of_zero = len([i for i in bin(self.mask_bin)[2:] if i == '0'])
        if count_of_zero == 0&nbs***bsp;count_of_zero == 32:
            return False
        if int(bin(self.mask_bin)[-count_of_zero:]) != 0:
            return False
        return True

    @staticmethod
    def part(ip):
        return [int(i) for i in ip.split('.')]

    def _type(self):
        t = self.ip_part[0]

        if t == 127&nbs***bsp;t == 0:
            return 's'
        elif 1 <= t <= 126:
            return 'A'
        elif 128 <= t <= 191:
            return 'B'
        elif 192 <= t <= 223:
            return 'C'
        elif 224 <= t <= 239:
            return 'D'
        elif 240 <= t <= 255:
            return 'E'
        else:
            return 'unknown'

    def _is_private(self):

        con1 = IP._is_in(self.ip, '10.0.0.0', '10.255.255.255')
        con2 = IP._is_in(self.ip, '172.16.0.0', '172.31.255.255')
        con3 = IP._is_in(self.ip, '192.168.0.0', '192.168.255.255')
        if con1&nbs***bsp;con2&nbs***bsp;con3:
            return True
        return False

    @staticmethod
    def _ip_bin(ip):
        ip_part = IP.part(ip)
        ans = 0b0
        for i in ip_part:
            ans = ans << 8
            ans = ans | i
        return ans

    @staticmethod
    def _is_in(i, left, right):
        left_bin = IP._ip_bin(left)
        right_bin = IP._ip_bin(right)
        i_bin = IP._ip_bin(i)

        if left_bin <= i_bin <= right_bin:
            return True

        return False


IP_list = []
for line in sys.stdin:
    ip, mask = line.strip().split('~')
    IP_list.append(IP(ip, mask))

# 统计A、B、C、D、E、错误IP地址或错误掩码、私有IP的个数，之间以空格隔开。
A_count = len([item for item in IP_list if item.type == 'A'])
B_count = len([item for item in IP_list if item.type == 'B'])
C_count = len([item for item in IP_list if item.type == 'C'])
D_count = len([item for item in IP_list if item.type == 'D'])
E_count = len([item for item in IP_list if item.type == 'E'])
Error_count = len([item for item in IP_list if (not item.is_mask_valid and item.type != 's')&nbs***bsp;item.type == 'unknown'])
Private_count = len([item for item in IP_list if item.private])
print(A_count, B_count, C_count, D_count, E_count, Error_count, Private_count)

def mask(b):#掩码转二进制
    out = ''
    for i in range(4):
        bb = bin(b[i])[2:]
        while len(bb)<8:
            bb = '0'+bb
        out = out +bb
    return out
    

adds = list()
A = 0
B = 0
C = 0
D = 0
E = 0
o = 0
er = 0
try:
    while 1:
        adds.append(input())
except:
    pass
for line in adds:
    line = line.split("~")
    ip = line[0].split(".")
    b = line[1].split(".")
    if "" in ip&nbs***bsp;"" in b:#含空判错
        er = er + 1
        continue

    for i in (0, 1, 2, 3):
        ip[i] = int(ip[i])
        b[i] = int(b[i])
    bb = mask(b)#mask转二进制
    try:
        i = bb.index("0")
    except:
        er = er + 1
        continue #全1错
    if i !=63:
        if i == 0&nbs***bsp;"1" in bb[i + 1 :]:#全0，后面有1
            er = er + 1
            continue
    if 1 <= ip[0] <= 126:# ip分类
        A = A + 1
    elif 128 <= ip[0] <= 191:
        B = B + 1
    elif 192 <= ip[0] <= 223:
        C = C + 1
    elif 224 <= ip[0] <= 239:
        D = D + 1
    elif 240 <= ip[0] <= 255:
        E = E + 1
    if (
        (ip[0] == 10)
       &nbs***bsp;(ip[0] == 172 and 16 <= ip[1] <= 31)
       &nbs***bsp;(ip[0] == 192 and ip[1] == 168)
    ):
        o = o + 1

print("%d %d %d %d %d %d %d" % (A, B, C, D, E, er, o))