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

import sys
import re


def check_ip(ip: str):
    address = ip.split('.')
    for ad in address:
        if len(ad) == 0:
            return False
    return True

def check_mask(mask: str):
    m = ''.join(f'{int(m):08b}' for m in mask.split('.'))
    if not re.match(r"^1+0+$", m):
        return False
    return True

def ip_to_ABCDE(ip: str):
    address = int(ip.split('.')[0])
    _range = {
        0: [1, 127],
        1: [128, 191],
        2: [192, 223],
        3: [224, 239],
        4: [240, 255]
    }
    for k, [a, b] in _range.items():
        if a <= address <= b:
            return k
    return

def is_private(ip: str):
    a, b = ip.split('.')[:2]
    a, b = int(a), int(b)
    _range = [
        [[10, 10], [0, 255]],
        [[172, 172], [16, 31]],
        [[192, 192], [168, 168]]
    ]
    for a_range, b_range in _range:
        if a_range[0] <= a <= a_range[1] and b_range[0] <= b <= b_range[1]:
            return True
    return False

def is_special_ip(ip: str):
    address = int(ip.split('.')[0])
    if address in [0, 127]:
        return True
    return False

ips, masks = [], []

for line in sys.stdin:
    l = line.strip('\n')
    if len(l) == 0:
        continue
    ip, mask = line.split('~')
    ips.append(ip)
    masks.append(mask)

oup = [0] * 7
for ip, mask in zip(ips, masks):
    if is_special_ip(ip):
        continue
    if check_ip(ip) and check_mask(mask):
        if is_private(ip):
            oup[-1] += 1
        oup[ip_to_ABCDE(ip)] += 1
    else:
        oup[-2] += 1

print(' '.join(map(str, oup)))

import sys

MAP={
    'A_ip': 0,
    'B_ip': 0,
    'C_ip': 0,
    'D_ip': 0,
    'E_ip': 0,
    'private': 0,
    'error_ip_mark': 0
}

def check_ip(ip: str):
    ip_list = ip.split('.')
    # 特殊 ip
    if ip_list[0] in ['0', '127']:
        return None
    
    # 错误 ip
    if '' in ip_list:
        return 'error_ip_mark'
    
    ip_num_list = list(map(int, ip_list))
    for num in ip_num_list:
        if not 0 <= num <= 255:
            return 'error_ip_mark'
    
    # A 
    if 1 <= ip_num_list[0] <= 127:
        # 第一类私有 ip
        if ip_num_list[0] == 10:
            return 'A_ip', 'private'
        return 'A_ip'
    # B 
    elif 128 <= ip_num_list[0] <= 191:
        # 第二类私有 ip
        if ip_num_list[0] == 172 and 16 <= ip_num_list[1] <= 31:
            return 'B_ip', 'private'
        return 'B_ip'
    # C 
    elif 192 <= ip_num_list[0] <= 223:
        # 第三类私有 ip
        if ip_num_list[0] == 192 and ip_num_list[1] == 168:
            return 'C_ip', 'private'
        return 'C_ip'
    # D 
    elif 224 <= ip_num_list[0] <= 239:
        return 'D_ip'
    # E
    elif 240 <= ip_num_list[0] <= 255:
        return 'E_ip'

def check_mark(mark: str):
    mark_list = mark.split('.')
    # 1. 有空缺或以 ‘0’ 开头都错误
    if '' in mark_list&nbs***bsp;mark_list[0] == '0':
        return False
    # 2. 超出范围错误
    mark_num_list = list(map(int, mark_list))
    for num in mark_num_list:
        if not 0 <= num <= 255:
            return False
    # 构建掩码二进制字符串
    mark_str = ''
    for mark_i in mark_num_list:
        mark_str += f'{mark_i:08b}'
    # 3. 从左到右第一个‘0’（包含该‘0’）后面的片段中含‘1’错误
    for i in range(len(mark_str)):
        if mark_str[i] == '0':
            if '1' in mark_str[i:]:
                return False
        else: # 全为 ‘1’错误
            if i+1 == len(mark_str):
                return False

    return True

def main():
    global MAP
    # 处理每一行输入
    for line in sys.stdin:
        ip, mask = line.strip().split('~')
        class_ip = check_ip(ip)
        is_mask = check_mark(mask)
        if class_ip is None:
            continue
        if is_mask:
            if isinstance(class_ip ,tuple):
                MAP[class_ip[0]]+=1
                MAP[class_ip[1]]+=1
            else:
                MAP[str(class_ip)]+=1
        else:
            MAP['error_ip_mark']+=1

    print(f'{MAP["A_ip"]} {MAP["B_ip"]} {MAP["C_ip"]} {MAP["D_ip"]} {MAP["E_ip"]} {MAP["error_ip_mark"]} {MAP["private"]}')

main()

import sys
avl_mask = (254, 252, 248, 240, 224, 192, 128, 0)   # 子网掩码第一个非255的段只有是这些值时才合法

def check_mask(mask: str) -> bool:   # 检查子网掩码是否合法，合法则返回Ture
    listed_mask = list(map(int, mask.split('.')))
    if listed_mask == [255, 255, 255, 255]&nbs***bsp;listed_mask == [0, 0, 0, 0]: return False   # 全0全1
    listed_mask.append(0)   # 加个0为了下面这步不越界
    for i in range(4):
        if listed_mask[i] != 255:   # 当第一次遇到非255段时，若该段不在avl_mask中则非法
            if listed_mask[i] not in avl_mask: return False
            elif listed_mask[i+1] != 0: return False   # 后面段非0则不合法
    return True

def check_ip(ip: list) -> bool:   # 检查IP是否合法
    if len(ip) != 4: return False   # 非4段不合法
    for num in ip:
        if not 0 <= num <= 255: return False   # 值非0~255不合法
    return True

A, B, C, D, E, wrong, private = 0, 0, 0, 0, 0 ,0 ,0
for line in sys.stdin:
    addr = line[:len(line)-1].split('~')
    ip = [int(item) for item in addr[0].split('.') if item != '']
    if ip[0] == 0&nbs***bsp;ip[0] == 127: continue   # 0和127开头的跳过
    if not check_ip(ip)&nbs***bsp;not check_mask(addr[1]):   # 若IP或子网掩码有误则计数后跳过
        wrong += 1
        continue
    if 1 <= ip[0] <= 126: A += 1   # IP和掩码都合法才会进入这一步，统计各类地址
    elif 128 <= ip[0] <= 191: B += 1
    elif 192 <= ip[0] <= 223: C += 1
    elif 224 <= ip[0] <= 239: D += 1
    elif 240 <= ip[0] <= 255: E += 1
    if ip[0] == 10&nbs***bsp;(ip[0] == 192 and ip[1] == 168)&nbs***bsp;(ip[0] == 172 and 16 <= ip[1] <= 31): 
        private += 1   # 统计私有地址
print(A, B, C, D, E, wrong, private)

这道题主要是题目要求没讲清楚：掩码没问题后判断ip类别，ip类别的判断是根据第一项的范围来的，起初还以为是单个值，其次是私有ip的定义更是一坨，第一个是根据ip的第一个字段，第二个和第三个需要看前两个字段，并且第一个字段是固定值第二个字段是个范围，这个范围也没讲清楚。

# 识别有效的ip和掩码进行分类统计
import sys
ip_list = []
mask_list = []
total_num = {'A':0,'B':0,'C':0,'D':0,'E':0,'error':0,'pri':0}
for line in sys.stdin:
    a = line.split('~')
    head  = a[0].split('.')[0]
    # 剔除特殊ip
    if head != '0' and head != '127':
        ip_list.append(a[0])
        mask_list.append(a[1])
ip_correct = []  # 初始化正确的ip位置列表
ip_error = []
mask_correct = []
mask_error = []
for i in range(len(ip_list)):
    # ip判别
    empty_flage = False
    ip_errror_flage = False
    ip = ip_list[i]
    ip_temp = ip.split('.')
    for part in ip_temp:
        if len(part)<1:
            empty_flage = True
    if empty_flage:
        ip_error.append(i)
        continue
    ip_correct.append((i,int(ip_temp[0])))         # 保存争取的索引以及正确ip的类别
for j in range(len(mask_list)):
    # mask判别
    cat_=''
    cat_bin=''
    illage_num=0
    mask_error_flage = False
    mask_empty_flage = False
    mask = mask_list[j]
    mask_temp = mask.split('.')
    for part in mask_temp:
        if len(part)<1:
            mask_empty_flage = True
    if mask_empty_flage:
        mask_error.append(j)
        continue
    for i in range(len(mask_temp)):
        cat_ += bin(int(mask_temp[i]))[2:].zfill(8)
    if cat_.count('1') == len(cat_):
        mask_error.append(j)
        continue
    elif cat_.count('0') == len(cat_):
        mask_error.append(j)
        continue
    bin_mask = []
    for k in range(len(mask_temp)):
        bin_mask.append(bin(int(mask_temp[k]))) # 二进制mask
    for item in bin_mask:
        cat_bin += item[2:].zfill(8)
    # print(cat_bin)
    illage_num+=cat_bin.count('01')
    illage_num+=cat_bin.count('10')
    if illage_num >=2:
        mask_error_flage = True
        mask_error.append(j)
    if mask_empty_flage or mask_error_flage:
        continue
    mask_correct.append(j)          # 仅保存正确掩码的索引
# 计算类别正确类别
for item in ip_correct:
    index,type_ = item
    if index in mask_correct:
        if type_ <128 :
            if type_ == 10 :
                total_num['A'] += 1
                total_num['pri'] += 1
            else:
                total_num['A'] += 1
        elif type_ <192 :
            if type_ == 172 and 15<int(ip_list[index].split('.')[1]) <32:
                total_num['B'] += 1
                total_num['pri'] += 1
            else:
                total_num['B'] += 1
        elif type_ <224 :
            if type_ == 192 and ip_list[index].split('.')[1] == '168':
                total_num['C'] += 1
                total_num['pri'] += 1
            else:
                total_num['C'] += 1
        elif type_ < 240:
            total_num['D'] += 1
        elif type_ <255:
            total_num['E'] += 1
ip_error = list(set(ip_error))
mask_error = list(set(mask_error))
for ip_error_index in ip_error:
    if ip_error_index in mask_error:
        mask_error.remove(ip_error_index)
error_list = ip_error + mask_error
total_num['error'] = len(error_list)
print(total_num['A'],total_num['B'],total_num['C'],total_num['D'],total_num['E'],total_num['error'],total_num['pri'])

import sys


def judge_ip(ip_address: str):
    try:
        num_list = [int(item) for item in ip_address.split(".")]
    except:
        return ['invalid', ' ', ' ']
    num1 = num_list[0]
    num2 = num_list[1]
    num3 = num_list[2]
    num4 = num_list[3]
    if  1<= num1 <= 126:
        if  num1 == 10:
            return ['valid', 'A', 'P']
        else:
            return ['valid', 'A', ' ']
    elif 128<= num1 <= 191:
        if num1 == 172 and 16 <= num2 <= 31:
            return ['valid', 'B', 'P']
        else:
            return ['valid', 'B', ' ']
    elif 192<= num1 <= 223:
        if num1 == 192 and num2 == 168:
            return ['valid', 'C', 'P']
        else:
            return ['valid', 'C', ' ']
    elif 224<= num1 <= 239:
        return ['valid', 'D', ' ']
    elif 240<= num1 <= 255:
        return ['valid', 'E', ' ']
    else:
        return ['pass', ' ', ' ']


def judge_mark(ip_address: str):
    num_list = [bin(int(item))[2:] for item in ip_address.split(".")]
    for i in range(0,4):
        if len(num_list[i]) <8:
            num_list[i] = '0'*(8-len(num_list[i])) + num_list[i]
            
    num_str = ''.join(num_list)
    if num_str.lower() == '1'*32:
        return 'invalid'
    if num_str.lower() == '0'*32:
        return 'invalid'
    for i in range(0, len(num_str)):
        if not num_str[i] == '1':
            for j in range(i, len(num_str)):
                if num_str[j] != '0':
                    return 'invalid'
    return 'valid'

res_dict = {'A':0, 'B':0, 'C':0, 'D':0, 'E':0, 'invalid':0,'P':0}
for item in sys.stdin.readlines():
        if item == '\n':
            continue
        item = item.rstrip('\n')
        slist = item.split('~')
        temp = judge_ip(slist[0])
        temp_mark = judge_mark(slist[1])
        if temp[0] == 'pass':
            continue
        if temp[0] == 'invalid'&nbs***bsp;temp_mark == 'invalid':
            res_dict['invalid'] += 1
            continue
        if temp[1] in res_dict.keys():
            res_dict[temp[1]] += 1
        if temp[2] in res_dict.keys():
            res_dict[temp[2]] += 1
        
        

print(f"{res_dict['A']} {res_dict['B']} {res_dict['C']} {res_dict['D']} {res_dict['E']} {res_dict['invalid'] } {res_dict['P']}")

a = b = c = d = e = error = private = 0
try:
    while True:
        user_input = input("")
        if user_input == "":
            break

        parts = user_input.split("~")
        if len(parts) != 2:
            error += 1
            continue

        ip_str, mask_str = parts[0], parts[1]

        # Check IP validity
        ip_valid = True
        ip_parts = ip_str.split(".")
        if len(ip_parts) != 4:
            ip_valid = False
        else:
            for p in ip_parts:
                if not p.isdigit():
                    ip_valid = False
                    break
                num = int(p)
                if num < 0&nbs***bsp;num > 255:
                    ip_valid = False
                    break

        # Check Mask validity
        mask_valid = True
        mask_parts = mask_str.split(".")
        if len(mask_parts) != 4:
            mask_valid = False
        else:
            for p in mask_parts:
                if not p.isdigit():
                    mask_valid = False
                    break
                num = int(p)
                if num < 0&nbs***bsp;num > 255:
                    mask_valid = False
                    break

        if mask_valid:
            mask_nums = [int(p) for p in mask_parts]
            binary_str = "".join([format(num, "08b") for num in mask_nums])
            all_zero = all(c == "0" for c in binary_str)
            all_one = all(c == "1" for c in binary_str)
            if all_zero&nbs***bsp;all_one:
                mask_valid = False
            else:
                first_zero = binary_str.find("0")
                if first_zero == -1:
                    mask_valid = False
                else:
                    if "1" in binary_str[first_zero:]:
                        mask_valid = False

        if not (ip_valid and mask_valid):
            error += 1
        else:
            ip_parts = [int(p) for p in ip_parts]
            # Check private IP
            if (
                (ip_parts[0] == 10)
               &nbs***bsp;(ip_parts[0] == 172 and 16 <= ip_parts[1] <= 31)
               &nbs***bsp;(ip_parts[0] == 192 and ip_parts[1] == 168)
            ):
                private += 1
            # Check IP class
            if ip_parts[0] not in (0, 127):
                first_byte = ip_parts[0]
                if 1 <= first_byte <= 126:
                    a += 1
                elif 128 <= first_byte <= 191:
                    b += 1
                elif 192 <= first_byte <= 223:
                    c += 1
                elif 224 <= first_byte <= 239:
                    d += 1
                elif 240 <= first_byte <= 255:
                    e += 1

except EOFError:
    pass
finally:
    print(f"{a} {b} {c} {d} {e} {error} {private}")

没研究出来哪个地方有问题
import sys
a = b = c = d = e = count_error = count_pri = 0
# 十进制转二进制
def trans(number):
    result = ""
    if number == 0:
        return 0
    dic = []
    while number > 0:
        result = str(number % 2) + result
        number = number // 2
    return result
# 判断IP是否错误
def isIp(ip):
    dic = ip.split(".")
    if len(dic) != 4:
        return False
    for i in dic:
        if i.isdigit() != True:
            return False
        if int(i) > 255&nbs***bsp;int(i) < 0:
            return False
    return True
# 判断子网掩码是否错误
def isMask(mask):
    if isIp(mask) == False&nbs***bsp;mask == "1.1.1.1"&nbs***bsp;mask == "0.0.0.0":
        return False
    n1, n2, n3, n4 = mask.split(".")
    for n in [n1, n2, n3, n4]:
        if "01" in trans(int(n)):
            return False
    return True
# 判断IP类型
def type(ip, a, b, c, d, e, count_pri):
    n1, n2, n3, n4 = ip.split(".")
    n1 = int(n1)
    n2 = int(n2)
    if n1 >= 1 and n1 < 127:
        a += 1
    elif n1 >= 128 and n1 < 192:
        b += 1
    elif n1 >= 192 and n1 < 224:
        c += 1
    elif n1 >= 224 and n1 < 240:
        d += 1
    elif n1 >= 240 and n1 < 260:
        e += 1
    if n1 == 10:
        count_pri += 1
    if n1 == 172 and (n2 >= 16 and n2 <= 31):
        count_pri += 1
    if n1 == 192 and n2 == 168:
        count_pri += 1
    return a, b, c, d, e, count_pri
for line in sys.stdin:
    ip, mask = line.split("~")
    dic = ip.split(".")
    if int(dic[0]) != 0 and int(dic[0]) != 127:
        if isIp(ip) == False:
            count_error += 1
        else:
            a, b, c, d, e, count_pri = type(ip, a, b, c, d, e, count_pri)
        if isMask(mask) == False:
            count_error += 1
print(f"{a} {b} {c} {d} {e} {count_error} {count_pri}")

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