Choosing the Right Data Structure for Performance Efficiency
In every programming language, choosing the right data structure can make or break performance. In Python, the most common choices for storing collections are lists and dictionaries — and while they may look similar, their internal workings and performance profiles differ dramatically.

Understanding when to use one over the other can help you write code that’s both faster and more memory-efficient — much like how Solidity developers pick between arrays and mappings for gas efficiency on Ethereum.

A Quick Refresher

• Lists store ordered sequences of elements.
  You can access elements by index, iterate, append, and slice easily.

• Dictionaries (or dicts) store key–value pairs.
  They provide constant-time lookups and updates but don’t maintain numeric ordering (before Python 3.7).

Example: Comparing Lists and Dictionaries

Let’s compare how Python handles the same data — user balances.
Using a List of Tuples

users = [("alice", 100), ("bob", 200), ("carol", 300)]

def get_balance_list(users, name):
    for user, balance in users:
        if user == name:
            return balance
    return 0

print(get_balance_list(users, "bob"))  # Output: 200

• ✅ Simple and ordered

• ❌ Inefficient lookups → O(n) time complexity

Using a Dictionary

# Using a dictionary
balances = {"alice": 100, "bob": 200, "carol": 300}

def get_balance_dict(balances, name):
    return balances.get(name, 0)

print(get_balance_dict(balances, "bob"))  # Output: 200

• ✅ Constant-time lookup → O(1) on average

• ❌ Cannot easily preserve order before Python 3.7

Performance Benchmark

Let’s measure the difference in lookup time for large datasets.

import time

# Create large datasets
users = [(f"user{i}", i) for i in range(1000000)]
balances = {f"user{i}": i for i in range(1000000)}

# Measure lookup time
start = time.time()
get_balance_list(users, "user999999")
print("List lookup:", time.time() - start)

start = time.time()
get_balance_dict(balances, "user999999")
print("Dict lookup:", time.time() - start)

Output :

List lookup: 0.12 seconds
Dict lookup: 0.00001 seconds

That’s nearly 10,000× faster using a dictionary right… ?

When to Use Which ?

Example: Hybrid Pattern

balances = {}
user_list = []

def deposit(user, amount):
    if user not in balances:
        user_list.append(user)
    balances[user] = balances.get(user, 0) + amount

def get_total_balance():
    return sum(balances[u] for u in user_list)

This pattern mirrors the Solidity hybrid (mapping + array) approach:
constant-time lookups with the ability to iterate when needed.

Key Points

• dictionary → Faster lookups, ideal for key-based access

• lists → Best for ordered sequences or duplicates

• Hybrid → Combine both for iteration + fast access

• Rule of thumb: If you’re searching by key or ID, use a dictionary.

🔗 References

• Python Docs: Data Structures — Lists, Tuples, Dictionaries

• Time Complexity of Python Data Structures (Big O Cheat Sheet)

• Real Python: Dictionaries vs Lists — When to Use Which