Mapping local news events is a powerful way to tell stories visually, allowing audiences to quickly grasp the scope, distribution, and types of incidents occurring in their communities. By placing events on a map according to their geographic coordinates, you can reveal patterns and clusters that might otherwise go unnoticed in raw data tables. This approach is especially valuable for journalists aiming to contextualize news, highlight hotspots, or draw attention to trends across neighborhoods or regions.

import pandas as pd
import matplotlib.pyplot as plt

# Sample DataFrame of local news events
data = {
    "event": ["Burglary", "Town Hall", "Charity Run", "Robbery", "Election Rally", "Food Drive"],
    "type": ["crime", "politics", "community", "crime", "politics", "community"],
    "latitude": [40.7128, 40.7135, 40.7150, 40.7142, 40.7130, 40.7160],
    "longitude": [-74.0060, -74.0050, -74.0070, -74.0045, -74.0080, -74.0030]
}
df = pd.DataFrame(data)

# Assign a color to each event type
color_map = {"crime": "red", "politics": "blue", "community": "green"}
df["color"] = df["type"].map(color_map)

# Plotting the events
plt.figure(figsize=(8, 6))
for event_type in df["type"].unique():
    subset = df[df["type"] == event_type]
    plt.scatter(subset["longitude"], subset["latitude"], 
                c=subset["color"], label=event_type.capitalize(), s=100, edgecolor="black")

plt.title("Local News Events Map")
plt.xlabel("Longitude")
plt.ylabel("Latitude")
plt.legend(title="Event Type")
plt.show()

Using **color-coding** for different event types makes the map much easier to interpret at a glance. When each category—such as `crime`, `politics`, or `community`—is assigned a distinct color, you can quickly identify clusters, outliers, or locations where certain types of events are more common. This not only improves the visual appeal of your map but also helps your audience draw meaningful conclusions from the data.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import io
from contextlib import redirect_stdout
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import pandas as pd

class TestTask(unittest.TestCase):
    def setUp(self):
        # Prepare the DataFrame as in the starter code
        self.data = {
            "event": ["Burglary", "Town Hall", "Charity Run", "Robbery", "Election Rally", "Food Drive"],
            "type": ["crime", "politics", "community", "crime", "politics", "community"],
            "latitude": [40.7128, 40.7135, 40.7150, 40.7142, 40.7130, 40.7160],
            "longitude": [-74.0060, -74.0050, -74.0070, -74.0045, -74.0080, -74.0030]
        }
        self.df = pd.DataFrame(self.data)
        # Remove user_code from sys.modules to reload fresh
        if 'user_code' in sys.modules:
            del sys.modules['user_code']

    def test_points_plotted(self):
        import user_code
        importlib.reload(user_code)
        plot_func = getattr(user_code, 'plot_event_map', None)
        _dynamic_test(
            self,
            callable(plot_func),
            "plot_event_map function is defined",
            "plot_event_map function is not defined or not callable",
        )
        plt.close('all')
        plot_func(self.df)
        fig = plt.gcf()
        ax = plt.gca()
        points = 0
        for coll in ax.collections:
            offsets = coll.get_offsets()
            points += len(offsets)
        _dynamic_test(
            self,
            points == len(self.df),
            f"Plotted {points} points for {len(self.df)} events.",
            f"Expected {len(self.df)} points plotted, got {points}.",
        )

    def test_unique_color_per_type(self):
        import user_code
        importlib.reload(user_code)
        plot_func = getattr(user_code, 'plot_event_map', None)
        plt.close('all')
        plot_func(self.df)
        ax = plt.gca()
        # Each type should have a unique color
        type_color = {}
        for coll in ax.collections:
            # Get label for legend
            label = coll.get_label().lower()
            color = coll.get_facecolor()[0][:3]
            type_color[label] = color
        _dynamic_test(
            self,
            len(type_color) == len(set(self.df['type'])),
            "Each event type is represented by a unique color.",
            f"Expected {len(set(self.df['type']))} unique colors, got {len(type_color)}.",
        )

    def test_legend_labels(self):
        import user_code
        importlib.reload(user_code)
        plot_func = getattr(user_code, 'plot_event_map', None)
        plt.close('all')
        plot_func(self.df)
        ax = plt.gca()
        legend = ax.get_legend()
        _dynamic_test(
            self,
            legend is not None,
            "Legend is present on the plot.",
            "Legend is missing from the plot.",
        )
        legend_labels = [t.get_text().lower() for t in legend.get_texts()]
        expected_labels = sorted(set([t.lower() for t in self.df['type']]))
        legend_labels_sorted = sorted([l for l in legend_labels if l in expected_labels])
        _dynamic_test(
            self,
            legend_labels_sorted == expected_labels,
            f"Legend contains correct event type labels: {expected_labels}",
            f"Legend labels incorrect. Expected {expected_labels}, got {legend_labels}.",
        )

    def test_plot_title(self):
        import user_code
        importlib.reload(user_code)
        plot_func = getattr(user_code, 'plot_event_map', None)
        plt.close('all')
        plot_func(self.df)
        ax = plt.gca()
        title = ax.get_title()
        _dynamic_test(
            self,
            "local news events map" in title.lower(),
            "Plot includes a title.",
            f"Plot title incorrect or missing. Got: '{title}'",
        )

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: Map Local News Events

Løsning