Conversion from IP string to integer, and backward in Python

Question

i have a little problem with my script, where i need to convert ip in form 'xxx.xxx.xxx.xxx' to integer representation and go back from this form.

def iptoint(ip):
    return int(socket.inet_aton(ip).encode('hex'),16)

def inttoip(ip):
    return socket.inet_ntoa(hex(ip)[2:].decode('hex'))


In [65]: inttoip(iptoint('192.168.1.1'))
Out[65]: '192.168.1.1'

In [66]: inttoip(iptoint('4.1.75.131'))
---------------------------------------------------------------------------
error                                     Traceback (most recent call last)

/home/thc/<ipython console> in <module>()

/home/thc/<ipython console> in inttoip(ip)

error: packed IP wrong length for inet_ntoa`

Anybody knows how to fix that?

Doesn't work at all in my Python 2.6.6: `inttoip` raises a `TypeError: Odd-length string`. — Ilkka, Apr 11 '11 at 10:15
@Ilkka use socket.inet_ntoa(hex(ip)[2:].decode('hex')) for inttoip — Maksym Polshcha, Jan 21 '15 at 12:00

score 114 · Answer 1 · edited Aug 17 '18 at 05:21

114

#!/usr/bin/env python
import socket
import struct


def ip2int(addr):
    return struct.unpack("!I", socket.inet_aton(addr))[0]


def int2ip(addr):
    return socket.inet_ntoa(struct.pack("!I", addr))


print(int2ip(0xc0a80164)) # 192.168.1.100
print(ip2int('10.0.0.1')) # 167772161

edited Aug 17 '18 at 05:21

mja

1,273
1
20
22

answered Nov 08 '12 at 17:28

fiorix

3,619
3
19
12

This requires `import struct`. – StockB May 15 '18 at 13:28
1

3 times faster comparing to ipaddress. – 0script0 Nov 29 '19 at 14:12

score 96 · Answer 2 · answered Apr 07 '16 at 11:38

96

Python 3 has ipaddress module which features very simple conversion:

int(ipaddress.IPv4Address("192.168.0.1"))
str(ipaddress.IPv4Address(3232235521))

answered Apr 07 '16 at 11:38

markhor

2,235
21
18

4

This should be the top answer. Python 2 has this module too, but not built in. – Smit Johnth Mar 24 '20 at 12:07
1

This module is so slow – Jiulin Teng Apr 18 '21 at 17:28
1

I've just ran this over 50 ip addresses with no noticable difference to my original script when I wasn't running the additional conversion and back back again.. seems quick enough to me – c7borg Nov 18 '21 at 09:48

score 28 · Answer 3 · answered May 08 '13 at 16:52

28

In pure python without use additional module

def IP2Int(ip):
    o = map(int, ip.split('.'))
    res = (16777216 * o[0]) + (65536 * o[1]) + (256 * o[2]) + o[3]
    return res


def Int2IP(ipnum):
    o1 = int(ipnum / 16777216) % 256
    o2 = int(ipnum / 65536) % 256
    o3 = int(ipnum / 256) % 256
    o4 = int(ipnum) % 256
    return '%(o1)s.%(o2)s.%(o3)s.%(o4)s' % locals()

# Example
print('192.168.0.1 -> %s' % IP2Int('192.168.0.1'))
print('3232235521 -> %s' % Int2IP(3232235521))

Result:

192.168.0.1 -> 3232235521
3232235521 -> 192.168.0.1

answered May 08 '13 at 16:52

Bruno Adelé

1,087
13
16

i realise that this post is fairly old, but you can also use `pow`:: `res = (o[0] * pow(256, 3)) + (o[1] * pow(256, 2)) + (o[2] * 256) + o[3]` – Renier Jul 31 '18 at 13:34
1

Dude, `'%(o1)s.%(o2)s.%(o3)s.%(o4)s' % locals()` is a veeeery bad style. – Smit Johnth Mar 24 '20 at 12:17
@SmitJohnth Thank you for giving the alternative solution ..., here, the new style can be `f'{o1}.{o2}.{o3}.{o4}'` – Bruno Adelé Apr 12 '20 at 10:26

score 12 · Answer 4 · answered Apr 11 '11 at 10:17

12

You lose the left-zero-padding which breaks decoding of your string.

Here's a working function:

def inttoip(ip):
    return socket.inet_ntoa(hex(ip)[2:].zfill(8).decode('hex'))

answered Apr 11 '11 at 10:17

ThiefMaster

310,957
84
592
636

Yeah, you also fixed the `[2:-1]` slice to `[2:]`, that was causing the error I commented about above. – Ilkka Apr 11 '11 at 10:18
1

If ip is a LONG there will be a `'L'` turd at the end of the string. Either replace `hex(ip)` with `hex(int(ip))` or add `.rstrip('L')` after `[2:]`. – johnny Sep 14 '12 at 16:01

score 8 · Answer 5 · answered Apr 11 '11 at 11:10

Below are the fastest and most straightforward (to the best of my knowledge) convertors for IPv4 and IPv6:

    try:
        _str = socket.inet_pton(socket.AF_INET, val)
    except socket.error:
        raise ValueError
    return struct.unpack('!I', _str)[0]
    -------------------------------------------------
    return socket.inet_ntop(socket.AF_INET, struct.pack('!I', n))
    -------------------------------------------------
    try:
        _str = socket.inet_pton(socket.AF_INET6, val)
    except socket.error:
        raise ValueError
    a, b = struct.unpack('!2Q', _str)
    return (a << 64) | b
    -------------------------------------------------
    a = n >> 64
    b = n & ((1 << 64) - 1)
    return socket.inet_ntop(socket.AF_INET6, struct.pack('!2Q', a, b))

Python code not using inet_ntop() and struct module is like order of magnitude slower than this regardless of what it is doing.

socket.inet_pton and inet_ntop are only available on Unix – johnny Sep 14 '12 at 15:44 — johnny, Sep 14 '12 at 15:44

Thomas Ducrot · Answer 6 · 2018-01-19T08:26:42.953

6

One line

reduce(lambda out, x: (out << 8) + int(x), '127.0.0.1'.split('.'), 0)

edited Jan 19 '18 at 08:26

answered Jun 17 '17 at 13:30

Thomas Ducrot

2,841
1
16
14

and by far more efficient/faster to left-shift than multiply – Galland Mar 06 '20 at 09:55

score 6 · Answer 7 · answered Mar 06 '20 at 10:13

6

Python3 oneliner (based on Thomas Webber's Python2 answer):

sum([int(x) << 8*i for i,x in enumerate(reversed(ip.split('.')))])

Left shifts are much faster than pow().

answered Mar 06 '20 at 10:13

Galland

473
5
5

Janith · Answer 8 · 2021-01-07T04:52:27.113

5

It can be done without using any library.

def iptoint(ip):
        h=list(map(int,ip.split(".")))
        return (h[0]<<24)+(h[1]<<16)+(h[2]<<8)+(h[3]<<0)

def inttoip(ip):
       return ".".join(map(str,[((ip>>24)&0xff),((ip>>16)&0xff),((ip>>8)&0xff),((ip>>0)&0xff)]))

iptoint("8.8.8.8") # 134744072

inttoip(134744072) # 8.8.8.8

edited Jan 07 '21 at 04:52

answered Nov 24 '20 at 07:30

Janith

403
6
14

1

correction: `def iptoint(ip): h=list(map(int,ip.split("."))) return (h[0]<<24)+(h[1]<<16)+(h[2]<<8)+(h[3]<<0) ` – Ken Jan 06 '21 at 11:29

score 3 · Answer 9 · edited Jun 20 '20 at 09:12

3

I used following:

ip2int = lambda ip: reduce(lambda a,b: long(a)*256 + long(b), ip.split('.'))

ip2int('192.168.1.1')

#output

3232235777L

# from int to ip
int2ip = lambda num: '.'.join( [ str((num >> 8*i) % 256)  for i in [3,2,1,0] ])

int2ip(3232235777L)

#output

'192.168.1.1'

edited Jun 20 '20 at 09:12

Community

1
1

answered Jan 31 '19 at 13:46

Ahmed

414
4
3

score 1 · Answer 10 · answered Nov 13 '18 at 04:19

Let me give a more understandable way:

ip to int

def str_ip2_int(s_ip='192.168.1.100'):
    lst = [int(item) for item in s_ip.split('.')]
    print lst   
    # [192, 168, 1, 100]

    int_ip = lst[3] | lst[2] << 8 | lst[1] << 16 | lst[0] << 24
    return int_ip   # 3232235876

The above:

lst = [int(item) for item in s_ip.split('.')]

equivalent to :

lst = map(int, s_ip.split('.'))

also:

int_ip = lst[3] | lst[2] << 8 | lst[1] << 16 | lst[0] << 24

equivalent to :

int_ip = lst[3] + (lst[2] << 8) + (lst[1] << 16) + (lst[0] << 24)

int_ip = lst[3] + lst[2] * pow(2, 8) + lst[1] * pow(2, 16) + lst[0] * pow(2, 24)

int to ip:

def int_ip2str(int_ip=3232235876):
    a0 = str(int_ip & 0xff)
    a1 = str((int_ip & 0xff00) >> 8) 
    a2 = str((int_ip & 0xff0000) >> 16)
    a3 = str((int_ip & 0xff000000) >> 24)

    return ".".join([a3, a2, a1, a0])

or:

def int_ip2str(int_ip=3232235876):
    lst = []
    for i in xrange(4):
        shift_n = 8 * i
        lst.insert(0, str((int_ip >> shift_n) & 0xff))

    return ".".join(lst)

score 0 · Answer 11 · answered Dec 25 '18 at 13:00

My approach is to straightforwardly look at the the number the way it is stored, rather than displayed, and to manipulate it from the display format to the stored format and vice versa.

So, from an IP address to an int:

def convertIpToInt(ip):
    return sum([int(ipField) << 8*index for index, ipField in enumerate(reversed(ip.split('.')))])

This evaluates each field, and shifts it to its correct offset, and then sums them all up, neatly converting the IP address' display into its numerical value.

In the opposite direction, from an int to an IP address:

def convertIntToIp(ipInt):
    return '.'.join([str(int(ipHexField, 16)) for ipHexField in (map(''.join, zip(*[iter(str(hex(ipInt))[2:].zfill(8))]*2)))])

The numerical representation is first converted into its hexadecimal string representation, which can be manipulated as a sequence, making it easier to break up. Then, pairs are extracted by mapping ''.join onto tuples of pairs provided by zipping a list of two references to an iterator of the IP string (see How does zip(*[iter(s)]*n) work?), and those pairs are in turn converted from hex string representations to int string representations, and joined by '.'.

score 0 · Answer 12 · answered May 23 '22 at 09:49

def ip2int(ip):
    """
    Convert IP string to integer
    :param ip: IP string
    :return: IP integer
    """
    return reduce(lambda x, y: x * 256 + y, map(int, ip.split('.')))


def int2ip(num):
    """
    Convert IP integer to string
    :param num: IP integer
    :return: IP string
    """
    return '.'.join(map(lambda x: str(num // 256 ** x % 256), range(3, -1, -1)))

Conversion from IP string to integer, and backward in Python

12 Answers12

I used following:

Linked