Python Numbers Every Programmer Should Know

There are numbers every Python programmer should know. For example, how fast or slow is it to add an item to a list in Python? What about opening a file? Is that less than a millisecond? Is there something that makes that slower than you might have guessed? If you have a performance sensitive algorithm, which data structure should you use? How much memory does a floating point number use? What about a single character or the empty string? How fast is FastAPI compared to Django?

I wanted to take a moment and write down performance numbers specifically focused on Python developers. Below you will find an extensive table of such values. They are grouped by category. And I provided a couple of graphs for the more significant analysis below the table.

Source code for the benchmarks

This article is posted without any code. I encourage you to dig into the benchmarks. The code is available on GitHub at:

https://github.com/mikeckennedy/python-numbers-everyone-should-know

📊 System Information

The benchmarks were run on the sytem described in this table. While yours may be faster or slower, the most important thing to consider is relative comparisons.

Python numbers you should know

More analysis and graphs by category below the table.

Memory Costs

Understanding how much memory different Python objects consume.

An empty Python process uses 15.73 MB

Strings

The rule of thumb for strings is the core string object takes 41 bytes. Each additional character is 1 byte.

Numbers

Numbers are surprisingly large in Python. They have to derive from CPython’s PyObject and are subject to reference counting for garabage collection, they exceed our typical mental model many of:

• 2 bytes = short int
• 4 bytes = long int
• etc.

Collections

Collections are amazing in Python. Dynamically growing lists. Ultra high-perf dictionaries and sets. Here is the empty and “full” overhead of each.

Classes and Instances

Slots are an interesting addition to Python classes. They remove the entire concept of a __dict__ for tracking fields and other values. This does not significantly matter for a single instance, with the slots instance actually larger. But if you are holding a large number of them in memory for a list or cache, the memory savings of a slots class is very dramatic. Luckily for most use-cases, just adding a slots entry saves a ton of memory with minimal effort.

Aggregate Memory Usage (1,000 instances):

Basic Operations

The cost of fundamental Python operations: Way slower than C/C++/C# but still quite fast.

Arithmetic

String Operations

String operations in Python are fast as well. f-strings are the fastest formatting style, while even the slowest style is still measured in just nano-seconds.

List Operations

List operations are very fast in Python. Adding a single item usually requires 28ns. Said another way, you can do 35M appends per second. This is unless the list has to expand using something like a doubling algorithm. You can see this in the ops/sec for 1,000 items.

Surprisingly, list comprehensions are 20% faster than the equivalent for loops with append statements.

Collection Access and Iteration

How fast can you get data out of Python’s built-in collections? Here is a dramatic example of how much faster the correct data structure is. item in set or item in dict is 200x faster than item in list for just 1,000 items!

The graph below is non-linear in the x-axis.

Access by Key/Index

Length

len() is very fast. Maybe we don’t have to optimize it out of the test condition on a while loop looping 100 times after all.

Iteration

Class and Object Attributes

The cost of reading and writing attributes, and how __slots__ changes things. Slots is a tiny bit slower but easily saves over 2x the memory usage on large collections.

Attribute Access

Other Attribute Operations

JSON and Serialization

Comparing standard library JSON with optimized alternatives. orjson handles more data types and is over 11x faster than standard lib json. Impressive!

Serialization (dumps)

Deserialization (loads)

Pydantic

Web Frameworks

Returning a simple JSON response. Benchmarked with wrk against localhost running 4 works in Granian. Each framework returns the same JSON payload from a minimal endpoint. No database access or that sort of thing. This is just how much overhead/perf do we get from each framework itself. The code we write that runs within those view methods is largely the same.

Results

File I/O

Reading and writing files of various sizes. Note that the graph is non-linear in y-axis.

Basic Operations

Pickle vs JSON to Disk

Database and Persistence

Comparing SQLite, diskcache, and MongoDB using the same complex object.

Test Object

user_data = {
    "id": 12345,
    "username": "alice_dev",
    "email": "alice@example.com",
    "profile": {
        "bio": "Software engineer who loves Python",
        "location": "Portland, OR",
        "website": "https://alice.dev",
        "joined": "2020-03-15T08:30:00Z"
    },
    "posts": [
        {"id": 1, "title": "First Post", "tags": ["python", "tutorial"], "views": 1520},
        {"id": 2, "title": "Second Post", "tags": ["rust", "wasm"], "views": 843},
        {"id": 3, "title": "Third Post", "tags": ["python", "async"], "views": 2341},
    ],
    "settings": {
        "theme": "dark",
        "notifications": True,
        "email_frequency": "weekly"
    }
}

SQLite (JSON blob approach)

diskcache

MongoDB

Comparison Table

Note: MongoDB is a victim of network access version in-process access.

Function and Call Overhead

The hidden cost of function calls, exceptions, and async.

Function Calls

Exceptions

Type Checking

Async Overhead

The cost of async machinery.

Coroutine Creation

Running Coroutines

asyncio.sleep()

asyncio.gather()

Task Creation

Async Context Managers & Iteration

Sync vs Async Comparison

Methodology

Benchmarking Approach

• All benchmarks run multiple times and with warmup not timed
• Timing uses timeit or perf_counter_ns as appropriate
• Memory measured with sys.getsizeof() and tracemalloc
• Results are median of N runs

Environment

• OS: macOS 26.2
• Python: 3.14.2 (CPython)
• CPU: ARM - 14 cores (14 logical)
• RAM: 24.0 GB

Code Repository

All benchmark code available at: https://github.com/mkennedy/python-numbers-everyone-should-know

Key Takeaways

1. Memory overhead: Python objects have significant memory overhead - even an empty list is 56 bytes
2. Dict/set speed: Dictionary and set lookups are extremely fast (O(1) average case) compared to list membership checks (O(n))
3. JSON performance: Alternative JSON libraries like orjson and msgspec are 3-11x faster than stdlib json
4. Async overhead: Creating and awaiting coroutines has measurable overhead - only use async when you need concurrency
5. __slots__ tradeoff: While __slots__ saves memory, the difference for attribute access speed is minimal

Acknowledgments

Inspired by Latency Numbers Every Programmer Should Know and similar resources.

*Last updated: 2025-12-31