class Child(Parent):

Polymorphism: Methods with the same name in different classes.

Encapsulation: Using conventions like _private_var (single underscore) or __mangled_var (double underscore).

Decorators: Functions that modify other functions. @property, @staticmethod, @classmethod.

Advanced Python

Generators and Iterators

Generators: Functions that yield values, creating iterators. Memory efficient.

def count_up_to(n):
  i = 0
  while i <= n:
    yield i
    i += 1
# Usage:
for num in count_up_to(5):
  print(num)

Iterators: Objects implementing __iter__() and __next__().

Decorators

Custom Decorator:

def my_decorator(func):
  def wrapper(*args, **kwargs):
    print("Before function call")
    result = func(*args, **kwargs)
    print("After function call")
    return result
  return wrapper

@my_decorator
def say_hello(name):
  return f"Hello, {name}!"

Context Managers

Using with statement: Ensures resources are properly acquired/released.

from contextlib import contextmanager

@contextmanager
def managed_resource(name):
  print(f"Acquiring {name}")
  yield name
  print(f"Releasing {name}")

with managed_resource("database") as db:
  print(f"Working with {db}")

Asynchronous Programming (`asyncio`)

Event Loop: Manages and distributes execution of tasks.

Coroutines: Functions defined with async def, executed with await.

import asyncio

async def fetch_data(delay):
  await asyncio.sleep(delay)
  return f"Data after {delay} seconds"

async def main():
  task1 = asyncio.create_task(fetch_data(2))
  task2 = asyncio.create_task(fetch_data(1))
  print("Tasks started...")
  result1 = await task1
  result2 = await task2
  print(result1)
  print(result2)

if __name__ == "__main__":
  asyncio.run(main())

Metaclasses

Customizing Class Creation: Classes are instances of metaclasses. type is the default metaclass.

Example:

class MyMeta(type):
  def __new__(mcs, name, bases, dct):
    # Modify class dictionary before creation
    dct['added_attribute'] = 100
    return super().__new__(mcs, name, bases, dct)

class MyNewClass(metaclass=MyMeta):
  pass

# MyNewClass.added_attribute will be 100

Concurrency and Parallelism

threading module: For I/O-bound tasks (due to GIL).
multiprocessing module: For CPU-bound tasks (bypasses GIL).
GIL (Global Interpreter Lock): Allows only one thread to execute Python bytecode at a time.

Python Ecosystem & Best Practices (2025)

Package Management

pip: Python's package installer.
- pip install package_name
- pip install -r requirements.txt
- pip freeze > requirements.txt
Virtual Environments: python -m venv .venv, source .venv/bin/activate (Linux/macOS) or .venv\Scripts\activate (Windows).
Poetry/Rye/PDM: Modern dependency management and packaging tools.

Testing

unittest: Built-in module for unit testing.
pytest: Popular third-party testing framework.
- Assertions: