# Examples
x = 42           # int
y = 3.14         # float
z = 2 + 3j       # complex
name = "Python"  # str
items = [1,2,3]  # list
point = (1,2)    # tuple
data = {"a": 1}  # dict
unique = {1,2,3} # set
flag = True      # bool
nothing = None   # NoneType

# List — mutable
my_list = [1, 2, 3]
my_list[0] = 10      # Works fine
my_list.append(4)    # Works fine

# Tuple — immutable
my_tuple = (1, 2, 3)
# my_tuple[0] = 10   # Raises TypeError!

# Dictionary
student = {"name": "Alice", "age": 22}
print(student["name"])  # Alice

# Set
numbers = {1, 2, 3, 3, 4, 4}
print(numbers)  # {1, 2, 3, 4} — duplicates removed

# Value equality (==)
a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)   # True — same values
print(a is b)   # False — different objects in memory

# Identity equality (is)
x = "hello"
y = x           # y points to the SAME object as x
print(x is y)   # True — same object

# Special case: Small integers and strings are cached
p = 256
q = 256
print(p is q)   # True — Python caches small integers (-5 to 256)

p = 1000
q = 1000
print(p is q)   # False — large integers are not cached

# Mutable — can change
my_list = [1, 2, 3]
my_list[0] = 100    # Works!
print(my_list)      # [100, 2, 3]

# Immutable — cannot change
my_string = "hello"
# my_string[0] = "H"  # Raises TypeError!

# When you "change" a string, a NEW object is created
my_string = "Hello"  # New string object — original "hello" is unchanged

def sum_all(*args):
    return sum(args)

print(sum_all(1, 2, 3))        # 6
print(sum_all(10, 20, 30, 40)) # 100

def display_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

display_info(name="Alice", age=25, city="Hyderabad")
# name: Alice
# age: 25
# city: Hyderabad

def mixed_function(*args, **kwargs):
    print("Positional args:", args)
    print("Keyword args:", kwargs)

mixed_function(1, 2, 3, name="Alice", age=25)
# Positional args: (1, 2, 3)
# Keyword args: {'name': 'Alice', 'age': 25}

list1 = [1, 2, 3]
list2 = [1, 2, 3]

# append() — adds the entire list as ONE element
list1.append([4, 5])
print(list1)  # [1, 2, 3, [4, 5]]

# extend() — adds each element individually
list2.extend([4, 5])
print(list2)  # [1, 2, 3, 4, 5]

# Basic decorator
def my_decorator(func):
    def wrapper():
        print("--- Before function call ---")
        func()
        print("--- After function call ---")
    return wrapper

@my_decorator
def say_hello():
    print("Hello, World!")

say_hello()
# Output:
# --- Before function call ---
# Hello, World!
# --- After function call ---

# Practical example: Timing decorator
import time

def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} took {end - start:.4f} seconds")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)
    print("Function complete!")

slow_function()
# Function complete!
# slow_function took 1.0012 seconds

# Regular function — stores ALL values in memory
def get_squares_list(n):
    return [x**2 for x in range(n)]

# Generator function — produces values one at a time
def get_squares_generator(n):
    for x in range(n):
        yield x**2

# Memory comparison
import sys
list_result = get_squares_list(10000)
gen_result = get_squares_generator(10000)

print(sys.getsizeof(list_result))   # ~87,624 bytes
print(sys.getsizeof(gen_result))    # 112 bytes (!)

# Using a generator
gen = get_squares_generator(5)
print(next(gen))  # 0
print(next(gen))  # 1
print(next(gen))  # 4

# Or loop through it
for square in get_squares_generator(5):
    print(square)  # 0, 1, 4, 9, 16

# Regular loop
squares = []
for x in range(1, 6):
    squares.append(x**2)
print(squares)  # [1, 4, 9, 16, 25]

# List comprehension — same result, one line
squares = [x**2 for x in range(1, 6)]
print(squares)  # [1, 4, 9, 16, 25]

# With condition
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print(even_squares)  # [4, 16, 36, 64, 100]

# Nested list comprehension
matrix = [[i*j for j in range(1, 4)] for i in range(1, 4)]
print(matrix)
# [[1, 2, 3], [2, 4, 6], [3, 6, 9]]

# Dictionary comprehension
word_lengths = {word: len(word) for word in ["Python", "Java", "JavaScript"]}
print(word_lengths)  # {'Python': 6, 'Java': 4, 'JavaScript': 10}

# Set comprehension
unique_lengths = {len(word) for word in ["cat", "dog", "elephant", "ant"]}
print(unique_lengths)  # {3, 8}

import copy

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

# Shallow copy
shallow = copy.copy(original)
shallow[0][0] = 99
print(original)  # [[99, 2, 3], [4, 5, 6]] — ORIGINAL IS AFFECTED!
print(shallow)   # [[99, 2, 3], [4, 5, 6]]

# Deep copy
original2 = [[1, 2, 3], [4, 5, 6]]
deep = copy.deepcopy(original2)
deep[0][0] = 99
print(original2) # [[1, 2, 3], [4, 5, 6]] — Original unchanged
print(deep)      # [[99, 2, 3], [4, 5, 6]]

# For CPU-bound tasks — use multiprocessing, not threading
from multiprocessing import Pool

def square(n):
    return n ** 2

with Pool(4) as p:  # 4 parallel processes
    results = p.map(square, range(10))
print(results)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

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

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

# Equivalent list comprehension
squares = [x**2 for x in numbers]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Filter even numbers
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4, 6, 8, 10]

from functools import reduce

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

# Sum all numbers
total = reduce(lambda x, y: x + y, numbers)
print(total)  # 15  (1+2=3, 3+3=6, 6+4=10, 10+5=15)

# Find maximum
maximum = reduce(lambda x, y: x if x > y else y, numbers)
print(maximum)  # 5

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    # Instance method — has access to instance via self
    def to_fahrenheit(self):
        return (self.celsius * 9/5) + 32

    # Class method — has access to class via cls
    @classmethod
    def from_fahrenheit(cls, fahrenheit):
        celsius = (fahrenheit - 32) * 5/9
        return cls(celsius)  # Creates new instance

    # Static method — no access to class or instance
    @staticmethod
    def is_valid_temperature(celsius):
        return celsius >= -273.15  # Above absolute zero

# Usage
temp1 = Temperature(100)
print(temp1.to_fahrenheit())       # 212.0

temp2 = Temperature.from_fahrenheit(212)
print(temp2.celsius)               # 100.0

print(Temperature.is_valid_temperature(-300))  # False

def divide_numbers(a, b):
    try:
        # Code that might raise an exception
        result = a / b
        
    except ZeroDivisionError:
        # Runs if ZeroDivisionError is raised
        print("Error: Cannot divide by zero!")
        return None
        
    except TypeError as e:
        # Runs if TypeError is raised
        print(f"Type Error: {e}")
        return None
        
    except Exception as e:
        # Catches any other exception
        print(f"Unexpected error: {e}")
        return None
        
    else:
        # Runs ONLY if NO exception was raised
        print("Division successful!")
        return result
        
    finally:
        # ALWAYS runs — with or without an exception
        print("Operation complete.")

divide_numbers(10, 2)   # Division successful! → 5.0
divide_numbers(10, 0)   # Error: Cannot divide by zero!
divide_numbers(10, "a") # Type Error: unsupported operand type(s)

class Book:
    def __init__(self, title, author, pages):
        """Constructor — called when creating an object"""
        self.title = title
        self.author = author
        self.pages = pages

    def __str__(self):
        """Human-readable string — called by print() and str()"""
        return f"'{self.title}' by {self.author}"

    def __repr__(self):
        """Developer/debug representation — called in console"""
        return f"Book(title='{self.title}', author='{self.author}', pages={self.pages})"

    def __len__(self):
        """Called by len()"""
        return self.pages

    def __eq__(self, other):
        """Called by == operator"""
        return self.title == other.title and self.author == other.author

    def __lt__(self, other):
        """Called by < operator"""
        return self.pages < other.pages

book1 = Book("Python Crash Course", "Eric Matthes", 544)
book2 = Book("Fluent Python", "Luciano Ramalho", 792)

print(str(book1))    # 'Python Crash Course' by Eric Matthes
print(repr(book1))   # Book(title='Python Crash Course', ...)
print(len(book1))    # 544
print(book1 < book2) # True

class MyClass:
    def __new__(cls, *args, **kwargs):
        print(f"1. __new__ called — creating instance")
        instance = super().__new__(cls)
        return instance

    def __init__(self, value):
        print(f"2. __init__ called — initializing instance")
        self.value = value

obj = MyClass(42)
# Output:
# 1. __new__ called — creating instance
# 2. __init__ called — initializing instance

def outer_function(message):
    # 'message' is a free variable captured by the closure
    def inner_function():
        print(f"Message: {message}")  # Remembers 'message'
    return inner_function

greet_alice = outer_function("Hello, Alice!")
greet_bob = outer_function("Hello, Bob!")

greet_alice()  # Message: Hello, Alice!
greet_bob()    # Message: Hello, Bob!

# Practical use: Counter using closure
def make_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

counter1 = make_counter()
print(counter1())  # 1
print(counter1())  # 2
print(counter1())  # 3

counter2 = make_counter()
print(counter2())  # 1 (independent counter)

# Threading — good for I/O-bound (network requests, file I/O)
import threading
import time

def download_file(filename):
    print(f"Downloading {filename}...")
    time.sleep(2)  # Simulate network delay
    print(f"{filename} downloaded!")

threads = [threading.Thread(target=download_file, args=(f"file{i}.txt",))
           for i in range(3)]

for t in threads:
    t.start()
for t in threads:
    t.join()

# Multiprocessing — good for CPU-bound (data processing, computation)
from multiprocessing import Pool

def compute_square(n):
    return n ** 2

with Pool(4) as pool:  # 4 CPU cores
    results = pool.map(compute_square, range(1, 11))
print(results)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

import asyncio
import time

async def fetch_data(name, delay):
    print(f"Starting to fetch {name}...")
    await asyncio.sleep(delay)  # Non-blocking wait
    print(f"Finished fetching {name}")
    return f"{name} data"

async def main():
    start = time.time()
    
    # Run concurrently using gather
    results = await asyncio.gather(
        fetch_data("Users", 2),
        fetch_data("Products", 1),
        fetch_data("Orders", 3)
    )
    
    end = time.time()
    print(f"\nAll done in {end - start:.1f}s")
    print(results)

asyncio.run(main())
# Completes in ~3s instead of 6s (sequential)

import sys

x = [1, 2, 3]
print(sys.getrefcount(x))  # Reference count (at least 2 — x and the getrefcount argument)

y = x            # Reference count increases
del x            # Reference count decreases
# When count reaches 0, memory is freed

import gc

# Enable/disable garbage collector
gc.enable()
gc.disable()

# Force a garbage collection
gc.collect()

# Check garbage collection stats
print(gc.get_stats())

# Regular class — uses __dict__
class RegularPoint:
    def __init__(self, x, y):
        self.x = x
        self.y = y

# Class with __slots__
class SlottedPoint:
    __slots__ = ['x', 'y']  # Only these attributes allowed
    
    def __init__(self, x, y):
        self.x = x
        self.y = y

import sys
p1 = RegularPoint(1, 2)
p2 = SlottedPoint(1, 2)

print(sys.getsizeof(p1))  # ~152 bytes
print(sys.getsizeof(p2))  # ~56 bytes (much less!)

# Restriction: Cannot add new attributes dynamically
# p2.z = 3  # Raises AttributeError!

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

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def get_balance(self):
        return self.__balance

account = BankAccount(1000)
account.deposit(500)
print(account.get_balance())  # 1500
# print(account.__balance)   # AttributeError — private!

class Animal:
    def speak(self):
        return "Some sound"

class Dog(Animal):
    def speak(self):  # Override
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

animals = [Dog(), Cat(), Animal()]
for animal in animals:
    print(animal.speak())  # Each responds differently

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):  # Must be implemented by subclasses
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14159 * self.radius ** 2

class Flyable:
    def move(self):
        return "Flying"

class Swimmable:
    def move(self):
        return "Swimming"

class Duck(Flyable, Swimmable):  # Inherits from both
    pass

duck = Duck()
print(duck.move())  # "Flying" — Flyable is checked first

print(Duck.__mro__)
# (<class 'Duck'>, <class 'Flyable'>, <class 'Swimmable'>, <class 'object'>)

# Or use mro() method
print(Duck.mro())

class A:
    def method(self):
        return "A"

class B(A):
    def method(self):
        return "B"

class C(A):
    def method(self):
        return "C"

class D(B, C):  # Diamond inheritance
    pass

print(D().method())  # "B" — follows MRO: D → B → C → A
print(D.__mro__)     # (D, B, C, A, object)

s = "Python Interview"

# Method 1: Slicing (most Pythonic)
print(s[::-1])           # "weivretnI nohtyP"

# Method 2: reversed() + join
print("".join(reversed(s)))

# Method 3: Loop
reversed_str = ""
for char in s:
    reversed_str = char + reversed_str
print(reversed_str)

def is_palindrome(s):
    # Clean the string: lowercase, remove non-alphanumeric
    cleaned = ''.join(c.lower() for c in s if c.isalnum())
    return cleaned == cleaned[::-1]

print(is_palindrome("racecar"))    # True
print(is_palindrome("A man a plan a canal Panama"))  # True
print(is_palindrome("hello"))      # False

def find_duplicates(lst):
    seen = set()
    duplicates = set()
    for item in lst:
        if item in seen:
            duplicates.add(item)
        else:
            seen.add(item)
    return list(duplicates)

numbers = [1, 2, 3, 2, 4, 3, 5, 1]
print(find_duplicates(numbers))  # [1, 2, 3]

# Using Counter (most Pythonic)
from collections import Counter
counts = Counter(numbers)
duplicates = [item for item, count in counts.items() if count > 1]
print(duplicates)  # [1, 2, 3]

students = [
    {"name": "Alice", "grade": 85},
    {"name": "Bob", "grade": 92},
    {"name": "Charlie", "grade": 78},
    {"name": "Diana", "grade": 95}
]

# Sort by grade (ascending)
sorted_students = sorted(students, key=lambda s: s["grade"])

# Sort by grade (descending)
sorted_students_desc = sorted(students, key=lambda s: s["grade"], reverse=True)

# Using itemgetter (more efficient for large datasets)
from operator import itemgetter
sorted_students = sorted(students, key=itemgetter("grade"))

print(sorted_students_desc)
# [Diana:95, Bob:92, Alice:85, Charlie:78]

def word_frequency(text):
    from collections import Counter
    words = text.lower().split()
    return Counter(words)

text = "python is great python is easy python is powerful"
freq = word_frequency(text)
print(freq)
# Counter({'python': 3, 'is': 3, 'great': 1, 'easy': 1, 'powerful': 1})

# Most common words
print(freq.most_common(2))
# [('python', 3), ('is', 3)]

import numpy as np

# Create arrays
arr = np.array([1, 2, 3, 4, 5])
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Array operations (vectorized — no loops needed)
print(arr * 2)          # [2, 4, 6, 8, 10]
print(arr ** 2)         # [1, 4, 9, 16, 25]
print(np.sqrt(arr))     # [1., 1.41, 1.73, 2., 2.23]
print(np.mean(arr))     # 3.0
print(np.sum(matrix))   # 45

# Broadcasting
arr2 = np.array([10, 20, 30, 40, 50])
print(arr + arr2)        # [11, 22, 33, 44, 55]

import pandas as pd

# Create a DataFrame
data = {
    "Name": ["Alice", "Bob", "Charlie", "Diana"],
    "Age": [25, 30, 35, 28],
    "Salary": [60000, 80000, 95000, 72000],
    "Department": ["IT", "Finance", "IT", "HR"]
}
df = pd.DataFrame(data)

# Basic operations
print(df.head())           # First 5 rows
print(df.shape)            # (4, 4) — rows, columns
print(df.describe())       # Statistical summary
print(df.dtypes)           # Data types of each column

# Filtering
it_team = df[df["Department"] == "IT"]
high_salary = df[df["Salary"] > 70000]

# Groupby and aggregation
avg_salary = df.groupby("Department")["Salary"].mean()
print(avg_salary)

# Sorting
sorted_df = df.sort_values("Salary", ascending=False)

import pandas as pd

df = pd.DataFrame({
    "Name": ["Alice", "Bob", "Charlie"],
    "Score": [85, 92, 78]
}, index=["row1", "row2", "row3"])

# loc — use labels
print(df.loc["row1"])           # Row with label "row1"
print(df.loc["row1", "Name"])   # "Alice"
print(df.loc["row1":"row2"])    # Rows row1 to row2 (inclusive)

# iloc — use integer positions
print(df.iloc[0])               # First row (position 0)
print(df.iloc[0, 0])            # First row, first column → "Alice"
print(df.iloc[0:2])             # Rows 0 to 1 (exclusive of 2)

names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]
combined = list(zip(names, scores))
# [('Alice', 85), ('Bob', 92), ('Charlie', 78)]

fruits = ["apple", "banana", "cherry"]
for i, fruit in enumerate(fruits, start=1):
    print(f"{i}. {fruit}")
# 1. apple, 2. banana, 3. cherry

fs = frozenset([1, 2, 3])
d = {fs: "value"}  # Works! Regular set would raise TypeError

def main():
    print("Running directly")

if __name__ == "__main__":
    main()  # Only runs when script is executed directly

class Circle:
    def __init__(self, radius):
        self._radius = radius
    
    @property
    def area(self):
        return 3.14159 * self._radius ** 2

c = Circle(5)
print(c.area)  # 78.54 — called like attribute, not c.area()

# File is automatically closed even if an exception occurs
with open("file.txt", "w") as f:
    f.write("Hello!")
# File is closed here automatically

a, *b, c = [1, 2, 3, 4, 5]
print(a)  # 1
print(b)  # [2, 3, 4]
print(c)  # 5

# Merging lists
list1 = [1, 2, 3]
list2 = [4, 5, 6]
merged = [*list1, *list2]  # [1, 2, 3, 4, 5, 6]

x = None
if x is None:    # Correct
    print("x is None")
if x == None:    # Works but not recommended
    print("x equals None")

from collections import Counter, defaultdict, OrderedDict, deque, namedtuple

# Counter — count occurrences
c = Counter("mississippi")
print(c)  # Counter({'s': 4, 'i': 4, 'p': 2, 'm': 1})

# defaultdict — dict with default values for missing keys
dd = defaultdict(int)  # Default value is 0 for int
dd["count"] += 1       # No KeyError!
print(dd["count"])     # 1
print(dd["missing"])   # 0 — default value, no error

# deque — double-ended queue (efficient append/pop from both ends)
d = deque([1, 2, 3])
d.appendleft(0)    # Add to left: [0, 1, 2, 3]
d.append(4)        # Add to right: [0, 1, 2, 3, 4]
d.popleft()        # Remove from left: [1, 2, 3, 4]

# namedtuple — tuple with named fields
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(p.x, p.y)    # 10 20
print(p[0], p[1])  # 10 20 — still accessible by index