La méthode en 4 étapes
Le traitement le plus fiable suit cette séquence :
- Repérer les chaînes commençant par
http://ouhttps://. - Retirer les caractères ajoutés par le texte, comme un point ou une parenthèse fermante.
- Valider les URL avec un parseur dédié.
- Supprimer les doublons en conservant l’ordre d’apparition.
Une URL peut contenir un schéma, un domaine, un chemin, des paramètres de requête et un fragment. Cette structure est décrite par la RFC 3986.
Extraire les URL avec une expression régulière
Pour un texte courant, une expression régulière permet de repérer rapidement les URL absolues :
import re
texte = """
Consultez https://example.com/article.
La documentation est disponible sur https://docs.example.com/page?q=1.
"""
candidats = re.findall(r'https?://[^\s<>"\']+', texte)
print(candidats)
Le résultat peut contenir la ponctuation placée après le lien :
[
"https://example.com/article.",
"https://docs.example.com/page?q=1."
]
Nettoyer la ponctuation finale
Retirez les signes qui ne font généralement pas partie de l’URL :
URLS_PONCTUATION = ".,;:!?)]}"
urls_nettoyees = [
url.rstrip(URLS_PONCTUATION)
for url in candidats
]
print(urls_nettoyees)
Ce nettoyage est pratique, mais il ne remplace pas une validation complète. Certaines URL peuvent notamment contenir des parenthèses légitimes.
Valider les URL extraites
En Python, urllib.parse.urlsplit() sépare les composants d’une URL. Le module analyse la chaîne, mais ne garantit pas à lui seul que le site existe ou qu’il est accessible.
from urllib.parse import urlsplit
def est_url_http_valide(url):
try:
resultat = urlsplit(url)
return (
resultat.scheme in {"http", "https"}
and bool(resultat.netloc)
)
except ValueError:
return False
urls_valides = [
url for url in urls_nettoyees
if est_url_http_valide(url)
]
Cette vérification limite les résultats aux URL HTTP et HTTPS et exige la présence d’un domaine ou d’une autorité.
Supprimer les doublons en conservant l’ordre
La méthode recommandée en Python
Pour supprimer les répétitions exactes sans modifier l’ordre d’apparition, utilisez dict.fromkeys() :
urls = [
"https://example.com",
"https://example.com",
"https://example.com/page"
]
urls_uniques = list(dict.fromkeys(urls))
print(urls_uniques)
Résultat :
[
"https://example.com",
"https://example.com/page"
]
Pourquoi éviter un simple set ?
Cette instruction supprime également les doublons :
urls_uniques = list(set(urls_valides))
En revanche, elle ne doit pas être utilisée si l’ordre de présentation est important. En JavaScript, un objet Set conserve l’ordre d’insertion et stocke une seule occurrence de chaque valeur. Voir la documentation MDN de Set.
Script Python complet
Voici une fonction prête à utiliser pour extraire les URL d’un texte, les valider et les dédoublonner :
import re
from urllib.parse import urlsplit
URLS_PONCTUATION = ".,;:!?)]}"
def extraire_urls(texte):
candidats = re.findall(
r'https?://[^\s<>"\']+',
texte
)
urls_valides = []
for candidat in candidats:
url = candidat.rstrip(URLS_PONCTUATION)
try:
composants = urlsplit(url)
if (
composants.scheme in {"http", "https"}
and composants.netloc
):
urls_valides.append(url)
except ValueError:
continue
return list(dict.fromkeys(urls_valides))
texte = """
Voir https://example.com,
puis https://example.com/page.
Le lien https://example.com est répété.
"""
for url in extraire_urls(texte):
print(url)
Sortie :
https://example.com
https://example.com/page
Gérer les liens relatifs
Une chaîne comme /docs/guide n’est pas une URL absolue. Il faut une URL de base pour la compléter avec urljoin() :
from urllib.parse import urljoin
base = "https://example.com/section/"
lien_relatif = "../docs/guide"
url_complete = urljoin(base, lien_relatif)
print(url_complete)
Résultat :
https://example.com/docs/guide
En JavaScript, le constructeur URL permet également de résoudre une URL relative avec une base.
Cas du HTML et du Markdown
HTML
Si le contenu est du HTML, recherchez de préférence les attributs href des balises de lien :
<a href="https://example.com/page">Voir la page</a>
L’URL peut être absente du texte visible, mais présente dans l’attribut href. Un parseur HTML est donc plus adapté qu’une expression régulière généraliste.
Markdown
Pour un lien Markdown, il faut traiter la structure suivante :
[Voir la page](https://example.com/page)
Une expression régulière peut convenir aux cas simples, mais un parseur Markdown sera plus fiable pour gérer toutes les variantes.
Faut-il normaliser les URL avant de les dédoublonner ?
Par défaut, privilégiez la déduplication exacte. Les URL suivantes doivent alors être considérées comme différentes :
https://example.com/page
https://example.com/page?utm_source=newsletter
La seconde contient un paramètre qui peut avoir une fonction réelle pour le serveur ou l’application.
Une déduplication normalisée peut toutefois être pertinente si vous définissez clairement vos règles, par exemple :
- mettre le schéma et le domaine en minuscules ;
- supprimer les fragments comme
#sectionsi seule la page compte ; - retirer certains paramètres de suivi connus ;
- résoudre les URL relatives avec une URL de base.
Le standard URL WHATWG décrit les règles modernes d’analyse et de normalisation utilisées par les navigateurs. N’appliquez pas de normalisation automatique sans avoir défini l’objectif métier.
À retenir
- Une expression régulière repère rapidement les URL, mais ne les valide pas complètement.
- Nettoyez la ponctuation avant la validation.
- Utilisez
urlsplit()pour vérifier la présence d’un schéma HTTP(S) et d’un domaine. - Utilisez
list(dict.fromkeys(urls))pour supprimer les doublons tout en conservant l’ordre. - Adaptez la méthode au format : texte brut, HTML, Markdown ou liens relatifs.