Your first class

How classes work

Working with classes follows a simple pattern:

Define the class - Create a blueprint with the class keyword
Add an __init__ method - Set up initial data when objects are created
Create instances - Make actual objects from your class
Access the data - Use the attributes you defined

Let’s go through each step to build your first class.

Basic class structure

Every class starts with the class keyword:

class Dog:  # Note: class names use PascalCase
    pass  # Empty class

Adding an initializer

The __init__ method runs when you create a new object:

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

# Create dog objects - using positional arguments
dog1 = Dog("Buddy", "Golden Retriever")
dog2 = Dog("Max", "Beagle")

# Or with named arguments (clearer)
dog3 = Dog(name="Charlie", breed="Poodle")

print(dog1.name)   # Buddy
print(dog2.breed)  # Beagle

Yes, __init__ looks weird with those double underscores! This is called a “dunder” method (double underscore). It’s just how Python works - you’ll need to type it exactly like this. Don’t worry, after writing it a few times it becomes second nature. Think of it as Python’s special way of saying “this is the setup method”.

Understanding self

self refers to the current object. It’s how an object keeps track of its own data:

When defining methods in a class, you always include self as the first parameter. But when calling the method, you don’t pass it - Python does that automatically!

class Dog:
    def __init__(self, name):
        self.name = name  # self.name belongs to this specific dog

# Using positional argument
dog1 = Dog("Buddy")

# Using named argument (same result)
dog2 = Dog(name="Max")

# Each dog has its own name
print(dog1.name)  # Buddy
print(dog2.name)  # Max

Real-world example: configuration

Here’s a practical class for AI engineering:

class APIConfig:
    def __init__(self, api_key, model="gpt-3.5-turbo", max_tokens=100):
        self.api_key = api_key
        self.model = model
        self.max_tokens = max_tokens
        self.base_url = "https://api.openai.com/v1"

# Create different configurations
# Using positional for required arg, named for optional
dev_config = APIConfig("sk-dev-key", max_tokens=50)

# Using all named arguments (clearest)
prod_config = APIConfig(api_key="sk-prod-key", model="gpt-4", max_tokens=1000)

# Access the configuration
print(dev_config.model)        # gpt-3.5-turbo
print(prod_config.model)       # gpt-4
print(prod_config.max_tokens)  # 1000

Class vs instance

Class: The blueprint (like a recipe)
Instance/Object: What you create from the class (like a cake from the recipe)

# APIConfig is the class
# config1 and config2 are instances
config1 = APIConfig(api_key="key1", max_tokens=50)
config2 = APIConfig(api_key="key2", max_tokens=200)

# Each instance has its own data
print(config1.max_tokens)  # 50
print(config2.max_tokens)  # 200

# Changing one doesn't affect the other
config1.max_tokens = 75
print(config1.max_tokens)  # 75
print(config2.max_tokens)  # 200 (unchanged)

Always use clear, descriptive names for your classes. In Python, class names use PascalCase (like TextProcessor or DataLoader), while variable names use snake_case (like text_processor or data_loader).

Common mistakes

Forgetting self in __init__

# Wrong - forgot self parameter
class Dog:
    def __init__(name):  # Missing self!
        name = name

# Right - include self
class Dog:
    def __init__(self, name):
        self.name = name

Not using self for attributes

# Wrong - creates local variable
class Dog:
    def __init__(self, name):
        name = name  # Just a local variable!

# Right - use self
class Dog:
    def __init__(self, name):
        self.name = name  # Instance attribute

Forgetting parentheses when creating instance

# Wrong - assigns the class itself
my_config = APIConfig  # Not an instance!

# Right - call with parentheses
my_config = APIConfig(api_key="api-key")  # Creates instance

Modifying class instead of instance

# Wrong - modifies the class
class Counter:
    count = 0

c1 = Counter()
c1.count += 1  # This affects the class!

# Right - instance attribute
class Counter:
    def __init__(self):
        self.count = 0  # Each instance gets its own

What’s next?

Now that you understand how to create classes and store data in them, let’s learn how to add behavior with methods.

Methods and attributes

Add behavior to your classes

Functions

External tools

Practical Python

Error handling

Classes

How classes work

Basic class structure

Adding an initializer

Understanding self

Real-world example: configuration

Class vs instance

Common mistakes

What’s next?

Methods and attributes

​How classes work

​Basic class structure

​Adding an initializer

​Understanding self

​Real-world example: configuration

​Class vs instance

​Common mistakes

​What’s next?

Methods and attributes

How classes work

Basic class structure

Adding an initializer

Understanding self

Real-world example: configuration

Class vs instance

Common mistakes

What’s next?