OOP

A style where an object's suitability is judged by the methods and attributes it actually has, not by its class or inheritance — if it provides the needed methods, it works, enabling polymorphism.

Encapsulation bundles data with the methods that operate on it into one unit, keeping related knowledge together and hiding implementation details. Data hiding (restricting access) is one goal of it, but encapsulation is broader than just hiding.

Encapsulation bundles data with the methods on it and hides internals; inheritance derives one class from another; polymorphism gives one interface many implementations; abstraction exposes only the essential features of a thing.

Polymorphism lets one interface work with different types. Forms: ad-hoc (overloading), parametric (generics), and subtype — a derived type used via its base with overridden methods, the most commonly meant. Python leans on duck typing.

Call super() with no arguments in Python 3; it returns a proxy dispatching to the next class in the MRO, so super().__init__() runs the parent's method. It cooperates with multiple inheritance.

Abstraction is the design act of exposing only essential features and ignoring irrelevant detail. Encapsulation is the mechanism that bundles data with methods and hides internals. Abstraction = what to expose; encapsulation = how to hide it.

Inheritance tightly couples a subclass to its base and exposes its internals, making hierarchies rigid. Composition (an object holding collaborators and delegating) is more flexible and swappable at runtime. Use inheritance only for true is-a cases.

An object usable with with defining __enter__ (its return binds to as) and __exit__ (runs on exit even on exception, receiving exc type, value, traceback). You can also wrap a generator with @contextlib.contextmanager.

By default == falls back to identity — the default __eq__ compares id() — and two fresh objects differ, so it is False. is always tests identity; == tests equality, customizable via __eq__.

__new__(cls, ...) creates and returns the new instance and runs first; __init__(self, ...) initializes that instance and returns None, running second. __init__ runs only if __new__ returned an instance of cls.

Subclass abc.ABC (or set metaclass=ABCMeta) and decorate the required methods with @abstractmethod. Python then refuses to instantiate the base, or any subclass that leaves an abstract method unimplemented, raising TypeError — enforcing a contract concrete subclasses must satisfy.

DRY — Don't Repeat Yourself: factor duplication into one reusable place. KISS — Keep It Simple: avoid needless cleverness. YAGNI — You Aren't Gonna Need It: don't build speculative features before they're required.

Methods with double-underscore names like __init__, __len__, __add__ that the interpreter invokes implicitly through built-ins, operators, or syntax — len(x) calls x.__len__(), a + b calls a.__add__(b).

By default in a per-instance __dict__ mapping name to value, so attributes can be added or removed dynamically at runtime. obj.__dict__ or vars(obj) shows that dict directly.

Yes — a class may list several bases, as in class A(B, C). Method and attribute lookup follows the MRO computed by C3, which enables mixins but can introduce ambiguity the MRO order resolves.

It wraps a class whose interface you can't change so it matches the interface the client expects, translating calls between the two. It lets otherwise-incompatible code work together — fitting a third-party API onto your own interface — without touching either side's source.

1 1, then 1 2, then 3 2. Initially Child.x is inherited from Parent. Assigning Child.x = 2 creates a separate attribute on Child that shadows the parent's, so later changing Parent.x to 3 no longer affects Child, which keeps its own 2.

Use @contextlib.contextmanager: acquire before yield value (bound to as), and release in a finally so cleanup runs even on exception. It is equivalent to a class with __enter__ / __exit__. The with statement guarantees the code after yield (the finally) executes.

It wraps an object in another of the same interface to add behavior at runtime, stacking layers without subclassing. Each wrapper forwards to the inner object and adds its own piece, so features compose dynamically. It is distinct from Python's @decorator function syntax.

It moves object creation into a method (often overridden by subclasses) so callers request a product by intent, not by concrete class. Calling code depends only on the abstract product, so a new variant is a new subclass — no edits to existing call sites.

A small helper class added to an inheritance chain to contribute specific behavior or methods, not meant to stand alone or be instantiated. It is technically an ordinary class; convention just names it ...Mixin.

It sets up a one-to-many link: when a subject's state changes, every registered observer is notified automatically, usually by a notify loop calling each observer's update. It decouples the subject from its listeners — the subject knows only the observer interface, not concrete types.

items = [] is a class attribute shared by every instance, so a and b mutate the same list and b.items shows ['apple']. Fix: initialize it per-instance in __init__: def __init__(self): self.items = [].

Ensure one shared instance. Idiomatic options: a module (imported once, so a natural singleton), a metaclass overriding __call__, a decorator caching the instance, or overriding __new__. Metaclass and module approaches cover subclasses well.

It captures a family of interchangeable algorithms behind a shared interface and lets the client pick or swap one at runtime, instead of hard-coding if/elif branches. The context holds a strategy object and delegates to it, so a new algorithm drops in without touching the context.

The GoF groups them into three: Creational (object creation — factory, singleton, builder), Structural (composing objects — adapter, facade, decorator), and Behavioral (object interaction and responsibility — observer, strategy, iterator).

An interface for creating whole families of related objects without naming concrete classes. One factory produces a matched set — say, all widgets of one UI theme — so swapping the factory swaps the entire family at once and stops products of different families from mixing.

It splits an abstraction from its implementation so the two vary independently, holding the implementation via composition instead of inheritance. This avoids a class explosion when two orthogonal dimensions — say shapes × rendering backends — would otherwise multiply into NxM subclasses.

It constructs a complex object step by step through a sequence of method calls, separating how it is assembled from its final representation. You add only the parts you need (no telescoping constructors), then call build() to get the finished product.

Cohesion measures how focused one module is — high cohesion (it does one well-defined thing) is good. Coupling measures interdependence between modules — low coupling (modules depend minimally) is good. Aim for high cohesion, low coupling.

It puts one simplified, high-level interface in front of a complex subsystem of many classes, so clients use the facade instead of wiring the parts themselves. It cuts coupling to internals and gives a clean entry point, while still allowing direct subsystem access when needed.

Method Resolution Order — the deterministic linear order Python searches base classes for an attribute or method. It is computed by C3 linearization, exposed as Cls.__mro__, and is the order super() walks.

A single leading underscore (_x) is a convention for internal use; it stays fully accessible. A double leading underscore (__x) triggers name mangling — rewritten to _ClassName__x so subclasses won't override it.

It puts a stand-in object with the same interface in front of a real object to control access — adding lazy loading, caching, access checks, or remote calls without changing the client. The client can't tell the proxy from the real subject, since both share one interface.

That all statements inside a single function sit at the same level of abstraction — don't mix high-level orchestration with low-level detail in one body. You extract the low-level steps into named helper functions, so each function reads as a coherent narrative at one altitude.

SRP (single responsibility — one reason to change), OCP (open for extension, closed for modification), LSP (subtypes replace their base), ISP (small client-specific interfaces), DIP (depend on abstractions). Martin's five OOD rules.

C3 merges each base's MRO plus the base list, keeping local precedence and monotonicity. For a diamond A(B, C) both deriving D, it yields [A, B, C, D, object] — D appears once, after all its subclasses.

__slots__ declares a fixed attribute set and removes the per-instance __dict__, saving memory and slightly speeding access — valuable for millions of instances. The cost: you can't add attributes outside the list.

High-level modules shouldn't depend on low-level ones — both depend on abstractions; and abstractions shouldn't depend on details, details depend on abstractions. In practice inject an interface, not a concrete class, to decouple policy from detail.

It passes a request along a chain of handlers until one handles it, so the sender doesn't know which will. Each handler either processes the request or forwards it to the next, decoupling sender from receiver and letting you reorder or add handlers freely.

It packages a request as an object carrying the action plus its arguments, so calls can be queued, logged, passed around, or undone. The invoker triggers execute without knowing the concrete operation, decoupling who requests an action from who actually performs it.

It arranges objects into tree structures and lets clients treat individual leaves and whole branches uniformly through one shared interface. A folder and a file both expose size(); the folder just recurses into its children. It models part-whole hierarchies cleanly.

It minimizes memory by sharing one immutable instance of common intrinsic state across many objects, keeping per-object extrinsic state outside. Thousands of tree sprites share one texture object; only positions differ. Python's string and small-int interning is a built-in example.

It defines a class hierarchy representing the grammar of a small language plus an interpret method to evaluate sentences in it. Each grammar rule becomes a node type; an expression tree is built and recursively evaluated. It fits simple DSLs like filters or arithmetic.

It centralizes communication between many objects in one mediator so they no longer reference each other directly. Components talk to the mediator, which coordinates them, turning a tangled many-to-many web of dependencies into a hub-and-spoke. Think a chat room routing messages.

It captures an object's internal state into a snapshot (the memento) that can be stored and later restored, without exposing the object's internals. The originator creates and restores from mementos; a caretaker just holds them. It is the basis of undo/redo.

It creates new objects by cloning an existing instance (the prototype) instead of instantiating a class from scratch. Useful when construction is expensive or the concrete type is decided at runtime — you copy a ready object, often via copy.deepcopy, and tweak it.

It lets an object change its behavior when its internal state changes, by delegating to a separate state object the context swaps at runtime. It replaces sprawling if/elif on a status flag with one class per state, each defining the transitions out of itself.

It defines the skeleton of an algorithm in a base-class method, deferring specific steps to subclass overrides. The overall sequence is fixed; subclasses fill in the variable parts without changing the structure. It is the 'Hollywood principle' — the base calls you.

It lets you add new operations to a fixed set of element classes without modifying them, by moving the operation into a visitor object. Each element calls visitor.visit(self) (double dispatch); a new operation is a new visitor, not edits across every element class.