L’audit de plan de site implique des vérifications de syntaxe, d’exploration et d’indexation pour les URL et les balises de vos fichiers de plan de site.
Un fichier de sitemap contient les URL à indexer avec des informations supplémentaires concernant la date de la dernière modification, la priorité de l’URL, les images, les vidéos sur l’URL et d’autres langues alternatives de l’URL, ainsi que la fréquence de changement.
Les fichiers d’index de sitemap peuvent impliquer des millions d’URL, même si un seul sitemap ne peut impliquer que 50 000 URL en haut.
L’audit de ces URL pour une meilleure indexation et exploration peut prendre du temps.
Mais avec l’aide de Python et de l’automatisation SEO, il est possible d’auditer des millions d’URL dans les sitemaps.
De quoi avez-vous besoin pour effectuer un audit de sitemap avec Python ?
Pour comprendre le processus Python Sitemap Audit, vous aurez besoin de :
- Une compréhension fondamentale des fichiers XML techniques de référencement et de sitemap.
- Connaissance pratique de Python et de la syntaxe XML du sitemap.
- La possibilité de travailler avec les bibliothèques Python, Pandas, Advertools, LXML, Requests et XPath Selectors.
Quelles URL doivent figurer dans le plan du site ?
Un fichier sitemap XML de plan de site sain doit inclure les critères suivants :
- Toutes les URL doivent avoir un code d’état 200.
- Toutes les URL doivent être auto-canoniques.
- Les URL doivent être ouvertes à l’indexation et à l’exploration.
- Les URL ne doivent pas être dupliquées.
- Les URL ne doivent pas être des 404 souples.
- Le plan du site doit avoir une syntaxe XML appropriée.
- Les URL du sitemap doivent avoir un alignement canonique avec les URL Open Graph et Twitter Card.
- Le sitemap doit avoir moins de 50 000 URL et une taille de 50 Mo.
Quels sont les avantages d’un fichier de plan de site XML sain ?
Les plans de site plus petits sont meilleurs que les plans de site plus grands pour une indexation plus rapide. Ceci est particulièrement important dans le référencement des actualités, car des sitemaps plus petits aident à augmenter le nombre global d’URL indexées valides.
Différenciez les URL de contenu fréquemment mises à jour et statiques les unes des autres pour fournir une meilleure distribution d’exploration parmi les URL.
L’utilisation de la date « lastmod » d’une manière honnête qui correspond à la date de publication ou de mise à jour réelle aide un moteur de recherche à faire confiance à la date de la dernière publication.
Lors de l’exécution de l’audit de sitemap pour une meilleure indexation, exploration et communication du moteur de recherche avec Python, les critères ci-dessus sont suivis.
Une remarque importante…
En ce qui concerne la nature et l’audit d’un sitemap, Google et Microsoft Bing n’utilisent pas « changefreq » pour changer la fréquence des URL et la « priorité » pour comprendre la proéminence d’une URL. En fait, ils appellent cela un « sac de bruit ».
Cependant, Yandex et Baidu utilisent toutes ces balises pour comprendre les caractéristiques du site Web.
Un audit de sitemap en 16 étapes pour le référencement avec Python
Un audit de sitemap peut impliquer la catégorisation du contenu, l’arborescence du site ou l’actualité et les caractéristiques du contenu.
Cependant, un audit de sitemap pour une meilleure indexation et crawlabilité implique principalement un référencement technique plutôt que des caractéristiques de contenu.
Dans ce processus d’audit de plan de site étape par étape, nous utiliserons Python pour aborder les aspects techniques de l’audit de plan de site de millions d’URL.
1. Importez les bibliothèques Python pour votre audit de sitemap
Le bloc de code suivant consiste à importer les bibliothèques Python nécessaires pour l’audit du fichier XML Sitemap.
import advertools as adv
import pandas as pd
from lxml import etree
from IPython.core.display import display, HTML
display(HTML("<style>.container { width:100% !important; }</style>"))
Voici ce que vous devez savoir sur ce bloc de code :
- Advertools est nécessaire pour extraire les URL du fichier sitemap et faire une requête pour prendre leur contenu ou les codes d’état de réponse.
- « Pandas » est nécessaire pour agréger et manipuler les données.
- Plotly est nécessaire pour la visualisation du résultat de l’audit du sitemap.
- LXML est nécessaire pour l’audit de syntaxe du fichier XML du sitemap.
- IPython est facultatif pour développer les cellules de sortie de Jupyter Notebook à 100 % de largeur.
2. Prenez toutes les URL du plan du site
Des millions d’URL peuvent être prises dans un bloc de données Pandas avec Advertools, comme indiqué ci-dessous.
sitemap_url = "https://www.complaintsboard.com/sitemap.xml"
sitemap = adv.sitemap_to_df(sitemap_url)
sitemap.to_csv("sitemap.csv")
sitemap_df = pd.read_csv("sitemap.csv", index_col=False)
sitemap_df.drop(columns=["Unnamed: 0"], inplace=True)
sitemap_df
Ci-dessus, le plan du site Complaintsboard.com a été pris dans un bloc de données Pandas, et vous pouvez voir la sortie ci-dessous.
Au total, nous avons 245 691 URL dans le fichier d’index du sitemap de Complaintsboard.com.
Le site Web utilise « changefreq », « lastmod » et « priority » avec une incohérence.
3. Vérifier l’utilisation des balises dans le fichier XML du sitemap
Pour comprendre quelles balises sont utilisées ou non dans le fichier XML Sitemap, utilisez la fonction ci-dessous.
def check_sitemap_tag_usage(sitemap):
lastmod = sitemap["lastmod"].isna().value_counts()
priority = sitemap["priority"].isna().value_counts()
changefreq = sitemap["changefreq"].isna().value_counts()
lastmod_perc = sitemap["lastmod"].isna().value_counts(normalize = True) * 100
priority_perc = sitemap["priority"].isna().value_counts(normalize = True) * 100
changefreq_perc = sitemap["changefreq"].isna().value_counts(normalize = True) * 100
sitemap_tag_usage_df = pd.DataFrame(data={"lastmod":lastmod,
"priority":priority,
"changefreq":changefreq,
"lastmod_perc": lastmod_perc,
"priority_perc": priority_perc,
"changefreq_perc": changefreq_perc})
return sitemap_tag_usage_df.astype(int)
La fonction check_sitemap_tag_usage est un constructeur de bloc de données basé sur l’utilisation des balises sitemap.
Il prend les colonnes « lastmod », « priority » et « changefreq » en implémentant les méthodes « isna() » et « value_counts() » via « pd.DataFrame ».
Ci-dessous, vous pouvez voir la sortie.
Le bloc de données ci-dessus montre que 96 840 des URL n’ont pas la balise Lastmod, ce qui équivaut à 39 % du nombre total d’URL du fichier sitemap.
Le même pourcentage d’utilisation est de 19 % pour la « priorité » et le « changefreq » dans le fichier XML du sitemap.
Il existe trois principaux signaux de fraîcheur du contenu d’un site Web.
Ce sont des dates issues d’une page web (visibles pour l’utilisateur), des données structurées (invisibles pour l’utilisateur), « lastmod » dans le plan du site.
Si ces dates ne sont pas cohérentes les unes avec les autres, les moteurs de recherche peuvent ignorer les dates sur les sites Web pour voir leurs signaux de fraîcheur.
4. Auditer l’arborescence du site et la structure URL du site Web
Comprendre le chemin d’URL le plus important ou le plus encombré est nécessaire pour peser les efforts de référencement du site Web ou les audits techniques de référencement.
Une seule amélioration du référencement technique peut bénéficier simultanément à des milliers d’URL, ce qui crée une stratégie de référencement rentable et économique.
La compréhension de la structure d’URL se concentre principalement sur les sections les plus importantes du site Web et la compréhension de l’analyse du réseau de contenu.
Pour créer un cadre de données d’arborescence d’URL à partir des URL d’un site Web à partir du sitemap, utilisez le bloc de code suivant.
sitemap_url_df = adv.url_to_df(sitemap_df["loc"]) sitemap_url_df
Avec l’aide de « urllib » ou des « advertools » comme ci-dessus, vous pouvez facilement analyser les URL du sitemap dans un bloc de données.
-
- La vérification des répartitions d’URL aide à comprendre l’arborescence d’informations globale d’un site Web.
La trame de données ci-dessus contient le « schéma », « netloc », « chemin » et chaque répartition « / » dans les URL sous la forme d’un « répertoire » qui représente le répertoire.
L’audit de la structure URL du site Web est important pour deux objectifs.
Ceux-ci vérifient si toutes les URL ont « HTTPS » et comprennent le réseau de contenu du site Web.
L’analyse de contenu avec des fichiers sitemap n’est pas directement le sujet de « l’indexation et l’exploration », donc à la fin de l’article, nous en parlerons légèrement.
Consultez la section suivante pour voir l’utilisation de SSL sur les URL de sitemap.
5. Vérifiez l’utilisation HTTPS sur les URL dans le sitemap
Utilisez le bloc de code suivant pour vérifier le taux d’utilisation HTTP pour les URL dans le sitemap.
sitemap_url_df["scheme"].value_counts().to_frame()
Le bloc de code ci-dessus utilise une simple filtration des données pour la colonne « schéma » qui contient les informations de protocole HTTPS des URL.
en utilisant les « value_counts », nous voyons que toutes les URL sont sur le HTTPS.
6. Vérifiez les commandes d’interdiction de Robots.txt pour l’exploration
La structure des URL dans le plan du site est utile pour voir s’il existe une situation pour « soumis mais refusé ».
Pour voir s’il existe un fichier robots.txt du site Web, utilisez le bloc de code ci-dessous.
import requests
r = requests.get("https://www.complaintsboard.com/robots.txt")
R.status_code
200
Simplement, nous envoyons une « demande d’obtention » à l’URL robots.txt.
Si le code d’état de la réponse est 200, cela signifie qu’il existe un fichier robots.txt pour le contrôle d’exploration basé sur l’agent utilisateur.
Après avoir vérifié l’existence de « robots.txt », nous pouvons utiliser la méthode « adv.robotstxt_test » pour l’audit en masse de robots.txt pour l’exploration des URL dans le sitemap.
sitemap_df_robotstxt_check = adv.robotstxt_test("https://www.complaintsboard.com/robots.txt", urls=sitemap_df["loc"], user_agents=["*"])
sitemap_df_robotstxt_check["can_fetch"].value_counts()
Nous avons créé une nouvelle variable appelée « sitemap_df_robotstxt_check » et attribué la sortie de la méthode « robotstxt_test ».
Nous avons utilisé les URL dans le sitemap avec le « sitemap_df[“loc”]”.
Nous avons réalisé l’audit pour tous les user-agents via le « user_agents = [“*”]” paramètre et paire de valeurs.
Vous pouvez voir le résultat ci-dessous.
True 245690 False 1 Name: can_fetch, dtype: int64
Cela montre qu’il y a une URL qui est refusée mais soumise.
Nous pouvons filtrer l’URL spécifique comme ci-dessous.
pd.set_option("display.max_colwidth",255)
sitemap_df_robotstxt_check[sitemap_df_robotstxt_check["can_fetch"] == False]
Nous avons utilisé « set_option » pour développer toutes les valeurs dans la section « url_path ».
-
- Nous constatons qu’une page de « profil » a été refusée et soumise.
Plus tard, le même contrôle peut être effectué pour d’autres examens tels que « refusé mais lié en interne ».
Mais, pour ce faire, nous devons explorer au moins 3 millions d’URL à partir de ComplaintsBoard.com, et cela peut être un tout nouveau guide.
Certaines URL de sites Web n’ont pas de « hiérarchie de répertoires » appropriée, ce qui peut compliquer l’analyse des URL, en termes de caractéristiques du réseau de contenu.
Complaintsboard.com n’utilise pas une structure d’URL et une taxonomie appropriées, donc l’analyse de la structure du site Web n’est pas facile pour un référencement ou un moteur de recherche.
Mais les mots les plus utilisés dans les URL ou la fréquence de mise à jour du contenu peuvent indiquer sur quel sujet l’entreprise pèse réellement.
Étant donné que nous nous concentrons sur les « aspects techniques » dans ce didacticiel, vous pouvez lire l’audit de contenu du sitemap ici.
7. Vérifiez le code d’état des URL du sitemap avec Python
Chaque URL du sitemap doit avoir un code de statut 200.
Une analyse doit être effectuée pour vérifier les codes d’état des URL dans le sitemap.
Mais, comme cela coûte cher lorsque vous avez des millions d’URL à auditer, nous pouvons simplement utiliser une nouvelle méthode de crawling d’Advertools.
Sans prendre le corps de la réponse, nous pouvons explorer uniquement les en-têtes de réponse des URL dans le sitemap.
Il est utile de réduire le temps d’exploration pour auditer les robots éventuels, l’indexation et les signaux canoniques des en-têtes de réponse.
Pour effectuer une analyse d’en-tête de réponse, utilisez la méthode « adv.crawl_headers ».
adv.crawl_headers(sitemap_df["loc"], output_file="sitemap_df_header.jl")
df_headers = pd.read_json("sitemap_df_header.jl", lines=True)
df_headers["status"].value_counts()
L’explication du bloc de code pour vérifier les codes d’état des URL dans les fichiers XML Sitemap pour l’aspect SEO technique peut être vue ci-dessous.
200 207866 404 23 Name: status, dtype: int64
Cela montre que l’URL 23 du sitemap est en fait 404.
Et, ils doivent être supprimés du sitemap.
Pour vérifier quelles URL du sitemap sont 404, utilisez la méthode de filtrage ci-dessous de Pandas.
df_headers[df_headers["status"] == 404]
Le résultat peut être vu ci-dessous.
8. Vérifier la canonisation des en-têtes de réponse
De temps en temps, l’utilisation d’indications de canonisation sur les en-têtes de réponse est bénéfique pour l’exploration et l’indexation de la consolidation du signal.
Dans ce contexte, la balise canonique sur le HTML et l’en-tête de réponse doivent être identiques.
S’il existe deux signaux de canonisation différents sur une page Web, les moteurs de recherche peuvent ignorer les deux affectations.
Pour ComplaintsBoard.com, nous n’avons pas d’en-tête de réponse canonique.
- La première étape est vérifier si l’en-tête de réponse pour l’utilisation canonique existe.
- La deuxième étape est comparer la valeur canonique de l’en-tête de réponse à la valeur canonique HTML s’il existe.
- La troisième étape est vérifier si les valeurs canoniques sont auto-référentielles.
Vérifiez les colonnes de la sortie de l’analyse de l’en-tête pour vérifier la canonisation des en-têtes de réponse.
df_headers.columns
Ci-dessous, vous pouvez voir les colonnes.
Si vous n’êtes pas familiarisé avec les en-têtes de réponse, vous ne savez peut-être pas comment utiliser les indications canoniques dans les en-têtes de réponse.
Un en-tête de réponse peut inclure l’indice canonique avec la valeur « Lien ».
Il est enregistré en tant que « resp_headers_link » par les Advertools directement.
Un autre problème est que les chaînes extraites apparaissent dans le «
Cela signifie que nous utiliserons regex pour l’extraire.
df_headers["resp_headers_link"]
Vous pouvez voir le résultat ci-dessous.
Le modèle de regex « [^<>][a-z:/0-9-.]* » est assez bon pour extraire la valeur canonique spécifique.
Une vérification d’auto-canonicalisation avec les en-têtes de réponse est ci-dessous.
df_headers["response_header_canonical"] = df_headers["resp_headers_link"].str.extract(r"([^<>][a-z:/0-9-.]*)") (df_headers["response_header_canonical"] == df_headers["url"]).value_counts()
Nous avons utilisé deux contrôles booléens différents.
Un pour vérifier si l’indice canonique de l’en-tête de réponse est égal à l’URL elle-même.
Un autre pour voir si le code d’état est 200.
Puisque nous avons 404 URL dans le sitemap, leur valeur canonique sera « NaN ».
- Nous avons 29 valeurs aberrantes pour le référencement technique. Chaque mauvais signal donné au moteur de recherche pour l’indexation ou le classement entraînera la dilution des signaux de classement.
Pour voir ces URL, utilisez le bloc de code ci-dessous.
Les valeurs canoniques des en-têtes de réponse sont visibles ci-dessus.
df_headers[(df_headers["response_header_canonical"] != df_headers["url"]) & (df_headers["status"] == 200)]
Même un seul « / » dans l’URL peut provoquer un conflit de canonisation, comme cela apparaît ici pour la page d’accueil.
- Vous pouvez vérifier le conflit canonique ici.
Si vous vérifiez les fichiers journaux, vous verrez que le moteur de recherche explore les URL à partir des en-têtes de réponse « Lien ».
Ainsi, dans le référencement technique, cela devrait être pondéré.
9. Vérifiez les commandes d’indexation et d’exploration à partir des en-têtes de réponse
Il existe 14 spécifications X-Robots-Tag différentes pour le robot d’exploration du moteur de recherche Google.
Le dernier en date est « indexifembedded » pour déterminer le montant de l’indexation sur une page Web.
Les directives d’indexation et d’exploration peuvent se présenter sous la forme d’un en-tête de réponse ou d’une balise méta HTML.
Cette section se concentre sur la version d’en-tête de réponse des directives d’indexation et d’exploration.
- La première étape est vérifier si la propriété et les valeurs X-Robots-Tag existent dans l’en-tête HTTP ou non.
- La deuxième étape est vérifier s’il s’aligne sur les propriétés et les valeurs de la balise HTML Meta Tag s’ils existent.
Utilisez la commande ci-dessous pour vérifier le X-Robots-Tag » dans les en-têtes de réponse.
def robots_tag_checker(dataframe:pd.DataFrame):
for i in df_headers:
if i.__contains__("robots"):
return i
else:
return "There is no robots tag"
robots_tag_checker(df_headers)
OUTPUT>>>
'There is no robots tag'
Nous avons créé une fonction personnalisée pour vérifier les en-têtes de réponse « X-Robots-tag » à partir du code source des pages Web.
Il semble que le site Web de notre sujet de test n’utilise pas le X-Robots-Tag.
S’il y avait une balise X-Robots, le bloc de code ci-dessous doit être utilisé.
df_headers["response_header_x_robots_tag"].value_counts() df_headers[df_headers["response_header_x_robots_tag"] == "noindex"]
Vérifiez s’il existe une directive « noindex » dans les en-têtes de réponse et filtrez les URL avec ce conflit d’indexation.
Dans le rapport de couverture de la console de recherche Google, ceux-ci apparaissent comme « Soumis marqués comme noindex ».
Des indices et des signaux d’indexation et de canonisation contradictoires peuvent amener un moteur de recherche à ignorer tous les signaux tout en rendant les algorithmes de recherche moins fiables envers les signaux déclarés par l’utilisateur.
10. Vérifiez l’auto-canonalisation des URL de plan de site
Chaque URL dans les fichiers XML du sitemap doit donner un indice d’auto-canonalisation.
Les sitemaps ne doivent inclure que les versions canoniques des URL.
Le bloc de code Python de cette section consiste à comprendre si les URL du sitemap ont ou non des valeurs d’auto-canonalisation.
Pour vérifier la canonisation à partir de la section «
» des documents HTML, parcourez les sites Web en prenant leur corps de réponse.Utilisez le bloc de code ci-dessous.
user_agent = "Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/W.X.Y.Z Mobile Safari/537.36 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"
La différence entre « crawl_headers » et « crawl » est que « crawl » prend tout le corps de la réponse, tandis que « crawl_headers » ne concerne que les en-têtes de réponse.
adv.crawl(sitemap_df["loc"],
output_file="sitemap_crawl_complaintsboard.jl",
follow_links=False,
custom_settings={"LOG_FILE":"sitemap_crawl_complaintsboard.log", “USER_AGENT”:user_agent})
Vous pouvez vérifier les différences de taille de fichier entre les journaux d’analyse, l’analyse de l’en-tête de réponse et l’analyse de l’ensemble du corps de la réponse.
De la sortie de 6 Go à la sortie de 387 Mo, c’est assez économique.
Si un moteur de recherche veut juste voir certains en-têtes de réponse et le code d’état, la création d’informations sur les en-têtes rendrait leurs résultats d’exploration plus économiques.
Comment gérer les grandes trames de données pour la lecture et l’agrégation de données ?
Cette section nécessite de traiter les grandes trames de données.
Un ordinateur ne peut pas lire un Pandas DataFrame à partir d’un fichier CSV ou JL si la taille du fichier est supérieure à la RAM de l’ordinateur.
Ainsi, la méthode du « chunking » est utilisée.
Lorsqu’un fichier XML de sitemap de site Web contient des millions d’URL, la sortie totale de l’analyse sera supérieure à des dizaines de gigaoctets.
Une itération sur les lignes du bloc de données de sortie de l’analyse du sitemap est nécessaire.
Pour la segmentation, utilisez le bloc de code ci-dessous.
df_iterator = pd.read_json(
'sitemap_crawl_complaintsboard.jl',
chunksize=10000,
lines=True)
for i, df_chunk in enumerate(df_iterator):
output_df = pd.DataFrame(data={"url":df_chunk["url"],"canonical":df_chunk["canonical"], "self_canonicalised":df_chunk["url"] == df_chunk["canonical"]})
mode="w" if i == 0 else 'a'
header = i == 0
output_df.to_csv(
"canonical_check.csv",
index=False,
header=header,
mode=mode
)
df[((df["url"] != df["canonical"]) == True) & (df["self_canonicalised"] == False) & (df["canonical"].isna() != True)]
Vous pouvez voir le résultat ci-dessous.
Nous voyons que les URL paginées du sous-dossier « livre » donnent des indications canoniques à la première page, ce qui n’est pas une pratique correcte selon les directives de Google.
11. Vérifiez la taille des plans de site dans les fichiers d’index de plan de site
Chaque fichier Sitemap doit être inférieur à 50 Mo. Utilisez le bloc de code Python ci-dessous dans le contexte SEO technique avec Python pour vérifier la taille du fichier sitemap.
pd.pivot_table(sitemap_df[sitemap_df["loc"].duplicated()==True], index="sitemap")
Vous pouvez voir le résultat ci-dessous.
Nous constatons que tous les fichiers XML de plan de site font moins de 50 Mo.
Pour une indexation meilleure et plus rapide, il est avantageux de conserver la valeur et l’unicité des URL du plan du site tout en réduisant la taille des fichiers du plan du site.
12. Vérifiez le nombre d’URL par sitemap avec Python
Chaque URL dans les sitemaps doit avoir moins de 50 000 URL.
Utilisez le bloc de code Python ci-dessous pour vérifier le nombre d’URL dans les fichiers XML du sitemap.
(pd.pivot_table(sitemap_df, values=["loc"], index="sitemap", aggfunc="count") .sort_values(by="loc", ascending=False))
Vous pouvez voir le résultat ci-dessous.
- Tous les sitemaps ont moins de 50 000 URL. Certains sitemaps n’ont qu’une seule URL, ce qui gaspille l’attention du moteur de recherche.
Il est avantageux de conserver les URL de plan de site fréquemment mises à jour différentes des URL de contenu statiques et obsolètes.
Les différences de caractères du nombre d’URL et du contenu de l’URL aident un moteur de recherche à ajuster efficacement la demande d’exploration pour différentes sections de site Web.
13. Vérifiez l’indexation et l’exploration des balises méta à partir du contenu des URL avec Python
Même si une page Web n’est pas interdite à partir de robots.txt, elle peut toujours être interdite à partir des balises Meta HTML.
Ainsi, il est nécessaire de vérifier les balises HTML Meta pour une meilleure indexation et une meilleure exploration.
L’utilisation des « sélecteurs personnalisés » est nécessaire pour effectuer l’audit HTML Meta Tag pour les URL du sitemap.
sitemap = adv.sitemap_to_df("https://www.holisticseo.digital/sitemap.xml")
adv.crawl(url_list=sitemap["loc"][:1000], output_file="meta_command_audit.jl",
follow_links=False,
xpath_selectors= {"meta_command": "//meta[@name="robots"]/@content"},
custom_settings={"CLOSESPIDER_PAGECOUNT":1000})
df_meta_check = pd.read_json("meta_command_audit.jl", lines=True)
df_meta_check["meta_command"].str.contains("nofollow|noindex", regex=True).value_counts()
Le « //méta[@name=”robots”]/@content” Le sélecteur XPATH consiste à extraire toutes les commandes des robots des URL du sitemap.
Nous n’avons utilisé que les 1000 premières URL du sitemap.
Et, j’arrête de ramper après les 1000 réponses initiales.
J’ai utilisé un autre site Web pour vérifier les balises Meta Crawling puisque ComplaintsBoard.com ne l’a pas sur le code source.
Vous pouvez voir le résultat ci-dessous.
- Aucune des URL du sitemap n’a « nofollow » ou « noindex » dans les commandes « Robots ».
Pour vérifier leurs valeurs, utilisez le code ci-dessous.
df_meta_check[df_meta_check["meta_command"].str.contains("nofollow|noindex", regex=True) == False][["url", "meta_command"]]
Vous pouvez voir le résultat ci-dessous.
14. Valider la syntaxe du fichier XML Sitemap avec Python
La validation de la syntaxe du fichier XML Sitemap est nécessaire pour valider l’intégration du fichier Sitemap avec la perception du moteur de recherche.
Même s’il y a certaines erreurs de syntaxe, un moteur de recherche peut reconnaître le fichier sitemap lors de la normalisation XML.
Mais, chaque erreur de syntaxe peut diminuer l’efficacité pour certains niveaux.
Utilisez le bloc de code ci-dessous pour valider la syntaxe du fichier XML Sitemap.
def validate_sitemap_syntax(xml_path: str, xsd_path: str)
xmlschema_doc = etree.parse(xsd_path)
xmlschema = etree.XMLSchema(xmlschema_doc)
xml_doc = etree.parse(xml_path)
result = xmlschema.validate(xml_doc)
return result
validate_sitemap_syntax("sej_sitemap.xml", "sitemap.xsd")
Pour cet exemple, j’ai utilisé « https://www.searchenginejournal.com/sitemap_index.xml ». Le fichier XSD implique le contexte et l’arborescence du fichier XML.
Il est indiqué dans la première ligne du fichier Sitemap comme ci-dessous.
Pour plus d’informations, vous pouvez également consulter la documentation DTD.
15. Vérifiez l’URL Open Graph et la correspondance d’URL canonique
Ce n’est un secret pour personne que les moteurs de recherche utilisent également les URL Open Graph et RSS Feed du code source pour une canonisation et une exploration plus poussées.
Les URL Open Graph doivent être identiques à celles de la soumission d’URL canonique.
De temps en temps, même dans Google Discover, Google choisit d’utiliser l’image de l’Open Graph.
Pour vérifier la cohérence de l’URL Open Graph et de l’URL canonique, utilisez le bloc de code ci-dessous.
for i, df_chunk in enumerate(df_iterator):
if "og:url" in df_chunk.columns:
output_df = pd.DataFrame(data={
"canonical":df_chunk["canonical"],
"og:url":df_chunk["og:url"],
"open_graph_canonical_consistency":df_chunk["canonical"] == df_chunk["og:url"]})
mode="w" if i == 0 else 'a'
header = i == 0
output_df.to_csv(
"open_graph_canonical_consistency.csv",
index=False,
header=header,
mode=mode
)
else:
print("There is no Open Graph URL Property")
There is no Open Graph URL Property
S’il existe une propriété d’URL Open Graph sur le site Web, un fichier CSV sera fourni pour vérifier si l’URL canonique et l’URL Open Graph sont identiques ou non.
Mais pour ce site Web, nous n’avons pas d’URL Open Graph.
Ainsi, j’ai utilisé un autre site Web pour l’audit.
if "og:url" in df_meta_check.columns:
output_df = pd.DataFrame(data={
"canonical":df_meta_check["canonical"],
"og:url":df_meta_check["og:url"],
"open_graph_canonical_consistency":df_meta_check["canonical"] == df_meta_check["og:url"]})
mode="w" if i == 0 else 'a'
#header = i == 0
output_df.to_csv(
"df_og_url_canonical_audit.csv",
index=False,
#header=header,
mode=mode
)
else:
print("There is no Open Graph URL Property")
df = pd.read_csv("df_og_url_canonical_audit.csv")
df
Vous pouvez voir le résultat ci-dessous.
Nous voyons que toutes les URL canoniques et les URL Open Graph sont les mêmes.
16. Vérifiez les URL en double dans les soumissions de plan de site
Un fichier d’index de plan de site ne doit pas avoir d’URL en double dans différents fichiers de plan de site ou dans le même fichier XML de plan de site.
La duplication des URL dans les fichiers de plan de site peut faire en sorte qu’un moteur de recherche télécharge moins les fichiers de plan de site, car un certain pourcentage du fichier de plan de site est gonflé de soumissions inutiles.
Dans certaines situations, cela peut apparaître comme une tentative de spam pour contrôler les schémas d’exploration des robots des moteurs de recherche.
utilisez le bloc de code ci-dessous pour vérifier les URL en double dans les soumissions de sitemap.
sitemap_df["loc"].duplicated().value_counts()
Vous pouvez voir que les 49574 URL du sitemap sont dupliquées.
Pour voir quels sitemaps ont le plus d’URL dupliquées, utilisez le bloc de code ci-dessous.
pd.pivot_table(sitemap_df[sitemap_df["loc"].duplicated()==True], index="sitemap", values="loc", aggfunc="count").sort_values(by="loc", ascending=False)
Vous pouvez voir le résultat.
Le découpage des sitemaps peut aider à l’analyse de l’arborescence du site et du référencement technique.
Pour voir les URL en double dans le sitemap, utilisez le bloc de code ci-dessous.
sitemap_df[sitemap_df["loc"].duplicated() == True]
Vous pouvez voir le résultat ci-dessous.
Conclusion
Je voulais montrer comment valider un fichier sitemap pour une indexation et une exploration meilleures et plus saines pour le référencement technique.
Python est largement utilisé pour la science des données, l’apprentissage automatique et le traitement du langage naturel.
Mais, vous pouvez également l’utiliser pour des audits SEO techniques afin de soutenir les autres verticales SEO avec une approche SEO holistique.
Dans un prochain article, nous pourrons développer davantage ces audits SEO techniques avec différents détails et méthodes.
Mais, en général, il s’agit de l’un des guides de référencement technique les plus complets pour les plans de site et le didacticiel d’audit de plan de site avec Python.
Davantage de ressources:
- Comment utiliser Python pour analyser les données SEO : un guide de référence
- 10 facteurs de contenu de site Web que vous devez vérifier lors d’un audit SEO
- Référencement technique avancé : un guide complet
Image en vedette : elenasavchina2/Shutterstock
