Module 1: Introduction to Python

1. What is Python?

Python is a high-level, interpreted programming language known for its simplicity and versatility. It is widely used in areas such as:

• Web Development
• Data Science and Machine Learning
• Scripting and Automation
• Game Development
• Scientific Computing

Key Features:

1. Easy to Learn and Read: Python has an intuitive syntax that resembles natural language.
2. Cross-Platform: Python can run on Windows, macOS, and Linux.
3. Extensive Libraries: Python includes libraries for web development (Flask, Django), data analysis (pandas, numpy), and more.
4. Open Source: Python is free and community-driven.

2. Setting Up Python

A. Installing Python

1. Visit python.org and download the latest version of Python.

2. During installation:

   • Check the option “Add Python to PATH”.
   • Proceed with the installation and verify it.

3. Verify the installation:

   python --version
   

   or

   python3 --version
   

B. Setting Up an IDE

Choose an IDE for Python development. Here are the most popular options:

1. Visual Studio Code

• Lightweight and highly customizable.
• Extensions like Python (Microsoft) enhance the coding experience.
• Installation:
  • Download from VS Code.
  • Install the Python extension from the Extensions Marketplace.
• Running Code:
  • Open a .py file.
  • Click Run or press Ctrl+Shift+P and type “Run Python File”.

2. PyCharm

• A feature-rich IDE for Python, available in both Community (free) and Professional (paid) editions.
• Download from JetBrains PyCharm.
• Create a Python project and start coding.

3. Jupyter Notebook

• Ideal for interactive computing and data science.
• Install using pip:

  pip install notebook
  

• Start Jupyter Notebook:

  jupyter notebook
  

C. Running Python in a Text Editor

You can also use basic editors like Notepad++ or Sublime Text, but IDEs are recommended for beginners.

3. Running Your First Python Script

A. Using the Python Interactive Shell

1. Open your terminal or command prompt.
2. Type:

   python
   

3. Run the command:

   print("Hello, World!")
   

   Output:

   Hello, World!
   

B. Writing a Script

1. Create a new file called hello.py:

   print("Hello, World!")
   

2. Run the script in your terminal:

   python hello.py
   

C. Running Code in an IDE

In IDEs like VS Code or PyCharm:

1. Open the hello.py file.
2. Click the Run button or press the shortcut (F5 in VS Code).

4. Python Syntax and Indentation

Python relies heavily on indentation to define code blocks instead of curly braces ({}) like other languages.

A. Basic Syntax

1. Case Sensitivity:

   • Variable names are case-sensitive:

     age = 25
     Age = 30  # This is a different variable
     

2. Statements:

   • Each statement is typically written on a new line:

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

3. Comments:

   • Single-line comments:

     # This is a comment
     print("Hello, World!")  # Inline comment
     

   • Multi-line comments (using triple quotes):

     """
     This is a
     multi-line comment.
     """
     

B. Indentation

Indentation is mandatory in Python and is used to define blocks of code.

Example: If-Else Block

x = 10
if x > 5:
    print("x is greater than 5")
else:
    print("x is 5 or less")

• Correct: Use consistent spaces (typically 4 spaces per indentation level).
• Incorrect:

  x = 10
  if x > 5:
      print("x is greater than 5")
   else:
       print("This will throw an error")  # IndentationError
  

C. Code Example: Basic Syntax

# Define variables
name = "Alice"
age = 25

# Print a formatted string
print(f"My name is {name} and I am {age} years old.")

# Conditional statement
if age > 18:
    print("You are an adult.")
else:
    print("You are a minor.")

# Loop through a range
for i in range(1, 6):
    print(f"Number: {i}")

5. Practical Exercises

1. Exercise 1: Print Statements

   • Write a script to display:

     print("Welcome to Python!")
     print("Python is fun!")
     

2. Exercise 2: Indentation

   • Fix the following code:

     x = 15
     if x > 10:
     print("Greater than 10")
     else:
         print("10 or less")
     

3. Exercise 3: Create a Simple Script

   • Write a Python script to take user input and display:

     name = input("Enter your name: ")
     print(f"Hello, {name}!")
     

6. Summary

Key Takeaways:

1. Python is a beginner-friendly programming language used for a variety of purposes.
2. Setting up Python involves installing Python and selecting an IDE like VS Code, PyCharm, or Jupyter Notebook.
3. Running Python code can be done interactively, via scripts, or using an IDE.
4. Python uses indentation to define code blocks, which is crucial for error-free execution.

Module 2: Variables and Data Types

1. Variables and Constants

A. What are Variables?

• Variables are containers for storing data.
• You can think of them as labels assigned to values in memory.
• Python does not require specifying the type of the variable; it determines it automatically based on the value assigned.

Syntax

variable_name = value

Example

# Assigning values to variables
name = "Alice"
age = 25
height = 5.4
is_student = True

# Printing variable values
print(name)        # Output: Alice
print(age)         # Output: 25
print(height)      # Output: 5.4
print(is_student)  # Output: True

B. Constants

• Constants are variables whose values should not change during the program.
• Python does not have built-in support for constants but by convention, we use UPPERCASE variable names to represent constants.

Example

PI = 3.14159
GRAVITY = 9.8

# Printing constants
print(PI)       # Output: 3.14159
print(GRAVITY)  # Output: 9.8

2. Data Types

Python has several built-in data types to work with.

A. Core Data Types

1. String (str):
   • A sequence of characters enclosed in quotes.
   • Example: "Hello", 'Python'.
2. Integer (int):
   • Whole numbers (positive or negative).
   • Example: 10, -5.
3. Float (float):
   • Numbers with decimals.
   • Example: 3.14, -2.5.
4. Boolean (bool):
   • Represents True or False.

B. Checking the Type of a Variable

You can use the type() function to check the data type of a variable.

Example

name = "Alice"
age = 25
height = 5.4
is_student = True

print(type(name))       # Output: <class 'str'>
print(type(age))        # Output: <class 'int'>
print(type(height))     # Output: <class 'float'>
print(type(is_student)) # Output: <class 'bool'>

3. Type Conversion

Sometimes you need to convert one data type to another. Python provides built-in functions for this.

A. Common Type Conversion Functions

1. int(): Converts to an integer.
2. float(): Converts to a float.
3. str(): Converts to a string.

Example

# Convert string to integer
num_str = "25"
num_int = int(num_str)
print(num_int)          # Output: 25
print(type(num_int))    # Output: <class 'int'>

# Convert integer to float
num_float = float(num_int)
print(num_float)        # Output: 25.0
print(type(num_float))  # Output: <class 'float'>

# Convert float to string
float_str = str(num_float)
print(float_str)        # Output: '25.0'
print(type(float_str))  # Output: <class 'str'>

B. Automatic Type Conversion

Python automatically converts types during operations (type coercion).

x = 10  # int
y = 3.5 # float
z = x + y
print(z)           # Output: 13.5
print(type(z))     # Output: <class 'float'>

4. Input and Output

A. Input (input())

• Used to take user input.
• Always returns a string, so you may need to convert it to the desired data type.

Example

# Taking user input
name = input("Enter your name: ")
age = int(input("Enter your age: "))
height = float(input("Enter your height: "))

print(f"Name: {name}, Age: {age}, Height: {height}")

B. Output (print())

• Used to display information to the user.
• Accepts multiple arguments separated by commas.
• Supports formatting strings using f-strings or format().

Example

# Simple print
print("Hello, World!")

# Print multiple values
name = "Alice"
age = 25
print("Name:", name, "Age:", age)

# Using f-strings for formatted output
print(f"My name is {name} and I am {age} years old.")

5. Practical Exercises

Exercise 1: Variable Assignment

• Create variables for:
  • Your name.
  • Your age.
  • Your favorite number.
• Print them using print().

Solution

name = "Alice"
age = 25
favorite_number = 7
print(f"Name: {name}, Age: {age}, Favorite Number: {favorite_number}")

Exercise 2: Type Conversion

• Write a program to:
  1. Take an integer input.
  2. Convert it to a float and print.
  3. Convert it to a string and print.

Solution

num = int(input("Enter an integer: "))
print(f"As float: {float(num)}")
print(f"As string: {str(num)}")

Exercise 3: Simple Calculator

• Write a program to:
  1. Take two numbers as input.
  2. Perform addition, subtraction, multiplication, and division.
  3. Print the results.

Solution

num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))

print(f"Addition: {num1 + num2}")
print(f"Subtraction: {num1 - num2}")
print(f"Multiplication: {num1 * num2}")
print(f"Division: {num1 / num2}")

6. Summary

Key Takeaways:

1. Variables store data and can hold different types (int, float, str, bool).
2. Constants are not enforced but can be represented by naming conventions.
3. Use int(), float(), and str() for explicit type conversion.
4. The input() function always returns a string; convert as needed.
5. The print() function is versatile and supports formatted output.

Module 3: Control Flow

Objective: Understand how to control the flow of your Python program using conditional statements, logical operators, loops, and loop control statements. These constructs allow programs to make decisions and repeat tasks efficiently.

1. If-Else Statements

A. Overview

Conditional statements allow your program to make decisions based on conditions.

• if: Executes a block of code if a condition is true.
• else: Executes a block of code if the condition is false.
• elif: Allows multiple conditions to be checked in sequence.

B. Syntax

if condition:
    # Code to execute if condition is True
elif another_condition:
    # Code to execute if another_condition is True
else:
    # Code to execute if all conditions are False

C. Example

age = 20

if age < 18:
    print("You are a minor.")
elif age == 18:
    print("You just became an adult!")
else:
    print("You are an adult.")

2. Logical Operators

A. Overview

Logical operators combine multiple conditions into a single condition:

• and: Returns True if both conditions are true.
• or: Returns True if at least one condition is true.
• not: Reverses the result of a condition.

B. Examples

# Using 'and'
age = 25
has_id = True

if age > 18 and has_id:
    print("You are allowed to enter.")

# Using 'or'
is_member = False
has_pass = True

if is_member or has_pass:
    print("Access granted.")

# Using 'not'
is_logged_in = False

if not is_logged_in:
    print("Please log in first.")

3. Loops

A. For Loops

1. Overview

• A for loop iterates over a sequence (e.g., list, string, range).
• Useful when you know how many iterations are needed.

2. Syntax

for item in sequence:
    # Code to execute for each item

3. Example

# Looping through a list
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(f"I like {fruit}")

# Using range()
for i in range(1, 6):
    print(f"Number: {i}")

B. While Loops

1. Overview

• A while loop repeats a block of code as long as a condition is true.
• Useful when the number of iterations is unknown.

2. Syntax

while condition:
    # Code to execute while condition is True

3. Example

# Count down from 5
count = 5
while count > 0:
    print(f"Countdown: {count}")
    count -= 1

print("Liftoff!")

4. Loop Control Statements

A. Overview

Loop control statements modify the behavior of loops:

1. break: Exits the loop immediately.
2. continue: Skips the current iteration and continues with the next.
3. pass: Does nothing (used as a placeholder).

B. Examples

1. Break

# Exit the loop when number equals 3
for number in range(1, 6):
    if number == 3:
        break
    print(number)

Output:

1
2

2. Continue

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

Output:

1
2
4
5

3. Pass

# Placeholder in a loop
for number in range(1, 6):
    if number == 3:
        pass  # Do nothing
    print(number)

Output:

1
2
3
4
5

5. Practical Exercises

Exercise 1: If-Else

Write a program to check if a number is positive, negative, or zero.

Solution:

number = int(input("Enter a number: "))

if number > 0:
    print("The number is positive.")
elif number < 0:
    print("The number is negative.")
else:
    print("The number is zero.")

Exercise 2: Logical Operators

Write a program to check if a person is eligible to vote (age >= 18) and is a registered voter.

Solution:

age = int(input("Enter your age: "))
is_registered = input("Are you a registered voter? (yes/no): ").lower() == "yes"

if age >= 18 and is_registered:
    print("You are eligible to vote.")
else:
    print("You are not eligible to vote.")

Exercise 3: For Loop

Write a program to calculate the sum of numbers from 1 to 10.

Solution:

total = 0
for i in range(1, 11):
    total += i

print(f"The sum is: {total}")

Exercise 4: While Loop

Write a program to find the factorial of a number using a while loop.

Solution:

number = int(input("Enter a number: "))
factorial = 1

while number > 0:
    factorial *= number
    number -= 1

print(f"The factorial is: {factorial}")

Exercise 5: Loop Control

Write a program to print all numbers from 1 to 10, but skip multiples of 3.

Solution:

for i in range(1, 11):
    if i % 3 == 0:
        continue
    print(i)

6. Summary

Key Takeaways:

1. If-Else Statements:
   • Allow conditional execution of code based on conditions.
2. Logical Operators:
   • Combine conditions using and, or, and not.
3. Loops:
   • for loops iterate over sequences; while loops execute until a condition becomes false.
4. Loop Control Statements:
   • Modify loop behavior with break, continue, and pass.

Module 4: Functions

Objective: Understand how to define and call functions, work with parameters and return values, utilize default and keyword arguments, and manage variable scope in Python programs. Functions help in organizing code, improving reusability, and making programs modular.

1. Defining and Calling Functions

A. Defining Functions

A function is a block of reusable code that performs a specific task. Use the def keyword to define a function.

Syntax

def function_name(parameters):
    # Code block
    return value

Example

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

B. Calling Functions

To call a function, use its name followed by parentheses.

Example

# Defining the function
def greet():
    print("Hello, World!")

# Calling the function
greet()  # Output: Hello, World!

2. Parameters and Return Values

A. Parameters

Parameters allow you to pass values into a function.

Example

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

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

B. Return Values

A function can return a value using the return keyword.

Example

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

result = add(3, 5)
print(result)  # Output: 8

3. Default and Keyword Arguments

A. Default Arguments

Default arguments are used when you want to provide a default value for a parameter.

Example

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

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

B. Keyword Arguments

Keyword arguments allow you to call functions with arguments in a non-positional order by specifying parameter names.

Example

def describe_person(name, age):
    print(f"{name} is {age} years old.")

describe_person(age=25, name="Alice")  # Output: Alice is 25 years old.

4. Scope (Local vs. Global Variables)

A. Local Variables

• Variables declared inside a function are local to that function.
• They cannot be accessed outside the function.

Example

def greet():
    message = "Hello, World!"  # Local variable
    print(message)

greet()        # Output: Hello, World!
# print(message)  # Error: message is not defined

B. Global Variables

• Variables declared outside any function are global.
• They can be accessed and modified inside a function using the global keyword.

Example

message = "Hello, Global!"  # Global variable

def greet():
    global message
    message = "Hello, Local!"
    print(message)

greet()        # Output: Hello, Local!
print(message) # Output: Hello, Local!

5. Practical Exercises

Exercise 1: Simple Function

Write a function to calculate the square of a number.

Solution:

def square(num):
    return num ** 2

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

Exercise 2: Function with Default Arguments

Write a function to greet a user with a default name.

Solution:

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

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

Exercise 3: Keyword Arguments

Write a function to display a person’s details.

Solution:

def show_details(name, age, city):
    print(f"{name} is {age} years old and lives in {city}.")

show_details(age=30, city="New York", name="Alice")

Exercise 4: Local vs. Global Variables

Write a program to demonstrate the difference between local and global variables.

Solution:

counter = 10  # Global variable

def increment():
    global counter
    counter += 1  # Modifying global variable
    print(f"Inside function: {counter}")

increment()          # Output: Inside function: 11
print(counter)       # Output: 11

Exercise 5: Return Multiple Values

Write a function to return the sum and product of two numbers.

Solution:

def calculate(a, b):
    return a + b, a * b

sum_, product = calculate(3, 5)
print(f"Sum: {sum_}, Product: {product}")

6. Summary

Key Takeaways:

1. Defining Functions:
   • Use def followed by the function name and parentheses.
2. Parameters and Return Values:
   • Functions can take input (parameters) and return output (return values).
3. Default and Keyword Arguments:
   • Default arguments provide fallback values.
   • Keyword arguments allow calling with parameter names.
4. Scope:
   • Local variables are limited to their function, while global variables can be accessed globally.

Module 5: Data Structures

Objective: Learn the foundational data structures in Python, including lists, tuples, sets, and dictionaries. Each data structure serves a unique purpose, and understanding their operations will enhance your ability to solve complex programming problems efficiently.

1. Lists

A. Overview

• A list is an ordered, mutable collection of elements.
• It can contain elements of different data types (e.g., integers, strings, or even other lists).

B. Creating a List

fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4, 5]
mixed = ["text", 42, 3.14, True]

C. Adding Elements

1. append(): Adds a single element to the end of the list.
2. extend(): Adds multiple elements to the list.
3. insert(): Inserts an element at a specific index.

Examples

fruits = ["apple", "banana"]
fruits.append("cherry")
print(fruits)  # Output: ['apple', 'banana', 'cherry']

fruits.extend(["date", "fig"])
print(fruits)  # Output: ['apple', 'banana', 'cherry', 'date', 'fig']

fruits.insert(1, "blueberry")
print(fruits)  # Output: ['apple', 'blueberry', 'banana', 'cherry', 'date', 'fig']

D. Removing Elements

1. remove(): Removes the first occurrence of an element.
2. pop(): Removes an element at a specific index (or the last element if no index is provided).
3. clear(): Removes all elements.

Examples

fruits = ["apple", "banana", "cherry", "apple"]
fruits.remove("apple")
print(fruits)  # Output: ['banana', 'cherry', 'apple']

fruits.pop(1)
print(fruits)  # Output: ['banana', 'apple']

fruits.clear()
print(fruits)  # Output: []

E. Slicing

Slicing extracts a portion of the list using the [start:end:step] syntax.

Examples

numbers = [1, 2, 3, 4, 5, 6]
print(numbers[1:4])  # Output: [2, 3, 4]
print(numbers[:3])   # Output: [1, 2, 3]
print(numbers[::2])  # Output: [1, 3, 5]

F. Iterating

Use a for loop to iterate over elements.

Example

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

2. Tuples

A. Overview

• A tuple is an immutable, ordered collection of elements.
• Once created, elements cannot be added, removed, or modified.

B. Creating a Tuple

fruits = ("apple", "banana", "cherry")
numbers = (1, 2, 3, 4, 5)

C. Accessing Elements

Tuples support indexing and slicing, just like lists.

Example

print(fruits[1])  # Output: banana
print(numbers[:3])  # Output: (1, 2, 3)

D. Iterating

for fruit in fruits:
    print(fruit)

E. Why Use Tuples?

1. Tuples are faster than lists.
2. They are immutable, making them useful for data that shouldn’t change.

3. Sets

A. Overview

• A set is an unordered collection of unique elements.
• Elements are not indexed.

B. Creating a Set

fruits = {"apple", "banana", "cherry"}

C. Set Operations

1. Union (|): Combines all unique elements from two sets.
2. Intersection (&): Returns common elements.
3. Difference (-): Returns elements in one set but not in the other.

Examples

set1 = {1, 2, 3}
set2 = {3, 4, 5}

print(set1 | set2)  # Output: {1, 2, 3, 4, 5}
print(set1 & set2)  # Output: {3}
print(set1 - set2)  # Output: {1, 2}

D. Adding and Removing Elements

• add(): Adds an element.
• remove(): Removes an element.

Example

fruits.add("date")
print(fruits)  # Output: {'apple', 'banana', 'cherry', 'date'}

fruits.remove("banana")
print(fruits)  # Output: {'apple', 'cherry', 'date'}

4. Dictionaries

A. Overview

• A dictionary is a collection of key-value pairs.
• Keys are unique, and values can be of any type.

B. Creating a Dictionary

person = {"name": "Alice", "age": 25, "city": "New York"}

C. Accessing Elements

Access elements using keys.

Example

print(person["name"])  # Output: Alice
print(person.get("age"))  # Output: 25

D. Adding and Updating

person["job"] = "Engineer"  # Add
person["age"] = 26         # Update
print(person)

E. Removing Elements

• pop(key): Removes a specific key.
• clear(): Removes all key-value pairs.

Example

person.pop("city")
print(person)  # Output: {'name': 'Alice', 'age': 26, 'job': 'Engineer'}

person.clear()
print(person)  # Output: {}

F. Iterating

for key, value in person.items():
    print(f"{key}: {value}")

5. Practical Exercises

Exercise 1: List Operations

Write a program to:

1. Create a list of numbers.
2. Add a new number to the list.
3. Remove the smallest number.
4. Print the sorted list.

Solution:

numbers = [5, 2, 8, 1, 9]
numbers.append(6)
numbers.remove(min(numbers))
print(sorted(numbers))

Exercise 2: Tuple

Create a tuple of fruits and print the second element.

Solution:

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

Exercise 3: Set Operations

Write a program to:

1. Create two sets of integers.
2. Perform union, intersection, and difference.

Solution:

set1 = {1, 2, 3}
set2 = {3, 4, 5}

print(set1 | set2)  # Union
print(set1 & set2)  # Intersection
print(set1 - set2)  # Difference

Exercise 4: Dictionary

Write a program to:

1. Create a dictionary of a person’s details.
2. Update the person’s age.
3. Print all key-value pairs.

Solution:

person = {"name": "Alice", "age": 25, "city": "New York"}
person["age"] = 26
for key, value in person.items():
    print(f"{key}: {value}")

6. Summary

Key Takeaways:

1. Lists:
   • Ordered, mutable, and allow duplicates.
2. Tuples:
   • Immutable and ordered.
3. Sets:
   • Unordered, unique elements, with powerful mathematical operations.
4. Dictionaries:
   • Key-value pairs for efficient data storage and retrieval.

Module 6: File Handling

Objective: Learn how to handle files in Python for reading, writing, and managing data stored in plain text or CSV files. This module will introduce essential file operations and the csv module for structured data.

1. Reading Files

A. Using open() and .read()

The open() function is used to open a file in Python. It returns a file object, which can be used to read or write to the file.

Syntax

file = open("filename", mode)

• filename: Path to the file.
• mode: Specifies the operation (e.g., read, write, append).
  • "r": Read (default mode).
  • "rb": Read in binary mode.

B. Reading File Content

1. read(): Reads the entire content of the file.
2. readline(): Reads one line at a time.
3. readlines(): Reads all lines and returns them as a list.

Examples

# Example file: example.txt
# Content: 
# Hello, World!
# Welcome to Python.

# Reading the entire file
file = open("example.txt", "r")
content = file.read()
print(content)  # Output: Hello, World!\nWelcome to Python.
file.close()

# Reading line by line
file = open("example.txt", "r")
line = file.readline()
while line:
    print(line.strip())  # Output: Hello, World! \n Welcome to Python.
    line = file.readline()
file.close()

# Reading all lines at once
file = open("example.txt", "r")
lines = file.readlines()
print(lines)  # Output: ['Hello, World!\n', 'Welcome to Python.\n']
file.close()

C. Using with Statement

The with statement automatically closes the file after the operation is complete.

Example

with open("example.txt", "r") as file:
    content = file.read()
    print(content)

2. Writing Files

A. Writing to a File

Use the mode "w" (write) or "a" (append) to write to a file. Writing will overwrite existing content, while appending will add new content to the end.

Example

# Writing to a file
with open("example.txt", "w") as file:
    file.write("Hello, World!\n")
    file.write("Welcome to Python.\n")

# Appending to a file
with open("example.txt", "a") as file:
    file.write("This is an appended line.\n")

B. Writing Multiple Lines

Use a list of strings and the writelines() method to write multiple lines.

Example

lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
with open("example.txt", "w") as file:
    file.writelines(lines)

3. Working with CSV Files

A. Overview of the csv Module

The csv module allows easy handling of CSV (Comma-Separated Values) files, commonly used for storing tabular data.

B. Reading CSV Files

Use csv.reader() to read CSV files.

Example: Reading a CSV File

import csv

with open("example.csv", "r") as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)

CSV File: example.csv

Name,Age,City
Alice,25,New York
Bob,30,Los Angeles

Output:

['Name', 'Age', 'City']
['Alice', '25', 'New York']
['Bob', '30', 'Los Angeles']

C. Writing CSV Files

Use csv.writer() to write data into a CSV file.

Example: Writing to a CSV File

import csv

data = [
    ["Name", "Age", "City"],
    ["Alice", 25, "New York"],
    ["Bob", 30, "Los Angeles"]
]

with open("example.csv", "w", newline="") as file:
    writer = csv.writer(file)
    writer.writerows(data)

Output File: example.csv

Name,Age,City
Alice,25,New York
Bob,30,Los Angeles

D. Reading CSV as a Dictionary

Use csv.DictReader() to read rows as dictionaries.

Example

import csv

with open("example.csv", "r") as file:
    reader = csv.DictReader(file)
    for row in reader:
        print(row)

Output:

{'Name': 'Alice', 'Age': '25', 'City': 'New York'}
{'Name': 'Bob', 'Age': '30', 'City': 'Los Angeles'}

E. Writing CSV as a Dictionary

Use csv.DictWriter() to write dictionaries to a CSV file.

Example

import csv

data = [
    {"Name": "Alice", "Age": 25, "City": "New York"},
    {"Name": "Bob", "Age": 30, "City": "Los Angeles"}
]

with open("example.csv", "w", newline="") as file:
    fieldnames = ["Name", "Age", "City"]
    writer = csv.DictWriter(file, fieldnames=fieldnames)
    
    writer.writeheader()  # Write the header row
    writer.writerows(data)

4. Practical Exercises

Exercise 1: Read and Print a Text File

Write a program to read and print the contents of a text file.

Solution:

with open("example.txt", "r") as file:
    content = file.read()
    print(content)

Exercise 2: Append to a Text File

Write a program to append a new line to a file.

Solution:

with open("example.txt", "a") as file:
    file.write("This is a new line.\n")

Exercise 3: CSV Reader

Write a program to read a CSV file and print only the rows where age is greater than 25.

Solution:

import csv

with open("example.csv", "r") as file:
    reader = csv.DictReader(file)
    for row in reader:
        if int(row["Age"]) > 25:
            print(row)

Exercise 4: CSV Writer

Write a program to write data of students (Name, Age, Grade) into a CSV file.

Solution:

import csv

data = [
    {"Name": "Alice", "Age": 20, "Grade": "A"},
    {"Name": "Bob", "Age": 22, "Grade": "B"}
]

with open("students.csv", "w", newline="") as file:
    fieldnames = ["Name", "Age", "Grade"]
    writer = csv.DictWriter(file, fieldnames=fieldnames)
    
    writer.writeheader()
    writer.writerows(data)

5. Summary

Key Takeaways:

1. Reading Files:
   • Use open() and methods like .read(), .readline(), and .readlines().
   • Use with to manage file closing automatically.
2. Writing Files:
   • Use write() to add content and writelines() for multiple lines.
   • Use "w" for overwriting and "a" for appending.
3. Working with CSV:
   • Use the csv module for reading and writing structured data.
   • csv.DictReader and csv.DictWriter simplify working with dictionaries.

Module 7: Error and Exception Handling

Objective: Learn how to identify and handle common exceptions in Python using try, except, and finally blocks. This module will also explore raising custom exceptions with the raise keyword to manage errors effectively.

1. Common Exceptions

A. What are Exceptions?

Exceptions are errors that occur during the execution of a program. They disrupt the normal flow of the program but can be handled to prevent crashes.

B. Common Exceptions in Python

C. Examples

1. ValueError

num = int("abc")  # Raises ValueError: invalid literal for int()

2. TypeError

result = "5" + 5  # Raises TypeError: can only concatenate str (not "int") to str

3. ZeroDivisionError

result = 10 / 0  # Raises ZeroDivisionError: division by zero

4. IndexError

numbers = [1, 2, 3]
print(numbers[5])  # Raises IndexError: list index out of range

2. Using try, except, and finally

A. Overview

• try block: Code that might raise an exception is placed here.
• except block: Code to handle the exception.
• finally block: Code that always executes, regardless of whether an exception occurred.

B. Syntax

try:
    # Code that may raise an exception
except ExceptionType:
    # Code to handle the exception
finally:
    # Code that will always execute (optional)

C. Handling Specific Exceptions

Example

try:
    num = int(input("Enter a number: "))
    result = 10 / num
    print(f"Result: {result}")
except ValueError:
    print("Please enter a valid integer.")
except ZeroDivisionError:
    print("Cannot divide by zero.")
finally:
    print("Execution complete.")

Output (if num = 0):

Cannot divide by zero.
Execution complete.

Output (if num = abc):

Please enter a valid integer.
Execution complete.

D. Catching All Exceptions

Use a general except block to handle any exception.

try:
    # Some risky code
except Exception as e:
    print(f"An error occurred: {e}")

E. Using else

The else block executes if no exception is raised.

Example

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ZeroDivisionError:
    print("Cannot divide by zero.")
except ValueError:
    print("Please enter a valid number.")
else:
    print(f"Result: {result}")  # Executes only if no exception occurs
finally:
    print("Execution complete.")

3. Raising Exceptions

A. Overview

Use the raise keyword to trigger an exception manually.

B. Syntax

raise ExceptionType("Error message")

C. Examples

1. Raising Built-in Exceptions

def divide(a, b):
    if b == 0:
        raise ZeroDivisionError("Cannot divide by zero.")
    return a / b

try:
    print(divide(10, 0))
except ZeroDivisionError as e:
    print(e)

2. Custom Exceptions

You can define custom exceptions by creating a new class that inherits from Exception.

class NegativeNumberError(Exception):
    """Custom exception for negative numbers."""
    pass

def check_positive(num):
    if num < 0:
        raise NegativeNumberError("Negative numbers are not allowed.")
    print(f"Number {num} is positive.")

try:
    check_positive(-5)
except NegativeNumberError as e:
    print(e)

Output:

Negative numbers are not allowed.

4. Practical Exercises

Exercise 1: Catch Specific Exceptions

Write a program to:

1. Take two numbers as input.
2. Perform division.
3. Handle ValueError and ZeroDivisionError.

Solution:

try:
    num1 = int(input("Enter the numerator: "))
    num2 = int(input("Enter the denominator: "))
    result = num1 / num2
    print(f"Result: {result}")
except ValueError:
    print("Please enter valid numbers.")
except ZeroDivisionError:
    print("Cannot divide by zero.")

Exercise 2: Raising Exceptions

Write a function to check if a number is positive. Raise an exception if it is negative.

Solution:

def check_positive(num):
    if num < 0:
        raise ValueError("Negative numbers are not allowed.")
    return True

try:
    print(check_positive(-5))
except ValueError as e:
    print(e)

Exercise 3: Using finally

Write a program to open a file, read its content, and ensure the file is closed using finally.

Solution:

try:
    file = open("example.txt", "r")
    print(file.read())
except FileNotFoundError:
    print("File not found.")
finally:
    file.close()
    print("File closed.")

Exercise 4: Custom Exception

Define a custom exception for invalid age input and raise it if the age is negative.

Solution:

class InvalidAgeError(Exception):
    """Custom exception for invalid age."""
    pass

def check_age(age):
    if age < 0:
        raise InvalidAgeError("Age cannot be negative.")
    print(f"Age: {age}")

try:
    check_age(-3)
except InvalidAgeError as e:
    print(e)

5. Summary

Key Takeaways:

1. Common Exceptions:
   • Python provides many built-in exceptions like ValueError, TypeError, IndexError, etc.
2. Using try, except, and finally:
   • Handle exceptions gracefully to avoid program crashes.
3. Raising Exceptions:
   • Use raise to trigger exceptions manually, including custom exceptions.
4. Custom Exceptions:
   • Create specialized exception classes for specific use cases.

Module 8: Object-Oriented Programming (OOP)

Objective: Master the concepts of Object-Oriented Programming (OOP) in Python, including creating classes and objects, understanding methods and constructors, using inheritance and polymorphism for code reusability, and managing encapsulation to protect data integrity.

1. Classes and Objects

A. What is a Class?

• A class is a blueprint for creating objects.
• It defines attributes (data) and methods (functions) that the objects will have.

B. What is an Object?

• An object is an instance of a class.
• Objects are created using the class blueprint.

C. Defining a Class

Syntax

class ClassName:
    # Attributes and methods

Example

# Defining a class
class Dog:
    # Attribute
    species = "Canine"
    
    # Method
    def bark(self):
        print("Woof! Woof!")

# Creating an object
my_dog = Dog()
print(my_dog.species)  # Output: Canine
my_dog.bark()          # Output: Woof! Woof!

2. Methods and Constructors

A. Methods

• Methods are functions defined inside a class.
• The first parameter of any method is self, which refers to the instance calling the method.

Example

class Dog:
    def bark(self):
        print("Woof! Woof!")

# Using a method
my_dog = Dog()
my_dog.bark()

B. Constructors

• A constructor is a special method used to initialize an object when it is created.
• It is defined using the __init__ method.

Example

class Dog:
    def __init__(self, name, age):
        self.name = name  # Instance variable
        self.age = age    # Instance variable

    def bark(self):
        print(f"{self.name} says Woof!")

# Creating an object with constructor
my_dog = Dog("Buddy", 3)
print(my_dog.name)  # Output: Buddy
print(my_dog.age)   # Output: 3
my_dog.bark()       # Output: Buddy says Woof!

3. Inheritance and Polymorphism

A. Inheritance

• Inheritance allows a class to inherit the attributes and methods of another class.
• The parent class is also called the base class, and the child class is the derived class.

Example

class Animal:
    def eat(self):
        print("This animal eats food.")

class Dog(Animal):
    def bark(self):
        print("Woof! Woof!")

# Using inheritance
my_dog = Dog()
my_dog.eat()  # Output: This animal eats food.
my_dog.bark() # Output: Woof! Woof!

B. Polymorphism

• Polymorphism allows different classes to have methods with the same name, which behave differently depending on the object.

Example

class Animal:
    def sound(self):
        print("Animals make sounds.")

class Dog(Animal):
    def sound(self):
        print("Woof! Woof!")

class Cat(Animal):
    def sound(self):
        print("Meow!")

# Using polymorphism
animals = [Dog(), Cat()]
for animal in animals:
    animal.sound()

Output:

Woof! Woof!
Meow!

4. Encapsulation with Private/Public Attributes

A. Public Attributes

• By default, all attributes in Python are public and can be accessed from outside the class.

Example

class Dog:
    def __init__(self, name):
        self.name = name  # Public attribute

my_dog = Dog("Buddy")
print(my_dog.name)  # Output: Buddy

B. Private Attributes

• Private attributes are indicated by a double underscore (__) prefix.
• They cannot be accessed directly from outside the class.

Example

class Dog:
    def __init__(self, name):
        self.__name = name  # Private attribute

    def get_name(self):  # Getter method
        return self.__name

    def set_name(self, name):  # Setter method
        self.__name = name

my_dog = Dog("Buddy")
print(my_dog.get_name())  # Output: Buddy
my_dog.set_name("Max")
print(my_dog.get_name())  # Output: Max

C. Why Encapsulation?

• Encapsulation hides sensitive data to protect it from being modified accidentally.
• Access to private attributes is controlled through getter and setter methods.

5. Practical Exercises

Exercise 1: Creating Classes and Objects

Write a Car class with:

1. Attributes: brand, model, year.
2. A method start() that prints “The car is starting.”

Solution:

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

    def start(self):
        print(f"The {self.brand} {self.model} is starting.")

my_car = Car("Toyota", "Corolla", 2020)
my_car.start()

Exercise 2: Inheritance

Create a Person class and a Student subclass. The Student class should have an additional attribute student_id.

Solution:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f"Hello, my name is {self.name}.")

class Student(Person):
    def __init__(self, name, age, student_id):
        super().__init__(name, age)
        self.student_id = student_id

    def show_id(self):
        print(f"My student ID is {self.student_id}.")

student = Student("Alice", 20, "S12345")
student.greet()
student.show_id()

Exercise 3: Polymorphism

Write two classes, Bird and Fish, both with a move() method. Demonstrate polymorphism by calling move() on instances of both classes.

Solution:

class Bird:
    def move(self):
        print("I fly.")

class Fish:
    def move(self):
        print("I swim.")

animals = [Bird(), Fish()]
for animal in animals:
    animal.move()

Exercise 4: Encapsulation

Create a BankAccount class with a private attribute __balance and methods deposit() and withdraw().

Solution:

class BankAccount:
    def __init__(self):
        self.__balance = 0

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print(f"Deposited: {amount}")
        else:
            print("Invalid amount.")

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            print(f"Withdrawn: {amount}")
        else:
            print("Invalid transaction.")

    def get_balance(self):
        return self.__balance

account = BankAccount()
account.deposit(100)
account.withdraw(50)
print(f"Balance: {account.get_balance()}")

6. Summary

Key Takeaways:

1. Classes and Objects:
   • A class is a blueprint; an object is an instance of a class.
2. Methods and Constructors:
   • Methods define object behavior; constructors initialize objects.
3. Inheritance and Polymorphism:
   • Inheritance promotes reusability; polymorphism allows different behaviors for the same method name.
4. Encapsulation:
   • Protects sensitive data using private attributes and getter/setter methods.

Module 9: Modules and Libraries

Objective: Understand how to create and use Python modules, import functionality from modules, and work with standard libraries such as math, datetime, and random. Modules and libraries help in organizing code and using pre-built functionalities to save time and effort.

1. Creating and Using Modules

A. What is a Module?

• A module is a file containing Python code (functions, variables, or classes) that can be reused in other programs.
• Modules make it easy to organize code and avoid duplication.

B. Creating a Module

A module is simply a .py file with reusable code.

Example: Create a File greetings.py

# greetings.py
def say_hello(name):
    return f"Hello, {name}!"

def say_goodbye(name):
    return f"Goodbye, {name}!"

C. Using a Module

To use the functions from a module, you can import it.

Example

# main.py
import greetings

print(greetings.say_hello("Alice"))  # Output: Hello, Alice!
print(greetings.say_goodbye("Alice"))  # Output: Goodbye, Alice!

D. Importing Specific Functions

Use from ... import to import specific functions or variables.

Example

from greetings import say_hello

print(say_hello("Bob"))  # Output: Hello, Bob!

E. Aliasing a Module

Use as to give a module or function an alias.

Example

import greetings as gr

print(gr.say_hello("Charlie"))  # Output: Hello, Charlie!

2. Standard Libraries

Python comes with a wide range of built-in libraries for common tasks. Here, we will focus on math, datetime, and random.

A. The math Module

1. Overview

The math module provides functions for mathematical operations.

2. Common Functions

Example

import math

print(math.sqrt(16))          # Output: 4.0
print(math.pow(2, 3))         # Output: 8.0
print(math.pi)                # Output: 3.141592653589793
print(math.sin(math.pi / 2))  # Output: 1.0
print(math.factorial(5))      # Output: 120

B. The datetime Module

1. Overview

The datetime module helps in working with dates and times.

2. Common Classes and Methods

Example

import datetime

# Get the current date and time
now = datetime.datetime.now()
print(f"Current Date and Time: {now}")

# Create a specific date
specific_date = datetime.date(2024, 1, 1)
print(f"Specific Date: {specific_date}")

# Add 7 days to the current date
future_date = now + datetime.timedelta(days=7)
print(f"Date 7 days from now: {future_date.strftime('%Y-%m-%d')}")

C. The random Module

1. Overview

The random module is used to generate random numbers and perform random operations.

2. Common Functions

Example

import random

# Random integer
print(random.randint(1, 10))  # Output: Random number between 1 and 10

# Random float
print(random.random())  # Output: Random number between 0.0 and 1.0

# Random choice
fruits = ["apple", "banana", "cherry"]
print(random.choice(fruits))  # Output: Randomly chosen fruit

# Shuffle a list
numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)
print(numbers)  # Output: Shuffled list

# Random sample
print(random.sample(numbers, 3))  # Output: Random 3 numbers from the list

3. Practical Exercises

Exercise 1: Using a Custom Module

Create a math_operations.py module with the following functions:

1. add(a, b)
2. subtract(a, b)
3. multiply(a, b)
4. divide(a, b)

Import the module and use its functions.

Solution:

# math_operations.py
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

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

def divide(a, b):
    if b != 0:
        return a / b
    return "Division by zero is not allowed"

# main.py
import math_operations

print(math_operations.add(10, 5))        # Output: 15
print(math_operations.divide(10, 0))    # Output: Division by zero is not allowed

Exercise 2: Using the math Module

Write a program to calculate the area of a circle given its radius.

Solution:

import math

radius = float(input("Enter the radius of the circle: "))
area = math.pi * math.pow(radius, 2)
print(f"Area of the circle: {area}")

Exercise 3: Using the datetime Module

Write a program to display today’s date and calculate the date 30 days from today.

Solution:

import datetime

today = datetime.date.today()
future_date = today + datetime.timedelta(days=30)

print(f"Today's date: {today}")
print(f"Date 30 days from today: {future_date}")

Exercise 4: Using the random Module

Write a program to simulate a dice roll (random number between 1 and 6).

Solution:

import random

dice_roll = random.randint(1, 6)
print(f"Dice rolled: {dice_roll}")

4. Summary

Key Takeaways:

1. Modules:
   • Organize code into reusable files (.py files).
   • Use import or from ... import to bring modules into your program.
2. Standard Libraries:
   • math: For mathematical operations.
   • datetime: For working with dates and times.
   • random: For generating random numbers and operations.
3. Practical Use:
   • Use built-in modules to simplify coding tasks.

Module 10: Regular Expressions

Objective: Learn how to use Python’s re module to work with regular expressions for searching, matching, replacing, and extracting data in text. Regular expressions (regex) are powerful tools for text processing and pattern matching.

1. Using the re Module

A. Overview

The re module in Python provides functions to work with regular expressions. Commonly used functions include:

• re.search(): Searches for a pattern in a string.
• re.match(): Checks if a string matches a pattern at the beginning.
• re.findall(): Returns all occurrences of a pattern in a string.
• re.sub(): Replaces occurrences of a pattern with a specified string.

B. Importing the re Module

import re

C. Defining Patterns

Regex patterns are defined as strings, using special characters for matching:

2. Searching and Matching Patterns

A. Using re.search()

• Finds the first match of a pattern in a string.
• Returns a Match object if found, otherwise None.

Example

import re

text = "Welcome to Python 101!"
pattern = r"\d+"  # Match one or more digits

match = re.search(pattern, text)
if match:
    print(f"Found match: {match.group()}")  # Output: Found match: 101
else:
    print("No match found.")

B. Using re.match()

• Matches a pattern only at the beginning of the string.

Example

text = "Python is fun."
pattern = r"Python"

match = re.match(pattern, text)
if match:
    print("Match found at the beginning.")  # Output: Match found at the beginning.
else:
    print("No match found.")

C. Using re.findall()

• Finds all occurrences of a pattern in a string and returns them as a list.

Example

text = "My numbers are 123, 456, and 789."
pattern = r"\d+"  # Match all numbers

matches = re.findall(pattern, text)
print(matches)  # Output: ['123', '456', '789']

3. Replacing and Extracting Data Using Regex

A. Using re.sub()

• Replaces all occurrences of a pattern with a specified string.

Example

text = "My email is [email protected]."
pattern = r"@\w+\.\w+"  # Match domain

result = re.sub(pattern, "@hidden.com", text)
print(result)  # Output: My email is [email protected].

B. Using Groups to Extract Data

• Parentheses ( ) in a pattern define groups to extract specific parts of a match.

Example

text = "My phone number is (123) 456-7890."
pattern = r"\((\d+)\)\s(\d+)-(\d+)"  # Match area code, prefix, and line number

match = re.search(pattern, text)
if match:
    print(f"Area code: {match.group(1)}")  # Output: Area code: 123
    print(f"Prefix: {match.group(2)}")    # Output: Prefix: 456
    print(f"Line number: {match.group(3)}")  # Output: Line number: 7890

C. Escaping Special Characters

• Use \ to escape special characters when you want to match them literally.

Example

text = "Price is $100."
pattern = r"\$100"

if re.search(pattern, text):
    print("Match found!")  # Output: Match found!

4. Practical Exercises

Exercise 1: Validate Email Addresses

Write a program to validate if an email address is in the format [email protected].

Solution:

import re

email = "[email protected]"
pattern = r"^\w+@\w+\.\w+$"

if re.match(pattern, email):
    print("Valid email.")  # Output: Valid email.
else:
    print("Invalid email.")

Exercise 2: Extract Phone Numbers

Write a program to extract phone numbers in the format (XXX) XXX-XXXX from a string.

Solution:

text = "Contact me at (123) 456-7890 or (987) 654-3210."
pattern = r"\(\d{3}\)\s\d{3}-\d{4}"

matches = re.findall(pattern, text)
print(matches)  # Output: ['(123) 456-7890', '(987) 654-3210']

Exercise 3: Replace Dates

Replace all dates in the format YYYY-MM-DD with MM/DD/YYYY.

Solution:

text = "Today's date is 2024-11-28."
pattern = r"(\d{4})-(\d{2})-(\d{2})"

result = re.sub(pattern, r"\2/\3/\1", text)
print(result)  # Output: Today's date is 11/28/2024.

Exercise 4: Extract Words

Extract all words that start with a capital letter from a string.

Solution:

text = "Alice and Bob are going to New York."
pattern = r"\b[A-Z][a-z]*\b"

matches = re.findall(pattern, text)
print(matches)  # Output: ['Alice', 'Bob', 'New', 'York']

5. Summary

Key Takeaways:

1. Using the re Module:
   • Import the module with import re.
   • Use functions like search(), match(), findall(), and sub() for regex operations.
2. Searching and Matching:
   • search() finds the first occurrence of a pattern.
   • match() checks if the pattern matches the start of the string.
3. Replacing and Extracting:
   • Use sub() to replace patterns and groups to extract specific parts of matches.
4. Regular Expressions:
   • Use regex syntax (\d, \w, ^, $, etc.) to create powerful patterns.

Module 11: Data Analysis

Objective: Understand the foundational tools for data analysis in Python, focusing on the use of pandas for handling data structures and matplotlib for visualizing data. This module covers working with DataFrames, reading/writing files, data cleaning, and creating basic plots.

1. Introduction to pandas

A. What is pandas?

• pandas is a Python library for data manipulation and analysis.
• It provides two primary data structures:
  1. Series: One-dimensional labeled arrays (similar to a list or array).
  2. DataFrame: Two-dimensional labeled tables (like a spreadsheet).

Importing pandas

import pandas as pd

B. Series and DataFrames

1. Series

A Series is a one-dimensional labeled array.

Example:

import pandas as pd

data = [10, 20, 30, 40]
series = pd.Series(data, index=["a", "b", "c", "d"])
print(series)

Output:

a    10
b    20
c    30
d    40
dtype: int64

2. DataFrame

A DataFrame is a two-dimensional table.

Example:

data = {
    "Name": ["Alice", "Bob", "Charlie"],
    "Age": [25, 30, 35],
    "City": ["New York", "Los Angeles", "Chicago"]
}

df = pd.DataFrame(data)
print(df)

Output:

      Name  Age         City
0    Alice   25    New York
1      Bob   30  Los Angeles
2  Charlie   35     Chicago

C. Reading and Writing CSV/Excel Files

1. Reading a CSV File

df = pd.read_csv("data.csv")
print(df.head())  # Display the first 5 rows

2. Writing to a CSV File

df.to_csv("output.csv", index=False)

3. Reading and Writing Excel Files

Requires the openpyxl library for Excel file support.

# Reading an Excel file
df = pd.read_excel("data.xlsx")

# Writing to an Excel file
df.to_excel("output.xlsx", index=False)

D. Data Cleaning and Manipulation

1. Handling Missing Data

• fillna(): Replace missing values.
• dropna(): Remove rows/columns with missing values.

Example:

data = {
    "Name": ["Alice", "Bob", None],
    "Age": [25, None, 35],
    "City": ["New York", "Los Angeles", "Chicago"]
}
df = pd.DataFrame(data)

df.fillna("Unknown", inplace=True)
print(df)

Output:

     Name   Age         City
0   Alice  25.0     New York
1     Bob  Unknown  Los Angeles
2  Unknown  35.0     Chicago

2. Filtering and Sorting

• Filtering:

filtered_df = df[df["Age"] > 30]
print(filtered_df)

• Sorting:

sorted_df = df.sort_values(by="Age", ascending=False)
print(sorted_df)

3. Adding/Removing Columns

• Adding:

df["Country"] = ["USA", "USA", "USA"]

• Removing:

df.drop(columns=["Country"], inplace=True)

2. Basic Visualization with matplotlib

A. What is matplotlib?

• matplotlib is a Python library for creating static, interactive, and animated visualizations.

Importing matplotlib

import matplotlib.pyplot as plt

B. Creating Basic Plots

1. Line Plot

x = [1, 2, 3, 4]
y = [10, 20, 30, 40]

plt.plot(x, y, marker="o")
plt.title("Line Plot")
plt.xlabel("X-axis")
plt.ylabel("Y-axis")
plt.show()

2. Bar Plot

categories = ["A", "B", "C"]
values = [10, 15, 7]

plt.bar(categories, values, color="skyblue")
plt.title("Bar Plot")
plt.xlabel("Categories")
plt.ylabel("Values")
plt.show()

3. Scatter Plot

x = [5, 7, 8, 7, 2, 17, 2, 9, 4, 11]
y = [99, 86, 87, 88, 100, 86, 103, 87, 94, 78]

plt.scatter(x, y, color="green")
plt.title("Scatter Plot")
plt.xlabel("X-axis")
plt.ylabel("Y-axis")
plt.show()

C. Combining pandas and matplotlib

You can use pandas directly for plotting.

Example

data = {
    "Year": [2018, 2019, 2020, 2021],
    "Sales": [100, 200, 300, 400]
}
df = pd.DataFrame(data)

df.plot(x="Year", y="Sales", kind="line", marker="o", title="Sales Over Years")
plt.show()

3. Practical Exercises

Exercise 1: Reading a CSV File

Write a program to read a CSV file containing student data, filter students with scores greater than 80, and save the filtered data to a new file.

Solution:

import pandas as pd

# Reading the CSV file
df = pd.read_csv("students.csv")

# Filtering
filtered_df = df[df["Score"] > 80]

# Saving to a new file
filtered_df.to_csv("filtered_students.csv", index=False)

Exercise 2: Plot Sales Data

Write a program to create a bar plot of product sales.

Solution:

import matplotlib.pyplot as plt

products = ["Product A", "Product B", "Product C"]
sales = [150, 200, 100]

plt.bar(products, sales, color="orange")
plt.title("Product Sales")
plt.xlabel("Products")
plt.ylabel("Sales")
plt.show()

Exercise 3: Data Cleaning

Write a program to replace missing values in a DataFrame with the mean of the column.

Solution:

import pandas as pd
import numpy as np

data = {
    "Name": ["Alice", "Bob", "Charlie"],
    "Age": [25, np.nan, 35],
    "Score": [85, 90, np.nan]
}
df = pd.DataFrame(data)

# Fill missing values with column mean
df["Age"].fillna(df["Age"].mean(), inplace=True)
df["Score"].fillna(df["Score"].mean(), inplace=True)

print(df)

Exercise 4: Plot with pandas

Write a program to read a CSV file containing sales data and plot a line chart of monthly sales.

Solution:

import pandas as pd
import matplotlib.pyplot as plt

# Reading data
df = pd.read_csv("sales.csv")

# Plotting
df.plot(x="Month", y="Sales", kind="line", marker="o", title="Monthly Sales")
plt.show()

4. Summary

Key Takeaways:

1. pandas:
   • Series and DataFrame are the primary data structures.
   • Use read_csv() and to_csv() for file I/O.
   • Data cleaning tools include fillna() and dropna().
2. matplotlib:
   • Use plot(), bar(), and scatter() for creating basic visualizations.
   • Combine pandas and matplotlib for seamless plotting.
3. Integration:
   • pandas simplifies data manipulation, while matplotlib provides visualization tools for insights.

Module 12: Web Scraping

Objective: Learn the essential tools and techniques for extracting data from websites using Python. This module covers fetching web data with requests, parsing HTML with BeautifulSoup, and handling dynamic content with selenium.

1. Fetching Web Data Using requests

A. What is requests?

• The requests library allows you to send HTTP requests to websites and retrieve their content.

Installing requests

pip install requests

B. Sending HTTP Requests

Use requests.get() to fetch web page content.

Example

import requests

url = "https://example.com"
response = requests.get(url)

if response.status_code == 200:  # Check if the request was successful
    print(response.text)  # Prints the HTML content of the page
else:
    print(f"Failed to fetch page. Status code: {response.status_code}")

C. Handling Common Issues

1. Timeouts:

   response = requests.get(url, timeout=5)  # Waits up to 5 seconds
   

2. Headers: Many websites block requests without a user-agent header.

   headers = {"User-Agent": "Mozilla/5.0"}
   response = requests.get(url, headers=headers)
   

2. Parsing HTML with BeautifulSoup

A. What is BeautifulSoup?

• BeautifulSoup is a library for parsing and navigating HTML and XML documents.

Installing BeautifulSoup

pip install beautifulsoup4

B. Creating a BeautifulSoup Object

from bs4 import BeautifulSoup

html_content = response.text  # Get HTML content using requests
soup = BeautifulSoup(html_content, "html.parser")

C. Navigating the HTML Tree

1. Find Elements by Tag:

   title = soup.title  # Finds the <title> tag
   print(title.text)   # Extracts text from the <title> tag
   

2. Find Elements by Class:

   paragraphs = soup.find_all("p", class_="intro")  # Finds all <p> tags with class="intro"
   for p in paragraphs:
       print(p.text)
   

3. Find Elements by ID:

   div = soup.find("div", id="main")  # Finds a <div> with id="main"
   print(div.text)
   

D. Extracting Links and Text

1. Extracting All Links:

   links = soup.find_all("a")
   for link in links:
       print(link["href"])  # Prints the href attribute of each <a> tag
   

2. Extracting Text Content:

   text = soup.get_text()  # Gets all text content on the page
   print(text)
   

E. Practical Example: Scraping a Blog

import requests
from bs4 import BeautifulSoup

url = "https://example-blog.com"
response = requests.get(url)

if response.status_code == 200:
    soup = BeautifulSoup(response.text, "html.parser")
    articles = soup.find_all("h2", class_="post-title")
    
    for article in articles:
        print(article.text)  # Print the title of each blog post

3. Handling Dynamic Websites with selenium

A. What is selenium?

• selenium automates web browsers and handles websites that require JavaScript to render content.

Installing selenium

pip install selenium

B. Setting Up Selenium

1. Install a WebDriver: Selenium requires a browser driver (e.g., ChromeDriver for Google Chrome). Download ChromeDriver.

2. Launching a Browser:

   from selenium import webdriver
   
   driver = webdriver.Chrome(executable_path="/path/to/chromedriver")
   driver.get("https://example.com")
   print(driver.title)  # Prints the page title
   

C. Interacting with Web Pages

1. Finding Elements:

   search_box = driver.find_element("name", "q")  # Finds an element by its name attribute
   search_box.send_keys("Web scraping")          # Types into the search box
   search_box.submit()                           # Submits the form
   

2. Clicking Buttons:

   button = driver.find_element("id", "search-button")
   button.click()
   

3. Extracting Content:

   elements = driver.find_elements("tag name", "h2")
   for element in elements:
       print(element.text)
   

D. Waiting for Elements to Load

Dynamic websites often require waiting for elements to load.

Example

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Wait for an element to appear
element = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.ID, "main-content"))
)
print(element.text)

E. Closing the Browser

driver.quit()  # Closes the browser

F. Practical Example: Scraping a Dynamic Website

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

driver = webdriver.Chrome(executable_path="/path/to/chromedriver")
driver.get("https://example-dynamic.com")

# Wait for an element to load and extract data
try:
    articles = WebDriverWait(driver, 10).until(
        EC.presence_of_all_elements_located((By.CLASS_NAME, "article-title"))
    )
    for article in articles:
        print(article.text)
finally:
    driver.quit()

4. Practical Exercises

Exercise 1: Fetch and Parse HTML

Write a program to fetch the HTML of a website and extract all <h1> headings.

Solution:

import requests
from bs4 import BeautifulSoup

url = "https://example.com"
response = requests.get(url)
soup = BeautifulSoup(response.text, "html.parser")

headings = soup.find_all("h1")
for heading in headings:
    print(heading.text)

Exercise 2: Extract Links

Write a program to extract all internal and external links from a webpage.

Solution:

import requests
from bs4 import BeautifulSoup

url = "https://example.com"
response = requests.get(url)
soup = BeautifulSoup(response.text, "html.parser")

links = soup.find_all("a")
for link in links:
    href = link.get("href")
    if href and href.startswith("http"):
        print(f"External link: {href}")
    elif href:
        print(f"Internal link: {href}")

Exercise 3: Scrape a Dynamic Website

Write a program to scrape titles of news articles from a dynamic website using selenium.

Solution:

from selenium import webdriver
from selenium.webdriver.common.by import By

driver = webdriver.Chrome(executable_path="/path/to/chromedriver")
driver.get("https://example-news.com")

titles = driver.find_elements(By.CLASS_NAME, "news-title")
for title in titles:
    print(title.text)

driver.quit()

5. Summary

Key Takeaways:

1. Fetching Data:
   • Use requests for fetching static web pages.
   • Use headers to handle basic restrictions.
2. Parsing HTML:
   • Use BeautifulSoup for navigating and extracting data from HTML.
3. Dynamic Websites:
   • Use selenium for JavaScript-rendered content.
   • Automate browser actions and handle dynamically loaded elements.

Module 13: Automation

Objective: Master automation of repetitive tasks using Python libraries. This module covers file and folder operations, email automation, and working with Excel files.

1. Automating File and Folder Tasks with os and shutil

A. Overview of os Module

The os module allows you to interact with the operating system, perform file and directory operations, and navigate the file system.

Common os Functions

Example: Basic Directory Operations

import os

# Get the current directory
print("Current Directory:", os.getcwd())

# Create a new directory
os.mkdir("new_folder")

# Rename the directory
os.rename("new_folder", "renamed_folder")

# List contents of the current directory
print(os.listdir("."))

# Remove the directory
os.rmdir("renamed_folder")

B. Overview of shutil Module

The shutil module provides high-level file operations, such as copying and moving files.

Common shutil Functions

Example: Copying and Moving Files

import shutil

# Copy a file
shutil.copy("source.txt", "destination.txt")

# Move a file
shutil.move("destination.txt", "new_folder/destination.txt")

# Delete a folder and its contents
shutil.rmtree("new_folder")

2. Sending Emails with smtplib

A. Overview

The smtplib module allows you to send emails using the Simple Mail Transfer Protocol (SMTP).

Installing smtplib

smtplib is part of Python’s standard library, so no installation is required.

B. Sending a Simple Email

Example

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

# Email details
sender_email = "[email protected]"
receiver_email = "[email protected]"
password = "your_password"

# Create the email
message = MIMEMultipart()
message["From"] = sender_email
message["To"] = receiver_email
message["Subject"] = "Hello from Python"

# Email body
body = "This is an automated email sent using Python."
message.attach(MIMEText(body, "plain"))

# Send the email
try:
    with smtplib.SMTP("smtp.gmail.com", 587) as server:
        server.starttls()  # Secure the connection
        server.login(sender_email, password)
        server.send_message(message)
    print("Email sent successfully!")
except Exception as e:
    print(f"Failed to send email: {e}")

C. Sending Emails with Attachments

Example

from email.mime.base import MIMEBase
from email import encoders

# Add an attachment
filename = "document.pdf"
with open(filename, "rb") as attachment:
    part = MIMEBase("application", "octet-stream")
    part.set_payload(attachment.read())
    encoders.encode_base64(part)
    part.add_header("Content-Disposition", f"attachment; filename={filename}")
    message.attach(part)

# Email sending logic remains the same as above

3. Automating Excel Tasks with openpyxl

A. Overview of openpyxl

openpyxl is a library for reading and writing Excel files (XLSX).

Installing openpyxl

pip install openpyxl

B. Reading Excel Files

Example

import openpyxl

# Load the workbook
workbook = openpyxl.load_workbook("example.xlsx")

# Select a sheet
sheet = workbook.active

# Read data from cells
print(sheet["A1"].value)  # Read cell A1
for row in sheet.iter_rows(min_row=1, max_row=5, max_col=3, values_only=True):
    print(row)  # Print first 5 rows

C. Writing to Excel Files

Example

# Create a workbook
workbook = openpyxl.Workbook()

# Select the active sheet
sheet = workbook.active

# Write data
sheet["A1"] = "Name"
sheet["B1"] = "Age"
sheet.append(["Alice", 25])
sheet.append(["Bob", 30])

# Save the workbook
workbook.save("new_file.xlsx")

D. Formatting Excel Cells

Example

from openpyxl.styles import Font, PatternFill

# Apply font and color
sheet["A1"].font = Font(bold=True, color="FFFFFF")
sheet["A1"].fill = PatternFill(start_color="0000FF", end_color="0000FF", fill_type="solid")

# Save changes
workbook.save("formatted_file.xlsx")

4. Practical Exercises

Exercise 1: Organize Files in a Folder

Write a script to sort files in a folder into subfolders based on their extensions.

Solution:

import os
import shutil

source_folder = "downloads"
for file in os.listdir(source_folder):
    extension = file.split(".")[-1]
    folder = os.path.join(source_folder, extension)
    os.makedirs(folder, exist_ok=True)
    shutil.move(os.path.join(source_folder, file), os.path.join(folder, file))

Exercise 2: Send a Daily Report Email

Write a script to send a daily report email with an Excel file as an attachment.

Solution:

# Use the email sending logic and include the attachment code shown above.
filename = "daily_report.xlsx"
message.attach(part)

Exercise 3: Automate Excel Calculations

Write a script to calculate the total sales in an Excel file and save the result in a new column.

Solution:

import openpyxl

# Load the workbook
workbook = openpyxl.load_workbook("sales.xlsx")
sheet = workbook.active

# Add a Total column
sheet["D1"] = "Total"
for row in range(2, sheet.max_row + 1):
    total = sheet[f"B{row}"].value * sheet[f"C{row}"].value
    sheet[f"D{row}"] = total

# Save the workbook
workbook.save("sales_with_total.xlsx")

5. Summary

Key Takeaways:

1. File Automation:
   • Use os for file and folder management.
   • Use shutil for copying, moving, and deleting files and directories.
2. Email Automation:
   • Automate email sending with smtplib.
   • Add attachments using MIMEBase.
3. Excel Automation:
   • Read, write, and format Excel files with openpyxl.

Module 14: Introduction to Flask

Objective: Learn the basics of Flask, a lightweight Python web framework. This module covers setting up a Flask project, creating routes and views, handling forms and templates, and building a simple Flask app (a To-Do List).

1. Setting up a Flask Project

A. Installing Flask

Flask can be installed using pip.

pip install flask

B. Creating a Flask Project

1. Create a project folder and navigate to it:

   mkdir flask_project
   cd flask_project
   

2. Create a file named app.py for the main Flask application.

3. Run the Flask app:

   flask run
   

   By default, the app runs on http://127.0.0.1:5000.

C. Writing Your First Flask App

Code Example

from flask import Flask

app = Flask(__name__)

@app.route("/")  # Define the route for the homepage
def home():
    return "Welcome to Flask!"

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

2. Creating Routes and Views

A. What are Routes?

Routes define the URL paths of your web application and map them to specific functions (views).

Example: Defining Routes

@app.route("/about")
def about():
    return "This is the About page."

B. Dynamic Routes

You can use variables in routes by enclosing them in angle brackets (< >).

Example

@app.route("/user/<username>")
def user_profile(username):
    return f"Welcome, {username}!"

URL: http://127.0.0.1:5000/user/John
Output: Welcome, John!

C. HTTP Methods

Routes can handle different HTTP methods (GET, POST).

Example

@app.route("/submit", methods=["GET", "POST"])
def submit():
    if request.method == "POST":
        return "Form submitted!"
    return "Submit your form."

3. Handling Forms and Templates

A. Templates

Flask uses Jinja2 as its template engine. Templates are HTML files stored in a templates folder.

Example: Creating a Template

1. Create a templates folder and a file templates/home.html:

   <!DOCTYPE html>
   <html>
   <head>
       <title>Flask App</title>
   </head>
   <body>
       <h1>Welcome to {{ name }}!</h1>
   </body>
   </html>
   

2. Render the template in your Flask app:

   from flask import render_template
   
   @app.route("/")
   def home():
       return render_template("home.html", name="Flask")
   

B. Handling Forms

1. Create a form in templates/form.html:

   <!DOCTYPE html>
   <html>
   <body>
       <form action="/submit" method="POST">
           <label for="name">Name:</label>
           <input type="text" id="name" name="name">
           <button type="submit">Submit</button>
       </form>
   </body>
   </html>
   

2. Handle form data in your Flask app:

   from flask import request
   
   @app.route("/submit", methods=["POST"])
   def submit():
       name = request.form["name"]
       return f"Hello, {name}!"
   

4. Building a Simple Flask App (To-Do List)

A. Overview

In this section, we’ll build a simple To-Do List app where users can:

1. View tasks.
2. Add new tasks.
3. Delete tasks.

B. File Structure

flask_project/
|-- app.py
|-- templates/
    |-- index.html
    |-- add_task.html

C. Code Implementation

1. Flask Application (app.py)

from flask import Flask, render_template, request, redirect, url_for

app = Flask(__name__)

# Store tasks in a list
tasks = []

@app.route("/")
def index():
    return render_template("index.html", tasks=tasks)

@app.route("/add", methods=["GET", "POST"])
def add_task():
    if request.method == "POST":
        task = request.form["task"]
        tasks.append(task)
        return redirect(url_for("index"))
    return render_template("add_task.html")

@app.route("/delete/<int:task_id>")
def delete_task(task_id):
    if 0 <= task_id < len(tasks):
        tasks.pop(task_id)
    return redirect(url_for("index"))

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

2. Template: Home Page (templates/index.html)

<!DOCTYPE html>
<html>
<head>
    <title>To-Do List</title>
</head>
<body>
    <h1>To-Do List</h1>
    <ul>
        {% for task in tasks %}
        <li>{{ task }} <a href="/delete/{{ loop.index0 }}">Delete</a></li>
        {% endfor %}
    </ul>
    <a href="/add">Add Task</a>
</body>
</html>

3. Template: Add Task Page (templates/add_task.html)

<!DOCTYPE html>
<html>
<head>
    <title>Add Task</title>
</head>
<body>
    <h1>Add a New Task</h1>
    <form action="/add" method="POST">
        <label for="task">Task:</label>
        <input type="text" id="task" name="task" required>
        <button type="submit">Add</button>
    </form>
    <a href="/">Back to To-Do List</a>
</body>
</html>

D. Running the App

1. Save the code in app.py.
2. Run the Flask app:

   flask run
   

3. Open http://127.0.0.1:5000 in your browser to interact with the To-Do List app.

5. Practical Exercises

Exercise 1: Add Edit Functionality

Extend the To-Do List app to allow users to edit tasks.

Exercise 2: Save Tasks to a File

Modify the app to save tasks to a file and load them when the app starts.

Exercise 3: Add Task Deadlines

Allow users to add deadlines for tasks and display them.

6. Summary

Key Takeaways:

1. Setting up Flask:
   • Install Flask using pip and create routes with @app.route.
2. Templates:
   • Use Jinja2 templates for rendering dynamic HTML.
3. Forms:
   • Handle form submissions with request.form and process POST data.
4. Building a Simple App:
   • Combine Flask concepts to build functional applications like a To-Do List.

Module 15: Introduction to Django

Objective: Learn the fundamentals of Django, a high-level Python web framework. This module covers setting up a Django project, understanding the Models-Views-Templates (MVT) pattern, and building a simple Django app (e.g., a Blog).

1. Setting Up a Django Project

A. Installing Django

Install Django using pip:

pip install django

B. Creating a Django Project

1. Create a new Django project:

   django-admin startproject myproject
   cd myproject
   

2. Run the development server:

   python manage.py runserver
   

3. Open your browser and navigate to http://127.0.0.1:8000 to see the default Django welcome page.

C. Creating a Django App

An app is a specific module within a Django project that focuses on a particular functionality.

1. Create a new app:

   python manage.py startapp blog
   

2. Register the app in the project’s settings file (myproject/settings.py):

   INSTALLED_APPS = [
       ...
       'blog',
   ]
   

2. Understanding the MVT Pattern

A. Overview of the MVT Pattern

Django follows the Models-Views-Templates (MVT) architecture:

1. Model: Represents the database structure.
2. View: Contains the business logic and processes user requests.
3. Template: Defines the presentation layer (HTML).

B. Example Workflow

1. User sends a request (e.g., /posts).
2. Django’s URL dispatcher maps the request to a view function.
3. The view interacts with the model (database) to fetch data.
4. The view passes the data to a template.
5. The template renders the data as an HTML response to the user.

3. Building a Simple Django Blog App

A. Defining Models

Models define the structure of the database.

1. Open blog/models.py and define the Post model:

   from django.db import models
   
   class Post(models.Model):
       title = models.CharField(max_length=100)
       content = models.TextField()
       created_at = models.DateTimeField(auto_now_add=True)
   
       def __str__(self):
           return self.title
   

2. Create and apply migrations to update the database schema:

   python manage.py makemigrations
   python manage.py migrate
   

B. Creating Views

Views handle user requests and return responses.

1. Open blog/views.py and define a view to list all posts:

   from django.shortcuts import render
   from .models import Post
   
   def post_list(request):
       posts = Post.objects.all()
       return render(request, 'blog/post_list.html', {'posts': posts})
   

C. Configuring URLs

URLs map user requests to specific views.

1. Create a new file blog/urls.py:

   from django.urls import path
   from . import views
   
   urlpatterns = [
       path('', views.post_list, name='post_list'),
   ]
   

2. Include the app’s URLs in the project’s urls.py:

   from django.contrib import admin
   from django.urls import path, include
   
   urlpatterns = [
       path('admin/', admin.site.urls),
       path('blog/', include('blog.urls')),
   ]
   

D. Creating Templates

Templates define the presentation layer.

1. Create a folder blog/templates/blog/ and add a file post_list.html:

   <!DOCTYPE html>
   <html>
   <head>
       <title>Blog</title>
   </head>
   <body>
       <h1>Blog Posts</h1>
       <ul>
           {% for post in posts %}
           <li>
               <h2>{{ post.title }}</h2>
               <p>{{ post.content }}</p>
               <small>Posted on {{ post.created_at }}</small>
           </li>
           {% endfor %}
       </ul>
   </body>
   </html>
   

2. Run the development server and navigate to http://127.0.0.1:8000/blog/ to see the list of posts.

E. Adding the Admin Interface

Django provides an admin interface for managing data.

1. Create a superuser:

   python manage.py createsuperuser
   

2. Register the Post model in blog/admin.py:

   from django.contrib import admin
   from .models import Post
   
   admin.site.register(Post)
   

3. Access the admin panel at http://127.0.0.1:8000/admin/ to add, edit, or delete posts.

4. Practical Exercises

Exercise 1: Add a Detail View

Create a view to display the details of a single blog post.

1. Update blog/urls.py:

   urlpatterns = [
       path('', views.post_list, name='post_list'),
       path('<int:id>/', views.post_detail, name='post_detail'),
   ]
   

2. Update blog/views.py:

   def post_detail(request, id):
       post = Post.objects.get(id=id)
       return render(request, 'blog/post_detail.html', {'post': post})
   

3. Create blog/templates/blog/post_detail.html:

   <!DOCTYPE html>
   <html>
   <head>
       <title>{{ post.title }}</title>
   </head>
   <body>
       <h1>{{ post.title }}</h1>
       <p>{{ post.content }}</p>
       <small>Posted on {{ post.created_at }}</small>
       <a href="{% url 'post_list' %}">Back to all posts</a>
   </body>
   </html>
   

Exercise 2: Add a Create Post Form

1. Add a view to handle post creation in blog/views.py:

   from django.shortcuts import redirect
   
   def create_post(request):
       if request.method == "POST":
           title = request.POST['title']
           content = request.POST['content']
           Post.objects.create(title=title, content=content)
           return redirect('post_list')
       return render(request, 'blog/create_post.html')
   

2. Add a URL in blog/urls.py:

   path('create/', views.create_post, name='create_post'),
   

3. Create blog/templates/blog/create_post.html:

   <!DOCTYPE html>
   <html>
   <head>
       <title>Create Post</title>
   </head>
   <body>
       <h1>Create a New Post</h1>
       <form method="POST">
           {% csrf_token %}
           <label for="title">Title:</label>
           <input type="text" name="title" required><br>
           <label for="content">Content:</label>
           <textarea name="content" required></textarea><br>
           <button type="submit">Create Post</button>
       </form>
       <a href="{% url 'post_list' %}">Back to all posts</a>
   </body>
   </html>
   

5. Summary

Key Takeaways:

1. Setting Up Django:
   • Install Django, create a project, and run the development server.
2. MVT Pattern:
   • Models handle the database, views handle the logic, and templates handle the presentation.
3. Building a Blog App:
   • Define models, create views, configure URLs, and use templates for a simple blog application.
4. Admin Interface:
   • Use Django’s admin panel to manage your app’s data.

Module 16: Working with APIs

Objective: Learn how to interact with APIs using Python and create your own APIs. This module covers consuming APIs with Python’s requests library, working with JSON data, and building APIs using Flask or Django REST Framework (DRF).

1. Introduction to REST APIs

A. What is an API?

• API (Application Programming Interface) allows applications to communicate with each other.
• A REST API (Representational State Transfer API) uses standard HTTP methods (GET, POST, PUT, DELETE) to perform actions.

B. Common HTTP Methods

C. JSON Format

• APIs often use JSON (JavaScript Object Notation) to transfer data.
• Example JSON:

{
    "name": "John Doe",
    "age": 30,
    "skills": ["Python", "Flask", "Django"]
}

2. Consuming APIs with requests

A. Making a GET Request

Example

import requests

url = "https://jsonplaceholder.typicode.com/posts"
response = requests.get(url)

if response.status_code == 200:
    print(response.json())  # Parse the JSON response
else:
    print(f"Failed to fetch data. Status code: {response.status_code}")

B. Making a POST Request

Example

url = "https://jsonplaceholder.typicode.com/posts"
data = {
    "title": "My First Post",
    "body": "This is the body of the post",
    "userId": 1
}

response = requests.post(url, json=data)

if response.status_code == 201:  # 201 Created
    print("Post created:", response.json())
else:
    print(f"Failed to create post. Status code: {response.status_code}")

C. Parsing JSON Data

Example

url = "https://jsonplaceholder.typicode.com/users"
response = requests.get(url)

if response.status_code == 200:
    users = response.json()
    for user in users:
        print(f"Name: {user['name']}, Email: {user['email']}")

3. Sending API Requests and Parsing JSON

A. Sending Headers

Some APIs require authentication using headers.

Example

url = "https://api.example.com/data"
headers = {"Authorization": "Bearer YOUR_API_KEY"}

response = requests.get(url, headers=headers)
if response.status_code == 200:
    print(response.json())

B. Handling Query Parameters

Example

url = "https://jsonplaceholder.typicode.com/comments"
params = {"postId": 1}  # Query parameter

response = requests.get(url, params=params)

if response.status_code == 200:
    print(response.json())  # Prints comments for post ID 1

4. Building APIs with Flask

A. Setting Up a Flask API

1. Install Flask:

   pip install flask
   

2. Create a simple API in app.py:

   from flask import Flask, jsonify, request
   
   app = Flask(__name__)
   
   # Sample data
   posts = [
       {"id": 1, "title": "First Post", "content": "Hello, world!"},
       {"id": 2, "title": "Second Post", "content": "Flask is awesome!"}
   ]
   
   @app.route("/posts", methods=["GET"])
   def get_posts():
       return jsonify(posts)
   
   @app.route("/posts", methods=["POST"])
   def create_post():
       data = request.json
       new_post = {
           "id": len(posts) + 1,
           "title": data["title"],
           "content": data["content"]
       }
       posts.append(new_post)
       return jsonify(new_post), 201
   
   if __name__ == "__main__":
       app.run(debug=True)
   

3. Run the Flask server:

   python app.py
   

4. Test the API:

   • GET: http://127.0.0.1:5000/posts
   • POST: Use a tool like Postman to send a POST request with JSON data.

5. Building APIs with Django REST Framework (DRF)

A. Setting Up DRF

1. Install Django and DRF:

   pip install django djangorestframework
   

2. Create a Django project and app:

   django-admin startproject myproject
   cd myproject
   python manage.py startapp api
   

3. Add rest_framework and api to INSTALLED_APPS in myproject/settings.py.

B. Creating a Model

1. Define a Post model in api/models.py:

   from django.db import models
   
   class Post(models.Model):
       title = models.CharField(max_length=100)
       content = models.TextField()
   

2. Apply migrations:

   python manage.py makemigrations
   python manage.py migrate
   

C. Creating a Serializer

Serializers convert model instances into JSON format.

1. Create a serializer in api/serializers.py:

   from rest_framework import serializers
   from .models import Post
   
   class PostSerializer(serializers.ModelSerializer):
       class Meta:
           model = Post
           fields = '__all__'
   

D. Creating API Views

1. Define API views in api/views.py:

   from rest_framework.response import Response
   from rest_framework.decorators import api_view
   from .models import Post
   from .serializers import PostSerializer
   
   @api_view(["GET"])
   def get_posts(request):
       posts = Post.objects.all()
       serializer = PostSerializer(posts, many=True)
       return Response(serializer.data)
   
   @api_view(["POST"])
   def create_post(request):
       serializer = PostSerializer(data=request.data)
       if serializer.is_valid():
           serializer.save()
           return Response(serializer.data, status=201)
       return Response(serializer.errors, status=400)
   

E. Configuring URLs

1. Create api/urls.py:

   from django.urls import path
   from . import views
   
   urlpatterns = [
       path("posts/", views.get_posts, name="get_posts"),
       path("posts/create/", views.create_post, name="create_post"),
   ]
   

2. Include the app’s URLs in myproject/urls.py:

   from django.urls import path, include
   
   urlpatterns = [
       path("api/", include("api.urls")),
   ]
   

F. Testing the API

1. Start the server:

   python manage.py runserver
   

2. Test the API:

   • GET: http://127.0.0.1:8000/api/posts/
   • POST: Use Postman or a Python script to send POST requests.

6. Practical Exercises

Exercise 1: Build a Weather App

• Use a public API like OpenWeatherMap to fetch weather data based on user input.

Exercise 2: Build a CRUD API

• Create a full CRUD API (Create, Read, Update, Delete) for managing tasks.

Exercise 3: Create a Custom API

• Build a custom API in Flask or Django REST Framework that serves specific data (e.g., a product catalog).

7. Summary

Key Takeaways:

1. REST APIs:
   • Use HTTP methods (GET, POST, etc.) for CRUD operations.
   • Data is often exchanged in JSON format.
2. Consuming APIs:
   • Use requests to fetch, send, and process API data.
3. Building APIs:
   • Use Flask for lightweight APIs.
   • Use Django REST Framework for robust, scalable APIs.

Module 17: Testing in Python

Objective: Learn how to write reliable and efficient tests for Python applications using the unittest framework, understand the role of mocking in testing, and measure test coverage to ensure comprehensive testing.

1. Writing Unit Tests with unittest

A. What is unittest?

• unittest is Python’s built-in testing framework.
• It provides tools for organizing and automating tests.

B. Basic Structure of a Unit Test

1. Import unittest.
2. Create a test class that inherits from unittest.TestCase.
3. Define test methods (method names must start with test_).
4. Use assertions to validate behavior.

Example

import unittest

# Function to test
def add(a, b):
    return a + b

# Test class
class TestMathOperations(unittest.TestCase):

    def test_add(self):
        self.assertEqual(add(2, 3), 5)  # Test for correct result
        self.assertEqual(add(-1, 1), 0)

    def test_add_negative(self):
        self.assertLess(add(-3, -2), 0)  # Result should be negative

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

C. Common Assertions

Example

def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

class TestDivide(unittest.TestCase):
    def test_divide_by_zero(self):
        with self.assertRaises(ValueError):
            divide(5, 0)

D. Running Tests

1. Save your test file (e.g., test_math.py).
2. Run the tests:

   python -m unittest test_math.py
   

2. Mocking in Tests

A. What is Mocking?

• Mocking is a way to replace parts of your system under test with mock objects.
• Mock objects simulate the behavior of real objects.

B. Using unittest.mock

1. Import mock from unittest.
2. Replace real objects (e.g., functions, APIs) with mocks.

Example: Mocking a Function

from unittest.mock import MagicMock

# Function to test
def fetch_data(api_client):
    return api_client.get_data()

# Test
class TestFetchData(unittest.TestCase):
    def test_fetch_data(self):
        mock_client = MagicMock()
        mock_client.get_data.return_value = {"key": "value"}  # Mocked response

        result = fetch_data(mock_client)
        self.assertEqual(result, {"key": "value"})

C. Mocking External APIs

Example

from unittest.mock import patch

# Function to test
def get_user_name(user_id):
    import requests
    response = requests.get(f"https://api.example.com/users/{user_id}")
    return response.json()["name"]

# Test
class TestGetUserName(unittest.TestCase):
    @patch("requests.get")
    def test_get_user_name(self, mock_get):
        mock_get.return_value.json.return_value = {"name": "John Doe"}
        name = get_user_name(1)
        self.assertEqual(name, "John Doe")

D. Mocking Objects

• Mock classes and their methods to isolate functionality.

Example: Mocking a Database Connection

class Database:
    def connect(self):
        return "Connected to database"

class TestDatabase(unittest.TestCase):
    @patch("__main__.Database.connect")
    def test_connect(self, mock_connect):
        mock_connect.return_value = "Mocked Connection"
        db = Database()
        self.assertEqual(db.connect(), "Mocked Connection")

3. Test Coverage Tools

A. What is Test Coverage?

• Test coverage measures the percentage of your codebase tested by unit tests.
• Tools like coverage.py help identify untested code.

B. Installing coverage

Install coverage:

pip install coverage

C. Measuring Test Coverage

1. Run your tests with coverage:

   coverage run -m unittest test_math.py
   

2. Generate a coverage report:

   coverage report
   

3. Generate an HTML report:

   coverage html
   

   Open the htmlcov/index.html file in your browser to view the detailed coverage report.

D. Ignoring Lines in Coverage

• Use # pragma: no cover to exclude lines from coverage.

Example

def divide(a, b):
    if b == 0:  # pragma: no cover
        raise ValueError("Cannot divide by zero")
    return a / b

4. Practical Exercises

Exercise 1: Write Unit Tests for a Calculator

Write tests for a calculator app with functions like add, subtract, multiply, and divide.

Exercise 2: Mock API Responses

Write tests for a function that fetches weather data from an external API. Mock the API to simulate different responses.

Exercise 3: Measure Test Coverage

1. Write unit tests for a simple app.
2. Measure test coverage using coverage.py.
3. Identify untested lines and write additional tests.

5. Summary

Key Takeaways:

1. Unit Testing:
   • Use unittest to write and organize tests.
   • Leverage assertions to validate expected outcomes.
2. Mocking:
   • Use unittest.mock to simulate real objects and external APIs.
   • Patch methods and classes to isolate functionality during testing.
3. Test Coverage:
   • Measure test coverage with coverage.py.
   • Use coverage reports to identify untested parts of the codebase.

Module 18: Data Visualization

Objective: Learn how to create advanced visualizations with Python using libraries like Seaborn and Plotly, and build interactive dashboards for data-driven storytelling.

1. Advanced Visualizations with Seaborn

A. What is Seaborn?

• Seaborn is a Python library built on top of Matplotlib, designed for statistical data visualization.
• It provides an interface for creating aesthetically pleasing and complex visualizations with minimal code.

B. Installing Seaborn

pip install seaborn

C. Creating Advanced Visualizations

1. Pair Plot

Displays pairwise relationships between features in a dataset.

Example:

import seaborn as sns
import matplotlib.pyplot as plt

# Load sample dataset
iris = sns.load_dataset("iris")

# Create a pair plot
sns.pairplot(iris, hue="species")
plt.show()

2. Heatmaps

Used to display the correlation matrix of numerical data.

Example:

import seaborn as sns
import matplotlib.pyplot as plt

# Load dataset
flights = sns.load_dataset("flights")
pivot_table = flights.pivot("month", "year", "passengers")

# Create heatmap
sns.heatmap(pivot_table, annot=True, fmt="d", cmap="coolwarm")
plt.title("Flights Heatmap")
plt.show()

3. Violin Plots

Show the distribution of data and its probability density.

Example:

sns.violinplot(x="species", y="sepal_length", data=iris, palette="muted")
plt.title("Violin Plot of Sepal Length by Species")
plt.show()

4. Regression Plots

Display linear relationships between variables.

Example:

sns.lmplot(x="sepal_length", y="petal_length", hue="species", data=iris)
plt.title("Regression Plot")
plt.show()

2. Advanced Visualizations with Plotly

A. What is Plotly?

• Plotly is a Python library for creating interactive, web-based visualizations.
• It supports a variety of charts including 3D plots, maps, and dashboards.

B. Installing Plotly

pip install plotly

C. Creating Interactive Visualizations

1. Line Chart

Example:

import plotly.graph_objects as go

# Create a line chart
fig = go.Figure(data=go.Scatter(x=[1, 2, 3, 4], y=[10, 20, 30, 40], mode="lines+markers"))
fig.update_layout(title="Line Chart Example", xaxis_title="X-axis", yaxis_title="Y-axis")
fig.show()

2. Bar Chart

Example:

import plotly.express as px

# Create bar chart
data = {"Fruit": ["Apples", "Bananas", "Cherries"], "Quantity": [10, 15, 7]}
fig = px.bar(data, x="Fruit", y="Quantity", title="Bar Chart Example")
fig.show()

3. 3D Scatter Plot

Example:

import plotly.express as px
import pandas as pd

# Create random 3D data
df = pd.DataFrame({
    "x": [1, 2, 3, 4],
    "y": [10, 20, 30, 40],
    "z": [5, 15, 25, 35],
    "label": ["A", "B", "C", "D"]
})

# Create 3D scatter plot
fig = px.scatter_3d(df, x="x", y="y", z="z", color="label", title="3D Scatter Plot Example")
fig.show()

4. Interactive Heatmap

Example:

import plotly.express as px
import numpy as np

# Generate random data
data = np.random.rand(10, 10)

# Create heatmap
fig = px.imshow(data, color_continuous_scale="Viridis", title="Interactive Heatmap Example")
fig.show()

3. Creating Interactive Dashboards

A. Using Plotly Dash

Dash is a Python framework for building interactive web applications and dashboards.

B. Installing Dash

pip install dash

C. Basic Dashboard with Dash

1. Create a file app.py:

   import dash
   from dash import dcc, html
   import plotly.express as px
   import pandas as pd
   
   # Create a Dash app
   app = dash.Dash(__name__)
   
   # Sample dataset
   df = px.data.gapminder()
   
   # Dropdown options
   options = [{"label": year, "value": year} for year in df["year"].unique()]
   
   # Layout
   app.layout = html.Div([
       html.H1("Interactive Dashboard Example"),
       dcc.Dropdown(id="year-dropdown", options=options, value=1952),
       dcc.Graph(id="scatter-plot")
   ])
   
   # Callback for interactivity
   @app.callback(
       dash.dependencies.Output("scatter-plot", "figure"),
       [dash.dependencies.Input("year-dropdown", "value")]
   )
   def update_scatter(selected_year):
       filtered_df = df[df["year"] == selected_year]
       fig = px.scatter(filtered_df, x="gdpPercap", y="lifeExp", size="pop", color="continent",
                        hover_name="country", title=f"Year: {selected_year}")
       return fig
   
   if __name__ == "__main__":
       app.run_server(debug=True)
   

2. Run the app:

   python app.py
   

3. Open http://127.0.0.1:8050 in your browser to view the dashboard.

D. Adding Multiple Components

Extend the dashboard with additional plots, filters, and interactivity.

Example: Line Chart

Add a line chart for GDP over time:

dcc.Graph(
    id="line-chart",
    figure=px.line(filtered_df, x="year", y="gdpPercap", title="GDP Over Time")
)

4. Practical Exercises

Exercise 1: Create a Seaborn Dashboard

• Use Seaborn to create a multi-panel grid showing distributions of variables for different categories.

Exercise 2: Build an Interactive Dashboard

• Use Dash to build a dashboard with:
  • Dropdowns for filtering data.
  • Interactive scatter and bar charts.
  • A heatmap for showing correlations.

Exercise 3: Use Real API Data

• Fetch real-time weather data from an API and visualize it with Plotly.

5. Summary

Key Takeaways:

1. Seaborn:
   • Ideal for creating static, statistically-driven plots.
   • Supports complex visualizations like pair plots and heatmaps.
2. Plotly:
   • Best for interactive, web-based visualizations.
   • Offers advanced plots like 3D scatter plots and interactive heatmaps.
3. Dash:
   • A framework for building interactive dashboards.
   • Combine components (graphs, dropdowns, sliders) for dynamic web apps.

Module 19: Machine Learning Basics

Objective: Gain foundational knowledge in machine learning using scikit-learn. Learn how to build and evaluate your first ML models for regression and classification tasks.

1. Introduction to Machine Learning

A. What is Machine Learning?

Machine learning (ML) involves training algorithms to learn patterns in data and make predictions or decisions without being explicitly programmed.

B. Types of Machine Learning

1. Supervised Learning:
   • The algorithm learns from labeled data.
   • Examples: Regression, Classification.
2. Unsupervised Learning:
   • The algorithm learns patterns from unlabeled data.
   • Examples: Clustering, Dimensionality Reduction.
3. Reinforcement Learning:
   • The algorithm learns by interacting with the environment and receiving rewards or penalties.

2. Setting Up scikit-learn

A. Installing Required Libraries

pip install scikit-learn pandas numpy matplotlib

B. Importing Key Libraries

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, mean_squared_error

3. Regression with scikit-learn

A. What is Regression?

Regression predicts a continuous value (e.g., house prices, stock prices).

B. Building a Simple Regression Model

1. Dataset: Use a sample dataset from scikit-learn.

   from sklearn.datasets import load_diabetes
   
   # Load dataset
   data = load_diabetes()
   X = data.data  # Features
   y = data.target  # Target
   

2. Splitting the Dataset:

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

3. Training a Linear Regression Model:

   from sklearn.linear_model import LinearRegression
   
   model = LinearRegression()
   model.fit(X_train, y_train)
   

4. Making Predictions:

   y_pred = model.predict(X_test)
   

5. Evaluating the Model:

   mse = mean_squared_error(y_test, y_pred)
   print(f"Mean Squared Error: {mse}")
   

C. Visualizing Regression Results

import matplotlib.pyplot as plt

plt.scatter(y_test, y_pred)
plt.xlabel("Actual")
plt.ylabel("Predicted")
plt.title("Actual vs Predicted")
plt.show()

4. Classification with scikit-learn

A. What is Classification?

Classification predicts discrete categories (e.g., spam vs. not spam, disease vs. no disease).

B. Building a Simple Classification Model

1. Dataset: Use the Iris dataset.

   from sklearn.datasets import load_iris
   
   # Load dataset
   data = load_iris()
   X = data.data  # Features
   y = data.target  # Target
   

2. Splitting the Dataset:

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

3. Training a Logistic Regression Model:

   from sklearn.linear_model import LogisticRegression
   
   model = LogisticRegression(max_iter=200)
   model.fit(X_train, y_train)
   

4. Making Predictions:

   y_pred = model.predict(X_test)
   

5. Evaluating the Model:

   accuracy = accuracy_score(y_test, y_pred)
   print(f"Accuracy: {accuracy}")
   

C. Visualizing Classification Results

from sklearn.metrics import ConfusionMatrixDisplay

ConfusionMatrixDisplay.from_estimator(model, X_test, y_test)
plt.title("Confusion Matrix")
plt.show()

5. Training, Testing, and Evaluating Models

A. Training and Testing

1. Why Split Data?

   • To prevent overfitting and ensure the model generalizes to new data.
   • Use train_test_split to divide data into training and testing sets.

2. Example:

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

B. Cross-Validation

1. What is Cross-Validation?

   • A technique to evaluate a model’s performance by splitting the data into k subsets and training/testing the model on different combinations.

2. Example:

   from sklearn.model_selection import cross_val_score
   
   scores = cross_val_score(model, X, y, cv=5)
   print(f"Cross-Validation Scores: {scores}")
   print(f"Mean Score: {scores.mean()}")
   

C. Hyperparameter Tuning

1. Grid Search:

   from sklearn.model_selection import GridSearchCV
   
   param_grid = {'C': [0.1, 1, 10], 'solver': ['liblinear']}
   grid_search = GridSearchCV(LogisticRegression(), param_grid, cv=5)
   grid_search.fit(X_train, y_train)
   
   print(f"Best Parameters: {grid_search.best_params_}")
   print(f"Best Score: {grid_search.best_score_}")
   

2. Random Search (Faster alternative):

   from sklearn.model_selection import RandomizedSearchCV
   
   random_search = RandomizedSearchCV(LogisticRegression(), param_grid, cv=5, n_iter=5)
   random_search.fit(X_train, y_train)
   
   print(f"Best Parameters: {random_search.best_params_}")
   

6. Practical Exercises

Exercise 1: Predict House Prices

• Use the Boston Housing dataset to build a regression model and predict house prices.
• Evaluate the model using RMSE (Root Mean Squared Error).

Exercise 2: Classify Emails

• Use the Email Spam dataset to build a classification model.
• Evaluate the model using accuracy and confusion matrix.

Exercise 3: Hyperparameter Tuning

• Perform hyperparameter tuning on a Support Vector Machine (SVM) classifier using GridSearchCV.

7. Summary

Key Takeaways:

1. Regression:
   • Use models like Linear Regression for predicting continuous values.
   • Evaluate using metrics like Mean Squared Error (MSE).
2. Classification:
   • Use models like Logistic Regression for predicting categories.
   • Evaluate using accuracy, confusion matrix, and cross-validation.
3. Model Evaluation:
   • Split data into training and testing sets.
   • Use cross-validation for robust evaluation.
4. Hyperparameter Tuning:
   • Use Grid Search or Random Search to optimize model performance.

Module 20: Building a Real-World Application

Objective: Develop a complete, real-world application to consolidate your knowledge. In this module, we’ll build a Data Analysis Dashboard that loads, processes, visualizes data, and provides an interactive user interface for exploring insights.

Project Overview: Data Analysis Dashboard

Objective:

Build a dashboard to analyze and visualize data interactively. The application will:

1. Load a dataset (e.g., a CSV file).
2. Perform basic data analysis (summaries, statistics).
3. Display interactive visualizations (charts, tables).

Technology Stack:

1. Backend: Flask (or Django if preferred).
2. Frontend: Plotly Dash for interactivity and visualization.
3. Data Processing: Pandas and NumPy.

1. Setting Up the Project

A. Create a Virtual Environment

python -m venv venv
source venv/bin/activate  # Linux/Mac
venv\Scripts\activate     # Windows

B. Install Required Libraries

pip install pandas numpy dash plotly flask

2. Loading and Processing Data

A. Sample Dataset

Use a public dataset (e.g., Titanic dataset, Sales data, or any dataset of your choice). For this example, let’s use a Sales Data CSV file.

Sample CSV Content:

Date,Product,Region,Sales
2023-01-01,Product A,North,100
2023-01-01,Product B,South,150
2023-01-02,Product A,North,200
2023-01-02,Product B,South,250

B. Code for Loading Data

Create a Python script (app.py) to load and process the data.

import pandas as pd

# Load the dataset
def load_data():
    data = pd.read_csv("sales_data.csv")
    return data

# Summary statistics
def get_summary(data):
    return data.describe()

3. Building the Dashboard with Dash

A. Basic Layout

Create a Dash app with components for file upload, data display, and visualizations.

Code: Basic App Layout

from dash import Dash, dcc, html, Input, Output
import plotly.express as px
import pandas as pd

# Initialize Dash app
app = Dash(__name__)
app.title = "Data Analysis Dashboard"

# Load initial dataset
data = pd.read_csv("sales_data.csv")

# App Layout
app.layout = html.Div([
    html.H1("Data Analysis Dashboard", style={"textAlign": "center"}),

    # Dropdown to filter data by product
    html.Label("Select Product:"),
    dcc.Dropdown(
        id="product-dropdown",
        options=[{"label": product, "value": product} for product in data["Product"].unique()],
        value=data["Product"].unique()[0]
    ),

    # Graph output
    dcc.Graph(id="sales-graph"),

    # Table output
    html.Label("Data Table:"),
    html.Div(id="data-table")
])

B. Adding Interactivity

Callback for Graph Updates

@app.callback(
    Output("sales-graph", "figure"),
    Input("product-dropdown", "value")
)
def update_graph(selected_product):
    filtered_data = data[data["Product"] == selected_product]
    fig = px.bar(filtered_data, x="Date", y="Sales", title=f"Sales of {selected_product} Over Time")
    return fig

Callback for Table Updates

@app.callback(
    Output("data-table", "children"),
    Input("product-dropdown", "value")
)
def update_table(selected_product):
    filtered_data = data[data["Product"] == selected_product]
    return html.Table([
        html.Tr([html.Th(col) for col in filtered_data.columns])  # Header row
    ] + [
        html.Tr([html.Td(filtered_data.iloc[i][col]) for col in filtered_data.columns]) for i in range(len(filtered_data))
    ])

C. Run the App

Add the following to run the app:

if __name__ == "__main__":
    app.run_server(debug=True)

Run the script and open http://127.0.0.1:8050 in your browser.

4. Enhancing the Dashboard

A. Add Advanced Filters

1. Filter by Region.
2. Filter by a Date Range.

Example: Date Range Filter

dcc.DatePickerRange(
    id="date-picker",
    start_date=data["Date"].min(),
    end_date=data["Date"].max()
)

B. Add More Visualizations

1. Pie Chart: Sales distribution by region.

   fig = px.pie(data, names="Region", values="Sales", title="Sales by Region")
   

2. Scatter Plot: Sales trend across regions.

   fig = px.scatter(data, x="Date", y="Sales", color="Region", title="Sales Trend by Region")
   

C. Add Download Options

Allow users to download filtered data as a CSV file.

Example:

from dash import dcc

dcc.Download(id="download-dataframe-csv"),

@app.callback(
    Output("download-dataframe-csv", "data"),
    Input("download-button", "n_clicks"),
    prevent_initial_call=True
)
def download_filtered_data(n_clicks):
    filtered_data = data[data["Product"] == selected_product]
    return dcc.send_data_frame(filtered_data.to_csv, "filtered_data.csv")

D. Deploying the Dashboard

Deploy the app to a cloud platform like Heroku or Render.

1. Install gunicorn:

   pip install gunicorn
   

2. Create a Procfile:

   web: gunicorn app:server
   

3. Deploy to Heroku:

   heroku create
   git push heroku main
   

5. Practical Exercises

Exercise 1: Enhance the Dashboard

• Add filters for multiple columns (e.g., Region, Product).
• Add a summary section with total sales, average sales, etc.

Exercise 2: Use Real-World Data

• Fetch real-time stock data using an API and visualize price trends.

Exercise 3: Build a Custom Dashboard

• Use a dataset of your choice (e.g., e-commerce, healthcare) to build a dashboard with insights.

6. Summary

Key Takeaways:

1. Data Processing:
   • Use Pandas to load and manipulate datasets.
2. Interactive Visualizations:
   • Use Plotly Dash for dynamic, web-based visualizations.
3. Dashboard Development:
   • Combine filtering, graphing, and table views for a comprehensive app.