Object-oriented programming

A class is a blueprint for creating objects. It defines attributes that describe the data and methods that describe the behavior. Instances of a class are objects with their own state. Classes are themselves objects, instances of the type metaclass, which means they can be assigned to variables and passed around.

A class defines structure and behavior. An instance is a concrete object created from the class, with its own data. A single class can have many instances. Class attributes are shared across all instances, while instance attributes are unique to each instance.

Dunder init is the initializer method called automatically when a new instance is created. It receives the new instance as self and can set initial attribute values. It is not technically a constructor; the actual construction is done by dunder new, which creates the instance before init runs.

Dunder new is a static method that creates and returns a new instance. Dunder init initializes the already-created instance. New is rarely overridden except for immutable types or singletons. Init is overridden in almost every custom class to set up instance state.

Dunder methods, short for double-underscore methods, are special methods recognized by Python that define how objects respond to built-in operations. Examples include dunder add for the plus operator, dunder len for the len function, and dunder str for string conversion. They are also called magic methods.

Dunder repr returns an unambiguous string representation, ideally one that could recreate the object. Dunder str returns a user-friendly string for display. The repr is used by interactive prompts and the repr function; the str is used by print and the str function. If only repr is defined, it is used as a fallback for str.

Class attributes are defined directly in the class body and are shared by all instances. Instance attributes are set on individual instances, usually in init via self. When you access an attribute, Python looks first on the instance, then on the class, then on its base classes.

Inheritance is a mechanism where a class derives attributes and methods from another class, called the parent or base. The derived class is called the subclass or child. Inheritance enables code reuse and polymorphism. A subclass can override inherited methods and add new ones.

Multiple inheritance is when a class inherits from more than one parent class. Python supports it directly. It allows a class to combine features from several sources but introduces complexity in method resolution. Python uses the C3 linearization algorithm to determine the order of method lookup.

Method Resolution Order, or MRO, is the order in which Python looks up methods in a class hierarchy. With multiple inheritance, Python uses the C3 linearization algorithm to compute a consistent linear order. You can inspect it with the dunder mro attribute or the mro method on a class.

The super function returns a proxy object that delegates method calls to a parent or sibling class. It is most commonly used inside dunder init and other overridden methods to call the parent implementation. With multiple inheritance, super follows the MRO, which is essential for cooperative classes.

Polymorphism means that different types can respond to the same operation. In Python, this is achieved through duck typing: if an object provides the expected methods, it can be used in a given context regardless of its actual class. This is more flexible than the static polymorphism of typed languages.

Duck typing is the principle that an object's suitability is determined by whether it has the required methods and attributes, not by its class. The name comes from the saying that if it walks like a duck and quacks like a duck, it is a duck. Python embraces duck typing throughout its design.

Encapsulation is the practice of restricting direct access to an object's internal state, exposing only what is necessary. Python does not enforce access control; instead, it relies on naming conventions. A single leading underscore signals that an attribute is internal. A double leading underscore triggers name mangling.

Name mangling is when Python rewrites attribute names that start with two underscores but do not end with two underscores. The name is rewritten to include the class name, so dunder x in class A becomes underscore A double underscore x. This avoids accidental name clashes in subclasses.

An abstract method is declared but not implemented in a base class, requiring subclasses to provide an implementation. Python supports abstract methods through the abc module using the ABC base class and the abstractmethod decorator. A class with unimplemented abstract methods cannot be instantiated. ---