This beginner-friendly course provides a structured, hands-on introduction to Python programming. Trainees progress from writing basic programs to developing practical scripts for automation and data processing. Guided exercises and projects reinforce variables, data types, conditions, loops, functions, file handling, and object-oriented programming.

The course also develops debugging, error handling, and good coding habits. Trainees conclude by building a working command-line application that combines the skills learned throughout the course.

 

Duration 6 Days – 42 hrs. 

 

Objectives

• Write and run Python programs using an editor and the command line.
• Use variables, data types, operators, and collections to manage information.
• Apply conditions and loops to control program behavior.
• Create reusable functions and organize code into modules.
• Read, write, and process text, CSV, and JSON files.
• Apply basic object-oriented programming using classes and objects.
• Identify and correct errors using debugging techniques.
• Handle exceptions and validate user input.
• Follow good coding practices to produce readable and maintainable programs.
• Develop scripts that automate routine tasks and process data.
• Build and document a working Python application.

 

Target Audience 

• Beginners with little or no programming experience.
• Professionals who want to automate repetitive tasks.
• Staff who work with files, records, or routine data processing.
• Students and career shifters pursuing foundational programming skills.
• Aspiring developers seeking practical experience with Python.

 

Prerequisites 

• Basic computer literacy, including managing files and folders.
• Familiarity with installing and using desktop applications.
• Basic understanding of arithmetic and logical comparisons.
• No prior programming experience required.
• Access to a computer with permission to install Python and a code editor.

 

 

Course Outline 

Day 1: Getting Started with Python

Module 1: Introduction to Python and the Development Environment

• Python applications in automation, data processing, and software development.
• Installing Python 3 and a code editor.
• Using the interactive interpreter and running Python scripts.
• Understanding program execution, indentation, and comments.
• Guided exercise: Create and run a simple introductory program.

 Module 2: Variables, Data Types, and Basic Operations

• Variables, assignment, and naming conventions.
• Integers, floating-point numbers, strings, Booleans, and None.
• Arithmetic, comparison, and logical operators.
• Type conversion and basic input validation.
• User input, output, and formatted strings.
• Guided project: Build a simple expense or unit conversion calculator.

  

Day 2: Program Logic and Collections

Module 3: Conditions and Loops

• Decision-making with if, elif, and else.
• Combining conditions using logical operators.
• Repetition using for and while loops.
• Using range, break, and continue.
• Tracing program flow and resolving common logic errors.
• Guided exercise: Build a menu-driven program with repeated user input.

 Module 4: Working with Collections

• Creating and using lists, tuples, dictionaries, and sets.
• Accessing, updating, and removing collection items.
• Indexing, slicing, and membership checks.
• Iterating through collections.
• Introduction to list comprehensions.
• Guided project: Create an in-memory inventory or expense tracker.

  

Day 3: Reusable Code and File Handling

Module 5: Functions and Program Organization

• Defining and calling functions.
• Parameters, arguments, default values, and return values.
• Local and global scope.
• Breaking a program into manageable functions.
• Importing standard library modules.
• Creating and importing custom modules.
• Guided exercise: Refactor an earlier project into reusable functions.

 Module 6: Reading, Writing, and Processing Files

• Understanding file paths and using pathlib.
• Reading and writing text files.
• Managing files with context managers.
• Working with CSV files using csv.
• Reading and writing JSON data.
• Handling missing files and malformed records.
• Guided project: Save and reload application records using files.

 

Day 4: Reliable Programs and Object-Oriented Programming

Module 7: Debugging, Error Handling, and Good Coding Practices

• Distinguishing syntax, runtime, and logic errors.
• Reading tracebacks and locating the cause of errors.
• Using breakpoints and inspecting variable values.
• Handling exceptions with try, except, else, and finally.
• Raising meaningful exceptions and validating inputs.
• Applying consistent naming, formatting, and documentation.
• Checking function behavior with simple assertions and introductory unit tests.
• Guided exercise: Diagnose and repair a program containing common errors.

 Module 8: Introduction to Object-Oriented Programming

• Understanding classes, objects, attributes, and methods.
• Initializing objects with __init__.
• Managing instance state and behavior.
• Applying basic encapsulation.
• Introduction to inheritance and composition.
• Choosing between functions and classes for simple applications.
• Guided project: Model inventory items or expense records using classes.

  

Day 5: Automation and Data Processing

Module 9: Automating Routine Tasks

• Planning an automation script around a repeatable task.
• Finding and filtering files with pathlib.
• Creating folders and copying files with standard library tools.
• Working with dates and timestamps.
• Adding command-line arguments with argparse.
• Using preview mode and checking paths before file changes.
• Guided project: Build a file organizer that previews actions before copying files.

 Module 10: Processing Data and Generating Reports

• Loading records from CSV and JSON files.
• Cleaning text and converting data types.
• Validating records and managing incomplete data.
• Filtering, sorting, grouping, and summarizing records.
• Calculating totals, counts, and averages.
• Exporting processed records and summary reports.
• Guided project: Build a CSV processing script that produces a summary report.

  

Day 6: Capstone Application Development

Module 11: Capstone Planning and Implementation

• Define the requirements for a command-line expense tracker.
• Plan the application structure, record format, and user menu.
• Organize the application into functions, modules, and a simple record class.
• Implement adding, viewing, searching, and updating expense records.
• Save and load records using CSV or JSON.
• Validate amounts, dates, categories, and user selections.
• Handle file and input errors with clear messages.

 Module 12: Capstone Completion and Refinement

• Generate expense summaries by category and date range.
• Export a summary report.
• Debug the application and verify typical and invalid inputs.
• Improve readability and remove repeated code.
• Write setup instructions, usage examples, and known limitations.
• Demonstrate the completed application using sample data.

 

Capstone Deliverable: A working Python command-line expense tracker with persistent file storage, input validation, error handling, summary reporting, and user documentation.