# This is a comment in Python
print("Hello, World!")
# Output: Hello, World!

if True:
    print("This is indented correctly")  # 4 spaces
    print("Same block")
print("Back to top level")

# Single-line comment

\"\"\"
This is a multi-line comment
or docstring used for documentation
\"\"\"

# Variable assignment
name = "Alice"
age = 25
height = 5.7
is_student = True

# Multiple assignment
x, y, z = 10, 20, 30

# Same value to multiple variables
a = b = c = 0

# Implicit (automatic) conversion
result = 5 + 2.0   # int + float = float (7.0)

# Explicit (manual) conversion
x = int("42")       # str -> int
y = float(10)       # int -> float
z = str(3.14)       # float -> str
b = bool(0)         # int -> bool (False)

# Check type
print(type(x))      # <class 'int'>

# String creation
single = 'Hello'
double = "World"
multi  = \"\"\"Multi
line\"\"\"

# String methods
text = "  Python Programming  "
print(text.strip())        # "Python Programming"
print(text.lower())        # "  python programming  "
print(text.upper())        # "  PYTHON PROGRAMMING  "
print(text.replace("Python", "Java"))  # "  Java Programming  "
print(text.split())        # ['Python', 'Programming']

# f-strings (modern string formatting)
name = "Alice"
age = 25
print(f"My name is {name} and I am {age} years old.")

# String slicing
s = "Python"
print(s[0])     # P
print(s[-1])    # n
print(s[0:3])   # Pyt
print(s[::-1])  # nohtyP (reversed)

x, y = 10, 20
print(x == y)   # False  (equal)
print(x != y)   # True   (not equal)
print(x > y)    # False  (greater than)
print(x < y)    # True   (less than)
print(x >= 10)  # True   (greater than or equal)
print(x <= 5)   # False  (less than or equal)

a, b = True, False
print(a and b)   # False — both must be True
print(a or b)    # True  — at least one True
print(not a)     # False — negation

# Practical example
age = 20
has_id = True
can_enter = age >= 18 and has_id
print(can_enter)  # True

score = 78

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}")  # Your grade is: C

age = 22
has_license = True

if age >= 18:
    if has_license:
        print("You can drive!")
    else:
        print("You need a license.")
else:
    print("You are too young to drive.")

# Syntax: value_if_true if condition else value_if_false
x = 15
result = "Even" if x % 2 == 0 else "Odd"
print(result)  # Odd

day = "Monday"

match day:
    case "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday":
        print("Weekday")
    case "Saturday" | "Sunday":
        print("Weekend")
    case _:
        print("Unknown day")

# Iterating over a range
for i in range(5):
    print(i)       # 0, 1, 2, 3, 4

# range(start, stop, step)
for i in range(1, 10, 2):
    print(i)       # 1, 3, 5, 7, 9

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

# Iterating with index
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

count = 0
while count < 5:
    print(f"Count: {count}")
    count += 1

# Infinite loop with break
while True:
    user_input = input("Type quit to exit: ")
    if user_input.lower() == "quit":
        break
    print(f"You entered: {user_input}")

# break — exits the loop entirely
for i in range(10):
    if i == 5:
        break
    print(i)   # 0, 1, 2, 3, 4

# continue — skips the current iteration
for i in range(10):
    if i % 2 == 0:
        continue
    print(i)   # 1, 3, 5, 7, 9

# pass — placeholder, does nothing
for i in range(5):
    pass       # Placeholder for future code

# Traditional approach
squares = []
for x in range(10):
    squares.append(x ** 2)

# List comprehension (Pythonic way)
squares = [x ** 2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# With condition
evens = [x for x in range(20) if x % 2 == 0]
print(evens)    # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

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

message = greet("Alice")
print(message)  # Hello, Alice!

# Default parameters
def power(base, exponent=2):
    return base ** exponent

print(power(3))      # 9  (uses default exponent=2)
print(power(2, 10))  # 1024

# Keyword arguments
print(power(exponent=3, base=5))  # 125

# *args — variable number of positional arguments
def add_all(*args):
    return sum(args)
print(add_all(1, 2, 3, 4, 5))  # 15

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

display_info(name="Alice", age=25, city="Delhi")

# Lambda: anonymous single-expression function
square = lambda x: x ** 2
print(square(7))  # 49

# Lambda with sorted()
students = [("Alice", 85), ("Bob", 72), ("Carol", 91)]
students.sort(key=lambda s: s[1], reverse=True)
print(students)  # [('Carol', 91), ('Alice', 85), ('Bob', 72)]

total = 0  # Global variable

def add(n):
    global total      # Access the global variable
    total += n

add(5)
add(10)
print(total)  # 15

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

# Access
print(fruits[0])       # apple
print(fruits[-1])      # cherry

# Modify
fruits[1] = "blueberry"

# Methods
fruits.append("date")  # Add to end
fruits.insert(1, "avocado")  # Insert at index
fruits.remove("apple") # Remove by value
popped = fruits.pop()  # Remove and return last
fruits.sort()          # Sort in place
fruits.reverse()       # Reverse in place
print(len(fruits))     # Length

coordinates = (10.5, 20.3)
rgb = (255, 128, 0)

# Access (same as list)
print(coordinates[0])  # 10.5

# Unpacking
x, y = coordinates
print(x, y)  # 10.5 20.3

# Tuples can be used as dict keys (lists cannot)
locations = {(0, 0): "origin", (1, 0): "right"}

colors = {"red", "green", "blue", "red"}
print(colors)  # {"red", "green", "blue"} — duplicate removed

# Set operations
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

print(a | b)   # Union:        {1,2,3,4,5,6}
print(a & b)   # Intersection: {3,4}
print(a - b)   # Difference:   {1,2}
print(a ^ b)   # Symmetric:    {1,2,5,6}

student = {
    "name": "Alice",
    "age": 20,
    "grade": "A",
}

# Access
print(student["name"])          # Alice
print(student.get("score", 0))  # 0 (default if key missing)

# Modify
student["age"] = 21
student["city"] = "Mumbai"

# Iteration
for key, value in student.items():
    print(f"{key}: {value}")

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

# Using "with" statement (recommended — auto-closes file)
with open("example.txt", "w") as file:
    file.write("Hello, World!\n")
    file.write("Python File Handling\n")

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

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

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

# Read all lines as a list
with open("example.txt", "r") as file:
    lines = file.readlines()

import json

# Write JSON
data = {"name": "Alice", "age": 25, "skills": ["Python", "ML"]}

with open("data.json", "w") as f:
    json.dump(data, f, indent=4)

# Read JSON
with open("data.json", "r") as f:
    loaded = json.load(f)
    print(loaded["name"])  # Alice

class Dog:
    # Class attribute (shared by all instances)
    species = "Canis familiaris"

    # Constructor method
    def __init__(self, name, breed, age):
        self.name = name    # Instance attribute
        self.breed = breed
        self.age = age

    # Instance method
    def bark(self):
        return f"{self.name} says: Woof!"

    def description(self):
        return f"{self.name} is a {self.age}-year-old {self.breed}."

    # String representation
    def __str__(self):
        return self.description()

# Create objects (instances)
dog1 = Dog("Buddy", "Labrador", 3)
dog2 = Dog("Max", "Poodle", 5)

print(dog1.bark())         # Buddy says: Woof!
print(dog2.description())  # Max is a 5-year-old Poodle.

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("Subclass must implement this")

class Cat(Animal):     # Cat inherits from Animal
    def speak(self):
        return f"{self.name} says: Meow!"

class Dog(Animal):
    def speak(self):
        return f"{self.name} says: Woof!"

animals = [Cat("Whiskers"), Dog("Rex"), Cat("Luna")]
for animal in animals:
    print(animal.speak())

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # Private attribute (double underscore)

    @property
    def balance(self):            # Getter
        return self.__balance

    @balance.setter
    def balance(self, amount):    # Setter with validation
        if amount >= 0:
            self.__balance = amount
        else:
            raise ValueError("Balance cannot be negative")

acc = BankAccount(1000)
print(acc.balance)    # 1000
acc.balance = 1500
print(acc.balance)    # 1500

try:
    numerator = int(input("Enter numerator: "))
    denominator = int(input("Enter denominator: "))
    result = numerator / denominator

except ZeroDivisionError:
    print("Error: Cannot divide by zero!")

except ValueError:
    print("Error: Please enter valid integers!")

else:
    # Runs only if no exception occurred
    print(f"Result: {result}")

finally:
    # Always runs (cleanup code)
    print("Execution complete.")

class InsufficientFundsError(Exception):
    \"\"\"Custom exception for bank operations.\"\"\"
    def __init__(self, amount, balance):
        self.amount = amount
        self.balance = balance
        super().__init__(f"Cannot withdraw {amount}. Balance is {balance}.")

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

try:
    new_balance = withdraw(100, 200)
except InsufficientFundsError as e:
    print(f"Error: {e}")

# Install via pip
# pip install numpy

import numpy as np

import numpy as np

# From a Python list
a = np.array([1, 2, 3, 4, 5])
print(a)          # [1 2 3 4 5]
print(a.dtype)    # int64

# 2D Array (Matrix)
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(matrix.shape)  # (3, 3)

# Special arrays
print(np.zeros((3, 4)))        # 3x4 matrix of zeros
print(np.ones((2, 3)))         # 2x3 matrix of ones
print(np.eye(3))               # 3x3 identity matrix
print(np.arange(0, 10, 2))     # [0 2 4 6 8]
print(np.linspace(0, 1, 5))    # [0. 0.25 0.5 0.75 1.]
print(np.random.rand(3, 3))    # 3x3 random floats [0,1)

a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])

# Element-wise operations
print(a + b)      # [11 22 33 44]
print(a * b)      # [10 40 90 160]
print(a ** 2)     # [1 4 9 16]
print(b / 10)     # [1. 2. 3. 4.]

# Broadcasting
matrix = np.array([[1, 2, 3], [4, 5, 6]])
print(matrix + 10)  # Adds 10 to every element

# Dot product / Matrix multiplication
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print(np.dot(A, B))
# [[19 22]
#  [43 50]]

data = np.array([4, 7, 2, 9, 1, 5, 8, 3, 6])

print(np.min(data))     # 1
print(np.max(data))     # 9
print(np.mean(data))    # 5.0
print(np.median(data))  # 5.0
print(np.std(data))     # Standard deviation
print(np.sum(data))     # 45
print(np.sort(data))    # [1 2 3 4 5 6 7 8 9]
print(np.argmax(data))  # Index of max value: 3

# Reshaping
arr = np.arange(12)
reshaped = arr.reshape(3, 4)
print(reshaped)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

# Install via pip
# pip install pandas

import pandas as pd
import numpy as np

# A 1D labeled array
scores = pd.Series([85, 92, 78, 90, 88],
                   index=["Alice", "Bob", "Carol", "Dave", "Eve"])

print(scores)
# Alice    85
# Bob      92

print(scores["Alice"])   # 85
print(scores.mean())     # 86.6
print(scores[scores > 88])  # Filter: Bob 92, Dave 90

# A 2D labeled table
data = {
    "Name": ["Alice", "Bob", "Carol", "Dave"],
    "Age":  [24, 30, 22, 35],
    "Dept": ["IT", "HR", "IT", "Finance"],
    "Salary": [60000, 55000, 62000, 70000]
}

df = pd.DataFrame(data)
print(df)

# Basic inspection
print(df.shape)        # (4, 4)
print(df.dtypes)       # Data types per column
print(df.describe())   # Statistical summary
print(df.head(3))      # First 3 rows
print(df.tail(2))      # Last 2 rows

# Select column
print(df["Name"])
print(df[["Name", "Salary"]])  # Multiple columns

# Select rows by index
print(df.iloc[0])       # First row (integer location)
print(df.loc[2])        # Row with label/index 2

# Filtering rows
it_staff = df[df["Dept"] == "IT"]
high_earners = df[df["Salary"] > 60000]
combined = df[(df["Dept"] == "IT") & (df["Age"] < 30)]

# Add new column
df["Tax"] = df["Salary"] * 0.1

# Apply function
df["Name_Upper"] = df["Name"].apply(str.upper)

# Group by
dept_avg = df.groupby("Dept")["Salary"].mean()
print(dept_avg)

# Sort
df_sorted = df.sort_values("Salary", ascending=False)

# Drop column
df.drop(columns=["Tax"], inplace=True)

# Handle missing values
df.dropna()              # Remove rows with NaN
df.fillna(0)             # Fill NaN with 0
df.isnull().sum()        # Count missing per column

# CSV
df = pd.read_csv("data.csv")
df.to_csv("output.csv", index=False)

# Excel
df = pd.read_excel("data.xlsx", sheet_name="Sheet1")
df.to_excel("output.xlsx", index=False)

# JSON
df = pd.read_json("data.json")
df.to_json("output.json", orient="records")