Advanced Python Programming (4321602) - Winter 2023 Solution

# Dictionary Example
student = {
    "name": "Raj",
    "age": 20,
    "course": "IT"
}
print(student["name"])  # Output: Raj

# Tuple Methods Example
numbers = (1, 2, 3, 2, 4, 2)
print(numbers.count(2))     # Output: 3
print(numbers.index(3))     # Output: 2
print(len(numbers))         # Output: 6

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

print("Set 1:", set1)
print("Set 2:", set2)

# Union Operation
union_result = set1 | set2
print("Union:", union_result)

# Intersection Operation  
intersection_result = set1 & set2
print("Intersection:", intersection_result)

# Difference Operation
difference_result = set1 - set2
print("Difference:", difference_result)

# Symmetric Difference
sym_diff_result = set1 ^ set2
print("Symmetric Difference:", sym_diff_result)

# Subset and Superset
set3 = {1, 2}
print("Is set3 subset of set1?", set3.issubset(set1))
print("Is set1 superset of set3?", set1.issuperset(set3))

# Dictionary Operations Program
student_data = {
    "name": "Amit",
    "age": 21,
    "course": "IT",
    "semester": 2
}

print("Original Dictionary:", student_data)

# Accessing values
print("Student Name:", student_data.get("name"))
print("Student Age:", student_data["age"])

# Adding new key-value pair
student_data["city"] = "Ahmedabad"
print("After adding city:", student_data)

# Updating existing value
student_data.update({"age": 22, "semester": 3})
print("After update:", student_data)

# Dictionary methods
print("Keys:", list(student_data.keys()))
print("Values:", list(student_data.values()))
print("Items:", list(student_data.items()))

# Removing elements
removed_value = student_data.pop("semester")
print("Removed value:", removed_value)
print("Final Dictionary:", student_data)

# dir() Function Example
# For string object
text = "Hello"
string_methods = dir(text)
print("String methods:", string_methods[:5])

# For list object  
my_list = [1, 2, 3]
list_methods = dir(my_list)
print("List methods:", [m for m in list_methods if not m.startswith('_')][:5])

# For current namespace
print("Current namespace:", dir()[:3])

# For built-in functions
import math
print("Math module:", dir(math)[:5])

# circle.py - Circle calculation module
import math

# Constants
PI = math.pi

def area(radius):
    """Calculate area of circle"""
    if radius < 0:
        return "Radius cannot be negative"
    return PI * radius * radius

def circumference(radius):
    """Calculate circumference of circle"""
    if radius < 0:
        return "Radius cannot be negative"
    return 2 * PI * radius

def display_info():
    """Display module information"""
    print("Circle Module - Version 1.0")
    print("Functions: area(), circumference()")

# main.py - Main program using circle module
import circle

# Get radius from user
radius = float(input("Enter radius: "))

# Calculate using module functions
circle_area = circle.area(radius)
circle_circumference = circle.circumference(radius)

# Display results
print(f"Circle with radius {radius}:")
print(f"Area: {circle_area:.2f}")
print(f"Circumference: {circle_circumference:.2f}")

# Display module info
circle.display_info()

# Nested Tuple Example
student_records = (
    ("Raj", 20, ("IT", 2)),
    ("Priya", 19, ("CS", 1)), 
    ("Amit", 21, ("IT", 3))
)

# Accessing nested elements
print("First student:", student_records[0])
print("First student name:", student_records[0][0])
print("First student course:", student_records[0][2][0])

# Iterating through nested tuple
for student in student_records:
    name, age, (course, semester) = student
    print(f"{name} - Age: {age}, Course: {course}, Sem: {semester}")

# PIP Command Examples (Terminal/Command Prompt માં run કરવા)

# Install a package
# pip install requests

# Install specific version
# pip install Django==3.2.0

# Uninstall a package  
# pip uninstall numpy

# List all installed packages
# pip list

# Show package information
# pip show matplotlib

# Upgrade a package
# pip install --upgrade pandas

# Install from requirements file
# pip install -r requirements.txt

# Different Import Ways

# 1. Basic Import
import math
result = math.sqrt(16)

# 2. From Import
from math import sqrt, pi
result = sqrt(16)
area = pi * 5 * 5

# 3. Alias Import
import numpy as np
array = np.array([1, 2, 3])

# 4. Star Import (not recommended)
from math import *
result = cos(0)

# 5. Package Import
from mypackage import module1
from mypackage.subpackage import module3

# 6. Relative Import (within package)
# from . import module1
# from ..parent_module import function

# Syntax Error Example
# print("Hello World"  # Missing closing parenthesis
# SyntaxError: unexpected EOF while parsing

# Runtime Error Examples
try:
    # ZeroDivisionError
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")

try:
    # FileNotFoundError  
    file = open("nonexistent.txt", "r")
except FileNotFoundError:
    print("File not found")

# Exception Handling Example
def safe_division(a, b):
    try:
        # Code that might raise exception
        result = a / b
        print(f"Division successful: {result}")
        
    except ZeroDivisionError:
        # Handle specific exception
        print("Error: Cannot divide by zero")
        result = None
        
    except TypeError:
        # Handle type errors
        print("Error: Invalid data types")
        result = None
        
    else:
        # Executes if no exception
        print("Division completed successfully")
        
    finally:
        # Always executes
        print("Division operation finished")
        
    return result

# Test the function
safe_division(10, 2)   # Normal case
safe_division(10, 0)   # Zero division
safe_division(10, "a") # Type error

def safe_integer_division(num1, num2):
    """
    Divide two numbers with validation
    Raises TypeError if arguments are not integers
    Raises ZeroDivisionError if second argument is 0
    """
    
    # Check if both arguments are integers
    if not isinstance(num1, int):
        raise TypeError(f"First argument must be integer, got {type(num1).__name__}")
    
    if not isinstance(num2, int):
        raise TypeError(f"Second argument must be integer, got {type(num2).__name__}")
    
    # Check for zero division
    if num2 == 0:
        raise ZeroDivisionError("Cannot divide by zero")
    
    # Perform division
    result = num1 / num2
    return result

# Test the function with different cases
def test_division():
    test_cases = [
        (10, 2),      # Valid case
        (15, 3),      # Valid case  
        (10, 0),      # Zero division error
        (10.5, 2),    # Non-integer first argument
        (10, 2.5),    # Non-integer second argument
        ("10", 2),    # String argument
    ]
    
    for num1, num2 in test_cases:
        try:
            result = safe_integer_division(num1, num2)
            print(f"{num1} ÷ {num2} = {result}")
            
        except TypeError as e:
            print(f"Type Error: {e}")
            
        except ZeroDivisionError as e:
            print(f"Zero Division Error: {e}")
            
        except Exception as e:
            print(f"Unexpected Error: {e}")
        
        print("-" * 40)

# Run tests
test_division()

# Built-in Exceptions Examples

# 1. ValueError
try:
    number = int("not_a_number")
except ValueError:
    print("ValueError: Invalid conversion")

# 2. TypeError  
try:
    result = "Hello" + 5
except TypeError:
    print("TypeError: Cannot add string and integer")

# 3. IndexError
try:
    my_list = [1, 2, 3]
    value = my_list[5]
except IndexError:
    print("IndexError: List index out of range")

try:
    # Code that might raise exception
    risky_code()
except ExceptionType1:
    # Handle specific exception
    handle_error1()
except ExceptionType2:
    # Handle another exception
    handle_error2()
else:
    # Code runs if no exception
    success_code()
finally:
    # Code always runs
    cleanup_code()

def file_operation(filename):
    file_handle = None
    try:
        # Risky operation
        file_handle = open(filename, 'r')
        content = file_handle.read()
        print("File read successfully")
        
    except FileNotFoundError:
        print("File not found error")
        
    except PermissionError:
        print("Permission denied")
        
    else:
        print("File operation completed successfully")
        
    finally:
        # Cleanup - always executes
        if file_handle:
            file_handle.close()
            print("File closed")

# Test the function
file_operation("test.txt")

# User-defined Exception Class
class ShortTextError(Exception):
    """Custom exception for text that is too short"""
    
    def __init__(self, text_length, minimum_length=10):
        self.text_length = text_length
        self.minimum_length = minimum_length
        message = f"Text is too short! Length: {text_length}, Required: {minimum_length}"
        super().__init__(message)

def validate_text_length(text):
    """
    Validate text length and raise exception if too short
    """
    if len(text) < 10:
        raise ShortTextError(len(text))
    return True

def process_user_text(text):
    """
    Process text after validation
    """
    try:
        validate_text_length(text)
        print(f"✓ Text accepted: '{text}'")
        print(f"Text length: {len(text)} characters")
        return text.upper()  # Process the text
        
    except ShortTextError as e:
        print(f"❌ {e}")
        return None

def interactive_text_input():
    """
    Interactive function to get valid text from user
    """
    while True:
        try:
            user_input = input("Enter text (minimum 10 characters): ")
            
            # Validate text length
            if len(user_input) < 10:
                raise ShortTextError(len(user_input))
                
            print(f"✓ Valid text entered: '{user_input}'")
            break
            
        except ShortTextError as e:
            print(f"❌ Error: {e}")
            retry = input("Try again? (y/n): ")
            if retry.lower() != 'y':
                print("Operation cancelled.")
                break

# Test different scenarios
def test_custom_exception():
    test_texts = [
        "Hi",                    # Too short (2 chars)
        "Hello",                 # Too short (5 chars)  
        "Short",                 # Too short (5 chars)
        "This is valid text",    # Valid (19 chars)
        "Perfect length text"    # Valid (20 chars)
    ]
    
    print("Testing Custom Exception:")
    print("=" * 40)
    
    for text in test_texts:
        result = process_user_text(text)
        if result:
            print(f"Processed: {result}")
        print("-" * 30)

# Run tests
test_custom_exception()

# Uncomment to test interactive input
# interactive_text_input()

# Enhanced Custom Exception with more features
class TextValidationError(Exception):
    """Enhanced text validation exception"""
    
    def __init__(self, text, error_type, details=None):
        self.text = text
        self.error_type = error_type
        self.details = details
        
        if error_type == "short":
            message = f"Text too short: {len(text)} chars (min: 10)"
        elif error_type == "empty":
            message = "Text cannot be empty"
        elif error_type == "spaces":
            message = "Text contains only spaces"
        else:
            message = f"Text validation failed: {error_type}"
            
        super().__init__(message)

def advanced_text_validation(text):
    """Advanced text validation with multiple checks"""
    if not text:
        raise TextValidationError(text, "empty")
    
    if text.isspace():
        raise TextValidationError(text, "spaces")
        
    if len(text.strip()) < 10:
        raise TextValidationError(text, "short")
    
    return True

# Text vs Binary File Examples
# Text file example
with open("sample.txt", "w") as f:
    f.write("Hello World")

# Binary file example  
with open("sample.bin", "wb") as f:
    f.write(b'\x48\x65\x6c\x6c\x6f')

def separate_case_characters(input_file, upper_file, lower_file):
    """
    Read file and separate uppercase/lowercase characters
    """
    try:
        # Read from input file
        with open(input_file, 'r') as infile:
            content = infile.read()
        
        # Separate characters
        uppercase_chars = ""
        lowercase_chars = ""
        
        for char in content:
            if char.isupper():
                uppercase_chars += char
            elif char.islower():
                lowercase_chars += char
        
        # Write to uppercase file
        with open(upper_file, 'w') as upfile:
            upfile.write(uppercase_chars)
        
        # Write to lowercase file  
        with open(lower_file, 'w') as lowfile:
            lowfile.write(lowercase_chars)
        
        print(f"✓ Characters separated successfully!")
        print(f"Uppercase characters: {len(uppercase_chars)}")
        print(f"Lowercase characters: {len(lowercase_chars)}")
        
    except FileNotFoundError:
        print(f"Error: File '{input_file}' not found")
    except Exception as e:
        print(f"Error: {e}")

# Create sample input file
def create_sample_file():
    sample_text = """Hello World! This is a SAMPLE Text file.
It contains UPPERCASE and lowercase Characters.
Python Programming is FUN and Educational."""
    
    with open("input.txt", "w") as f:
        f.write(sample_text)
    print("Sample input file created: input.txt")

# Main execution
create_sample_file()
separate_case_characters("input.txt", "uppercase.txt", "lowercase.txt")

# Display results
print("\nFile Contents:")
print("-" * 30)

try:
    with open("uppercase.txt", "r") as f:
        print(f"Uppercase file: {f.read()}")
    
    with open("lowercase.txt", "r") as f:
        print(f"Lowercase file: {f.read()}")
except FileNotFoundError:
    print("Output files not found")

import pickle

# Example with different data types
def demonstrate_pickle():
    # Sample data to serialize
    student_data = {
        'name': 'Raj Patel',
        'age': 20,
        'grades': [85, 92, 78, 96],
        'subjects': ('Math', 'Python', 'Database'),
        'is_active': True
    }
    
    class Student:
        def __init__(self, name, roll_no):
            self.name = name
            self.roll_no = roll_no
        
        def __str__(self):
            return f"Student: {self.name} (Roll: {self.roll_no})"
    
    # Create objects
    student_obj = Student("Priya Shah", 101)
    data_list = [student_data, student_obj, [1, 2, 3, 4, 5]]
    
    # DUMP - Serialize objects to file
    print("=== DUMP Operation ===")
    try:
        with open('student_data.pkl', 'wb') as f:
            pickle.dump(data_list, f)
        print("✓ Data successfully dumped to student_data.pkl")
        
        # Also demonstrate dumps()
        serialized_bytes = pickle.dumps(student_data)
        print(f"✓ Data serialized to bytes: {len(serialized_bytes)} bytes")
        
    except Exception as e:
        print(f"❌ Dump error: {e}")
    
    # LOAD - Deserialize objects from file  
    print("\n=== LOAD Operation ===")
    try:
        with open('student_data.pkl', 'rb') as f:
            loaded_data = pickle.load(f)
        
        print("✓ Data successfully loaded from student_data.pkl")
        print("\nLoaded Data:")
        print("-" * 20)
        
        # Display loaded data
        for i, item in enumerate(loaded_data):
            print(f"Item {i+1}: {item}")
            print(f"Type: {type(item)}")
            print()
        
        # Also demonstrate loads()
        deserialized_data = pickle.loads(serialized_bytes)
        print(f"✓ Data deserialized from bytes: {deserialized_data}")
        
    except FileNotFoundError:
        print("❌ Pickle file not found")
    except Exception as e:
        print(f"❌ Load error: {e}")

# Advanced example with custom class
def advanced_pickle_example():
    class BankAccount:
        def __init__(self, account_no, holder_name, balance):
            self.account_no = account_no
            self.holder_name = holder_name
            self.balance = balance
            self.transactions = []
        
        def deposit(self, amount):
            self.balance += amount
            self.transactions.append(f"Deposit: +{amount}")
        
        def withdraw(self, amount):
            if self.balance >= amount:
                self.balance -= amount
                self.transactions.append(f"Withdraw: -{amount}")
            else:
                print("Insufficient balance")
        
        def __str__(self):
            return f"Account {self.account_no}: {self.holder_name} - Balance: ₹{self.balance}"
    
    # Create and use account
    account = BankAccount("12345", "Amit Kumar", 5000)
    account.deposit(1500)
    account.withdraw(800)
    
    print("=== Advanced Pickle Example ===")
    print(f"Original: {account}")
    print(f"Transactions: {account.transactions}")
    
    # Serialize account object
    with open('bank_account.pkl', 'wb') as f:
        pickle.dump(account, f)
    
    # Load account object
    with open('bank_account.pkl', 'rb') as f:
        loaded_account = pickle.load(f)
    
    print(f"Loaded: {loaded_account}")
    print(f"Loaded transactions: {loaded_account.transactions}")
    
    # Verify object functionality
    loaded_account.deposit(200)
    print(f"After new deposit: {loaded_account}")

# Run demonstrations
demonstrate_pickle()
print("\n" + "="*50 + "\n")
advanced_pickle_example()

# Benefits
benefits = [
    "Complete object state preservation",
    "Works with complex nested objects", 
    "Maintains object relationships",
    "Fast serialization/deserialization"
]

# Limitations  
limitations = [
    "Python-specific format",
    "Security risks with untrusted data",
    "Version compatibility issues",
    "Not human-readable"
]

print("Benefits:", benefits)
print("Limitations:", limitations)

# File Modes Examples
import os

# Create sample file for demonstration
with open('demo.txt', 'w') as f:
    f.write("Original content\nLine 2\nLine 3")

# Read mode ('r')
with open('demo.txt', 'r') as f:
    content = f.read()
    print("Read mode:", content)

# Append mode ('a')  
with open('demo.txt', 'a') as f:
    f.write("\nAppended line")

# Read+Write mode ('r+')
with open('demo.txt', 'r+') as f:
    f.seek(0)  # Go to beginning
    f.write("Modified")

print("File modes demonstrated successfully")

def demonstrate_line_functions():
    # Create sample file with multiple lines
    lines_to_write = [
        "First line of text\n",
        "Second line of text\n", 
        "Third line of text\n",
        "Fourth line without newline"
    ]
    
    print("=== WRITELINES() Demonstration ===")
    # Write multiple lines using writelines()
    with open('sample_lines.txt', 'w') as f:
        f.writelines(lines_to_write)
    print("✓ Multiple lines written using writelines()")
    
    print("\n=== READLINE() Demonstration ===")
    # Read lines one by one using readline()
    with open('sample_lines.txt', 'r') as f:
        line_count = 0
        while True:
            line = f.readline()
            if not line:  # End of file
                break
            line_count += 1
            print(f"Line {line_count}: {line.strip()}")
    
    print(f"Total lines read: {line_count}")
    
    print("\n=== READLINES() Demonstration ===")
    # Read all lines at once using readlines()
    with open('sample_lines.txt', 'r') as f:
        all_lines = f.readlines()
    
    print("All lines as list:")
    for i, line in enumerate(all_lines, 1):
        print(f"  [{i}] {repr(line)}")
    
    # Practical example: Processing file line by line
    print("\n=== Practical Example ===")
    student_data = [
        "Raj,20,IT\n",
        "Priya,19,CS\n", 
        "Amit,21,EC\n",
        "Sneha,20,IT\n"
    ]
    
    # Write student data
    with open('students.txt', 'w') as f:
        f.writelines(student_data)
    
    # Read and process line by line
    print("Student Information:")
    with open('students.txt', 'r') as f:
        while True:
            line = f.readline()
            if not line:
                break
            
            # Process each line
            parts = line.strip().split(',')
            if len(parts) == 3:
                name, age, course = parts
                print(f"  {name} (Age: {age}, Course: {course})")

# Run demonstration
demonstrate_line_functions()

# File pointer behavior example
def file_pointer_demo():
    print("\n=== File Pointer Behavior ===")
    
    with open('sample_lines.txt', 'r') as f:
        print(f"Initial position: {f.tell()}")
        
        line1 = f.readline()
        print(f"After readline(): position {f.tell()}")
        print(f"Read: {repr(line1)}")
        
        line2 = f.readline()  
        print(f"After second readline(): position {f.tell()}")
        print(f"Read: {repr(line2)}")

file_pointer_demo()

def demonstrate_seek_tell():
    # Create sample file with known content
    sample_text = "Hello Python Programming World!"
    
    with open('pointer_demo.txt', 'w') as f:
        f.write(sample_text)
    
    print("=== File Pointer Demonstration ===")
    print(f"File content: '{sample_text}'")
    print(f"File length: {len(sample_text)} characters")
    print()
    
    with open('pointer_demo.txt', 'r') as f:
        # Initial position
        print(f"1. Initial position: {f.tell()}")
        
        # Read some characters
        first_part = f.read(5)  # Read "Hello"
        print(f"2. After reading '{first_part}': position {f.tell()}")
        
        # Move to specific position
        f.seek(6)  # Move to position 6 (start of "Python")
        print(f"3. After seek(6): position {f.tell()}")
        
        # Read from new position
        next_part = f.read(6)  # Read "Python"
        print(f"4. Read '{next_part}': position {f.tell()}")
        
        # Move relative to current position (only in binary mode for positive offset)
        # Let's demonstrate absolute positioning
        f.seek(0)  # Go to beginning
        print(f"5. After seek(0): position {f.tell()}")
        
        # Move to end of file
        f.seek(0, 2)  # 0 offset from end (position 2 = end)
        print(f"6. After seek(0,2) - end of file: position {f.tell()}")
        
        # Move backwards from end
        f.seek(-6, 2)  # 6 positions before end
        print(f"7. After seek(-6,2): position {f.tell()}")
        
        # Read remaining content
        remaining = f.read()
        print(f"8. Read remaining '{remaining}': position {f.tell()}")

def practical_seek_tell_example():
    print("\n=== Practical Example: File Editor Simulation ===")
    
    # Create a file with structured data
    data_lines = [
        "NAME:John Doe\n",
        "AGE:25\n", 
        "CITY:Mumbai\n",
        "PHONE:9876543210\n",
        "EMAIL:john@example.com\n"
    ]
    
    with open('person_data.txt', 'w') as f:
        f.writelines(data_lines)
    
    # Demonstrate finding and modifying specific data
    with open('person_data.txt', 'r+') as f:  # Read+Write mode
        # Find and display all positions
        positions = {}
        
        while True:
            pos = f.tell()
            line = f.readline()
            if not line:
                break
            
            field = line.split(':')[0]
            positions[field] = pos
            print(f"Field '{field}' starts at position {pos}")
        
        print(f"\nFile positions: {positions}")
        
        # Modify specific field (AGE)
        if 'AGE' in positions:
            f.seek(positions['AGE'])
            print(f"\nMoving to AGE field at position {f.tell()}")
            
            # Read current line
            current_line = f.readline()
            print(f"Current line: {current_line.strip()}")
            
            # Calculate position to overwrite
            f.seek(positions['AGE'])
            new_age_line = "AGE:26\n"  # Same length as original
            f.write(new_age_line)
            print(f"Updated AGE field")
    
    # Verify changes
    print("\nUpdated file content:")
    with open('person_data.txt', 'r') as f:
        print(f.read())

def binary_seek_tell_demo():
    print("\n=== Binary File Seek/Tell Demo ===")
    
    # Create binary file
    binary_data = b'\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64'  # "Hello World"
    
    with open('binary_demo.bin', 'wb') as f:
        f.write(binary_data)
    
    with open('binary_demo.bin', 'rb') as f:
        print(f"Binary file size: {len(binary_data)} bytes")
        
        # Demonstrate all seek modes in binary
        print(f"Initial position: {f.tell()}")
        
        # Read first 5 bytes
        first_bytes = f.read(5)
        print(f"Read first 5 bytes: {first_bytes} at position {f.tell()}")
        
        # Seek relative to current position (works in binary mode)
        f.seek(1, 1)  # Move 1 byte forward from current
        print(f"After seek(1,1): position {f.tell()}")
        
        # Seek from end
        f.seek(-3, 2)  # 3 bytes before end
        print(f"After seek(-3,2): position {f.tell()}")
        
        # Read remaining
        remaining_bytes = f.read()
        print(f"Remaining bytes: {remaining_bytes}")

# Run all demonstrations
demonstrate_seek_tell()
practical_seek_tell_example()
binary_seek_tell_demo()

# Cleanup
import os
try:
    os.remove('pointer_demo.txt')
    os.remove('person_data.txt') 
    os.remove('binary_demo.bin')
    print("\nDemo files cleaned up")
except:
    pass

import turtle

def draw_filled_shapes():
    # Create screen and turtle
    screen = turtle.Screen()
    screen.title("Filled Shapes with Turtle")
    screen.bgcolor("white")
    screen.setup(800, 600)
    
    # Create turtle object
    painter = turtle.Turtle()
    painter.speed(3)
    
    # Draw filled circle
    print("Drawing filled circle...")
    painter.penup()
    painter.goto(-150, 0)  # Move to left side
    painter.pendown()
    
    painter.fillcolor("red")
    painter.begin_fill()
    painter.circle(80)  # Radius = 80
    painter.end_fill()
    
    # Draw filled rectangle
    print("Drawing filled rectangle...")
    painter.penup()
    painter.goto(50, 50)  # Move to right side
    painter.pendown()
    
    painter.fillcolor("red")
    painter.begin_fill()
    
    # Draw rectangle (100x80)
    for _ in range(2):
        painter.forward(100)
        painter.right(90)
        painter.forward(80)
        painter.right(90)
    
    painter.end_fill()
    
    # Add labels
    painter.penup()
    painter.goto(-150, -120)
    painter.write("Red Circle", align="center", font=("Arial", 14, "normal"))
    
    painter.goto(100, -50)
    painter.write("Red Rectangle", align="center", font=("Arial", 14, "normal"))
    
    # Hide turtle and display result
    painter.hideturtle()
    print("Shapes drawn successfully!")
    
    # Keep window open
    screen.exitonclick()

# Run the program
draw_filled_shapes()

import turtle

def demonstrate_direction_methods():
    screen = turtle.Screen()
    screen.setup(600, 600)
    screen.title("Turtle Direction Methods")
    
    t = turtle.Turtle()
    t.speed(2)
    t.shape("turtle")
    
    # 1. right() method
    t.write("1. right(90)", font=("Arial", 10, "normal"))
    t.forward(50)
    t.right(90)
    t.forward(50)
    
    # 2. left() method  
    t.penup()
    t.goto(-100, 100)
    t.pendown()
    t.write("2. left(45)", font=("Arial", 10, "normal"))
    t.forward(50)
    t.left(45)
    t.forward(50)
    
    # 3. setheading() method
    t.penup()
    t.goto(100, 100)
    t.pendown()
    t.write("3. setheading(180)", font=("Arial", 10, "normal"))
    t.setheading(180)  # Face west
    t.forward(50)
    
    # 4. towards() method
    t.penup()
    t.goto(-100, -100)
    t.pendown()
    target_x, target_y = 100, -100
    t.write("4. towards(100,-100)", font=("Arial", 10, "normal"))
    angle = t.towards(target_x, target_y)
    t.setheading(angle)
    t.goto(target_x, target_y)
    
    # 5. home() method
    t.write("5. home()", font=("Arial", 10, "normal"))
    t.home()  # Return to center and face east
    
    t.hideturtle()
    screen.exitonclick()

demonstrate_direction_methods()