Python — это мощный язык программирования, который за последние несколько лет приобрел популярность в индустрии SEO.

Благодаря относительно простому синтаксису, эффективной производительности и обилию библиотек и фреймворков Python произвел революцию в том, как многие SEO-специалисты подходят к своей работе.

Python предлагает универсальный набор инструментов, который может помочь сделать процесс оптимизации быстрее, точнее и эффективнее.

В этой статье рассматриваются пять скриптов Python, которые помогут повысить ваши усилия по SEO.

Самый простой способ начать работу с Python

Если вы хотите окунуться в программирование на Python, стоит подумать о Google Colab.

Это бесплатная веб-платформа, которая обеспечивает удобную площадку для написания и запуска кода Python без сложной локальной настройки.

По сути, он позволяет вам получать доступ к Jupyter Notebooks в вашем браузере и предоставляет множество предустановленных библиотек для обработки данных и машинного обучения.

Кроме того, он создан на основе Google Диска, поэтому вы можете легко сохранять свою работу и делиться ею с другими.

Чтобы начать, выполните следующие действия:

Включить загрузку файлов

После того, как вы откроете Google Colab, вам сначала нужно включить возможность создания временного репозитория файлов. Это так же просто, как щелкнуть значок папки.

Это позволяет загружать временные файлы, а затем загружать любые файлы результатов.

Загрузить исходные данные

Для работы многих наших скриптов Python требуется исходный файл. Чтобы загрузить файл, просто нажмите кнопку загрузки.

После завершения настройки вы можете приступить к тестированию следующих скриптов Python.

Сценарий 1: Автоматизируйте карту перенаправления

Создание карт перенаправления для больших сайтов может занять невероятно много времени. Поиск способов автоматизации процесса может помочь нам сэкономить время и сосредоточиться на других задачах.

Как работает этот скрипт

Этот сценарий фокусируется на анализе веб-контента, чтобы найти близко соответствующие статьи.

• Во-первых, он импортирует два TXT-файла URL-адресов: один для перенаправленного веб-сайта (source_urls.txt), а другой — для сайта, принимающего перенаправленный веб-сайт (target_urls.txt).
• Затем мы используем библиотеку Python Beautiful Soup для создания парсера для получения основного содержимого страницы. Этот сценарий игнорирует содержимое верхнего и нижнего колонтитула.
• После сканирования контента на всех страницах он использует библиотеку Python Polyfuzz для сопоставления контента между URL-адресами с процентом сходства.
• Наконец, он печатает результаты в файле CSV, включая процент сходства.

Отсюда вы можете вручную просмотреть любые URL-адреса с низким процентом сходства, чтобы найти следующее наиболее близкое совпадение.

Получить сценарий

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

Хотя метаописания не являются прямым фактором ранжирования, они помогают нам улучшить наши органические рейтинги кликов. Если оставить мета-описания пустыми, вероятность того, что Google создаст их, увеличится.

Если ваш SEO-аудит показывает, что в большом количестве URL-адресов отсутствует метаописание, может быть трудно найти время, чтобы написать все это вручную, особенно для веб-сайтов электронной коммерции.

Этот скрипт призван помочь вам сэкономить время, автоматизировав этот процесс.

Как работает скрипт

• Сначала скрипт импортирует список URL-адресов из файла TXT (urls.txt).
• Затем он анализирует все содержимое URL-адресов.
• После анализа контента создаются метаописания, длина которых не должна превышать 155 символов.
• Он экспортирует результаты в файл CSV.

Получить сценарий

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

Сценарий 3: Анализ ключевых слов с помощью N-грамм

N-граммы — не новая концепция, но они по-прежнему полезны для SEO. Они могут помочь нам понять темы в больших наборах данных ключевых слов.

Как работает этот скрипт

Этот сценарий выводит результаты в файл TXT, в котором ключевые слова разбиваются на униграммы, биграммы и триграммы.

• Во-первых, он импортирует TXT-файл со всеми вашими ключевыми словами (keyword.txt).
• Затем он использует библиотеку Python под названием Counter для анализа и извлечения N-грамм.
• Затем он экспортирует результаты в новый файл TXT.

Получить этот скрипт

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

Сценарий 4. Сгруппируйте ключевые слова в тематические кластеры.

В новых SEO-проектах исследование ключевых слов всегда находится на ранних стадиях. Иногда мы имеем дело с тысячами ключевых слов в наборе данных, что усложняет группировку.

Python позволяет нам автоматически объединять ключевые слова в похожие группы, чтобы определять тренды и завершать сопоставление ключевых слов.

Как работает этот скрипт

• Этот сценарий сначала импортирует TXT-файл ключевых слов (keywords.txt).
• Затем скрипт анализирует ключевые слова с помощью TfidfVectorizer и AffinityPropagation.
• Затем он присваивает числовое значение каждому тематическому кластеру.
• Затем результаты экспортируются в файл csv.

Получить этот скрипт

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

Сценарий 5: сопоставление списка ключевых слов со списком предопределенных тем

Это похоже на предыдущий сценарий, за исключением того, что позволяет сопоставить список ключевых слов с предопределенным набором тем.

Это отлично подходит для больших наборов ключевых слов, поскольку обрабатывает их партиями по 1000, чтобы предотвратить сбои системы.

Как работает этот скрипт

• Этот скрипт импортирует список ключевых слов (keywords.txt) и список тем (topics.txt).
• Затем он анализирует темы и списки ключевых слов и сопоставляет их с наиболее близким соответствием. Если он не находит совпадения, он классифицирует его как «другое».
• Затем результаты экспортируются в файл CSV.

Получить этот скрипт

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)

Работа с Python для SEO

Python — невероятно мощный и универсальный инструмент для профессионалов SEO.

Являетесь ли вы новичком или опытным практиком, бесплатные скрипты, которыми я поделился в этой статье, предлагают отличную отправную точку для изучения возможностей Python в SEO.

Благодаря интуитивно понятному синтаксису и обширному набору библиотек Python может помочь вам автоматизировать утомительные задачи, анализировать сложные данные и получать новые сведения о производительности вашего веб-сайта. Так почему бы не попробовать?

Удачи и удачного кодирования!