Apprendre à coder, que ce soit avec Python, JavaScript ou un autre langage de programmation, présente de nombreux avantages, notamment la possibilité de travailler avec des ensembles de données plus volumineux et d’automatiser les tâches répétitives.

Mais malgré les avantages, de nombreux professionnels du référencement n’ont pas encore fait la transition – et je comprends parfaitement pourquoi ! Ce n’est pas une compétence essentielle pour le référencement, et nous sommes tous des gens occupés.

Si vous êtes pressé par le temps et que vous savez déjà comment accomplir une tâche dans Excel ou Google Sheets, changer de cap peut donner l’impression de réinventer la roue.

Lorsque j’ai commencé à coder, je n’utilisais initialement Python que pour des tâches que je ne pouvais pas accomplir dans Excel – et il a fallu plusieurs années pour en arriver au point où c’est mon choix de facto pour le traitement des données.

Avec le recul, je suis incroyablement heureux d’avoir persisté, mais c’était parfois une expérience frustrante, avec plusieurs heures passées à analyser des fils de discussion sur Stack Overflow.

Cet article est conçu pour épargner le même sort aux autres professionnels du référencement.

Dans celui-ci, nous couvrirons les équivalents Python des formules et fonctionnalités Excel les plus couramment utilisées pour l’analyse des données SEO – qui sont toutes disponibles dans un bloc-notes Google Colab lié dans le résumé.

Plus précisément, vous apprendrez les équivalents de :

  • LEN.
  • Supprimez les doublons.
  • Texte aux colonnes.
  • RECHERCHER/TROUVER.
  • ENCHAÎNER.
  • Trouver et remplacer.
  • GAUCHE/MILIEU/DROITE.
  • SI.
  • IFS.
  • RECHERCHEV.
  • COUNTIF/SUMIF/AVERAGEIF.
  • Tableaux croisés dynamiques.

Étonnamment, pour accomplir tout cela, nous utiliserons principalement une bibliothèque singulière – Pandas – avec un peu d’aide par endroits de son grand frère, NumPy.

Conditions préalables

Par souci de brièveté, il y a quelques points que nous n’aborderons pas aujourd’hui, notamment :

  • Installation de Python.
  • Pandas de base, comme l’importation de CSV, le filtrage et la prévisualisation des dataframes.

Si vous n’êtes pas sûr de tout cela, alors le guide de Hamlet sur l’analyse de données Python pour le référencement est l’introduction parfaite.

Maintenant, sans plus tarder, commençons.

LEN

LEN fournit un décompte du nombre de caractères dans une chaîne de texte.

Pour le référencement en particulier, un cas d’utilisation courant consiste à mesurer la longueur des balises de titre ou des méta-descriptions pour déterminer si elles seront tronquées dans les résultats de recherche.

Dans Excel, si nous voulions compter la deuxième cellule de la colonne A, nous saisirions :

=LEN(A2)
Formule LEN excel

Python n’est pas trop différent, car nous pouvons compter sur la fonction len intégrée, qui peut être combinée avec la loc de Pandas[] pour accéder à une ligne de données spécifique dans une colonne :

len(df['Title'].loc[0])

Dans cet exemple, nous obtenons la longueur de la première ligne dans la colonne « Titre » de notre dataframe.

len fonction python
Capture d’écran de VS Code, novembre 2022

Cependant, trouver la longueur d’une cellule n’est pas très utile pour le référencement. Normalement, nous voudrions appliquer une fonction à une colonne entière !

Dans Excel, cela serait réalisé en sélectionnant la cellule de formule dans le coin inférieur droit et en la faisant glisser vers le bas ou en double-cliquant.

Lorsque vous travaillez avec une base de données Pandas, nous pouvons utiliser str.len pour calculer la longueur des lignes d’une série, puis stocker les résultats dans une nouvelle colonne :

df['Length'] = df['Title'].str.len()

Str.len est une opération « vectorisée », conçue pour être appliquée simultanément à une série de valeurs. Nous utiliserons ces opérations de manière intensive tout au long de cet article, car elles finissent presque universellement par être plus rapides qu’une boucle.

Une autre application courante de LEN consiste à le combiner avec SUBSTITUTE pour compter le nombre de mots dans une cellule :

=LEN(TRIM(A2))-LEN(SUBSTITUTE(A2," ",""))+1

Dans Pandas, nous pouvons y parvenir en combinant les fonctions str.split et str.len :

df['No. Words'] = df['Title'].str.split().str.len()

Nous aborderons str.split plus en détail plus tard, mais essentiellement, ce que nous faisons est de diviser nos données en fonction des espaces dans la chaîne, puis de compter le nombre de composants.

nombre de mots Python

Suppression des doublons

La fonction « Supprimer les doublons » d’Excel offre un moyen simple de supprimer les valeurs en double dans un ensemble de données, soit en supprimant les lignes entièrement en double (lorsque toutes les colonnes sont sélectionnées), soit en supprimant les lignes avec les mêmes valeurs dans des colonnes spécifiques.

Excel supprime les doublons

Dans Pandas, cette fonctionnalité est fournie par drop_duplicates.

Pour supprimer les lignes en double dans un type de dataframe :

df.drop_duplicates(inplace=True)

Pour supprimer des lignes basées sur des doublons dans une colonne unique, incluez le paramètre de sous-ensemble :

df.drop_duplicates(subset="column", inplace=True)

Ou spécifiez plusieurs colonnes dans une liste :

df.drop_duplicates(subset=['column','column2'], inplace=True)

Un ajout ci-dessus qui mérite d’être signalé est la présence du paramètre inplace. Inclure inplace=True nous permet d’écraser notre dataframe existant sans avoir besoin d’en créer un nouveau.

Il y a, bien sûr, des moments où nous voulons conserver nos données brutes. Dans ce cas, nous pouvons affecter notre dataframe dédupliqué à une variable différente :

df2 = df.drop_duplicates(subset="column")

Texte aux colonnes

Un autre élément essentiel de tous les jours, la fonction « texte en colonnes » peut être utilisée pour diviser une chaîne de texte en fonction d’un délimiteur, tel qu’une barre oblique, une virgule ou un espace.

Par exemple, diviser une URL en son domaine et ses sous-dossiers individuels.

Excel supprime les doublons

Lorsqu’il s’agit d’une trame de données, nous pouvons utiliser la fonction str.split, qui crée une liste pour chaque entrée d’une série. Cela peut être converti en plusieurs colonnes en définissant le paramètre expand sur True :

df['URL'].str.split(pat="/", expand=True)
str diviser Python

Comme c’est souvent le cas, nos URL dans l’image ci-dessus ont été divisées en colonnes incohérentes, car elles ne comportent pas le même nombre de dossiers.

Cela peut compliquer les choses lorsque nous voulons enregistrer nos données dans une base de données existante.

Spécifier le paramètre n limite le nombre de divisions, nous permettant de créer un nombre spécifique de colonnes :

df[['Domain', 'Folder1', 'Folder2', 'Folder3']] = df['URL'].str.split(pat="/", expand=True, n=3)

Une autre option consiste à utiliser pop pour supprimer votre colonne du dataframe, effectuer la scission, puis la rajouter avec la fonction join :

df = df.join(df.pop('Split').str.split(pat="/", expand=True))

La duplication de l’URL dans une nouvelle colonne avant le fractionnement nous permet de conserver l’URL complète. On peut alors renommer les nouvelles colonnes :🐆

df['Split'] = df['URL']

df = df.join(df.pop('Split').str.split(pat="/", expand=True))

df.rename(columns = {0:'Domain', 1:'Folder1', 2:'Folder2', 3:'Folder3', 4:'Parameter'}, inplace=True)
Fonctions de jointure pop fractionnées Python

ENCHAÎNER

La fonction CONCAT permet aux utilisateurs de combiner plusieurs chaînes de texte, par exemple lors de la génération d’une liste de mots-clés en ajoutant différents modificateurs.

Dans ce cas, nous ajoutons « mens » et un espace blanc à la liste des types de produits de la colonne A :

=CONCAT($F$1," ",A2)
concaténer Excel
Capture d’écran de Microsoft Excel, novembre 2022

En supposant que nous ayons affaire à des chaînes, la même chose peut être obtenue en Python en utilisant l’opérateur arithmétique :

df['Combined] = 'mens' + ' ' + df['Keyword']

Ou spécifiez plusieurs colonnes de données :

df['Combined'] = df['Subdomain'] + df['URL']
concat Python

Pandas a une fonction concat dédiée, mais cela est plus utile lorsque vous essayez de combiner plusieurs dataframes avec les mêmes colonnes.

Par exemple, si nous avions plusieurs exportations depuis notre outil d’analyse de liens préféré :

df = pd.read_csv('data.csv')
df2 = pd.read_csv('data2.csv')
df3 = pd.read_csv('data3.csv')

dflist = [df, df2, df3]

df = pd.concat(dflist, ignore_index=True)

CHERCHER/TROUVER

Les formules SEARCH et FIND permettent de localiser une sous-chaîne dans une chaîne de texte.

Ces commandes sont généralement combinées avec ISNUMBER pour créer une colonne booléenne qui permet de filtrer un ensemble de données, ce qui peut être extrêmement utile lors de l’exécution de tâches telles que l’analyse des fichiers journaux, comme expliqué dans ce guide. Par exemple:

=ISNUMBER(SEARCH("searchthis",A2)
recherche isnumber Excel

La différence entre SEARCH et FIND est que find est sensible à la casse.

La fonction Pandas équivalente, str.contains, est sensible à la casse par défaut :

df['Journal'] = df['URL'].str.contains('engine', na=False)

L’insensibilité à la casse peut être activée en définissant le paramètre case sur False :

df['Journal'] = df['URL'].str.contains('engine', case=False, na=False)

Dans les deux cas, inclure na=False empêchera les valeurs nulles d’être renvoyées dans la colonne booléenne.

Un énorme avantage de l’utilisation de Pandas ici est que, contrairement à Excel, regex est pris en charge de manière native par cette fonction – comme c’est le cas dans les feuilles Google via REGEXMATCH.

Enchaînez plusieurs sous-chaînes à l’aide du caractère pipe, également connu sous le nom d’opérateur OR :

df['Journal'] = df['URL'].str.contains('engine|search', na=False)

Trouver et remplacer

La fonction « Rechercher et remplacer » d’Excel offre un moyen simple de remplacer individuellement ou en bloc une sous-chaîne par une autre.

trouver remplacer Excel

Lors du traitement des données pour le référencement, nous sommes plus susceptibles de sélectionner une colonne entière et de « Remplacer tout ».

La formule SUBSTITUTE fournit une autre option ici et est utile si vous ne souhaitez pas écraser la colonne existante.

Par exemple, nous pouvons changer le protocole d’une URL de HTTP à HTTPS, ou le supprimer en le remplaçant par rien.

Lorsque vous travaillez avec des dataframes en Python, nous pouvons utiliser str.replace :

df['URL'] = df['URL'].str.replace('http://', 'https://')

Ou:

df['URL'] = df['URL'].str.replace('http://', '') # replace with nothing

Encore une fois, contrairement à Excel, regex peut être utilisé – comme avec REGEXREPLACE de Google Sheets :

df['URL'] = df['URL'].str.replace('http://|https://', '')

Alternativement, si vous souhaitez remplacer plusieurs sous-chaînes par des valeurs différentes, vous pouvez utiliser la méthode de remplacement de Python et fournir une liste.

Cela vous évite d’avoir à enchaîner plusieurs fonctions str.replace :

df['URL'] = df['URL'].replace(['http://', ' https://'], ['https://www.', 'https://www.’], regex=True)

GAUCHE/MILIEU/DROITE

L’extraction d’une sous-chaîne dans Excel nécessite l’utilisation des fonctions LEFT, MID ou RIGHT, selon l’emplacement de la sous-chaîne dans une cellule.

Supposons que nous souhaitions extraire le domaine et le sous-domaine racine d’une URL :

=MID(A2,FIND(":",A2,4)+3,FIND("/",A2,9)-FIND(":",A2,4)-3)
gauche milieu droite Excel

Utilisant une combinaison de MID et de plusieurs fonctions FIND, cette formule est moche, c’est le moins qu’on puisse dire – et les choses s’aggravent pour les extractions plus complexes.

Encore une fois, Google Sheets le fait mieux qu’Excel, car il a REGEXEXTRACT.

Quel dommage que lorsque vous l’alimentez avec des jeux de données plus volumineux, il fonde plus rapidement qu’un Babybel sur un radiateur chaud.

Heureusement, Pandas propose str.extract, qui fonctionne de manière similaire :

df['Domain'] = df['URL'].str.extract('.*://?([^/]+)')
str extrait Python

Combinez avec fillna pour éviter les valeurs nulles, comme vous le feriez dans Excel avec IFERROR :

df['Domain'] = df['URL'].str.extract('.*://?([^/]+)').fillna('-')

Si

Les instructions IF vous permettent de renvoyer différentes valeurs, selon qu’une condition est remplie ou non.

Pour illustrer, supposons que nous voulions créer une étiquette pour les mots clés qui se classent dans les trois premières positions.

Excel SI

Plutôt que d’utiliser Pandas dans ce cas, nous pouvons nous appuyer sur NumPy et la fonction where (n’oubliez pas d’importer NumPy, si vous ne l’avez pas déjà fait) :

df['Top 3'] = np.where(df['Position'] <= 3, 'Top 3', 'Not Top 3')

Plusieurs conditions peuvent être utilisées pour la même évaluation en utilisant les opérateurs AND/OR et en plaçant les critères individuels entre parenthèses :

df['Top 3'] = np.where((df['Position'] <= 3) & (df['Position'] != 0), 'Top 3', 'Not Top 3')

Dans ce qui précède, nous renvoyons « Top 3 » pour tous les mots clés avec un classement inférieur ou égal à trois, à l’exclusion de tous les mots clés classés en position zéro.

IFS

Parfois, plutôt que de spécifier plusieurs conditions pour la même évaluation, vous souhaiterez peut-être plusieurs conditions renvoyant des valeurs différentes.

Dans ce cas, la meilleure solution consiste à utiliser IFS :

=IFS(B2<=3,"Top 3",B2<=10,"Top 10",B2<=20,"Top 20")
Excel IFS

Encore une fois, NumPy nous fournit la meilleure solution lorsque nous travaillons avec des dataframes, via sa fonction select.

Avec select, nous pouvons créer une liste de conditions, de choix et une valeur facultative lorsque toutes les conditions sont fausses :

conditions = [df['Position'] <= 3, df['Position'] <= 10, df['Position'] <=20]

choices = ['Top 3', 'Top 10', 'Top 20']

df['Rank'] = np.select(conditions, choices, 'Not Top 20')

Il est également possible d’avoir plusieurs conditions pour chacune des évaluations.

Supposons que nous travaillions avec un détaillant de commerce électronique avec des pages de liste de produits (PLP) et des pages d’affichage de produits (PDP), et nous voulons étiqueter le type de pages de marque se classant dans les 10 premiers résultats.

La solution la plus simple consiste à rechercher des modèles d’URL spécifiques, tels qu’un sous-dossier ou une extension, mais que se passe-t-il si des concurrents ont des modèles similaires ?

Dans ce scénario, nous pourrions faire quelque chose comme ceci :

conditions = [(df['URL'].str.contains('/category/')) & (df['Brand Rank'] > 0),
(df['URL'].str.contains('/product/')) & (df['Brand Rank'] > 0),
(~df['URL'].str.contains('/product/')) & (~df['URL'].str.contains('/category/')) & (df['Brand Rank'] > 0)]

choices = ['PLP', 'PDP', 'Other']

df['Brand Page Type'] = np.select(conditions, choices, None)

Ci-dessus, nous utilisons str.contains pour évaluer si une URL dans le top 10 correspond ou non au modèle de notre marque, puis utilisons la colonne « Brand Rank » pour exclure tous les concurrents.

Dans cet exemple, le signe tilde (~) indique une correspondance négative. En d’autres termes, nous disons que nous voulons que chaque URL de marque qui ne correspond pas au modèle d’un « PDP » ou d’un « PLP » corresponde aux critères de « Autre ».

Enfin, None est inclus car nous voulons que les résultats sans marque renvoient une valeur nulle.

np sélectionner Python

RECHERCHEV

VLOOKUP est un outil essentiel pour réunir deux ensembles de données distincts sur une colonne commune.

Dans ce cas, en ajoutant les URL de la colonne N aux données de mot-clé, de position et de volume de recherche dans les colonnes AC, à l’aide de la colonne « Mot-clé » partagée :

=VLOOKUP(A2,M:N,2,FALSE)
vrecherche Excel

Pour faire quelque chose de similaire avec Pandas, nous pouvons utiliser merge.

Répliquant la fonctionnalité d’une jointure SQL, la fusion est une fonction incroyablement puissante qui prend en charge une variété de types de jointures différents.

Pour nos besoins, nous souhaitons utiliser une jointure gauche, qui conservera notre première trame de données et ne fusionnera que les valeurs correspondantes de notre deuxième trame de données :

mergeddf = df.merge(df2, how='left', on='Keyword')

Un avantage supplémentaire d’effectuer une fusion sur un VLOOKUP, c’est que vous n’avez pas besoin d’avoir les données partagées dans la première colonne du deuxième ensemble de données, comme avec le plus récent XLOOKUP.

Il extraira également plusieurs lignes de données plutôt que la première correspondance dans les découvertes.

Un problème courant lors de l’utilisation de la fonction est la duplication de colonnes indésirables. Cela se produit lorsque plusieurs colonnes partagées existent, mais que vous tentez de faire correspondre une seule.

Pour éviter cela et améliorer la précision de vos correspondances, vous pouvez spécifier une liste de colonnes :

mergeddf = df.merge(df2, how='left', on=['Keyword', 'Search Volume'])

Dans certains scénarios, vous pouvez souhaiter activement que ces colonnes soient incluses. Par exemple, lorsque vous essayez de fusionner plusieurs rapports de classement mensuel :

mergeddf = df.merge(df2, on='Keyword', how='left', suffixes=('', '_october'))
    .merge(df3, on='Keyword', how='left', suffixes=('', '_september'))

L’extrait de code ci-dessus exécute deux fusions pour réunir trois dataframes avec les mêmes colonnes – qui sont nos classements pour novembre, octobre et septembre.

En étiquetant les mois dans les paramètres de suffixe, nous nous retrouvons avec une trame de données beaucoup plus propre qui affiche clairement le mois, par opposition aux valeurs par défaut de _x et _y vues dans l’exemple précédent.

Python multi-fusion

COUNTIF/SUMIF/AVERAGEIF

Dans Excel, si vous souhaitez exécuter une fonction statistique basée sur une condition, vous utiliserez probablement COUNTIF, SUMIF ou AVERAGEIF.

Généralement, COUNTIF est utilisé pour déterminer combien de fois une chaîne spécifique apparaît dans un ensemble de données, comme une URL.

Nous pouvons y parvenir en déclarant la colonne « URL » comme plage, puis l’URL dans une cellule individuelle comme critère :

=COUNTIF(D:D,D2)
Comptage Excel

Dans Pandas, nous pouvons obtenir le même résultat en utilisant la fonction groupby :

df.groupby('URL')['URL'].count()
Groupe Python par

Ici, la colonne déclarée entre parenthèses indique les groupes individuels, et la colonne indiquée entre crochets est celle où l’agrégation (c’est-à-dire le comptage) est effectuée.

La sortie que nous recevons n’est cependant pas parfaite pour ce cas d’utilisation, car elle consolide les données.

En règle générale, lors de l’utilisation d’Excel, nous aurions le nombre d’URL en ligne dans notre ensemble de données. Ensuite, nous pouvons l’utiliser pour filtrer les URL les plus fréquemment répertoriées.

Pour ce faire, utilisez transform et stockez le résultat dans une colonne :

df['URL Count'] = df.groupby('URL')['URL'].transform('count')
Transformation groupée Python

Vous pouvez également appliquer des fonctions personnalisées à des groupes de données en utilisant une fonction lambda (anonyme) :

df['Google Count'] = df.groupby(['URL'])['URL'].transform(lambda x: x[x.str.contains('google')].count())

Jusqu’à présent, dans nos exemples, nous avons utilisé la même colonne pour nos regroupements et nos agrégations, mais ce n’est pas nécessaire. Comme pour COUNTIFS/SUMIFS/AVERAGEIFS dans Excel, il est possible de regrouper en utilisant une colonne, puis d’appliquer notre fonction statistique à une autre.

Pour en revenir à l’exemple précédent de page de résultats de moteur de recherche (SERP), nous pouvons vouloir compter tous les PDP de classement par mot clé et renvoyer ce nombre avec nos données existantes :

df['PDP Count'] = df.groupby(['Keyword'])['URL'].transform(lambda x: x[x.str.contains('/product/|/prd/|/pd/')].count())
Python groupe par countifs

Ce qui, dans le langage Excel, ressemblerait à ceci :

=SUM(COUNTIFS(A:A,[@Keyword],D:D,{"*/product/*","*/prd/*","*/pd/*"}))

Tableaux croisés dynamiques

Dernier point, mais non des moindres, il est temps de parler des tableaux croisés dynamiques.

Dans Excel, un tableau croisé dynamique sera probablement notre première escale si nous voulons résumer un grand ensemble de données.

Par exemple, lorsque vous travaillez avec des données de classement, nous pouvons souhaiter identifier les URL qui apparaissent le plus fréquemment et leur position de classement moyenne.

tableau croisé dynamique Excel

Encore une fois, Pandas a ses propres tableaux croisés dynamiques équivalents – mais si tout ce que vous voulez est un nombre de valeurs uniques dans une colonne, cela peut être accompli en utilisant la fonction value_counts :

count = df['URL'].value_counts()

L’utilisation de groupby est également une option.

Plus tôt dans l’article, effectuer un groupby qui agrégeait nos données n’était pas ce que nous voulions – mais c’est précisément ce qui est requis ici :

grouped = df.groupby('URL').agg(
     url_frequency=('Keyword', 'count'),
     avg_position=('Position', 'mean'),
     )

grouped.reset_index(inplace=True)
groupby-pivot Python

Deux fonctions d’agrégation ont été appliquées dans l’exemple ci-dessus, mais cela pourrait facilement être étendu et 13 types différents sont disponibles.

Il y a, bien sûr, des moments où nous voulons utiliser pivot_table, comme lors de l’exécution d’opérations multidimensionnelles.

Pour illustrer ce que cela signifie, réutilisons les regroupements de classement que nous avons créés à l’aide d’instructions conditionnelles et essayons d’afficher le nombre de fois qu’une URL se classe dans chaque groupe.

ranking_groupings = df.groupby(['URL', 'Grouping']).agg(
     url_frequency=('Keyword', 'count'),
     )
python groupby regroupement

Ce n’est pas le meilleur format à utiliser, car plusieurs lignes ont été créées pour chaque URL.

Au lieu de cela, nous pouvons utiliser pivot_table, qui affichera les données dans différentes colonnes :

pivot = pd.pivot_table(df,
index=['URL'],
columns=['Grouping'],
aggfunc="size",
fill_value=0,
)
tableau croisé dynamique Python

Dernières pensées

Que vous cherchiez de l’inspiration pour commencer à apprendre Python ou que vous l’utilisiez déjà dans vos flux de travail SEO, j’espère que les exemples ci-dessus vous aideront tout au long de votre parcours.

Comme promis, vous pouvez trouver un bloc-notes Google Colab avec tous les extraits de code ici.

En vérité, nous avons à peine effleuré la surface de ce qui est possible, mais comprendre les bases de l’analyse de données Python vous donnera une base solide sur laquelle construire.

Davantage de ressources:

  • Essayez ces outils et méthodes pour exporter les résultats de recherche Google vers Excel
  • 12 points de données SEO essentiels pour tout site Web
  • Référencement technique avancé : un guide complet

Image en vedette : mapo_japan/Shutterstock

LAISSER UN COMMENTAIRE

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