Election coverage often requires you to quickly analyze and summarize large amounts of voting data. As a journalist, you need to identify winners, trends, and turnout patterns to inform your audience. By using **Python** and `pandas`, you can efficiently process raw election results and generate clear, accurate reports that highlight the most important outcomes.

import pandas as pd

# Example DataFrame: Election results by precinct
data = {
    "precinct": ["A", "A", "B", "B", "C", "C"],
    "candidate": ["Smith", "Jones", "Smith", "Jones", "Smith", "Jones"],
    "votes": [120, 80, 150, 100, 130, 90],
    "turnout": [200, 200, 250, 250, 220, 220]
}
df = pd.DataFrame(data)

# Calculate total votes for each candidate
total_votes = df.groupby("candidate")["votes"].sum()
print("Total votes for each candidate:")
print(total_votes)

# Determine the candidate with the most votes
winner = total_votes.idxmax()
winner_votes = total_votes.max()
print(f"Winner: {winner} with {winner_votes} votes")

# Calculate average voter turnout per precinct
avg_turnout = df.groupby("precinct")["turnout"].first().mean()
print(f"Average voter turnout per precinct: {avg_turnout:.2f}")

These grouping and aggregation techniques are essential tools for journalists. They allow you to condense complex election datasets into clear, digestible summaries. By quickly identifying total votes, winners, and turnout averages, you can report key findings to your audience with confidence and speed, even when working under tight deadlines.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def setUp(self):
        import sys
        import os
        # Reload user_code fresh for each test
        if 'user_code' in sys.modules:
            del sys.modules['user_code']

    def test_total_votes_per_candidate(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_election_results(user_code.df)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "total votes for each candidate:" in output and "smith" in output and "jones" in output and "400" in output and "270" in output,
            "Output contains total votes for each candidate (Smith: 400, Jones: 270)",
            f"Output missing total votes for candidates: {output}"
        )

    def test_winner_and_votes(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_election_results(user_code.df)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "winner:" in output and "smith" in output and "400" in output,
            "Output includes winner Smith with correct vote total",
            f"Output missing winner or correct vote count: {output}"
        )

    def test_average_turnout(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_election_results(user_code.df)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "average voter turnout per precinct:" in output and "223.33" in output,
            "Output includes average voter turnout per precinct rounded to two decimals (223.33)",
            f"Output missing average turnout value: {output}"
        )

    def test_summary_report_format(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_election_results(user_code.df)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "election results summary" in output and "total votes for each candidate:" in output and "winner:" in output and "average voter turnout per precinct:" in output,
            "Output contains all required summary report sections",
            f"Output missing one or more summary sections: {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: Summarize Election Results

解答