Validador de URL Regex en Python

Use el Validador de URL Regex en Python para probar con precisión patrones que validen enlaces web en Python. Ya sea que verifique http, https o rutas complejas, esta herramienta garantiza que sus URLs sean limpias, correctas y confiables. Para más pruebas de regex, explore el Probador de Regex en Python, el Validador de Email Regex en Python o el Validador de Dirección IP Regex en Python.

Validador de URL Regex en Python - Documentación

¿Qué es el Validador de URL Regex en Python?

El Validador de URL Regex en Python está diseñado para ayudarle a verificar si sus expresiones regulares coinciden correctamente con direcciones web válidas. Esto incluye la verificación de:

Protocolos como http o https
Nombres de dominio y subdominios
Puertos, rutas, parámetros de consulta y fragmentos opcionales

Usa el módulo re de Python y es ideal para validación de formularios, web crawling, análisis de datos y tareas de verificación de enlaces.

Patrones Comunes de URL Regex

URL Básica HTTP/HTTPS
```
^(http|https):\/\/[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
```
Coincide con: http://example.com, https://qodex.ai
No coincide con: example.com, ftp://server.com
URL Completa con Rutas y Consultas Opcionales
```
^(http|https):\/\/[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(/[a-zA-Z0-9\-._~:/?#[\]@!$&'()*+,;=]*)?$
```
Coincide con: https://site.com/path?search=value, http://domain.org
Con Puerto Opcional
```
^(http|https):\/\/[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:\d{2,5})?(\/.*)?$
```
Coincide con: http://localhost:8000/home, https://api.site.com:443/v1

¿Qué Verifica Realmente el Regex?

Autenticación HTTP Básica: Permite opcionalmente credenciales antes del dominio.
Estructura del Dominio: Exige al menos un subdominio, acepta guiones dentro de subdominios y garantiza que cada subdominio y el dominio de nivel superior no excedan los límites de longitud.
Dominio de Nivel Superior: Solo permite caracteres alfanuméricos (sin guiones).
Soporte para Localhost: Acepta localhost como dominio válido.
Números de Puerto: Coincide opcionalmente con puertos de hasta 5 dígitos.
Direcciones IPv4: Reconoce direcciones IPv4 estándar en el netloc.
Direcciones IPv6: Para la validación de IPv6, conviene complementar con un validador dedicado de IPv6.

Manejo de Casos Complejos y Límite

Aunque los patrones regex anteriores cubren la mayoría de los casos de uso, las URLs en la práctica pueden ser complicadas, especialmente con dominios de nivel superior como .co.uk o estructuras de subdominio no convencionales. Si necesita una solución más robusta, considere un patrón regex que también permita:

Protocolo opcional (por ejemplo, http://, https:// o ninguno)
Subdominios opcionales (como www.)
Soporte para TLDs de varias partes (por ejemplo, co.uk)
Rutas, cadenas de consulta y fragmentos
Guiones en nombres de dominio

Regex Avanzado para Casos Límite

Un regex más completo puede manejar autenticación, direcciones IPv4/IPv6, localhost, números de puerto y más. Este enfoque divide la URL y valida el esquema y el dominio por separado, manejando una variedad más amplia de URLs válidas.

Alternativa: Usando Librerías de Validación

Aunque el regex es ideal para verificaciones rápidas de URL, Python tiene librerías de validación potentes que pueden ahorrarle tiempo, especialmente cuando aparecen casos límite.

Usando el Paquete `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

Consejo: Siempre elimine los espacios antes y después de la URL antes de validar, ya que incluso un espacio hará que la mayoría de los validadores rechacen la entrada.

Validación con 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

Validando URLs con Pydantic

Pydantic ofrece tipos como AnyHttpUrl para validación estricta de URLs. Este enfoque lanza excepciones para URLs inválidas y admite una variedad de tipos de URL.

AnyUrl: Acepta casi todas las URLs válidas, incluidos esquemas personalizados.
AnyHttpUrl: Restringe a URLs HTTP y HTTPS.
HttpUrl: Exige HTTP/HTTPS e incluye verificaciones de host y TLD.

Código de Ejemplo en 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

Pruebe variantes usando el Probador de Regex en Python.

Cómo Dividir y Validar una URL con `urllib.parse` y Regex

Descomponga la URL: Use urllib.parse.urlparse() para dividirla en sus partes principales: esquema, netloc, ruta, consulta y fragmento.
Valide cada componente: Aplique expresiones regulares a los componentes más importantes: esquema (http/https), netloc (dominio o IP con puerto opcional) y ruta si es necesario.
Soporte de Direcciones IP: Si sus URLs pueden contener direcciones IP, incluya patrones regex capaces de coincidir con IPv4. Para IPv6, use un validador especializado.

¿Por Qué Eliminar Espacios Antes de Validar URLs?

Antes de validar una URL, es esencial eliminar cualquier espacio al inicio o al final de la cadena. Incluso un espacio extra hará que la mayoría de los métodos de validación traten la URL como inválida.

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

Casos de Uso

Validación de Formularios: Garantice que los usuarios envíen URLs bien estructuradas en formularios web.
Limpieza de Datos: Elimine o corrija enlaces malformados en grandes conjuntos de datos.
Crawlers y Scrapers: Verifique URLs antes de rastrear o extraer contenido.
Filtrado de Seguridad: Bloquee URLs sospechosas o malformadas antes de almacenarlas o ejecutarlas.

Herramientas útiles:

Validador de Dirección IP Regex en Python: para verificaciones de URL basadas en red
Validador de Email Regex en Python: para validar formularios de contacto
Validador de Contraseña Regex en Python: para asegurar la entrada del usuario junto con URLs

Metacaracteres de Regex Categorizados

^: Coincide con el inicio de la cadena
$: Coincide con el final de la cadena
.: Coincide con cualquier carácter (excepto nueva línea)
+: Coincide con uno o más del token anterior
*: Coincide con cero o más del token anterior
?: Hace opcional el token anterior
[]: Coincide con cualquier carácter dentro de los corchetes
(): Agrupa patrones
|: Operador OR
:: Escapa caracteres especiales como ":"

Consejos Profesionales

Use siempre cadenas sin procesar (r'') en Python para evitar problemas de escape.
Agregue anclas ^ y $ para coincidir con la URL completa y evitar coincidencias parciales.
Use grupos no capturadores (?:...) para una coincidencia más limpia cuando sea necesario.
Pruebe localhost o puertos personalizados con un regex como: localhost:\d{2,5}
Combine este validador con el Validador de Dirección IP Regex en Python para APIs o herramientas internas.