In This Challenge, You Are Tasked With Helping A Small, Rura ✓ Solved

In this challenge, you are tasked with helping a small, rural a

In this challenge, you are tasked with helping a small, rural town modernize its vote counting process. You will be given a set of poll data called election_data.csv. The dataset is composed of three columns: Voter ID, County, and Candidate. Your task is to create a Python script that analyzes the votes and calculates each of the following: The total number of votes cast; A complete list of candidates who received votes; The percentage of votes each candidate won; The total number of votes each candidate won; The winner of the election based on popular vote. Your final script should both print the analysis to the terminal and export a text file with the results.

Paper For Above Instructions

Executive summary

This paper provides a clear, tested approach to analyze election_data.csv and produce the requested outputs: total votes, list of candidates, each candidate's vote count and percentage, and the winner by popular vote. The solution uses standard Python techniques for CSV parsing and counting to ensure portability and low dependency requirements (Python Software Foundation, 2024) (McKinney, 2018). The script prints results to the terminal and writes them to a results text file for auditing and archival use.

Design considerations

Key design goals are correctness, reproducibility, and auditability. Using the built-in csv module and a pure-Python counting strategy minimizes external dependencies and simplifies deployment in small municipal environments (Python CSV module documentation, 2024). The script must gracefully handle common CSV issues (missing header rows, trailing whitespace) and produce a deterministic winner in the event of ties by applying a clear tie-break policy (e.g., first-most votes wins, or lexicographic order if specified).

Algorithm and data flow

1. Read the CSV file election_data.csv using csv.DictReader to rely on column labels ("Voter ID", "County", "Candidate") (RFC 4180 describes CSV format considerations) (RFC 4180, 2005). 2. Count votes per candidate using collections.Counter for O(n) aggregation and minimal memory overhead for typical precinct-sized datasets (Van Rossum & Drake, 2009; Hettinger, 2024). 3. Compute total votes and percentages per candidate. 4. Determine the winner by selecting the candidate with the maximum count. 5. Print formatted results and write the same content to a text file for export and archival. This approach supports reproducibility and simple verification steps for election audits (EAC and NIST guidance on transparent reporting) (EAC, 2015; NIST, 2018).

Example Python script

The following script is compact, readable, and dependency-light. Save as analyze_votes.py and run in the same directory as election_data.csv.

#!/usr/bin/env python3

import csv


from collections import Counter


from pathlib import Path


INPUT_CSV = "election_data.csv"


OUTPUT_TXT = "election_results.txt"


def analyze_votes(input_csv):


counts = Counter()


total = 0


with open(input_csv, newline='', encoding='utf-8') as csvfile:


reader = csv.DictReader(csvfile)


for row in reader:


candidate = row.get('Candidate') or row.get('candidate') or ''


candidate = candidate.strip()


if candidate == '':


continue  # ignore malformed rows


counts[candidate] += 1


total += 1


return total, counts


def format_results(total, counts):


lines = []


lines.append("Election Results")


lines.append("-------------------------")


lines.append(f"Total Votes: {total}")


lines.append("-------------------------")


for candidate, votes in counts.most_common():


pct = (votes / total) * 100 if total > 0 else 0


lines.append(f"{candidate}: {pct:.3f}% ({votes})")


lines.append("-------------------------")


winner = counts.most_common(1)[0][0] if counts else "No winner"


lines.append(f"Winner: {winner}")


lines.append("-------------------------")


return "\n".join(lines)


def main():


total, counts = analyze_votes(INPUT_CSV)


results = format_results(total, counts)


print(results)


Path(OUTPUT_TXT).write_text(results, encoding='utf-8')


print(f"\nResults written to {OUTPUT_TXT}")


if __name__ == "__main__":


main()

Explanation of the script

The script uses csv.DictReader so it matches fields by header names, making it robust to column ordering (Python CSV docs, 2024). It trims whitespace and skips rows where the Candidate field is missing. collections.Counter gives a convenient API to tally votes and to get candidates ordered by vote count via most_common(), which also supports deterministic output useful for audits (Hettinger, 2024).

Output formatting and export

The formatted output mirrors the example provided in the assignment, providing percent values to three decimal places and exact vote counts. Writing the same formatted text to a plain UTF-8 text file ensures human-readability and easy archival. Plain text outputs are also easy to parse by other systems for verification or further processing (McKinney, 2018).

Edge cases and testing

Test cases to validate correctness include: empty file, single-candidate elections, tie elections, rows with missing candidate names, and files with extra whitespace or BOM markers. Unit tests or small sample CSV files should confirm that total counts equal the sum of per-candidate counts and that percentages sum to 100% within floating-point rounding limits (Real Python and community best practices for CSV handling) (Real Python, 2022).

Auditability and security notes

While this script meets the functional requirements for counting votes, production election systems require stronger audit mechanisms (e.g., persistent logs, cryptographic integrity checks, paper trails) (Brennan Center, 2016; NIST, 2018). For the small rural context specified, this approach provides a transparent and verifiable count that can be re-run by any stakeholder with the input CSV, improving trust and traceability (EAC, 2015).

Conclusion

Using standard Python libraries and a clear counting algorithm delivers an auditable, reproducible vote count that prints to the terminal and writes a text file for archival. The approach balances simplicity and robustness, making it appropriate for a small rural town modernizing its vote counting process while leaving open options for later enhancements (pandas-based performance scaling, digital signature of outputs, or integration into a secure audit pipeline) (McKinney, 2018; pandas documentation, 2024).

References

  • McKinney, W. (2018). Python for Data Analysis: Data Wrangling with pandas, NumPy, and IPython. O'Reilly Media.
  • Python Software Foundation. Python 3.x documentation: csv — CSV File Reading and Writing. https://docs.python.org/3/library/csv.html (accessed 2024).
  • pandas development team. pandas documentation. https://pandas.pydata.org/docs/ (accessed 2024).
  • RFC 4180. Common Format and MIME Type for Comma-Separated Values (CSV) Files. https://tools.ietf.org/html/rfc4180 (2005).
  • Hettinger, R. collections — Container datatypes (Python docs). https://docs.python.org/3/library/collections.html (accessed 2024).
  • Van Rossum, G., & Drake, F. L. (2009). The Python Language Reference. Python Software Foundation.
  • U.S. Election Assistance Commission (EAC). Voluntary Voting System Guidelines and documentation for transparent reporting. https://www.eac.gov/ (accessed 2015).
  • National Institute of Standards and Technology (NIST). Guidelines and technical reports on voting systems and testing (2018). https://www.nist.gov/ (accessed 2018).
  • Brennan Center for Justice. (2016). The Realities of Voting Technology and Security: Best Practices and Recommendations. https://www.brennancenter.org/ (accessed 2016).
  • Real Python. (2022). Working With CSV Files in Python. https://realpython.com/python-csv/ (accessed 2022).

Related Assignments