IP转int 和int 转IP 的实现（Python & Java）

最新推荐文章于 2024-04-28 21:55:35 发布
最新推荐文章于 2024-04-28 21:55:35 发布
阅读量4.1k 收藏 3
点赞数
分类专栏： Python ip转int 文章标签： python ip转int int转ip
原文链接：https://blog.csdn.net/nio_lu/article/details/93738956
版权

1、python IP转int 和int 转IP

1.1、IP地址意义

IP地址是一个32位的二进制数，通常被分割为4个“8位二进制数”（也就是4个字节）。IP地址通常用“点分十进制”表示成（a.b.c.d）的形式，其中，a,b,c,d都是0~255之间的十进制整数。例：点分十进IP地址（100.4.5.6），实际上是32位二进制数（01100100.00000100.00000101.00000110）。

根据这些特性就能解析出ip地址

1.2、IP str转IP int 解决函数解决方案

代码：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
print "IP str转IP int 解决函数解决方案"
def to_int(ip_str):
	print "ip_str: ", ip_str
	i = 0
	ip_int = 0
	for ip_part in ip_str.split('.')[::-1]:
	# for ip_part in ip_str.split('.'):
		print ip_part
		ip_int = ip_int + int(ip_part) * 256**i
		i += 1
	print "ip_int: ", ip_int
	return ip_int


ip_int = to_int("7.91.205.21")

输出：

IP str转IP int 解决函数解决方案
ip_str:  7.91.205.21
21
205
91
7
ip_int:  123456789

1.3、IP str转IP int 一行lambda 解决

print "IP str转IP int 一行lambda 解决"
ip_str_to_int = lambda x: sum([256**j*int(i) for j,i in enumerate(x.split('.')[::-1])])
print ip_str_to_int('7.91.205.21')

1.4、IP int转IP str 函数解决方案

代码：

print "IP int转IP str 函数解决方案"
def to_ip(ip_int):
	s = []
	for i in range(4):
		ip_part = str(ip_int % 256)
		s.append(ip_part)
		ip_int /= 256
		print "ip_part: ", ip_part
	print s
	print s[::-1]
	return '.'.join(s[::-1])


print to_ip(ip_int=123456789)

输出：

IP int转IP str 一行lambda 解决
ip_part:  21
ip_part:  205
ip_part:  91
ip_part:  7
['21', '205', '91', '7']
['7', '91', '205', '21']
7.91.205.21

1.5、IP int转IP str 一行lambda 解决

print "IP int转IP str 一行lambda 解决"
ip_int_to_str = lambda x: '.'.join([str(x/(256**i) % 256) for i in range(4)][::-1])
print ip_int_to_str(123456789)

1.7、python list间隔输出，倒序输出、enumerate() 函数介绍

#1、 开多次方的写法
print "2**3: ", 2**3  # 8
print "3**4: ", 3**4  # 81

tmp_list = [1,2,3,4,5,6,7]

#2、 提示 [::-1]是数组元素反转
print "tmp_list: ", tmp_list
# tmp_list:  [1, 2, 3, 4, 5, 6, 7]
print "reverse tmp_list:", tmp_list[::-1]
# reverse tmp_list: [7, 6, 5, 4, 3, 2, 1]

#3、打印下表小于end_pos的元素[0,end_pos)
end_pos=2
for e in tmp_list[:end_pos]:
	print e
'''
1
2
'''
#4、打印list中一段元素[start_pos,end_pos)
start_pos=1
end_pos=4
for e in tmp_list[start_pos:end_pos]:
	print e
'''
2
3
4
'''
#5、从下标0开始，每隔 正step元素 打印元素
step=2
for e in tmp_list[::step]:
	print e
'''
1
3
5
7
'''
#6、从下标len(tmp_list)-1开始，每隔 负step元素 打印元素
step=-2
for e in tmp_list[::step]:
	print e
'''
7
5
3
1
'''
#7、 enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，
# 一般用在 for 循环当中。Python 2.3. 以上版本可用，2.6 添加 start 参数。
for j, i in enumerate('7.91.205.21'.split('.')):
	print j, i
'''
0 7
1 91
2 205
3 21
'''
for j, i in enumerate('7.91.205.21'.split('.')[::-1]):
	print j, i
'''
0 21
1 205
2 91
3 7
'''

参考：https://blog.csdn.net/nio_lu/article/details/93738956

2、Java把IP地址转换成INT型存储（考察的位运算）

 java ip转Int 和 java Ip转Int

2.1、基本知识点 

IP ——> 整数：

  • 把IP地址转化为字节数组

  • 通过左移位（<<）、与（&）、或（|）这些操作转为int

整数 ——> IP：

  • 将整数值进行右移位操作（>>>），右移24位，再进行与操作符（&）0xFF，得到的数字即为第一段IP。

  • 将整数值进行右移位操作（>>>），右移16位，再进行与操作符（&）0xFF，得到的数字即为第二段IP。

  • 将整数值进行右移位操作（>>>），右移8位，再进行与操作符（&）0xFF，得到的数字即为第三段IP。

  • 将整数值进行与操作符（&）0xFF，得到的数字即为第四段IP。

2.2、java代码示例

package com.guozz.mianshiti.test19;
 
import java.net.InetAddress;
 
public class IPv4Util {
 
	private final static int INADDRSZ = 4;
 
    /**
     * 把IP地址转化为字节数组
     * @param ipAddr
     * @return byte[]
     */
    public static byte[] ipToBytesByInet(String ipAddr) {
        try {
            return InetAddress.getByName(ipAddr).getAddress();
        } catch (Exception e) {
            throw new IllegalArgumentException(ipAddr + " is invalid IP");
        }
    }
 
    /**
     * 把IP地址转化为int
     * @param ipAddr
     * @return int
     */
    public static byte[] ipToBytesByReg(String ipAddr) {
        byte[] ret = new byte[4];
        try {
            String[] ipArr = ipAddr.split("\\.");
            ret[0] = (byte) (Integer.parseInt(ipArr[0]) & 0xFF);
            ret[1] = (byte) (Integer.parseInt(ipArr[1]) & 0xFF);
            ret[2] = (byte) (Integer.parseInt(ipArr[2]) & 0xFF);
            ret[3] = (byte) (Integer.parseInt(ipArr[3]) & 0xFF);
            return ret;
        } catch (Exception e) {
            throw new IllegalArgumentException(ipAddr + " is invalid IP");
        }
 
    }
 
    /**
     * 字节数组转化为IP
     * @param bytes
     * @return int
     */
    public static String bytesToIp(byte[] bytes) {
        return new StringBuffer().append(bytes[0] & 0xFF).append('.').append(
                bytes[1] & 0xFF).append('.').append(bytes[2] & 0xFF)
                .append('.').append(bytes[3] & 0xFF).toString();
    }
 
    /**
     * 根据位运算把 byte[] -> int
     * @param bytes
     * @return int
     */
    public static int bytesToInt(byte[] bytes) {
        int addr = bytes[3] & 0xFF;
        addr |= ((bytes[2] << 8) & 0xFF00);
        addr |= ((bytes[1] << 16) & 0xFF0000);
        addr |= ((bytes[0] << 24) & 0xFF000000);
        return addr;
    }
 
    /**
     * 把IP地址转化为int
     * @param ipAddr
     * @return int
     */
    public static int ipToInt(String ipAddr) {
        try {
            return bytesToInt(ipToBytesByInet(ipAddr));
        } catch (Exception e) {
            throw new IllegalArgumentException(ipAddr + " is invalid IP");
        }
    }
 
    /**
     * ipInt -> byte[]
     * @param ipInt
     * @return byte[]
     */
    public static byte[] intToBytes(int ipInt) {
        byte[] ipAddr = new byte[INADDRSZ];
        ipAddr[0] = (byte) ((ipInt >>> 24) & 0xFF);
        ipAddr[1] = (byte) ((ipInt >>> 16) & 0xFF);
        ipAddr[2] = (byte) ((ipInt >>> 8) & 0xFF);
        ipAddr[3] = (byte) (ipInt & 0xFF);
        return ipAddr;
    }
 
    /**
     * 把int->ip地址
     * @param ipInt
     * @return String
     */
    public static String intToIp(int ipInt) {
        return new StringBuilder().append(((ipInt >> 24) & 0xff)).append('.')
                .append((ipInt >> 16) & 0xff).append('.').append(
                        (ipInt >> 8) & 0xff).append('.').append((ipInt & 0xff))
                .toString();
    }
 
    /**
     * 把192.168.1.1/24 转化为int数组范围
     * @param ipAndMask
     * @return int[]
     */
    public static int[] getIPIntScope(String ipAndMask) {
 
        String[] ipArr = ipAndMask.split("/");
        if (ipArr.length != 2) {
            throw new IllegalArgumentException("invalid ipAndMask with: "
                    + ipAndMask);
        }
        int netMask = Integer.valueOf(ipArr[1].trim());
        if (netMask < 0 || netMask > 31) {
            throw new IllegalArgumentException("invalid ipAndMask with: "
                    + ipAndMask);
        }
        int ipInt = IPv4Util.ipToInt(ipArr[0]);
        int netIP = ipInt & (0xFFFFFFFF << (32 - netMask));
        int hostScope = (0xFFFFFFFF >>> netMask);
        return new int[] { netIP, netIP + hostScope };
 
    }
 
    /**
     * 把192.168.1.1/24 转化为IP数组范围
     * @param ipAndMask
     * @return String[]
     */
    public static String[] getIPAddrScope(String ipAndMask) {
        int[] ipIntArr = IPv4Util.getIPIntScope(ipAndMask);
        return new String[] { IPv4Util.intToIp(ipIntArr[0]),
                IPv4Util.intToIp(ipIntArr[0]) };
    }
 
    /**
     * 根据IP 子网掩码（192.168.1.1 255.255.255.0）转化为IP段
     * @param ipAddr ipAddr
     * @param mask mask
     * @return int[]
     */
    public static int[] getIPIntScope(String ipAddr, String mask) {
 
        int ipInt;
        int netMaskInt = 0, ipcount = 0;
        try {
            ipInt = IPv4Util.ipToInt(ipAddr);
            if (null == mask || "".equals(mask)) {
                return new int[] { ipInt, ipInt };
            }
            netMaskInt = IPv4Util.ipToInt(mask);
            ipcount = IPv4Util.ipToInt("255.255.255.255") - netMaskInt;
            int netIP = ipInt & netMaskInt;
            int hostScope = netIP + ipcount;
            return new int[] { netIP, hostScope };
        } catch (Exception e) {
            throw new IllegalArgumentException("invalid ip scope express  ip:"
                    + ipAddr + "  mask:" + mask);
        }
 
    }
 
    /**
     * 根据IP 子网掩码（192.168.1.1 255.255.255.0）转化为IP段
     * @param ipAddr ipAddr
     * @param mask mask
     * @return String[]
     */
    public static String[] getIPStrScope(String ipAddr, String mask) {
        int[] ipIntArr = IPv4Util.getIPIntScope(ipAddr, mask);
        return new String[] { IPv4Util.intToIp(ipIntArr[0]),
                IPv4Util.intToIp(ipIntArr[0]) };
    }
 
    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        String ipAddr = "192.168.8.1";
 
        byte[] bytearr = IPv4Util.ipToBytesByInet(ipAddr);
 
        StringBuffer byteStr = new StringBuffer();
 
        for (byte b : bytearr) {
            if (byteStr.length() == 0) {
                byteStr.append(b);
            } else {
                byteStr.append("," + b);
            }
        }
        System.out.println("IP: " + ipAddr + " ByInet --> byte[]: [ " + byteStr
                + " ]");
 
        bytearr = IPv4Util.ipToBytesByReg(ipAddr);
        byteStr = new StringBuffer();
 
        for (byte b : bytearr) {
            if (byteStr.length() == 0) {
                byteStr.append(b);
            } else {
                byteStr.append("," + b);
            }
        }
        System.out.println("IP: " + ipAddr + " ByReg  --> byte[]: [ " + byteStr
                + " ]");
 
        System.out.println("byte[]: " + byteStr + " --> IP: "
                + IPv4Util.bytesToIp(bytearr));
 
        int ipInt = IPv4Util.ipToInt(ipAddr);
 
        System.out.println("IP: " + ipAddr + "  --> int: " + ipInt);
 
        System.out.println("int: " + ipInt + " --> IP: "
                + IPv4Util.intToIp(ipInt));
 
        String ipAndMask = "192.168.1.1/24";
 
        int[] ipscope = IPv4Util.getIPIntScope(ipAndMask);
        System.out.println(ipAndMask + " --> int地址段：[ " + ipscope[0] + ","
                + ipscope[1] + " ]");
 
        System.out.println(ipAndMask + " --> IP 地址段：[ "
                + IPv4Util.intToIp(ipscope[0]) + ","
                + IPv4Util.intToIp(ipscope[1]) + " ]");
 
        String ipAddr1 = "192.168.1.1", ipMask1 = "255.255.255.0";
 
        int[] ipscope1 = IPv4Util.getIPIntScope(ipAddr1, ipMask1);
        System.out.println(ipAddr1 + " , " + ipMask1 + "  --> int地址段 ：[ "
                + ipscope1[0] + "," + ipscope1[1] + " ]");
 
        System.out.println(ipAddr1 + " , " + ipMask1 + "  --> IP地址段 ：[ "
                + IPv4Util.intToIp(ipscope1[0]) + ","
                + IPv4Util.intToIp(ipscope1[1]) + " ]");
 
    }
}

参考：https://blog.csdn.net/paul342/article/details/48374237

Data_IT_Farmer
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言将整型转为IP地址或者MAC地址
RBK的博客
12-02 5260
在有的项目中会将IP地址用整型来表示，比如我现在这个项目，它用u_int32_t来表示一个IPv4地址，需要将其转为我们常见的x.x.x.x字符串形式。 IP 1 举个例子，比如有一个数1920103026，它表示的是一个IP地址，如何转换为直观的形式呢。 先将其转为二进制形式1110010011100100111001001110010，可以发现只有31位，而IP地址实际是有32位的，在最前面补一个0，然后分段，8位一段。 01110010 01110010 01110010 01110010，将每
IP地址与int整数的转换
zdfunk的博客
08-11 2837
给你一个IP4的地址，请转成十进制整数 （2021-03 腾讯-PCG-前端） 手撕算法: ip地址转整数 （2021-03 腾讯-TEG-后端） 输入描述: 输入 1 输入IP地址 2 输入10进制型的IP地址 输出描述: 输出 1 输出转换成10进制的IP地址 2 输出转换后的IP地址 示例1 输入 10.0.3.193 167969729 输出 167773121 10.3.3.193 牛客地址 例如，ip地址为10.0.3.193，把每段拆分成一个二进制形式组合起来为 00001010.
JAVA中IP和整数相互转化
徐辉的专栏
09-15 593
一、基本知识点   IP ——> 整数： 把IP地址转化为字节数组通过左移位（ 整数 ——> IP： 将整数值进行右移位操作（>>>），右移24位，再进行与操作符（&）0xFF，得到的数字即为第一段IP。将整数值进行右移位操作（>>>），右移16位，再
Python中，几种常用的方法可以将字符串转换为整数（int型）
最新发布
qq_36566678的博客
04-28 3668
这些是Python中常用的将字符串转换为整数的方法，选择合适的方法取决于具体情况和需求。注意：在使用这些方法时，要确保字符串中含有的内容确实能被有效转换为整数，否则会出现异常。函数可以计算字符串表达式，并返回结果。如果字符串是一个整数，也可以将其转换为整数。方法用于判断字符串是否全由数字组成，结合条件判断可以将纯数字字符串转换为整数。在Python中，有几种常用的方法可以。将字符串转换为整数（int型）
python中ip与int之间相互转化
weixin_38858749的博客
12-08 3670
import IPy ip_int = 1234567 # 将int转ip(str) 原理:将整数转换成无符号32位的二进制，用'.'对每8位进行分割，每8位转换成十进制即可。 ip = IPy.intToIp(ip_int, 4) print(ip, type(ip)) # 将ip转int print(IPy.parseAddress(ip, 4), type(IPy.parseAddress(ip, 4)[0])) ...
python ip与int相互转换
白小白的小白的博客
03-17 776
在项目中，我们经常会保存用户的ip，做一些判断，但是由于sql效率的原因，存整形比较好，所以，我们要把ip转化为int，如何转化那？ def int_ip(num): s = [] for i in range(4): s.append(str(num %256)) num //= 256 return '.'.join(s[::-1]) def ip_int(ip): res = 0 for j, i in enumerate(i.
jzzhq.rar_转换_进制 转换_进制转换
09-21
在编程中，许多语言提供了内置的函数来进行进制转换，比如Python的`bin()`, `oct()`, `hex()`和`int()`函数，以及Java的`Integer.toString(int, int)`和`Integer.parseInt(String, int)`等。了解如何利用这些函数...
jinzhizhuanhuan.zip_Variety_进制转换
09-19
在进行这样的转换时，可以手动进行计算，或者使用编程语言提供的内置函数，如JavaScript的`parseInt`和`toString`，Python的`bin`、`oct`、`hex`和`int`等。 在“jinzhizhuanhuan.zip”文件中，可能包含了多种编程...
判断ip地的合法性及子网判断
06-24
通过阅读和分析这些代码，我们可以学习他们各自的方法和实现策略，对比不同实现的优缺点，进一步提升对网络编程的理解。在实际工作中，这样的练习可以帮助我们更好地处理网络相关的编程问题，提高代码质量。
基于HslCommunication的远程读写PLC，JAVA，Python远程读写PLC的示例代码。.zip
03-23
HslCommunication是一款强大的通信库，它为开发者提供了与PLC进行远程通信的能力，支持多种编程语言，如JAVA和Python。这个压缩包“基于HslCommunication的远程读写PLC，JAVA，Python远程读写PLC的示例代码.zip”...
16进制转10进制例程.rar
04-03
4. **编程实现**：在编程语言中，如C, C++, Java, Python等，都有内置函数或方法可以方便地进行16进制到10进制的转换。例如，在Python中，可以使用`int(hex_number, 16)`来进行转换，其中`hex_number`是16进制字符串...
java ip to int_Java实现ip地址和int数字的相互转换示例代码
weixin_29798981的博客
02-20 409
本篇文章小编给大家分享一下Java实现ip地址和int数字的相互转换示例代码，文章代码介绍的很详细，小编觉得挺不错的，现在分享给大家供大家参考，有需要的小伙伴们可以来看看。Java版本的 ip地址和int数字的相互转换对于ipv4的地址来说，如果用字符串的形式存储的话，其占用字节就比较大，比如对于IPv4地址0.0.0.0的字符串，就需要7个字节，IPv4为255.255.255.255的字符串，...
python 整数与IP地址转换
douyaoxin_126的博客
04-03 379
【代码】python 整数与IP地址转换。
python实现将ip段解析为单个ip
sakura_ll的博客
06-05 3692
文章目录将ip段解析为单个ip192.168.1.*样式的ip段分解192.168.1-10.*样式的ip段进行分解192.168.1.0-255样式的ip段进行分解192.168.1.0/24样式的ip段进行分解整体代码附上 将ip段解析为单个ip 将类似于192.168.1.* 192.168.1.0-255 192.168.1-10.* 192.168.1.0/24 这样的段IP解析为单个的ip，以方便后续的扫描等操作。 192.168.1.*样式的ip段分解 def IP
IP地址（IPV4）与int类型之间的转换
热门推荐
王小二(海阔天空)
03-22 1万+
IP地址（IPV4）与int类型之间的转换 一、前言 IP地址（IPV4）是一个32位的二进制数，通常被分割为4个“8位二进制数”（也就是4个字节）。IP地址（IPV4）通常用“点分十进制”表示成（a.b.c.d）的形式，其中，a,b,c,d都是0~255之间的十进制整数。例：点分十进IP地址（100.4.5.6），实际上是32位二进制数（01100100.00000100.00000101.0...
IP转int，int转IP
李豆豆的博客
05-07 633
func toInt(ip string) int64 { i := 3 sum := int64(0) for j, v := range strings.Split(ip, ".") { intV, _ := strconv.ParseInt(v, 10, 64) sum = sum + intV*int64(math.Pow(float64(256), float64(i-j)...
java int变ip地址_Java实现ip地址和int数字的相互转换
weixin_36189723的博客
02-13 465
Java实现ip地址和int数字的相互转换发布时间：2020-10-11 22:15:15来源：脚本之家阅读：107作者：laosunJava版本的 ip地址和int数字的相互转换对于ipv4的地址来说，如果用字符串的形式存储的话，其占用字节就比较大，比如对于IPv4地址0.0.0.0的字符串，就需要7个字节，IPv4为255.255.255.255 的字符串，需要15个字节，也就是说存储一个ip...
C#IP转int int转IP
weiwei_y的博客
03-01 685
IP转int数值 int数值转ip C#
socketjava客户端和python服务端程序编写过程
09-23
Socket编程是一种在计算机网络中实现进程通信的方法。在Java中，可以使用java.net包中的Socket类来创建一个客户端。编写Socket客户端程序的过程包括以下几个步骤： 1. 导入必要的类：导入java.net包中的Socket和IOException类。 2. 创建Socket对象：使用Socket构造函数创建一个Socket对象。构造函数需要传入服务器的IP地址和端口号。 3. 获取输入输出流：通过Socket对象的getInputStream()方法获取输入流和getOutputStream()方法获取输出流。 4. 发送和接收数据：使用输出流向服务器发送数据，并使用输入流接收服务器返回的数据。 5. 关闭Socket连接：使用Socket对象的close()方法关闭连接。 下面是一个简单的Java Socket客户端程序示例： ```java import java.io.*; import java.net.*; public class SocketClient { public static void main(String[] args) { try { // 创建Socket对象，指定服务器的IP地址和端口号 Socket socket = new Socket("服务器IP地址", 端口号); // 获取输出流 OutputStream outputStream = socket.getOutputStream(); // 向服务器发送数据 String message = "需要发送的数据"; outputStream.write(message.getBytes()); // 获取输入流 InputStream inputStream = socket.getInputStream(); // 接收服务器返回的数据 byte[] buffer = new byte[1024]; int length = inputStream.read(buffer); String response = new String(buffer, 0, length); System.out.println("服务器返回的数据：" + response); // 关闭连接 socket.close(); } catch (IOException e) { e.printStackTrace(); } } } ``` 在Python中，可以使用socket模块来创建一个服务端。编写Socket服务端程序的过程包括以下几个步骤： 1. 导入必要的模块：导入socket模块。 2. 创建Socket对象：使用socket.socket()函数创建一个socket对象。 3. 绑定地址和端口：使用socket对象的bind()方法绑定服务器的IP地址和端口号。 4. 开始监听：使用socket对象的listen()方法开始监听，等待客户端连接。 5. 建立连接：使用socket对象的accept()方法接收客户端的连接请求，并返回客户端的Socket对象和地址。 6. 接收和发送数据：通过客户端的Socket对象进行数据的接收和发送。 7. 关闭连接：使用socket对象的close()方法关闭连接。 下面是一个简单的Python Socket服务端程序示例： ```python import socket # 创建socket对象 s = socket.socket() # 绑定地址和端口 host = '0.0.0.0' port = 20000 s.bind((host, port)) # 开始监听 s.listen(6) # 建立连接 conn, addr = s.accept() # 接收数据 data = conn.recv(1024) print(data.decode()) # 发送数据 data_last = data.decode() conn.send(f"{data_last},也算我一个，青鸟是我的！".encode()) # 关闭连接 s.close() conn.close() ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值