Was ist der URL Regex Python Validator?

Der URL Regex Python Validator hilft Ihnen zu prüfen, ob Ihre regulären Ausdrücke gültige Web-Adressen korrekt abgleichen. Dies umfasst die Prüfung auf:

• Protokolle wie http oder https

• Domain-Namen und Subdomains

• Optionale Ports, Pfade, Query-Parameter und Fragmente

Das Tool verwendet Pythons re-Modul und ist ideal für Formularvalidierung, Web-Crawling, Daten-Parsing und Link-Prüfungsaufgaben.

Häufige URL Regex-Muster

1. Einfache HTTP/HTTPS-URL

   ^(http|https):\/\/[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

   Trifft: http://example.com, https://qodex.ai

   Trifft nicht: example.com, ftp://server.com

2. Vollständige URL mit optionalen Pfaden und Queries

   ^(http|https):\/\/[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(/[a-zA-Z0-9\-._~:/?#[\]@!$&'()*+,;=]*)?$

   Trifft: https://site.com/path?search=value, http://domain.org

3. Mit optionalem Port

   ^(http|https):\/\/[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:\d{2,5})?(\/.*)?$

   Trifft: http://localhost:8000/home, https://api.site.com:443/v1

Was prüft das regex genau?

• HTTP-Basisauthentifizierung: Optionale Anmeldedaten vor der Domain.

• Domain-Struktur: Erzwingt mindestens eine Subdomain, erlaubt Bindestriche innerhalb von Subdomains und stellt sicher, dass jede Subdomain und die Top-Level-Domain die Längenbegrenzungen nicht überschreiten.

• Top-Level-Domain: Erlaubt nur alphanumerische Zeichen.

• Localhost-Unterstützung: Akzeptiert localhost als gültige Domain.

• Portnummern: Optional, bis zu 5 Ziffern.

• IPv4-Adressen: Erkennt Standard-IPv4-Adressen im Netloc.

• IPv6-Adressen: Für IPv6-Validierung empfiehlt sich ein spezialisierter IPv6-Validator.

Sonderfälle und komplexe URLs

URLs in der Praxis können schwierig sein, besonders mit Top-Level-Domains wie .co.uk oder ungewöhnlichen Subdomain-Strukturen. Für einen robusten Ansatz sollten Sie folgende Aspekte berücksichtigen:

• Optionales Protokoll (z. B. http://, https:// oder keines)

• Optionale Subdomains (wie www.)

• Unterstützung für mehrteilige TLDs (z. B. co.uk)

• Pfade, Query-Strings und Fragmente

• Bindestriche in Domain-Namen

Python-Codebeispiel

import re
def is_valid_url(url):
pattern = re.compile(r'^(http|https)://[a-zA-Z0-9.-]+.[a-zA-Z]{2,}(/[a-zA-Z0-9-._~:/?#[]@!$&'()+,;=])?$')
return bool(pattern.fullmatch(url))
Test-URLs
print(is_valid_url("https://qodex.ai"))             # True
print(is_valid_url("http://example.com/path"))      # True
print(is_valid_url("ftp://invalid.com"))            # False

Probieren Sie Varianten mit dem Python Regex Tester.

Validierung per Bibliothek: das validators-Paket

Während regex für schnelle Prüfungen hervorragend ist, bietet Python leistungsfähige Validierungsbibliotheken für komplexere Fälle.

import validators
print(validators.url("http://localhost:8000")) # True
print(validators.url("ftp://invalid.com")) # ValidationFailure-Objekt (ergibt False)

import validators
from validators import ValidationFailure
def is_string_an_url(url_string: str) -> bool:
result = validators.url(url_string.strip())
return result is True

print(is_string_an_url("http://localhost:8000")) # True
print(is_string_an_url("http://.www.foo.bar/")) # False
print(is_string_an_url("http://localhost:8000 ")) # True (nach .strip())

Tipp: Entfernen Sie vor der Validierung immer führende und nachfolgende Leerzeichen.

Djangos URLValidator

Wenn Sie Django bereits verwenden, nutzen Sie dessen eingebauten URL-Validator:

from django.core.validators import URLValidator
from django.core.exceptions import ValidationError
def is_string_an_url(url_string: str) -> bool:
validate_url = URLValidator()
try:
validate_url(url_string.strip())
return True
except ValidationError:
return False

print(is_string_an_url("https://example.com")) # True
print(is_string_an_url("not a url")) # False

Validierung mit Pydantic

Pydantic bietet robuste URL-Datentypen wie AnyUrl, AnyHttpUrl und HttpUrl für strukturierte Validierung mit aussagekräftigen Fehlermeldungen. Besonders nützlich in FastAPI- und Django-Projekten.

Warum Leerzeichen vor der URL-Validierung entfernen?

Selbst ein einzelnes Leerzeichen am Anfang oder Ende bringt die meisten Validierungsmethoden dazu, eine eigentlich gültige URL abzulehnen. Verwenden Sie Pythons strip()-Methode:

url = "http://localhost:8000 "
is_valid = is_string_an_url(url.strip())  # Returns True

URL-Validierung mit urllib.parse und regex

Für eine modulare Validierung kombinieren Sie Pythons urllib.parse mit gezielten regulären Ausdrücken für jede URL-Komponente: Prüfen Sie Scheme (http, https), Netloc (Domain, Subdomain, Port) und Pfad separat.

Anwendungsfälle

• Formularvalidierung: Stellen Sie sicher, dass Nutzer strukturierte URLs in Webformulare eingeben.

• Datenbereinigung: Entfernen oder korrigieren Sie fehlerhafte Links in großen Datensätzen.

• Crawler und Scraper: URLs vor dem Crawling oder Scraping prüfen.

• Sicherheitsfilterung: Verdächtige oder fehlerhafte URLs vom Speichern oder Ausführen abhalten.

Nützliche Tools:

• IP Address Regex Python Validator -- für netzwerkbasierte URL-Prüfungen

• Email Regex Python Validator -- zur Validierung von Kontaktformularen

• Password Regex Python Validator -- zur Absicherung von Nutzereingaben neben URLs

regex-Metazeichen (kategorisiert)

• ^: Trifft den Anfang der Zeichenkette

• $: Trifft das Ende der Zeichenkette

• .: Trifft jedes Zeichen (außer Zeilenumbruch)

• +: Trifft ein oder mehrere Vorkommen des vorherigen Tokens

• *: Trifft null oder mehr Vorkommen des vorherigen Tokens

• ?: Macht das vorhergehende Token optional

• []: Trifft ein beliebiges Zeichen innerhalb der Klammern

• (): Gruppiert Muster

• |: ODER-Operator

• :: Escapet Sonderzeichen wie ":"
  
  

Profi-Tipps

• Verwenden Sie in Python immer Raw Strings (r''), um Escape-Probleme zu vermeiden.

• Fügen Sie Anker ^ und $ hinzu, um die vollständige URL abzugleichen und Teilübereinstimmungen zu vermeiden.

• Verwenden Sie nicht-erfassende Gruppen (?:...) für sauberere Treffer.

• Testen Sie localhost oder benutzerdefinierte Ports mit: localhost:\d{2,5}

• Kombinieren Sie diesen Validator mit dem IP Address Regex Python Validator für APIs oder interne Tools.