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

更新

下面的原始答案适用于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

如果您真的只想将 IPv4 与 4 个小数部分匹配，那么您可以在点上拆分并测试每个部分是否是 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

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

123.45.67.89abc123boogabooga

若要解决此问题，请使用：

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

（注意末尾的）。$

最后，在 Python 中，通常的样式是 use 而不是 .is not None!= None

你可以通过编译它来使它更快一点：

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!'

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

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吗？

我会查看或库是否可以用于匹配 IPnetaddripaddr

我通常是为数不多的坚定捍卫正则表达式的 Python 专家之一（他们在 Python 社区中的名声很差），但这不是其中一种情况——接受（比如）作为“IP 地址”真的很糟糕，如果你需要在匹配 RE 后做更多的检查，无论如何，使用 RE 的大部分意义都丢失了。因此，我衷心支持@Mark的建议：IPy的通用性和优雅性（如果你愿意的话，包括支持IPv6！），字符串操作和int检查，如果你只需要IPv4（但是，请三思而后行，然后再想一想 - IPv6的时代已经到来了！'333.444.555.666'

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 之间的数字！

如果您正在验证IP地址，我会提出以下建议：

import socket

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

如果您只想检查它的格式是否正确，那么您需要针对所有法律依据（而不仅仅是以 10 为基数编号）进行检查。

此外，如果 IP 地址仅为 IPv4（并且没有一个是 IPv6），那么您可以查找有效地址是什么并使用（获取 IP 的各个组件）和（键入种姓进行比较）。此处提供了有效 IPv4 规则的快速参考。split()int()

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

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)

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

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())

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

>>> 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

安装 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']

我们不需要任何导入来执行此操作。这也工作得更快

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

非常简单，可以在内置库 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 中测试

这也适用于 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')

此页面中的其他正则表达式答案将接受数字超过 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

#!/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])

保存带有某个名称的代码，例如-并运行
它 注意：- 上面的代码对于下面的 IP 地址失败-check_ip.pypython check_ip.py 192.168.560.25
023.65.029.33

在 Python 3.6 上，我认为要简单得多，因为已经包含 ipaddress 模块：

import ipaddress

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

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

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

可以使用 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

在 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

我需要一个针对 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)

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