Python Learning

Here we post everything that we learn in python while doing this course

Table of contents

1. Python Fundamentals (≈10 Hours)

Environment Setup

Welcome to the first step of your Python journey! In this section, we'll cover everything you need to get started: installing Python, choosing the right IDE, and running your very first script. This foundation will ensure you have a smooth and efficient environment to support your learning.

Check out this detailed blog post: Real Python’s Guide to Installing Python

Environment Setup

1. Installing Python

Python is open-source and free to use. Here’s how to get it on your machine:

• Download the Installer: Visit python.org and download the installer for your operating system. For most users, the latest stable version is the best choice.

• Run the Installer: During installation, make sure to check the box that says "Add Python to PATH." This small step allows you to run Python from any command prompt or terminal window without additional configuration.

• Verify Your Installation: Open your terminal or command prompt and type:

  python --version

  You should see the Python version number displayed, confirming the successful installation.

2. Choosing an IDE

An Integrated Development Environment (IDE) simplifies coding by providing features like syntax highlighting, debugging tools, and code suggestions. Here are a few popular options:

• Visual Studio Code (VS Code): A versatile and lightweight editor, VS Code is highly recommended for beginners. Its extensive marketplace of extensions, including Python-specific plugins, makes it a powerful tool for development.

• PyCharm: PyCharm is a dedicated Python IDE that offers a rich set of features tailored to Python development. While the Community Edition is free, it provides robust tools for coding, testing, and debugging.

• Other Options: Alternatives like Atom, Sublime Text, or even Jupyter Notebook (great for data analysis) can also be considered, depending on your project needs.

Choose the one that best fits your style and workflow. If you’re unsure, starting with VS Code is a safe bet due to its balance of simplicity and functionality.

3. Running Your First Python Script

Now that Python is installed and your IDE is set up, it’s time to write and run a simple script.

• Create a New File: Open your IDE and create a new file named hello.py.

• Write Your Code: Type the following code:

  print("Hello, Python!")

• Run the Script: There are a couple of ways to execute your script:

  • Using the Terminal: Navigate to the directory where your script is saved and run:

    python hello.py

  • From the IDE: Most IDEs provide a “Run” button or similar functionality that allows you to execute the script directly from the interface.

When you run your script, you should see the output “Hello, Python!” in your terminal or the IDE’s console.

---

Python Basics: Syntax & Data Types

Understanding Python’s basic syntax and data types is the foundation of writing efficient code. In this section, we will cover variables, numbers, strings, booleans, and operators.

---

1. Variables & Assignment

A variable stores data in memory and can be assigned using =.

name = "Alice"   # String
age = 25         # Integer
pi = 3.14        # Float
is_active = True # Boolean

• Python is dynamically typed, meaning you don’t need to specify the type explicitly.

• Variable names should be meaningful and follow the snake_case convention (my_variable).

Practice Questions

1. Declare three variables: an integer, a floating-point number, and a string. Print their values.

2. Swap the values of two variables without using a third variable.

3. What will be the output of the following?

   x = 10
   y = "10"
   print(x + y)

   (Predict the output before running the code!)

---

2. Data Types

Python has built-in types for handling different kinds of data:

Type	Example	Description
int	10	Whole numbers
float	3.14	Decimal numbers
str	"Hello"	Text enclosed in quotes
bool	True, False	Logical values
list	[1, 2, 3]	Ordered collection (mutable)
tuple	(1, 2, 3)	Ordered collection (immutable)
dict	{"key": "value"}	Key-value pairs
set	{1, 2, 3}	Unordered unique elements

Use the type() function to check the data type:

print(type(10))       # Output: <class 'int'>
print(type(3.14))     # Output: <class 'float'>
print(type("Hello"))  # Output: <class 'str'>

Practice Questions

1. What is the difference between a list and a tuple? Create one of each.

2. Convert the string "123" to an integer and add 10 to it.

3. What will be the output of bool(""), bool(0), and bool([])? Why?

---

3. Operators in Python

Python supports several operators:

A. Arithmetic Operators

Operator	Description	Example
+	Addition	5 + 3 = 8
-	Subtraction	10 - 2 = 8
*	Multiplication	4 * 2 = 8
/	Division	10 / 2 = 5.0
//	Floor Division	10 // 3 = 3
%	Modulus	10 % 3 = 1
**	Exponentiation	2 ** 3 = 8

B. Comparison Operators

Operator	Description	Example
==	Equal to	5 == 5 → True
!=	Not equal to	5 != 3 → True
>	Greater than	7 > 5 → True
<	Less than	3 < 5 → True
>=	Greater than or equal to	5 >= 5 → True
<=	Less than or equal to	4 <= 6 → True

C. Logical Operators

Operator	Description	Example
and	Returns True if both conditions are true	(5 > 3 and 10 > 5) → True
or	Returns True if at least one condition is true	(5 > 3 or 10 < 5) → True
not	Reverses the boolean value	not(5 > 3) → False

Practice Questions

1. What is the difference between / and // operators in Python?

2. Predict the output of the following:

   a = 5
   b = 2
   print(a ** b // a)

3. Write a program that takes two numbers as input and prints whether the first is greater than, less than, or equal to the second.

---

4. String Operations

Strings (str) are sequences of characters enclosed in quotes.

text = "Hello, World!"
print(len(text))  # Length of the string
print(text.upper())  # Convert to uppercase
print(text.lower())  # Convert to lowercase
print(text[0:5])  # Slicing (first 5 characters)

String Concatenation & Formatting

first_name = "Alice"
last_name = "Smith"
full_name = first_name + " " + last_name  # Concatenation
print(f"My name is {first_name} {last_name}")  # f-strings (modern formatting)

Practice Questions

1. Given a string "Python Programming", write a program to:

   • Convert it to lowercase.

   • Find the index of the letter "P".

   • Extract "Programming" from the string.

2. What is the difference between single quotes (') and double quotes (") in Python strings?

3. What will be the output of the following?

   print("5" + "3")
   print("5" * 3)

Next Steps: Practice these concepts by solving the questions above before moving on to loops and control structures!

---

Python Control Structures: Conditional Statements & Loops

Control structures allow us to control the flow of execution in a program using conditional statements and loops. These are essential for decision-making and repetitive tasks.

---

1. Conditional Statements (if-elif-else)

Python uses if, elif (else if), and else to make decisions based on conditions.

Syntax:

x = 10
if x > 0:
    print("Positive number")  
elif x == 0:
    print("Zero")  
else:
    print("Negative number")  

• The if block executes if the condition is True.

• The elif block executes if the previous conditions are False, but its condition is True.

• The else block executes only if all previous conditions are False.

Practice Questions:

1. Write a Python program to check if a number is even or odd.

2. Given three numbers, write a program to find the largest among them.

3. Predict the output:

   a = 5
   b = 10
   if a > b:
       print("A is greater")
   elif a < b:
       print("B is greater")
   else:
       print("Both are equal")

---

2. Loops in Python

Loops allow us to execute a block of code multiple times.

A. The for Loop

A for loop iterates over a sequence (list, tuple, string, etc.).

for i in range(5):  # Loops from 0 to 4
    print("Iteration:", i)

Looping Over a List:

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

---

B. The while Loop

A while loop runs as long as a condition remains True.

count = 1
while count <= 5:
    print("Count:", count)
    count += 1  # Increment count to avoid infinite loop

---

C. Loop Control Statements

Python provides statements to control loop execution:

Statement	Description
break	Exits the loop immediately
continue	Skips the current iteration and moves to the next
pass	Acts as a placeholder (does nothing)

Example: Using break and continue

for i in range(1, 6):
    if i == 3:
        continue  # Skip 3
    print(i)

for i in range(1, 6):
    if i == 3:
        break  # Stop at 3
    print(i)

---

Practice Questions:

1. Write a Python program to print numbers from 1 to 10 using both for and while loops.

2. Write a program that prints only even numbers from 1 to 20.

3. Predict the output:

   for i in range(3):
       for j in range(2):
           print(i, j)

---

Next Steps: Move on to Functions & Data Structures after practicing these concepts!

2. Functions, Modules, and Data Structures (≈8 Hours)

Functions, modules, and data structures are the building blocks of Python programming. This section covers:

1. Functions: Writing reusable code with parameters and return values.

2. Modules & Packages: Organizing and reusing code efficiently.

3. Core Data Structures: Lists, tuples, dictionaries, and sets.

---

Functions in Python

Functions allow us to write reusable code, making programs more modular and efficient.

1. Defining a Function

A function is defined using the def keyword.

def greet():
    print("Hello, World!")

greet()  # Calling the function

2. Function Parameters & Arguments

Functions can take parameters to accept input values.

def greet(name):
    print(f"Hello, {name}!")

greet("Alice")  # Output: Hello, Alice!

Types of Arguments:

Type	Example
Positional Arguments	greet("Alice")
Keyword Arguments	greet(name="Alice")
Default Arguments	def greet(name="Guest")
Variable-Length Arguments	*args for multiple positional args, **kwargs for multiple keyword args

def add_numbers(*args):  # Accepts multiple numbers
    return sum(args)

print(add_numbers(2, 3, 5))  # Output: 10

3. Return Values in Functions

A function can return values using return.

def square(num):
    return num ** 2

result = square(4)  
print(result)  # Output: 16

---

Practice Questions

1. Write a function that takes two numbers as input and returns their sum.

2. Modify the above function to support variable-length arguments (*args).

3. Predict the output of the following:

   def test(a=5, b=10):
       return a * b
   print(test(3))  

---

Modules & Packages: Organizing and Reusing Code Efficiently

In Python, modules and packages help in organizing code, improving reusability, and maintaining clean project structures.

1. Modules in Python

A module is a Python file (.py) that contains functions, classes, or variables, which can be imported into other programs.

1.1 Creating and Importing Modules

1. Create a module (math_utils.py):

   def add(a, b):
       return a + b
   
   def multiply(a, b):
       return a * b

2. Import and use the module (main.py):

   import math_utils
   
   print(math_utils.add(3, 5))  # Output: 8
   print(math_utils.multiply(4, 2))  # Output: 8

3. Importing specific functions:

   from math_utils import add
   
   print(add(10, 20))  # Output: 30

---

2. Built-in Python Modules

Python comes with many built-in modules. Some common ones include:

Module	Purpose
math	Mathematical functions
random	Generate random numbers
datetime	Work with dates and times
os	Interact with the operating system

Example: Using the math module

import math

print(math.sqrt(25))  # Output: 5.0
print(math.pi)  # Output: 3.141592653589793

---

3. Python Packages

A package is a collection of modules, organized using a directory with an __init__.py file.

3.1 Creating a Package

1. Create a folder named mypackage/

2. Inside mypackage/, create __init__.py (This makes it a package)

3. Add modules: Example, mypackage/utils.py

   def greet(name):
       return f"Hello, {name}!"

4. Import from the package:

   from mypackage import utils
   
   print(utils.greet("Alice"))  # Output: Hello, Alice!

---

Practice Questions

1. Create a module calculator.py with functions for addition, subtraction, and multiplication. Import it into another script and use the functions.

2. Use the random module to generate a random number between 1 and 100.

3. What will be the output of the following?

   import datetime
   print(datetime.datetime.now().year)

---

Core Data Structures: Lists, Tuples, Dictionaries, and Sets

Python provides built-in data structures that help in storing and manipulating collections of data efficiently.

---

1. Lists (Ordered, Mutable, Allows Duplicates)

A list is an ordered collection that can hold different data types and is mutable (modifiable).

1.1 Creating and Accessing Lists

fruits = ["apple", "banana", "cherry"]
print(fruits[0])  # Output: apple

1.2 List Methods

fruits.append("orange")  # Adds an item
fruits.remove("banana")  # Removes an item
print(fruits)  # Output: ['apple', 'cherry', 'orange']

1.3 List Comprehension

squares = [x**2 for x in range(5)]
print(squares)  # Output: [0, 1, 4, 9, 16]

Practice Questions

1. Create a list of numbers and find the sum of all elements.

2. Write a Python program to remove duplicates from a list.

---

2. Tuples (Ordered, Immutable, Allows Duplicates)

Tuples are similar to lists but immutable (cannot be modified).

2.1 Creating and Accessing Tuples

coordinates = (10, 20)
print(coordinates[1])  # Output: 20

2.2 Tuple Unpacking

x, y = coordinates
print(x, y)  # Output: 10 20

Practice Questions

1. Convert a list to a tuple and try modifying it.

2. Write a program to swap two values using tuple unpacking.

---

3. Dictionaries (Key-Value Pairs, Unordered, Mutable)

A dictionary stores data in key-value pairs, making lookups efficient.

3.1 Creating and Accessing Dictionaries

student = {"name": "Alice", "age": 22, "grade": "A"}
print(student["name"])  # Output: Alice

3.2 Dictionary Methods

student["age"] = 23  # Modifying a value
student["city"] = "New York"  # Adding a new key-value pair
del student["grade"]  # Removing a key

Practice Questions

1. Create a dictionary of students with their marks and find the student with the highest marks.

2. Write a Python script to merge two dictionaries.

---

4. Sets (Unordered, Unique Elements, Mutable)

A set is an unordered collection that does not allow duplicates.

4.1 Creating and Using Sets

numbers = {1, 2, 3, 4, 4, 2}
print(numbers)  # Output: {1, 2, 3, 4} (Duplicates removed)

4.2 Set Operations

A = {1, 2, 3}
B = {3, 4, 5}

print(A | B)  # Union: {1, 2, 3, 4, 5}
print(A & B)  # Intersection: {3}
print(A - B)  # Difference: {1, 2}

Practice Questions

1. Write a Python program to remove duplicate values from a list using a set.

2. Given two sets, find their common elements and differences.

---

Error Handling in Python: Introduction to try/except Blocks

Errors (exceptions) can cause a program to crash if not handled properly. Python provides try/except blocks to handle exceptions gracefully.

---

1. What is an Exception?

An exception is an error that occurs during execution. Some common ones:

Exception	Description
ZeroDivisionError	Division by zero
TypeError	Operation on incompatible types
ValueError	Invalid value for a function
IndexError	List index out of range
KeyError	Accessing a non-existent dictionary key

Example of an unhandled exception:

print(5 / 0)  # ZeroDivisionError

---

2. Handling Errors with try/except

2.1 Basic try/except Usage

try:
    num = int(input("Enter a number: "))
    print(10 / num)
except ZeroDivisionError:
    print("Cannot divide by zero!")
except ValueError:
    print("Invalid input! Please enter a number.")

2.2 Using else and finally

• else runs if no exception occurs.

• finally runs always, whether an exception occurs or not.

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ZeroDivisionError:
    print("Cannot divide by zero!")
else:
    print("Result:", result)  # Runs only if no exception
finally:
    print("Execution completed.")  # Always runs

---

3. Raising Custom Exceptions

Use raise to trigger custom exceptions:

def check_age(age):
    if age < 18:
        raise ValueError("Age must be 18 or above!")
    print("Access granted.")

try:
    check_age(15)
except ValueError as e:
    print(e)

---

Practice Questions

1. Write a function that takes a list and an index as input. Use try/except to handle IndexError if the index is out of range.

2. Modify a program to handle KeyError when accessing a dictionary key that doesn’t exist.

3. Predict the output:

   try:
       print(10 / 2)
   except ZeroDivisionError:
       print("Error!")
   else:
       print("No error!")
   finally:
       print("Done!")

---

Object-Oriented Programming (≈6 Hours)

1. Defining a Class and Creating Objects

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

car1 = Car("Toyota", "Corolla")
print(car1.brand)  # Output: Toyota

---

2. Inheritance (Reusing properties and methods from a parent class)

class ElectricCar(Car):
    def __init__(self, brand, model, battery):
        super().__init__(brand, model)
        self.battery = battery

ecar = ElectricCar("Tesla", "Model S", "100 kWh")
print(ecar.battery)  # Output: 100 kWh

---

3. Method Overriding (Redefining a method in a child class)

class Animal:
    def speak(self):
        return "Some sound"

class Dog(Animal):
    def speak(self):
        return "Bark"

dog = Dog()
print(dog.speak())  # Output: Bark

---

4. Encapsulation (Using private variables with _ or __)

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # Private variable

    def get_balance(self):
        return self.__balance  # Getter method

account = BankAccount(1000)
print(account.get_balance())  # Output: 1000

---

5. Polymorphism (Using the same method name for different implementations)

class Cat:
    def speak(self):
        return "Meow"

animals = [Dog(), Cat()]
for animal in animals:
    print(animal.speak())  
# Output: Bark Meow

---

6. Abstract Classes (Using ABC for defining abstract methods)

from abc import ABC, abstractmethod

class Vehicle(ABC):
    @abstractmethod
    def start(self):
        pass

class Bike(Vehicle):
    def start(self):
        print("Bike started")

bike = Bike()
bike.start()  # Output: Bike started

7. Magic Methods (__str__, __len__, etc.)

Magic methods (also called dunder methods) allow objects to define behavior for built-in operations like printing, addition, and length calculations.

Example: __str__ and __len__

class Book:
    def __init__(self, title, pages):
        self.title = title
        self.pages = pages

    def __str__(self):
        return f"Book: {self.title}"

    def __len__(self):
        return self.pages

book = Book("Python Mastery", 300)
print(book)  # Output: Book: Python Mastery
print(len(book))  # Output: 300

---

8. Multiple Inheritance

Multiple inheritance allows a class to inherit from more than one parent class.

Example: Inheriting from Two Classes

class Writer:
    def write(self):
        return "Writing content"

class Editor:
    def edit(self):
        return "Editing content"

class Author(Writer, Editor):
    pass

author = Author()
print(author.write())  # Output: Writing content
print(author.edit())  # Output: Editing content

---

9. Composition

Composition is when a class contains an instance of another class rather than inheriting from it.

Example: Using Composition Instead of Inheritance

class Engine:
    def start(self):
        return "Engine started"

class Car:
    def __init__(self, brand):
        self.brand = brand
        self.engine = Engine()  # Creating an instance of Engine inside Car

    def start(self):
        return f"{self.brand} car: {self.engine.start()}"

car = Car("Toyota")
print(car.start())  # Output: Toyota car: Engine started

---

Practice Questions

1. Create a Person class with name and age attributes, and a method to display them.

2. Implement an Employee class that inherits from Person and adds a salary attribute.

3. Create a Shape class with a method area(), then implement Rectangle and Circle classes with their own area() calculations.

---

4. Building a “Hello World” API with Flask (≈8 Hours)

Simple static API

Steps to Run the API

1. Install Flask (if not already installed):

   pip install flask

2. Save the following code as app.py.

3. Run the script using:

   python app.py

4. Open a browser or use Postman to test:

   • http://127.0.0.1:5000/ → Home Route

   • http://127.0.0.1:5000/data → Static JSON Data

Static API Code (app.py)

from flask import Flask, jsonify

app = Flask(__name__)

# Home Route
@app.route('/')
def home():
    return jsonify({"message": "Welcome to the Static API!"})

# Static JSON Data Route
@app.route('/data')
def get_data():
    return jsonify({
        "name": "Manvendra",
        "role": "Senior Developer",
        "skills": ["Python", "Java", "iOS", "Machine Learning"]
    })

# Run the API
if __name__ == '__main__':
    app.run(debug=True)

Output Examples

1. Visiting / Route

{"message": "Welcome to the Static API!"}

2. Visiting /data Route

{
    "name": "Manvendra",
    "role": "Senior Developer",
    "skills": ["Python", "Java", "iOS", "Machine Learning"]
}

This is a basic static API returning hardcoded JSON responses.

---

Flask API with MongoDB (Dynamic Data)

1. Install Required Libraries

pip install flask pymongo

2. Setup MongoDB

Ensure MongoDB is running locally or use a cloud database (MongoDB Atlas).

• Local Connection URI: mongodb://localhost:27017/

• Cloud Connection URI (Atlas Example): mongodb+srv://<username>:<password>@cluster.mongodb.net/<database>?retryWrites=true&w=majority

3. API Code (app.py)

from flask import Flask, jsonify
from pymongo import MongoClient

app = Flask(__name__)

# Connect to MongoDB
client = MongoClient("mongodb://localhost:27017/")
db = client["testdb"]  # Database
collection = db["users"]  # Collection

# Insert Sample Data (Run once, then comment out)
# collection.insert_many([
#     {"name": "Manvendra", "role": "Senior Developer", "skills": ["Python", "Java"]},
#     {"name": "Alice", "role": "Data Scientist", "skills": ["Python", "ML", "AI"]}
# ])

# Fetch Data from MongoDB
@app.route('/users', methods=['GET'])
def get_users():
    users = list(collection.find({}, {"_id": 0}))  # Exclude MongoDB ObjectId
    return jsonify(users)

if __name__ == '__main__':
    app.run(debug=True)

4. Test API Endpoints

Start the API:

python app.py

Visit:

• http://127.0.0.1:5000/users → Fetches dynamic data from MongoDB.

5. Example Output

[
    {
        "name": "Manvendra",
        "role": "Senior Developer",
        "skills": ["Python", "Java"]
    },
    {
        "name": "Alice",
        "role": "Data Scientist",
        "skills": ["Python", "ML", "AI"]
    }
]

---

Database Integration: MongoDB CRUD Operations (≈6 Hours)

1. Install Required Libraries

pip install flask pymongo

2. API Code (app.py)

from flask import Flask, request, jsonify
from pymongo import MongoClient

app = Flask(__name__)

# Connect to MongoDB
client = MongoClient("mongodb://localhost:27017/")
db = client["testdb"]  # Database
collection = db["users"]  # Collection

# Create (Insert Data)
@app.route('/users', methods=['POST'])
def create_user():
    data = request.json
    collection.insert_one(data)
    return jsonify({"message": "User added successfully"}), 201

# Read (Get All Users)
@app.route('/users', methods=['GET'])
def get_users():
    users = list(collection.find({}, {"_id": 0}))  # Exclude MongoDB ObjectId
    return jsonify(users)

# Update (Modify an Existing User)
@app.route('/users/<string:name>', methods=['PUT'])
def update_user(name):
    data = request.json
    result = collection.update_one({"name": name}, {"$set": data})
    if result.matched_count:
        return jsonify({"message": "User updated successfully"})
    return jsonify({"error": "User not found"}), 404

# Delete (Remove a User)
@app.route('/users/<string:name>', methods=['DELETE'])
def delete_user(name):
    result = collection.delete_one({"name": name})
    if result.deleted_count:
        return jsonify({"message": "User deleted successfully"})
    return jsonify({"error": "User not found"}), 404

if __name__ == '__main__':
    app.run(debug=True)

3. Testing the API

Start the API:

python app.py

Create a User (POST)

POST http://127.0.0.1:5000/users
Body: {"name": "John", "role": "Developer", "skills": ["Python", "Flask"]}

Response:

{"message": "User added successfully"}

Get All Users (GET)

GET http://127.0.0.1:5000/users

Response Example:

[
    {"name": "John", "role": "Developer", "skills": ["Python", "Flask"]}
]

Update a User (PUT)

PUT http://127.0.0.1:5000/users/John
Body: {"role": "Senior Developer"}

Response:

{"message": "User updated successfully"}

Delete a User (DELETE)

DELETE http://127.0.0.1:5000/users/John

Response:

{"message": "User deleted successfully"}

6. Advanced Python Topics (≈8 Hours)

1. Decorators & Context Managers (Enhancing functions and managing resources)

1.1 Decorators (Modifying Function Behavior Without Changing Code)

def decorator(func):
    def wrapper():
        print("Before function call")
        func()
        print("After function call")
    return wrapper

@decorator
def greet():
    print("Hello, World!")

greet()

Output:

Before function call  
Hello, World!  
After function call  

1.2 Context Managers (with Statement for Resource Management)

with open("file.txt", "w") as f:
    f.write("Hello, Python!")

• Ensures the file is closed automatically after execution.

Practice Questions

1. Create a decorator that logs the execution time of a function.

2. Implement a context manager for handling database connections.

---

2. Iterators & Generators (Efficient looping and lazy evaluation)

2.1 Iterators (Custom Iteration Using __iter__ and __next__)

class Counter:
    def __init__(self, start, end):
        self.current = start
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.current >= self.end:
            raise StopIteration
        self.current += 1
        return self.current - 1

counter = Counter(1, 5)
for num in counter:
    print(num)

2.2 Generators (Memory-Efficient Iterators Using yield)

def number_generator(n):
    for i in range(n):
        yield i

gen = number_generator(5)
print(next(gen))  # Output: 0
print(next(gen))  # Output: 1

• Unlike lists, generators do not store all values in memory.

Practice Questions

1. Create an iterator that returns even numbers up to a limit.

2. Write a generator function to yield Fibonacci numbers.

---

3. Testing & Debugging (Ensuring code correctness and finding errors)

3.1 Unit Testing with unittest

import unittest

def add(a, b):
    return a + b

class TestMathOperations(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(2, 3), 5)

if __name__ == "__main__":
    unittest.main()

3.2 Debugging with pdb (Python Debugger)

import pdb

def buggy_function():
    x = 10
    y = 0
    pdb.set_trace()  # Debugging breakpoint
    return x / y  # Causes ZeroDivisionError

# buggy_function()  # Uncomment to debug

Practice Questions

1. Write unit tests for a function that checks if a string is a palindrome.

2. Use Python's pdb module to debug a function that calculates factorial.

---

Machine Learning with Python (≈30–40 Hours)

This section introduces Machine Learning (ML) with Python, covering essential libraries, data preprocessing, model training, and evaluation.

1. Setting Up the ML Environment (≈2 Hours)

• Install key libraries:

  pip install numpy pandas matplotlib seaborn scikit-learn

• Importing ML essentials:

  import numpy as np  
  import pandas as pd  
  import matplotlib.pyplot as plt  
  import seaborn as sns  
  from sklearn.model_selection import train_test_split  

2. Data Preprocessing & Exploration (≈6 Hours)

• Loading Data:

  df = pd.read_csv("data.csv")  
  print(df.head())  

• Handling Missing Values:

  df.fillna(df.mean(), inplace=True)  

• Feature Scaling:

  from sklearn.preprocessing import StandardScaler  
  scaler = StandardScaler()  
  df_scaled = scaler.fit_transform(df)  

Practice Questions

1. Load a dataset and check for missing values.

2. Normalize numerical features using MinMaxScaler.

3. Supervised Learning: Regression & Classification (≈10 Hours)

3.1 Linear Regression (Predicting Continuous Values)

from sklearn.linear_model import LinearRegression  

X = df[["feature1", "feature2"]]  
y = df["target"]  
model = LinearRegression()  
model.fit(X, y)  
print(model.coef_, model.intercept_)  

3.2 Logistic Regression (Binary Classification)

from sklearn.linear_model import LogisticRegression  

model = LogisticRegression()  
model.fit(X, y)  
print(model.predict([[5, 3]]))  

Practice Questions

1. Train a linear regression model to predict house prices.

2. Build a classifier to predict if an email is spam or not.

4. Unsupervised Learning: Clustering & Dimensionality Reduction (≈8 Hours)

4.1 K-Means Clustering (Grouping Similar Data)

from sklearn.cluster import KMeans  

kmeans = KMeans(n_clusters=3)  
kmeans.fit(df)  
df["Cluster"] = kmeans.labels_  

4.2 Principal Component Analysis (PCA) for Dimensionality Reduction

from sklearn.decomposition import PCA  

pca = PCA(n_components=2)  
df_pca = pca.fit_transform(df)  

Practice Questions

1. Apply K-Means to group customers based on purchasing behavior.

2. Use PCA to reduce the dimensions of a dataset with 10+ features.

5. Model Evaluation & Hyperparameter Tuning (≈6 Hours)

• Splitting Data:

  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  

• Evaluating with Metrics:

  from sklearn.metrics import accuracy_score, mean_squared_error  
  
  y_pred = model.predict(X_test)  
  print("Accuracy:", accuracy_score(y_test, y_pred))  

• Hyperparameter Tuning using GridSearchCV:

  from sklearn.model_selection import GridSearchCV  
  
  param_grid = {"C": [0.1, 1, 10]}  
  grid = GridSearchCV(LogisticRegression(), param_grid)  
  grid.fit(X_train, y_train)  
  print(grid.best_params_)  

Practice Questions

1. Evaluate a trained model using R² score or F1-score.

2. Use GridSearchCV to optimize hyperparameters for an SVM model.

6. Deep Learning with TensorFlow & Keras (Optional) (≈8 Hours)

pip install tensorflow keras

import tensorflow as tf  
from tensorflow import keras  

model = keras.Sequential([  
    keras.layers.Dense(128, activation="relu"),  
    keras.layers.Dense(1, activation="sigmoid")  
])  
model.compile(optimizer="adam", loss="binary_crossentropy", metrics=["accuracy"])  

Practice Questions

1. Train a neural network on the MNIST dataset.

2. Implement a CNN for image classification.

---

Next Steps:

Want to work on real-world ML projects or explore NLP & Computer Vision?