it-swarm.com.de

Verwenden eines RegEx zum Abgleichen von IP-Adressen in Python

Ich versuche, einen Test durchzuführen, um zu prüfen, ob eine sys.argv-Eingabe mit dem RegEx für eine IP-Adresse übereinstimmt.

Als einfachen Test habe ich folgendes ...

import re

pat = re.compile("\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}")
test = pat.match(hostIP)
if test:
   print "Acceptable ip address"
else:
   print "Unacceptable ip address"

Wenn ich jedoch zufällige Werte übergebe, wird in den meisten Fällen eine "akzeptable IP-Adresse" zurückgegeben, es sei denn, ich habe eine "Adresse", die im Wesentlichen äquivalent zu \d+ ist.

16
MHibbin

Sie müssen Ihren Regex auf folgende Weise ändern

pat = re.compile("^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$")

das ist, weil . ein Platzhalter ist, der für "jedes Zeichen" steht.

21
DonCallisto

Die Verwendung der regulären Ausdrücke zur Überprüfung der IP-Adresse ist eine schlechte Idee - dies wird 999.999.999.999 als gültig übergeben. Versuchen Sie diesen Ansatz stattdessen mit Socket - viel bessere Validierung und ebenso einfach, wenn nicht einfacher.

import socket

def valid_ip(address):
    try: 
        socket.inet_aton(address)
        return True
    except:
        return False

print valid_ip('10.10.20.30')
print valid_ip('999.10.20.30')
print valid_ip('gibberish')

Wenn Sie stattdessen wirklich den Parse-the-Host-Ansatz verwenden möchten, wird dieser Code genau dies tun:

def valid_ip(address):
    try:
        Host_bytes = address.split('.')
        valid = [int(b) for b in Host_bytes]
        valid = [b for b in valid if b >= 0 and b<=255]
        return len(Host_bytes) == 4 and len(valid) == 4
    except:
        return False
30
Maria Zverina

regulärer Ausdruck für IP v4: 

^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

andernfalls verwenden Sie keine gültige IP-Adresse, wie z

12
burning_LEGION

Ich bin auf die gleiche Situation gestoßen, ich fand die Antwort mit der Verwendung der Socket-Bibliothek hilfreich, bietet aber keine Unterstützung für IPv6-Adressen. Einen besseren Weg dafür gefunden:

Leider funktioniert es nur für 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')
5
Deepak

Sie versuchen zu benutzen. Als ein . nicht als Platzhalter für ein beliebiges Zeichen. Verwenden Sie stattdessen \., um einen Zeitraum anzugeben.

3
BlackVegetable
def ipcheck():
# 1.Validate the ip adderess
input_ip = input('Enter the ip:')
flag = 0

pattern = "^\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}$"
match = re.match(pattern, input_ip)
if (match):
    field = input_ip.split(".")
    for i in range(0, len(field)):
        if (int(field[i]) < 256):
            flag += 1
        else:
            flag = 0
if (flag == 4):
    print("valid ip")
else:
    print('No match for ip or not a valid ip')
1
str = "255.255.255.255"
print(str.split('.'))

list1 = str.split('.')

condition=0

if len(list1)==4:
    for i in list1:
        if int(i)>=0 and int(i)<=255:
            condition=condition+1

if condition!=4:
    print("Given number is not IP address")
else:
    print("Given number is valid IP address")
0
Karthic Kannan

Wenn Sie wirklich RegExs verwenden möchten, filtert der folgende Code möglicherweise die ungültigen IP-Adressen in einer Datei, unabhängig von der Organisation der Datei, eine oder mehrere pro Zeile, auch wenn mehr Text vorhanden ist (Konzept selbst von RegExs):

def getIps(filename):
    ips = []
    with open(filename) as file:
        for line in file:
            ipFound = re.compile("^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$").findall(line)
            hasIncorrectBytes = False
            try:
                    for ipAddr in ipFound:
                        for byte in ipAddr:
                            if int(byte) not in range(1, 255):
                                hasIncorrectBytes = True
                                break
                            else:
                                pass
                    if not hasIncorrectBytes:
                        ips.append(ipAddr)
            except:
                hasIncorrectBytes = True

    return ips
0
Unguest
import re
ipv=raw_input("Enter an ip address")
a=ipv.split('.')
s=str(bin(int(a[0]))+bin(int(a[1]))+bin(int(a[2]))+bin(int(a[3])))
s=s.replace("0b",".")
m=re.search('\.[0,1]{1,8}\.[0,1]{1,8}\.[0,1]{1,8}\.[0,1]{1,8}$',s)
if m is not None:
    print "Valid sequence of input"
else :
    print "Invalid input sequence"

Um es einfach zu halten, habe ich diesen Ansatz verwendet. Es ist einfach wie in, um zu erklären, wie die IPv4-Adresse wirklich ausgewertet wird. Überprüfen, ob es sich um eine Binärzahl handelt, obwohl dies nicht erforderlich ist.

0