python_mastery.py

#!/usr/bin/env python3
"""
PYTHON MASTERY: Complete Beginner-Friendly Reference
====================================================

This file contains a comprehensive guide to Python programming, covering all major
concepts from basic syntax to advanced topics. Each section includes:
- Clear explanations
- Runnable examples
- Expected outputs
- Best practices

Run this file to see all examples in action!
"""

# =============================================================================
# 1. BASIC SYNTAX, VARIABLES, AND DATA TYPES
# =============================================================================

print("=" * 60)
print("1. BASIC SYNTAX, VARIABLES, AND DATA TYPES")
print("=" * 60)

# Variables in Python are dynamically typed - no need to declare types
name = "Alice"           # String
age = 25                 # Integer
height = 5.6             # Float
is_student = True        # Boolean
nothing = None           # None type

print(f"Name: {name}, Type: {type(name)}")
print(f"Age: {age}, Type: {type(age)}")
print(f"Height: {height}, Type: {type(height)}")
print(f"Is Student: {is_student}, Type: {type(is_student)}")
print(f"Nothing: {nothing}, Type: {type(nothing)}")

# Multiple assignment
x, y, z = 1, 2, 3
print(f"x={x}, y={y}, z={z}")

# Type conversion
num_str = "42"
num_int = int(num_str)      # Convert string to integer
num_float = float(num_str)  # Convert string to float
print(f"String '{num_str}' -> int: {num_int}, float: {num_float}")

# =============================================================================
# 2. STRINGS
# =============================================================================

print("\n" + "=" * 60)
print("2. STRINGS")
print("=" * 60)

# String creation and basic operations
text = "Hello, World!"
print(f"Original: {text}")
print(f"Length: {len(text)}")
print(f"Uppercase: {text.upper()}")
print(f"Lowercase: {text.lower()}")
print(f"Replace: {text.replace('World', 'Python')}")

# String formatting (multiple ways)
name = "Bob"
age = 30

# f-strings (Python 3.6+, recommended)
message1 = f"Hello, {name}! You are {age} years old."
print(f"f-string: {message1}")

# .format() method
message2 = "Hello, {}! You are {} years old.".format(name, age)
print(f".format(): {message2}")

# % formatting (older style)
message3 = "Hello, %s! You are %d years old." % (name, age)
print(f"% formatting: {message3}")

# String slicing and indexing
text = "Python Programming"
print(f"First character: {text[0]}")
print(f"Last character: {text[-1]}")
print(f"First 6 characters: {text[:6]}")
print(f"Characters 7-11: {text[7:12]}")
print(f"Every 2nd character: {text[::2]}")

# String methods
text = "  hello world  "
print(f"Strip whitespace: '{text.strip()}'")
print(f"Split into words: {text.strip().split()}")
print(f"Join with dashes: {'-'.join(['hello', 'world'])}")

# =============================================================================
# 3. LISTS
# =============================================================================

print("\n" + "=" * 60)
print("3. LISTS")
print("=" * 60)

# Creating lists
numbers = [1, 2, 3, 4, 5]
fruits = ["apple", "banana", "cherry"]
mixed = [1, "hello", 3.14, True]

print(f"Numbers: {numbers}")
print(f"Fruits: {fruits}")
print(f"Mixed: {mixed}")

# List operations
numbers.append(6)           # Add to end
numbers.insert(0, 0)        # Insert at index
print(f"After append and insert: {numbers}")

# List slicing (same as strings)
print(f"First 3: {numbers[:3]}")
print(f"Last 3: {numbers[-3:]}")
print(f"Every 2nd: {numbers[::2]}")

# List methods
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
print(f"Original: {numbers}")
print(f"Sorted: {sorted(numbers)}")
print(f"Count of 1: {numbers.count(1)}")
print(f"Index of 5: {numbers.index(5)}")

# List comprehensions (powerful way to create lists)
squares = [x**2 for x in range(5)]
print(f"Squares: {squares}")

even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(f"Even squares: {even_squares}")

# =============================================================================
# 4. TUPLES
# =============================================================================

print("\n" + "=" * 60)
print("4. TUPLES")
print("=" * 60)

# Tuples are immutable (cannot be changed after creation)
coordinates = (3, 4)
person = ("Alice", 25, "Engineer")

print(f"Coordinates: {coordinates}")
print(f"Person: {person}")
print(f"X coordinate: {coordinates[0]}")
print(f"Name: {person[0]}")

# Tuple unpacking
x, y = coordinates
name, age, job = person
print(f"Unpacked: x={x}, y={y}")
print(f"Unpacked: name={name}, age={age}, job={job}")

# Tuples are often used for multiple return values
def get_name_and_age():
    return "Bob", 30

name, age = get_name_and_age()
print(f"Function returned: name={name}, age={age}")

# =============================================================================
# 5. SETS
# =============================================================================

print("\n" + "=" * 60)
print("5. SETS")
print("=" * 60)

# Sets store unique elements (no duplicates)
fruits = {"apple", "banana", "cherry", "apple"}  # Duplicate removed
print(f"Fruits set: {fruits}")

# Set operations
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

print(f"Set 1: {set1}")
print(f"Set 2: {set2}")
print(f"Union: {set1 | set2}")
print(f"Intersection: {set1 & set2}")
print(f"Difference: {set1 - set2}")
print(f"Symmetric difference: {set1 ^ set2}")

# Set methods
numbers = {1, 2, 3}
numbers.add(4)
numbers.remove(2)  # Raises error if not found
numbers.discard(5)  # Doesn't raise error if not found
print(f"After operations: {numbers}")

# =============================================================================
# 6. DICTIONARIES
# =============================================================================

print("\n" + "=" * 60)
print("6. DICTIONARIES")
print("=" * 60)

# Dictionaries store key-value pairs
person = {
    "name": "Alice",
    "age": 25,
    "city": "New York",
    "hobbies": ["reading", "swimming"]
}

print(f"Person: {person}")
print(f"Name: {person['name']}")
print(f"Age: {person.get('age', 'Unknown')}")

# Dictionary operations
person["email"] = "alice@example.com"  # Add new key
person["age"] = 26  # Update existing key
print(f"After updates: {person}")

# Dictionary methods
print(f"Keys: {list(person.keys())}")
print(f"Values: {list(person.values())}")
print(f"Items: {list(person.items())}")

# Dictionary comprehensions
squares_dict = {x: x**2 for x in range(5)}
print(f"Squares dict: {squares_dict}")

# =============================================================================
# 7. CONDITIONALS
# =============================================================================

print("\n" + "=" * 60)
print("7. CONDITIONALS")
print("=" * 60)

# Basic if-elif-else
score = 85

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "F"

print(f"Score {score} gets grade: {grade}")

# Comparison operators
a, b = 10, 20
print(f"a = {a}, b = {b}")
print(f"a == b: {a == b}")
print(f"a != b: {a != b}")
print(f"a < b: {a < b}")
print(f"a <= b: {a <= b}")
print(f"a > b: {a > b}")
print(f"a >= b: {a >= b}")

# Logical operators
x, y = True, False
print(f"x = {x}, y = {y}")
print(f"x and y: {x and y}")
print(f"x or y: {x or y}")
print(f"not x: {not x}")

# Ternary operator (conditional expression)
age = 17
status = "adult" if age >= 18 else "minor"
print(f"Age {age} is {status}")

# =============================================================================
# 8. LOOPS
# =============================================================================

print("\n" + "=" * 60)
print("8. LOOPS")
print("=" * 60)

# For loop with range
print("For loop with range:")
for i in range(5):
    print(f"  i = {i}")

# For loop with list
print("\nFor loop with list:")
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(f"  {fruit}")

# For loop with enumerate (get both index and value)
print("\nFor loop with enumerate:")
for i, fruit in enumerate(fruits):
    print(f"  {i}: {fruit}")

# For loop with dictionary
print("\nFor loop with dictionary:")
person = {"name": "Alice", "age": 25, "city": "NYC"}
for key, value in person.items():
    print(f"  {key}: {value}")

# While loop
print("\nWhile loop:")
count = 0
while count < 3:
    print(f"  Count: {count}")
    count += 1

# Loop control: break and continue
print("\nLoop with break and continue:")
for i in range(10):
    if i == 3:
        continue  # Skip this iteration
    if i == 7:
        break     # Exit loop
    print(f"  i = {i}")

# Else clause with loops (runs when loop completes normally)
print("\nLoop with else clause:")
for i in range(3):
    print(f"  i = {i}")
else:
    print("  Loop completed normally!")

# =============================================================================
# 9. FUNCTIONS
# =============================================================================

print("\n" + "=" * 60)
print("9. FUNCTIONS")
print("=" * 60)

# Basic function
def greet(name):
    """Return a greeting message."""
    return f"Hello, {name}!"

print(greet("Alice"))

# Function with default parameters
def greet_with_title(name, title="Mr./Ms."):
    return f"Hello, {title} {name}!"

print(greet_with_title("Smith"))
print(greet_with_title("Smith", "Dr."))

# Function with multiple parameters
def calculate_area(length, width):
    return length * width

print(f"Area: {calculate_area(5, 3)}")

# Function with *args (variable number of positional arguments)
def sum_all(*args):
    return sum(args)

print(f"Sum of 1,2,3,4: {sum_all(1, 2, 3, 4)}")
print(f"Sum of 10,20: {sum_all(10, 20)}")

# Function with **kwargs (variable number of keyword arguments)
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"  {key}: {value}")

print("Info with kwargs:")
print_info(name="Alice", age=25, city="NYC")

# Function with both *args and **kwargs
def flexible_function(*args, **kwargs):
    print(f"Positional args: {args}")
    print(f"Keyword args: {kwargs}")

flexible_function(1, 2, 3, name="Alice", age=25)

# Lambda functions (anonymous functions)
square = lambda x: x ** 2
print(f"Square of 5: {square(5)}")

# Lambda with multiple parameters
add = lambda x, y: x + y
print(f"Add 3 and 4: {add(3, 4)}")

# =============================================================================
# 10. CLASSES AND OBJECT-ORIENTED PROGRAMMING
# =============================================================================

print("\n" + "=" * 60)
print("10. CLASSES AND OBJECT-ORIENTED PROGRAMMING")
print("=" * 60)

# Basic class
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def greet(self):
        return f"Hello, I'm {self.name} and I'm {self.age} years old."
    
    def have_birthday(self):
        self.age += 1
        return f"Happy birthday! Now I'm {self.age} years old."

# Create an instance
person = Person("Alice", 25)
print(person.greet())
print(person.have_birthday())

# Class with class variables and methods
class BankAccount:
    # Class variable (shared by all instances)
    bank_name = "Python Bank"
    
    def __init__(self, account_holder, initial_balance=0):
        self.account_holder = account_holder
        self.balance = initial_balance
    
    def deposit(self, amount):
        self.balance += amount
        return f"Deposited ${amount}. New balance: ${self.balance}"
    
    def withdraw(self, amount):
        if amount <= self.balance:
            self.balance -= amount
            return f"Withdrew ${amount}. New balance: ${self.balance}"
        else:
            return "Insufficient funds!"
    
    @classmethod
    def get_bank_name(cls):
        return cls.bank_name
    
    @staticmethod
    def calculate_interest(principal, rate, time):
        return principal * rate * time

# Using the class
account = BankAccount("Bob", 1000)
print(account.deposit(500))
print(account.withdraw(200))
print(f"Bank name: {BankAccount.get_bank_name()}")
print(f"Interest: ${BankAccount.calculate_interest(1000, 0.05, 2)}")

# Inheritance
class Student(Person):
    def __init__(self, name, age, student_id):
        super().__init__(name, age)  # Call parent constructor
        self.student_id = student_id
        self.courses = []
    
    def enroll(self, course):
        self.courses.append(course)
        return f"Enrolled in {course}"
    
    def greet(self):  # Override parent method
        return f"Hi, I'm {self.name}, student ID: {self.student_id}"

student = Student("Charlie", 20, "S12345")
print(student.greet())
print(student.enroll("Python Programming"))

# =============================================================================
# 11. DECORATORS
# =============================================================================

print("\n" + "=" * 60)
print("11. DECORATORS")
print("=" * 60)

# Simple decorator
def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Something is happening before the function is called.")
        result = func(*args, **kwargs)
        print("Something is happening after the function is called.")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Alice")

# Decorator with parameters
def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

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

print("\nRepeated greeting:")
greet("Bob")

# Built-in decorators
class Circle:
    def __init__(self, radius):
        self._radius = radius
    
    @property
    def radius(self):
        return self._radius
    
    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("Radius cannot be negative")
        self._radius = value
    
    @property
    def area(self):
        return 3.14159 * self._radius ** 2

circle = Circle(5)
print(f"Circle radius: {circle.radius}")
print(f"Circle area: {circle.area:.2f}")

# =============================================================================
# 12. FILE HANDLING
# =============================================================================

print("\n" + "=" * 60)
print("12. FILE HANDLING")
print("=" * 60)

# Writing to a file
filename = "example.txt"
with open(filename, "w") as file:
    file.write("Hello, World!\n")
    file.write("This is a test file.\n")
    file.write("Python is awesome!\n")

print(f"Created file: {filename}")

# Reading from a file
with open(filename, "r") as file:
    content = file.read()
    print(f"File content:\n{content}")

# Reading line by line
with open(filename, "r") as file:
    lines = file.readlines()
    print("Lines:")
    for i, line in enumerate(lines, 1):
        print(f"  {i}: {line.strip()}")

# Appending to a file
with open(filename, "a") as file:
    file.write("This line was appended.\n")

print("Appended to file")

# JSON handling
import json

# Create a dictionary
data = {
    "name": "Alice",
    "age": 25,
    "hobbies": ["reading", "swimming"],
    "address": {
        "street": "123 Main St",
        "city": "New York"
    }
}

# Write to JSON file
with open("data.json", "w") as file:
    json.dump(data, file, indent=2)

print("Created JSON file: data.json")

# Read from JSON file
with open("data.json", "r") as file:
    loaded_data = json.load(file)
    print(f"Loaded data: {loaded_data}")

# CSV handling
import csv

# Write CSV file
with open("data.csv", "w", newline="") as file:
    writer = csv.writer(file)
    writer.writerow(["Name", "Age", "City"])
    writer.writerow(["Alice", 25, "New York"])
    writer.writerow(["Bob", 30, "Boston"])
    writer.writerow(["Charlie", 35, "Chicago"])

print("Created CSV file: data.csv")

# Read CSV file
with open("data.csv", "r") as file:
    reader = csv.reader(file)
    print("CSV content:")
    for row in reader:
        print(f"  {row}")

# =============================================================================
# 13. MODULES AND PACKAGES
# =============================================================================

print("\n" + "=" * 60)
print("13. MODULES AND PACKAGES")
print("=" * 60)

# Importing modules
import math
import random
from datetime import datetime, timedelta

# Using math module
print(f"Square root of 16: {math.sqrt(16)}")
print(f"Pi: {math.pi}")
print(f"Ceiling of 4.3: {math.ceil(4.3)}")

# Using random module
print(f"Random integer (1-10): {random.randint(1, 10)}")
print(f"Random float (0-1): {random.random()}")
print(f"Random choice from list: {random.choice(['apple', 'banana', 'cherry'])}")

# Using datetime module
now = datetime.now()
print(f"Current time: {now}")
print(f"Formatted time: {now.strftime('%Y-%m-%d %H:%M:%S')}")

tomorrow = now + timedelta(days=1)
print(f"Tomorrow: {tomorrow.strftime('%Y-%m-%d')}")

# Creating a simple module (simulated)
def add_numbers(a, b):
    return a + b

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

# This would normally be in a separate file called mymath.py
print(f"Using local functions: {add_numbers(3, 4)}")

# =============================================================================
# 14. ERROR HANDLING AND EXCEPTIONS
# =============================================================================

print("\n" + "=" * 60)
print("14. ERROR HANDLING AND EXCEPTIONS")
print("=" * 60)

# Basic try-except
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Error: Cannot divide by zero!")

# Multiple exception types
try:
    value = int("not_a_number")
except ValueError as e:
    print(f"ValueError: {e}")
except Exception as e:
    print(f"Other error: {e}")

# Try-except-else-finally
def divide_numbers(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("Cannot divide by zero!")
        return None
    except TypeError:
        print("Invalid input types!")
        return None
    else:
        print("Division successful!")
        return result
    finally:
        print("This always runs!")

print(divide_numbers(10, 2))
print(divide_numbers(10, 0))

# Raising exceptions
def validate_age(age):
    if age < 0:
        raise ValueError("Age cannot be negative")
    if age > 150:
        raise ValueError("Age seems unrealistic")
    return True

try:
    validate_age(-5)
except ValueError as e:
    print(f"Validation error: {e}")

# Custom exceptions
class CustomError(Exception):
    def __init__(self, message):
        self.message = message
        super().__init__(self.message)

def check_positive(number):
    if number < 0:
        raise CustomError("Number must be positive")
    return number

try:
    check_positive(-1)
except CustomError as e:
    print(f"Custom error: {e}")

# =============================================================================
# 15. COMPREHENSIONS
# =============================================================================

print("\n" + "=" * 60)
print("15. COMPREHENSIONS")
print("=" * 60)

# List comprehensions
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Square all numbers
squares = [x**2 for x in numbers]
print(f"Squares: {squares}")

# Even numbers only
evens = [x for x in numbers if x % 2 == 0]
print(f"Even numbers: {evens}")

# Square only even numbers
even_squares = [x**2 for x in numbers if x % 2 == 0]
print(f"Even squares: {even_squares}")

# Dictionary comprehensions
word_lengths = {word: len(word) for word in ["apple", "banana", "cherry"]}
print(f"Word lengths: {word_lengths}")

# Set comprehensions
unique_lengths = {len(word) for word in ["apple", "banana", "cherry", "date"]}
print(f"Unique lengths: {unique_lengths}")

# Nested comprehensions
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [item for row in matrix for item in row]
print(f"Flattened matrix: {flattened}")

# =============================================================================
# 16. GENERATORS AND ITERATORS
# =============================================================================

print("\n" + "=" * 60)
print("16. GENERATORS AND ITERATORS")
print("=" * 60)

# Generator function
def count_up_to(max_count):
    count = 1
    while count <= max_count:
        yield count
        count += 1

# Using the generator
counter = count_up_to(5)
print("Generator values:")
for value in counter:
    print(f"  {value}")

# Generator expression
squares_gen = (x**2 for x in range(5))
print(f"Generator expression: {list(squares_gen)}")

# Iterator protocol
class CountDown:
    def __init__(self, start):
        self.start = start
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.start <= 0:
            raise StopIteration
        self.start -= 1
        return self.start + 1

print("Countdown iterator:")
for i in CountDown(3):
    print(f"  {i}")

# =============================================================================
# 17. LAMBDA, MAP, FILTER, REDUCE
# =============================================================================

print("\n" + "=" * 60)
print("17. LAMBDA, MAP, FILTER, REDUCE")
print("=" * 60)

# Lambda functions
square = lambda x: x ** 2
add = lambda x, y: x + y

print(f"Square of 5: {square(5)}")
print(f"Add 3 and 4: {add(3, 4)}")

# Map function
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(f"Original: {numbers}")
print(f"Squared: {squared}")

# Filter function
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(f"Even numbers: {evens}")

# Reduce function (need to import)
from functools import reduce
sum_all = reduce(lambda x, y: x + y, numbers)
print(f"Sum of all numbers: {sum_all}")

# Combining map, filter, and reduce
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = reduce(lambda x, y: x + y, 
                map(lambda x: x**2, 
                    filter(lambda x: x % 2 == 0, numbers)))
print(f"Sum of squares of even numbers: {result}")

# =============================================================================
# 18. REGULAR EXPRESSIONS
# =============================================================================

print("\n" + "=" * 60)
print("18. REGULAR EXPRESSIONS")
print("=" * 60)

import re

# Basic pattern matching
text = "The quick brown fox jumps over the lazy dog"
pattern = r"fox"
match = re.search(pattern, text)
if match:
    print(f"Found '{match.group()}' at position {match.start()}")

# Find all matches
pattern = r"\b\w{4}\b"  # 4-letter words
matches = re.findall(pattern, text)
print(f"4-letter words: {matches}")

# Substitution
pattern = r"fox"
replacement = "cat"
new_text = re.sub(pattern, replacement, text)
print(f"After replacement: {new_text}")

# Email validation
email_pattern = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
emails = ["user@example.com", "invalid-email", "test@domain.org"]
for email in emails:
    if re.match(email_pattern, email):
        print(f"'{email}' is valid")
    else:
        print(f"'{email}' is invalid")

# =============================================================================
# 19. DATE AND TIME
# =============================================================================

print("\n" + "=" * 60)
print("19. DATE AND TIME")
print("=" * 60)

from datetime import datetime, date, time, timedelta
import time as time_module

# Current date and time
now = datetime.now()
print(f"Current datetime: {now}")
print(f"Current date: {now.date()}")
print(f"Current time: {now.time()}")

# Formatting dates
formatted = now.strftime("%Y-%m-%d %H:%M:%S")
print(f"Formatted: {formatted}")

# Parsing dates
date_string = "2024-01-15 14:30:00"
parsed_date = datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S")
print(f"Parsed date: {parsed_date}")

# Date arithmetic
today = date.today()
tomorrow = today + timedelta(days=1)
next_week = today + timedelta(weeks=1)
print(f"Today: {today}")
print(f"Tomorrow: {tomorrow}")
print(f"Next week: {next_week}")

# Time differences
start = datetime(2024, 1, 1, 10, 0, 0)
end = datetime(2024, 1, 1, 15, 30, 0)
difference = end - start
print(f"Time difference: {difference}")
print(f"Hours: {difference.total_seconds() / 3600}")

# Unix timestamp
timestamp = time_module.time()
print(f"Unix timestamp: {timestamp}")
converted = datetime.fromtimestamp(timestamp)
print(f"Converted back: {converted}")

# =============================================================================
# 20. VIRTUAL ENVIRONMENTS AND PIP
# =============================================================================

print("\n" + "=" * 60)
print("20. VIRTUAL ENVIRONMENTS AND PIP")
print("=" * 60)

print("""
Virtual Environments and Pip Commands:

# Create virtual environment
python -m venv myenv

# Activate virtual environment
# On Windows:
myenv\\Scripts\\activate
# On macOS/Linux:
source myenv/bin/activate

# Install packages
pip install package_name
pip install package_name==1.2.3  # Specific version
pip install -r requirements.txt  # From file

# List installed packages
pip list
pip freeze > requirements.txt  # Save to file

# Deactivate virtual environment
deactivate

# Remove virtual environment
# Just delete the folder
""")

# =============================================================================
# 21. USEFUL BUILT-IN MODULES
# =============================================================================

print("\n" + "=" * 60)
print("21. USEFUL BUILT-IN MODULES")
print("=" * 60)

# os module
import os
print(f"Current working directory: {os.getcwd()}")
print(f"Environment variable HOME: {os.environ.get('HOME', 'Not set')}")

# sys module
import sys
print(f"Python version: {sys.version}")
print(f"Command line arguments: {sys.argv}")

# math module
import math
print(f"Square root of 16: {math.sqrt(16)}")
print(f"Factorial of 5: {math.factorial(5)}")
print(f"Sine of π/2: {math.sin(math.pi/2)}")

# random module
import random
print(f"Random integer (1-100): {random.randint(1, 100)}")
print(f"Random choice: {random.choice(['apple', 'banana', 'cherry'])}")

# pathlib module (modern way to handle paths)
from pathlib import Path
current_path = Path.cwd()
print(f"Current path: {current_path}")
print(f"Path exists: {current_path.exists()}")

# itertools module
import itertools
print("Permutations of [1,2,3]:")
for perm in itertools.permutations([1, 2, 3]):
    print(f"  {perm}")

print("Combinations of [1,2,3,4] taken 2 at a time:")
for comb in itertools.combinations([1, 2, 3, 4], 2):
    print(f"  {comb}")

# =============================================================================
# 22. DATA SCIENCE BASICS (NumPy and Pandas)
# =============================================================================

print("\n" + "=" * 60)
print("22. DATA SCIENCE BASICS")
print("=" * 60)

# Note: These require installation: pip install numpy pandas matplotlib

try:
    import numpy as np
    print("NumPy examples:")
    
    # Create arrays
    arr1 = np.array([1, 2, 3, 4, 5])
    arr2 = np.array([[1, 2, 3], [4, 5, 6]])
    
    print(f"1D array: {arr1}")
    print(f"2D array:\n{arr2}")
    print(f"Array shape: {arr2.shape}")
    print(f"Array dtype: {arr2.dtype}")
    
    # Array operations
    print(f"Sum: {np.sum(arr1)}")
    print(f"Mean: {np.mean(arr1)}")
    print(f"Max: {np.max(arr1)}")
    
    # Array arithmetic
    doubled = arr1 * 2
    print(f"Doubled: {doubled}")
    
except ImportError:
    print("NumPy not installed. Install with: pip install numpy")

try:
    import pandas as pd
    print("\nPandas examples:")
    
    # Create DataFrame
    data = {
        'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['New York', 'Boston', 'Chicago']
    }
    df = pd.DataFrame(data)
    print("DataFrame:")
    print(df)
    
    # Basic operations
    print(f"\nMean age: {df['Age'].mean()}")
    print(f"Oldest person: {df.loc[df['Age'].idxmax(), 'Name']}")
    
except ImportError:
    print("Pandas not installed. Install with: pip install pandas")

# =============================================================================
# 23. PLOTTING (Matplotlib)
# =============================================================================

print("\n" + "=" * 60)
print("23. PLOTTING (Matplotlib)")
print("=" * 60)

try:
    import matplotlib.pyplot as plt
    import numpy as np
    
    print("Creating sample plots...")
    
    # Simple line plot
    x = np.linspace(0, 10, 100)
    y = np.sin(x)
    
    plt.figure(figsize=(10, 6))
    plt.subplot(2, 2, 1)
    plt.plot(x, y)
    plt.title('Sine Wave')
    plt.xlabel('x')
    plt.ylabel('sin(x)')
    
    # Bar chart
    plt.subplot(2, 2, 2)
    categories = ['A', 'B', 'C', 'D']
    values = [23, 45, 56, 78]
    plt.bar(categories, values)
    plt.title('Bar Chart')
    plt.xlabel('Categories')
    plt.ylabel('Values')
    
    # Scatter plot
    plt.subplot(2, 2, 3)
    x_scatter = np.random.randn(50)
    y_scatter = np.random.randn(50)
    plt.scatter(x_scatter, y_scatter)
    plt.title('Scatter Plot')
    plt.xlabel('X')
    plt.ylabel('Y')
    
    # Histogram
    plt.subplot(2, 2, 4)
    data = np.random.randn(1000)
    plt.hist(data, bins=30)
    plt.title('Histogram')
    plt.xlabel('Value')
    plt.ylabel('Frequency')
    
    plt.tight_layout()
    plt.savefig('sample_plots.png')
    print("Plots saved as 'sample_plots.png'")
    
except ImportError:
    print("Matplotlib not installed. Install with: pip install matplotlib")

# =============================================================================
# 24. APIs AND REQUESTS
# =============================================================================

print("\n" + "=" * 60)
print("24. APIs AND REQUESTS")
print("=" * 60)

try:
    import requests
    import json
    
    print("Making API request...")
    
    # Example API call (JSONPlaceholder - a fake API for testing)
    response = requests.get('https://jsonplaceholder.typicode.com/posts/1')
    
    if response.status_code == 200:
        data = response.json()
        print(f"API Response: {json.dumps(data, indent=2)}")
    else:
        print(f"Error: {response.status_code}")
    
    # POST request example
    new_post = {
        'title': 'My New Post',
        'body': 'This is the content of my post',
        'userId': 1
    }
    
    response = requests.post('https://jsonplaceholder.typicode.com/posts', 
                           json=new_post)
    print(f"POST response status: {response.status_code}")
    
except ImportError:
    print("Requests not installed. Install with: pip install requests")
except Exception as e:
    print(f"API request failed: {e}")

# =============================================================================
# 25. MULTITHREADING AND MULTIPROCESSING
# =============================================================================

print("\n" + "=" * 60)
print("25. MULTITHREADING AND MULTIPROCESSING")
print("=" * 60)

import threading
import multiprocessing
import time

# Threading example
def worker_function(name, duration):
    print(f"Thread {name} starting")
    time.sleep(duration)
    print(f"Thread {name} finished")

print("Threading example:")
threads = []
for i in range(3):
    thread = threading.Thread(target=worker_function, args=(f"Thread-{i}", 1))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print("All threads completed")

# Multiprocessing example
def cpu_intensive_task(n):
    result = sum(i*i for i in range(n))
    return result

print("\nMultiprocessing example:")
if __name__ == '__main__':
    # Single process
    start_time = time.time()
    result1 = cpu_intensive_task(1000000)
    single_time = time.time() - start_time
    print(f"Single process result: {result1}, time: {single_time:.2f}s")
    
    # Multiple processes
    start_time = time.time()
    with multiprocessing.Pool(processes=2) as pool:
        results = pool.map(cpu_intensive_task, [500000, 500000])
    multi_time = time.time() - start_time
    print(f"Multi-process results: {results}, time: {multi_time:.2f}s")

# =============================================================================
# 26. UNIT TESTING
# =============================================================================

print("\n" + "=" * 60)
print("26. UNIT TESTING")
print("=" * 60)

import unittest

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

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

# Test class
class TestMathFunctions(unittest.TestCase):
    def test_add_positive_numbers(self):
        self.assertEqual(add_numbers(2, 3), 5)
    
    def test_add_negative_numbers(self):
        self.assertEqual(add_numbers(-2, -3), -5)
    
    def test_divide_normal(self):
        self.assertEqual(divide_numbers(10, 2), 5)
    
    def test_divide_by_zero(self):
        with self.assertRaises(ValueError):
            divide_numbers(10, 0)

# Run tests
if __name__ == '__main__':
    print("Running unit tests...")
    unittest.main(argv=[''], exit=False, verbosity=2)

# =============================================================================
# 27. COMMON CODING PATTERNS AND EXAMPLES
# =============================================================================

print("\n" + "=" * 60)
print("27. COMMON CODING PATTERNS AND EXAMPLES")
print("=" * 60)

# Singleton pattern
class Singleton:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

# Factory pattern
class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

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

class AnimalFactory:
    @staticmethod
    def create_animal(animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        else:
            raise ValueError("Unknown animal type")

# Using the patterns
print("Singleton pattern:")
s1 = Singleton()
s2 = Singleton()
print(f"Same instance: {s1 is s2}")

print("\nFactory pattern:")
dog = AnimalFactory.create_animal("dog")
cat = AnimalFactory.create_animal("cat")
print(f"Dog says: {dog.speak()}")
print(f"Cat says: {cat.speak()}")

# Context manager
class Timer:
    def __init__(self, name):
        self.name = name
    
    def __enter__(self):
        self.start_time = time.time()
        print(f"Starting {self.name}...")
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        elapsed = time.time() - self.start_time
        print(f"{self.name} took {elapsed:.2f} seconds")

# Using context manager
with Timer("calculation"):
    result = sum(i**2 for i in range(100000))
    print(f"Result: {result}")

# =============================================================================
# CONCLUSION
# =============================================================================

print("\n" + "=" * 60)
print("CONCLUSION")
print("=" * 60)

print("""
Congratulations! You've covered the essential Python concepts:

✅ Basic syntax, variables, and data types
✅ Collections: strings, lists, tuples, sets, dictionaries
✅ Control flow: conditionals and loops
✅ Functions: basic to advanced (*args, **kwargs, lambda)
✅ Object-oriented programming: classes, inheritance, decorators
✅ File handling: text, JSON, CSV
✅ Modules, packages, and error handling
✅ Advanced features: comprehensions, generators, iterators
✅ Functional programming: map, filter, reduce
✅ Regular expressions
✅ Date and time handling
✅ Virtual environments and package management
✅ Built-in modules: os, sys, math, random, pathlib, itertools
✅ Data science basics: NumPy, Pandas, Matplotlib
✅ Web APIs and HTTP requests
✅ Concurrency: threading and multiprocessing
✅ Unit testing with unittest
✅ Common design patterns

Next steps:
1. Practice with real projects
2. Explore specific libraries for your domain
3. Learn about Python best practices (PEP 8)
4. Contribute to open source projects
5. Keep up with Python updates and new features

Happy coding! 🐍
""")

# Clean up temporary files
import os
temp_files = ["example.txt", "data.json", "data.csv"]
for file in temp_files:
    if os.path.exists(file):
        os.remove(file)
        print(f"Cleaned up: {file}")

print("\nTemporary files cleaned up. Python mastery complete!")