Project

CS3300/CS6375 Introduction to Python Programming for Data Analytics

Project Presentations

There will be three mini Python projects throughout the semester, and students are expected to present their work to the whole class via Zoom. Each presentation will be a live code demonstration, where you run your code in real time and explain how it works.

Presentation Format:

• Time limit: 5 minutes per student
• Mode: Live code walkthrough and execution (no slides required)

Each presentation should be treated as a mini technical interview. The goal is not only to show that your code works, but also to demonstrate that you understand your design decisions and can communicate your thinking clearly.

General Guidelines for Code Showcase and Explanation:

• Start with the big picture
• Briefly explain what problem your code is solving and what the program is supposed to do.
• Explain your approach
• Describe how you decided to solve the problem (e.g., why you used certain loops or functions).
• Walk through key parts of the code
• Focus on the most important sections rather than every single line.
• Run the code live via Zoom
• Show the program running and explain the output as it appears.
• Discuss any limitations (if any) in your code. (Optional)
• Mention what your code handles well and what could be improved. (Optional)

Notes:

• Perfection is not expected, and clarity of thought and explanation matters more than flawless code.
• Creativity and thoughtful design choices are encouraged.

The requirements and topic selections are detailed in the subsections below.

Presentation I

Please present your artwork from earlier assignments to the class. You may make improvements or modifications and explain your thought process when writing the code.

Presentation II

Available Topics for Selection for both undergraduate and graduate students. The topics will cover everything we’ve learned before the Project Presentation II date. You are welcome to use synthetic data to complete your project tasks.

• Mini Todo List Manager: Add, remove, and list tasks saved to a text file.

• Favorite Movies Tracker: Store and filter movies by rating or genre.

• Student Grade Analyzer: Read grades from a synthetic file and compute min, max, and average.

• Word Frequency Counter: Read a text file and list the most common words.

• Shopping Cart Simulator: Add items to a list and save receipts to a file.

• Random Password Generator: Use random and string libraries to generate random password.

• Daily Quote Generator: Load quotes from a file and display one randomly.

• Dice Game Simulator: Roll dice using random and log results.

• Simple Timer Program: Learn to use the time library to count down.

• Number Guessing Game: Check guesses against a secret number.

• Grade Letter Converter: Convert numeric scores into letter grades. Please refer the StMU grading policy here.

• Weather Outfit Advisor: Recommend clothing based on temperature.

• Login Authentication System: Check username/password correctness.

• Ticket Price Calculator: Adjust price based on age or status.

• Password Strength Checker: Validate length, digits, and symbols.

• Loan Approval Checker: Evaluate income, credit score, and debt.

• Game Difficulty Selector: Change behavior based on difficulty choice.

• Restaurant Menu Filter: Filter food options by dietary needs.

• Input Validation Loop: Keep asking until valid input is provided.

• ATM Machine Simulator: Menu loops until user exits.

• Trivia Quiz Game: Continue asking questions until player quits.

• Guess-Until-Correct Game: Loop until the correct answer is found.

• Python Chatbot Simulator: Respond until user types “exit”.

• Unit Converter Toolkit: Functions for length, weight, temperature.

• Text Formatter Utility: Functions to uppercase, reverse, clean text.

• Simple Banking System: Deposit, withdraw, and check balance via functions.

• Mini File Analyzer: Functions to count lines, words, and characters.

• Game Score Tracker: Functions to update and display scores stored in a file.

The topics above serve as general guidelines and represent the minimum expectations set by the instructor. Please do not limit your imagination when selecting the topic from the list and adding creativity and fun elements to your mini project. If you have additional topic suggestions or project ideas, please do not hesitate to discuss them with me first so I can consider adding them to the list for other students to select as well.

Final Presentation

The final project presentation requirements will differ for undergraduate and graduate students. Again, you are welcomed to use sythetically generated data to run and test your program.

Undergraduate-level Projects

Please select a topic from the following list. You are also welcome to challenge yourself as an undergraduate and select a topic from the Graduate-level projects bucket.

• Student Gradebook System: Create a gradebook that uses a dictionary to map student names (or IDs) to numeric grades. Your program should allow users to add, update, and view student records. You should include a sorting feature that orders students by grade or name. During the presentation, explain why a dictionary is appropriate and how sorting is applied. Focus on clarity, correctness, and readable code.

• Contact Book Application: Build a simple contact manager using a dictionary to store names and phone numbers or emails. Users should be able to add new contacts, search for existing ones, and display all contacts in sorted order. This project should demonstrate dictionary access, conditional checks, and list-based sorting. During the demo, explain how user input is validated and how sorting improves usability.

• Word Frequency Analyzer: Write a program that reads a text file and counts how often each word appears using a dictionary. After counting, sort the words by frequency or alphabetically and display the results. This project demonstrates file I/O, dictionaries, and sorting logic. Be prepared to explain how your program handles punctuation or capitalization. Discuss what improvements you could make for larger files.

• Quiz Score Tracker: Create a quiz score tracker where student names are stored as keys and scores as values. Allow multiple quiz attempts and compute summary statistics such as highest or average score. Sort students based on performance before displaying results. During the presentation, explain how your dictionary structure supports multiple records. Emphasize clean organization and clear output.

• Simple Inventory Manager: Develop an inventory system where item names map to quantities using a dictionary. The program should allow adding items, updating stock, and displaying items sorted by quantity or name. This project tests dictionary updates, conditionals, and sorting. Explain how your program handles low stock or invalid inputs. Focus on logical flow and correctness.

• Recursive List Sum Calculator: Write a recursive function that calculates the sum of numbers in a list without using loops. The program should demonstrate a clear base case and recursive reduction of the list. Explain how the function progresses toward termination. During the presentation, compare this approach to a loop-based solution. Focus on correctness and conceptual understanding.

• Recursive Countdown Timer: Create a recursive countdown function that prints numbers until reaching zero. Each recursive call should reduce the countdown value. This project helps demonstrate control flow and base cases. During the demo, explain how recursion replaces looping behavior. Discuss when recursion is or is not a good choice.

• Recursive Palindrome Checker: Build a recursive function that checks whether a word or phrase is a palindrome. The function should compare characters and reduce the problem size at each call. Explain how the base case is reached. During the presentation, demonstrate the function with multiple inputs. Emphasize clarity of logic.

• Recursive Simulated File-Line Counter: Simulate processing multiple files by recursively iterating through a list of filenames. Each recursive call should process one file and accumulate line counts. This project demonstrates recursion in a practical context. Explain how recursion replaces iteration here. Focus on clean function structure and explanation.

• Student Scores Ranking System: Create a program that stores student names and scores and ranks them using sorting. The data should be stored in a dictionary and converted to a sortable structure. Explain how sorting keys or values affects results. During the demo, show different ranking orders. Emphasize correctness and readability.

• High-Score Game Board: Design a game leaderboard that records player names and scores. The leaderboard should be sortable so that top scores appear first. This project demonstrates dictionary usage and sorting logic. Explain how new scores are inserted and ranked. Discuss how this system could scale.

• Alphabetical Word Sorter: Write a program that reads words from a file or user input and sorts them alphabetically. You may use built-in sorting or implement a simple algorithm. Explain how strings are compared during sorting. During the presentation, demonstrate sorting with different inputs. Focus on clear logic.

• Sorting Visualizer (Text-Based): Implement a basic sorting algorithm (e.g., bubble sort) and print the list after each step. This helps visualize how sorting progresses. Explain how elements are compared and swapped. During the demo, walk through one example step-by-step. Emphasize understanding of the algorithm.

• Sorting Strings by Length: Create a program that sorts strings based on their length instead of alphabetical order. This project demonstrates custom sorting logic. Explain how comparison criteria differ from default sorting. Show examples with varied input. Focus on correctness and explanation.

• Dictionary-Based Voting System: Build a voting system where candidates are keys and vote counts are values. Allow users to cast votes and display results sorted by vote count. This project combines dictionaries, conditionals, and sorting. Explain how ties are handled. Emphasize clean data handling.

• Recursive Menu Navigation: Create a menu system where the menu function calls itself until the user exits. This project demonstrates recursion in control flow. Explain how the base case corresponds to exiting the program. During the demo, show multiple menu selections. Focus on logic clarity.

• Grade Distribution Analyzer: Analyze a set of grades and group them into categories using a dictionary. Sort categories by frequency or grade range. This project demonstrates data grouping and sorting. Explain how categories are determined. Emphasize clear output.

• Simple Recommendation Tool: Build a recommendation tool that suggests items based on user preferences stored in a dictionary. The program should use conditions to select appropriate recommendations. Explain how data is structured and accessed. During the demo, show different user cases. Focus on logic and clarity.

• Library Book Organizer: Create a system to store books using dictionaries with attributes such as title and author. Allow sorting by title or author. Explain how records are stored and retrieved. During the presentation, demonstrate sorting options. Emphasize organization and readability.

The undergraduate-level project topics serve as general guidelines and represent the minimum expectations set by the instructor. Please do not limit your imagination when selecting the topic from the list and adding creativity and fun elements to your mini project. If you have additional topic suggestions or project ideas, please do not hesitate to discuss them with me first so I can consider adding them to the list for other undergraduate students to select as well.

Graduate-level Projects

Please select a topic from the following list only.

• Nested Dictionary Configuration System: Design a configuration manager using nested dictionaries to represent settings. The program should allow querying and updating values dynamically. Explain why nested dictionaries are appropriate. Discuss design decisions and extensibility. Emphasize abstraction and structure.

• Symbol Table Simulator: imulate a compiler-style symbol table using dictionaries. Store variable names, types, and values. Explain how scope or lookup works. Discuss how dictionaries support fast access. Focus on program design and clarity.

• Dictionary-Based Cache System: Implement caching for a recursive function using a dictionary. Explain how memoization improves performance. Compare recursive calls with and without caching. During the demo, show performance differences. Emphasize algorithmic reasoning.

• Multi-Key Record Manager: Create records stored in dictionaries with multiple attributes. Implement sorting by multiple keys (e.g., primary and secondary). Explain sorting stability and ordering. Discuss design tradeoffs. Focus on correctness and explanation.

• Recommendation Engine (Rule-Based): Design a rule-based recommendation system using dictionaries. Store rules and outcomes as key-value mappings. Explain how conditions trigger recommendations. Discuss limitations and extensions. Emphasize design clarity.

• Recursive Simulated Directory Tree Traversal: Represent a directory tree using nested dictionaries. Recursively traverse the structure and display contents. Explain base cases and recursive flow. Discuss real-world applications. Focus on recursion depth and structure.

• Recursive Expression Evaluator: Implement a simple recursive evaluator for arithmetic expressions. Break expressions into smaller components. Explain parsing logic and base cases. Discuss limitations of your approach. Emphasize correctness and reasoning.

• Recursive Simplied JSON File Parser: Traverse a nested dictionary and/or list structure recursively. Extract and display key information. Explain how recursion handles arbitrary depth. Discuss real-world relevance. Focus on clean recursion logic.

• Backtracking Puzzle Solver: Solve a puzzle using recursive backtracking. Explain how choices are explored and undone. Discuss base cases and pruning. Demonstrate a small example. Emphasize algorithmic thinking.

• Recursive Maze Solver: Represent a maze and recursively find a path. Explain decision points and termination. Discuss performance considerations. Demonstrate with different inputs. Focus on recursion reasoning.

• Sorting Benchmark Tool: Measure sorting performance across algorithms. Use dictionaries to store results. Explain benchmarking methodology. Discuss observed trends. Focus on analytical thinking.

• Custom Sorting Framework: Design a framework allowing user-defined sorting rules. Explain abstraction and flexibility. Discuss comparison functions. Demonstrate multiple use cases. Emphasize extensibility.

• Sorting Large Dataset Simulator: Simulate sorting large datasets from files. Explain memory and performance considerations. Discuss algorithm choice. Demonstrate scaled inputs. Focus on reasoning.

• Text Analytics System: Analyze text using dictionaries, recursion, and sorting. Explain data flow and structure. Discuss scalability. Demonstrate insights. Emphasize system integration.

• Recursive Graph Traversal (DFS): Represent a graph using dictionaries and traverse it recursively. Explain traversal order. Discuss base cases and visited tracking. Demonstrate with a sample graph. Focus on algorithm clarity.

• Game State Analyzer: Store game states in dictionaries and explore them recursively. Explain decision trees. Discuss pruning strategies. Demonstrate analysis. Emphasize reasoning depth.

• Multi-Level Data Organizer: Organize hierarchical data using recursion and sorting. Explain structure and traversal. Discuss design choices. Demonstrate outputs. Focus on clarity.

• Rebuilding sorted() Logic: Reimplement simplified sorting behavior. Explain internal logic. Compare with Python’s built-in function. Discuss tradeoffs. Emphasize deep understanding on the sorting topic to graduate-level.

The graduate-level project topics serve as general guidelines and represent the minimum expectations set by the instructor. Please do not limit your imagination when selecting the topic from the list and adding creativity and fun elements to your mini project. If you have additional topic suggestions or project ideas, please do not hesitate to discuss them with me first so I can consider adding them to the list for other graduate students to select as well.