5 scripts de Python para automatizar tareas de SEO

Python es un poderoso lenguaje de programación que ha ganado popularidad en la industria de SEO en los últimos años.

Con su sintaxis relativamente simple, rendimiento eficiente y abundancia de bibliotecas y marcos, Python ha revolucionado la forma en que muchos SEO abordan su trabajo.

Python ofrece un conjunto de herramientas versátil que puede ayudar a que el proceso de optimización sea más rápido, más preciso y más efectivo.

Este artículo explora cinco secuencias de comandos de Python para ayudar a impulsar sus esfuerzos de SEO.

• Automatice un mapa de redirección.
• Escribe meta descripciones a granel.
• Analice palabras clave con N-gramas.
• Agrupe las palabras clave en grupos de temas.
• Haga coincidir la lista de palabras clave con una lista de temas predefinidos.

La forma más fácil de comenzar con Python

Si está buscando sumergirse en la programación de Python, vale la pena considerar Google Colab.

Es una plataforma gratuita basada en la web que proporciona un campo de juego conveniente para escribir y ejecutar código de Python sin necesidad de una configuración local compleja.

Esencialmente, le permite acceder a Jupyter Notebooks dentro de su navegador y proporciona una gran cantidad de bibliotecas preinstaladas para ciencia de datos y aprendizaje automático.

Además, se basa en Google Drive, por lo que puede guardar y compartir fácilmente su trabajo con otros.

Para empezar, sigue estos pasos:

Habilitar carga de archivos

Una vez que abra Google Colab, primero deberá habilitar la capacidad de crear un repositorio de archivos temporales. Es tan simple como hacer clic en el icono de la carpeta.

Esto le permite cargar archivos temporales y luego descargar cualquier archivo de resultados.

Subir datos de origen

Muchos de nuestros scripts de Python requieren un archivo fuente para funcionar. Para cargar un archivo, simplemente haga clic en el botón de carga.

Una vez que termine la configuración, puede comenzar a probar los siguientes scripts de Python.

Guión 1: Automatizar un mapa de redirección

La creación de mapas de redireccionamiento para sitios grandes puede llevar mucho tiempo. Encontrar formas de automatizar el proceso puede ayudarnos a ahorrar tiempo y centrarnos en otras tareas.

Cómo funciona este guión

Este script se enfoca en analizar el contenido web para encontrar artículos que coincidan estrechamente.

• Primero, importa dos archivos TXT de URL: uno es para el sitio web redirigido (source_urls.txt) y el otro para el sitio que absorbe el sitio web redirigido (target_urls.txt).
• Luego, usamos la biblioteca de Python Beautiful Soup para crear un web scraper para obtener el contenido del cuerpo principal de la página. Este script ignora el contenido del encabezado y pie de página.
• Después de rastrear el contenido de todas las páginas, utiliza la biblioteca Polyfuzz de Python para hacer coincidir el contenido entre las URL con un porcentaje de similitud.
• Finalmente, imprime los resultados en un archivo CSV, incluyendo el porcentaje de similitud.

Desde aquí, puede revisar manualmente cualquier URL con un porcentaje de similitud bajo para encontrar la siguiente coincidencia más cercana.

Obtener el guión

 #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: escribir meta descripciones en masa

Si bien las metadescripciones no son un factor de clasificación directo, nos ayudan a mejorar nuestras tasas de clics orgánicos. Dejar las metadescripciones en blanco aumenta las posibilidades de que Google cree las suyas propias.

Si su auditoría de SEO muestra una gran cantidad de URL a las que les falta una meta descripción, puede ser difícil hacer tiempo para escribirlas todas a mano, especialmente para los sitios web de comercio electrónico.

Este script tiene como objetivo ayudarlo a ahorrar tiempo al automatizar ese proceso por usted.

Cómo funciona el guión

• Primero, el script importa una lista de URL desde un archivo TXT (urls.txt).
• Luego, analiza todo el contenido de las URL.
• Una vez que se analiza el contenido, crea metadescripciones con el objetivo de tener menos de 155 caracteres.
• Exporta los resultados a un archivo CSV.

Obtener el guión

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

Guión 3: analizar palabras clave con N-gramas

Los N-gramas no son un concepto nuevo, pero siguen siendo útiles para SEO. Pueden ayudarnos a comprender temas en grandes conjuntos de datos de palabras clave.

Cómo funciona este guión

Esta secuencia de comandos genera resultados en un archivo TXT que divide las palabras clave en unigramas, bigramas y trigramas.

• Primero, importa un archivo TXT de todas sus palabras clave (keyword.txt).
• Luego usa una biblioteca de Python llamada Counter para analizar y extraer los N-gramas.
• Luego exporta los resultados en un nuevo archivo TXT.

Obtén este guión

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

Guión 4: Agrupar palabras clave en grupos de temas

Con los nuevos proyectos de SEO, la investigación de palabras clave siempre se encuentra en las primeras etapas. A veces tratamos con miles de palabras clave en un conjunto de datos, lo que dificulta la agrupación.

Python nos permite agrupar automáticamente palabras clave en grupos similares para identificar tendencias y completar nuestro mapeo de palabras clave.

Cómo funciona este guión

• Este script primero importa un archivo TXT de palabras clave (keywords.txt).
• Luego, el script analiza las palabras clave mediante TfidfVectorizer y AffinityPropagation.
• Luego asigna un valor numérico a cada grupo de temas.
• Luego, los resultados se exportan a un archivo csv.

Obtén este guión

 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, ""])

Guión 5: haga coincidir la lista de palabras clave con una lista de temas predefinidos

Esto es similar a la secuencia de comandos anterior, excepto que le permite hacer coincidir una lista de palabras clave con un conjunto predefinido de temas.

Esto es excelente para grandes conjuntos de palabras clave porque las procesa en lotes de 1000 para evitar fallas en el sistema.

Cómo funciona este guión

• Este script importa una lista de palabras clave (keywords.txt) y una lista de temas (topics.txt).
• Luego analiza los temas y las listas de palabras clave y las compara con la coincidencia más cercana. Si no encuentra una coincidencia, la clasifica como otra.
• Luego, los resultados se exportan a un archivo CSV.

Obtén este guión

 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)

Trabajando con Python para SEO

Python es una herramienta increíblemente poderosa y versátil para los profesionales de SEO.

Ya sea que sea un principiante o un profesional experimentado, los scripts gratuitos que he compartido en este artículo ofrecen un excelente punto de partida para explorar las posibilidades de Python en SEO.

Con su sintaxis intuitiva y su amplia gama de bibliotecas, Python puede ayudarlo a automatizar tareas tediosas, analizar datos complejos y obtener nuevos conocimientos sobre el rendimiento de su sitio web. Asi que, por que no intentarlo?

¡Buena suerte y feliz codificación!