5 script Python per automatizzare le attività SEO

Python è un potente linguaggio di programmazione che ha guadagnato popolarità nel settore SEO negli ultimi anni.

Con la sua sintassi relativamente semplice, le prestazioni efficienti e l'abbondanza di librerie e framework, Python ha rivoluzionato il modo in cui molti SEO si avvicinano al loro lavoro.

Python offre un set di strumenti versatile che può aiutare a rendere il processo di ottimizzazione più veloce, accurato ed efficace.

Questo articolo esplora cinque script Python per aiutarti a potenziare i tuoi sforzi SEO.

• Automatizza una mappa di reindirizzamento.
• Scrivi meta descrizioni in blocco.
• Analizza le parole chiave con N-grammi.
• Raggruppa le parole chiave in gruppi di argomenti.
• Abbina l'elenco di parole chiave a un elenco di argomenti predefiniti.

Il modo più semplice per iniziare con Python

Se stai cercando di immergerti nella programmazione Python, vale la pena prendere in considerazione Google Colab.

È una piattaforma gratuita basata sul Web che fornisce un comodo parco giochi per scrivere ed eseguire codice Python senza bisogno di una complessa configurazione locale.

In sostanza, ti consente di accedere a Jupyter Notebook all'interno del tuo browser e fornisce una serie di librerie preinstallate per la scienza dei dati e l'apprendimento automatico.

Inoltre, è basato su Google Drive, quindi puoi salvare e condividere facilmente il tuo lavoro con altri.

Per iniziare, segui questi passaggi:

Abilita i caricamenti di file

Dopo aver aperto Google Colab, devi prima abilitare la possibilità di creare un repository di file temporanei. È semplice come fare clic sull'icona della cartella.

Ciò ti consente di caricare file temporanei e quindi di scaricare i file dei risultati.

Carica i dati di origine

Molti dei nostri script Python richiedono un file sorgente per funzionare. Per caricare un file, è sufficiente fare clic sul pulsante di caricamento.

Una volta terminata la configurazione, puoi iniziare a testare i seguenti script Python.

Script 1: automatizza una mappa di reindirizzamento

La creazione di mappe di reindirizzamento per siti di grandi dimensioni può richiedere molto tempo. Trovare modi per automatizzare il processo può aiutarci a risparmiare tempo e concentrarci su altre attività.

Come funziona questo script

Questo script si concentra sull'analisi del contenuto web per trovare articoli strettamente corrispondenti.

• Innanzitutto, importa due file TXT di URL: uno è per il sito Web reindirizzato (source_urls.txt) e l'altro per il sito che assorbe il sito Web reindirizzato (target_urls.txt).
• Quindi, usiamo la libreria Python Beautiful Soup per creare un web scraper per ottenere il contenuto del corpo principale della pagina. Questo script ignora il contenuto di intestazione e piè di pagina.
• Dopo aver eseguito la scansione del contenuto su tutte le pagine, utilizza la libreria Python Polyfuzz per abbinare il contenuto tra gli URL con una percentuale di somiglianza.
• Infine, stampa i risultati in un file CSV, inclusa la percentuale di somiglianza.

Da qui, puoi esaminare manualmente tutti gli URL con una bassa percentuale di somiglianza per trovare la successiva corrispondenza più vicina.

Prendi la sceneggiatura

 #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)

Script 2: Scrivi meta descrizioni in blocco

Sebbene le meta descrizioni non siano un fattore di ranking diretto, ci aiutano a migliorare le nostre percentuali di clic organiche. Lasciare vuote le meta descrizioni aumenta le possibilità che Google ne crei una propria.

Se il tuo audit SEO mostra un gran numero di URL privi di una meta descrizione, potrebbe essere difficile trovare il tempo per scriverli tutti a mano, specialmente per i siti di e-commerce.

Questo script ha lo scopo di aiutarti a risparmiare tempo automatizzando quel processo per te.

Come funziona la sceneggiatura

• Innanzitutto, lo script importa un elenco di URL da un file TXT (urls.txt).
• Quindi, analizza tutto il contenuto degli URL.
• Una volta analizzato il contenuto, crea meta descrizioni che mirano a essere inferiori a 155 caratteri.
• Esporta i risultati in un file CSV.

Prendi la sceneggiatura

 !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: analizza le parole chiave con N-grammi

Gli N-grammi non sono un concetto nuovo ma sono comunque utili per la SEO. Possono aiutarci a comprendere i temi di grandi insiemi di dati sulle parole chiave.

Come funziona questo script

Questo script restituisce i risultati in un file TXT che suddivide le parole chiave in unigrammi, bigrammi e trigrammi.

• Innanzitutto, importa un file TXT di tutte le tue parole chiave (keyword.txt).
• Quindi utilizza una libreria Python chiamata Counter per analizzare ed estrarre gli N-grammi.
• Quindi esporta i risultati in un nuovo file TXT.

Ottieni questo copione

 #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: raggruppa le parole chiave in gruppi di argomenti

Con i nuovi progetti SEO, la ricerca di parole chiave è sempre nelle fasi iniziali. A volte abbiamo a che fare con migliaia di parole chiave in un set di dati, rendendo difficile il raggruppamento.

Python ci consente di raggruppare automaticamente le parole chiave in gruppi simili per identificare le tendenze e completare la nostra mappatura delle parole chiave.

Come funziona questo script

• Questo script importa innanzitutto un file TXT di parole chiave (keywords.txt).
• Quindi lo script analizza le parole chiave utilizzando TfidfVectorizer e AffinityPropagation.
• Quindi assegna un valore numerico a ciascun cluster di argomenti.
• I risultati vengono quindi esportati in un file csv.

Ottieni questo copione

 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: abbina l'elenco di parole chiave a un elenco di argomenti predefiniti

Questo è simile allo script precedente, tranne per il fatto che ti consente di abbinare un elenco di parole chiave a un insieme predefinito di argomenti.

Questo è ottimo per grandi serie di parole chiave perché le elabora in batch di 1.000 per prevenire arresti anomali del sistema.

Come funziona questo script

• Questo script importa un elenco di parole chiave (keywords.txt) e un elenco di argomenti (topics.txt).
• Quindi analizza gli argomenti e gli elenchi di parole chiave e li abbina alla corrispondenza più vicina. Se non trova una corrispondenza, lo classifica come altro.
• I risultati vengono quindi esportati in un file CSV.

Ottieni questo copione

 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)

Lavorare con Python per la SEO

Python è uno strumento incredibilmente potente e versatile per i professionisti SEO.

Che tu sia un principiante o un professionista esperto, gli script gratuiti che ho condiviso in questo articolo offrono un ottimo punto di partenza per esplorare le possibilità di Python nella SEO.

Con la sua sintassi intuitiva e la vasta gamma di librerie, Python può aiutarti ad automatizzare attività noiose, analizzare dati complessi e ottenere nuove informazioni sulle prestazioni del tuo sito web. Allora perché non fare un tentativo?

Buona fortuna e buona programmazione!