# This is a comment
print("Hello, World!")
print("Welcome to Python Programming")

# Output:
# Hello, World!
# Welcome to Python Programming

# Valid variable names
name = "Amanuddin"
age = 25
_salary = 50000
student1 = "Mallick"

# Invalid variable names (Do NOT use)
# 1student = "Error"  # Cannot start with number
# my-name = "Error"   # Cannot use hyphen
# for = "Error"       # Cannot use keywords

# Integer operations
x = 10
y = 3
print(x + y)   # Addition: 13
print(x - y)   # Subtraction: 7
print(x * y)   # Multiplication: 30
print(x / y)   # Division: 3.333...
print(x // y)  # Floor Division: 3
print(x % y)   # Modulus: 1
print(x ** y)  # Exponentiation: 1000

# Float operations
price = 299.99
tax_rate = 0.18
total = price + (price * tax_rate)
print(f"Total: ₹{total:.2f}")  # Total: ₹353.99

# String operations
name = "Python Programming"
print(len(name))           # Length: 18
print(name.upper())        # PYTHON PROGRAMMING
print(name.lower())        # python programming
print(name.replace("Python", "Java"))  # Java Programming
print(name.split())        # ['Python', 'Programming']

# String formatting
age = 25
salary = 50000
print(f"Age: {age}, Salary: ₹{salary}")  # f-string (Python 3.6+)
print("Age: {}, Salary: ₹{}".format(age, salary))  # format method

# Converting between types
x = "123"
y = int(x)        # String to integer: 123
z = float(x)      # String to float: 123.0

a = 45.67
b = int(a)        # Float to integer: 45
c = str(a)        # Float to string: "45.67"

# Checking data type
print(type(y))    # <class 'int'>
print(isinstance(y, int))  # True

# Comparison operators
age = 18
print(age >= 18)  # True
print(age == 18)  # True
print(age != 20)  # True

# Logical operators
has_id = True
age_valid = age >= 18
can_vote = has_id and age_valid
print(can_vote)  # True

# Membership operators
fruits = ["apple", "banana", "cherry"]
print("apple" in fruits)      # True
print("grape" not in fruits)  # True

# Identity operators
x = [1, 2, 3]
y = [1, 2, 3]
z = x
print(x is z)     # True (same object)
print(x is y)     # False (different objects)
print(x == y)     # True (same values)

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

# If-elif-else
marks = 85
if marks >= 90:
    grade = "A+"
elif marks >= 80:
    grade = "A"
elif marks >= 70:
    grade = "B"
elif marks >= 60:
    grade = "C"
else:
    grade = "F"
print(f"Grade: {grade}")  # Grade: A

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

# Using range()
for i in range(5):
    print(i)  # Prints 0, 1, 2, 3, 4

# Range with start and end
for i in range(1, 6):
    print(i)  # Prints 1, 2, 3, 4, 5

# Range with step
for i in range(0, 10, 2):
    print(i)  # Prints 0, 2, 4, 6, 8

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

# Basic while loop
count = 0
while count < 5:
    print(count)
    count += 1

# While with break
while True:
    user_input = input("Enter 'quit' to exit: ")
    if user_input == "quit":
        break
    print(f"You entered: {user_input}")

# While with continue
num = 0
while num < 10:
    num += 1
    if num % 2 == 0:
        continue  # Skip even numbers
    print(num)  # Prints odd numbers only

# Structural pattern matching (new in Python 3.10)
def http_status(status):
    match status:
        case 200:
            return "OK"
        case 404:
            return "Not Found"
        case 500:
            return "Internal Server Error"
        case _:
            return "Unknown Status"

print(http_status(200))  # OK
print(http_status(404))  # Not Found

# Pattern matching with conditions
def process_command(command):
    match command.split():
        case ["quit"]:
            return "Quitting..."
        case ["load", filename]:
            return f"Loading {filename}"
        case ["save", filename]:
            return f"Saving {filename}"
        case _:
            return "Unknown command"

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

greet()  # Call function

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

greet_user("Amanuddin")  # Hello, Amanuddin!

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

result = add_numbers(5, 3)
print(result)  # 8

# Default parameters
def greet(name="Guest"):
    print(f"Hello, {name}!")

greet()              # Hello, Guest!
greet("Mallick")     # Hello, Mallick!

# Keyword arguments
def calculate_price(price, tax_rate=0.18, discount=0):
    total = price + (price * tax_rate) - discount
    return total

print(calculate_price(1000))  # ₹1180.00
print(calculate_price(1000, discount=100))  # ₹1080.00

# *args (variable positional arguments)
def sum_all(*numbers):
    return sum(numbers)

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

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

print_info(name="Amanuddin", age=25, city="Kolkata")

# Lambda (anonymous) functions
square = lambda x: x ** 2
print(square(5))  # 25

# Lambda with multiple arguments
multiply = lambda x, y: x * y
print(multiply(4, 5))  # 20

# Using lambda with map()
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

# Using lambda with filter()
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # [2, 4]

# Global vs Local scope
x = 10  # Global variable

def modify_value():
    global x  # Declare we're using global x
    x = 20
    print(f"Inside function: {x}")

modify_value()  # Inside function: 20
print(f"Outside function: {x}")  # Outside function: 20

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

# List operations
fruits.append("orange")      # Add to end
fruits.insert(1, "mango")    # Insert at index
fruits.remove("banana")      # Remove by value
popped = fruits.pop()        # Remove and return last
fruits.sort()                # Sort in place
fruits.reverse()             # Reverse in place

# List slicing
print(numbers[1:4])   # [2, 3, 4]
print(numbers[:3])    # [1, 2, 3]
print(numbers[2:])    # [3, 4, 5]
print(numbers[-1])    # 5 (last element)

# List comprehension
squares = [x**2 for x in range(10)]
even_squares = [x**2 for x in range(10) if x % 2 == 0]

# Creating tuples (immutable)
coordinates = (10, 20)
person = ("Amanuddin", 25, "Kolkata")

# Tuple unpacking
name, age, city = person
print(name)  # Amanuddin

# Tuples are immutable
# coordinates[0] = 15  # This will raise an error!

# Tuple methods
numbers = (1, 2, 3, 2, 2, 4)
print(numbers.count(2))  # 3
print(numbers.index(3))  # 2

# Creating dictionaries
student = {
    "name": "Amanuddin Mallick",
    "age": 25,
    "course": "Python Programming",
    "fees": 15000
}

# Accessing values
print(student["name"])       # Amanuddin Mallick
print(student.get("age"))    # 25

# Adding/Modifying
student["email"] = "aman@example.com"
student["age"] = 26

# Dictionary methods
print(student.keys())        # All keys
print(student.values())      # All values
print(student.items())       # Key-value pairs

# Dictionary comprehension
squares = {x: x**2 for x in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Nested dictionaries
students = {
    "student1": {"name": "Aman", "marks": 85},
    "student2": {"name": "Mallick", "marks": 92}
}

# Creating sets (unique elements)
numbers = {1, 2, 3, 4, 5}
fruits = {"apple", "banana", "cherry"}

# Set operations
numbers.add(6)           # Add element
numbers.remove(3)        # Remove element
numbers.discard(10)      # Remove if exists (no error)

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

union = set1 | set2           # {1, 2, 3, 4, 5, 6}
intersection = set1 & set2    # {3, 4}
difference = set1 - set2      # {1, 2}
symmetric_diff = set1 ^ set2  # {1, 2, 5, 6}

# Defining a class
class Student:
    # Constructor
    def __init__(self, name, age, course):
        self.name = name
        self.age = age
        self.course = course
    
    # Method
    def display_info(self):
        print(f"Name: {self.name}")
        print(f"Age: {self.age}")
        print(f"Course: {self.course}")
    
    def study(self):
        print(f"{self.name} is studying {self.course}")

# Creating objects
student1 = Student("Amanuddin", 25, "Python")
student2 = Student("Mallick", 24, "Java")

student1.display_info()
student1.study()

# Parent class
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def introduce(self):
        print(f"I am {self.name}, {self.age} years old")

# Child class
class Employee(Person):
    def __init__(self, name, age, employee_id, salary):
        super().__init__(name, age)  # Call parent constructor
        self.employee_id = employee_id
        self.salary = salary
    
    def work(self):
        print(f"{self.name} is working")
    
    def get_details(self):
        print(f"ID: {self.employee_id}, Salary: ₹{self.salary}")

# Using inheritance
emp = Employee("Amanuddin", 25, "E001", 50000)
emp.introduce()  # Inherited method
emp.work()       # Own method
emp.get_details()

# Encapsulation with private attributes
class BankAccount:
    def __init__(self, account_number, balance):
        self.__account_number = account_number  # Private
        self.__balance = balance                # Private
    
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print(f"Deposited: ₹{amount}")
        else:
            print("Invalid amount")
    
    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            print(f"Withdrawn: ₹{amount}")
        else:
            print("Insufficient balance")
    
    def get_balance(self):
        return self.__balance

account = BankAccount("123456", 10000)
account.deposit(5000)
account.withdraw(3000)
print(f"Balance: ₹{account.get_balance()}")
# print(account.__balance)  # This will raise an error!

# Method overriding
class Animal:
    def sound(self):
        print("Animal makes a sound")

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

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

# Polymorphism in action
animals = [Dog(), Cat(), Animal()]
for animal in animals:
    animal.sound()

# Output:
# Dog barks: Woof! Woof!
# Cat meows: Meow!
# Animal makes a sound

# Reading entire file
with open("data.txt", "r") as file:
    content = file.read()
    print(content)

# Reading line by line
with open("data.txt", "r") as file:
    for line in file:
        print(line.strip())

# Reading all lines as list
with open("data.txt", "r") as file:
    lines = file.readlines()
    print(lines)

# Writing to file (overwrites)
with open("output.txt", "w") as file:
    file.write("Hello, World!\n")
    file.write("Python File Handling\n")

# Appending to file
with open("output.txt", "a") as file:
    file.write("New line appended\n")

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

import csv

# Writing to CSV
data = [
    ["Name", "Age", "Salary"],
    ["Amanuddin", 25, 50000],
    ["Mallick", 24, 45000]
]

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

# Reading from CSV
with open("employees.csv", "r") as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)

# Using DictReader
with open("employees.csv", "r") as file:
    reader = csv.DictReader(file)
    for row in reader:
        print(f"{row['Name']}: ₹{row['Salary']}")

import json

# Python object
student = {
    "name": "Amanuddin",
    "age": 25,
    "courses": ["Python", "Java", "JavaScript"],
    "fees": 15000
}

# Writing JSON
with open("student.json", "w") as file:
    json.dump(student, file, indent=4)

# Reading JSON
with open("student.json", "r") as file:
    data = json.load(file)
    print(data)
    print(f"Name: {data['name']}")
    print(f"Fees: ₹{data['fees']}")

# Basic exception handling
try:
    num = int(input("Enter a number: "))
    result = 100 / num
    print(f"Result: {result}")
except ZeroDivisionError:
    print("Error: Cannot divide by zero!")
except ValueError:
    print("Error: Invalid input! Please enter a number.")

# Multiple exceptions
try:
    file = open("data.txt", "r")
    content = file.read()
    file.close()
except FileNotFoundError:
    print("Error: File not found!")
except PermissionError:
    print("Error: Permission denied!")
except Exception as e:
    print(f"An error occurred: {e}")

# Complete exception handling
try:
    amount = float(input("Enter amount: "))
    tax = amount * 0.18
except ValueError:
    print("Invalid amount!")
else:
    # Executes if no exception
    print(f"Tax: ₹{tax:.2f}")
finally:
    # Always executes
    print("Operation completed")

# File handling with finally
file = None
try:
    file = open("data.txt", "r")
    content = file.read()
    print(content)
except FileNotFoundError:
    print("File not found!")
finally:
    if file:
        file.close()
        print("File closed")

# Raising exceptions
def check_age(age):
    if age < 0:
        raise ValueError("Age cannot be negative")
    if age < 18:
        raise Exception("Must be 18 or older")
    return True

try:
    check_age(15)
except ValueError as e:
    print(f"ValueError: {e}")
except Exception as e:
    print(f"Exception: {e}")

# Custom exceptions
class InsufficientFundsError(Exception):
    pass

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError("Not enough balance")
    return balance - amount

# Importing entire module
import math
print(math.pi)          # 3.141592653589793
print(math.sqrt(16))    # 4.0

# Importing specific functions
from math import pi, sqrt
print(pi)               # 3.141592653589793
print(sqrt(25))         # 5.0

# Importing with alias
import datetime as dt
now = dt.datetime.now()
print(now)

# Importing everything (not recommended)
from math import *
print(sin(0))  # 0.0

# File: mymodule.py
def greet(name):
    return f"Hello, {name}!"

def calculate_gst(amount, rate=0.18):
    return amount * rate

PI = 3.14159

# File: main.py
import mymodule

print(mymodule.greet("Amanuddin"))
gst = mymodule.calculate_gst(1000)
print(f"GST: ₹{gst}")
print(mymodule.PI)

# Random module
import random
print(random.randint(1, 100))           # Random integer
print(random.choice(["A", "B", "C"]))   # Random choice
print(random.random())                   # Random float [0, 1)

# Datetime module
from datetime import datetime, timedelta
now = datetime.now()
print(now.strftime("%d-%m-%Y %H:%M:%S"))
tomorrow = now + timedelta(days=1)
print(f"Tomorrow: {tomorrow}")

# OS module
import os
print(os.getcwd())                 # Current directory
# os.mkdir("new_folder")           # Create directory
print(os.listdir())                # List files

# Statistics module
import statistics
data = [10, 20, 30, 40, 50]
print(statistics.mean(data))       # 30.0
print(statistics.median(data))     # 30
print(statistics.stdev(data))      # Standard deviation

# Python 3.10+ Match-Case statement
def process_status(status_code):
    match status_code:
        case 200:
            return "Success"
        case 404:
            return "Not Found"
        case 500 | 502 | 503:
            return "Server Error"
        case _:
            return "Unknown Status"

print(process_status(200))  # Success
print(process_status(500))  # Server Error

# Pattern matching with data structures
def analyze_point(point):
    match point:
        case (0, 0):
            return "Origin"
        case (0, y):
            return f"On Y-axis at {y}"
        case (x, 0):
            return f"On X-axis at {x}"
        case (x, y):
            return f"Point at ({x}, {y})"

print(analyze_point((0, 0)))   # Origin
print(analyze_point((5, 0)))   # On X-axis at 5
print(analyze_point((3, 4)))   # Point at (3, 4)

# Python 3.10+ provides more helpful error messages

# Before Python 3.10:
# NameError: name 'value' is not defined

# Python 3.10+:
# NameError: name 'value' is not defined. Did you mean: 'values'?

# Syntax error improvements
# Python 3.10 shows the exact location of syntax errors
# with better suggestions and context

# Python 3.10+ type hinting with | operator
def process_data(value: int | str) -> str:
    if isinstance(value, int):
        return f"Number: {value}"
    return f"Text: {value}"

# Before Python 3.10:
# from typing import Union
# def process_data(value: Union[int, str]) -> str:

# Multiple types
def calculate(x: int | float, y: int | float) -> int | float:
    return x + y

print(calculate(5, 3))      # 8
print(calculate(5.5, 2.3))  # 7.8

# Python 3.10+ allows parentheses for better formatting
with (
    open("file1.txt", "r") as f1,
    open("file2.txt", "r") as f2,
    open("output.txt", "w") as output
):
    content1 = f1.read()
    content2 = f2.read()
    output.write(content1 + content2)