Home > Articles > Open Source > Python

An Introduction to Object-Oriented Concepts in Python, Part 5

  • Print
  • + Share This
Programming expert Jesse Smith shows how to improve Python program design by using data structures.
Like this article? We recommend

In this article, I'll continue showing you how to use Python from an object-oriented (OO) point of view. If you're unfamiliar with object-oriented concepts such as inheritance, encapsulation, and polymorphism, read my article "A Primer on Object-Oriented Concepts" before continuing with this article.

This article builds on my earlier article "An Introduction to Object-Oriented Concepts in Python, Part 4." If you haven't read that article already, please read it before reading this article. The concepts in this article will take a closer look at using data structures such as tuples, dictionairies, and lists.

If you've been following my Python series, you know how object-oriented concepts such as subclassing using object inheritance in Python work. But so far I haven't addressed how data structures can be used to improve your code flow and class design. As in other programming languages, it's necessary to have data structures that allow us to store and retrieve information, eliminate spiked code patterns, and improve our overall application design by making a smaller footprint thru less redundancy.

Catch Up on All of the Articles in this Python Series

Jesse Smith has written five articles in this series. Here are the earlier installments:

Part 1
Part 3
Part 2
Part 4


Python has a lot of built-in objects, many of which include support for data structures. In Python, these objects are referred to as native data types. One such native data-type is a Tuple. A Tuple is like a list object, but is immutable. The elements of a Tuple are stored in parentheses, instead of brackets as they are with a list:

x = ("a","b","c","d")

Tuples are ideal for combining different data types. For example, if storing information about a book, we would store the author's name, price of the book, number of books in stock, and so on. This data would be in String and Integer types. But we're not restricted to primitive data types, and we can store our own types as well. One of the biggest advantages of Tuples is that we can use them as values inside other storage objects like the List object.

Let's get to the fun stuff about using Tuples. We can use a Tuple in place of a bunch of if conditions as a for loop. Let's say we have paired values that represent a stock name and a price. Without a Tuple, multiple if conditions can be used to determine what stock to pick and the price to associate with it:

if stock == "Google":
    price = 800
elif stock == "APPL":
    price = 400

This could be quite a long list of all major stock symbols. We can shorten our code quite a bit by using a Tuple:

stockVals = [("GOOG",800),("APPL",400)]
for(name,price) in stockVals:

In this example, we associate the price to a symbol, and the logic to handle each stock can be placed inside the for loop, instead of having multiple if conditions. This example demonstrates using Tuples inside lists. Thus far, the Tuple examples are of unnamed Tuples. As you can probably guess, you can apply a name to a Tuple. Take the following simple example:

from collections import namedtuple
Point = namedtuple('Point', 'x y')
pt1 = Point(2.0, 5.0)
pt2 = Point(3.5, 1.5)

In order to name a Tuple, we have to import the namedtuple base class. From there, we can pass in the name and values of our Tuple to the namedtuple class, which returns an object that can be assigned to a variable. This essentially allows a Tuple to become a class object type.

Tuples have no methods for adding, removing, or searching the elements. Tuples can also be used as keys in dictionaries. They're faster and safer than lists, but can be converted to a list if necessary.


A dictionary in Python is similar to a Hashmap in other languages. To define a dictionary, we assign key-to-value relationships:

stocks = {"GOOG":"800","APPL":"400"}

In this example, "GOOG" represents a key, while the stock price represents the value. You can retrieve values by keys, but you cannot retrieve keys by values. We can use the get method to retrieve a value:


Remember, Tuples can be used as values in a dictionary:

stocks = {"GOOG":(800,850,900,950)}

Any problems accessing the dictionary will result as a KeyError exception.

To iterate a dictionary, you can use the handy items method:

for stock,values in stocks.items():
    print(stock, values[0])

Each key and value are unpacked into the stock and values variables we define. The values variable is a Tuple, and the 0 index accesses the first value of the Tuple.


The most common native data type is none other than the list storage data type. Unlike the previous storage data types we've considered, the list is an order data type. Lists should be used when there are numerous objects with the same type that need an action performed on them. Lists should not be used for storing attributes of particular objects, such as items for which Tuples and dictionaries are often used.

Storing different data types in a list makes them more difficult to access in a loop structure than the other storage types discussed so far. The list has some fancy method for ordering elements, however, such as the reverse and sort methods. The reverse method does what you would expect, which is to reverse all the elements in the list or turn them around. This is another reason to use the same data types in lists—because they can be ordered (that is, strings or integers).

To sort a list in place, without creating a new list, use the sort method:

stocks = ["GOOG","APPL","SPWR","SCTY"]

To create a new sorted list, use the sorted method:

a = sorted([3,2,3,1,5])

To sort a list of Tuples, do the following:

stocks = [("GOOG",800),("APPL",400),("SPWR",27),("SCTY",42)]
stocks.sort(key=lambda i: i[1])

The lambda keyword creates a function that takes the Tuple as an argument and returns an indexed list. In this example, the list of Tuples is sorted by price in ascending order.


In this article, you learned more about using data structures in an object-oriented context. One such data structure, the Tuple, is useful for combining different data types. The Tuple's biggest advantage is being able to use it as keys in a dictionary, or as elements in a ;ist. You can also create named Tuples, thus making them an object type reference similar to a class.

Dictionaries are high-performance lists that use a key as an index to reference a corresponding value. They're similar to HashMaps in Java. The dictionary object in Python has some easy-to-use powerful methods, like the items method for traversing the values.

The list object is the most common "jack of all trades" storage data type. The list object is an ordered storage container that's useful when you need to store similar data types. The list object  can traverse Tuples as the elements by using the lambda function.

At this stage, you should be comfortable using the built-in storage data types and using them for better class design and code flow. Keep experimenting with each type of storage object and extending them as needed in your programs.

This concludes the OO Python series. I hope you enjoyed it and learned much from these articles. In the future, I plan to continue my overall Python coverage by introducing the Python Pyramid framework for web applications.

  • + Share This
  • 🔖 Save To Your Account