https://adamgrant.micro.blog/2025/07/24/123050.html

Adam Grant

  * About
  * Archive
  * Photos
  * Replies

  * About
  * Archive
  * Photos
  * Replies

You might not need a Python class

2025-07-24

Python is an incredibly versatile programming language known for its
simplicity and readability. Among its features, the ability to use
classes for object-oriented programming is both powerful and
frequently recommended. However, classes aren't always the best
solution. In many cases, Python's built-in types, functions, and
standard library modules provide simpler, cleaner alternatives. Here
are several scenarios where you might not need a Python class:

Simple Data Containers: Use Named Tuples or Data Classes

Often, classes are created just to store data. Python's built-in
alternatives, such as named tuples or data classes (Python 3.7+), can
be simpler and more concise.

Example with a Class:

class Point:
def __init__(self, x, y):
self.x = x
self.y = y

point = Point(10, 20)

Alternative with NamedTuple:

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
point = Point(10, 20)

Alternative with DataClass (Python 3.7+):

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

point = Point(10, 20)

Both namedtuple and dataclass are cleaner and automatically provide
methods like __init__, __repr__, and comparison methods without extra
boilerplate.

Stateless Utility Functions: Just Use Functions

If your class has methods but no state (no instance attributes), you
probably don't need a class at all.

Example with an unnecessary class:

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

result = MathUtils.add(3, 4)

Simpler alternative using a function:

def add(a, b):
    return a + b

result = add(3, 4)

In Python, functions are first-class citizens and often simpler than
creating classes for stateless operations.

Grouping Constants: Use Modules

Sometimes classes are used merely to group constants. Python modules
naturally serve this purpose without extra boilerplate.

Example with class:

class Config:
    HOST = 'localhost'
    PORT = 8080

print(Config.HOST)

Simpler alternative using module constants:

config.py

HOST = 'localhost'
PORT = 8080

another file

import config
print(config.HOST)

This approach is simpler and leverages Python's natural module
system.

Managing State with Simple Structures: Use Dictionaries or Lists

For simple state management, dictionaries or lists might suffice.
Classes become overkill when you simply want to store mutable data.

Example with a class:

class Inventory:
    def __init__(self):
        self.items = []

inventory = Inventory()
inventory.items.append('apple')

Alternative with a built-in list:

inventory = []
inventory.append('apple')

The built-in type simplifies the code and makes it clear and
straightforward.

Simple One-off Operations: Use Lambdas or Comprehensions

When performing simple operations, using lambdas or comprehensions
can greatly simplify code compared to defining methods within
classes.

Example with unnecessary class method:

class Transformer:
    def transform(self, data):
        return [x * 2 for x in data]

transformer = Transformer()
result = transformer.transform([1, 2, 3])

Simpler with comprehension:

result = [x * 2 for x in [1, 2, 3]]

Or even a lambda for one-off use:

transform = lambda data: [x * 2 for x in data]
result = transform([1, 2, 3])

Avoiding Complexity: Built-in Libraries

Python's standard library is extensive. Before writing your own
class, check if your requirement is already covered.

Example: You might think you need a custom class to manage and
serialize configurations, but Python's built-in configparser or json
module is usually enough.

import json

config = {'host': 'localhost', 'port': 8080}
with open('config.json', 'w') as f:
    json.dump(config, f)

Using built-ins reduces bugs, improves readability, and saves
development time.

When You Actually Need a Class

Classes are very powerful and useful, especially when: * You need to
encapsulate state and behavior. * Your objects have clear behavior
(methods) associated with their data. * You're modeling complex,
hierarchical structures (inheritance and composition).

But as demonstrated, Python's built-in features and standard
libraries often provide cleaner, simpler solutions.

Classes have their place, but Python's simplicity often allows you to
avoid unnecessary complexity. Whenever you're inclined to write a
class, first ask yourself if built-ins, standard libraries, or
simpler techniques could achieve the same goal more efficiently.

Keep your code clean, simple, and Pythonic. Sometimes that means
skipping the class entirely.

[a2e712b6-3]
Adam Grant
(c) 2025 Powered by Hugo Theme created by panr