python: Overhead to using classes instead of dictionaries?

Question

First, I'd like to point out that I know OOP concepts and understand the differences between dictionaries and classes. My question is about what makes sense design wise in this case:

I am designing a webapp in python and I have to represent something like a book object. Books have chapters and chapters have titles and content. For simplicity, lets say that the content is plain text.

My question is, should I make the book and chapter classes or dictionaries? I know it'd look neater to use book.chapter instead of book['chapter'], and if I end up having methods in the future, it might make sense to puts them in the book class. However, I'd like to know if there is any overhead to using classes instead of storing the information in dictionaries?

If I don't want to instantiate a book object from a database everytime and store it as a pickle, I'd have to be worried about incompatibility with past book objects if I add/remove data members from a class.I feel that it'd be easier to deal with this problem in dictionaries. Any pointers on whether/when it makes sense to use dictionaries instead of classes?

Answer 1

Objects were originally created to bundle data with functionality. If you just want to store data, use dictionaries. If you want to include methods for manipulating the data, use objects.

Answer 2

A few thoughts:

1. If you start with a dictionary, you can always switch to a custom class later that implements the mapping protocol (or subclasses dict). So it's probably a good starting point.

2. You can define custom Python objects to use __slots__, which will be faster and more memory efficient if you have a large number of objects.

3. If you use a custom Python object, it will be easier to replace it in the future with an object written in C. (I've never tried it, but I would expect that subclassing dict from C would be a tricky proposition.)

Answer 3

Kind of similar to your problem: http://stackoverflow.com/questions/794132/returning-an-object-vs-returning-a-tuple

There's no clearcut choice. Dictionaries are fast, nice, and clean. Class instances are, after all, a special dictionary. If you want to provide a way to add functionalities and change your interface later on, a class would be the best choice, but overdesign something simple is always a bad choice. Python is not java, where everything must be an instance of a properly made class. This is a sin I fall for as well.

Answer 4

If you go with objects, I wouldn't store the data pickled in the database simply for the reasons you gave. It would be considerably worse if you underwent a change of language or similar.

FWIW, I would start with a dictionary. If things get complicated or new features are needed, make it an object.

Answer 5

This is highly unlikely to be the bottleneck in your application, so worrying about the performance is probably a waste of time. However, if this is the bottleneck or you just have some time on your hands, look into using a namedtuple. It combines the immutability and low memory footprint of a tuple with the nice syntax of class attributes.