O que é o Validador de URL Regex em Python?

O Validador de URL Regex em Python foi projetado para ajudá-lo a verificar se suas expressões regulares correspondem corretamente a endereços web válidos. Isso inclui verificar:

• Protocolos como http ou https

• Nomes de domínio e subdomínios

• Portas opcionais, caminhos, parâmetros de query e fragmentos

Usa o módulo re do Python e é ideal para validação de formulários, rastreamento web, análise de dados e tarefas de verificação de links.

Padrões Comuns de URL Regex

1. URL HTTP/HTTPS Básica

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

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

   Não corresponde: example.com, ftp://server.com

2. URL Completa com Caminhos e Queries Opcionais

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

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

3. Com Porta Opcional

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

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

O que o Regex Verifica?

• Autenticação HTTP Básica: Permite opcionalmente credenciais antes do domínio.

• Estrutura de Domínio: Exige pelo menos um subdomínio, aceita hifens dentro de subdomínios e garante limites de comprimento (máx. 63 caracteres cada, domínio completo abaixo de 253).

• Domínio de Nível Superior: Permite apenas caracteres alfanuméricos (sem hifens).

• Suporte a Localhost: Aceita localhost como domínio válido.

• Números de Porta: Corresponde opcionalmente a portas de até 5 dígitos.

• Endereços IPv4: Reconhece endereços IPv4 padrão no netloc.

• Endereços IPv6: Para validação IPv6, complemente com um validador dedicado, pois o regex sozinho pode não cobrir todos os casos extremos.

Tratando Casos Complexos e Extremos

Embora os padrões acima cubram a maioria dos casos de uso, URLs do mundo real podem ser complicadas, especialmente com TLDs como .co.uk ou estruturas incomuns de subdomínio. Para uma solução mais robusta, considere um padrão que também permita:

• Protocolo opcional (por exemplo, http://, https:// ou nenhum)

• Subdomínios opcionais (como www.)

• Suporte a TLDs com múltiplas partes (por exemplo, co.uk)

• Caminhos, query strings e fragmentos

• Hifens em nomes de domínio

Casos de Teste

Uma abordagem mais flexível corresponderá a uma variedade de URLs do mundo real:

• http://www.google.com

• https://google.co.uk

• google.com/~user/profile

• https://sub.domain.co.uk/path/to/page

Alternativa: Usando Bibliotecas de Validação

Embora regex seja ótimo para verificações rápidas de URL, o Python possui algumas bibliotecas poderosas que podem economizar tempo.

Usando o Pacote 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:
# Always strip whitespace before validating!
result = validators.url(url_string.strip())
return result is True  # Only True is valid; ValidationFailure is falsy

Dica: Sempre remova espaços em branco antes de validar URLs, pois até um único espaço fará com que a maioria dos validadores rejeite a entrada.

Validação com o URLValidator do Django

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

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

Experimente variações usando o Testador de Regex Python.

Usando Pydantic para Validação Estruturada

O Pydantic fornece tipos de URL robustos prontos para uso:

• AnyUrl: Aceita praticamente todas as URLs válidas, incluindo esquemas personalizados.

• AnyHttpUrl: Restringe a URLs HTTP e HTTPS.

• HttpUrl: Exige HTTP/HTTPS, inclui verificações de host e TLD.

Por que Remover Espaços em Branco Antes da Validação?

Antes de validar uma URL, é essencial remover espaços no início ou no final da string. Mesmo um espaço extra fará com que a maioria dos métodos de validação trate a URL como inválida.

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

Validando com urllib.parse e Regex

Para validação completa, combine urllib.parse.urlparse() com regex direcionado para cada componente da URL:

1. Decompor a URL em esquema, netloc, caminho, etc.

2. Validar cada parte com regex específico.

3. Suporte a IP: inclua padrões para IPv4; para IPv6 use um validador especializado.

Casos de Uso

• Validação de Formulários: Garanta que os usuários enviem URLs bem estruturadas em formulários web.

• Limpeza de Dados: Remova ou corrija links malformados em grandes conjuntos de dados.

• Crawlers e Scrapers: Verifique URLs antes de rastrear ou extrair conteúdo.

• Filtragem de Segurança: Bloqueie URLs suspeitas ou malformadas de serem armazenadas ou executadas.

Ferramentas úteis:

• Validador de IP Regex em Python - para verificações de URL baseadas em rede

• Validador de Email Regex em Python - para validar formulários de contato

• Validador de Senha Regex em Python - ao proteger entradas de usuário junto com URLs

Metacaracteres Regex Categorizados

• ^: Corresponde ao início da string

• $: Corresponde ao final da string

• .: Corresponde a qualquer caractere (exceto nova linha)

• +: Corresponde a um ou mais do token anterior

• *: Corresponde a zero ou mais do token anterior

• ?: Torna o token anterior opcional

• []: Corresponde a qualquer caractere dentro dos colchetes

• (): Agrupa padrões

• |: Operador OR

• :: Escapa caracteres especiais como ":"

Dicas Profissionais

• Sempre use strings raw (r'') em Python para evitar problemas de escape.

• Adicione âncoras ^ e $ para corresponder à URL completa e evitar correspondências parciais.

• Use grupos não capturadores (?:...) para correspondência mais limpa, se necessário.

• Teste localhost ou portas personalizadas usando um regex como: localhost:\d{2,5}

• Combine este validador com o Validador de IP Regex em Python para APIs ou ferramentas internas.