Python Interview Questions

print("Hello, Python!")

# Dynamic typing
x = 10       # int
x = "hello"  # now str — no error

# Python shines at: automation, data, web
# Python struggles with: game engines, mobile apps, systems programming

import sys
print(sys.implementation.name)  # 'cpython'
print(sys.version)              # 3.12.x

Source Code (.py) → Parser → AST → Compiler → Bytecode (.pyc) → PVM → Output

# See the bytecode
import dis

def greet(name):
    return f"Hello, {name}"

dis.dis(greet)
# Shows bytecode instructions like LOAD_FAST, FORMAT_VALUE, BUILD_STRING, RETURN_VALUE

# PEP 8 compliant
class UserProfile:
    """User profile class."""

    def __init__(self, name: str, age: int) -> None:
        self.name = name
        self.age = age

MAX_LOGIN_ATTEMPTS = 3

def calculate_total(items: list) -> float:
    """Calculate total price of items."""
    return sum(item.price for item in items)

import this

x = None  # represents absence of value

# Mutable — objects can be modified in-place
my_list = [1, 2, 3]
my_list.append(4)      # ✅ list is now [1, 2, 3, 4]

# Immutable — "modification" creates a NEW object
my_str = "hello"
my_str.upper()         # returns "HELLO" — original unchanged
print(my_str)          # "hello"

# Tuples are immutable
t = (1, 2, 3)
# t[0] = 99           # ❌ TypeError

# But they can contain mutable objects
t = ([1, 2], 3)
t[0].append(99)        # ✅ t[0] is now [1, 2, 99]

# No type declarations needed
x = 10          # x is int
x = "hello"     # x is now str — no error
x = [1, 2, 3]   # x is now list

# Type can change freely
def process(value):
    if isinstance(value, int):
        return value * 2
    elif isinstance(value, str):
        return value.upper()
    return value

# Type hints are optional (Python 3.5+)
name: str = "Alice"          # hint only, not enforced
age: int = "thirty"          # no error at runtime!

class Duck:
    def quack(self): return "Quack!"

class Person:
    def quack(self): return "I'm quacking like a duck!"

def make_it_quack(thing):
    print(thing.quack())  # ✅ Works with any object that has .quack()

make_it_quack(Duck())     # "Quack!"
make_it_quack(Person())   # "I'm quacking like a duck!"

# Python's EAFP: Easier to Ask Forgiveness than Permission
def safe_quack(thing):
    try:
        return thing.quack()
    except AttributeError:
        return "Can't quack"

from typing import Protocol

class Quackable(Protocol):
    def quack(self) -> str: ...

# Implicit conversion (coercion) — Python auto-converts
result = 10 + 3.14     # 13.14 (int → float)

# Explicit conversion — using type constructors
int("42")              # 42
float("3.14")          # 3.14
str(42)                # "42"
bool(1)                # True
list("hello")          # ['h', 'e', 'l', 'l', 'o']
tuple([1, 2, 3])       # (1, 2, 3)
set([1, 2, 2, 3])      # {1, 2, 3}
dict([("a", 1), ("b", 2)])  # {'a': 1, 'b': 2}

# Safe conversion
def safe_int(value):
    try:
        return int(value)
    except (ValueError, TypeError):
        return None

x = None

# Check for None (use 'is', not '==')
if x is None:           # ✅ correct
if x is not None:       # ✅ correct
if x == None:           # ❌ works but not idiomatic

# Functions return None by default
def no_return():
    pass

result = no_return()
print(result)           # None

# Common None patterns
user = get_user(123)
if user is not None:
    print(user.name)

# Default params with None
def fetch_data(timeout=None):
    if timeout is None:
        timeout = 30  # default
    ...

# int — arbitrary precision (no overflow)
x = 42
y = 10 ** 100           # huge, still an int!

# float — double-precision IEEE 754
pi = 3.14159
sci = 1.5e10            # 15000000000.0

# complex
z = 3 + 4j
print(z.real)           # 3.0
print(z.imag)           # 4.0

# bool — subclass of int
print(True + True)      # 2 (True=1, False=0)

# Division
print(5 / 2)            # 2.5  (true division)
print(5 // 2)           # 2    (floor division)
print(5 % 2)            # 1    (modulo)

# Underscores for readability
million = 1_000_000     # same as 1000000

# True division (/)
7 / 2     # 3.5
7 / -2    # -3.5
8 / 4     # 2.0 (always float!)

# Floor division (//)
7 // 2    # 3 (floor of 3.5)
7 // -2   # -4 (floor of -3.5 = -4)
-7 // 2   # -4

# Floor division rounds DOWN (toward negative infinity)
# Not truncation toward zero!

# Modulo follows floor division
7 % 2     # 1
7 % -2    # -1 (preserves sign of divisor)

# Single quotes
s1 = 'hello'

# Double quotes
s2 = "hello"

# Triple quotes (multi-line)
s3 = """Line 1
Line 2
Line 3"""

# Raw strings (ignore escape sequences)
path = r"C:\Users\name"     # no need to escape backslashes

# f-strings (formatted string literals)
name = "Alice"
age = 30
msg = f"{name} is {age} years old"  # "Alice is 30 years old"

# bytes
b = b"hello"                # immutable byte sequence
ba = bytearray(b"hello")    # mutable byte sequence

name = "Alice"
age = 30

# Basic
f"Name: {name}, Age: {age}"      # "Name: Alice, Age: 30"

# Expressions
f"2 + 2 = {2 + 2}"               # "2 + 2 = 4"

# Format specifiers
price = 19.99
f"Price: ${price:.2f}"           # "Price: $19.99"
f"Hex: {255:#x}"                 # "Hex: 0xff"

# Alignment
f"{name:<10}"                    # "Alice     " (left align)
f"{name:>10}"                    # "     Alice" (right align)
f"{name:^10}"                    # "  Alice   " (center)

# Debugging (3.8+)
x = 10
f"{x = }"                        # "x = 10"
f"{x + 5 = }"                    # "x + 5 = 15"

# Nested f-strings
precision = 2
f"Pi is {3.14159:.{precision}f}" # "Pi is 3.14"

# Creation
nums = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True]
empty = []
list_from_range = list(range(5))  # [0, 1, 2, 3, 4]

# Indexing (0-based)
nums[0]      # 1
nums[-1]     # 5 (last element)

# Slicing [start:stop:step]
nums[1:3]    # [2, 3]
nums[:3]     # [1, 2, 3]
nums[::2]    # [1, 3, 5]
nums[::-1]   # [5, 4, 3, 2, 1] (reverse)

# Methods
nums.append(6)      # [1, 2, 3, 4, 5, 6]
nums.insert(0, 0)   # [0, 1, 2, 3, 4, 5, 6]
nums.pop()          # 6 (remove & return last)
nums.remove(3)      # remove first occurrence of 3
nums.sort()         # sort in-place
nums.reverse()      # reverse in-place
len(nums)           # number of elements

# List comprehension (idiomatic!)
squares = [x**2 for x in range(10) if x % 2 == 0]
# [0, 4, 16, 36, 64]

# Creation
t = (1, 2, 3)
single = (1,)          # trailing comma — required!
no_parens = 1, 2, 3    # also a tuple (tuple packing)
empty = ()

# Access (same as list)
t[0]       # 1
t[1:3]     # (2, 3)

# Immutability
# t[0] = 99            # ❌ TypeError

# But can contain mutable objects
t = ([1, 2], 3)
t[0].append(99)        # ✅ t[0] is now [1, 2, 99]

# Tuple unpacking
a, b, c = (1, 2, 3)   # a=1, b=2, c=3
a, b = b, a            # swap (needs RHS tuple)

# Return multiple values from function
def min_max(nums):
    return min(nums), max(nums)

low, high = min_max([3, 1, 4, 1, 5])  # low=1, high=5

# When to use: fixed collections, dict keys, function returns

# Creation
user = {"name": "Alice", "age": 30, "active": True}
empty = {}
dict_from_pairs = dict([("a", 1), ("b", 2)])

# Access
user["name"]           # "Alice"
user.get("name")       # "Alice"
user.get("phone")      # None (no error!)
user.get("phone", "N/A")  # "N/A" (default)

# Key check
"name" in user         # True

# Modify
user["age"] = 31       # update
user["email"] = "a@b.com"  # add new

# Delete
del user["active"]
user.pop("age")        # 31 (remove & return)
user.pop("missing", None)  # safe removal

# Iteration
for key in user:                    # keys
for key, val in user.items():       # key-value pairs
for val in user.values():           # values

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

# Merge (3.9+)
user = {"name": "Alice"} | {"age": 30}  # {'name': 'Alice', 'age': 30}

# Creation
s = {1, 2, 3, 2, 1}   # {1, 2, 3} — duplicates removed
empty_set = set()       # NOT {} — that's a dict
set_from_list = set([1, 2, 2, 3])  # {1, 2, 3}

# Basic operations
s.add(4)               # {1, 2, 3, 4}
s.remove(3)            # {1, 2, 4} — KeyError if missing
s.discard(10)          # {1, 2, 4} — no error if missing
s.pop()                # remove & return arbitrary element

# Membership (O(1) average!)
100 in s               # True/False

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

a | b                  # {1, 2, 3, 4, 5}  union
a & b                  # {3}               intersection
a - b                  # {1, 2}            difference
a ^ b                  # {1, 2, 4, 5}      symmetric diff
a <= b                 # subset check
a >= b                 # superset check

# Set comprehension
evens = {x for x in range(20) if x % 2 == 0}

# Arithmetic
+ - * / // % **        # add, sub, mul, div, floor, mod, pow

# Comparison
== != < > <= >=        # returns bool

# Logical
and or not             # short-circuit operators

# Identity
is  is not             # checks object identity (not equality)

# Membership
in  not in             # checks if element exists in collection

# Bitwise
& | ^ ~ << >>          # and, or, xor, not, shift

# Assignment
= += -= *= /= //= %= **= &= |= ^= <<= >>=

# Walrus (3.8+)
if (n := len(items)) > 10:
    print(f"Got {n} items")  # assigns AND uses in expression

# Without walrus
data = fetch_data()
if data:
    process(data)

# With walrus — assign AND check in one line
if (data := fetch_data()):
    process(data)

# While loops
while (chunk := file.read(1024)):
    process(chunk)

# List comprehensions
results = [y for x in range(10) if (y := expensive(x)) > 5]
# Without walrus, expensive(x) would be called twice

# Use sparingly — can reduce readability if overused

# When in doubt, use parentheses!
result = 2 + 3 * 4      # 14 (not 20)
result = (2 + 3) * 4    # 20

# if / elif / else
score = 85
if score >= 90:
    grade = "A"
elif score >= 75:
    grade = "B"
elif score >= 60:
    grade = "C"
else:
    grade = "F"

# match-case (Python 3.10+)
def http_status(code):
    match code:
        case 200:
            return "OK"
        case 201:
            return "Created"
        case 404:
            return "Not Found"
        case _:
            return "Unknown"

# Ternary expression
status = "Adult" if age >= 18 else "Minor"

# for loop
for i in range(5):           # 0, 1, 2, 3, 4
for i, item in enumerate(items):  # with index
for a, b in zip(list1, list2):    # parallel iteration

# while loop
while condition:
    # body
    break         # exit loop
    continue      # skip to next iteration
    pass          # no-op placeholder

# Loop with else (runs if no break)
for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            break
    else:
        print(f"{n} is prime")

# Simple value matching
def describe(value):
    match value:
        case 0:
            return "zero"
        case 1 | 2 | 3:
            return "small"
        case _:
            return "other"

# Pattern matching with sequences
def process(point):
    match point:
        case (0, 0):
            return "origin"
        case (0, y):
            return f"x=0, y={y}"
        case (x, 0):
            return f"x={x}, y=0"
        case (x, y):
            return f"x={x}, y={y}"
        case _:
            return "not a point"

# Pattern matching with objects
class User:
    def __init__(self, name, role):
        self.name = name
        self.role = role

match user:
    case User(name="admin", role="admin"):
        return "admin user"
    case User(name=name, role="user") if name:
        return f"user: {name}"

# Matching dictionaries
match config:
    case {"method": "GET"}:
        return handle_get()
    case {"method": "POST", "data": data}:
        return handle_post(data)

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

# Type hints (optional, 3.5+)
def add(a: int, b: int) -> int:
    return a + b

# Default arguments
def power(base, exp=2):
    return base ** exp

# Keyword-only arguments
def configure(*, host, port=8080):
    print(f"{host}:{port}")

configure(host="localhost")     # ✅
# configure("localhost")        # ❌ TypeError

# Positional-only arguments (3.8+)
def divide(a, b, /):
    return a / b

divide(10, 2)   # ✅
# divide(a=10, b=2)  # ❌

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

# **kwargs (variable keyword)
def create_user(**kwargs):
    return kwargs

# Docstrings
def calculate(x, y):
    """Calculate something important.

    Args:
        x: First number
        y: Second number

    Returns:
        The calculated result
    """
    return x * y

# *args — arbitrary positional arguments
def log_message(level, *messages):
    print(f"[{level}]", *messages)

log_message("INFO", "Server", "started", "on port 8080")
# [INFO] Server started on port 8080

# **kwargs — arbitrary keyword arguments
def create_profile(name, **details):
    profile = {"name": name}
    profile.update(details)
    return profile

p = create_profile("Alice", age=30, city="NYC", active=True)
# {'name': 'Alice', 'age': 30, 'city': 'NYC', 'active': True}

# Combined
def func(a, b, *args, **kwargs):
    pass

# Unpacking with * and **
def add(a, b, c):
    return a + b + c

nums = [1, 2, 3]
add(*nums)                  # 6 — unpack list

config = {"a": 1, "b": 2, "c": 3}
add(**config)               # 6 — unpack dict

# Merging dictionaries (3.9+)
defaults = {"host": "localhost", "port": 8080}
options = {"port": 9090}
merged = {**defaults, **options}  # {'host': 'localhost', 'port': 9090}

# Syntax: lambda args: expression

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

# Multiple args
add = lambda a, b: a + b
add(3, 4)           # 7

# With sorted()
users = [("Alice", 30), ("Bob", 25), ("Carol", 35)]
sorted(users, key=lambda u: u[1])  # sort by age

# With map/filter
nums = [1, 2, 3, 4, 5]
list(map(lambda x: x * 2, nums))   # [2, 4, 6, 8, 10]
list(filter(lambda x: x % 2 == 0, nums))  # [2, 4]

# With default arguments in lambda
multiply = lambda x, y=2: x * y
multiply(5)          # 10
multiply(5, 3)       # 15

# Basic: [expression for item in iterable]
squares = [x**2 for x in range(10)]
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

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

# With if-else (different syntax!)
result = ["even" if x % 2 == 0 else "odd" for x in range(5)]
# ['even', 'odd', 'even', 'odd', 'even']

# Nested loops
pairs = [(x, y) for x in range(3) for y in range(3)]
# [(0,0), (0,1), (0,2), (1,0), (1,1), (1,2), (2,0), (2,1), (2,2)]

# With functions
items = ["  Hello  ", "World", "  Python  "]
cleaned = [item.strip().upper() for item in items if item.strip()]
# ['HELLO', 'WORLD', 'PYTHON']

# Dict and set comprehensions
squares_dict = {x: x**2 for x in range(5)}
squares_set = {x**2 for x in range(5)}

import sys

# List comprehension — creates all items immediately
squares_list = [x**2 for x in range(1000)]
sys.getsizeof(squares_list)  # ~8KB

# Generator expression — creates items lazily
squares_gen = (x**2 for x in range(1000))
sys.getsizeof(squares_gen)   # ~112 bytes

# Use generator for large data
sum(x**2 for x in range(10_000_000))  # ✅ memory efficient

# Use list comprehension when you need
# - Multiple iterations
# - Random access (indexing)
# - Length checking

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

# Multiple exception types
try:
    value = int(input())
    result = 100 / value
except ValueError:
    print("Not a valid number")
except ZeroDivisionError:
    print("Can't divide by zero")
except Exception as e:
    print(f"Unexpected error: {e}")

# try/except/else/finally
try:
    file = open("data.txt")
    data = file.read()
except FileNotFoundError:
    print("File not found")
else:
    print(f"Read {len(data)} characters")  # runs if no exception
finally:
    file.close()  # always runs

# Raising exceptions
def withdraw(amount, balance):
    if amount > balance:
        raise ValueError("Insufficient funds")
    return balance - amount

# Custom exceptions
class InsufficientFundsError(Exception):
    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
        super().__init__(f"Need {amount}, have {balance}")

# Assertions
def divide(a, b):
    assert b != 0, "Divisor cannot be zero"
    return a / b

def process_file(path):
    try:
        file = open(path)
    except FileNotFoundError:
        print("File not found, using defaults")
        return default_data()
    else:
        # Only runs if file opened successfully
        data = file.read()
        return process(data)
    finally:
        # Always runs — even if return in try/except
        try:
            file.close()
        except NameError:
            pass  # file was never opened

# File handling — auto-closes even on error
with open("file.txt", "r") as file:
    data = file.read()
# file is automatically closed here

# Multiple resources
with open("input.txt") as infile, open("output.txt", "w") as outfile:
    outfile.write(infile.read())

# Custom context manager (class-based)
class ManagedFile:
    def __enter__(self):
        print("Opening file")
        self.file = open("data.txt")
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Closing file")
        self.file.close()
        return False  # don't suppress exceptions

with ManagedFile() as f:
    data = f.read()

# Using contextlib (simpler)
from contextlib import contextmanager

@contextmanager
def managed_file(path):
    try:
        f = open(path)
        yield f
    finally:
        f.close()

with managed_file("data.txt") as f:
    data = f.read()

# Importing modules
import math
from datetime import datetime, timedelta
from collections import defaultdict as dd
import numpy as np  # alias

# Package structure
# my_package/
#   __init__.py
#   module_a.py
#   sub_package/
#     __init__.py
#     module_b.py

from my_package.module_a import function_a
from my_package.sub_package import module_b

# Conditional imports
try:
    import pandas as pd
except ImportError:
    pd = None

# Module attributes
print(__name__)      # '__main__' for scripts, module name for imports
print(__file__)      # path to current file

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

# __name__ values:
# - When run directly:   __name__ == "__main__"
# - When imported:       __name__ == "my_script"

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

    # Constructor
    def __init__(self, name, age):
        # Instance variables
        self.name = name
        self.age = age

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

    # String representation
    def __str__(self):
        return f"{self.name} ({self.age})"

    def __repr__(self):
        return f"Dog('{self.name}', {self.age})"

# Using the class
my_dog = Dog("Rex", 3)
print(my_dog.name)         # Rex
print(my_dog.bark())       # Rex says Woof!
print(my_dog)              # Rex (3)

# Class variable access
print(Dog.species)         # Canis familiaris
print(my_dog.species)      # Canis familiaris (inherited)

class Example:
    class_var = "shared"

    def __init__(self, value):
        self.instance_var = value

    # Instance method — receives self (the instance)
    def instance_method(self):
        return f"Instance: {self.instance_var}"

    # Class method — receives cls (the class)
    @classmethod
    def class_method(cls):
        return f"Class: {cls.class_var}"

    # Static method — receives nothing
    @staticmethod
    def static_method(x, y):
        return x + y

obj = Example("hello")

obj.instance_method()   # "Instance: hello"
Example.class_method()  # "Class: shared"
Example.static_method(3, 4)  # 7

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

    def speak(self):
        return "..."
    def move(self):
        return f"{self.name} moves"

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

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

dog = Dog("Rex")
print(dog.speak())       # Woof! (overridden)
print(dog.move())        # Rex moves (inherited)

# Using super()
class Puppy(Dog):
    def __init__(self, name, toy):
        super().__init__(name)  # Call parent constructor
        self.toy = toy

    def speak(self):
        return super().speak() + "!"  # Extend parent method

# isinstance / issubclass
isinstance(dog, Animal)    # True
issubclass(Dog, Animal)    # True

class Flyer:
    def fly(self): return "Flying"

class Swimmer:
    def swim(self): return "Swimming"

class Duck(Flyer, Swimmer):
    def quack(self): return "Quack!"

d = Duck()
d.fly()        # "Flying"
d.swim()       # "Swimming"
d.quack()      # "Quack!"

# Method Resolution Order (MRO)
print(Duck.__mro__)
# (<class 'Duck'>, <class 'Flyer'>, <class 'Swimmer'>, <class 'object'>)

# Diamond problem — Python resolves via MRO (C3 linearization)
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):
    pass

d = D()
d.method()       # "B"
print(D.__mro__) # D → B → C → A → object

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner        # public
        self._balance = balance   # "protected" (convention only)
        self.__pin = "1234"       # "private" (name mangling)

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

    def withdraw(self, amount):
        if 0 < amount <= self._balance:
            self._balance -= amount
            return amount
        raise ValueError("Insufficient funds")

    def get_balance(self):
        return self._balance

# Name mangling for __double_underscore
# __pin becomes _BankAccount__pin
print(acc._BankAccount__pin)  # "1234" — still accessible but the name changes

# Properties — controlled access with attribute syntax
class Temperature:
    def __init__(self, celsius=0):
        self._celsius = celsius

    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Below absolute zero")
        self._celsius = value

    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32

t = Temperature(100)
print(t.celsius)       # 100 (getter)
t.celsius = 50         # uses setter
print(t.fahrenheit)    # 122.0 (computed property)

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

@timer               # same as: slow_function = timer(slow_function)
def slow_function():
    import time
    time.sleep(1)

slow_function()      # slow_function took 1.0002s

# Decorator with arguments
def repeat(n=2):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(n=3)
def say_hi():
    print("Hi!")

# Built-in decorators
@staticmethod
@classmethod
@property
@functools.lru_cache   # memoization
@dataclass              # auto-generates __init__, __repr__, etc.

# Generator function
def countdown(n):
    while n > 0:
        yield n           # pauses here, resumes on next next()
        n -= 1

for num in countdown(5):  # 5, 4, 3, 2, 1
    print(num)

# Generator for infinite sequences
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib = fibonacci()
[next(fib) for _ in range(10)]  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

# Generator expressions
squares = (x**2 for x in range(10_000_000))  # lazy — no memory issue

# Pipelining generators
def read_large(file_path):
    with open(file_path) as f:
        for line in f:
            yield line.strip()

def filter_comments(lines):
    for line in lines:
        if not line.startswith("#"):
            yield line

def parse_csv(lines):
    for line in lines:
        yield line.split(",")

# Memory-efficient pipeline
processed = parse_csv(filter_comments(read_large("data.csv")))
for row in processed:
    process(row)

# Send values into generator (advanced)
def accumulator():
    total = 0
    while True:
        value = yield total
        if value is not None:
            total += value

acc = accumulator()
next(acc)          # 0
print(acc.send(5)) # 5
print(acc.send(3)) # 8