Advanced Python Programming (4321602) - Summer 2023 Solution

# Creating set
my_set = {1, 2, 3, 4}

# Adding element
my_set.add(5)        # {1, 2, 3, 4, 5}

# Removing elements
my_set.remove(2)     # {1, 3, 4, 5}
my_set.discard(10)   # No error if element doesn't exist

# Pop operation
element = my_set.pop()  # Removes random element

# Create dictionary
student = {'name': 'John', 'age': 20, 'grade': 'A'}

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

# Safe access
print("Age:", student.get('age', 'Not found'))

# Update and add
student.update({'city': 'Mumbai', 'age': 21})
print("Updated:", student)

# Remove operations
grade = student.pop('grade')
print("Removed grade:", grade)

# Different ways to create tuples
coordinates = (10, 20)          # Standard way
colors = 'red', 'blue', 'green' # Without parentheses
single = (42,)                  # Single element (comma needed)
empty = ()                      # Empty tuple

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

# main.py (using module)
import math_utils
result = math_utils.add(5, 3)

mkdir mathtools

# mathtools/__init__.py
print("MathTools package loaded")

# mathtools/basic.py
def add(a, b):
    return a + b

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

# mathtools/advanced.py
def power(base, exp):
    return base ** exp

def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n-1)

# main.py
import mathtools.basic
from mathtools.advanced import power

result1 = mathtools.basic.add(5, 3)
result2 = power(2, 3)
print(f"Addition: {result1}, Power: {result2}")

# Tuple - Immutable
coordinates = (10, 20)
# coordinates[0] = 15  # Error!

# List - Mutable  
numbers = [1, 2, 3]
numbers[0] = 10      # Works fine
numbers.append(4)    # Can add elements

# calculator/basic.py
def add(a, b):
    return a + b

# calculator/scientific.py
from .basic import add  # Relative import
from .utils.helpers import validate  # Sub-package import

def advanced_add(a, b):
    if validate(a) and validate(b):
        return add(a, b)
    return None

# calculator/utils/helpers.py
def validate(num):
    return isinstance(num, (int, float))

# circle.py - Circle operations module
import math

def area(radius):
    """Calculate area of circle"""
    if radius < 0:
        return None
    return math.pi * radius * radius

def circumference(radius):
    """Calculate circumference of circle"""
    if radius < 0:
        return None
    return 2 * math.pi * radius

def diameter(radius):
    """Calculate diameter of circle"""
    if radius < 0:
        return None
    return 2 * radius

# Module constant
PI = math.pi

# main.py - Using circle module
import circle
from circle import area, circumference

# Method 1: Using module name
radius = 5
print("Using module name:")
print(f"Area: {circle.area(radius):.2f}")
print(f"Circumference: {circle.circumference(radius):.2f}")

# Method 2: Direct function import
print("\nUsing direct import:")
print(f"Area: {area(radius):.2f}")
print(f"Circumference: {circumference(radius):.2f}")

# Using module constant
print(f"PI value: {circle.PI:.4f}")

# Import all functions
from circle import *

# Import with alias
import circle as c
result = c.area(10)

# Import specific function with alias
from circle import area as circle_area

# Syntax Error
# if x > 5  # Missing colon

# Runtime Error  
# result = 10 / 0  # ZeroDivisionError

# Logical Error
def average(a, b):
    return a + b / 2  # Should be (a + b) / 2

try:
    # Code that might cause error
    risky_code()
except ErrorType:
    # Handle specific error
    handle_error()
except:
    # Handle any other error
    handle_all_errors()
finally:
    # Always executed
    cleanup_code()

try:
    num = int(input("Enter number: "))
    result = 100 / num
    print(f"Result: {result}")
except ValueError:
    print("Invalid number format")
except ZeroDivisionError:
    print("Cannot divide by zero")
finally:
    print("Operation completed")

# Custom exception class
class InvalidMarksError(Exception):
    """Custom exception for invalid marks"""
    def __init__(self, subject, marks):
        self.subject = subject
        self.marks = marks
        super().__init__(f"Invalid {subject} marks: {marks}. Marks cannot be negative.")

def marks_result(english, maths):
    """
    Calculate result based on English and Maths marks
    
    Args:
        english (float): English subject marks
        maths (float): Mathematics subject marks
    
    Returns:
        dict: Result with total, percentage, and grade
    
    Raises:
        InvalidMarksError: If any marks are negative
        TypeError: If marks are not numeric
    """
    
    # Type validation
    if not isinstance(english, (int, float)) or not isinstance(maths, (int, float)):
        raise TypeError("Marks must be numeric values")
    
    # Negative marks validation
    if english < 0:
        raise InvalidMarksError("English", english)
    
    if maths < 0:
        raise InvalidMarksError("Mathematics", maths)
    
    # Marks range validation (0-100)
    if english > 100:
        raise InvalidMarksError("English", english)
    
    if maths > 100:
        raise InvalidMarksError("Mathematics", maths)
    
    # Calculate results
    total = english + maths
    percentage = (total / 200) * 100
    
    # Determine grade
    if percentage >= 90:
        grade = 'A+'
    elif percentage >= 80:
        grade = 'A'
    elif percentage >= 70:
        grade = 'B'
    elif percentage >= 60:
        grade = 'C'
    elif percentage >= 50:
        grade = 'D'
    else:
        grade = 'F'
    
    return {
        'english': english,
        'maths': maths,
        'total': total,
        'percentage': round(percentage, 2),
        'grade': grade,
        'status': 'Pass' if percentage >= 50 else 'Fail'
    }

# Usage examples with error handling
def main():
    """Main function to demonstrate the marks_result function"""
    
    test_cases = [
        (85, 92),      # Valid marks
        (-10, 85),     # Negative English
        (75, -5),      # Negative Maths
        (105, 80),     # Marks > 100
        ("80", 90),    # String input
    ]
    
    for i, (eng, math) in enumerate(test_cases, 1):
        print(f"\nTest Case {i}: English={eng}, Maths={math}")
        try:
            result = marks_result(eng, math)
            print(f"Result: {result}")
            
        except InvalidMarksError as e:
            print(f"Custom Error: {e}")
            
        except TypeError as e:
            print(f"Type Error: {e}")
            
        except Exception as e:
            print(f"Unexpected Error: {e}")

# Interactive function
def get_student_result():
    """Interactive function to get student marks"""
    
    while True:
        try:
            print("\n--- Student Result Calculator ---")
            english = float(input("Enter English marks (0-100): "))
            maths = float(input("Enter Maths marks (0-100): "))
            
            result = marks_result(english, maths)
            
            print(f"\n--- RESULT ---")
            print(f"English: {result['english']}")
            print(f"Mathematics: {result['maths']}")
            print(f"Total: {result['total']}/200")
            print(f"Percentage: {result['percentage']}%")
            print(f"Grade: {result['grade']}")
            print(f"Status: {result['status']}")
            
            break
            
        except InvalidMarksError as e:
            print(f"Error: {e}")
            print("Please enter valid marks (0-100)")
            
        except ValueError:
            print("Error: Please enter numeric values only")
            
        except KeyboardInterrupt:
            print("\nProgram terminated by user")
            break

if __name__ == "__main__":
    main()
    get_student_result()

# ValueError
try:
    number = int("hello")  # Cannot convert to int
except ValueError:
    print("Invalid number format")

# TypeError  
try:
    result = "text" + 42   # Cannot add string and int
except TypeError:
    print("Type mismatch")

# IndexError
try:
    mylist = [1, 2, 3]
    print(mylist[5])       # Index 5 doesn't exist
except IndexError:
    print("Index out of range")

def file_operations(filename):
    """Demonstrate finally block with file operations"""
    file_handle = None
    
    try:
        print("Opening file...")
        file_handle = open(filename, 'r')
        
        print("Reading file content...")
        content = file_handle.read()
        
        # Simulate potential error
        if len(content) == 0:
            raise ValueError("File is empty")
            
        print(f"File content: {content}")
        return content
        
    except FileNotFoundError:
        print("Error: File not found")
        return None
        
    except ValueError as e:
        print(f"Error: {e}")
        return None
        
    finally:
        print("Finally block executing...")
        if file_handle:
            file_handle.close()
            print("File closed successfully")
        else:
            print("No file to close")
        print("Cleanup completed")

# Test the function
print("=== Test 1: Valid file ===")
result1 = file_operations("test.txt")

print("\n=== Test 2: Non-existent file ===") 
result2 = file_operations("missing.txt")

import sys
import logging

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

class DivisionCalculator:
    """Calculator class with divide by zero exception handling"""
    
    def __init__(self):
        self.calculation_count = 0
        self.error_count = 0
    
    def safe_divide(self, dividend, divisor):
        """
        Perform division with exception handling
        
        Args:
            dividend (float): Number to be divided
            divisor (float): Number to divide by
            
        Returns:
            float or None: Result of division or None if error
        """
        operation_id = self.calculation_count + 1
        
        try:
            print(f"\n--- Operation {operation_id} ---")
            print(f"Attempting to divide {dividend} by {divisor}")
            logging.info(f"Division operation started: {dividend} ÷ {divisor}")
            
            # Type validation
            if not isinstance(dividend, (int, float)) or not isinstance(divisor, (int, float)):
                raise TypeError("Both arguments must be numeric")
            
            # Perform division
            result = dividend / divisor
            
            print(f"Result: {dividend} ÷ {divisor} = {result}")
            logging.info(f"Division successful: {result}")
            
            return result
            
        except ZeroDivisionError:
            error_msg = f"Error: Cannot divide {dividend} by zero!"
            print(error_msg)
            logging.error(error_msg)
            self.error_count += 1
            return None
            
        except TypeError as e:
            error_msg = f"Type Error: {e}"
            print(error_msg)
            logging.error(error_msg)
            self.error_count += 1
            return None
            
        except Exception as e:
            error_msg = f"Unexpected error: {e}"
            print(error_msg)
            logging.error(error_msg)
            self.error_count += 1
            return None
            
        finally:
            # Always executed - cleanup and logging
            self.calculation_count += 1
            print(f"Operation {operation_id} completed")
            print(f"Total operations: {self.calculation_count}")
            print(f"Total errors: {self.error_count}")
            logging.info(f"Operation {operation_id} finalized")
            
            # Resource cleanup simulation
            if hasattr(self, 'temp_data'):
                delattr(self, 'temp_data')
                print("Temporary data cleaned up")

def interactive_calculator():
    """Interactive division calculator"""
    
    calc = DivisionCalculator()
    print("=== Interactive Division Calculator ===")
    print("Enter 'quit' to exit the program")
    
    while True:
        try:
            print("\n" + "="*40)
            
            # Get dividend
            dividend_input = input("Enter dividend (number to be divided): ")
            if dividend_input.lower() == 'quit':
                break
                
            dividend = float(dividend_input)
            
            # Get divisor
            divisor_input = input("Enter divisor (number to divide by): ")
            if divisor_input.lower() == 'quit':
                break
                
            divisor = float(divisor_input)
            
            # Perform calculation
            result = calc.safe_divide(dividend, divisor)
            
            if result is not None:
                print(f"✓ Success: {dividend} ÷ {divisor} = {result}")
            else:
                print("✗ Operation failed")
                
        except ValueError:
            print("Error: Please enter valid numeric values")
            calc.error_count += 1
            
        except KeyboardInterrupt:
            print("\n\nProgram interrupted by user")
            break
            
        finally:
            # Final cleanup for each iteration
            if 'dividend_input' in locals():
                del dividend_input
            if 'divisor_input' in locals():
                del divisor_input
            print("Input variables cleaned up")

def test_division_cases():
    """Test various division scenarios"""
    
    print("=== Testing Division Cases ===")
    calc = DivisionCalculator()
    
    test_cases = [
        (10, 2),       # Normal division
        (15, 0),       # Divide by zero
        (7.5, 2.5),    # Float division
        (-20, 4),      # Negative numbers
        (0, 5),        # Zero dividend
        ("10", 2),     # String input
        (100, 0.0),    # Zero as float
    ]
    
    for dividend, divisor in test_cases:
        result = calc.safe_divide(dividend, divisor)
    
    # Final statistics
    print(f"\n=== Final Statistics ===")
    print(f"Total operations attempted: {calc.calculation_count}")
    print(f"Total errors encountered: {calc.error_count}")
    print(f"Success rate: {((calc.calculation_count - calc.error_count) / calc.calculation_count * 100):.1f}%")

if __name__ == "__main__":
    # Run test cases
    test_division_cases()
    
    # Run interactive calculator
    interactive_calculator()

# Basic file operations
file = open("data.txt", "w")  # Open
file.write("Hello World")     # Write
file.close()                  # Close

import pickle

# Serialization (Writing)
data = {'name': 'John', 'age': 25, 'scores': [85, 92, 78]}

with open('data.pkl', 'wb') as file:
    pickle.dump(data, file)

# Deserialization (Reading)
with open('data.pkl', 'rb') as file:
    loaded_data = pickle.load(file)
    print(loaded_data)

import os
import string
from collections import Counter

class VowelCounter:
    """Class to count vowels in text files"""
    
    def __init__(self):
        self.vowels = set('aeiouAEIOU')
        self.total_files_processed = 0
        self.total_vowels_found = 0
    
    def count_vowels_in_text(self, text):
        """
        Count vowels in given text
        
        Args:
            text (str): Text to analyze
            
        Returns:
            dict: Vowel counts and statistics
        """
        vowel_counts = {vowel.lower(): 0 for vowel in 'aeiou'}
        total_vowels = 0
        total_characters = 0
        
        for char in text:
            if char.isalpha():
                total_characters += 1
                if char.lower() in vowel_counts:
                    vowel_counts[char.lower()] += 1
                    total_vowels += 1
        
        return {
            'vowel_counts': vowel_counts,
            'total_vowels': total_vowels,
            'total_characters': total_characters,
            'vowel_percentage': (total_vowels / total_characters * 100) if total_characters > 0 else 0
        }
    
    def count_vowels_in_file(self, filename):
        """
        Count vowels in a specific file
        
        Args:
            filename (str): Path to file
            
        Returns:
            dict or None: Vowel analysis results
        """
        try:
            print(f"\n--- Processing file: {filename} ---")
            
            # Check if file exists
            if not os.path.exists(filename):
                raise FileNotFoundError(f"File '{filename}' not found")
            
            # Check if it's a file (not directory)
            if not os.path.isfile(filename):
                raise ValueError(f"'{filename}' is not a file")
            
            # Read file content
            with open(filename, 'r', encoding='utf-8') as file:
                content = file.read()
            
            print(f"File size: {len(content)} characters")
            
            if not content.strip():
                print("Warning: File is empty")
                return None
            
            # Count vowels
            results = self.count_vowels_in_text(content)
            
            # Display results
            print(f"Total characters (letters only): {results['total_characters']}")
            print(f"Total vowels found: {results['total_vowels']}")
            print(f"Vowel percentage: {results['vowel_percentage']:.2f}%")
            
            print("\nIndividual vowel counts:")
            for vowel, count in results['vowel_counts'].items():
                percentage = (count / results['total_vowels'] * 100) if results['total_vowels'] > 0 else 0
                print(f"  {vowel.upper()}: {count} ({percentage:.1f}%)")
            
            # Update statistics
            self.total_files_processed += 1
            self.total_vowels_found += results['total_vowels']
            
            return results
            
        except FileNotFoundError as e:
            print(f"Error: {e}")
            return None
            
        except PermissionError:
            print(f"Error: Permission denied to read '{filename}'")
            return None
            
        except UnicodeDecodeError:
            print(f"Error: Cannot decode file '{filename}'. Try different encoding.")
            return None
            
        except Exception as e:
            print(f"Unexpected error: {e}")
            return None
        
        finally:
            print(f"File processing completed for: {filename}")
    
    def create_sample_file(self, filename="sample.txt"):
        """Create a sample file for testing"""
        sample_content = """Python is a programming language.
It is easy to learn and powerful.
Python has simple syntax and great libraries.
We can use Python for web development, data science, and automation.
This file contains various vowels: a, e, i, o, u.
UPPER CASE VOWELS: A, E, I, O, U."""
        
        try:
            with open(filename, 'w', encoding='utf-8') as file:
                file.write(sample_content)
            print(f"Sample file '{filename}' created successfully")
            return True
        except Exception as e:
            print(f"Error creating sample file: {e}")
            return False
    
    def batch_process_files(self, file_list):
        """Process multiple files"""
        print("=== Batch Processing Files ===")
        
        all_results = []
        
        for filename in file_list:
            result = self.count_vowels_in_file(filename)
            if result:
                all_results.append((filename, result))
        
        # Summary statistics
        if all_results:
            print(f"\n=== Batch Processing Summary ===")
            print(f"Files processed successfully: {len(all_results)}")
            
            total_vowels = sum(result['total_vowels'] for _, result in all_results)
            total_chars = sum(result['total_characters'] for _, result in all_results)
            
            print(f"Total vowels across all files: {total_vowels}")
            print(f"Total characters across all files: {total_chars}")
            print(f"Overall vowel percentage: {(total_vowels/total_chars*100):.2f}%")

def interactive_vowel_counter():
    """Interactive vowel counter program"""
    
    counter = VowelCounter()
    
    while True:
        print("\n" + "="*50)
        print("VOWEL COUNTER PROGRAM")
        print("="*50)
        print("1. Count vowels in existing file")
        print("2. Create sample file and count vowels")
        print("3. Enter text directly")
        print("4. Process multiple files")
        print("5. Exit")
        
        try:
            choice = input("\nEnter your choice (1-5): ").strip()
            
            if choice == '1':
                filename = input("Enter filename: ").strip()
                counter.count_vowels_in_file(filename)
                
            elif choice == '2':
                filename = input("Enter filename for sample (default: sample.txt): ").strip()
                if not filename:
                    filename = "sample.txt"
                
                if counter.create_sample_file(filename):
                    counter.count_vowels_in_file(filename)
                
            elif choice == '3':
                text = input("Enter text to analyze: ")
                if text.strip():
                    result = counter.count_vowels_in_text(text)
                    print(f"\nVowel analysis for entered text:")
                    print(f"Total vowels: {result['total_vowels']}")
                    print(f"Vowel percentage: {result['vowel_percentage']:.2f}%")
                    for vowel, count in result['vowel_counts'].items():
                        if count > 0:
                            print(f"  {vowel.upper()}: {count}")
                else:
                    print("No text entered")
                    
            elif choice == '4':
                files_input = input("Enter filenames separated by commas: ")
                file_list = [f.strip() for f in files_input.split(',') if f.strip()]
                if file_list:
                    counter.batch_process_files(file_list)
                else:
                    print("No files specified")
                    
            elif choice == '5':
                print("Thank you for using Vowel Counter!")
                break
                
            else:
                print("Invalid choice. Please enter 1-5.")
                
        except KeyboardInterrupt:
            print("\n\nProgram interrupted. Goodbye!")
            break
        except Exception as e:
            print(f"Error: {e}")

if __name__ == "__main__":
    interactive_vowel_counter()

# Opening files
file = open("filename.txt", "r")     # Read mode
file = open("data.txt", "w")         # Write mode
file = open("log.txt", "a")          # Append mode

# Closing files
file.close()                         # Manual closing

# Automatic closing with 'with' statement
with open("filename.txt", "r") as file:
    content = file.read()
# File automatically closed here

# Text File Operations
with open("text_file.txt", "w") as file:
    file.write("Hello World!")

with open("text_file.txt", "r") as file:
    content = file.read()
    print(content)  # Output: Hello World!

# Binary File Operations  
import pickle

data = [1, 2, 3, 4, 5]

# Write binary
with open("binary_file.pkl", "wb") as file:
    pickle.dump(data, file)

# Read binary
with open("binary_file.pkl", "rb") as file:
    loaded_data = pickle.load(file)
    print(loaded_data)  # Output: [1, 2, 3, 4, 5]

import pickle
import os
from typing import Dict, Optional

class StudentRecordManager:
    """Manage student records in binary file"""
    
    def __init__(self, filename="students.pkl"):
        self.filename = filename
        self.records = {}
        self.load_records()
    
    def load_records(self):
        """Load existing records from binary file"""
        try:
            if os.path.exists(self.filename):
                with open(self.filename, 'rb') as file:
                    self.records = pickle.load(file)
                print(f"Loaded {len(self.records)} existing records")
            else:
                print("No existing record file found. Starting fresh.")
                self.records = {}
        except Exception as e:
            print(f"Error loading records: {e}")
            self.records = {}
    
    def save_records(self):
        """Save records to binary file"""
        try:
            with open(self.filename, 'wb') as file:
                pickle.dump(self.records, file)
            print(f"Records saved successfully to {self.filename}")
            return True
        except Exception as e:
            print(f"Error saving records: {e}")
            return False
    
    def add_student(self, seat_no: int, name: str):
        """Add new student record"""
        try:
            if not isinstance(seat_no, int) or seat_no <= 0:
                raise ValueError("Seat number must be a positive integer")
            
            if not name or not name.strip():
                raise ValueError("Name cannot be empty")
            
            name = name.strip().title()
            
            if seat_no in self.records:
                print(f"Warning: Seat {seat_no} already exists with name '{self.records[seat_no]}'")
                overwrite = input("Do you want to overwrite? (y/n): ").lower()
                if overwrite != 'y':
                    print("Record not added")
                    return False
            
            self.records[seat_no] = name
            self.save_records()
            print(f"Student added: Seat {seat_no} - {name}")
            return True
            
        except ValueError as e:
            print(f"Error: {e}")
            return False
        except Exception as e:
            print(f"Unexpected error: {e}")
            return False
    
    def search_student(self, seat_no: int):
        """Search for student by seat number"""
        try:
            if not isinstance(seat_no, int):
                raise ValueError("Seat number must be an integer")
            
            if seat_no in self.records:
                name = self.records[seat_no]
                print(f"Found: Seat {seat_no} - {name}")
                return name
            else:
                print("Seat no not found")
                return None
                
        except ValueError as e:
            print(f"Error: {e}")
            return None
        except Exception as e:
            print(f"Unexpected error: {e}")
            return None
    
    def display_all_records(self):
        """Display all student records"""
        if not self.records:
            print("No records found")
            return
        
        print(f"\n--- All Student Records ({len(self.records)} total) ---")
        print("Seat No. | Name")
        print("-" * 25)
        
        # Sort by seat number for better display
        for seat_no in sorted(self.records.keys()):
            print(f"{seat_no:8} | {self.records[seat_no]}")
    
    def delete_student(self, seat_no: int):
        """Delete student record"""
        try:
            if seat_no in self.records:
                name = self.records[seat_no]
                del self.records[seat_no]
                self.save_records()
                print(f"Deleted: Seat {seat_no} - {name}")
                return True
            else:
                print("Seat no not found")
                return False
        except Exception as e:
            print(f"Error deleting record: {e}")
            return False
    
    def get_statistics(self):
        """Get record statistics"""
        if not self.records:
            print("No records available for statistics")
            return
        
        seat_numbers = list(self.records.keys())
        print(f"\n--- Statistics ---")
        print(f"Total students: {len(self.records)}")
        print(f"Lowest seat number: {min(seat_numbers)}")
        print(f"Highest seat number: {max(seat_numbers)}")
        print(f"File size: {os.path.getsize(self.filename) if os.path.exists(self.filename) else 0} bytes")

def add_sample_data(manager):
    """Add sample student data for testing"""
    sample_students = [
        (101, "Alice Johnson"),
        (102, "Bob Smith"),
        (103, "Charlie Brown"),
        (104, "Diana Prince"),
        (105, "Edward Norton"),
        (201, "Fiona Apple"),
        (202, "George Wilson"),
        (203, "Hannah Montana"),
        (204, "Ian Fleming"),
        (205, "Julia Roberts")
    ]
    
    print("Adding sample data...")
    for seat_no, name in sample_students:
        manager.records[seat_no] = name
    
    manager.save_records()
    print(f"Added {len(sample_students)} sample records")

def main():
    """Main program with interactive menu"""
    
    print("=" * 50)
    print("STUDENT RECORD MANAGEMENT SYSTEM")
    print("Binary File Storage with Search")
    print("=" * 50)
    
    manager = StudentRecordManager()
    
    while True:
        print(f"\n--- MENU ---")
        print("1. Add new student")
        print("2. Search student by seat number")
        print("3. Display all records")
        print("4. Delete student record")
        print("5. Add sample data")
        print("6. Show statistics")
        print("7. Exit")
        
        try:
            choice = input("\nEnter your choice (1-7): ").strip()
            
            if choice == '1':
                try:
                    seat_no = int(input("Enter seat number: "))
                    name = input("Enter student name: ")
                    manager.add_student(seat_no, name)
                except ValueError:
                    print("Error: Please enter a valid seat number")
            
            elif choice == '2':
                try:
                    seat_no = int(input("Enter seat number to search: "))
                    manager.search_student(seat_no)
                except ValueError:
                    print("Error: Please enter a valid seat number")
            
            elif choice == '3':
                manager.display_all_records()
            
            elif choice == '4':
                try:
                    seat_no = int(input("Enter seat number to delete: "))
                    confirm = input(f"Are you sure you want to delete seat {seat_no}? (y/n): ")
                    if confirm.lower() == 'y':
                        manager.delete_student(seat_no)
                except ValueError:
                    print("Error: Please enter a valid seat number")
            
            elif choice == '5':
                confirm = input("This will add sample data. Continue? (y/n): ")
                if confirm.lower() == 'y':
                    add_sample_data(manager)
            
            elif choice == '6':
                manager.get_statistics()
            
            elif choice == '7':
                print("Thank you for using Student Record System!")
                break
            
            else:
                print("Invalid choice. Please enter 1-7.")
                
        except KeyboardInterrupt:
            print("\n\nProgram interrupted. Goodbye!")
            break
        except Exception as e:
            print(f"Error: {e}")

def quick_demo():
    """Quick demonstration of the program"""
    print("\n--- QUICK DEMO ---")
    
    # Create manager with demo file
    demo_manager = StudentRecordManager("demo_students.pkl")
    
    # Add some students
    demo_students = [
        (101, "John Doe"),
        (102, "Jane Smith"),
        (103, "Mike Johnson")
    ]
    
    print("Adding demo students...")
    for seat_no, name in demo_students:
        demo_manager.add_student(seat_no, name)
    
    print("\nSearching for existing student:")
    demo_manager.search_student(102)
    
    print("\nSearching for non-existing student:")
    demo_manager.search_student(999)
    
    print("\nAll records:")
    demo_manager.display_all_records()

if __name__ == "__main__":
    # Ask user for demo or full program
    mode = input("Run (d)emo or (f)ull program? (d/f): ").lower()
    
    if mode == 'd':
        quick_demo()
    else:
        main()

import turtle

# Create screen and turtle
screen = turtle.Screen()
pen = turtle.Turtle()

# Draw a square
for i in range(4):
    pen.forward(100)    # Move forward 100 units
    pen.right(90)       # Turn right 90 degrees

screen.exitonclick()    # Close on click