Object-Oriented Programming Cheat Sheet

Object-Oriented Programming (OOP) in Python treats everything as an object, bundling data and procedures into reusable types (classes) that simplify complex systems through abstraction and modularity.

Core Principles

Everything in Python is an object, possessing a type, internal data representation, and procedures for interaction.
Objects are data abstractions that combine an internal representation (data attributes) with an interface (methods) for interaction, hiding implementation details.
Classes define blueprints for creating objects, allowing developers to create their own types with specific attributes and behaviors.
OOP promotes 'divide-and-conquer' development by enabling the implementation and testing of classes separately, leading to increased modularity and reusability.

Action Steps

Define a new type using the `class` keyword, specifying its parent class (e.g., `object`).
Define class attributes within the class body to represent the data associated with objects of that type.
Implement the `__init__` method to initialize an object's data attributes when an instance is created.
Define methods (functions within a class) to specify the behaviors and interactions of objects, using `self` to refer to the instance.
Use the dot operator (`.`) to access an object's attributes or call its methods.
Define special methods (e.g., `__str__`) with double underscores to customize object behavior for operations like printing.

Key Terms

Object: A fundamental entity in Python that has a type, an internal data representation, and a set of procedures for interaction.
Type: Defines the kind of an object, determining what operations can be performed on it.
Instance: A specific object created from a particular type or class.
Class: A blueprint or template for creating objects, defining their attributes and methods.
Data Attributes: Variables that store the internal representation of an object.
Methods: Functions defined within a class that operate on the object's data attributes and define its behavior.
__init__: A special method used to initialize an object's attributes when an instance is created.
self: A conventional parameter name in methods that refers to the instance of the object itself.
__str__: A special method that defines the string representation of an object, used by the `print()` function.
Garbage Collection: The process by which Python automatically reclaims memory occupied by objects that are no longer in use.

Pro Tips

Internal representation of an object should be private; manipulating it directly can compromise correct behavior.
Python's garbage collection automatically reclaims memory from destroyed or inaccessible objects.
Use `isinstance()` to check if an object is an instance of a specific class, ensuring type correctness.
Define special methods (like `__add__`, `__len__`, `__str__`) with double underscores to allow your custom objects to work with built-in Python operators and functions.

Pitfalls to Avoid

Manipulating an object's internal representation directly can lead to unexpected behavior and bugs.
Forgetting to define the `__init__` method will result in objects not being properly initialized with their required attributes.
Not defining a `__str__` method leads to uninformative default print representations for custom objects.

Real World Examples

Representing a 2D point with x and y coordinates.: Define a `Coordinate` class with `x` and `y` data attributes, an `__init__` method to set these values, and a `distance` method to calculate the distance to another `Coordinate` object.
Creating a custom data type for fractions.: Define a `Fraction` class with `numerator` and `denominator` attributes, and methods for addition, subtraction, and conversion to float.