Python & C++ Syntax + DSA Mastery

# Variables
x = 5          # int
y = 3.14       # float
z = 2 + 3j     # complex

# Type conversion
int(3.7)       # 3 (truncates)
float(5)       # 5.0
str(42)        # '42'

# Multiple assignment
a, b, c = 1, 2, 3
x = y = z = 0

# String literals
s1 = 'hello'
s2 = "world"
s3 = '''multi
line'''

# String operations
s = "Hello World"
len(s)              # 11
s[0]                # 'H'
s[1:4]              # 'ell'
s.upper()           # 'HELLO WORLD'
s.split()           # ['Hello', 'World']
" ".join(['a', 'b']) # 'a b'

# String formatting
f"Value: {x}"       # f-strings (Python 3.6+)
"Value: {}".format(x)
"Value: %s" % x

# List creation
lst = [1, 2, 3]
empty = []
nested = [[1, 2], [3, 4]]

# List operations
lst.append(4)       # [1, 2, 3, 4]
lst.insert(0, 0)    # [0, 1, 2, 3, 4]
lst.pop()           # removes last element
lst.remove(2)       # removes first occurrence of 2
lst.sort()          # sorts in place
lst.reverse()       # reverses in place

# List comprehensions
squares = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]
evens = [x for x in lst if x % 2 == 0]

# Tuple creation
tup = (1, 2, 3)
single = (5,)      # comma required for single element
empty = ()
tup = 1, 2, 3      # parentheses optional

# Tuple operations
tup[0]             # 1
tup[1:3]           # (2, 3)
len(tup)           # 3
1 in tup           # True

# Tuple unpacking
a, b, c = tup
first, *rest = tup  # first=1, rest=[2, 3]
*head, last = tup   # head=[1, 2], last=3

# Dictionary creation
d = {'a': 1, 'b': 2}
d = dict(a=1, b=2)
d = dict([('a', 1), ('b', 2)])

# Dictionary operations
d['c'] = 3         # add/update
d.get('a', 0)      # 1 (safe access)
d.pop('b')         # removes and returns value
d.keys()           # dict_keys(['a', 'c'])
d.values()          # dict_values([1, 3])
d.items()          # dict_items([('a', 1), ('c', 3)])

# Dict comprehensions
squares = {x: x**2 for x in range(5)}  # {0: 0, 1: 1, 4: 4, ...}

# Set creation
s = {1, 2, 3}
s = set([1, 2, 2, 3])  # {1, 2, 3} (duplicates removed)
empty = set()

# Set operations
s.add(4)           # {1, 2, 3, 4}
s.remove(2)        # {1, 3, 4}
s.discard(5)       # no error if not present
2 in s             # True

# Set algebra
a = {1, 2, 3}
b = {2, 3, 4}
a | b              # union: {1, 2, 3, 4}
a & b              # intersection: {2, 3}
a - b              # difference: {1}
a ^ b              # symmetric difference: {1, 4}

# Boolean values
True, False

# Truthy/falsy values
bool(0)        # False
bool(1)        # True
bool([])       # False
bool([1])      # True
bool('')       # False
bool('hi')     # True
bool(None)     # False

# Boolean operations
and, or, not

# Short-circuit evaluation
x = 5
y = 0
result = x > 0 and y != 0  # False (y != 0 not evaluated)

# Basic if/else
if condition:
    # do something
elif another_condition:
    # do something else
else:
    # default case

# Ternary operator
result = x if condition else y

# Multiple conditions
if x > 0 and y > 0:
    print("Both positive")

# Membership testing
if item in collection:
    print("Found it")

# for loop
for item in iterable:
    if condition:
        continue  # skip to next iteration
    if exit_condition:
        break     # exit loop
    # process item

# while loop
while condition:
    # do something
    if exit_condition:
        break

# enumerate for index
for i, item in enumerate(items):
    print(f"Index {i}: {item}")

# range for numbers
for i in range(5):      # 0, 1, 2, 3, 4
for i in range(1, 6):   # 1, 2, 3, 4, 5
for i in range(0, 10, 2): # 0, 2, 4, 6, 8

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

# Dict comprehension
squares_dict = {x: x**2 for x in range(5)}

# Set comprehension
unique_squares = {x**2 for x in [-2, -1, 0, 1, 2]}

# Nested comprehensions
matrix = [[i*j for j in range(3)] for i in range(3)]

# Multiple conditions
filtered = [x for x in data if x > 0 and x < 100]

# Complex expressions
processed = [func(item) for item in data if condition(item)]

# Basic function
def greet(name):
    return f"Hello, {name}!"

# Function with default arguments
def power(base, exponent=2):
    return base ** exponent

# Multiple return values
def divide(a, b):
    quotient = a // b
    remainder = a % b
    return quotient, remainder

# Unpacking return values
q, r = divide(10, 3)

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

sum_all(1, 2, 3, 4)  # 10

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

print_info(name="Alice", age=30)

# Mixed parameters
def func(required, *args, default=None, **kwargs):
    pass

# Calling with unpacking
args = (1, 2, 3)
kwargs = {'key': 'value'}
func(*args, **kwargs)

# Basic lambda
square = lambda x: x ** 2
square(5)  # 25

# Lambda with multiple arguments
add = lambda x, y: x + y

# Common use cases
numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, numbers))
evens = list(filter(lambda x: x % 2 == 0, numbers))

# Sorting with key function
points = [(1, 2), (3, 1), (5, 0)]
points.sort(key=lambda p: p[1])  # sort by y-coordinate

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

# Fibonacci
def fib(n):
    if n <= 1:
        return n
    return fib(n-1) + fib(n-2)

# Tail recursion (Python doesn't optimize)
def tail_factorial(n, acc=1):
    if n <= 1:
        return acc
    return tail_factorial(n-1, n * acc)

# Memoization for performance
from functools import lru_cache

@lru_cache(maxsize=None)
def fib_memo(n):
    if n <= 1:
        return n
    return fib_memo(n-1) + fib_memo(n-2)

# Basic class
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def greet(self):
        return f"Hello, I'm {self.name}"

# Creating instances
person = Person("Alice", 30)
person.greet()  # "Hello, I'm Alice"

# Class vs instance attributes
class Counter:
    count = 0  # class attribute
    
    def __init__(self):
        self.value = 0  # instance attribute
        Counter.count += 1

# Single inheritance
class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        return "Some sound"

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

# Multiple inheritance
class A:
    def method(self):
        return "A"

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

class C(A, B):
    pass

c = C()
c.method()  # "A" (MRO: Method Resolution Order)

# super() for parent calls
class Cat(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
    
    def __str__(self):
        return f"Vector({self.x}, {self.y})"
    
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"
    
    def __len__(self):
        return 2  # number of components

v1 = Vector(1, 2)
v2 = Vector(3, 4)
v3 = v1 + v2  # Vector(4, 6)
print(v3)     # Vector(4, 6)
len(v3)       # 2

# Import module
import math
math.sqrt(16)  # 4.0

# Import specific items
from math import sqrt, pi
sqrt(16)  # 4.0

# Import with alias
import numpy as np
np.array([1, 2, 3])

# Import all (avoid in production)
from math import *

# Relative imports (in packages)
from .utils import helper  # same package
from ..data import loader  # parent package

# In mymodule.py
print(__name__)  # "__main__" if run directly, "mymodule" if imported

def main():
    print("Running as script")

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

# Usage
# python mymodule.py -> runs main()
# import mymodule -> doesn't run main()

# Reading files
with open('file.txt', 'r') as f:
    content = f.read()        # read all
    lines = f.readlines()     # read lines as list
    line = f.readline()       # read one line

# Writing files
with open('output.txt', 'w') as f:
    f.write("Hello World\n")
    f.writelines(["line1\n", "line2\n"])

# Binary files
with open('data.bin', 'rb') as f:
    data = f.read()

# Context manager ensures file is closed
# Manual closing (avoid)
f = open('file.txt')
try:
    content = f.read()
finally:
    f.close()

# Basic try/except
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")

# Multiple exceptions
try:
    value = int(input("Enter number: "))
except ValueError:
    print("Not a valid number")
except KeyboardInterrupt:
    print("User cancelled")

# Exception with else/finally
try:
    result = risky_operation()
except Exception as e:
    print(f"Error: {e}")
else:
    print("Success!")  # runs if no exception
finally:
    cleanup()  # always runs

# Raising exceptions
if x < 0:
    raise ValueError("x must be non-negative")

# Custom exceptions
class CustomError(Exception):
    pass

# Function decorator
def timer(func):
    def wrapper(*args, **kwargs):
        import time
        start = time.time()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.time() - start:.2f}s")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)

slow_function()  # prints timing

# Decorator with parameters
def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def greet(name):
    print(f"Hello {name}")

# Built-in decorators
class MyClass:
    @property
    def name(self):
        return self._name
    
    @staticmethod
    def utility():
        pass
    
    @classmethod
    def from_string(cls, s):
        return cls(s)

# Generator function
def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

for num in fibonacci(10):
    print(num)

# Generator expression
squares = (x**2 for x in range(10))  # lazy
list(squares)  # [0, 1, 4, 9, ...]

# Memory efficient
def read_large_file(filename):
    with open(filename) as f:
        for line in f:
            yield line.strip()

# Pipeline with generators
data = (line for line in open('file.txt'))
processed = (process(line) for line in data)
filtered = (item for item in processed if condition(item))

# Using context managers
with open('file.txt', 'r') as f:
    content = f.read()

# Custom context manager
class Timer:
    def __enter__(self):
        self.start = time.time()
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.end = time.time()
        print(f"Elapsed: {self.end - self.start:.2f}s")

with Timer():
    do_work()

# contextlib for simple cases
from contextlib import contextmanager

@contextmanager
def temp_dir():
    import tempfile, os
    dir_path = tempfile.mkdtemp()
    try:
        yield dir_path
    finally:
        import shutil
        shutil.rmtree(dir_path)

with temp_dir() as tmp:
    # use tmp directory

from typing import List, Dict, Optional, Union

# Function type hints
def greet(name: str) -> str:
    return f"Hello {name}"

# Complex types
def process_data(data: List[Dict[str, Union[int, str]]]) -> Optional[str]:
    pass

# Generic types
from typing import TypeVar, Generic

T = TypeVar('T')

class Stack(Generic[T]):
    def __init__(self):
        self.items: List[T] = []
    
    def push(self, item: T) -> None:
        self.items.append(item)
    
    def pop(self) -> T:
        return self.items.pop()

# Union types
def add(x: Union[int, float], y: Union[int, float]) -> Union[int, float]:
    return x + y

from dataclasses import dataclass, field
from typing import List

@dataclass
class Person:
    name: str
    age: int
    email: str = ""  # default value
    
    def greet(self):
        return f"Hello, I'm {self.name}"

@dataclass
class AddressBook:
    owner: str
    contacts: List[Person] = field(default_factory=list)
    
    def add_contact(self, person: Person):
        self.contacts.append(person)

# Automatic methods
p1 = Person("Alice", 30, "alice@email.com")
p2 = Person("Bob", 25)
print(p1)  # Person(name='Alice', age=30, email='alice@email.com')
p1 == Person("Alice", 30, "alice@email.com")  # True

# Frozen dataclasses
@dataclass(frozen=True)
class ImmutablePoint:
    x: int
    y: int

point = ImmutablePoint(1, 2)
point.x = 3  # FrozenInstanceError

import itertools

# Infinite iterators
count = itertools.count(10, 2)  # 10, 12, 14, ...
cycle = itertools.cycle('ABC')  # A, B, C, A, B, C, ...
repeat = itertools.repeat(5, 3)  # 5, 5, 5

# Combinatorics
permutations = list(itertools.permutations([1, 2, 3], 2))
# [(1,2), (1,3), (2,1), (2,3), (3,1), (3,2)]

combinations = list(itertools.combinations([1, 2, 3], 2))
# [(1,2), (1,3), (2,3)]

combinations_with_replacement = list(itertools.combinations_with_replacement([1, 2, 3], 2))
# [(1,1), (1,2), (1,3), (2,2), (2,3), (3,3)]

# Grouping and filtering
grouped = itertools.groupby(sorted([1, 1, 2, 2, 3]), key=lambda x: x)
# Groups consecutive equal elements

# Accumulate (prefix sums)
prefix = list(itertools.accumulate([1, 2, 3, 4]))
# [1, 3, 6, 10]

# Chain (flatten)
chained = list(itertools.chain([1, 2], [3, 4], [5]))
# [1, 2, 3, 4, 5]

# Product (Cartesian product)
product = list(itertools.product([1, 2], ['a', 'b']))
# [(1,'a'), (1,'b'), (2,'a'), (2,'b')]

import collections

# Counter - frequency counting
counter = collections.Counter(['a', 'b', 'a', 'c', 'b', 'a'])
# Counter({'a': 3, 'b': 2, 'c': 1})
counter.most_common(2)  # [('a', 3), ('b', 2)]

# defaultdict - dict with default values
dd = collections.defaultdict(int)
dd['key'] += 1  # No KeyError, defaults to 0

dd_list = collections.defaultdict(list)
dd_list['key'].append(1)  # Defaults to []

# deque - double-ended queue
dq = collections.deque([1, 2, 3])
dq.append(4)      # [1, 2, 3, 4]
dq.appendleft(0)  # [0, 1, 2, 3, 4]
dq.pop()          # 4, deque([0, 1, 2, 3])
dq.popleft()      # 0, deque([1, 2, 3])

# namedtuple - tuple with named fields
Point = collections.namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
p.x, p.y  # 1, 2
p[0], p[1]  # 1, 2

# OrderedDict - dict that remembers insertion order (Python < 3.7)
od = collections.OrderedDict()
od['a'] = 1
od['b'] = 2
list(od.keys())  # ['a', 'b']

import bisect

# bisect_left - find insertion point for x
arr = [1, 3, 5, 7, 9]
bisect.bisect_left(arr, 4)  # 2 (insert at index 2)
bisect.bisect_left(arr, 5)  # 2 (already exists)

# bisect_right - find insertion point for x (after equal elements)
bisect.bisect_right(arr, 5)  # 3

# insort - insert while maintaining sorted order
bisect.insort_left(arr, 4)   # arr = [1, 3, 4, 5, 7, 9]
bisect.insort_right(arr, 5)  # arr = [1, 3, 4, 5, 5, 7, 9]

# For custom comparison
import bisect
def bisect_custom(arr, x, key=lambda x: x):
    lo, hi = 0, len(arr)
    while lo < hi:
        mid = (lo + hi) // 2
        if key(arr[mid]) < x:
            lo = mid + 1
        else:
            hi = mid
    return lo

import heapq

# Basic heap operations
heap = []
heapq.heappush(heap, 3)
heapq.heappush(heap, 1)
heapq.heappush(heap, 4)
heapq.heappop(heap)  # 1

# Convert list to heap
arr = [3, 1, 4, 1, 5]
heapq.heapify(arr)  # arr becomes [1, 1, 4, 3, 5]

# Max-heap (using negative values)
max_heap = []
heapq.heappush(max_heap, -3)
heapq.heappush(max_heap, -1)
-heapq.heappop(max_heap)  # 3

# Custom heap with tuples
heap = []
heapq.heappush(heap, (2, 'task2'))
heapq.heappush(heap, (1, 'task1'))
heapq.heappop(heap)  # (1, 'task1')

# nlargest/nsmallest
numbers = [3, 1, 4, 1, 5, 9, 2]
heapq.nlargest(3, numbers)  # [9, 5, 4]
heapq.nsmallest(3, numbers)  # [1, 1, 2]

# Merge sorted iterables
list(heapq.merge([1, 3, 5], [2, 4, 6]))  # [1, 2, 3, 4, 5, 6]

import functools

# lru_cache - memoization decorator
@functools.lru_cache(maxsize=None)
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

# reduce - apply function cumulatively
numbers = [1, 2, 3, 4]
functools.reduce(lambda x, y: x + y, numbers)  # 10
functools.reduce(lambda x, y: x * y, numbers)  # 24

# partial - fix some arguments
def multiply(x, y):
    return x * y

double = functools.partial(multiply, 2)
double(5)  # 10

# cmp_to_key - convert comparison function to key function
def compare(a, b):
    if a < b:
        return -1
    elif a > b:
        return 1
    else:
        return 0

sorted_list = sorted([3, 1, 4, 1, 5], key=functools.cmp_to_key(compare))

# total_ordering - auto-generate comparison methods
@functools.total_ordering
class Person:
    def __init__(self, age):
        self.age = age
    
    def __eq__(self, other):
        return self.age == other.age
    
    def __lt__(self, other):
        return self.age < other.age
    
    # __le__, __gt__, __ge__ auto-generated

import re

# Basic patterns
pattern = r'd+'  # one or more digits
text = "I have 123 apples and 456 bananas"
re.findall(pattern, text)  # ['123', '456']

# Compile for reuse
compiled = re.compile(r'w+')  # word boundaries
words = compiled.findall("Hello world!")  # ['Hello', 'world']

# Match vs Search vs Findall
re.match(r'hello', 'hello world')    # matches at start
re.search(r'world', 'hello world')   # searches anywhere
re.findall(r'd', 'a1b2c3')          # ['1', '2', '3']

# Groups and capturing
pattern = r'(w+) (w+)'
match = re.search(pattern, 'John Doe')
match.groups()  # ('John', 'Doe')
match.group(1)  # 'John'

# Substitution
re.sub(r'd', 'X', 'a1b2c3')  # 'aXbXcX'

# Flags
re.findall(r'hello', 'Hello HELLO', re.IGNORECASE)  # ['Hello', 'HELLO']

# Common patterns
email_pattern = r'[w.-]+@[w.-]+.w+'
phone_pattern = r'(d{3})s*d{3}-d{4}'
url_pattern = r'https?://(?:[-w.])+(?:[:d]+)?(?:/(?:[w/_.])*(?:?(?:[w&=%.])*)?(?:#(?:w*))?)?.*

# Walrus operator (:=) - Python 3.8+
if (n := len(data)) > 0:
    print(f"Data has {n} items")

# Match-case - Python 3.10+
def classify(value):
    match value:
        case int() if value > 0:
            return "positive integer"
        case str():
            return "string"
        case [x, y]:
            return f"pair: {x}, {y}"
        case _:
            return "other"

# Global vs nonlocal
def outer():
    x = "outer"
    def inner():
        nonlocal x  # refers to outer's x
        x = "inner"
    inner()
    print(x)  # "inner"

# Async/await basics
import asyncio

async def async_function():
    await asyncio.sleep(1)
    return "done"

async def main():
    result = await async_function()
    print(result)

# asyncio.run(main())

# F-string advanced formatting
name = "Alice"
age = 30
print(f"{name:>10}")    # right-align
print(f"{age:04d}")     # zero-pad
print(f"{3.14159:.2f}") # precision
print(f"{1000:,}")      # comma separator