Use of dict instead of class

Question

I don't understand when should I use dictionaries instead of classes on Python. If a class can do the same as dictionaries and more, why do we use dictionaries? For example, the next two snippets do the same:

Using class:

class PiggyBank:
    def __init__(self, dollars, cents):
        self.dollars = dollars
        self.cents = cents


piggy1 = PiggyBank(2, 2)
print(piggy1.dollars)  # 2
print(piggy1.__dict__)  # {'dollars': 2, 'cents': 2}

Using dictionary:

def create_piggy(dollars, cents):
    return {'dollars': dollars, 'cents': cents}


piggy2 = create_piggy(2, 2)
print(piggy2['dollars'])  # 2
print(piggy2)  # {'dollars': 2, 'cents': 2}

So at the end, I am creating two static objects with the same information. When should I use a class or a function for creating an instance?

Answer 1

You can use dictionary if it suffices your usecase and you are not forced to use a Class. But if you need some added benefits of class (like below) you may write is as Class

Some use cases when you might need Class

• When you need to update code frequently
• When you need encapsulation
• When you need to reuse the same interface,code or logic

Answer 2

You would typically want to use a dictionary when you're doing something dynamic -- something where you don't know all of the keys or information when you're writing the code. Note also that classes have restrictions like not being able to use numbers as properties.

As a classic example (which has better solutions using collections.Counter , but we'll still keep it for its educational value), if you have a list of values that you want to count you can use a dictionary to do so efficiently:

items_to_count = ['a', 'a', 'a', 'b', 5, 5]

count = {}
for item in items_to_count:
    if item in count:
        count[item] += 1
    else:
        count[item] = 1

# count == {'a': 3, 'b': 1, 5: 2}

Answer 3

why do we use dictionaries?

Dictionaries are built-in containers with quite a bit of functionality that can be used at no extra coding cost to us . Since they are built-in a lot of that functionality is probably optimized.

Answer 4

dict s are often called "associative arrays". They're like regular list s in Python, except that instead of using an integer as an index, you can use strings (or any hashable type).

You can certainly implement list -like and dict -like objects (as well as set -like objects and str -like objects) with Python classes, but why would you if there's already an object type that does exactly what you need?

So if all you're looking for is an associative array, a dict will most likely serve you just fine. But if you jump through hoops to implement a class that already does what a dict does, you'll be "re-inventing the wheel," as well as giving the future readers of your code extra work trying to figure out that all your class is doing is re-implementing a dict with no real extra functionality.

Basically, if all that you need is a dict , just use a dict . Otherwise, you'll be writing a lot of extra code (that may be prone to bugs) for no real gain.