Python Tutorial — Learn Python Step by Step

Python Objects and Classes

A class is a blueprint for creating objects. Objects bundle data (attributes) and behavior (methods) together, enabling you to model real-world concepts in code.

Defining a Class

# Basic class definition
class Dog:
    # Class attribute — shared by all instances
    species = "Canis familiaris"

    # Constructor — called when creating a new instance
    def __init__(self, name, age):
        # Instance attributes — unique to each object
        self.name = name
        self.age = age

    # Instance method
    def bark(self):
        return f"{self.name} says Woof!"

    # Another method
    def description(self):
        return f"{self.name} is {self.age} years old"

# Creating objects (instances)
dog1 = Dog("Rex", 3)
dog2 = Dog("Buddy", 5)

print(dog1.bark())         # Rex says Woof!
print(dog2.description())  # Buddy is 5 years old
print(dog1.species)        # Canis familiaris

The __init__ Method and self

# self refers to the current instance
class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner      # instance attribute
        self.balance = balance
        self._transactions = [] # convention: _ prefix = "private"

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit must be positive")
        self.balance += amount
        self._transactions.append(f"+{amount}")
        return self  # return self for method chaining

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("Insufficient funds")
        self.balance -= amount
        self._transactions.append(f"-{amount}")
        return self

    def get_statement(self):
        return f"{self.owner}: ${self.balance} | History: {self._transactions}"

# Usage
account = BankAccount("Alice", 1000)
account.deposit(500).withdraw(200)  # method chaining
print(account.get_statement())
# Alice: $1300 | History: ["+500", "-200"]

Special (Dunder) Methods

# Dunder methods customize how objects behave with built-in operations
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        """Developer-friendly string (for debugging)."""
        return f"Point({self.x}, {self.y})"

    def __str__(self):
        """User-friendly string (for print)."""
        return f"({self.x}, {self.y})"

    def __eq__(self, other):
        """Enable == comparison."""
        return self.x == other.x and self.y == other.y

    def __add__(self, other):
        """Enable + operator."""
        return Point(self.x + other.x, self.y + other.y)

    def __len__(self):
        """Enable len() — return distance from origin (as int)."""
        return int((self.x**2 + self.y**2) ** 0.5)

p1 = Point(3, 4)
p2 = Point(1, 2)
print(p1)          # (3, 4)
print(repr(p1))    # Point(3, 4)
print(p1 + p2)     # (4, 6)
print(p1 == Point(3, 4))  # True
print(len(p1))     # 5

Class Methods and Static Methods

class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def __str__(self):
        return f"{self.year}-{self.month:02d}-{self.day:02d}"

    @classmethod
    def from_string(cls, date_string):
        """Alternative constructor — create from string."""
        year, month, day = map(int, date_string.split("-"))
        return cls(year, month, day)

    @classmethod
    def today(cls):
        """Alternative constructor — create from today."""
        from datetime import date
        d = date.today()
        return cls(d.year, d.month, d.day)

    @staticmethod
    def is_valid(year, month, day):
        """Utility — does not need class or instance."""
        return 1 <= month <= 12 and 1 <= day <= 31

# Usage
d1 = Date(2024, 6, 15)
d2 = Date.from_string("2024-12-25")  # classmethod
d3 = Date.today()                     # classmethod
print(Date.is_valid(2024, 13, 1))     # False (staticmethod)

Properties (Getters and Setters)

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius  # triggers the setter

    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Below absolute zero!")
        self._celsius = value

    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32

temp = Temperature(25)
print(temp.celsius)      # 25
print(temp.fahrenheit)   # 77.0
temp.celsius = 100       # uses setter
# temp.celsius = -300    # raises ValueError

• __init__ initializes a new object; self refers to the current instance.
• Use dunder methods (__str__, __eq__, __add__) to make objects work with Python operators.
• Use @classmethod for alternative constructors; @staticmethod for utility functions.
• Use @property to add validation/logic to attribute access without changing the API.
• Prefix attributes with _ to signal they are internal (convention, not enforced).