Qu'est-ce que le Validateur URL Regex Python ?

Le Validateur URL Regex Python est conçu pour vous aider à vérifier si vos expressions régulières correspondent correctement aux adresses web valides. Cela comprend la vérification de :

• Protocoles comme http ou https

• Noms de domaine et sous-domaines

• Ports, chemins, paramètres de requête et fragments optionnels

Il utilise le module re de Python et est idéal pour la validation de formulaires, le crawl web, l'analyse de données et les tâches de vérification de liens.

Patterns Regex URL courants

1. URL HTTP/HTTPS de base

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

   Correspond à : http://example.com, https://qodex.ai

   Ne correspond pas à : example.com, ftp://server.com

2. URL complète avec chemins et requêtes optionnels

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

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

3. Avec port optionnel

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

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

Ce que le Regex vérifie réellement

• Authentification HTTP de base : permet optionnellement les identifiants avant le domaine.

• Structure du domaine : impose au moins un sous-domaine, accepte les tirets et limite la longueur (63 caractères max par étiquette, 253 au total).

• Domaine de premier niveau : seuls les caractères alphanumériques sont autorisés.

• Support localhost : accepte localhost comme domaine valide.

• Numéros de port : ports jusqu'à 5 chiffres correspondus optionnellement.

• Adresses IPv4 : reconnaît les adresses IPv4 standard dans le netloc.

• Adresses IPv6 : pour la validation IPv6, complétez avec un validateur dédié.

Gestion des cas complexes et limites

Si vous avez besoin d'une solution plus robuste gérant les TLD comme .co.uk ou des structures de sous-domaines non conventionnelles, envisagez un pattern qui prend également en compte :

• Protocole optionnel (http://, https:// ou aucun)

• Sous-domaines optionnels (comme www.)

• TLD à plusieurs parties (par exemple co.uk)

• Chemins, chaînes de requête et fragments

• Tirets dans les noms de domaine

Alternative : bibliothèques de validation

Python dispose de puissantes bibliothèques de validation qui peuvent vous faire gagner du temps sur les cas limites.

Utilisation du package validators

import validators
print(validators.url("http://localhost:8000")) # True
print(validators.url("ftp://invalid.com")) # ValidationFailure object (evaluates to 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

Exemples

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 (after .strip())

Conseil : supprimez toujours les espaces avant et après avant de valider les URL.

Utiliser Django URLValidator

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

Validation avec Pydantic

Pydantic fournit des types URL robustes comme AnyHttpUrl, particulièrement utiles pour les modèles FastAPI et les validations de configuration :

• AnyUrl : accepte presque toutes les URL valides, y compris les schémas personnalisés.

• AnyHttpUrl : restreint aux URL HTTP et HTTPS.

• HttpUrl : exige HTTP/HTTPS, inclut des vérifications pour l'hôte et le TLD.

Exemple de code Python

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

Testez des variantes avec le Python Regex Tester.

Utiliser urllib.parse pour valider une URL

Pour une validation approfondie en Python, combinez urllib.parse avec des expressions régulières ciblées pour chaque composant :

1. Décomposez l'URL : utilisez urllib.parse.urlparse() pour séparer le schéma, le netloc, le chemin, la requête, etc.

2. Validez chaque partie : appliquez des regex sur le schéma (http/https) et le netloc (domaine valide ou IP avec port optionnel).

3. Support IPv4/IPv6 : incluez des patterns regex pour IPv4 ; pour IPv6, utilisez un validateur spécialisé.

Pourquoi supprimer les espaces avant la validation ?

Un simple espace en tête ou en fin de chaîne suffit à faire échouer la validation. Utilisez la méthode strip() de Python pour éviter les faux négatifs :

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

Cas d'utilisation

• Validation de formulaires : garantissez que les utilisateurs soumettent des URL bien structurées.

• Nettoyage de données : supprimez ou corrigez les liens malformés dans de grands jeux de données.

• Crawlers et Scrapers : vérifiez les URL avant le crawl ou le scraping.

• Filtrage de sécurité : bloquez les URL suspectes ou malformées.

Outils utiles :

• Validateur IP Address Regex Python - pour les vérifications d'URL réseau

• Validateur Email Regex Python - pour valider les formulaires de contact

• Validateur Password Regex Python - pour sécuriser les saisies utilisateurs aux côtés des URL

Métacaractères Regex

• ^ : correspond au début de la chaîne

• $ : correspond à la fin de la chaîne

• . : correspond à tout caractère (sauf saut de ligne)

• + : une ou plusieurs occurrences du token précédent

• * : zéro ou plusieurs occurrences du token précédent

• ? : rend le token précédent optionnel

• [] : correspond à l'un des caractères entre crochets

• () : groupe des patterns

• | : opérateur OU

• : : échappe les caractères spéciaux comme ":"

Conseils pratiques

• Utilisez toujours les chaînes brutes (r'') en Python pour éviter les problèmes d'échappement.

• Ajoutez les ancres ^ et $ pour correspondre à l'URL complète et éviter les correspondances partielles.

• Utilisez des groupes non capturants (?:...) pour une correspondance plus propre si nécessaire.

• Testez localhost ou les ports personnalisés avec un regex comme : localhost:\d{2,5}

• Combinez ce validateur avec le Validateur IP Address Regex Python pour les API ou outils internes.