Python est un langage de programmation puissant qui a gagné en popularité dans l’industrie du référencement au cours des dernières années.
Avec sa syntaxe relativement simple, ses performances efficaces et son abondance de bibliothèques et de frameworks, Python a révolutionné la façon dont de nombreux référenceurs abordent leur travail.
Python offre un ensemble d’outils polyvalents qui peuvent aider à rendre le processus d’optimisation plus rapide, plus précis et plus efficace.
Cet article explore cinq scripts Python pour vous aider à booster vos efforts de référencement.
Le moyen le plus simple de démarrer avec Python
Si vous cherchez à plonger vos orteils dans la programmation Python, Google Colab vaut la peine d’être considéré.
Il s’agit d’une plate-forme Web gratuite qui offre un terrain de jeu pratique pour écrire et exécuter du code Python sans avoir besoin d’une configuration locale complexe.
Essentiellement, il vous permet d’accéder aux blocs-notes Jupyter dans votre navigateur et fournit une multitude de bibliothèques préinstallées pour la science des données et l’apprentissage automatique.
De plus, il est construit sur Google Drive, vous pouvez donc facilement enregistrer et partager votre travail avec d’autres.
Pour commencer, procédez comme suit :
Activer les téléchargements de fichiers
Une fois que vous avez ouvert Google Colab, vous devez d’abord activer la possibilité de créer un référentiel de fichiers temporaire. C’est aussi simple que de cliquer sur l’icône du dossier.
Cela vous permet de télécharger des fichiers temporaires, puis de télécharger tous les fichiers de résultats.
Télécharger les données sources
Beaucoup de nos scripts Python nécessitent un fichier source pour fonctionner. Pour télécharger un fichier, cliquez simplement sur le bouton de téléchargement.
Une fois la configuration terminée, vous pouvez commencer à tester les scripts Python suivants.
Script 1 : Automatiser une carte de redirection
La création de cartes de redirection pour les grands sites peut prendre énormément de temps. Trouver des moyens d’automatiser le processus peut nous aider à gagner du temps et à nous concentrer sur d’autres tâches.
Comment fonctionne ce script
Ce script se concentre sur l’analyse du contenu Web pour trouver des articles correspondant étroitement.
- Tout d’abord, il importe deux fichiers TXT d’URL : l’un pour le site Web redirigé (source_urls.txt), et l’autre pour le site absorbant le site Web redirigé (target_urls.txt).
- Ensuite, nous utilisons la bibliothèque Python Beautiful Soup pour créer un grattoir Web afin d’obtenir le contenu du corps principal de la page. Ce script ignore le contenu de l’en-tête et du pied de page.
- Après avoir exploré le contenu de toutes les pages, il utilise la bibliothèque Python Polyfuzz pour faire correspondre le contenu entre les URL avec un pourcentage de similarité.
- Enfin, il imprime les résultats dans un fichier CSV, y compris le pourcentage de similarité.
À partir de là, vous pouvez examiner manuellement toutes les URL avec un faible pourcentage de similarité pour trouver la prochaine correspondance la plus proche.
Obtenir le scénario
#import libraries
from bs4 import BeautifulSoup, SoupStrainer
from polyfuzz import PolyFuzz
import concurrent.futures
import csv
import pandas as pd
import requests
#import urls
with open("source_urls.txt", "r") as file:
url_list_a = [line.strip() for line in file]
with open("target_urls.txt", "r") as file:
url_list_b = [line.strip() for line in file]
#create a content scraper via bs4
def get_content(url_argument):
page_source = requests.get(url_argument).text
strainer = SoupStrainer('p')
soup = BeautifulSoup(page_source, 'lxml', parse_only=strainer)
paragraph_list = [element.text for element in soup.find_all(strainer)]
content = " ".join(paragraph_list)
return content
#scrape the urls for content
with concurrent.futures.ThreadPoolExecutor() as executor:
content_list_a = list(executor.map(get_content, url_list_a))
content_list_b = list(executor.map(get_content, url_list_b))
content_dictionary = dict(zip(url_list_b, content_list_b))
#get content similarities via polyfuzz
model = PolyFuzz("TF-IDF")
model.match(content_list_a, content_list_b)
data = model.get_matches()
#map similarity data back to urls
def get_key(argument):
for key, value in content_dictionary.items():
if argument == value:
return key
return key
with concurrent.futures.ThreadPoolExecutor() as executor:
result = list(executor.map(get_key, data["To"]))
#create a dataframe for the final results
to_zip = list(zip(url_list_a, result, data["Similarity"]))
df = pd.DataFrame(to_zip)
df.columns = ["From URL", "To URL", "% Identical"]
#export to a spreadsheet
with open("redirect_map.csv", "w", newline="") as file:
columns = ["From URL", "To URL", "% Identical"]
writer = csv.writer(file)
writer.writerow(columns)
for row in to_zip:
writer.writerow(row)Bien que les méta-descriptions ne soient pas un facteur de classement direct, elles nous aident à améliorer nos taux de clics organiques. Laisser les méta descriptions vides augmente les chances que Google crée les siennes.
Si votre audit SEO montre qu’un grand nombre d’URL manquent d’une méta description, il peut être difficile de prendre le temps de toutes les écrire à la main, en particulier pour les sites de commerce électronique.
Ce script vise à vous aider à gagner du temps en automatisant ce processus pour vous.
Comment fonctionne le script
- Tout d’abord, le script importe une liste d’URL à partir d’un fichier TXT (urls.txt).
- Ensuite, il analyse tout le contenu des URL.
- Une fois le contenu analysé, il crée des méta descriptions visant à être inférieures à 155 caractères.
- Il exporte les résultats dans un fichier CSV.
Obtenir le scénario
!pip install sumy
from sumy.parsers.html import HtmlParser
from sumy.nlp.tokenizers import Tokenizer
from sumy.nlp.stemmers import Stemmer
from sumy.utils import get_stop_words
from sumy.summarizers.lsa import LsaSummarizer
import csv
#1) imports a list of URLs from a txt file
with open('urls.txt') as f:
urls = [line.strip() for line in f]
results = []
# 2) analyzes the content on each URL
for url in urls:
parser = HtmlParser.from_url(url, Tokenizer("english"))
stemmer = Stemmer("english")
summarizer = LsaSummarizer(stemmer)
summarizer.stop_words = get_stop_words("english")
description = summarizer(parser.document, 3)
description = " ".join([sentence._text for sentence in description])
if len(description) > 155:
description = description[:152] + '...'
results.append({
'url': url,
'description': description
})
# 4) exports the results to a csv file
with open('results.csv', 'w', newline="") as f:
writer = csv.DictWriter(f, fieldnames=['url','description'])
writer.writeheader()
writer.writerows(results)Script 3 : analysez les mots-clés avec des N-grammes
Les N-grammes ne sont pas un nouveau concept mais sont toujours utiles pour le référencement. Ils peuvent nous aider à comprendre les thèmes à travers de grands ensembles de données de mots clés.
Comment fonctionne ce script
Ce script génère des résultats dans un fichier TXT qui décompose les mots-clés en unigrammes, bigrammes et trigrammes.
- Tout d’abord, il importe un fichier TXT de tous vos mots-clés (keyword.txt).
- Ensuite, il utilise une bibliothèque Python appelée Counter pour analyser et extraire les N-grammes.
- Ensuite, il exporte les résultats dans un nouveau fichier TXT.
Obtenir ce script
#Import necessary libraries
import re
from collections import Counter
#Open the text file and read its contents into a list of words
with open('keywords.txt', 'r') as f:
words = f.read().split()
#Use a regular expression to remove any non-alphabetic characters from the words
words = [re.sub(r'[^a-zA-Z]', '', word) for word in words]
#Initialize empty dictionaries for storing the unigrams, bigrams, and trigrams
unigrams = {}
bigrams = {}
trigrams = {}
#Iterate through the list of words and count the number of occurrences of each unigram, bigram, and trigram
for i in range(len(words)):
# Unigrams
if words[i] in unigrams:
unigrams[words[i]] += 1
else:
unigrams[words[i]] = 1
# Bigrams
if i < len(words)-1:
bigram = words[i] + ' ' + words[i+1]
if bigram in bigrams:
bigrams[bigram] += 1
else:
bigrams[bigram] = 1
# Trigrams
if i < len(words)-2:
trigram = words[i] + ' ' + words[i+1] + ' ' + words[i+2]
if trigram in trigrams:
trigrams[trigram] += 1
else:
trigrams[trigram] = 1
# Sort the dictionaries by the number of occurrences
sorted_unigrams = sorted(unigrams.items(), key=lambda x: x[1], reverse=True)
sorted_bigrams = sorted(bigrams.items(), key=lambda x: x[1], reverse=True)
sorted_trigrams = sorted(trigrams.items(), key=lambda x: x[1], reverse=True)
# Write the results to a text file
with open('results.txt', 'w') as f:
f.write("Most common unigrams:n")
for unigram, count in sorted_unigrams[:10]:
f.write(unigram + ": " + str(count) + "n")
f.write("nMost common bigrams:n")
for bigram, count in sorted_bigrams[:10]:
f.write(bigram + ": " + str(count) + "n")
f.write("nMost common trigrams:n")
for trigram, count in sorted_trigrams[:10]:
f.write(trigram + ": " + str(count) + "n")Script 4 : regrouper les mots-clés dans des groupes de rubriques
Avec les nouveaux projets de référencement, la recherche de mots-clés en est toujours à ses débuts. Parfois, nous traitons des milliers de mots-clés dans un ensemble de données, ce qui rend le regroupement difficile.
Python nous permet de regrouper automatiquement les mots-clés dans des groupes similaires pour identifier les tendances et compléter notre cartographie des mots-clés.
Comment fonctionne ce script
- Ce script importe d’abord un fichier TXT de mots clés (keywords.txt).
- Ensuite, le script analyse les mots-clés à l’aide de TfidfVectorizer et AffinityPropagation.
- Ensuite, il attribue une valeur numérique à chaque groupe de rubriques.
- Les résultats sont ensuite exportés dans un fichier csv.
Obtenir ce script
import csv
import numpy as np
from sklearn.cluster import AffinityPropagation
from sklearn.feature_extraction.text import TfidfVectorizer
# Read keywords from text file
with open("keywords.txt", "r") as f:
keywords = f.read().splitlines()
# Create a Tf-idf representation of the keywords
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(keywords)
# Perform Affinity Propagation clustering
af = AffinityPropagation().fit(X)
cluster_centers_indices = af.cluster_centers_indices_
labels = af.labels_
# Get the number of clusters found
n_clusters = len(cluster_centers_indices)
# Write the clusters to a csv file
with open("clusters.csv", "w", newline="") as f:
writer = csv.writer(f)
writer.writerow(["Cluster", "Keyword"])
for i in range(n_clusters):
cluster_keywords = [keywords[j] for j in range(len(labels)) if labels[j] == i]
if cluster_keywords:
for keyword in cluster_keywords:
writer.writerow([i, keyword])
else:
writer.writerow([i, ""])Script 5 : Faites correspondre la liste de mots clés à une liste de sujets prédéfinis
Ceci est similaire au script précédent, sauf qu’il vous permet de faire correspondre une liste de mots-clés à un ensemble prédéfini de sujets.
Ceci est idéal pour les grands ensembles de mots-clés car il les traite par lots de 1 000 pour éviter les pannes du système.
Comment fonctionne ce script
- Ce script importe une liste de mots-clés (keywords.txt) et une liste de sujets (topics.txt).
- Ensuite, il analyse les sujets et les listes de mots clés et les associe à la correspondance la plus proche. S’il ne trouve pas de correspondance, il la classe dans la catégorie autre.
- Les résultats sont ensuite exportés dans un fichier CSV.
Obtenir ce script
import pandas as pd
import spacy
from spacy.lang.en.stop_words import STOP_WORDS
# Load the Spacy English language model
nlp = spacy.load("en_core_web_sm")
# Define the batch size for keyword analysis
BATCH_SIZE = 1000
# Load the keywords and topics files as Pandas dataframes
keywords_df = pd.read_csv("keywords.txt", header=None, names=["keyword"])
topics_df = pd.read_csv("topics.txt", header=None, names=["topic"])
# Define a function to categorize a keyword based on the closest related topic
def categorize_keyword(keyword):
# Tokenize the keyword
tokens = nlp(keyword.lower())
# Remove stop words and punctuation
tokens = [token.text for token in tokens if not token.is_stop and not token.is_punct]
# Find the topic that has the most token overlaps with the keyword
max_overlap = 0
best_topic = "Other"
for topic in topics_df["topic"]:
topic_tokens = nlp(topic.lower())
topic_tokens = [token.text for token in topic_tokens if not token.is_stop and not token.is_punct]
overlap = len(set(tokens).intersection(set(topic_tokens)))
if overlap > max_overlap:
max_overlap = overlap
best_topic = topic
return best_topic
# Define a function to process a batch of keywords and return the results as a dataframe
def process_keyword_batch(keyword_batch):
results = []
for keyword in keyword_batch:
category = categorize_keyword(keyword)
results.append({"keyword": keyword, "category": category})
return pd.DataFrame(results)
# Initialize an empty dataframe to hold the results
results_df = pd.DataFrame(columns=["keyword", "category"])
# Process the keywords in batches
for i in range(0, len(keywords_df), BATCH_SIZE):
keyword_batch = keywords_df.iloc[i:i+BATCH_SIZE]["keyword"].tolist()
batch_results_df = process_keyword_batch(keyword_batch)
results_df = pd.concat([results_df, batch_results_df])
# Export the results to a CSV file
results_df.to_csv("results.csv", index=False)Travailler avec Python pour le référencement
Python est un outil incroyablement puissant et polyvalent pour les professionnels du référencement.
Que vous soyez un débutant ou un praticien chevronné, les scripts gratuits que j’ai partagés dans cet article offrent un excellent point de départ pour explorer les possibilités de Python dans le référencement.
Avec sa syntaxe intuitive et sa vaste gamme de bibliothèques, Python peut vous aider à automatiser les tâches fastidieuses, à analyser des données complexes et à obtenir de nouvelles informations sur les performances de votre site Web. Alors pourquoi ne pas essayer ?
Bonne chance et bon codage !
Les opinions exprimées dans cet article sont celles de l’auteur invité et pas nécessairement Search Engine Land. Les auteurs du personnel sont répertoriés ici.
