How Can Python Be Used For SEO: From Ready‑Made Plugins to Custom Scripts

				
					from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.cluster import AgglomerativeClustering, DBSCAN
from sklearn.metrics import silhouette_score
from scipy.cluster.hierarchy import dendrogram, linkage
from scipy.spatial.distance import pdist, squareform
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from collections import defaultdict

def preprocess_keywords(keywords):
    """Normalize keywords for better clustering"""
    processed = []
    for kw in keywords:
        # Lowercase and strip
        kw = kw.lower().strip()
        # Remove extra spaces
        kw = ' '.join(kw.split())
        processed.append(kw)
    return processed

def cluster_keywords_auto(keywords, min_similarity=0.3, method='average'):
    """
    Automatically cluster keywords using hierarchical clustering
    with distance threshold instead of fixed cluster count.
    
    Args:
        keywords: List of keyword strings
        min_similarity: Minimum similarity (0-1) to group keywords together
        method: Linkage method ('average', 'complete', 'single')
    """
    keywords = preprocess_keywords(keywords)
    
    # Create TF-IDF matrix
    vectorizer = TfidfVectorizer(
        lowercase=True,
        ngram_range=(1, 2),  # Consider both unigrams and bigrams
        min_df=1,
        max_df=0.9
    )
    tfidf_matrix = vectorizer.fit_transform(keywords)
    
    # Calculate distance threshold from similarity
    distance_threshold = 1 - min_similarity
    
    # Cluster with distance threshold (no need to specify n_clusters)
    clustering = AgglomerativeClustering(
        n_clusters=None,
        distance_threshold=distance_threshold,
        linkage=method,
        metric='cosine'
    )
    
    labels = clustering.fit_predict(tfidf_matrix.toarray())
    
    # Organize results
    clusters = defaultdict(list)
    for keyword, label in zip(keywords, labels):
        clusters[label].append(keyword)
    
    # Sort clusters by size (largest first)
    sorted_clusters = dict(sorted(clusters.items(), 
                                  key=lambda x: len(x[1]), 
                                  reverse=True))
    
    return sorted_clusters, labels, tfidf_matrix

def cluster_keywords_fixed(keywords, num_clusters=5):
    """Original approach with fixed cluster count"""
    keywords = preprocess_keywords(keywords)
    
    vectorizer = TfidfVectorizer(ngram_range=(1, 2))
    tfidf_matrix = vectorizer.fit_transform(keywords)
    
    clustering = AgglomerativeClustering(
        n_clusters=num_clusters,
        linkage='ward'
    )
    
    labels = clustering.fit_predict(tfidf_matrix.toarray())
    
    clusters = defaultdict(list)
    for keyword, label in zip(keywords, labels):
        clusters[label].append(keyword)
    
    return clusters, labels, tfidf_matrix

def find_optimal_clusters(keywords, max_clusters=10):
    """Find optimal number of clusters using silhouette score"""
    keywords = preprocess_keywords(keywords)
    
    vectorizer = TfidfVectorizer(ngram_range=(1, 2))
    tfidf_matrix = vectorizer.fit_transform(keywords).toarray()
    
    silhouette_scores = []
    cluster_range = range(2, min(max_clusters + 1, len(keywords)))
    
    for n_clusters in cluster_range:
        clustering = AgglomerativeClustering(n_clusters=n_clusters, linkage='ward')
        labels = clustering.fit_predict(tfidf_matrix)
        score = silhouette_score(tfidf_matrix, labels)
        silhouette_scores.append(score)
        print(f"Clusters: {n_clusters}, Silhouette Score: {score:.3f}")
    
    optimal = cluster_range[np.argmax(silhouette_scores)]
    print(f"\nOptimal number of clusters: {optimal}")
    
    return optimal, silhouette_scores

def export_clusters_to_csv(clusters, filename='keyword_clusters.csv'):
    """Export clusters to CSV for easy analysis"""
    rows = []
    for cluster_id, keywords in clusters.items():
        for keyword in keywords:
            rows.append({
                'cluster_id': cluster_id,
                'cluster_size': len(keywords),
                'keyword': keyword
            })
    
    df = pd.DataFrame(rows)
    df = df.sort_values(['cluster_size', 'cluster_id'], ascending=[False, True])
    df.to_csv(filename, index=False, encoding='utf-8')
    print(f"Exported to {filename}")
    return df

def print_cluster_report(clusters, keywords):
    """Print detailed cluster report"""
    print(f"\n{'='*60}")
    print(f"KEYWORD CLUSTERING REPORT")
    print(f"{'='*60}")
    print(f"Total keywords: {len(keywords)}")
    print(f"Total clusters: {len(clusters)}")
    print(f"Average cluster size: {len(keywords)/len(clusters):.1f}")
    print(f"{'='*60}\n")
    
    for cluster_id, group in clusters.items():
        print(f"\nCluster {cluster_id} ({len(group)} keywords):")
        print("-" * 50)
        for kw in sorted(group):
            print(f"  • {kw}")

# Usage Examples:

keywords = [ 
    'python tutorial', 
    'learn python', 
    'python for beginners', 
    'python course', 
    'best python books', 
    'python documentation', 
    'web development python', 
    'django tutorial', 
    'flask framework',
    'python web development',
    'learn django',
    'flask tutorial',
    'python programming',
    'python guide'
] 

print("=" * 60)
print("METHOD 1: Auto-clustering with similarity threshold")
print("=" * 60)
clusters, labels, matrix = cluster_keywords_auto(
    keywords, 
    min_similarity=0.3  # Keywords must be 30% similar to cluster together
)
print_cluster_report(clusters, keywords)
df = export_clusters_to_csv(clusters)

print("\n" + "=" * 60)
print("METHOD 2: Finding optimal cluster count")
print("=" * 60)
optimal_n, scores = find_optimal_clusters(keywords, max_clusters=8)

print("\n" + "=" * 60)
print("METHOD 3: Fixed cluster count")
print("=" * 60)
clusters_fixed, labels_fixed, matrix_fixed = cluster_keywords_fixed(
    keywords, 
    num_clusters=optimal_n
)
print_cluster_report(clusters_fixed, keywords)