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))

weblist = []
while True:
    try:
        weblist.append(input())
    except:
        break
A, B, C, D, E, count_error, count_privit = 0, 0, 0, 0, 0, 0, 0
for web in weblist:
    ip_yanma = web.split('~')
    ip, yanma = ip_yanma[0], ip_yanma[1]
    ip_split, yanma_split = ip.split('.'), yanma.split('.')
    flag = 1
    if len(ip_split) == 4 and len(yanma_split) == 4:
        for code in ip_split[1:]:
            if code.isdigit():
                if int(code) not in range(256):
                    flag =0
                    break
            else:
                flag = 0
                break
        yanma_combine = ''
        for code in yanma_split:
            if int(code) not in range(256):
                flag = 0
                break
            else:
                yanma_combine += str(bin(int(code)))[2:]
        if yanma_combine[0] ==  '1' and yanma_combine[-1] != '1':
            yanma_count = yanma_combine.split('0')
            for _ in yanma_count[1:]:
                if _.isdigit():
                    flag = 0
                    break
        else:
            flag = 0
        if flag:
            if  int(ip_split[0]) in range(1,127):
                A += 1
            elif int(ip_split[0]) in range(128, 192):
                B += 1
            elif int(ip_split[0]) in range(192,224):
                C += 1
            elif int(ip_split[0]) in range(224,240):
                D += 1
            elif int(ip_split[0]) in range(240,256):
                E += 1
            elif int(ip_split[0]) not in [0,127]:
                count_error += 1
            
            if int(ip_split[0]) == 10:
                count_privit += 1
            elif int(ip_split[0]) == 172 and int(ip_split[1]) in range(16,32):
                count_privit += 1
            elif int(ip_split[0]) == 192 and int(ip_split[1]) == 168:
                count_privit += 1

        else:
            count_error += 1
    else:
        count_error += 1
outputlist = [A,B,C,D,E,count_error,count_privit]
print(' '.join(list(map(str,outputlist))))

import sys
IpClass={'A':0,'B':0,'C':0,'D':0,'E':0,"F":0}
FM,PI=0,0

def JudgmentMask(mark):
    try:
        StandMark = [0] * 32
        i = 0
        while i < 4:
            calulate = int(mark[i])
#           print(calulate)
            j = (i + 1) * 8 - 1
            while calulate != 0:
                StandMark[j] = calulate % 2
                j = j - 1
                calulate = calulate // 2
            i = i + 1
#       print(StandMark)
#       print(len(StandMark))
        stand = 0
        x=0
        y=0
        for i in StandMark:
            if i == 0:
                stand = 1
                x=x+1
            if i == 1:
                y=y+1
            if x==32:
                return 1
            if y==32:
                return 1
            if stand == 1:
                if i == 1:
#                   print("Mark is false!!!")
                    return 1
#       print("Mark is right~~~")
        return 0
    except:
#       print("Mark is false!!!")
        return 1


def JudgmentIp(ip):
    try:
        i=1
        while i<4:
            if not 0<=int(ip[i])<=255:
               break
            i=i+1
        if i!=4:
            return "F"
        if 1<=int(ip[0])<=126:
            return 'A'
        if 128<=int(ip[0])<=191:
            return 'B'
        if 192<=int(ip[0])<=223:
            return 'C'
        if 224<=int(ip[0])<=239:
            return 'D'
        if 240<=int(ip[0])<=255:
            return 'E'
    except:
        return "F"

def JudgmentPrivateIp(ip):
    try:
        if int(ip[0])==10:
            i=1
            while i<4:
                if not 0<=int(ip[i])<=255:
                    break
                i=i+1
            if i==4:
#               print('yes')
                return 1
            else:
                return 0
        if int(ip[0])==172:
            if 16<=int(ip[1])<=31:
                if 0<=int(ip[2])<=255:
                    if 0<=int(ip[3])<=255:
#                       print('yes')
                        return 1
        if int(ip[0])==192:
            if int(ip[1])==168:
                if 0 <= int(ip[2]) <= 255:
                    if 0 <= int(ip[3]) <= 255:
#                       print('yes')
                        return 1
        return 0
    except:
        return 0

for line in sys.stdin:
    scan = line.split("~")
    try:
        scan[1] = scan[1][0:-1:1]
    except:
        break
#   print(scan)
    ip= scan[0].split('.')
    mark = scan[1].split('.')
#   print(ip)
#   print(mark)
    if ip[0]=='127':
        continue
    if ip[0]=='0':
        continue
    m=JudgmentMask(mark)
    FM=FM+m
    if m==1:
        continue
    stand=JudgmentIp(ip)
#   print(stand)
    IpClass[stand]=IpClass[stand]+1
    PI=PI+JudgmentPrivateIp(ip)

IpClass["F"]=IpClass["F"]+FM
for i in IpClass:
    print(IpClass[i],end=' ')
print(PI)

🤗🤗🤗

定义了三个函数分别判断：

1. 错误ip
2. 掩码规范
3. 私有地址

对于处理掩码规范，借鉴了这位小哥哥 的代码，处理的很巧妙👍

import sys
from collections import namedtuple


IP = namedtuple('IP', 'ip mask')
ips = []
result = {key: 0 for key in ['A', 'B', 'C', 'D', 'E', 'w_ip_ma', 'pri_ip']}
for line in sys.stdin:
    a = line.strip().split('~')
    ips.append(IP(a[0], a[1]))

def wrong_ip_mask(adrs:'IP'):
    ips = adrs.ip.split('.')
    mask = adrs.mask.split('.')
    if False in [ip_ma.isnumeric()  for ip_ma in ips + mask]:
        return True
    elif not mask_rule(mask):
        return True
    else:
        return False

def mask_rule(mask_list):
    mask_to_bin = [bin(int(m))[2:].rjust(8,'0') for m in mask_list]#掐掉二进制冗余头部，并补全8位
    mask_bin = ''.join(mask_to_bin)
    s0 = mask_bin.find('0')
    s1 = mask_bin.rfind('1')
    if s0 != -1 and s1 != -1 and s0 - s1 == 1:
        return True
    return False

def is_pri_ip(adrs:'IP'):
    ip_list = adrs.ip.split('.')
    if ip_list[0] == '10': return True
    elif ip_list[0] == '172' and int(ip_list[1]) in range(16, 31 + 1): return True
    elif ip_list[0] == '192' and ip_list[1] == '168'  :return True
    else: return False


for adrs in ips:
    first_ad = int(adrs.ip.split('.')[0])
    if first_ad == 0 or first_ad == 127: continue
    if wrong_ip_mask(adrs): 
        result['w_ip_ma'] += 1
        continue
    if is_pri_ip(adrs): result['pri_ip'] += 1
    if first_ad in range(1, 126 +1): result['A'] += 1
    elif first_ad in range(128, 191 + 1): result['B'] += 1
    elif first_ad in range(192, 223 + 1): result['C'] += 1
    elif first_ad in range(224, 239 + 1): result['D'] += 1
    elif first_ad in range(240, 255 + 1): result['E'] += 1



print(*result.values(), sep=' ')