OOP and Classes

A class attribute is created in the class body and stored on the class, so every instance sees the same object. An instance attribute is created by assigning to self.name and lives in that one object's own namespace.

A plain method takes the instance as its first argument, self. A classmethod takes the class as cls, so a subclass gets its own class. A staticmethod receives nothing implicitly; it is just a function stored in the class namespace.

A single leading underscore is pure convention: it marks an attribute as internal and the interpreter ignores it. A double leading underscore inside a class body is rewritten by the compiler to _ClassName__name, which avoids subclass collisions rather than blocking access.

The list is built once, when the class body runs, and stored on the class. Every instance reaches that same object through self.name, so an append from one is visible from all. Build the list in init instead.

Both refer to an object without keeping it alive. A weakref.ref is a callable: call it to get the object, or None once it is gone. A weakref.proxy forwards attribute access through, and raises ReferenceError once it is gone.

A mixin is a small class that contributes methods to other classes through multiple inheritance and is never instantiated on its own. A base class says what an object is; a mixin only adds a slice of behaviour.

B's run executes. Python flattens the hierarchy into one method resolution order — D, B, C, then their shared base, then object — and calls the first class in that list that defines run.

A zero-argument super() builds a proxy that starts attribute lookup at the class after the one where the method was defined, following the receiver's method resolution order rather than the class's declared base.

dict.copy(), dict(d) and {**d} are built-in constructors: they allocate an exact dict and copy the items, so your class and its instance attributes are lost. copy.copy(d) goes through the reduction protocol and rebuilds an instance of your subclass.

Python calls init_subclass on the nearest parent every time a new subclass of it is created, passing the brand-new subclass as cls. It is implicitly a classmethod, and it never runs for the class that defines it.

len answers len(obj), getitem answers obj[i] and slicing, and contains answers x in obj. Defining them on any class makes the built-ins work, because Python looks for the methods, not for a particular base class.

__repr__ returns the unambiguous developer-facing view, used by repr(), the REPL and debuggers. __str__ returns the readable user-facing view used by print() and str(). A missing __str__ falls back to __repr__, never the reverse.

Objects that compare equal must return equal hash values, and an object's hash must not change while it lives. The converse is not required: equal hashes are a collision, resolved by ==.

When a class body defines eq without hash, Python sets hash to None in that class, so hash() raises TypeError: unhashable type. Define hash over the same fields to restore it.

Because len() resolves len on type(obj), not on the object. The lambda lands in the instance dictionary, which implicit special method lookup never reads, so the class still has no len and len() raises TypeError.

Write the record as a class: an annotated name with an assigned value becomes that field's default, and ordinary def statements become real methods on the generated tuple subclass. Defaulted fields must come last, exactly as with function parameters.

@dataclass writes init, repr and eq from the class's annotated attributes, in declaration order. Only annotated names become fields; a plain assignment with no annotation stays an ordinary class attribute.

Setting or deleting an attribute on a frozen dataclass instance raises dataclasses.FrozenInstanceError, because the decorator generates blocking setattr and delattr methods. It does not freeze what the fields point at: a list field can still be mutated in place.

@dataclass generates an init that assigns every field, and if the class defines post_init that generated constructor calls it as its final statement. It is the hook for validating arguments and computing derived values.

A default in the class body is created once and would be shared by every instance, so @dataclass rejects it at class-creation time. Use dataclasses.field(default_factory=list), which calls the factory per instance.

The @property decorator turns a method into a read-only attribute, so callers write obj.title rather than obj.title(). Decorating a second method of the same name with @title.setter makes assignment work and gives you one place to validate the value.

Because an assignment inside setattr is itself an attribute assignment, so it calls setattr again and never terminates, ending in RecursionError. Break the cycle by delegating to object.setattr or super().setattr, or by writing straight into the instance dictionary.

getattribute is called for every attribute access on an instance and performs the whole lookup itself; getattr is only the fallback the runtime calls when that lookup fails with AttributeError. Overriding getattribute touches every access and every internal read.

It is a non-data descriptor: the first read runs the function and stores the result in the instance __dict__ under the same attribute name. Later reads find that entry first, so the descriptor never runs again.

A data descriptor defines set or delete and outranks the instance dict; a non-data descriptor defines only get and loses to it. So instance data can shadow a non-data descriptor but never a data one.

abc.ABCMeta collects every still-abstract name into a frozenset stored on the class as abstractmethods, and object construction refuses to run while that set is non-empty. The failure therefore lands at instantiation, not at class definition.

Instances lose their per-instance __dict__. Only the names listed in __slots__ can be assigned, each into a fixed storage slot, and assigning any other attribute raises AttributeError instead of silently creating it.

It creates and returns a brand-new class object at runtime. type('Duck', (Bird,), {'legs': 2}) produces the same kind of object a class Duck(Bird) statement would. The one-argument form, type(obj), instead reports an object's class.

Put @abstractmethod innermost, directly above the def, with @property, @classmethod or @staticmethod outside it. The reverse order raises AttributeError while the class body runs, because those wrapper objects expose a read-only isabstractmethod.

Meta.__prepare__ runs first and returns the mapping the class body executes into. The body then runs, and the filled mapping is handed to Meta.__new__, which creates the class object, and finally to Meta.__init__, which configures it.

The | operator unions two enum.Flag members into one composite member carrying both bits, and & intersects them. Test a single flag with perms & Perm.READ, which is truthy only when that bit is set.

Each enum.Enum member is created once and cached, so every access returns the same object and is compares them exactly. A plain member equals only itself: Color.RED == 1 is False, and so is a same-valued member of another enum.

A duplicate value creates an alias, not a new member: enum.Enum binds the second name to the member that already owns that value. Iterating the class yields only canonical members, so the alias name never shows up.

Only when a member must still work as a raw int or string somewhere you cannot change - a wire format, a stored column, a C constant. Those members really are int and str subclasses: a compatibility shim, not a default.

Inside a Flag or IntFlag subclass, auto() assigns successive powers of two — 1, 2, 4, 8 — rather than the 1, 2, 3 it gives a plain Enum, so every member owns a distinct bit and members can be combined.

Define copy(self) for copy.copy() and deepcopy(self, memo) for copy.deepcopy(). Each returns the finished new object, so the class itself decides which attributes are duplicated, which are shared, and which are rebuilt.

reduce returns either a string naming a module-level global to look up, or a tuple whose first item is a callable and whose second is a tuple of arguments. Loading imports that callable by name and calls it with those arguments.

getstate returns a copy of the instance dict with the lock key removed, so it is never serialised. setstate merges the stored data back and creates a fresh threading.Lock on the restored object.

pickle does not serialise a function's code. It stores the function's module name and qualified name and looks that pair up again on load. A lambda's qualified name is <lambda>, which resolves to nothing, so dumping raises pickle.PicklingError.

getstate returns the data written into the pickle, which by default is the instance dict. setstate receives that data on unpickling and rebuilds the object from it. Unpickling never calls init.