python新手上路，以前主要搞网络路由交换这一块，现在用python做一下简单的关于网络的脚本，记录一下学习历程。

    1个IP是否属于1个网段，需要3前提条件，2个IP，1个子网掩码。

    例如192.168.1.60是否和192.168.1.33/26属于同一网段。

    按照之前的学习的，先把IP地址和子网掩码都转换为二进制文件，然后2个IP都和子网掩码做“与”运算，如果结果相同，就是同一网段；如果不同，就是不同网段。


二进制IP和掩码“与”运算
IP1：  192.168.1.601100000010101000000000010011110011000000101010000000000100000000
掩码：255.255.255.19211111111111111111111111111000000
IP2：  192.168.1.331100000010101000000000010010000111000000101010000000000100000000


   按照上述，使用python实现。

class ipSunetRoute(object):

    ##将IP地址转为二进制
    def ipToBinary(self,ip):
        '''ip address transformat into binary
        Argv:
            ip: ip address
        Return:
            binary
        '''
        ip_num = ip.split('.')
        x = 0
        
        ##IP地址是点分十进制，例如：192.168.1.33，共32bit
        ##第1节（192）向前移24位，第2节（168）向前移16位
        ##第3节（1）向迁移8位，第4节（33）不动
        ##然后进行或运算，得出数据
        for i in range(len(ip_num)):
            num = int(ip_num[i]) << (24 - i*8)
            x = x | num

        brnary = str(bin(x).replace('0b',''))
        return brnary
    
    ##将子网掩码转为二进制
    def maskToBinary(self,mask):
        '''netmask change, example: 24 or 255.255.255.0 change binary
        Argv:
            mask: netmask, example:24 or 255.255.255.0
        Return:
            binary
        '''
        mask_list = str(mask).split('.')
        
        ##子网掩码有两种表现形式，例如：/24或255.255.255.0
        if len(mask_list) == 1:
            ##生成一个32个元素均是0的列表
            binary32 = []
            for i in range(32):
                binary32.append('0')

            ##多少位子网掩码就是连续多少个1
            for i in range(int(mask)):
                binary32[i] = '1'
            
            binary = ''.join(binary32)
            
        ##输入的子网掩码是255.255.255.0这种点分十进制格式
        elif len(mask_list) == 4:
            binary = self.ipToBinary(mask)

        return binary

    ##判断IP地址是否属于这个网段
    def ipInSubnet(self,ip,subnet):
        '''
        Argv:
            ip: ip address,example:1.1.1.1
            subnet: subnet,example:1.1.1.0/24,or 1.1.1.0/255.255.255.0
        Return:
            False or True
        '''
        subnet_list = subnet.split('/')
        networt_add = subnet_list[0]
        network_mask = subnet_list[1]

        ##原来的得出的二进制数据类型是str，转换数据类型
        ip_num = int(self.ipToBinary(ip),2)
        subnet_num = int(self.ipToBinary(networt_add),2)
        mask_bin = int(self.maskToBinary(network_mask),2)
        
        ##IP和掩码与运算后比较
        if (ip_num & mask_bin) == (subnet_num & mask_bin):
            return True
        else:
            return False

其他的尝试

      ##将/24的掩码转换位255.255.255.0这样点分十进制格式
    def maskChange(self,mask):
        '''netmask change, example: 24 change 255.255.255.0
        Argv:
            mask: 0 <= 32
        Return:
            netmask is ip, example 255.255.255.0
        '''
        mask = int(mask)
        binary32 = []
        for i in range(32):
            binary32.append('0')
        
        for i in range(mask):
            binary32[i] = '1'
            
        binary_ip = []
        for i in range(4):
            binary_ = ''.join(binary32[i * 8:i * 8 + 8])
            decimal = str(int(binary_, 2))
            binary_ip.append(decimal)
        netmask = '.'.join(binary_ip)
        return netmask
        
    ##和ipToBinary差不多
    def ipToNum(self,ip):
        '''ip address change binary
        Argv:
            ip: ip address,example:1.1.1.1
        Return:
            neumber
        '''
        ip_num = ip.split('.')
        ip = []
        for x in ip_num:
            ip.append(int(x))
        ip_num = ip[0]<<24 | ip[1]<<16 | ip[2]<<8 | ip[3]
        return ip_num
        
    ##和maskChange结合在一起，就与maskToBinary差不多，
    def maskToNum(self,mask):
        '''netmask change binary
        Argv:
            ip: netmask,example: 24 or 255.255.255.0
        Return:
            neumber
        '''
        mask_list = str(mask).split('.')
        if len(mask_list) == 1:
            mask = self.maskChange(int(mask))
        mask_num = self.ipToNum(mask)
        return mask_num

下一步用python实现路由的子网掩码最长匹配。