Visualizing keyword trends is a powerful way to prioritize your SEO efforts. By plotting the search volume of your top keywords over time, you can quickly identify which terms are gaining or losing traction and allocate resources accordingly. In this challenge, you will work with a pandas DataFrame containing `month`, `keyword`, and `search_volume` columns. Your task is to create a function that identifies the top 2 keywords with the highest average search volume and plots their monthly search volume trends using **matplotlib**. This visualization will help you spot emerging opportunities and shifts in keyword popularity.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import pandas as pd
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import importlib
import user_code

class TestTask(unittest.TestCase):
    def setUp(self):
        # Prepare a test DataFrame
        self.data = {
            'month': ['2024-01', '2024-02', '2024-03', '2024-01', '2024-02', '2024-03', '2024-01', '2024-02', '2024-03'],
            'keyword': ['seo', 'seo', 'seo', 'python', 'python', 'python', 'analytics', 'analytics', 'analytics'],
            'search_volume': [1200, 1300, 1250, 900, 950, 1000, 400, 420, 410]
        }
        self.df = pd.DataFrame(self.data)

    def test_top_keywords_identified(self):
        importlib.reload(user_code)
        df = self.df.copy()
        # Patch plt.show to prevent plot window
        plt_show_called = {'called': False}
        orig_show = plt.show
        plt.show = lambda: plt_show_called.update({'called': True})
        user_code.plot_top_keywords(df)
        # Calculate expected top 2 keywords
        avg_search = df.groupby('keyword')['search_volume'].mean().sort_values(ascending=False)
        expected_top = avg_search.index[:2].tolist()
        # Now, check if the plot contains exactly the top 2 keyword lines
        ax = plt.gca()
        actual_labels = [line.get_label() for line in ax.get_lines()]
        # Remove '_nolegend_' if present
        actual_labels = [lbl for lbl in actual_labels if lbl != '_nolegend_']
        found = all(lbl in expected_top for lbl in actual_labels) and len(actual_labels) == 2
        plt.clf()
        plt.show = orig_show
        _dynamic_test(
            self,
            found,
            f"Function correctly identifies and plots top 2 keywords: {expected_top}",
            f"Top 2 keywords on plot are not correct. Expected: {expected_top}, Got: {actual_labels}",
        )

    def test_plot_trends_on_same_chart(self):
        importlib.reload(user_code)
        df = self.df.copy()
        plt_show_called = {'called': False}
        orig_show = plt.show
        plt.show = lambda: plt_show_called.update({'called': True})
        user_code.plot_top_keywords(df)
        ax = plt.gca()
        num_lines = len([line for line in ax.get_lines() if line.get_label() != '_nolegend_'])
        plt.clf()
        plt.show = orig_show
        _dynamic_test(
            self,
            num_lines == 2,
            "Both keyword trends are plotted together on one chart.",
            f"Expected 2 lines on the plot, got {num_lines}.",
        )

    def test_handles_more_than_two_keywords(self):
        importlib.reload(user_code)
        df = self.df.copy()
        # Add a fourth keyword with low volume
        df2 = pd.concat([df, pd.DataFrame([{'month': '2024-01', 'keyword': 'blog', 'search_volume': 100}])], ignore_index=True)
        plt_show_called = {'called': False}
        orig_show = plt.show
        plt.show = lambda: plt_show_called.update({'called': True})
        user_code.plot_top_keywords(df2)
        ax = plt.gca()
        actual_labels = [line.get_label() for line in ax.get_lines() if line.get_label() != '_nolegend_']
        plt.clf()
        plt.show = orig_show
        _dynamic_test(
            self,
            len(actual_labels) == 2,
            "Function only plots top 2 keywords, even if more are present.",
            f"Expected 2 lines for top 2 keywords, got {len(actual_labels)} lines.",
        )

    def test_chronological_month_order(self):
        importlib.reload(user_code)
        # Shuffle months so they are out of order
        df = self.df.sample(frac=1, random_state=42).reset_index(drop=True)
        plt_show_called = {'called': False}
        orig_show = plt.show
        plt.show = lambda: plt_show_called.update({'called': True})
        user_code.plot_top_keywords(df)
        ax = plt.gca()
        xlabels = [tick.get_text() for tick in ax.get_xticklabels()]
        # Remove empty labels
        xlabels = [lbl for lbl in xlabels if lbl]
        expected = sorted(set(self.df['month']))
        plt.clf()
        plt.show = orig_show
        _dynamic_test(
            self,
            xlabels == expected,
            "Months are sorted chronologically on the x-axis.",
            f"Expected months order: {expected}, got: {xlabels}",
        )

    def test_function_runs_without_error(self):
        importlib.reload(user_code)
        df = self.df.copy()
        # Patch plt.show
        orig_show = plt.show
        plt.show = lambda: None
        try:
            user_code.plot_top_keywords(df)
            no_error = True
        except Exception as e:
            no_error = False
        plt.clf()
        plt.show = orig_show
        _dynamic_test(
            self,
            no_error,
            "Function runs without error on well-formed DataFrame.",
            "Function raised an error on valid DataFrame input.",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Master the use of Python to automate, analyze, and optimize SEO workflows. This course guides SEO professionals through practical Python applications for keyword research, on-page analysis, and technical SEO, using real-world scenarios and hands-on coding tasks.

Learn how Python can automate repetitive SEO tasks, from scraping search results to generating meta tags, making your SEO workflow more efficient.

Explore how Python can be used to analyze keyword data, identify opportunities, and visualize keyword trends for SEO campaigns.

Apply Python to analyze on-page SEO elements and perform technical audits, including content checks, tag analysis, and site structure evaluation.

Challenge: Plot Top Keyword Trends

Løsning

Challenge: Plot Top Keyword Trends

Løsning