Filtering for high-opportunity keywords is a key step in keyword research. By narrowing your focus to keywords with **high search volume** and **low difficulty**, you can identify terms that are more likely to bring valuable traffic with less competition. In this challenge, you will use your Python and `pandas` skills to filter a DataFrame of keyword data, isolating only those keywords that meet specific opportunity criteria.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import pandas as pd

class TestTask(unittest.TestCase):
    def setUp(self):
        self.user_code = importlib.import_module("user_code")

    def test_filter_basic(self):
        # Test that only correct rows are returned
        data = {
            'keyword': ['python seo', 'best seo tools', 'seo audit', 'seo basics', 'advanced seo'],
            'search_volume': [500, 2500, 1200, 800, 3000],
            'difficulty': [35, 45, 30, 20, 38]
        }
        df = pd.DataFrame(data)
        result = self.user_code.filter_keywords(df)
        expected = df.loc[[2, 4]]
        _dynamic_test(
            self,
            result is not None and isinstance(result, pd.DataFrame) and result.reset_index(drop=True).equals(expected.reset_index(drop=True)),
            "Returns DataFrame with only rows where search_volume > 1000 and difficulty < 40.",
            f"Expected filtered DataFrame:\\n{expected}\\nGot:\\n{result}"
        )

    def test_columns_and_order(self):
        # Test columns and order are maintained
        data = {
            'keyword': ['a', 'b', 'c'],
            'search_volume': [2000, 3000, 4000],
            'difficulty': [10, 20, 30]
        }
        df = pd.DataFrame(data)
        result = self.user_code.filter_keywords(df)
        _dynamic_test(
            self,
            result is not None and list(result.columns) == list(df.columns),
            "Returned DataFrame maintains original columns and order.",
            f"Expected columns: {list(df.columns)}, got: {list(result.columns)}"
        )

    def test_empty_result(self):
        # Test returns empty DataFrame if no rows match
        data = {
            'keyword': ['x', 'y'],
            'search_volume': [100, 200],
            'difficulty': [50, 60]
        }
        df = pd.DataFrame(data)
        result = self.user_code.filter_keywords(df)
        _dynamic_test(
            self,
            result is not None and result.empty,
            "Returns empty DataFrame if no rows match criteria.",
            f"Expected empty DataFrame, got: {result}"
        )

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: Filter High-Opportunity Keywords

Solution