检查字符串是否与 python 中的 IP 地址模式匹配？

问题描述：

检查字符串是否与特定模式匹配的最快方法是什么？正则表达式是最好的方法吗？

例如，我有一堆字符串，想检查每个字符串是否是有效的 IP 地址（在这种情况下有效意味着正确的格式），最快的方法是使用正则表达式吗？或者有没有更快的方法，比如字符串格式化之类的。

到目前为止我一直在做这样的事情：

for st in strs:
    if re.match('d{1,3}.d{1,3}.d{1,3}.d{1,3}', st) != None:
       print 'IP!'

解决方案 1：

更新

下面的原始答案适用于 2011 年，但自 2012 年以来，使用 Python 的ipaddress stdlib 模块可能会更好- 除了检查 IPv4 和 IPv6 的 IP 有效性之外，它还可以做很多其他事情。

看起来您正在尝试验证 IP 地址。正则表达式可能不是最好的工具。

如果您想接受所有有效的 IP 地址（包括一些您可能甚至不知道是否有效的地址），那么您可以使用IPy （来源）：

from IPy import IP
IP('127.0.0.1')

如果 IP 地址无效，则会引发异常。

或者你可以使用socket （来源）：

import socket
try:
    socket.inet_aton(addr)
    # legal
except socket.error:
    # Not legal

如果您确实只想匹配具有 4 个小数部分的 IPv4，那么您可以在点上拆分并测试每个部分是否是 0 到 255 之间的整数。

def validate_ip(s):
    a = s.split('.')
    if len(a) != 4:
        return False
    for x in a:
        if not x.isdigit():
            return False
        i = int(x)
        if i < 0 or i > 255:
            return False
    return True

请注意，您的正则表达式不会进行此额外检查。它会被接受999.999.999.999为有效地址。

解决方案 2：

如果你使用Python3，则可以使用ipaddress模块http://docs.python.org/py3k/library/ipaddress.html。例如：

>>> import ipaddress

>>> ipv6 = "2001:0db8:0a0b:12f0:0000:0000:0000:0001"
>>> ipv4 = "192.168.2.10"
>>> ipv4invalid = "266.255.9.10"
>>> str = "Tay Tay"

>>> ipaddress.ip_address(ipv6)
IPv6Address('2001:db8:a0b:12f0::1')

>>> ipaddress.ip_address(ipv4)
IPv4Address('192.168.2.10')

>>> ipaddress.ip_address(ipv4invalid)
Traceback (most recent call last):
  File "<console>", line 1, in <module>
  File "/usr/lib/python3.4/ipaddress.py", line 54, in ip_address
    address)
ValueError: '266.255.9.10' does not appear to be an IPv4 or IPv6 address

>>> ipaddress.ip_address(str)
Traceback (most recent call last):
  File "<console>", line 1, in <module>
  File "/usr/lib/python3.4/ipaddress.py", line 54, in ip_address
    address)
ValueError: 'Tay Tay' does not appear to be an IPv4 or IPv6 address

解决方案 3：

在 Python 3.6 上我认为更简单，因为 ipaddress 模块已经包含在内：

import ipaddress

    def is_ipv4(string):
        try:
            ipaddress.IPv4Network(string)
            return True
        except ValueError:
            return False

解决方案 4：

我通常是少数坚定捍卫正则表达式的 Python 专家之一（它们在 Python 社区中名声很差），但这不是其中一种情况——接受（比如说）'333.444.555.666'“IP 地址”确实很糟糕，而且如果您在匹配 RE 后需要进行更多检查，那么使用 RE 的大部分意义就丧失了。因此，我衷心赞同 @Mark 的建议：IPy具有通用性和优雅性（如果您愿意，包括支持 IPv6！），如果您只需要 IPv4，则可以使用字符串操作和 int 检查（但请仔细考虑该限制，然后再考虑一次——IPv6 的时代已经到来了！）：

def isgoodipv4(s):
    pieces = s.split('.')
    if len(pieces) != 4: return False
    try: return all(0<=int(p)<256 for p in pieces)
    except ValueError: return False

我宁愿这样做，也不愿使用复杂的 RE 来匹配 0 到 255 之间的数字！-)

解决方案 5：

再进行一次无需重新验证的验证：

def validip(ip):
    return ip.count('.') == 3 and  all(0<=int(num)<256 for num in ip.rstrip().split('.'))

for i in ('123.233.42.12','3234.23.453.353','-2.23.24.234','1.2.3.4'):
    print i,validip(i)

解决方案 6：

您的正则表达式不会检查字符串的结尾，因此它会匹配：

123.45.67.89abc123boogabooga

要修复此问题，请使用：

'd{1,3}.d{1,3}.d{1,3}.d{1,3}$'

（请注意$最后的）。

最后，在 Python 中通常的样式是使用is not None而不是!= None。

解决方案 7：

本页中的其他正则表达式答案将接受数字超过 255 的 IP。

这个正则表达式将避免这个问题：

import re

def validate_ip(ip_str):
    reg = r"^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]).){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$"
    if re.match(reg, ip_str):
        return True
    else:
        return False

解决方案 8：

如果您正在验证 IP 地址，我建议您执行以下操作：

import socket

try:
    socket.inet_aton(addr)
    return True
except socket.error:
    return False

如果您只是想检查它是否采用正确的格式，那么您需要对所有合法的进制（而不仅仅是十进制）进行此操作。

此外，如果 IP 地址仅支持 IPv4（并且没有 IPv6），那么您可以查找有效地址，然后使用split()（获取IP 的各个组成部分int()）和（进行类型转换以进行比较）。有效 IPv4 规则的快速参考在此处。

解决方案 9：

安装 netaddr 包

sudo pip install netaddr

然后你可以这样做

>>> from netaddr import valid_ipv4
>>> valid_ipv4('11.1.1.2') 
True
>>> valid_ipv4('11.1.1.a')
False

您还可以从该字符串创建一个 IPAddress 对象以及更多与 IP 相关的操作

>>> from netaddr import IPAddress
>>> ip = IPAddress('11.1.1.1')
>>> [f for f in dir(ip) if '__' not in f]
['_module', '_set_value', '_value', 'bin', 'bits', 'format', 'info', 'ipv4', 'ipv6', 'is_hostmask', 'is_ipv4_compat', 'is_ipv4_mapped', 'is_link_local', 'is_loopback', 'is_multicast', 'is_netmask', 'is_private', 'is_reserved', 'is_unicast', 'key', 'netmask_bits', 'packed', 'reverse_dns', 'sort_key', 'value', 'version', 'words']

解决方案 10：

可以使用iptools。

import iptools
ipv4 = '1.1.1.1'
ipv6 = '5000::1'
iptools.ipv4.validate_ip(ipv4) #returns bool
iptools.ipv6.validate_ip(ipv6) #returns bool

解决方案 11：

使用内置库ipaddress可以非常轻松地检查给定的 IP 是否有效。您还可以使用掩码值进行验证。

ip = '30.0.0.1'   #valid
#ip = '300.0.0.0/8'  #invalid
#ip = '30.0.0.0/8'   #valid
#ip = '30.0.0.1/8'   #invalid
#ip = 'fc00:da00::3402:69b1' #valid
#ip = 'fc00:da00::3402:69b1/128' #valid
#ip = 'fc00:da00::3402:69b1:33333' #invalid

if ip.find('/') > 0:
    try:
        temp2 = ipaddress.ip_network(ip)
        print('Valid IP network')        
    except ValueError:
        print('Invalid IP network, value error')
else:        
    try:
        temp2 = ipaddress.ip_address(ip)
        print('Valid IP')
    except ValueError:
        print('Invalid IP')

注意：在 Python 3.4.3 中测试

解决方案 12：

在 Python 3.* 中非常简单，这是一个实用函数，它将检查任何 ip、ipv4 或 ipv6，只需使用 Python 标准库ipaddress — IPv4/IPv6 操作库

from ipaddress import ip_address, IPv4Address, IPv6Address, AddressValueError


def _is_valid_ip_address(ip, ipv_type: str = 'any') -> bool:
    """Validates an ipd address"""
    try:
        if ipv_type == 'any':
            ip_address(ip)
        elif ipv_type == 'ipv4':
            IPv4Address(ip)
        elif ipv_type == 'ipv6':
            IPv6Address(ip)
        else:
            raise NotImplementedError
    except (AddressValueError, ValueError):
        return False
    else:
        return True

def run_tests():
    ipv4 = '192.168.0.1'
    ipv6 = '2001:db8::1000'
    bad = "I AM NOT AN IP"
    is_pv4 = _is_valid_ip_address(ipv4)
    is_pv6 = _is_valid_ip_address(ipv6)
    bad_ip = _is_valid_ip_address(bad)

    am_i_pv4 = _is_valid_ip_address(ipv6, ipv_type='ipv4')
    am_i_pv6 = _is_valid_ip_address(ipv4, ipv_type='ipv6')
    print(f'''
    * is_pv4 -> {is_pv4}
    * is_pv6 -> {is_pv6}
    * bad_ip -> {bad_ip}
    * am_i_pv4 -> {am_i_pv4}
    * am_i_pv6 -> {am_i_pv6}
    ''')



if __name__ == '__main__':
    run_tests()

结果

* is_pv4 -> True
* is_pv6 -> True
* bad_ip -> False
* am_i_pv4 -> False
* am_i_pv6 -> False

解决方案 13：

我需要一个针对 Python 2.7 上的 IPV4 地址的解决方案（工作中的旧项目）

• socket.inet_aton比我想要的更宽容。

• 不想/不喜欢使用正则表达式。

这对我有用：

def is_ipv4_address(ip_string):

    ip_parts = ip_string.split('.')
    return len(ip_parts) == 4 and all(part.isdigit() for part in ip_parts) and all(255 >= int(part) >=0 for part in ip_parts)

• int(part) in range(0,255)看起来比 更好255 >= int(part) >=0，但是速度较慢：

%timeit 5 in range(0,255)
113 ns ± 1.27 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops each)

%timeit 255 >= 5 >= 0
30.5 ns ± 0.276 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops each)

• 在 Python 3.10/Linux 上，此方法比以下方法运行速度更快ipaddress.ip_address()：

import ipaddress

ip = '192.168.0.0'

%timeit ipaddress.ip_address(ip)
2.15 µs ± 21.5 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)

%timeit is_ipv4_address(ip)
1.18 µs ± 24.6 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)

解决方案 14：

你可以通过编译来让它更快一些：

expression = re.compile('^d{1,3}.d{1,3}.d{1,3}.d{1,3}$')
for st in strs:
    if expression.match(st):
       print 'IP!'

解决方案 15：

如果你反复使用正则表达式，你应该对其进行预编译

re_ip = re.compile('d{1,3}.d{1,3}.d{1,3}.d{1,3}$')
# note the terminating $ to really match only the IPs

然后使用

if re_ip.match(st):
    print '!IP'

但是...例如“111.222.333.444”真的是 IP 吗？

我会看看netaddr或ipaddr库是否可以用来匹配 IP

解决方案 16：

我作弊了，使用了其他人提交的多个答案的组合。我认为这是一段非常清晰和直接的代码。ip_validation应该返回True或False。此外，此答案仅适用于 IPv4 地址

import re
ip_match = re.match('^' + '[.]'.join(['(d{1,3})']*4) + '$', ip_input)
ip_validate = bool(ip_match)
if ip_validate:
    ip_validate &= all(map(lambda n: 0 <= int(n) <= 255, ip_match.groups())

解决方案 17：

这也适用于 ipv6 地址。

不幸的是它只适用于python3

import ipaddress

def valid_ip(address):
    try: 
        print ipaddress.ip_address(address)
        return True
    except:
        return False

print valid_ip('10.10.20.30')
print valid_ip('2001:DB8::1')
print valid_ip('gibberish')

解决方案 18：

我们不需要任何导入即可完成此操作。这也更快

def is_valid_ip(str_ip_addr):
   """
   :return: returns true if IP is valid, else returns False
   """
   ip_blocks = str(str_ip_addr).split(".")
   if len(ip_blocks) == 4:
       for block in ip_blocks:
           # Check if number is digit, if not checked before calling this function
           if not block.isdigit():
               return False
           tmp = int(block)
           if 0 > tmp > 255:
               return False
       return True
    return False

解决方案 19：

#!/usr/bin/python
import sys
def check_ip(address):
    part=address.split(".")
    temp=True
    if len(part) != 4:
            temp=False
            return temp
    for p in part:
            if not 0<= int(p) <= 255:
                    temp=False
                    return temp
            else:
                    temp=True
    return temp
if __name__=="__main__":
    print check_ip(sys.argv[1])

使用某些名称保存代码，check_ip.py然后按以下方式运行python check_ip.py 192.168.560.25

：注意： 上述代码对于以下 IP 地址失败：

023.65.029.33

解决方案 20：

您可以尝试以下操作（程序可以进一步优化）：

path = "/abc/test1.txt"
fh = open (path, 'r')
ip_arr_tmp = []
ip_arr = []
ip_arr_invalid = []

for lines in fh.readlines():
    resp = re.search ("([0-9]+).([0-9]+).([0-9]+).([0-9]+)", lines)
    print resp

    if resp != None:
       (p1,p2,p3,p4) = [resp.group(1), resp.group(2), resp.group(3), resp.group(4)]       

       if (int(p1) < 0 or int(p2) < 0 or int(p3) < 0 or int(p4) <0):
           ip_arr_invalid.append("%s.%s.%s.%s" %(p1,p2,p3,p4))

       elif (int(p1) > 255 or int(p2) > 255 or int(p3) > 255 or int(p4) > 255):
            ip_arr_invalid.append("%s.%s.%s.%s" %(p1,p2,p3,p4))

       elif (len(p1)>3 or len(p2)>3 or len(p3)>3 or len(p4)>3):
            ip_arr_invalid.append("%s.%s.%s.%s" %(p1,p2,p3,p4))

       else:
           ip = ("%s.%s.%s.%s" %(p1,p2,p3,p4))
           ip_arr_tmp.append(ip)

print ip_arr_tmp

for item in ip_arr_tmp:
    if not item in ip_arr:
       ip_arr.append(item)

print ip_arr

解决方案 21：

from ipaddress import ip_address, IPv4Address

def validIPAddress(IP: str) -> str:
    try:
        return "IPv4" if type(ip_address(IP)) is IPv4Address else "IPv6"
    except ValueError:
        return "Invalid"

if __name__ == '__main__' :
        
    # Enter the Ip address
    Ip = "192.168.0.1"
    print(validIPAddress(Ip))

    Ip = "2001:0db8:85a3:0000:0000:8a2e:0370:7334"
    print(validIPAddress(Ip))

    Ip = "256.32.555.5"
    print(validIPAddress(Ip))

    Ip = "250.32:555.5"
    print(validIPAddress(Ip))

输出 ：

IPv4
IPv6
Invalid
Invalid