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-grams.
• 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 uma 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 metas descrições não sejam um fator direto de classificação, elas nos ajudam a melhorar nossas taxas de cliques orgânicos. Deixar as metas descrições em branco aumenta as chances de o Google criar suas próprias.

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