Type checking

Ensures safe attribute access by confirming an object implements the Drawable interface before invocation.

Game development: verifying an entity is drawable before rendering it in the main loop. GUI framework: checking if a widget supports custom drawing before invoking its draw method. Plugin system: confirming a loaded module provides a Drawable interface before treating it as a renderable component.

Python game engines (e.g., Pygame), GUI toolkits (Tkinter, PyQt), and plugin architectures where runtime type safety is needed.

isinstance(object, class_or_tuple)

isinstance(..., ...)

object: any Python object, class_or_tuple: a class, type, or tuple of classes

• hasattr() for attribute existence checks
• getattr() for safe attribute retrieval
• abstract base classes for formal interfaces

• duck typing: try/except AttributeError — avoids explicit type checks but may hide errors
• abstract base classes: register implementations — provides formal interface but requires inheritance
• typing.Protocol: structural subtyping — static checking without inheritance

Passing a non-type as the second argument (e.g., a string) causes TypeError: isinstance() arg 2 must be a type or tuple of types; Using isinstance with a module or object instead of a class returns False unexpectedly, leading to missed type checks; Confusing isinstance with issubclass (checking class vs instance) results in logical errors when verifying inheritance hierarchies; Forgetting parentheses around a tuple of types (e.g., isinstance(obj, int, str)) raises a syntax error; Relying on isinstance for duck‑typed code undermines polymorphism and creates rigid, fragile designs.

issubclass: checks class inheritance rather than instance; hasattr: tests for attribute presence without verifying type; duck typing: assumes object has needed attributes and handles missing ones via exceptions; abstract base classes: enforce interface via inheritance and registration.

Coming from Java: may use instanceof for null‑safe calls — Python's isinstance requires an explicit type and does not replace null checks; Coming from C: may rely on pointer‑based type tags — Python uses dynamic typing and isinstance works with user‑defined classes and abc virtual subclasses.

• issubclass
• hasattr
• getattr
• abstract base classes
• typing.Protocol

Avoid isinstance when duck typing is sufficient and you prefer the EAFP (easier to ask for forgiveness than permission) style, as explicit type checks can hinder flexibility. The type check itself is O(1) with negligible overhead, but repeated isinstance calls in tight loops can accumulate measurable cost; caching the result or using a protocol check may improve performance. isinstance recognizes virtual subclasses registered with abc.AbstractBaseClass, and accepts a tuple of types so isinstance(obj, (int, str)) works for union‑like checks.

Prevents runtime AttributeError by ensuring objects conform to the expected Drawable interface before attribute access, enabling safer polymorphism.

isinstance: like showing an ID to a bouncer who verifies you're allowed inside before you enter the club.

When a tuple of types is supplied, isinstance returns True if the object is an instance of any of those types.