Python est un excellent outil pour automatiser les tâches répétitives ainsi que pour obtenir des informations supplémentaires sur les données.
Dans cet article, vous apprendrez à créer un outil pour vérifier quels mots clés sont proches du classement dans les positions un à trois et vous indiquera s’il est possible d’intégrer naturellement ces mots clés dans la page.
Il est parfait pour les débutants et les professionnels de Python et constitue une excellente introduction à l’utilisation de Python pour le référencement.
Si vous souhaitez simplement rester coincé, une application Streamlit pratique est disponible pour le code. Ceci est simple à utiliser et ne nécessite aucune expérience de codage.
Il existe également une feuille de collaboration Google si vous souhaitez vous familiariser avec le code. Si vous pouvez explorer un site Web, vous pouvez utiliser ce script !
Voici un exemple de ce que nous allons faire aujourd’hui :
Ces mots clés se retrouvent dans le titre de la page et H1, mais ne pas dans la copie. L’ajout naturel de ces mots-clés à la copie existante serait un moyen simple d’augmenter la pertinence de ces mots-clés.
En prenant l’indice des moteurs de recherche et en incluant naturellement tous les mots-clés manquants pour lesquels un site se classe déjà, nous augmentons la confiance des moteurs de recherche pour classer ces mots-clés plus haut dans les SERPs.
Ce rapport peut être créé manuellement, mais cela prend beaucoup de temps.
Nous allons donc automatiser le processus à l’aide d’un script SEO Python.
Aperçu de la sortie
Voici un exemple de ce à quoi ressemblera le résultat final après l’exécution du rapport :
Le résultat final prend les cinq meilleures opportunités par volume de recherche pour chaque page et les place soigneusement horizontalement avec le volume de recherche estimé.
Il indique également le volume de recherche total de tous les mots-clés d’une page à portée de main, ainsi que le nombre total de mots-clés à portée.
Les cinq premiers mots-clés par volume de recherche sont ensuite vérifiés pour voir s’ils se trouvent dans le titre, H1 ou copie, puis marqués VRAI ou FAUX.
C’est idéal pour trouver des gains rapides ! Ajoutez simplement le mot-clé manquant naturellement dans la copie de la page, le titre ou le H1.
Commencer
La configuration est assez simple. Nous avons juste besoin d’une analyse du site (idéalement avec une extraction personnalisée pour la copie que vous souhaitez vérifier) et d’un fichier exporté de tous les mots-clés pour lesquels un site est classé.
Cet article vous guidera à travers la configuration, le code et un lien vers une feuille Google Colaboratory si vous souhaitez simplement rester coincé sans le coder vous-même.
Pour commencer, vous aurez besoin de :
- Une exploration du site Web.
- Une exportation de tous les mots-clés pour lesquels un site est classé.
- Cette feuille Google Colab ou cette application Streamlit pour mélanger les données de crawl et de mots-clés
Nous l’avons nommé le rapport de distance de frappe car il signale les mots-clés qui sont facilement à distance de frappe.
(Nous avons défini la distance de frappe comme des mots-clés qui se classent dans les positions 4 à 20, mais nous en avons fait une option configurable au cas où vous voudriez définir vos propres paramètres.)
Rapport de référencement à distance frappante : mise en route
1. Explorer le site Web cible
- Définissez un extracteur personnalisé pour la copie de page (facultatif, mais recommandé).
- Filtrez les pages de pagination du crawl.
2. Exportez tous les mots clés Le site se classe pour l’utilisation de votre fournisseur préféré
- Filtrez les mots clés qui se déclenchent en tant que lien de site.
- Supprimez les mots clés qui se déclenchent en tant qu’image.
- Filtrez les mots-clés de marque.
- Utilisez les deux exportations pour créer un rapport exploitable sur la distance de frappe à partir du mot-clé et analyser les données avec Python.
Explorer le site
J’ai choisi d’utiliser Screaming Frog pour obtenir le crawl initial. N’importe quel robot d’exploration fonctionnera, tant que l’exportation CSV utilise les mêmes noms de colonne ou qu’ils sont renommés pour correspondre.
Le script s’attend à trouver les colonnes suivantes dans l’exportation CSV d’exploration :
"Address", "Title 1", "H1-1", "Copy 1", "Indexability"
Paramètres d’exploration
La première chose à faire est de se diriger vers les principaux paramètres de configuration dans Screaming Frog :
Configuration > Araignée > Explorer
Les principaux paramètres à utiliser sont :
Explorer les liens internes, canoniques, et le Pagination (Rel Next/Prev) paramètre.
(Le script fonctionnera avec tout ce qui est sélectionné, mais l’exploration prendra plus de temps !)
Ensuite, c’est au Extraction languette.
Configuration > Araignée > Extraction
Au minimum, nous devons extraire le titre de la page, H1, et calculer si la page est indexable, comme indiqué ci-dessous.
L’indexabilité est utile car c’est un moyen facile pour le script d’identifier les URL à déposer en une seule fois, ne laissant que les mots-clés éligibles au classement dans les SERP.
Si le script ne trouve pas la colonne d’indexabilité, il fonctionnera toujours normalement mais ne fera pas la différence entre les pages qui peuvent et ne peuvent pas être classées.
Définition d’un extracteur personnalisé pour la copie de page
Afin de vérifier si un mot-clé se trouve dans la copie de la page, nous devons définir un extracteur personnalisé dans Screaming Frog.
Configuration > Personnalisé > Extraction
Nommez l’extracteur « Copier » comme indiqué ci-dessous.
Important: Le script s’attend à ce que l’extracteur s’appelle « Copier » comme ci-dessus, veuillez donc revérifier !
Enfin, assurez-vous Extraire le texte est sélectionné pour exporter la copie sous forme de texte, plutôt que HTML.
Il existe de nombreux guides sur l’utilisation d’extracteurs personnalisés en ligne si vous avez besoin d’aide pour en configurer un, donc je n’y reviendrai pas ici.
Une fois l’extraction définie, il est temps d’explorer le site et d’exporter le fichier HTML au format CSV.
Exportation du fichier CSV
L’exportation du fichier CSV est aussi simple que de changer le menu déroulant affiché sous Interne en HTML et en appuyant sur le bouton Exporter.
Interne > HTML > Exporter
Après avoir cliqué ExporterIl est important de s’assurer que le type est défini sur le format CSV.
L’écran d’exportation devrait ressembler à ce qui suit :
Astuce 1 : Filtrage des pages de pagination
Je vous recommande de filtrer les pages de pagination de votre crawl soit en sélectionnant Respecter Suivant/Précédent sous le Avancé paramètres (ou simplement en les supprimant du fichier CSV, si vous préférez).
Astuce 2 : Enregistrer les paramètres d’exploration
Une fois que vous avez configuré le crawl, cela vaut simplement la peine de sauvegarder les paramètres de crawl (qui se souviendront également de l’extraction personnalisée).
Cela vous fera gagner beaucoup de temps si vous souhaitez réutiliser le script à l’avenir.
Fichier > Configuration > Enregistrer sous
Exporter des mots-clés
Une fois que nous avons le fichier d’analyse, l’étape suivante consiste à charger votre outil de recherche de mots clés préféré et à exporter tous les mots clés pour lesquels un site se classe.
L’objectif ici est d’exporter tous les mots-clés pour lesquels un site se classe, en filtrant les mots-clés de marque et ceux qui se sont déclenchés en tant que lien de site ou image.
Pour cet exemple, j’utilise le rapport sur les mots-clés organiques dans Ahrefs, mais cela fonctionnera aussi bien avec Semrush si c’est votre outil préféré.
Dans Ahrefs, entrez le domaine que vous souhaitez enregistrer Explorateur de sites et choisissez Mots clés organiques.
Explorateur de site > Mots-clés organiques
Cela fera apparaître tous les mots-clés pour lesquels le site est classé.
Filtrage des liens de site et des liens d’image
L’étape suivante consiste à filtrer tous les mots clés déclenchés en tant que lien annexe ou pack d’images.
La raison pour laquelle nous devons filtrer les liens annexes est qu’ils n’ont aucune influence sur le classement de l’URL parent. En effet, seule la page parent est techniquement classée pour le mot-clé, et non les URL de lien de site affichées en dessous.
Le filtrage des liens annexes garantira que nous optimisons la bonne page.
Voici comment le faire dans Ahrefs.
Enfin, je recommande de filtrer tous les mots-clés de marque. Vous pouvez le faire en filtrant directement la sortie CSV, ou en pré-filtrant dans l’outil de mots-clés de votre choix avant l’exportation.
Enfin, lors de l’exportation, assurez-vous de choisir Exportation complète et le UTF-8 format comme indiqué ci-dessous.
Par défaut, le script fonctionne avec les exportations de mots-clés Ahrefs (v1/v2) et Semrush. Il peut fonctionner avec n’importe quel fichier CSV de mots clés tant que les noms de colonne attendus par le script sont présents.
Traitement
Les instructions suivantes concernent l’exécution d’une feuille Google Colaboratory pour exécuter le code.
Il existe désormais une option plus simple pour ceux qui la préfèrent sous la forme d’une application Streamlit. Suivez simplement les instructions fournies pour télécharger votre fichier d’exploration et de mots clés.
Maintenant que nous avons nos fichiers exportés, il ne reste plus qu’à les uploader sur la feuille Google Colaboratory pour traitement.
Sélectionner Exécution > Exécuter tout dans la barre de navigation supérieure pour exécuter toutes les cellules de la feuille.
Le script vous invitera à télécharger d’abord le mot-clé CSV depuis Ahrefs ou Semrush, puis le fichier d’analyse.
C’est ça! Le script téléchargera automatiquement un fichier CSV exploitable que vous pourrez utiliser pour optimiser votre site.
Une fois que vous êtes familiarisé avec l’ensemble du processus, l’utilisation du script est vraiment simple.
Répartition et explication du code
Si vous apprenez Python pour le référencement et que vous êtes intéressé par ce que fait le code pour produire le rapport, restez dans les parages pour la procédure pas à pas !
Installer les bibliothèques
Installons des pandas pour lancer le bal.
!pip install pandas
Importer les modules
Ensuite, nous devons importer les modules requis.
import pandas as pd from pandas import DataFrame, Series from typing import Union from google.colab import files
Définir les variables
Il est maintenant temps de définir les variables.
Le script considère tous les mots-clés entre les positions quatre et 20 comme à distance de frappe.
Changer les variables ici vous permettra de définir votre propre plage si vous le souhaitez. Cela vaut la peine d’expérimenter les paramètres pour obtenir le meilleur résultat possible pour vos besoins.
# set all variables here min_volume = 10 # set the minimum search volume min_position = 4 # set the minimum position / default = 4 max_position = 20 # set the maximum position / default = 20 drop_all_true = True # If all checks (h1/title/copy) are true, remove the recommendation (Nothing to do) pagination_filters = "filterby|page|p=" # filter patterns used to detect and drop paginated pages
Télécharger le fichier CSV d’exportation de mots clés
L’étape suivante consiste à lire la liste des mots-clés du fichier CSV.
Il est paramétré pour accepter un rapport Ahrefs (V1 et V2) ainsi qu’un export Semrush.
Ce code lit le fichier CSV dans un Pandas DataFrame.
upload = files.upload()
upload = list(upload.keys())[0]
df_keywords = pd.read_csv(
(upload),
error_bad_lines=False,
low_memory=False,
encoding="utf8",
dtype={
"URL": "str",
"Keyword": "str",
"Volume": "str",
"Position": int,
"Current URL": "str",
"Search Volume": int,
},
)
print("Uploaded Keyword CSV File Successfully!")
Si tout s’est déroulé comme prévu, vous verrez un aperçu du DataFrame créé à partir de l’exportation CSV du mot-clé.
Télécharger le fichier CSV d’exportation d’exploration
Une fois les mots-clés importés, il est temps de télécharger le fichier de crawl.
This fairly simple piece of code reads in the crawl with some error handling option and creates a Pandas DataFrame named df_crawl.
upload = files.upload()
upload = list(upload.keys())[0]
df_crawl = pd.read_csv(
(upload),
error_bad_lines=False,
low_memory=False,
encoding="utf8",
dtype="str",
)
print("Uploaded Crawl Dataframe Successfully!")
Une fois le téléchargement du fichier CSV terminé, vous verrez un aperçu du DataFrame.
Nettoyer et standardiser les données de mots-clés
L’étape suivante consiste à renommer les noms de colonne pour assurer la normalisation entre les types d’exportation de fichiers les plus courants.
Essentiellement, nous mettons le mot-clé DataFrame dans un bon état et filtrons à l’aide de seuils définis par les variables.
df_keywords.rename(
columns={
"Current position": "Position",
"Current URL": "URL",
"Search Volume": "Volume",
},
inplace=True,
)
# keep only the following columns from the keyword dataframe
cols = "URL", "Keyword", "Volume", "Position"
df_keywords = df_keywords.reindex(columns=cols)
try:
# clean the data. (v1 of the ahrefs keyword export combines strings and ints in the volume column)
df_keywords["Volume"] = df_keywords["Volume"].str.replace("0-10", "0")
except AttributeError:
pass
# clean the keyword data
df_keywords = df_keywords[df_keywords["URL"].notna()] # remove any missing values
df_keywords = df_keywords[df_keywords["Volume"].notna()] # remove any missing values
df_keywords = df_keywords.astype({"Volume": int}) # change data type to int
df_keywords = df_keywords.sort_values(by="Volume", ascending=False) # sort by highest vol to keep the top opportunity
# make new dataframe to merge search volume back in later
df_keyword_vol = df_keywords[["Keyword", "Volume"]]
# drop rows if minimum search volume doesn't match specified criteria
df_keywords.loc[df_keywords["Volume"] < min_volume, "Volume_Too_Low"] = "drop"
df_keywords = df_keywords[~df_keywords["Volume_Too_Low"].isin(["drop"])]
# drop rows if minimum search position doesn't match specified criteria
df_keywords.loc[df_keywords["Position"] <= min_position, "Position_Too_High"] = "drop"
df_keywords = df_keywords[~df_keywords["Position_Too_High"].isin(["drop"])]
# drop rows if maximum search position doesn't match specified criteria
df_keywords.loc[df_keywords["Position"] >= max_position, "Position_Too_Low"] = "drop"
df_keywords = df_keywords[~df_keywords["Position_Too_Low"].isin(["drop"])]
Nettoyer et standardiser les données de crawl
Ensuite, nous devons nettoyer et standardiser les données de crawl.
Essentiellement, nous utilisons la réindexation pour ne conserver que les colonnes « Adresse », « Indexabilité », « Titre de la page », « H1-1 » et « Copie 1 », en supprimant le reste.
Nous utilisons la colonne pratique « Indexabilité » pour ne conserver que les lignes indexables. Cela supprimera les URL canonisées, les redirections, etc. Je recommande d’activer cette option dans le crawl.
Enfin, nous normalisons les noms de colonne afin qu’ils soient un peu plus agréables à utiliser.
# keep only the following columns from the crawl dataframe
cols = "Address", "Indexability", "Title 1", "H1-1", "Copy 1"
df_crawl = df_crawl.reindex(columns=cols)
# drop non-indexable rows
df_crawl = df_crawl[~df_crawl["Indexability"].isin(["Non-Indexable"])]
# standardise the column names
df_crawl.rename(columns={"Address": "URL", "Title 1": "Title", "H1-1": "H1", "Copy 1": "Copy"}, inplace=True)
df_crawl.head()
Grouper les mots-clés
À l’approche de la sortie finale, il est nécessaire de regrouper nos mots-clés pour calculer l’opportunité totale pour chaque page.
Ici, nous calculons le nombre de mots-clés à portée de frappe pour chaque page, ainsi que le volume de recherche combiné.
# groups the URLs (remove the dupes and combines stats)
# make a copy of the keywords dataframe for grouping - this ensures stats can be merged back in later from the OG df
df_keywords_group = df_keywords.copy()
df_keywords_group["KWs in Striking Dist."] = 1 # used to count the number of keywords in striking distance
df_keywords_group = (
df_keywords_group.groupby("URL")
.agg({"Volume": "sum", "KWs in Striking Dist.": "count"})
.reset_index()
)
df_keywords_group.head()
Une fois terminé, vous verrez un aperçu du DataFrame.
Afficher les mots-clés dans les lignes adjacentes
Nous utilisons les données groupées comme base pour le résultat final. Nous utilisons Pandas.unstack pour remodeler le DataFrame afin d’afficher les mots-clés dans le style d’une exportation GrepWords.
# create a new df, combine the merged data with the original data. display in adjacent rows ala grepwords
df_merged_all_kws = df_keywords_group.merge(
df_keywords.groupby("URL")["Keyword"]
.apply(lambda x: x.reset_index(drop=True))
.unstack()
.reset_index()
)
# sort by biggest opportunity
df_merged_all_kws = df_merged_all_kws.sort_values(
by="KWs in Striking Dist.", ascending=False
)
# reindex the columns to keep just the top five keywords
cols = "URL", "Volume", "KWs in Striking Dist.", 0, 1, 2, 3, 4
df_merged_all_kws = df_merged_all_kws.reindex(columns=cols)
# create union and rename the columns
df_striking: Union[Series, DataFrame, None] = df_merged_all_kws.rename(
columns={
"Volume": "Striking Dist. Vol",
0: "KW1",
1: "KW2",
2: "KW3",
3: "KW4",
4: "KW5",
}
)
# merges striking distance df with crawl df to merge in the title, h1 and category description
df_striking = pd.merge(df_striking, df_crawl, on="URL", how="inner")
Définir l’ordre final des colonnes et insérer des colonnes d’espace réservé
Enfin, nous définissons l’ordre final des colonnes et fusionnons les données de mots-clés d’origine.
Il y a beaucoup de colonnes à trier et à créer !
# set the final column order and merge the keyword data in
cols = [
"URL",
"Title",
"H1",
"Copy",
"Striking Dist. Vol",
"KWs in Striking Dist.",
"KW1",
"KW1 Vol",
"KW1 in Title",
"KW1 in H1",
"KW1 in Copy",
"KW2",
"KW2 Vol",
"KW2 in Title",
"KW2 in H1",
"KW2 in Copy",
"KW3",
"KW3 Vol",
"KW3 in Title",
"KW3 in H1",
"KW3 in Copy",
"KW4",
"KW4 Vol",
"KW4 in Title",
"KW4 in H1",
"KW4 in Copy",
"KW5",
"KW5 Vol",
"KW5 in Title",
"KW5 in H1",
"KW5 in Copy",
]
# re-index the columns to place them in a logical order + inserts new blank columns for kw checks.
df_striking = df_striking.reindex(columns=cols)
Fusionner les données de mots-clés pour chaque colonne
Ce code fusionne les données de volume de mots-clés dans le DataFrame. C’est plus ou moins l’équivalent d’une fonction RECHERCHEV d’Excel.
# merge in keyword data for each keyword column (KW1 - KW5) df_striking = pd.merge(df_striking, df_keyword_vol, left_on="KW1", right_on="Keyword", how="left") df_striking['KW1 Vol'] = df_striking['Volume'] df_striking.drop(['Keyword', 'Volume'], axis=1, inplace=True) df_striking = pd.merge(df_striking, df_keyword_vol, left_on="KW2", right_on="Keyword", how="left") df_striking['KW2 Vol'] = df_striking['Volume'] df_striking.drop(['Keyword', 'Volume'], axis=1, inplace=True) df_striking = pd.merge(df_striking, df_keyword_vol, left_on="KW3", right_on="Keyword", how="left") df_striking['KW3 Vol'] = df_striking['Volume'] df_striking.drop(['Keyword', 'Volume'], axis=1, inplace=True) df_striking = pd.merge(df_striking, df_keyword_vol, left_on="KW4", right_on="Keyword", how="left") df_striking['KW4 Vol'] = df_striking['Volume'] df_striking.drop(['Keyword', 'Volume'], axis=1, inplace=True) df_striking = pd.merge(df_striking, df_keyword_vol, left_on="KW5", right_on="Keyword", how="left") df_striking['KW5 Vol'] = df_striking['Volume'] df_striking.drop(['Keyword', 'Volume'], axis=1, inplace=True)
Nettoyez encore plus les données
Les données nécessitent un nettoyage supplémentaire pour remplir les valeurs vides (NaNs) en tant que chaînes vides. Cela améliore la lisibilité de la sortie finale en créant des cellules vides, au lieu de cellules remplies de valeurs de chaîne NaN.
Ensuite, nous convertissons les colonnes en minuscules afin qu’elles correspondent lors de la vérification si un mot-clé cible est présenté dans une colonne spécifique.
# replace nan values with empty strings
df_striking = df_striking.fillna("")
# drop the title, h1 and category description to lower case so kws can be matched to them
df_striking["Title"] = df_striking["Title"].str.lower()
df_striking["H1"] = df_striking["H1"].str.lower()
df_striking["Copy"] = df_striking["Copy"].str.lower()
Vérifiez si le mot-clé apparaît dans le titre/H1/Copier et renvoyez vrai ou faux
Ce code vérifie si le mot-clé cible se trouve dans le titre/H1 ou la copie de la page.
Il indiquera vrai ou faux selon qu’un mot-clé a été trouvé dans les éléments de la page.
df_striking["KW1 in Title"] = df_striking.apply(lambda row: row["KW1"] in row["Title"], axis=1) df_striking["KW1 in H1"] = df_striking.apply(lambda row: row["KW1"] in row["H1"], axis=1) df_striking["KW1 in Copy"] = df_striking.apply(lambda row: row["KW1"] in row["Copy"], axis=1) df_striking["KW2 in Title"] = df_striking.apply(lambda row: row["KW2"] in row["Title"], axis=1) df_striking["KW2 in H1"] = df_striking.apply(lambda row: row["KW2"] in row["H1"], axis=1) df_striking["KW2 in Copy"] = df_striking.apply(lambda row: row["KW2"] in row["Copy"], axis=1) df_striking["KW3 in Title"] = df_striking.apply(lambda row: row["KW3"] in row["Title"], axis=1) df_striking["KW3 in H1"] = df_striking.apply(lambda row: row["KW3"] in row["H1"], axis=1) df_striking["KW3 in Copy"] = df_striking.apply(lambda row: row["KW3"] in row["Copy"], axis=1) df_striking["KW4 in Title"] = df_striking.apply(lambda row: row["KW4"] in row["Title"], axis=1) df_striking["KW4 in H1"] = df_striking.apply(lambda row: row["KW4"] in row["H1"], axis=1) df_striking["KW4 in Copy"] = df_striking.apply(lambda row: row["KW4"] in row["Copy"], axis=1) df_striking["KW5 in Title"] = df_striking.apply(lambda row: row["KW5"] in row["Title"], axis=1) df_striking["KW5 in H1"] = df_striking.apply(lambda row: row["KW5"] in row["H1"], axis=1) df_striking["KW5 in Copy"] = df_striking.apply(lambda row: row["KW5"] in row["Copy"], axis=1)
Supprimer les valeurs Vrai/Faux s’il n’y a pas de mot-clé
Cela supprimera les valeurs vrai/faux lorsqu’il n’y a pas de mot-clé adjacent.
# delete true / false values if there is no keyword df_striking.loc[df_striking["KW1"] == "", ["KW1 in Title", "KW1 in H1", "KW1 in Copy"]] = "" df_striking.loc[df_striking["KW2"] == "", ["KW2 in Title", "KW2 in H1", "KW2 in Copy"]] = "" df_striking.loc[df_striking["KW3"] == "", ["KW3 in Title", "KW3 in H1", "KW3 in Copy"]] = "" df_striking.loc[df_striking["KW4"] == "", ["KW4 in Title", "KW4 in H1", "KW4 in Copy"]] = "" df_striking.loc[df_striking["KW5"] == "", ["KW5 in Title", "KW5 in H1", "KW5 in Copy"]] = "" df_striking.head()
Supprimer les lignes si toutes les valeurs == True
Cette option configurable est vraiment utile pour réduire le temps d’AQ requis pour la sortie finale en supprimant l’opportunité de mot-clé de la sortie finale si elle se trouve dans les trois colonnes.
def true_dropper(col1, col2, col3):
drop = df_striking.drop(
df_striking[
(df_striking[col1] == True)
& (df_striking[col2] == True)
& (df_striking[col3] == True)
].index
)
return drop
if drop_all_true == True:
df_striking = true_dropper("KW1 in Title", "KW1 in H1", "KW1 in Copy")
df_striking = true_dropper("KW2 in Title", "KW2 in H1", "KW2 in Copy")
df_striking = true_dropper("KW3 in Title", "KW3 in H1", "KW3 in Copy")
df_striking = true_dropper("KW4 in Title", "KW4 in H1", "KW4 in Copy")
df_striking = true_dropper("KW5 in Title", "KW5 in H1", "KW5 in Copy")
Télécharger le fichier CSV
La dernière étape consiste à télécharger le fichier CSV et à démarrer le processus d’optimisation.
df_striking.to_csv('Keywords in Striking Distance.csv', index=False)
files.download("Keywords in Striking Distance.csv")
Conclusion
Si vous recherchez des gains rapides pour n’importe quel site Web, le rapport de distance de frappe est un moyen très simple de les trouver.
Ne laissez pas le nombre d’étapes vous tromper. Ce n’est pas aussi complexe qu’il n’y paraît. C’est aussi simple que de télécharger une analyse et une exportation de mots clés vers la feuille Google Colab fournie ou d’utiliser l’application Streamlit.
Les résultats en valent vraiment la peine !
Davantage de ressources:
- Une introduction à Python et à l’apprentissage automatique pour le référencement technique
- Comment faire un audit de sitemap pour une meilleure indexation et exploration via Python
- Référencement technique avancé : un guide complet
Image en vedette : aurielaki/Shutterstock
