To make informed editorial decisions, you need to understand not just what content is published, but how it performs. **Data analysis** can help you uncover which types of articles engage your audience most. By investigating relationships between article characteristics—such as `length` or `publication time`—and engagement metrics, you can identify patterns that guide content planning and strategy.

import pandas as pd

# Example DataFrame with article data
data = {
    "article_length": [500, 1500, 800, 2000, 1200],
    "engagement": [120, 340, 150, 410, 220]
}
df = pd.DataFrame(data)

# Calculate correlation between article length and engagement
correlation = df["article_length"].corr(df["engagement"])
print("Correlation between article length and engagement:", correlation)

# Interpret the correlation
if correlation > 0:
    interpretation = "Longer articles tend to get more engagement."
elif correlation < 0:
    interpretation = "Longer articles tend to get less engagement."
else:
    interpretation = "There is no relationship between article length and engagement."
print("Interpretation:", interpretation)

**Insights from such analyses can directly inform your content strategy.** If you discover that longer articles drive more engagement, you might prioritize in-depth reporting. Conversely, if shorter pieces perform better, you could focus on concise updates. Using data in this way allows you to align editorial choices with audience interests and maximize your newsroom's impact.


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

class TestTask(unittest.TestCase):
    def setUp(self):
        import user_code
        importlib.reload(user_code)
        self.df = getattr(user_code, 'df', None)
        self.func = getattr(user_code, 'investigate_article_performance', None)

    def test_correlation_value(self):
        import user_code
        importlib.reload(user_code)
        df = getattr(user_code, 'df', None)
        func = getattr(user_code, 'investigate_article_performance', None)
        _dynamic_test(
            self,
            df is not None and func is not None,
            "DataFrame and function are defined",
            "DataFrame `df` or function `investigate_article_performance` not found"
        )
        expected_corr = df["article_length"].corr(df["engagement"])
        # Capture stdout
        f = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f
        try:
            func(df)
        finally:
            sys.stdout = sys_stdout
        output = f.getvalue()
        found = False
        for line in output.splitlines():
            if "Correlation between article length and engagement" in line:
                try:
                    val = float(line.split(":")[-1].strip())
                    # Accept small rounding difference
                    found = abs(val - expected_corr) < 1e-6
                except Exception:
                    found = False
        _dynamic_test(
            self,
            found,
            "Correlation value is correctly calculated and printed",
            f"Expected correlation: {expected_corr} printed in output"
        )

    def test_scatter_plot(self):
        import user_code
        importlib.reload(user_code)
        df = getattr(user_code, 'df', None)
        func = getattr(user_code, 'investigate_article_performance', None)
        _dynamic_test(
            self,
            df is not None and func is not None,
            "DataFrame and function are defined",
            "DataFrame `df` or function `investigate_article_performance` not found"
        )
        # Patch plt.show to avoid actually displaying
        show_called = {'value': False}
        orig_show = plt.show
        def fake_show(*args, **kwargs):
            show_called['value'] = True
        plt.show = fake_show
        try:
            func(df)
        finally:
            plt.show = orig_show
        _dynamic_test(
            self,
            show_called['value'],
            "Scatter plot is produced (plt.show called)",
            "Scatter plot not shown (plt.show not called)"
        )

    def test_interpretation(self):
        import user_code
        importlib.reload(user_code)
        df = getattr(user_code, 'df', None)
        func = getattr(user_code, 'investigate_article_performance', None)
        _dynamic_test(
            self,
            df is not None and func is not None,
            "DataFrame and function are defined",
            "DataFrame `df` or function `investigate_article_performance` not found"
        )
        correlation = df["article_length"].corr(df["engagement"])
        f = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f
        try:
            func(df)
        finally:
            sys.stdout = sys_stdout
        output = f.getvalue()
        if correlation > 0:
            expected = "Longer articles tend to get more engagement."
        elif correlation < 0:
            expected = "Longer articles tend to get less engagement."
        else:
            expected = "There is no relationship between article length and engagement."
        _dynamic_test(
            self,
            expected in output,
            "Interpretation matches the sign of the correlation",
            f"Expected interpretation '{expected}' not found in output: {output}"
        )

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

A practical course designed for journalists and media professionals to harness the power of Python for data-driven storytelling, news automation, and media analysis. Learn to collect, analyze, and visualize data, automate repetitive newsroom tasks, and uncover insights from large datasets using Python.

Learn how to gather, clean, and prepare data for journalistic investigations and media reporting using Python.

Master the skills to analyze, interpret, and visualize media data for compelling storytelling and reporting.

Discover how Python can automate repetitive newsroom tasks and analyze media content for deeper insights.

Challenge: Investigate Article Performance

Oplossing