print("Hello, World!")

name = input("Enter your name: ")
print("Hello,", name)

# Correct
if 5 > 3:
    print("Yes")

# Incorrect (no indentation)
if 5 > 3:
print("Yes")  # ❌ Error

# List
fruits = ["apple", "banana", "cherry"]

# Tuple
coordinates = (10, 20)

# Dictionary
student = {"name": "Ali", "age": 20}

# Set
colors = {"red", "green", "blue"}

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

# Empty list
empty_list = []
also_empty = list()

# List with repeated values
zeros = [0] * 5  # [0, 0, 0, 0, 0]

# List from range
countdown = list(range(10, 0, -1))  # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

# List from string
letters = list("Python")  # ['P', 'y', 't', 'h', 'o', 'n']

print(f"Fruits: {fruits}")
print(f"Mixed types: {mixed}")
print(f"Countdown: {countdown}")

colors = ["red", "green", "blue", "yellow", "purple"]

# Positive indexing (from start)
print(colors[0])    # "red" - first item
print(colors[2])    # "blue" - third item
print(colors[4])    # "purple" - last item

# Negative indexing (from end)
print(colors[-1])   # "purple" - last item
print(colors[-2])   # "yellow" - second to last

# List slicing
print(colors[1:4])     # ["green", "blue", "yellow"] - items 1 to 3
print(colors[:3])      # ["red", "green", "blue"] - first 3 items
print(colors[2:])      # ["blue", "yellow", "purple"] - from index 2 to end
print(colors[::2])     # ["red", "blue", "purple"] - every 2nd item
print(colors[::-1])    # Reverse the list

# Getting list length
print(f"List has {len(colors)} items")

shopping_list = ["milk", "bread"]

# append() - Add single item to end
shopping_list.append("eggs")
print(f"After append: {shopping_list}")

# insert() - Add item at specific position
shopping_list.insert(1, "butter")  # Insert at index 1
print(f"After insert: {shopping_list}")

# extend() - Add multiple items from another list
more_items = ["cheese", "yogurt", "honey"]
shopping_list.extend(more_items)
print(f"After extend: {shopping_list}")

# Using + operator to combine lists
fruits = ["apple", "banana"]
vegetables = ["carrot", "lettuce"]
grocery = fruits + vegetables
print(f"Combined list: {grocery}")

# Using += to add to existing list
fruits += ["orange", "grape"]
print(f"Updated fruits: {fruits}")

numbers = [1, 2, 3, 4, 5, 3, 6]

# remove() - Remove first occurrence of value
numbers.remove(3)  # Removes first 3
print(f"After remove(3): {numbers}")

# pop() - Remove and return item by index
last_item = numbers.pop()      # Remove last item
print(f"Popped item: {last_item}, List: {numbers}")

second_item = numbers.pop(1)   # Remove item at index 1
print(f"Popped item: {second_item}, List: {numbers}")

# del - Delete by index or slice
del numbers[0]        # Delete first item
print(f"After del[0]: {numbers}")

# clear() - Remove all items
backup = numbers.copy()  # Make a backup first
numbers.clear()
print(f"After clear(): {numbers}")
print(f"Backup: {backup}")

scores = [85, 92, 78, 96, 88]

# Modifying individual items
scores[2] = 82  # Change third score
print(f"Updated scores: {scores}")

# Modifying multiple items with slicing
scores[1:3] = [95, 85]  # Replace items at index 1 and 2
print(f"After slice modification: {scores}")

# Sorting
names = ["Charlie", "Alice", "Bob", "Diana"]
names.sort()  # Sort in place (alphabetical)
print(f"Sorted names: {names}")

# Sort in reverse
scores.sort(reverse=True)
print(f"Scores (highest first): {scores}")

# sorted() - Returns new sorted list without changing original
original = [3, 1, 4, 1, 5]
sorted_version = sorted(original)
print(f"Original: {original}")
print(f"Sorted copy: {sorted_version}")

# reverse() - Reverse the order
colors = ["red", "green", "blue"]
colors.reverse()
print(f"Reversed colors: {colors}")

# Counting and finding
letters = ['a', 'b', 'a', 'c', 'a', 'b']
print(f"Count of 'a': {letters.count('a')}")
print(f"Index of 'b': {letters.index('b')}")

# Basic list comprehension
numbers = [1, 2, 3, 4, 5]
squares = [x**2 for x in numbers]
print(f"Squares: {squares}")

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

# String manipulation
words = ["hello", "world", "python", "programming"]
capitalized = [word.upper() for word in words]
long_words = [word for word in words if len(word) > 5]

print(f"Capitalized: {capitalized}")
print(f"Long words: {long_words}")

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

# Creating a multiplication table
multiplication_table = [[i * j for j in range(1, 6)] for i in range(1, 6)]
for row in multiplication_table:
    print(row)

# Copying lists
original = [1, 2, 3, 4, 5]
shallow_copy = original.copy()
deep_copy = original[:]

# Checking membership
fruits = ["apple", "banana", "cherry"]
print("apple" in fruits)        # True
print("orange" not in fruits)   # True

# Unpacking lists
coordinates = [10, 20, 30]
x, y, z = coordinates
print(f"x={x}, y={y}, z={z}")

# Using * for flexible unpacking
numbers = [1, 2, 3, 4, 5]
first, *middle, last = numbers
print(f"First: {first}, Middle: {middle}, Last: {last}")

# zip() - Combine multiple lists
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
cities = ["New York", "London", "Tokyo"]

combined = list(zip(names, ages, cities))
print("Combined data:")
for name, age, city in combined:
    print(f"  {name}, {age} years old, lives in {city}")

# enumerate() - Get index and value
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

# max(), min(), sum() with lists
numbers = [4, 2, 9, 1, 7]
print(f"Max: {max(numbers)}")
print(f"Min: {min(numbers)}")
print(f"Sum: {sum(numbers)}")
print(f"Average: {sum(numbers) / len(numbers)}")

# Student grade management
class GradeBook:
    def __init__(self):
        self.grades = []
    
    def add_grade(self, grade):
        if 0 <= grade <= 100:
            self.grades.append(grade)
            print(f"Added grade: {grade}")
        else:
            print("Grade must be between 0 and 100")
    
    def get_average(self):
        if self.grades:
            return sum(self.grades) / len(self.grades)
        return 0
    
    def get_letter_grade(self):
        avg = self.get_average()
        if avg >= 90: return 'A'
        elif avg >= 80: return 'B'
        elif avg >= 70: return 'C'
        elif avg >= 60: return 'D'
        else: return 'F'

# Usage example
student_grades = GradeBook()
student_grades.add_grade(85)
student_grades.add_grade(92)
student_grades.add_grade(78)

print(f"Average: {student_grades.get_average():.1f}")
print(f"Letter Grade: {student_grades.get_letter_grade()}")

# Inventory management
inventory = [
    {"item": "Laptop", "quantity": 5, "price": 999.99},
    {"item": "Mouse", "quantity": 20, "price": 25.99},
    {"item": "Keyboard", "quantity": 15, "price": 79.99}
]

# Find total inventory value
total_value = sum(item["quantity"] * item["price"] for item in inventory)
print(f"Total inventory value: ${total_value:.2f}")

# Find items running low (quantity < 10)
low_stock = [item["item"] for item in inventory if item["quantity"] < 10]
print(f"Low stock items: {low_stock}")

coordinates = (10, 20)
colors = ("red", "green", "blue")

# Accessing tuple items
print(coordinates[0])   # First item
print(colors[-1])       # Last item

# Tuples are immutable - this would cause an error:
# coordinates[0] = 15

# Tuple unpacking
x, y = coordinates
print(f"X: {x}, Y: {y}")

# Multiple assignment
point = (5, 10, 15)
x, y, z = point

# RGB color values
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)

# Geographic coordinates
locations = [
    ("Paris", 48.8566, 2.3522),
    ("London", 51.5074, -0.1278),
    ("Tokyo", 35.6762, 139.6503)
]

for city, lat, lon in locations:
    print(f"{city}: {lat}, {lon}")

fruits = {"apple", "banana", "cherry"}
numbers = {1, 2, 3, 4, 5}

# Sets automatically remove duplicates
duplicates = {1, 2, 2, 3, 3, 4}
print(duplicates)  # {1, 2, 3, 4}

# Adding and removing items
fruits.add("orange")
fruits.remove("banana")  # Error if item doesn't exist
fruits.discard("grape")  # No error if item doesn't exist

print(fruits)

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

# Union - all unique items from both sets
union = set1 | set2  # or set1.union(set2)

# Intersection - items in both sets
intersection = set1 & set2  # or set1.intersection(set2)

# Difference - items in set1 but not in set2
difference = set1 - set2  # or set1.difference(set2)

print(f"Union: {union}")
print(f"Intersection: {intersection}")
print(f"Difference: {difference}")

age = 18

if age >= 18:
    print("You are an adult")
else:
    print("You are a minor")

# Using elif for multiple conditions
score = 85

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

print(f"Your grade is: {grade}")

temperature = 25
is_sunny = True

# Comparison operators: ==, !=, <, >, <=, >=
if temperature > 20:
    print("It's warm!")

# Logical operators: and, or, not
if temperature > 20 and is_sunny:
    print("Perfect weather for a picnic!")

if temperature < 0 or temperature > 35:
    print("Extreme weather!")

if not is_sunny:
    print("Bring an umbrella!")

# Checking membership with 'in'
fruits = ["apple", "banana", "cherry"]
if "apple" in fruits:
    print("Apple is available!")

# Simple countdown
count = 5
while count > 0:
number = 0
while number < 10:
    number += 1
    if number % 2 == 0:
        continue  # Skip even numbers
    print(f"Odd number: {number}")

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

# Loop through a string
for letter in "Hello":
    print(letter)

# Loop with range
for i in range(5):
    print(f"Number: {i}")

# Range with start and end
for i in range(1, 6):
    print(f"Count: {i}")

# Range with step
for i in range(0, 10, 2):
    print(f"Even: {i}")

# Loop with index using enumerate
shopping_list = ["milk", "bread", "eggs", "cheese"]
for index, item in enumerate(shopping_list):
    print(f"{index + 1}. {item}")

# Iterating over dictionary
student_grades = {"Alice": 85, "Bob": 90, "Charlie": 78}
for name, grade in student_grades.items():
    print(f"{name}: {grade}")

# Nested loops - multiplication table
for i in range(1, 4):
    for j in range(1, 4):
        print(f"{i} x {j} = {i * j}")
    print("---")

# List comprehension alternative
squares = [x**2 for x in range(1, 6)]
print(f"Squares: {squares}")

# Using zip to iterate over multiple lists
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(f"{name} is {age} years old")

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

greet()  # Call the function

# Function with parameters
def greet_person(name):
    print(f"Hello, {name}!")

greet_person("Alice")

# Function with return value
def add_numbers(a, b):
    result = a + b
    return result

sum_result = add_numbers(5, 3)
print(f"Sum: {sum_result}")

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

room_area = calculate_area(10, 12)
print(f"Room area: {room_area} square feet")

# Function with default parameters
def introduce(name, age=25, city="Unknown"):
    print(f"Hi, I'm {name}, {age} years old, from {city}")

introduce("Alice")  # Uses defaults
introduce("Bob", 30)  # Overrides age
introduce("Charlie", city="Paris")  # Uses keyword argument

# Function returning multiple values
def get_name_parts(full_name):
    parts = full_name.split()
    first_name = parts[0]
    last_name = parts[-1] if len(parts) > 1 else ""
    return first_name, last_name

first, last = get_name_parts("Alice Johnson")
print(f"First: {first}, Last: {last}")

# Function with docstring
def fahrenheit_to_celsius(fahrenheit):
    """
    Convert temperature from Fahrenheit to Celsius.
    
    Args:
        fahrenheit (float): Temperature in Fahrenheit
    
    Returns:
        float: Temperature in Celsius
    """
    celsius = (fahrenheit - 32) * 5/9
    return celsius

temp = fahrenheit_to_celsius(100)
print(f"100°F = {temp:.1f}°C")

# Positional arguments
def introduce(name, age, city):
    print(f"Hi, I'm {name}, {age} years old, from {city}")

introduce("Alice", 25, "New York")

# Keyword arguments
introduce(city="London", name="Bob", age=30)

# *args - variable number of positional arguments
def sum_all(*numbers):
    total = 0
    for num in numbers:
        total += num
    return total

print(sum_all(1, 2, 3))        # 6
print(sum_all(1, 2, 3, 4, 5))  # 15

# **kwargs - variable number of keyword arguments
def create_profile(**info):
    print("User Profile:")
    for key, value in info.items():
        print(f"  {key}: {value}")

create_profile(name="Alice", age=25, job="Engineer", city="Boston")

# Combining different argument types
def complex_function(required, default="default", *args, **kwargs):
    print(f"Required: {required}")
    print(f"Default: {default}")
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

complex_function("hello")
complex_function("hello", "world", 1, 2, 3, name="Alice", age=25)

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

print(square(5))    # 25
print(add(3, 4))    # 7

# Using lambda with built-in functions
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))

print(f"Squared: {squared}")
print(f"Even: {even_numbers}")

# Global scope
global_var = "I'm global"

def my_function():
    # Local scope
    local_var = "I'm local"
    print(f"Inside function: {global_var}")  # Can access global
    print(f"Inside function: {local_var}")   # Can access local

my_function()
print(f"Outside function: {global_var}")    # Can access global
# print(local_var)  # This would cause an error!

# Modifying global variables
counter = 0

def increment():
    global counter  # Tell Python we want to modify the global variable
    counter += 1
    print(f"Counter: {counter}")

increment()  # Counter: 1
increment()  # Counter: 2
print(f"Final counter: {counter}")  # Final counter: 2

# Built-in scope (like len, print, etc.)
# Global scope
x = "global x"

def outer_function():
    # Enclosing scope
    x = "enclosing x"
    
    def inner_function():
        # Local scope
        x = "local x"
        print(f"Inner function: {x}")  # local x
    
    inner_function()
    print(f"Outer function: {x}")      # enclosing x

outer_function()
print(f"Global scope: {x}")           # global x

# Nonlocal keyword
def outer():
    x = "outer x"
    
    def inner():
        nonlocal x  # Modify the enclosing scope variable
        x = "modified by inner"
        print(f"Inner: {x}")
    
    inner()
    print(f"Outer after inner: {x}")

outer()

# Import entire module
import math
print(math.pi)        # 3.141592653589793
print(math.sqrt(16))  # 4.0
print(math.cos(0))    # 1.0

# Import with alias
import datetime as dt
now = dt.datetime.now()
print(f"Current time: {now}")

# Import specific functions
from random import randint, choice
number = randint(1, 100)      # Random integer between 1-100
color = choice(['red', 'blue', 'green'])  # Random choice from list
print(f"Random number: {number}, Random color: {color}")

# Import all (use with caution)
from math import *
result = sin(pi/2)  # Now we can use sin and pi directly
print(f"sin(π/2) = {result}")

# datetime - Working with dates and times
from datetime import datetime, timedelta
now = datetime.now()
tomorrow = now + timedelta(days=1)
print(f"Today: {now.strftime('%Y-%m-%d %H:%M:%S')}")
print(f"Tomorrow: {tomorrow.strftime('%Y-%m-%d')}")

# random - Generate random numbers and choices
import random
print(f"Random integer: {random.randint(1, 100)}")
print(f"Random float: {random.random()}")
colors = ['red', 'green', 'blue', 'yellow']
random.shuffle(colors)
print(f"Shuffled colors: {colors}")

# os - Operating system interface
import os
print(f"Current directory: {os.getcwd()}")

# json - Working with JSON data
import json
data = {"name": "Alice", "age": 30, "city": "New York"}
json_string = json.dumps(data)
parsed_data = json.loads(json_string)
print(f"JSON: {json_string}")
print(f"Parsed name: {parsed_data['name']}")

# File: calculator.py (your custom module)
"""
A simple calculator module
"""

PI = 3.14159
AUTHOR = "Your Name"

def add(x, y):
    """Add two numbers"""
    return x + y

def multiply(x, y):
    """Multiply two numbers"""
    return x * y

def circle_area(radius):
    """Calculate area of a circle"""
    return PI * radius * radius

class Calculator:
    def __init__(self):
        self.history = []
    
    def calculate(self, operation, x, y):
        if operation == '+':
            result = add(x, y)
        elif operation == '*':
            result = multiply(x, y)
        else:
            result = None
        
        self.history.append(f"{x} {operation} {y} = {result}")
        return result

# This runs only when the file is executed directly
if __name__ == "__main__":
    print("Testing calculator module...")
    print(f"5 + 3 = {add(5, 3)}")
    print(f"Circle area (radius=5): {circle_area(5)}")

# Now you can use your custom module in another file:
# import calculator
# result = calculator.add(10, 5)
# print(f"Addition result: {result}")

# Basic exception handling
try:
    # Code that might raise an exception
    number = int(input("Enter a number: "))
    result = 10 / number
    print(f"Result: {result}")
except ZeroDivisionError:
    # Handle specific exception
    print("Error: Cannot divide by zero!")
except ValueError:
    # Handle another specific exception
    print("Error: Please enter a valid number!")

print("Program continues executing...")

# Multiple exceptions in one except block
try:
    age = int(input("Enter your age: "))
    print(f"Next year you'll be {age + 1}")
except (ValueError, TypeError):
    print("Please enter a valid age!")

# 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:
        # Runs only if no exception occurred
        print("Division successful!")
        return result
    finally:
        # Always runs, regardless of exceptions
        print("Division operation completed")

print(divide_numbers(10, 2))   # Normal case
print(divide_numbers(10, 0))   # Zero division
print(divide_numbers("10", 2)) # Type error

# Raising custom 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}")

# Different types of exceptions
examples = [
    # IndexError
    lambda: [1, 2, 3][5],
    
    # KeyError
    lambda: {"name": "Alice"}["age"],
    
    # AttributeError
    lambda: "hello".append("world"),
    
    # FileNotFoundError
    lambda: open("nonexistent.txt"),
    
    # TypeError
    lambda: "5" + 5
]

exception_names = ["IndexError", "KeyError", "AttributeError", 
                  "FileNotFoundError", "TypeError"]

for i, example in enumerate(examples):
    try:
        example()
    except Exception as e:
        print(f"{exception_names[i]}: {e}")

# Generic exception handling (use sparingly)
try:
    # Some risky operation
    result = some_dangerous_function()
except Exception as e:
    print(f"An unexpected error occurred: {e}")
    # Log the error for debugging
    import traceback
    traceback.print_exc()

# Simple calculator project
def add(x, y):
    return x + y

def subtract(x, y):
    return x - y

def multiply(x, y):
    return x * y

def divide(x, y):
    if y != 0:
        return x / y
    else:
        return "Cannot divide by zero!"

def calculator():
    print("Welcome to Simple Calculator!")
    print("Operations: +, -, *, /")
    
    while True:
        try:
            num1 = float(input("Enter first number: "))
            operation = input("Enter operation (+, -, *, /) or 'quit': ")
            
            if operation.lower() == 'quit':
                break
                
            num2 = float(input("Enter second number: "))
            
            if operation == '+':
                result = add(num1, num2)
            elif operation == '-':
                result = subtract(num1, num2)
            elif operation == '*':
                result = multiply(num1, num2)
            elif operation == '/':
                result = divide(num1, num2)
            else:
                print("Invalid operation!")
                continue
                
            print(f"Result: {result}")
            
        except ValueError:
            print("Please enter valid numbers!")

# calculator()  # Uncomment to run

# To-Do list project
class TodoList:
    def __init__(self):
        self.tasks = []
    
    def add_task(self, task):
        self.tasks.append({"task": task, "completed": False})
        print(f"Added: '{task}'")
    
    def show_tasks(self):
        if not self.tasks:
            print("No tasks yet!")
            return
        
        print("\nYour Tasks:")
        for i, task in enumerate(self.tasks, 1):
            status = "✓" if task["completed"] else "○"
            print(f"{i}. {status} {task['task']}")
    
    def complete_task(self, index):
        if 1 <= index <= len(self.tasks):
            self.tasks[index - 1]["completed"] = True
            print(f"Completed: '{self.tasks[index - 1]['task']}'")
        else:
            print("Invalid task number!")
    
    def remove_task(self, index):
        if 1 <= index <= len(self.tasks):
            removed = self.tasks.pop(index - 1)
            print(f"Removed: '{removed['task']}'")
        else:
            print("Invalid task number!")

# Example usage
todo = TodoList()
todo.add_task("Learn Python")
todo.add_task("Build a project")
todo.add_task("Practice coding")
todo.show_tasks()
todo.complete_task(1)
todo.show_tasks()

# Number guessing game
import random

def guessing_game():
    print("Welcome to the Number Guessing Game!")
    print("I'm thinking of a number between 1 and 100")
    
    # Generate random number
    secret_number = random.randint(1, 100)
    attempts = 0
    max_attempts = 7
    
    while attempts < max_attempts:
        try:
            guess = int(input(f"\nAttempt {attempts + 1}/{max_attempts} - Enter your guess: "))
            attempts += 1
            
            if guess == secret_number:
                print(f"🎉 Congratulations! You guessed it in {attempts} attempts!")
                break
            elif guess < secret_number:
                print("Too low! Try higher.")
            else:
                print("Too high! Try lower.")
                
            # Give hints
            if attempts == max_attempts // 2:
                if secret_number % 2 == 0:
                    print("Hint: The number is even!")
                else:
                    print("Hint: The number is odd!")
                    
        except ValueError:
            print("Please enter a valid number!")
            attempts -= 1  # Don't count invalid input as an attempt
    
    else:
        print(f"Game over! The number was {secret_number}")
    
    # Ask to play again
    play_again = input("Play again? (y/n): ").lower()
    if play_again == 'y':
        guessing_game()

# guessing_game()  # Uncomment to run