运维Python自动化之路：基础信息模块之IPy模块

pip3 install IPy

 通过IPy的学习，获取ip和网段的基本信息。

识别ip分类    
    version()
 获取ip数量
    len()

  ip分类：
   ipv4:
        样式：192.168.1.1
        四部分数字组成，0-9，值的范围是0~255
   ipv6
        样式：00：00：00：00：00：00
        六部分组成，0-9，a-f

ip_content = '192.168.242.130/32'
ip_result = IP(ip_content).version()
print("{} 的ip类型是：IPv{}".format(ip_content,ip_result))

ip_content = 'fe80::124:5bff:fc2b:619f'
ip_result = IP(ip_content).version()
print("{} 的ip类型是：IPv{}".format(ip_content,ip_result))

#2.1定义网段
ip_range  = IP('192.168.1.0/30')

#2.2获取ip数量
 print("{} 网段有{} 个ip".format(ip_range,ip_range.len()))

#2.3 查询所有的ip
for i in ip_range:
print(i)

 通过IPy的学习，了解ip操作的常见方式。

反向解析：
  reversnNames()
ip类型：
  iptype()
ip转换
  转换成整型 int()
  转换成十六进制 strHex()
  转换成二进制 strBin()
  十六进制转换成ip地址 IP（）

举例：www.baidu.com ---- 36.152.44.95
正向解析：
  通过域名找到对应的ip地址
反向解析：
  根据ip地址，找到对应的网站域名

#获取Ip相关信息
#导包
import IPy
from IPy import IP
#1.反向解析名称
#1.1定制ip地址
my_ip = IP('36.152.44.95')  
#1.2获取定制域名
name = my_ip.reverseNames()
print("{} 的域名名称是：{}".format(my_ip,name))

#2.ip类型
#2.1地址ip地址
my_ip1 = IP('36.152.44.95')  #PUBLIC类型公网
my_ip2 = IP('192.168.1.1')   #PRIVATE类型私网
#2.2获取ip类型
name1 = my_ip1.iptype()
name2 = my_ip2.iptype()
print("{} 的类型是{}".format(my_ip1,name1))
print("{} 的类型是{}".format(my_ip2,name2))

#3.ip转换
#3.1定制ip地址
my_ip = IP('36.152.44.95')
#3.2 转换类型
int_result = my_ip.int()
print("{} 的转换成整型{}".format(my_ip,int_result))
hex_result = my_ip.strHex()
print("{} 的转换成十六进制{}".format(my_ip,hex_result))
bin_result = my_ip.strBin()
print("{} 的转换成二进制{}".format(my_ip,bin_result))

#3.3 ip地址反转换
hex_address = '0x24982c5f'
ip_result = IP(hex_address)
print("{}的转换成ip类型{}".format(hex_address,ip_result))

bin_address = '00100100100110000010110001011111'
#注意:IP接收的内容不能是非十六进制IP地址
ip_result1 = IP(bin_address)
print("{}的转换成ip类型{}".format(hex_address,ip_result1))

ip的表现样式：
  样式1   ip/掩码数字
      192.168.1.1/24
  样式2  ip   掩码地址
    192.168.1.1 255.255.255.0

格式：
  IP（‘ip地址’）.make_net(‘掩码地址’)
  IP('ip地址段')，make_net=True)

#网段的常见操作
#导包
from IPy import IP
#1.网段地址转换
#1.1转换样式1
ip_net = '192.168.1.0'
ip_result = IP(ip_net).make_net('255.255.255.0')
print("{} 转换后的样式 {}".format(ip_net,ip_result))

#1.2转换样式2
ip_net2 = '192.168.1.0/255.255.255.0'
ip_result2 = IP(ip_net2,make_net=True)
print("{} 转换后的样式 {}".format(ip_net2,ip_result2))


#1.3转换样式3
ip_net3 = '192.168.1.0-192.168.1.255'
ip_result3 = IP(ip_net3,make_net=True)
print("{} 转换后的样式 {}".format(ip_net3,ip_result3))

通过指定 wantprefixlen数值，来获取不同的网段
值解析：
  0 返回默认的IP地址
  1 返回ip地址/掩码值 样式
  2 返回ip地址/掩码  样式
  3 返回ip地址-IP地址  样式

#网段常见操作
#导包
from IPy import IP

#1.网段地址转换
#1.1定制ip
my_ip = IP('192.168.1.0/24')

#1.2格式转换
format_0 = my_ip.strNormal(0)
print("{}转换的样式0:{}".format(my_ip,format_0))
format_1 = my_ip.strNormal(1)
print("{}转换的样式1:{}".format(my_ip,format_1))
format_2 = my_ip.strNormal(2)
print("{}转换的样式2:{}".format(my_ip,format_2))
format_3 = my_ip.strNormal(3)
print("{}转换的样式3:{}".format(my_ip,format_3))

简介：
  相同ip段，不同的掩码获取的ip地址不一样
  不同ip段，相同的掩码获取的ip地址不一样
  而不同的网段，彼此之间有可能存在ip地址重合交叉

#多网段的常见操作
#导包
from IPy  import IP
#1.掩码的作用
#1.1相同ip段不同的掩码获取的ip地址不一样
ip_range  = IP('192.168.1.0/30')
ip_range2 = IP('192.168.1.0/28')
#1.2获取ip数量及查询所有的ip
print("{} 网段有{} 个ip".format(ip_range,ip_range.len()))
for i in ip_range:
  print(i)
print('===================================================')
print("{} 网段有{} 个ip".format(ip_range2,ip_range2.len()))
for j in ip_range2:
        print(j)

网段比较
  ip对象 <  ip对象
  结果为True或者为False
地址包含
  ip地址 ip  ip对象
  结果为True或者为False
网段重叠
  ip对象.over laps(ip网段)

#多网段的基本i操作

#导包
from IPy  import IP
#1.网段比较
ip_net1 = '192.168.1.0/24'
ip_net2 = '192.168.1.0/24'
ip_net3 = '192.168.2.0/24'
result = IP(ip_net1) == IP(ip_net2)
print("{}和{}网段信息是否一致：{}".format(ip_net1,ip_net2,result))

result = IP(ip_net1) == IP(ip_net3)
print("{}和{}网段信息是否一致：{}".format(ip_net1,ip_net3,result))
result = IP(ip_net1) < IP(ip_net3)
print("{}和{}网段信息是否一致：{}".format(ip_net1,ip_net3,result))

#2.地址包含
#2.1 判断ip地址是否在某个ip段内
ip_add  = '192.168.1.100'
ip_add2 = '192.168.2.100'
ip_net  = '192.168.1.0/24'
result = ip_add in IP(ip_net)
print("{}是否在网段{}内：{}".format(ip_add,ip_net,result))
print("{}是否在网段{}内：{}".format(ip_add2,ip_net,result))
#2.2 判断ip段是否在另外一个ip段内
ip_net2  = '192.168.0.0/16'
result2 = ip_net in IP(ip_net2)
print("{}是否在网段{}内：{}".format(ip_net2,ip_net,result2))

#3.网段重叠
#3.1返回值-1代表前面的网段是后面网段的子集
ip_net1 = '192.168.1.0/24'
ip_net2  = '192.168.0.0/16'
ip_net3 = '192.168.3.0/24'
result1 = IP(ip_net1).overlaps(ip_net2)
print("{}和{}是否存在网络重叠：{}".format(ip_net1,ip_net2,result1))


#3.2返回值1代表后面的网段是前面网段的子集
result2 = IP(ip_net2).overlaps(ip_net1)
print("{}和{}是否存在网络重叠：{}".format(ip_net1,ip_net2,result2))

#3.3返回值0代表两个网段没有重合
result3 = IP(ip_net1).overlaps(ip_net3)
print("{}和{}是否存在网络重叠：{}".format(ip_net1,ip_net3,result3))

通过一个简单的场景，来对我们的ipy模块进行综合实践
对用户输入的信息进行判断
如果是多个ip地址就逐一的查看具体信息
如果是单个ip地址，就显示ip反向解析域名
输出ip地址的其他几种格式

#网络的综合实践
#导包
from IPy import IP

#1.接收用户的输入信息
ip_s = input("Please input an IP or net-range:")
#2.对用户输入的信息进行判断
ips = IP(ip_s)
if len(ips) > 1:
  #3.如果是多个ip地址就逐一的查看具体信息
  print("net:{}".format(ips.net()))
  print("netmask:{}".format(ips.netmask()))
  print("broadcast:{}".format(ips.broadcast()))
  print("reverse address:{}".format(ips.reverseNames()[0]))
  print("subnet:{}".format(ips.len()))
else:
  #4.如果是单个ip地址，就显示反向解析域名
  print("reverse address:{}".format(ips.reverseNames()[0]))

#5.输出IP地址的其他几种格式
print("ip地址的十六进制格式：{}".format(ips.strHex()))
print("ip地址的二进制格式：{}".format(ips.strBin()))
print("ip地址的类型：{}".format(ips.iptype()))

在用户输入的时候，对用户输入的信息进行判断，确定用户输入的内容是否是ip地址
--分析
  我们知道ipy模块，有一个方法用于判断ip地址是否正确，version
  正常的时候，version有两种值4或者6，否则报错。

#网络的综合实践改造
#导包
from IPy import IP

#1.接收用户的输入信息
ip_s = input("Please input an IP or net-range:")
#2.对用户输入的信息进行判断
try:
 ips = IP(ip_s)
except Exception as e:
  print("您输入的ip地址不是正确的格式")
else:
  if len(ips) > 1:
  #3.如果是多个ip地址就逐一的查看具体信息
    print("net:{}".format(ips.net()))
    print("netmask:{}".format(ips.netmask()))
    print("broadcast:{}".format(ips.broadcast()))
    print("reverse address:{}".format(ips.reverseNames()[0]))
    print("subnet:{}".format(ips.len()))
  else:
  #4.如果是单个ip地址，就显示反向解析域名
   print("reverse address:{}".format(ips.reverseNames()[0]))

  #5.输出IP地址的其他几种格式
  print("ip地址的十六进制格式：{}".format(ips.strHex()))
  print("ip地址的二进制格式：{}".format(ips.strBin()))
  print("ip地址的类型：{}".format(ips.iptype()))