La taille et la différence de vocabulaire sont des concepts sémantiques et linguistiques pour la linguistique mathématique et qualitative.

Par exemple, la loi de Heaps affirme que la longueur de l’article et la taille du vocabulaire sont corrélatives. Pourtant, passé un certain seuil, les mêmes mots continuent d’apparaître sans améliorer la taille du vocabulaire.

Le Word2Vec utilise le Sac Continu de Mots (CBOW) et le Skip-gram pour comprendre les mots contextuellement pertinents localement et leur distance les uns par rapport aux autres. Dans le même temps, GloVe essaie d’utiliser la factorisation matricielle avec des fenêtres contextuelles.

La loi de Zipf est une théorie complémentaire à la loi de Heaps. Il indique que les mots les plus fréquents et les deuxièmes les plus fréquents ont une différence de pourcentage régulière entre eux.

Il existe d’autres sémantiques distributionnelles et théories linguistiques dans le traitement statistique du langage naturel.

Mais la «comparaison de vocabulaire» est une méthodologie fondamentale pour les moteurs de recherche pour comprendre les «différences d’actualité», «le sujet principal du document» ou «l’expertise globale du document».

Paul Haahr de Google a déclaré qu’il compare le « vocabulaire de requête » au « vocabulaire de document ».

David C. Taylor et ses conceptions pour les domaines contextuels impliquent certains vecteurs de mots dans la recherche vectorielle pour voir quel document et quelle sous-section de document concernent davantage quoi, afin qu’un moteur de recherche puisse classer et reclasser les documents en fonction des modifications de la requête de recherche.

La comparaison des différences de vocabulaire entre le classement des pages Web sur la page de résultats des moteurs de recherche (SERP) aide les professionnels du référencement à voir quels contextes, mots simultanés et proximité de mots ils sautent par rapport à leurs concurrents.

Il est utile de voir les différences de contexte dans les documents.

Dans ce guide, le langage de programmation Python est utilisé pour rechercher sur Google et prendre des éléments SERP (extraits) pour explorer leur contenu, tokeniser et comparer leur vocabulaire les uns aux autres.

Comparez les différences de vocabulaire entre le classement des pages Web sur SERP avec Python

Comment comparer le vocabulaire des documents Web de classement avec Python ?

Pour comparer les vocabulaires de classement des documents Web (avec Python), les bibliothèques et packages utilisés du langage de programmation Python sont répertoriés ci-dessous.

  • Googlesearch est un package Python permettant d’effectuer une recherche Google avec une requête, une région, une langue, un nombre de résultats, une fréquence de requête ou des filtres de recherche sécurisés.
  • URLlib est une bibliothèque Python permettant d’analyser les URL vers le netloc, le schéma ou le chemin.
  • Les requêtes (facultatives) consistent à prendre les titres, les descriptions et les liens sur les éléments SERP (extraits).
  • Fake_useragent est un package Python permettant d’utiliser des agents utilisateurs factices et aléatoires pour empêcher les codes d’état 429.
  • Advertools est utilisé pour explorer les URL sur les résultats de recherche de la requête Google afin de prendre leur corps de texte pour le nettoyage et le traitement du texte.
  • Les pandas régulent et agrègent les données pour une analyse plus approfondie de la sémantique distributionnelle des documents sur le SERP.
  • Le kit Natural LanguageTool est utilisé pour symboliser le contenu des documents et utiliser des mots vides en anglais pour supprimer les mots vides.
  • Collections pour utiliser la méthode « Counter » pour compter l’occurrence des mots.
  • La chaîne est un module Python qui appelle toute la ponctuation dans une liste pour le nettoyage des caractères de ponctuation.

Quelles sont les étapes de comparaison des tailles de vocabulaire et du contenu entre les pages Web ?

Les étapes de comparaison de la taille du vocabulaire et du contenu entre les pages Web de classement sont répertoriées ci-dessous.

  • Importez les bibliothèques et packages Python nécessaires pour récupérer et traiter le contenu textuel des pages Web.
  • Effectuez une recherche Google pour récupérer les URL de résultats sur la SERP.
  • Explorez les URL pour récupérer leur corps de texte, qui contient leur contenu.
  • Tokenize le contenu des pages Web pour le traitement de texte dans les méthodologies NLP.
  • Supprimez les mots vides et la ponctuation pour une meilleure analyse de texte propre.
  • Comptez le nombre d’occurrences de mots dans le contenu de la page Web.
  • Construisez un cadre de données Pandas pour une analyse de texte plus approfondie et meilleure.
  • Choisissez deux URL et comparez leurs fréquences de mots.
  • Comparez la taille et le contenu du vocabulaire de l’URL choisie.

1. Importez les bibliothèques et packages Python nécessaires pour récupérer et traiter le contenu textuel des pages Web

Importez les bibliothèques et packages Python nécessaires à l’aide des commandes et méthodes « from » et « import ».

from googlesearch import search

from urllib.parse import urlparse

import requests

from fake_useragent import UserAgent

import advertools as adv

import pandas as pd

from nltk.tokenize import word_tokenize

import nltk

from collections import Counter

from nltk.corpus import stopwords

import string

nltk.download()

Utilisez « nltk.download » uniquement si vous utilisez NLTK pour la première fois. Téléchargez tous les corpus, modèles et packages. Cela ouvrira une fenêtre comme ci-dessous.

Téléchargeur NLTK

Rafraîchir la fenêtre de temps en temps ; si tout est vert, fermez la fenêtre pour que le code en cours d’exécution sur votre éditeur de code s’arrête et se termine.

Si vous n’avez pas certains modules ci-dessus, utilisez la méthode « pip install » pour les télécharger sur votre machine locale. Si vous avez un projet en environnement fermé, utilisez un environnement virtuel en Python.

2. Effectuez une recherche Google pour récupérer les URL de résultats sur les pages de résultats des moteurs de recherche

Pour effectuer une recherche Google afin de récupérer les URL de résultats sur les éléments SERP, utilisez une boucle for dans l’objet « search », qui provient du package « Googlesearch ».

serp_item_url = []

for i in search("search engine optimization", num=10, start=1, stop=10, pause=1, lang="en", country="us"):

    serp_item_url.append(i)

    print(i)

L’explication du bloc de code ci-dessus est :

  • Créez un objet de liste vide, tel que « serp_item_url ».
  • Démarrez une boucle for dans l’objet « recherche » qui indique une requête, la langue, le nombre de résultats, le premier et le dernier résultat et la restriction de pays.
  • Ajoutez tous les résultats à l’objet « serp_item_url », ce qui implique une liste Python.
  • Imprimez toutes les URL que vous avez récupérées à partir de Google SERP.

Vous pouvez voir le résultat ci-dessous.

Les URL de classement pour la requête « optimisation pour les moteurs de recherche » sont données ci-dessus.

L’étape suivante consiste à analyser ces URL pour un nettoyage plus approfondi.

Parce que si les résultats impliquent du « contenu vidéo », il ne sera pas possible d’effectuer une analyse de texte sain s’ils n’ont pas une longue description vidéo ou trop de commentaires, ce qui est un type de contenu différent.

3. Nettoyez les URL de contenu vidéo des pages Web de résultats

Pour nettoyer les URL de contenu vidéo, utilisez le bloc de code ci-dessous.

parsed_urls = []


for i in range(len(serp_item_url)):

    parsed_url = urlparse(serp_item_url[i])

    i += 1

    full_url = parsed_url.scheme + '://' + parsed_url.netloc + parsed_url.path


    if ('youtube' not in full_url and 'vimeo' not in full_url and 'dailymotion' not in full_url and "dtube" not in full_url and "sproutvideo" not in full_url and "wistia" not in full_url):

        parsed_urls.append(full_url)

Les moteurs de recherche vidéo tels que YouTube, Vimeo, Dailymotion, Sproutvideo, Dtube et Wistia sont nettoyés des URL résultantes si elles apparaissent dans les résultats.

Vous pouvez utiliser la même méthodologie de nettoyage pour les sites Web qui, selon vous, dilueront l’efficacité de votre analyse ou briseront les résultats avec leur propre type de contenu.

Par exemple, Pinterest ou d’autres sites Web à fort contenu visuel peuvent ne pas être nécessaires pour vérifier les différences de « taille de vocabulaire » entre des documents concurrents.

Explication du bloc de code ci-dessus :

  • Créez un objet tel que « parsed_urls ».
  • Créez une boucle for dans la plage de longueur du nombre d’URL de résultat récupéré.
  • Analysez les URL avec « urlparse » de « URLlib ».
  • Itérer en augmentant le nombre de « i ».
  • Récupérez l’URL complète en unissant le « schéma », « netloc » et « chemin ».
  • Effectuez une recherche avec des conditions dans l’instruction « if » avec des conditions « et » pour les domaines à nettoyer.
  • Prenez-les dans une liste avec la méthode « dict.fromkeys ».
  • Imprimez les URL à examiner.

Vous pouvez voir le résultat ci-dessous.

URL de contenu vidéo

4. Explorer les URL d’examen nettoyées pour récupérer leur contenu

Explorez les URL d’examen nettoyées pour récupérer leur contenu avec des outils publicitaires.

Vous pouvez également utiliser des requêtes avec une boucle for et une méthodologie d’ajout de liste, mais advertools est plus rapide pour l’exploration et la création de la trame de données avec la sortie résultante.

Avec les requêtes, vous récupérez et réunissez manuellement tous les éléments « p » et « heading ».

adv.crawl(examine_urls, output_file="examine_urls.jl",

          follow_links=False,

          custom_settings={"USER_AGENT": UserAgent().random,

                           "LOG_FILE": "examine_urls.log",

                           "CRAWL_DELAY": 2})

crawled_df = pd.read_json("examine_urls.jl", lines=True)

crawled_df

Explication du bloc de code ci-dessus :

  • Utilisez « adv.crawl » pour explorer l’objet « examine_urls ».
  • Créez un chemin pour les fichiers de sortie avec l’extension « jl », qui est plus petite que les autres.
  • Utilisez « follow_links=false » pour arrêter l’exploration uniquement pour les URL répertoriées.
  • Utilisez des paramètres personnalisés pour indiquer un « agent utilisateur aléatoire » et un fichier journal d’exploration si certaines URL ne répondent pas aux demandes d’exploration. Utilisez une configuration de délai d’exploration pour empêcher la possibilité d’un code d’état 429.
  • Utilisez pandas « read_json » avec le paramètre « lines=True » pour lire les résultats.
  • Appelez le « crawled_df » comme ci-dessous.

Vous pouvez voir le résultat ci-dessous.

Comparez les différences de vocabulaire entre le classement des pages Web sur SERP avec Python

Vous pouvez voir nos URL de résultats et tous leurs éléments SEO sur la page, y compris les en-têtes de réponse, les tailles de réponse et les informations de données structurées.

5. Tokéniser le contenu des pages Web pour le traitement de texte dans les méthodologies NLP

La tokenisation du contenu des pages Web nécessite de choisir la colonne « body_text » de la sortie de crawl d’advertools et d’utiliser le « word_tokenize » de NLTK.

crawled_df["body_text"][0]

La ligne de code ci-dessus appelle l’intégralité du contenu d’une des pages de résultats comme ci-dessous.

Comparez les différences de vocabulaire entre le classement des pages Web sur SERP avec Python

Pour tokeniser ces phrases, utilisez le bloc de code ci-dessous.

tokenized_words = word_tokenize(crawled_df["body_text"][0])

len(tokenized_words)

Nous avons symbolisé le contenu du premier document et vérifié le nombre de mots qu’il contenait.

Comparez les différences de vocabulaire entre le classement des pages Web sur SERP avec Python

Le premier document que nous avons tokenisé pour la requête « optimisation pour les moteurs de recherche » contient 11 211 mots. Et le contenu passe-partout est inclus dans ce nombre.

6. Supprimez les ponctuations et les mots vides du corpus

Supprimez les ponctuations et les mots vides, comme ci-dessous.


stop_words = set(stopwords.words("english"))
tokenized_words = [word for word in tokenized_words if not word.lower() in stop_words and word.lower() not in string.punctuation]

len(tokenized_words)

Explication du bloc de code ci-dessus :

  • Créez un ensemble avec les « stopwords.words (« english ») » pour inclure tous les mots vides en anglais. Les ensembles Python n’incluent pas de valeurs en double ; ainsi, nous avons utilisé un ensemble plutôt qu’une liste pour éviter tout conflit.
  • Utilisez la compréhension de liste avec les instructions « if » et « else ».
  • Utilisez la méthode «minuscule» pour comparer correctement les types de mots «Et» ou «À» à leurs versions minuscules dans la liste des mots vides.
  • Utilisez le module « chaîne » et incluez des « ponctuations ». Une note ici est que le module de chaîne peut ne pas inclure toutes les ponctuations dont vous pourriez avoir besoin. Pour ces situations, créez votre propre liste de ponctuation et remplacez ces caractères par un espace en utilisant la regex et « regex.sub ».
  • Facultativement, pour supprimer les ponctuations ou certaines autres valeurs non alphabétiques et numériques, vous pouvez utiliser la méthode « isalnum » des chaînes Python. Mais, en fonction des phrases, cela pourrait donner des résultats différents. Par exemple, « isalnum » supprimerait un mot tel que « lié au mot-clé » puisque le « – » au milieu du mot n’est pas alphanumérique. Mais, string.punctuation ne le supprimerait pas car « lié au mot-clé » n’est pas une ponctuation, même si le « – » l’est.
  • Mesurez la longueur de la nouvelle liste.

La nouvelle longueur de notre liste de mots tokenisés est « 5319 ». Elle montre que près de la moitié du vocabulaire du document est constitué de mots vides ou de ponctuations.

Cela pourrait signifier que seulement 54% des mots sont contextuels et que le reste est fonctionnel.

7. Comptez le nombre d’occurrences des mots dans le contenu des pages Web

Pour compter les occurrences des mots du corpus, l’objet « Compteur » du module « Collections » est utilisé comme ci-dessous.

counted_tokenized_words = Counter(tokenized_words)

counts_of_words_df = pd.DataFrame.from_dict(

    counted_tokenized_words, orient="index").reset_index()

counts_of_words_df.sort_values(by=0, ascending=False, inplace=True)

counts_of_words_df.head(50)

Une explication du bloc de code est ci-dessous.

  • Créez une variable telle que « counted_tokenized_words » pour impliquer les résultats de la méthode Counter.
  • Utilisez le constructeur « DataFrame » des Pandas pour construire une nouvelle trame de données à partir des résultats de la méthode Counter pour le texte tokenisé et nettoyé.
  • Utilisez la méthode « from_dict » car « Counter » donne un objet dictionnaire.
  • Utilisez « sort_values » avec « by=0 » qui signifie trier en fonction des lignes, et « ascending=False » signifie mettre la valeur la plus élevée en haut. « Inpace=True » sert à rendre permanente la nouvelle version triée.
  • Appelez les 50 premières lignes avec la méthode « head() » de pandas pour vérifier le premier aspect de la trame de données.

Vous pouvez voir le résultat ci-dessous.

nombre de mots

On ne voit pas de mot vide sur les résultats, mais quelques signes de ponctuation intéressants subsistent.

Cela se produit parce que certains sites Web utilisent des caractères différents aux mêmes fins, comme les guillemets bouclés (guillemets intelligents), les guillemets simples droits et les guillemets droits doubles.

Et le module « fonctions » du module de chaîne ne les implique pas.

Ainsi, pour nettoyer notre bloc de données, nous utiliserons une fonction lambda personnalisée comme ci-dessous.

removed_curly_quotes = "’“”"

counts_of_words_df["index"] = counts_of_words_df["index"].apply(lambda x: float("NaN") if x in removed_curly_quotes else x)

counts_of_words_df.dropna(inplace=True)

counts_of_words_df.head(50)

Explication du bloc de code :

  • Création d’une variable nommée « removed_curly_quotes » pour impliquer des guillemets simples bouclés, des guillemets doubles et des guillemets doubles droits.
  • Utilisez la fonction « appliquer » dans pandas pour vérifier toutes les colonnes avec ces valeurs possibles.
  • Utilisé la fonction lambda avec « float (« NaN ») afin que nous puissions utiliser la méthode « dropna » de Pandas.
  • Utilisez « dropna » pour supprimer toute valeur NaN qui remplace les versions spécifiques des guillemets bouclés. Ajoutez « inplace=True » pour supprimer définitivement les valeurs NaN.
  • Appelez la nouvelle version de la trame de données et vérifiez-la.

Vous pouvez voir le résultat ci-dessous.

nombre de mots df

Nous voyons les mots les plus utilisés dans le document Web de classement lié à « l’optimisation des moteurs de recherche ».

Avec la méthodologie « plot » de Panda, nous pouvons le visualiser facilement comme ci-dessous.

counts_of_words_df.head(20).plot(kind="bar",x="index", orientation="vertical", figsize=(15,10), xlabel="Tokens", ylabel="Count", colormap="viridis", table=False, grid=True, fontsize=15, rot=35, position=1, title="Token Counts from a Website Content with Punctiation", legend=True).legend(["Tokens"], loc="lower left", prop={"size":15})

Explication du bloc de code ci-dessus :

  • Utilisez la méthode head pour voir les premières valeurs significatives afin d’avoir une visualisation nette.
  • Utilisez « plot » avec l’attribut « kind » pour avoir un « bar plot ».
  • Mettez l’axe « x » avec les colonnes qui impliquent les mots.
  • Utilisez l’attribut orientation pour spécifier la direction du tracé.
  • Déterminez figsize avec un tuple qui spécifie la hauteur et la largeur.
  • Mettez les étiquettes x et y pour les noms des axes x et y.
  • Déterminez une palette de couleurs qui a une construction telle que « viridis ».
  • Déterminez la taille de la police, la rotation des étiquettes, la position des étiquettes, le titre du tracé, l’existence de la légende, le titre de la légende, l’emplacement de la légende et la taille de la légende.

Le traçage de Pandas DataFrame est un vaste sujet. Si vous souhaitez utiliser « Plotly » comme back-end de visualisation Pandas, consultez la visualisation des sujets d’actualité pour le référencement des actualités.

Vous pouvez voir le résultat ci-dessous.

Pandas DataFrame Traçage

Maintenant, nous pouvons choisir notre deuxième URL pour commencer notre comparaison de la taille du vocabulaire et de l’occurrence des mots.

8. Choisissez la deuxième URL pour comparer la taille du vocabulaire et les occurrences des mots

Pour comparer le contenu SEO précédent à un document Web concurrent, nous utiliserons le guide SEO de SEJ. Vous pouvez voir une version compressée des étapes suivies jusqu’à présent pour le deuxième article.

def tokenize_visualize(article:int):

    stop_words = set(stopwords.words("english"))

    removed_curly_quotes = "’“”"

    tokenized_words = word_tokenize(crawled_df["body_text"][article])

    print("Count of tokenized words:", len(tokenized_words))

    tokenized_words = [word for word in tokenized_words if not word.lower() in stop_words and word.lower() not in string.punctuation and word.lower() not in removed_curly_quotes]

    print("Count of tokenized words after removal punctations, and stop words:", len(tokenized_words))

    counted_tokenized_words = Counter(tokenized_words)

    counts_of_words_df = pd.DataFrame.from_dict(

    counted_tokenized_words, orient="index").reset_index()

    counts_of_words_df.sort_values(by=0, ascending=False, inplace=True)

    #counts_of_words_df["index"] = counts_of_words_df["index"].apply(lambda x: float("NaN") if x in removed_curly_quotes else x)

    counts_of_words_df.dropna(inplace=True)

    counts_of_words_df.head(20).plot(kind="bar",

    x="index",

    orientation="vertical",

    figsize=(15,10),

    xlabel="Tokens",

    ylabel="Count",

    colormap="viridis",

    table=False,

    grid=True,

    fontsize=15,

    rot=35,

    position=1,

    title="Token Counts from a Website Content with Punctiation",

    legend=True).legend(["Tokens"],

    loc="lower left",

    prop={"size":15})

Nous avons tout collecté pour la tokenisation, la suppression des mots vides, les ponctuations, le remplacement des guillemets bouclés, le comptage des mots, la construction des trames de données, le tri des trames de données et la visualisation.

Ci-dessous, vous pouvez voir le résultat.

tokeniser les résultats de la visualisation

L’article du SEJ est au huitième rang.

tokenize_visualize(8)

Le chiffre huit signifie qu’il se classe au huitième rang sur la trame de données de sortie d’exploration, égale à l’article SEJ pour le référencement. Vous pouvez voir le résultat ci-dessous.

nombre de jetons à partir du contenu du site Web et de la ponctuation

Nous voyons que les 20 mots les plus utilisés entre l’article SEJ SEO et les autres articles SEO concurrents diffèrent.

9. Créez une fonction personnalisée pour automatiser le nombre d’occurrences de mots et la visualisation des différences de vocabulaire

L’étape fondamentale pour automatiser toute tâche de référencement avec Python consiste à regrouper toutes les étapes et les nécessités sous une certaine fonction Python avec différentes possibilités.

La fonction que vous verrez ci-dessous a une instruction conditionnelle. Si vous passez un seul article, il utilise un seul appel de visualisation ; pour plusieurs, il crée des sous-parcelles en fonction du nombre de sous-parcelles.

def tokenize_visualize(articles:list, article:int=None):

     if article:

          stop_words = set(stopwords.words("english"))

          removed_curly_quotes = "’“”"

          tokenized_words = word_tokenize(crawled_df["body_text"][article])

          print("Count of tokenized words:", len(tokenized_words))

          tokenized_words = [word for word in tokenized_words if not word.lower() in stop_words and word.lower() not in string.punctuation and word.lower() not in removed_curly_quotes]

          print("Count of tokenized words after removal punctations, and stop words:", len(tokenized_words))

          counted_tokenized_words = Counter(tokenized_words)

          counts_of_words_df = pd.DataFrame.from_dict(

          counted_tokenized_words, orient="index").reset_index()

          counts_of_words_df.sort_values(by=0, ascending=False, inplace=True)

          #counts_of_words_df["index"] = counts_of_words_df["index"].apply(lambda x: float("NaN") if x in removed_curly_quotes else x)

          counts_of_words_df.dropna(inplace=True)

          counts_of_words_df.head(20).plot(kind="bar",

          x="index",

          orientation="vertical",

          figsize=(15,10),

          xlabel="Tokens",

          ylabel="Count",

          colormap="viridis",

          table=False,

          grid=True,

          fontsize=15,

          rot=35,

          position=1,

          title="Token Counts from a Website Content with Punctiation",

          legend=True).legend(["Tokens"],

          loc="lower left",

          prop={"size":15})

     

     if articles:

          source_names = []

          for i in range(len(articles)):

               source_name = crawled_df["url"][articles[i]]

               print(source_name)

               source_name = urlparse(source_name)

               print(source_name)

               source_name = source_name.netloc

               print(source_name)

               source_names.append(source_name)

          global dfs

          dfs = []

          for i in articles:

               stop_words = set(stopwords.words("english"))

               removed_curly_quotes = "’“”"

               tokenized_words = word_tokenize(crawled_df["body_text"][i])

               print("Count of tokenized words:", len(tokenized_words))

               tokenized_words = [word for word in tokenized_words if not word.lower() in stop_words and word.lower() not in string.punctuation and word.lower() not in removed_curly_quotes]

               print("Count of tokenized words after removal punctations, and stop words:", len(tokenized_words))

               counted_tokenized_words = Counter(tokenized_words)

               counts_of_words_df = pd.DataFrame.from_dict(

               counted_tokenized_words, orient="index").reset_index()

               counts_of_words_df.sort_values(by=0, ascending=False, inplace=True)

               #counts_of_words_df["index"] = counts_of_words_df["index"].apply(lambda x: float("NaN") if x in removed_curly_quotes else x)

               counts_of_words_df.dropna(inplace=True)

               df_individual = counts_of_words_df

               dfs.append(df_individual)

               

          import matplotlib.pyplot as plt

          figure, axes = plt.subplots(len(articles), 1)

          for i in range(len(dfs) + 0):

               dfs[i].head(20).plot(ax = axes[i], kind="bar",

                    x="index",

                    orientation="vertical",

                    figsize=(len(articles) * 10, len(articles) * 10),

                    xlabel="Tokens",

                    ylabel="Count",

                    colormap="viridis",

                    table=False,

                    grid=True,

                    fontsize=15,

                    rot=35,

                    position=1,

                    title= f"{source_names[i]} Token Counts",

                    legend=True).legend(["Tokens"],

                    loc="lower left",

                    prop={"size":15})

Pour garder l’article concis, je n’ajouterai pas d’explication pour ceux-ci. Néanmoins, si vous consultez les précédents didacticiels SEJ Python SEO que j’ai écrits, vous réaliserez des fonctions d’encapsulation similaires.

Utilisons-le.

tokenize_visualize(articles=[1, 8, 4])

Nous voulions prendre les premier, huitième et quatrième articles et visualiser leurs 20 premiers mots et leurs occurrences ; vous pouvez voir le résultat ci-dessous.

visualisation des 20 premiers mots

10. Comparez le nombre de mots uniques entre les documents

Comparer le nombre de mots uniques entre les documents est assez facile, grâce aux pandas. Vous pouvez vérifier la fonction personnalisée ci-dessous.

def compare_unique_word_count(articles:list):

     source_names = []

     for i in range(len(articles)):

          source_name = crawled_df["url"][articles[i]]

          source_name = urlparse(source_name)

          source_name = source_name.netloc

          source_names.append(source_name)


     stop_words = set(stopwords.words("english"))

     removed_curly_quotes = "’“”"

     i = 0

     for article in articles:

          text = crawled_df["body_text"][article]

          tokenized_text = word_tokenize(text)

          tokenized_cleaned_text = [word for word in tokenized_text if not word.lower() in stop_words if not word.lower() in string.punctuation if not word.lower() in removed_curly_quotes]

          tokenized_cleanet_text_counts = Counter(tokenized_cleaned_text)

          tokenized_cleanet_text_counts_df = pd.DataFrame.from_dict(tokenized_cleanet_text_counts, orient="index").reset_index().rename(columns={"index": source_names[i], 0: "Counts"}).sort_values(by="Counts", ascending=False)

          i += 1

          print(tokenized_cleanet_text_counts_df, "Number of unique words: ",  tokenized_cleanet_text_counts_df.nunique(), "Total contextual word count: ", tokenized_cleanet_text_counts_df["Counts"].sum(), "Total word count: ", len(tokenized_text))

compare_unique_word_count(articles=[1, 8, 4])

Le résultat est ci-dessous.

Le bas du résultat affiche le nombre de valeurs uniques, qui indique le nombre de mots uniques dans le document.

www.wordstream.com compte

16 Google 71

82 Référencement 66

186 recherche 43

228 emplacement 28

274 page 27

… … …

510 balisage/structuré 1

1 Récent 1

514 erreur 1

515 bas 1

1024 LinkedIn 1

[1025 rows x 2 columns] Nombre de mots uniques :

www.wordstream.com 1025

Compte 24

dtype : int64 Nombre total de mots contextuels : 2399 Nombre total de mots : 4918

www.searchenginejournal.com compte

9 Référencement 93

242 recherche 25

64 Guide 23

40 Contenu 17

13Google 17

.. … …

229 Action 1

228 Déplacement 1

227 agile 1

226 32 1

465 nouvelles 1

[466 rows x 2 columns] Nombre de mots uniques :

www.searchenginejournal.com 466

Compte 16

dtype : int64 Nombre total de mots contextuels : 1019 Nombre total de mots : 1601

compte blog.hubspot.com

166 Référencement 86

160 recherche 76

32 contenu 46

368 page 40

327 liens 39

… … …

695 idée 1

697 parlé 1

698 plus tôt 1

699 Analyse 1

1326 Sécurité 1

[1327 rows x 2 columns] Nombre de mots uniques :

blog.hubspot.com 1327

Compte 31

dtype : int64 Nombre total de mots contextuels : 3418 Nombre total de mots : 6728

Il y a 1025 mots uniques sur 2399 mots contextuels sans mots vides et sans ponctuation. Le nombre total de mots est de 4918.

Les cinq mots les plus utilisés sont « Google », « SEO », « recherche », « site » et « page » pour « Wordstream ». Vous pouvez voir les autres avec les mêmes numéros.

11. Comparez les différences de vocabulaire entre les documents sur le SERP

L’audit des mots distinctifs qui apparaissent dans les documents concurrents vous aide à voir où le document pèse le plus et comment il crée une différence.

La méthodologie est simple : le type d’objet « ensemble » a une méthode « différence » pour afficher les différentes valeurs entre deux ensembles.

def audit_vocabulary_difference(articles:list):

     stop_words = set(stopwords.words("english"))

     removed_curly_quotes = "’“”"

     global dfs

     global source_names

     source_names = []

     for i in range(len(articles)):

          source_name = crawled_df["url"][articles[i]]

          source_name = urlparse(source_name)

          source_name = source_name.netloc

          source_names.append(source_name)

     i = 0

     dfs = []

     for article in articles:

               text = crawled_df["body_text"][article]

               tokenized_text = word_tokenize(text)

               tokenized_cleaned_text = [word for word in tokenized_text if not word.lower() in stop_words if not word.lower() in string.punctuation if not word.lower() in removed_curly_quotes]

               tokenized_cleanet_text_counts = Counter(tokenized_cleaned_text)

               tokenized_cleanet_text_counts_df = pd.DataFrame.from_dict(tokenized_cleanet_text_counts, orient="index").reset_index().rename(columns={"index": source_names[i], 0: "Counts"}).sort_values(by="Counts", ascending=False)

               tokenized_cleanet_text_counts_df.dropna(inplace=True)

               i += 1

               df_individual = tokenized_cleanet_text_counts_df

               dfs.append(df_individual)

     global vocabulary_difference

     vocabulary_difference = []

     for i in dfs:

          vocabulary = set(i.iloc[:, 0].to_list())

          vocabulary_difference.append(vocabulary)

     print( "Words that appear on :", source_names[0], "but not on: ", source_names[1], "are below: n", vocabulary_difference[0].difference(vocabulary_difference[1]))

Pour rester concis, je n’expliquerai pas les lignes de fonction une par une, mais en gros, nous prenons les mots uniques dans plusieurs articles et les comparons les uns aux autres.

Vous pouvez voir le résultat ci-dessous.

Les mots qui apparaissent sur : www.techtarget.com mais pas sur : moz.com sont ci-dessous :

Comparez les différences de vocabulaire entre le classement des pages Web sur SERP avec Python

Utilisez la fonction personnalisée ci-dessous pour voir à quelle fréquence ces mots sont utilisés dans le document spécifique.

def unique_vocabulry_weight():

     audit_vocabulary_difference(articles=[3, 1])

vocabulary_difference_list = vocabulary_difference_df[0].to_list()

     return dfs[0][dfs[0].iloc[:, 0].isin(vocabulary_difference_list)]

unique_vocabulry_weight()

Les résultats sont ci-dessous.

Comparez les différences de vocabulaire entre le classement des pages Web sur SERP avec Python

La différence de vocabulaire entre TechTarget et Moz pour la requête « optimisation pour les moteurs de recherche » du point de vue de TechTarget est ci-dessus. Nous pouvons l’inverser.

def unique_vocabulry_weight():

audit_vocabulary_difference(articles=[1, 3])

vocabulary_difference_list = vocabulary_difference_df[0].to_list()

return dfs[0][dfs[0].iloc[:, 0].isin(vocabulary_difference_list)]

unique_vocabulry_weight()

Changer l’ordre des nombres. Vérifiez d’un autre point de vue.

Moz compte les résultats

Vous pouvez voir que Wordstream a 868 mots uniques qui n’apparaissent pas sur Boosmart, et les cinq premiers et les cinq derniers sont donnés ci-dessus avec leurs occurrences.

L’audit des différences de vocabulaire peut être amélioré avec une « fréquence pondérée » en vérifiant les informations de la requête et le réseau.

Mais, à des fins pédagogiques, il s’agit déjà d’un cours intensif Python, Data Science et SEO lourd, détaillé et avancé.

Rendez-vous dans les prochains guides et tutoriels.

Davantage de ressources:

  • Utilisation de Python + Streamlit pour trouver des opportunités de mots-clés à distance frappante
  • Quelle est la différence entre les requêtes de recherche et les mots clés ?
  • Référencement technique avancé : un guide complet

Image en vedette : VectorMine/Shutterstock

LAISSER UN COMMENTAIRE

S'il vous plaît entrez votre commentaire!
S'il vous plaît entrez votre nom ici