5 scripts Python para automatizar tarefas de SEO

Python é uma linguagem de programação poderosa que ganhou popularidade na indústria de SEO nos últimos anos.

Com sua sintaxe relativamente simples, desempenho eficiente e abundância de bibliotecas e estruturas, o Python revolucionou a forma como muitos SEOs abordam seu trabalho.

O Python oferece um conjunto de ferramentas versátil que pode ajudar a tornar o processo de otimização mais rápido, preciso e eficaz.

Este artigo explora cinco scripts Python para ajudar a impulsionar seus esforços de SEO.

• Automatize um mapa de redirecionamento.
• Escreva meta descrições em massa.
• Analise palavras-chave com N-gramas.
• Agrupe palavras-chave em grupos de tópicos.
• Combine a lista de palavras-chave com uma lista de tópicos predefinidos.

A maneira mais fácil de começar a usar o Python

Se você deseja mergulhar na programação Python, vale a pena considerar o Google Colab.

É uma plataforma gratuita baseada na Web que fornece um playground conveniente para escrever e executar código Python sem a necessidade de uma configuração local complexa.

Essencialmente, ele permite que você acesse Jupyter Notebooks em seu navegador e fornece uma série de bibliotecas pré-instaladas para ciência de dados e aprendizado de máquina.

Além disso, ele é construído sobre o Google Drive, para que você possa salvar e compartilhar facilmente seu trabalho com outras pessoas.

Para começar, siga estas etapas:

Habilitar uploads de arquivos

Depois de abrir o Google Colab, primeiro você precisa habilitar a capacidade de criar um repositório de arquivos temporários. É tão simples quanto clicar no ícone da pasta.

Isso permite que você carregue arquivos temporários e, em seguida, baixe quaisquer arquivos de resultados.

Carregar dados de origem

Muitos de nossos scripts Python requerem um arquivo de origem para funcionar. Para fazer upload de um arquivo, basta clicar no botão de upload.

Depois de concluir a configuração, você pode começar a testar os seguintes scripts Python.

Script 1: automatizar um mapa de redirecionamento

A criação de mapas de redirecionamento para sites grandes pode consumir muito tempo. Encontrar maneiras de automatizar o processo pode nos ajudar a economizar tempo e focar em outras tarefas.

Como esse roteiro funciona

Este script concentra-se na análise do conteúdo da Web para encontrar artigos que correspondam de forma aproximada.

• Primeiro, ele importa dois arquivos TXT de URLs: um é para o site redirecionado (source_urls.txt) e outro para o site que está absorvendo o site redirecionado (target_urls.txt).
• Em seguida, usamos a biblioteca Beautiful Soup do Python para criar um web scraper para obter o conteúdo do corpo principal da página. Este script ignora o conteúdo do cabeçalho e rodapé.
• Depois de rastrear o conteúdo em todas as páginas, ele usa a biblioteca Python Polyfuzz para corresponder o conteúdo entre URLs com uma porcentagem de similaridade.
• Por fim, imprime os resultados em um arquivo CSV, incluindo a porcentagem de similaridade.

A partir daqui, você pode revisar manualmente quaisquer URLs com uma baixa porcentagem de similaridade para encontrar a próxima correspondência mais próxima.

Obtenha o roteiro

 #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: escreva meta descrições em massa

Embora as meta descrições não sejam um fator direto de classificação, elas nos ajudam a melhorar nossas taxas de cliques orgânicos. Deixar as meta descrições em branco aumenta as chances de o Google criar suas próprias.

Se a sua auditoria de SEO mostrar um grande número de URLs sem uma meta descrição, pode ser difícil arranjar tempo para escrevê-los manualmente, especialmente para sites de comércio eletrônico.

Este script visa ajudá-lo a economizar tempo automatizando esse processo para você.

Como funciona o roteiro

• Primeiro, o script importa uma lista de URLs de um arquivo TXT (urls.txt).
• Em seguida, ele analisa todo o conteúdo das URLs.
• Depois que o conteúdo é analisado, ele cria meta descrições com o objetivo de ter menos de 155 caracteres.
• Ele exporta os resultados para um arquivo CSV.

Obtenha o roteiro

 !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: analise palavras-chave com N-gramas

N-grams não são um conceito novo, mas ainda são úteis para SEO. Eles podem nos ajudar a entender os temas em grandes conjuntos de dados de palavras-chave.

Como esse roteiro funciona

Esse script gera resultados em um arquivo TXT que divide as palavras-chave em unigramas, bigramas e trigramas.

• Primeiro, importa um arquivo TXT de todas as suas palavras-chave (keyword.txt).
• Em seguida, ele usa uma biblioteca Python chamada Counter para analisar e extrair os N-gramas.
• Em seguida, exporta os resultados em um novo arquivo TXT.

Obter este 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: agrupar palavras-chave em grupos de tópicos

Com novos projetos de SEO, a pesquisa de palavras-chave está sempre nos estágios iniciais. Às vezes, lidamos com milhares de palavras-chave em um conjunto de dados, tornando o agrupamento um desafio.

O Python nos permite agrupar palavras-chave automaticamente em grupos semelhantes para identificar tendências de tendências e concluir nosso mapeamento de palavras-chave.

Como esse roteiro funciona

• Este script primeiro importa um arquivo TXT de palavras-chave (keywords.txt).
• Em seguida, o script analisa as palavras-chave usando TfidfVectorizer e AffinityPropagation.
• Em seguida, atribui um valor numérico a cada cluster de tópico.
• Os resultados são então exportados para um arquivo csv.

Obter este 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: Combine a lista de palavras-chave com uma lista de tópicos predefinidos

Isso é semelhante ao script anterior, exceto que permite corresponder uma lista de palavras-chave a um conjunto predefinido de tópicos.

Isso é ótimo para grandes conjuntos de palavras-chave porque os processa em lotes de 1.000 para evitar travamentos do sistema.

Como esse roteiro funciona

• Este script importa uma lista de palavras-chave (keywords.txt) e uma lista de tópicos (topics.txt).
• Em seguida, ele analisa os tópicos e as listas de palavras-chave e os compara com a correspondência mais próxima. Se não encontrar uma correspondência, ele a categoriza como outra.
• Os resultados são então exportados para um arquivo CSV.

Obter este 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)

Trabalhando com Python para SEO

Python é uma ferramenta incrivelmente poderosa e versátil para profissionais de SEO.

Seja você um iniciante ou um praticante experiente, os scripts gratuitos que compartilhei neste artigo oferecem um excelente ponto de partida para explorar as possibilidades do Python em SEO.

Com sua sintaxe intuitiva e vasta gama de bibliotecas, o Python pode ajudá-lo a automatizar tarefas tediosas, analisar dados complexos e obter novos insights sobre o desempenho do seu site. Então, por que não tentar?

Boa sorte e codificação feliz!