Description

Ce script vise à identifier le mot-clé le plus légitime parmi un ensemble de doublons en utilisant les suggestions de Google et la distance de Levenshtein. Il attribue ensuite un tag (légitime ou variante) à chaque mot-clé du groupe.

Vous pouvez trouvez le code fonctionnel et utilisable directement depuis ce Notebook Google Colab

Dépendances

Avant d'exécuter ce script, assurez-vous d'avoir installé les bibliothèques nécessaires :

pip install requests fake_useragent pandas python-Levenshtein

Importation des modules

import requests
import json
import pandas as pd
from fake_useragent import UserAgent
from Levenshtein import distance

requests : pour effectuer des requêtes HTTP aux suggestions de Google.
json : pour parser les réponses JSON.
pandas : pour manipuler les données et afficher les résultats sous forme de tableau.
fake_useragent : pour générer un User-Agent aléatoire afin d'éviter le blocage par Google.
Levenshtein : pour calculer la distance entre les chaînes de caractères.

Définition des mots-clés à analyser

keywords = [
    "loue appartmen pari",
    "location appartement parris",
    "location appartement paris",
    "loer appartment dans paris",
    "louer appartement paris",
]

Ce tableau contient plusieurs variantes d'un même mot-clé avec des fautes typographiques et des reformulations.

Fonction pour obtenir les suggestions de Google

def get_google_suggestions(keyword):
    endpoint = f"https://suggestqueries.google.com/complete/search?output=firefox&q={keyword}&hl=fr&gl=fr"
    ua = UserAgent()
    headers = {"user-agent": ua.chrome}
    response = requests.get(endpoint, headers=headers, verify=True)
    suggestions = json.loads(response.text)
    return suggestions[1]

Cette fonction :

Effectue une requête à l'API non officielle des suggestions Google.
Génère un User-Agent aléatoire pour limiter les restrictions d'accès.
Retourne les suggestions Google associées au mot-clé donné.

Fonction de calcul de la distance de Levenshtein

def calculate_levenshtein_similarity(str1, str2):
    return distance(str1, str2)

Cette fonction calcule la distance de Levenshtein entre deux chaînes de caractères. Plus la distance est faible, plus les chaînes sont similaires.

Fonction de traitement des mots-clés

def tag_keywords(keywords):
    all_suggestions = {}
    legit_keyword = None

    # Obtenir les suggestions Google pour chaque mot-clé
    for keyword in keywords:
        suggestions = get_google_suggestions(keyword)
        all_suggestions[keyword] = suggestions

Un dictionnaire all_suggestions est créé pour stocker les suggestions Google associées à chaque mot-clé.
Chaque mot-clé est analysé et ses suggestions sont stockées.

Étape 1 : Recherche d'une correspondance exacte

    for keyword in keywords:
        if any(keyword == suggestion for suggestion in all_suggestions[keyword]):
            legit_keyword = keyword
            break

On vérifie si l'un des mots-clés figure exactement dans ses propres suggestions Google.
Si un mot-clé correspond, il est immédiatement considéré comme légitime.

Étape 2 : Utilisation de la distance de Levenshtein

Si aucun mot-clé légitime n'a été trouvé, la distance de Levenshtein, qui évalue la similarité entre deux chaînes en comptant le nombre de modifications nécessaires pour passer de l'une à l'autre, est utilisée pour identifier le plus pertinent.

    if not legit_keyword:
        min_distance = float('inf')
        for keyword in keywords:
            total_distance = 0
            for other_keyword in keywords:
                for suggestion in all_suggestions[other_keyword]:
                    total_distance += calculate_levenshtein_similarity(keyword, suggestion)
            avg_distance = total_distance / len(keywords)
            if avg_distance < min_distance:
                min_distance = avg_distance
                legit_keyword = keyword

Pour chaque mot-clé, on calcule une distance moyenne basée sur toutes les suggestions de l'ensemble.
Le mot-clé avec la plus petite distance moyenne est choisi comme légitime.

Attribution des tags et affichage des résultats

    tagged_keywords = []
    for keyword in keywords:
        tag = "légitime" if keyword == legit_keyword else "variante"
        tagged_keywords.append({"keyword": keyword, "tag": tag})

    df = pd.DataFrame(tagged_keywords)
    return df

On assigne un tag légitime au mot-clé sélectionné, et variante aux autres.
Les résultats sont organisés sous forme de DataFrame pour une meilleure lisibilité.

Exécution du script

tagged_keywords_df = tag_keywords(keywords)
tagged_keywords_df

Ce code génère et affiche un tableau indiquant quel mot-clé est considéré comme légitime et lesquels sont des variantes.

Code complet


import requests
import json
import pandas as pd
from fake_useragent import UserAgent
from Levenshtein import distance

# Fonction pour obtenir les suggestions de Google
def get_google_suggestions(keyword):
    endpoint = f"https://suggestqueries.google.com/complete/search?output=firefox&q={keyword}&hl=fr&gl=fr"
    ua = UserAgent()
    headers = {"user-agent": ua.chrome}
    response = requests.get(endpoint, headers=headers, verify=True)
    suggestions = json.loads(response.text)
    return suggestions[1]

# Fonction pour calculer la distance de Levenshtein
def calculate_levenshtein_similarity(str1, str2):
    return distance(str1, str2)

# Fonction pour traiter les mots-clés et attribuer les tags (légitime ou variant)
def tag_keywords(keywords):
    all_suggestions = {}
    legit_keyword = None

    # Obtenir les suggestions Google pour chaque mot-clé
    for keyword in keywords:
        suggestions = get_google_suggestions(keyword)
        all_suggestions[keyword] = suggestions

    # Étape 1 : Vérifier s'il y a des correspondances exactes dans les suggestions
    for keyword in keywords:
        if any(keyword == suggestion for suggestion in all_suggestions[keyword]):
            legit_keyword = keyword
            break

    # Étape 2 : Si aucun mot-clé légitime n'est trouvé, calculer la distance de Levenshtein
    if not legit_keyword:
        min_distance = float('inf')
        for keyword in keywords:
            total_distance = 0
            for other_keyword in keywords:
                for suggestion in all_suggestions[other_keyword]:
                    total_distance += calculate_levenshtein_similarity(keyword, suggestion)
            avg_distance = total_distance / len(keywords)
            if avg_distance < min_distance:
                min_distance = avg_distance
                legit_keyword = keyword

    # Attribution des tags aux mots-clés
    tagged_keywords = []
    for keyword in keywords:
        tag = "légitime" if keyword == legit_keyword else "variante"
        tagged_keywords.append({"keyword": keyword, "tag": tag})

    # Convertir en DataFrame pour l'affichage
    df = pd.DataFrame(tagged_keywords)
    return df

# Obtenir les mots-clés tagués
keywords = [
    "loue appartmen pari",
    "location appartement parris",
    "location appartement paris",
    "loer appartment dans paris",
    "louer appartement paris",
]
tagged_keywords_df = tag_keywords(keywords)
tagged_keywords_df