import re
print('Введите ip адрес\n'
'формат адреса x.x.x.x/y\n'
' где y - маска в десятичном формате')
print()
decimal = input('Введите адрес: ')
while re.fullmatch(r'((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)/(3[0-2]|[12][0-9]|[1-9])$', decimal) == None:
print('Неверный адрес')
decimal = input('Введите корректный адрес: ')
print()
ipaddr = decimal.split('/')[0]
mask = decimal.split('/')[1]
separet_ipaddr = ipaddr.split('.')
octets_ip_0 = bin(int(separet_ipaddr[0]))[2:]
octets_ip_1 = bin(int(separet_ipaddr[1]))[2:]
octets_ip_2 = bin(int(separet_ipaddr[2]))[2:]
octets_ip_3 = bin(int(separet_ipaddr[3]))[2:]
list_for_fully_empty = [octets_ip_0, octets_ip_1, octets_ip_2, octets_ip_3]
binars_ip_octets_group = []
for i in list_for_fully_empty:
if len(i) != 8:
diff_octets = 8 - len(i)
i = '0' * diff_octets + i
binars_ip_octets_group.append(i)
elif len(i) == 8:
binars_ip_octets_group.append(i)
else:
print('ошибка (else)')
continue
#mask
dictionary_of_masks = {'1':'128.0.0.0',
'2':'192.0.0.0',
'3':'224.0.0.0',
'4':'240.0.0.0',
'5':'248.0.0.0',
'6':'252.0.0.0',
'7':'254.0.0.0',
'8':'255.0.0.0',
'9':'255.128.0.0',
'10':'255.192.0.0',
'11':'255.224.0.0',
'12':'255.240.0.0',
'13':'255.248.0.0',
'14':'255.252.0.0',
'15':'255.254.0.0',
'16':'255.255.0.0',
'17':'255.255.128.0',
'18':'255.255.192.0',
'19':'255.255.224.0',
'20':'255.255.240.0',
'21':'255.255.248.0',
'22':'255.255.252.0',
'23':'255.255.254.0',
'24':'255.255.255.0',
'25':'255.255.255.128',
'26':'255.255.255.192',
'27':'255.255.255.224',
'28':'255.255.255.240',
'29':'255.255.255.248',
'30':'255.255.255.252',
'31':'255.255.255.254',
'32':'255.255.255.255'}
separet_mask = dictionary_of_masks[mask].split('.')
# print(f"separet_mask = {separet_mask}")
octets_mask_0 = bin(int(separet_mask[0]))[2:]
octets_mask_1 = bin(int(separet_mask[1]))[2:]
octets_mask_2 = bin(int(separet_mask[2]))[2:]
octets_mask_3 = bin(int(separet_mask[3]))[2:]
list_for_fully_empty_of_masks = [octets_mask_0, octets_mask_1, octets_mask_2, octets_mask_3]
binars_masks_octets_group = []
#заполнение нулями маску
for f in list_for_fully_empty_of_masks:
if len(f) != 8:
diff_octets_of_mask = 8 - len(f)
f = '0' * diff_octets_of_mask + f
binars_masks_octets_group.append(f)
elif len(f) == 8:
binars_masks_octets_group.append(f)
else:
print('ошибка в маске (else)')
continue
binary_mask_for_show = '.'.join(binars_masks_octets_group)
#логическое поумноживание каждого октета ip c mask
"""Нулевый октет"""
binary_final_result_of_logic_and = []
binary_result_of_logic_and_octet_0 = []
count = 0 # счетчик для внутреннего цикла
for inet in str(binars_ip_octets_group[0]):
for imask in str(binars_masks_octets_group[0])[count]:
logic_and = int(inet) & int(imask)
binary_result_of_logic_and_octet_0.append(logic_and)
count +=1
###отполировка результата нулевого октета
binary_result_of_logic_and_octet_0 = str(binary_result_of_logic_and_octet_0).replace(',', '').replace(' ','').replace('[','').replace(']','')
###Добавление отполированного результата нулевого октета в итог
binary_final_result_of_logic_and.append(binary_result_of_logic_and_octet_0)
"""Первый октет"""
binary_result_of_logic_and_octet_1 = []
count = 0 # счетчик для внутреннего цикла
for inet in str(binars_ip_octets_group[1]):
for imask in str(binars_masks_octets_group[1])[count]:
logic_and = int(inet) & int(imask)
binary_result_of_logic_and_octet_1.append(logic_and)
count +=1
###отполировка результата первого октета
binary_result_of_logic_and_octet_1 = str(binary_result_of_logic_and_octet_1).replace(',', '').replace(' ','').replace('[','').replace(']','')
###Добавление отполированного результата первого октета в итог
binary_final_result_of_logic_and.append(binary_result_of_logic_and_octet_1)
"""Второй октет"""
binary_result_of_logic_and_octet_2 = []
count = 0 # счетчик для внутреннего цикла
for inet in str(binars_ip_octets_group[2]):
for imask in str(binars_masks_octets_group[2])[count]:
logic_and = int(inet) & int(imask)
binary_result_of_logic_and_octet_2.append(logic_and)
count +=1
###отполировка результата первого октета
binary_result_of_logic_and_octet_2 = str(binary_result_of_logic_and_octet_2).replace(',', '').replace(' ','').replace('[','').replace(']','')
###Добавление отполированного результата первого октета в итог
binary_final_result_of_logic_and.append(binary_result_of_logic_and_octet_2)
"""Третий октет"""
binary_result_of_logic_and_octet_3 = []
count = 0 # счетчик для внутреннего цикла
for inet in str(binars_ip_octets_group[3]):
for imask in str(binars_masks_octets_group[3])[count]:
logic_and = int(inet) & int(imask)
binary_result_of_logic_and_octet_3.append(logic_and)
count +=1
###отполировка результата первого октета
binary_result_of_logic_and_octet_3 = str(binary_result_of_logic_and_octet_3).replace(',', '').replace(' ','').replace('[','').replace(']','')
###Добавление отполированного результата первого октета в итог
binary_final_result_of_logic_and.append(binary_result_of_logic_and_octet_3)
octets_0_final = binary_final_result_of_logic_and[0]
octets_1_final = binary_final_result_of_logic_and[1]
octets_2_final = binary_final_result_of_logic_and[2]
octets_3_final = binary_final_result_of_logic_and[3]
binary_network = (f"{octets_0_final}.{octets_1_final}.{octets_2_final}.{octets_3_final}")
#Конкретирование адреса сети из бинара в десятичную
binary_network_address = binary_network.split('.')
"""Нулевый октет"""
degree = 7
decimal_result_of_network_octet_0 = 0
for i in binary_network_address[0]:
i = int(i) * (2 ** degree)
decimal_result_of_network_octet_0+=i
degree-=1
"""Первый октет"""
degree = 7
decimal_result_of_network_octet_1 = 0
for i in binary_network_address[1]:
i = int(i) * (2 ** degree)
decimal_result_of_network_octet_1+=i
degree-=1
"""Второй октет"""
degree = 7
decimal_result_of_network_octet_2 = 0
for i in binary_network_address[2]:
i = int(i) * (2 ** degree)
decimal_result_of_network_octet_2+=i
degree-=1
"""Третий октет"""
degree = 7
decimal_result_of_network_octet_3 = 0
for i in binary_network_address[3]:
i = int(i) * (2 ** degree)
decimal_result_of_network_octet_3+=i
degree-=1
result_network_address = f'{decimal_result_of_network_octet_0}.{decimal_result_of_network_octet_1}.{decimal_result_of_network_octet_2}.{decimal_result_of_network_octet_3}'
# Найти бродкаст адрес
net_for_find_broadcast = binary_network.replace('.', '')
mask_for_find_broadcast = f"{binars_masks_octets_group[0]}.{binars_masks_octets_group[1]}.{binars_masks_octets_group[2]}.{binars_masks_octets_group[3]}"
mask_for_find_broadcast = mask_for_find_broadcast.replace('.', '')
find_first_zero_for_broadcast = mask_for_find_broadcast.find('0')
binary_broadcast = []
count = 0
for i in net_for_find_broadcast:
if count >= find_first_zero_for_broadcast:
i = '1'
binary_broadcast.append(i)
count+=1
else:
binary_broadcast.append(i)
count+=1
binary_broadcast = str(binary_broadcast).replace(',', '').replace(' ','').replace('[','').replace(']','').replace("'",'')
binary_broadcast = binary_broadcast[:8] + '.' + binary_broadcast[8:16] + '.' + binary_broadcast[16:24] + '.' + binary_broadcast[24:]
binary_broadcast = binary_broadcast.split('.')
binary_broadcast_for_show = '.'.join(binary_broadcast)
#Конвертирование бродкаст адреса с бинара в десятичную
"""Нулевый октет"""
degree = 7
decimal_final_result_of_broadcast = []
decimal_result_of_broadcast_octet_0 = 0
for i in binary_broadcast[0]:
i = int(i) * (2 ** degree)
decimal_result_of_broadcast_octet_0+=i
degree-=1
#Конвертирование бродкаст адреса с бинара в десятичную
"""Первый октет"""
degree = 7
decimal_result_of_broadcast_octet_1 = 0
for i in binary_broadcast[1]:
i = int(i) * (2 ** degree)
decimal_result_of_broadcast_octet_1+=i
degree-=1
#Конвертирование бродкаст адреса с бинара в десятичную
"""Второй октет"""
degree = 7
decimal_result_of_broadcast_octet_2 = 0
for i in binary_broadcast[2]:
i = int(i) * (2 ** degree)
decimal_result_of_broadcast_octet_2+=i
degree-=1
#Конвертирование бродкаст адреса с бинара в десятичную
"""Третий октет"""
degree = 7
decimal_result_of_broadcast_octet_3 = 0
for i in binary_broadcast[3]:
i = int(i) * (2 ** degree)
decimal_result_of_broadcast_octet_3+=i
degree-=1
result_broadcast_address = f'{decimal_result_of_broadcast_octet_0}.{decimal_result_of_broadcast_octet_1}.{decimal_result_of_broadcast_octet_2}.{decimal_result_of_broadcast_octet_3}'
# Первый адрес хоста
binary_find_first_host = []
count = 1
binary_final_result_for_first_host = binary_final_result_of_logic_and
for i in binary_final_result_for_first_host[3]:
if count == len(binary_final_result_for_first_host[3]):
i = '1'
binary_find_first_host.append(i)
else:
binary_find_first_host.append(i)
count+=1
binary_find_first_host = ''.join(binary_find_first_host)
binary_final_result_for_first_host.pop(3)
binary_final_result_for_first_host.append(binary_find_first_host)
binary_first_host_for_show = '.'.join(binary_final_result_for_first_host)
#Конвертирование адреса первого хоста с бинара в десятичную
"""Нулевый октет"""
degree = 7
decimal_result_of_first_host_octet_0 = 0
for i in binary_final_result_for_first_host[0]:
i = int(i) * (2 ** degree)
decimal_result_of_first_host_octet_0+=i
degree-=1
#Конвертирование адреса первого хоста с бинара в десятичную
"""Первый октет"""
degree = 7
decimal_result_of_first_host_octet_1 = 0
for i in binary_final_result_for_first_host[1]:
i = int(i) * (2 ** degree)
decimal_result_of_first_host_octet_1+=i
degree-=1
#Конвертирование адреса первого хоста с бинара в десятичную
"""Второй октет"""
degree = 7
decimal_result_of_first_host_octet_2 = 0
for i in binary_final_result_for_first_host[2]:
i = int(i) * (2 ** degree)
decimal_result_of_first_host_octet_2+=i
degree-=1
#Конвертирование адреса первого хоста с бинара в десятичную
"""Второй октет"""
degree = 7
decimal_result_of_first_host_octet_3 = 0
for i in binary_final_result_for_first_host[3]:
i = int(i) * (2 ** degree)
decimal_result_of_first_host_octet_3+=i
degree-=1
result_first_host_address = f'{decimal_result_of_first_host_octet_0}.{decimal_result_of_first_host_octet_1}.{decimal_result_of_first_host_octet_2}.{decimal_result_of_first_host_octet_3}'
# Найти последний адрес хоста
find_first_zero_for_last_host = find_first_zero_for_broadcast
net_for_find_last_host = net_for_find_broadcast
binary_net_find_last_host = []
count = 0
for i in net_for_find_last_host:
if count >= find_first_zero_for_last_host and count < 31:
i = '1'
binary_net_find_last_host.append(i)
count+=1
else:
binary_net_find_last_host.append(i)
count+=1
binary_net_find_last_host = ''.join(binary_net_find_last_host)
binary_net_find_last_host = binary_net_find_last_host[:8] + '.' + binary_net_find_last_host[8:16] + '.' + binary_net_find_last_host[16:24] + '.' + binary_net_find_last_host[24:]
binary_net_find_last_host = binary_net_find_last_host.split('.')
binary_last_host_for_show = '.'.join(binary_net_find_last_host)
#Конвертирование адреса последнего хоста с бинара в десятичную
"""Нулевый октет"""
degree = 7
decimal_result_of_last_host_octet_0 = 0
for i in binary_net_find_last_host[0]:
i = int(i) * (2 ** degree)
decimal_result_of_last_host_octet_0+=i
degree-=1
#Конвертирование адреса последнего хоста с бинара в десятичную
"""Первый октет"""
degree = 7
decimal_result_of_last_host_octet_1 = 0
for i in binary_net_find_last_host[1]:
i = int(i) * (2 ** degree)
decimal_result_of_last_host_octet_1+=i
degree-=1
#Конвертирование адреса последнего хоста с бинара в десятичную
"""Второй октет"""
degree = 7
decimal_result_of_last_host_octet_2 = 0
for i in binary_net_find_last_host[2]:
i = int(i) * (2 ** degree)
decimal_result_of_last_host_octet_2+=i
degree-=1
#Конвертирование адреса последнего хоста с бинара в десятичную
"""Третий октет"""
degree = 7
decimal_result_of_last_host_octet_3 = 0
for i in binary_net_find_last_host[3]:
i = int(i) * (2 ** degree)
decimal_result_of_last_host_octet_3+=i
degree-=1
result_last_host_address = f'{decimal_result_of_last_host_octet_0}.{decimal_result_of_last_host_octet_1}.{decimal_result_of_last_host_octet_2}.{decimal_result_of_last_host_octet_3}'
#число хостов
##Находим кол-во нулей
binary_mask_of_count_hosts = ''.join(binars_masks_octets_group)
binary_mask_of_wildcard_mask = binary_mask_of_count_hosts
binary_mask_of_count_hosts = binary_mask_of_count_hosts.count('0')
if binary_mask_of_count_hosts == 0:
count_hosts_for_show = 1
else:
count_hosts_for_show = (2 ** binary_mask_of_count_hosts) - 2
#wildcard mask
binary_wildcard_mask = []
for i in binary_mask_of_wildcard_mask:
if i == '1':
i = '0'
binary_wildcard_mask.append(i)
elif i == '0':
i = '1'
binary_wildcard_mask.append(i)
else:
print('error else - wildcard')
binary_wildcard_mask = ''.join(binary_wildcard_mask)
binary_wildcard_mask_for_show = binary_wildcard_mask[:8] + '.' + binary_wildcard_mask[8:16] + '.' + binary_wildcard_mask[16:24] + '.' + binary_wildcard_mask[24:]
#Конвертирование wildcard маски с бинара в десятичную
"""Нулевый октет"""
degree = 7
binary_wildcard_mask_for_decimal = binary_wildcard_mask_for_show.split('.')
decimal_result_of_wildcard_mask_octet_0 = 0
for i in binary_wildcard_mask_for_decimal[0]:
i = int(i) * (2 ** degree)
decimal_result_of_wildcard_mask_octet_0+=i
degree-=1
#Конвертирование wildcard маски с бинара в десятичную
"""Первый октет"""
degree = 7
decimal_result_of_wildcard_mask_octet_1 = 0
for i in binary_wildcard_mask_for_decimal[1]:
i = int(i) * (2 ** degree)
decimal_result_of_wildcard_mask_octet_1+=i
degree-=1
#Конвертирование wildcard маски с бинара в десятичную
"""Второй октет"""
degree = 7
decimal_result_of_wildcard_mask_octet_2 = 0
for i in binary_wildcard_mask_for_decimal[2]:
i = int(i) * (2 ** degree)
decimal_result_of_wildcard_mask_octet_2+=i
degree-=1
#Конвертирование wildcard маски с бинара в десятичную
"""Третий октет"""
degree = 7
decimal_result_of_wildcard_mask_octet_3 = 0
for i in binary_wildcard_mask_for_decimal[3]:
i = int(i) * (2 ** degree)
decimal_result_of_wildcard_mask_octet_3+=i
degree-=1
result_wilrdcard_mask = f'{decimal_result_of_wildcard_mask_octet_0}.{decimal_result_of_wildcard_mask_octet_1}.{decimal_result_of_wildcard_mask_octet_2}.{decimal_result_of_wildcard_mask_octet_3}'
print('//Вводимые данные\\\\')
print(f"Адрес: {ipaddr}")
print(f"Маска: {dictionary_of_masks[mask]} = {mask}")
print('---------------------')
print(' //Результат\\\\')
row_name_network = 'Network:'
row_name_mask = 'Mask:'
row_name_first_address = 'First address:'
row_name_last_address = 'Last address:'
row_name_broadcast_address = 'Broadcast address:'
row_name_available_hosts = 'Available hosts:'
row_name_wildcard_mask = 'Wildcard mask:'
row_net_and_mask = f"{result_network_address}/{mask}"
if mask == '32':
result_last_host_address = result_first_host_address
binary_last_host_for_show = binary_first_host_for_show
print(f"{row_name_network.ljust(20)}{row_net_and_mask.ljust(20)}{binary_network} ")
print(f"{row_name_mask.ljust(20)}{dictionary_of_masks[mask].ljust(20)}{binary_mask_for_show}")
print(f"{row_name_wildcard_mask.ljust(20)}{result_wilrdcard_mask.ljust(20)}{binary_wildcard_mask_for_show}")
print(f"{row_name_first_address.ljust(20)}{result_first_host_address.ljust(20)}{binary_first_host_for_show}")
print(f'{row_name_last_address.ljust(20)}{result_last_host_address.ljust(20)}{binary_last_host_for_show}')
print(f'{row_name_broadcast_address.ljust(20)}{result_broadcast_address.ljust(20)}{binary_broadcast_for_show}')
print(f"{row_name_available_hosts.ljust(20)}{count_hosts_for_show}")
