Introduction to Python Programming

Overview: This foundational lesson introduces the core elements of the Python programming language, starting with the traditional "Hello World" program using the print() function. We will establish crucial syntax rules, covering indentation importance, case sensitivity, and how to use comments effectively for code documentation. A significant focus will be placed on variables, covering declaration, assignment, and fundamental data types such as integers, floats, and strings, which are necessary for storing prices and item names. Finally, we will immediately apply these concepts by building the framework for a simple point-of-sale system tailored for a furniture store. This application will involve defining specific item variables (e.g., 'sofa_price', 'quantity') and performing basic arithmetic calculations to determine a final purchase total, solidifying the understanding of Python’s operational flow. Learning Outcomes:

• Execute the standard "Hello World" program using the Python print() function.
• Describe and apply Python’s basic syntax rules, including proper indentation and effective use of comments.
• Define, declare, and assign values to variables using appropriate fundamental data types (int, float, str).
• Utilize basic arithmetic operators to perform simple calculations within a program.
• Construct the initial structure of a point-of-sale system, defining item prices and calculating a transaction total.

Overview: This lesson introduces the fundamental concept of Control Flow, which dictates the order in which a program's code executes. We will begin by exploring Boolean logic, understanding the bool data type (True/False) and relational operators (e.g., ==, >, <) used to create conditional expressions. The core structure, the if statement, will be thoroughly examined, demonstrating how to execute code blocks only when a condition is met. We will then expand this to handle mutually exclusive paths using the else and elif statements, enabling complex decision trees in Python code. Finally, students will master logical operators (and, or, not), allowing them to combine multiple conditional checks efficiently. Practical examples will focus on checking user input constraints and routing program execution based on specific criteria. Learning Outcomes:

• Define Boolean variables and use relational operators (e.g., ==, >, <) to evaluate conditional expressions.
• Construct basic conditional logic structures using the if statement.
• Implement multi-path decision logic using else and elif statements.
• Explain the critical role of indentation in defining Python's control flow blocks.
• Apply logical operators (and, or, not) to create compound conditional tests.

Overview: This lesson introduces the Python list, the fundamental sequence data type for storing ordered, changeable collections. We will begin by defining how to create lists using square brackets [] and demonstrate their ability to hold heterogeneous data types. The core mechanics of lists—indexing and slicing—will be covered extensively, showing students how to access specific elements or sub-sections using both positive (0-based) and negative indexing. A crucial theoretical point covered is mutability, explaining that lists can be modified in place after creation. Practical examples will focus on essential list management methods, including adding elements (append(), insert()), removing elements (remove(), pop(), del keyword), and determining length (len()). Students will learn to effectively store and manipulate dynamic groups of data, a critical skill for any Python application. Learning Outcomes:

• Define and initialize a list in Python using appropriate syntax, understanding its role as an ordered, mutable sequence.
• Access, modify, and extract elements or sub-sections from lists using positive indexing, negative indexing, and slicing.
• Apply fundamental list methods, such as append(), insert(), pop(), and remove(), to dynamically manage list content.
• Explain the concept of mutability and differentiate how list content is managed compared to immutable data types.

Overview: This lesson introduces the concept of iteration, a fundamental programming tool that allows developers to execute code blocks repeatedly, leading to simplified and highly efficient programs. We will dissect the two primary loop structures in Python: the for loop, which is ideal for iterating over a known sequence (such as elements in a list or numbers generated by the range() function), and the while loop, which executes repeatedly as long as a specified Boolean condition remains True. We will demonstrate how to construct robust loops, ensuring proper termination criteria for while loops to prevent infinite execution. Furthermore, we will cover specialized loop control mechanisms, including the break statement to exit a loop immediately, and the continue statement to skip the remainder of the current iteration and proceed to the next, enabling complex flow control for iterative solutions. Learning Outcomes:

• Differentiate between the structural roles of for and while loops and select the appropriate loop type for a given programming task.
• Construct and utilize for loops to iterate efficiently over sequences (like Lists) and use the range() function for numerical iteration.
• Implement safe and controlled while loops, ensuring clear termination conditions to prevent infinite execution.
• Apply break and continue statements to modify the standard flow of loop execution for specific conditional requirements.

Overview: This lesson introduces the essential concept of code reuse through Python functions. Students will first learn the fundamental syntax for defining a function using the 'def' keyword, understanding the importance of proper indentation and optional docstrings. We will cover how to structure functions to accept input via parameters (arguments) and how to return output using the 'return' statement. The core benefit of functions—simplifying code, improving readability, and preventing redundancy (the DRY principle)—will be emphasized. Practical application will involve solving real-world mathematical problems. Students will define and call functions to calculate famous physics formulas, such as Kinetic Energy or gravitational force, demonstrating how functions encapsulate specific logic for easy and repeatable use throughout any Python program. Learning Outcomes:

• Define the purpose of functions in Python programming and articulate the benefits of code reuse and modularity.
• Construct and define simple Python functions using the 'def' keyword, incorporating appropriate parameters and standard naming conventions.
• Successfully call defined functions, passing required arguments to execute the encapsulated logic.
• Utilize the 'return' statement to output results from a function for assignment or further computation.
• Apply functional programming concepts to implement and calculate famous physics formulas, such as calculating distance or velocity.

Overview: This lesson dives into the powerful Python string object, which is fundamental for handling text data. We will begin by exploring how strings are created, including the use of single versus double quotes, and discuss their immutable nature. A core focus will be on accessing and rearranging text using indexing and slicing, which allows for extracting specific characters or substrings efficiently. We will then cover essential methods for text manipulation, including cleaning text using .strip(), changing case with .lower() and .upper(), and checking content using methods like .startswith(). Finally, students will master the process of disassembling large blocks of text into lists of words or lines using the powerful .split() method, and subsequently reassembling them efficiently using the versatile .join() method, enabling automated text processing applications. Learning Outcomes:

• Define the Python string object and apply indexing and slicing to access specific characters or substrings.
• Utilize common string methods like .upper(), .lower(), and .strip() for cleaning and formatting text data.
• Implement string interpolation techniques using f-strings and the .format() method for dynamic text creation.
• Demonstrate the use of .split() to disassemble text into lists and the .join() method to reassemble sequences into strings.

Overview: This lesson introduces the essential concept of Python modules, which allow for code organization and massive functionality extension through reusable files. We will define what a module is (a standard .py file) and explain why using modules promotes code reuse and clarity. The core focus will be mastering the 'import' statement, covering standard syntax (import module_name), aliasing (import module as alias), and targeted imports (from module import item) to manage the program's namespace effectively. We will explore practical examples using fundamental built-in modules from the Python Standard Library, such as the math module (for functions like sqrt or constants like pi) and the random module. Finally, we will illustrate how to create and implement a simple custom module to structure and reuse your own functions across different Python files. Learning Outcomes:

• Define what a Python module is and explain its role in extending functionality and organizing large programs.
• Correctly utilize the standard import statement and its variants (aliasing and targeted imports).
• Demonstrate the ability to call and utilize functions from common built-in modules like math and random.
• Explain how different import methods affect the current program's namespace.
• Create a simple custom Python module containing reusable functions.

Overview: This lesson dives into the Python dictionary, a fundamental, powerful data structure used for mapping unique keys to specific values. We will begin by defining the dictionary structure using curly braces and colon-separated key-value pairs, emphasizing that dictionaries are mutable and optimized for rapid lookups based on the key. The lesson will cover essential operations, including how to efficiently access values using square bracket notation, and how to add new pairs or modify existing values dynamically. We will explore key constraints, noting that keys must be immutable types (like strings or tuples). Finally, students will learn critical methods such as ".keys()", ".values()", and ".items()" for viewing dictionary contents, and how to iterate over these elements using loops, solidifying their ability to store and retrieve complex, unstructured data effectively. Learning Outcomes:

• Define the Python dictionary structure and articulate its primary function as a key-value mapping container.
• Construct and initialize a dictionary using literal syntax and correctly assign and retrieve values based on their corresponding keys.
• Perform CRUD operations (Create, Read, Update, Delete) on dictionary elements using bracket notation and the 'del' keyword.
• Utilize built-in dictionary methods, including .keys(), .values(), and .items(), to efficiently extract different views of the stored data.
• Apply dictionaries in practical coding examples, such as modeling a user profile or managing configuration settings.

Overview: This lesson introduces File Input and Output (I/O) in Python, enabling automation and data persistence. We begin by mastering the core file handling operations: opening files using the built-in open() function, specifying various access modes (read 'r', write 'w', append 'a'), and understanding the crucial role of the with open() as f: context manager to ensure files are automatically closed, preventing resource leaks. Subsequently, we will explore reading and writing unstructured data using standard text files (.txt). The second half focuses on structured data: utilizing Python's dedicated csv module for efficient reading and writing of comma-separated values, and implementing the json module (specifically json.load() and json.dump()) to handle complex, nested JSON data structures, which are vital for interacting with APIs and modern configuration files. Mastery of these concepts is key for building practical Python applications that interact with external data sources. Learning Outcomes:

• Explain the fundamental process of file handling in Python, including the use of the open() function and specifying read/write/append modes.
• Implement the with statement (context manager) to safely and reliably manage file resources, ensuring files are always closed.
• Write Python code to read from and write sequential data to standard text files (.txt).
• Apply the built-in csv module to programmatically read, parse, and generate data in CSV format.
• Utilize the json module to serialize Python objects into JSON format and deserialize JSON data back into usable Python structures.

Overview: This lesson provides a foundational introduction to Object-Oriented Programming (OOP) in Python. We will begin by clarifying the distinction between Python's standard, built-in data types (like int, str, list) and the powerful, user-defined structures known as classes. Learners will understand that a class serves as a blueprint, while an object is a concrete instance derived from that blueprint. We will cover the essential syntax for defining a class using the class keyword, focusing heavily on how to initialize object state using the special __init__ method (the constructor) and how to define operational methods. Finally, we will explore how these concepts enable encapsulation—bundling data and the methods that operate on that data—and briefly discuss the role of interfaces in defining clear behavioral contracts for objects, laying the groundwork for complex software architecture. Learning Outcomes:

• Distinguish between built-in Python data types and custom, user-defined class types.
• Define and articulate the fundamental difference between a class and an object (instance).
• Implement a basic Python class, including instantiation and the definition of instance attributes.
• Utilize the __init__ method (constructor) to properly initialize object state upon creation.
• Explain how encapsulation structures code and contributes to code reusability and maintainability.