python - framework - tutorial django

comprobar si una cadena coincide con un patrón de dirección IP en python?

Question

¿Cuál es la forma más rápida de verificar si una cadena coincide con un patrón determinado? Es regex la mejor manera?

Por ejemplo, tengo un montón de cadenas y quiero verificar cada una de ellas para ver si son una dirección IP válida (válida en este caso, es decir, el formato correcto), ¿es la forma más rápida de hacerlo usando expresiones regulares? O hay algo más rápido con el formato de cadenas similares o algo así.

Algo así es lo que he estado haciendo hasta ahora:

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

Answer 1

En Python 3.6 creo que es mucho más simple ya que el módulo ipaddress ya está incluido:

import ipaddress

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

Answer 2

Esto también funciona para direcciones IPv6.

Desafortunadamente funciona solo para 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'')

Answer 3

Hice trampa y usé la combinación de respuestas múltiples enviadas por otras personas. Creo que esto es una pieza bastante clara y directa de código. ip_validation debería devolver True o False . Además, esta respuesta solo funciona para direcciones 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())

Answer 4

Instalar el paquete netaddr

sudo pip install netaddr

Y luego puedes hacer esto

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

También creas un objeto IPAddress a partir de esa cadena y muchas más operaciones relacionadas con la 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'']

Answer 5

Muy sencillo comprobar si la IP dada es válida o no en la biblioteca integrada ipaddress . También puede validar usando el valor de máscara .

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

Nota: Probado en Python 3.4.3

Answer 6

No necesitamos ninguna importación para hacer esto. Esto también funciona mucho más rápido

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

Answer 7

Normalmente soy uno de los pocos expertos en Python que defiende firmemente las expresiones regulares (tienen una reputación bastante mala en la comunidad de Python), pero este no es uno de esos casos: aceptar (decir) ''333.444.555.666'' como una "dirección IP" es realmente mala, y si necesita hacer más comprobaciones después de hacer coincidir el RE, gran parte del punto de utilizar un RE se pierde de todos modos. Por lo tanto, IPy las recomendaciones de IPy : generalidad y elegancia (¡incluido el soporte de IPv6 si lo desea!), Operaciones de cadena y verificaciones int si solo necesita IPv4 (pero, piense dos veces sobre esa limitación, y luego piense una más - - ¡Ha llegado el momento de 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

Prefiero hacer eso que un RE enrevesado para hacer coincidir solo números entre 0 y 256! -)

Answer 8

Otras respuestas de expresiones regulares en esta página aceptarán una IP con un número superior a 255.

Esta expresión regular evitará este problema:

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

Answer 9

Parece que estás intentando validar las direcciones IP . Una expresión regular probablemente no sea la mejor herramienta para esto.

Si desea aceptar todas las direcciones IP válidas (incluidas algunas direcciones que probablemente ni siquiera sabía que eran válidas), entonces puede usar IPy (Source) :

from IPy import IP
IP(''127.0.0.1'')

Si la dirección IP no es válida arrojará una excepción.

O podría usar socket (Source) :

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

Si realmente desea coincidir con IPv4 con 4 partes decimales, puede dividir el punto y probar que cada parte es un número entero entre 0 y 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

Tenga en cuenta que su expresión regular no hace esta comprobación adicional. Aceptaría 999.999.999.999 como una dirección válida.

Answer 10

Puede hacerlo un poco más rápido compilando:

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

Answer 11

Puede intentar lo siguiente (el programa puede optimizarse aún más):

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

Answer 12

Puede usar expresiones regulares: http://www.regular-expressions.info/python.html

Answer 13

Si está validando la dirección IP, sugeriría lo siguiente:

import socket

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

Si solo quieres comprobar si está en el formato correcto, entonces querrás hacerlo para todas las bases legales (no solo para la numeración de base 10).

Además, si la dirección IP es solo IPv4 (y ninguna es IPv6), entonces podría buscar las direcciones válidas y usar split() (para obtener componentes individuales de la IP) e int() (para la casta de tipos para comparar) . Una referencia rápida a las reglas válidas de IPv4 está here .

Answer 14

Si usa Python3 , puede usar el módulo ipaddress http://docs.python.org/py3k/library/ipaddress.html . Ejemplo:

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

Answer 15

Su expresión regular no comprueba el final de la cadena, por lo que coincidiría:

123.45.67.89abc123boogabooga

Para arreglar esto, usa:

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

(tenga en cuenta los $ al final).

Finalmente, en Python, el estilo habitual es usar is not None lugar de != None .

Answer 16

Una validación más sin re:

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)

Answer 17

debe precompilar la expresión regular, si la usa repetidamente

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

luego usa

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

pero ... ¿es por ejemplo ''111.222.333.444'' realmente el IP?

ipaddr bibliotecas netaddr o ipaddr si se pueden usar para hacer coincidir las direcciones IP

Answer 18

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

Guarde el código con un nombre que check_ip.py y ejecútelo como python check_ip.py 192.168.560.25
Nota: - El código anterior falla para la siguiente dirección IP-
023.65.029.33