Adventures in Machine Learning

Mastering Python’s Data Structures: Sets Tuples Lists and Dictionaries

Understanding Sets in Python: Handling TypeErrors and Checking Values

Python is a versatile programming language that offers developers numerous capabilities. Sets are an essential feature of the Python language, allowing developers to store data in an unordered fashion.

Because sets are mutable, the elements stored in a set can be updated, added, or removed, making them more flexible than tuples, which are immutable and cannot be changed or updated. However, sets can present challenges when it comes to handling TypeErrors.

Let us dive into the main ways to handle TypeErrors when working with sets in Python.

Handling TypeError for Sets

TypeError is commonly encountered when programming in Python. It occurs when an operation attempts to use an object that does not support that operation, like adding a string to an integer.

In the context of handling TypeErrors for sets in Python, one of the most common challenges is accessing an element in a set by an index number, as you would do with lists. Converting a set to a list to access it at an index is a common solution to this problem.

We can use the list function to convert a set into a list, which have defined indexes. Once the set is converted into a list, we can access it using an index.

Here is an example:

cities = {‘Paris’, ‘Madrid’, ‘London’, ‘Berlin’}

city_list = list(cities) # convert set to list


The output will be Paris. By converting the set to a list, we can now access elements in it using an index.

Another option is to convert a set to a tuple to access an element at an index. This involves using the tuple function to convert the set to a tuple.

Once the set is converted to a tuple, accessing elements is the same as with lists, using the index operator. Here is an example:

cities = {‘Paris’, ‘Madrid’, ‘London’, ‘Berlin’}

city_tuple = tuple(cities) # convert set to tuple


The output will be Paris.

Tuple is similar to lists in that it has defined indexes, but unlike lists that are mutable, tuples are immutable. Declaring a list instead of a set is another way to avoid TypeErrors entirely.

We can declare a list using square brackets [], while a set uses curly brackets {}. The downside to declaring a list as opposed to a set is that lists do not provide guarantees of uniqueness or an unordered collection.

Here’s what that would look like:

cities_list = [‘Paris’, ‘Madrid’, ‘London’, ‘Berlin’]


Using the ‘in’ operator to check if a value is in a set is another powerful tool when working with sets in Python. We can use ‘in’ to check if a value is present in a set and return a Boolean value.

Here is an example:

cities = {‘Paris’, ‘Madrid’, ‘London’, ‘Berlin’}

print(‘Paris’ in cities)

print(‘Tokyo’ in cities)

The output will be True and False, respectively. If the value is not present in the set, it returns False.

Differences Between Tuples and lists

When working with sequences in Python, developers can choose between lists and tuples. Both lists and tuples can store data in ordered form, with each element assigned an index number.

However, there are a few key differences between these two data structures. Declaring a tuple involves using parentheses (), while declaring a list involves using square brackets [].

Here is an example of declaring a tuple:

tup = (‘apple’, ‘banana’, ‘cherry’)

And here is an example of declaring a list:

lst = [‘apple’, ‘banana’, ‘cherry’]

One significant difference between a tuple and a list is that tuples are immutable and cannot be changed once created. Lists, on the other hand, are mutable and can be updated with new elements, modified, or deleted elements.

Tuples, however, provide a few advantages over lists. Since tuples are immutable and offer limited functionality, they are faster than lists.

They are also safe for sharing data between different processes. Another difference between lists and tuples is that tuples have fewer built-in methods than lists.

Since tuples are immutable, they cannot be changed by adding or removing elements. Therefore, methods like append(), extend(), pop() are not supported.

However, tuples do support basic methods like count() and index(), which can be used to obtain information about the tuples’ content.


Sets, lists, and tuples are fundamental data structures in Python and play a significant role in developers’ day-to-day coding. Handling TypeErrors and knowing the differences between tuples and lists is critical to writing efficient Python code.

Armed with the knowledge of these Python sets and sequences, developers can build complex programs and applications with ease. Python is a powerful language that provides developers with numerous facilities for manipulating data structures.

Two important data containers in Python are dictionaries and subscriptable objects. To use these structures effectively in Python programming, it is essential to understand their syntax and how to access them using square brackets.

Syntax for Declaring a Dictionary

In Python, a dictionary is a collection of key-value pairs that can be accessed by the key. To declare a dictionary, youll need to use curly brackets {} to enclose the key-value pairs.

Heres an example of how to create a dictionary in Python:

my_dict = {‘name’: ‘John’, ‘age’: 35, ‘location’: ‘New York’}

Each key and value pair are separated using a colon (:). Notice that each key-value pair is separated using a comma (,).

Accessing Subscriptable Objects with Square Brackets

In Python, subscriptable objects are those that allow accessing their elements using an index value. Lists and tuples are the most common subscriptable objects in Python.

To access these elements, you use square brackets [] and provide an index value to the element you want to access. The index values start at 0, so the first element in a list or tuple is indexed as 0.

The Subscriptable Objects in Python

In Python, lists, tuples, and strings are subscriptable. For example, to access the second element in a list, you can write:

my_list = [1, 2, 3, 4, 5]


The output for this code would be 2 since the index for the second element is 1.

This same syntax can be used to access elements in tuples and strings as well.

Converting Non-Subscriptable Objects to Subscriptable Objects

Some objects in Python are not subscriptable, which means that you cannot use the square brackets [] to access their elements directly. For example, the set data structure in Python is an unordered collection of unique elements that do not support indexing.

Attempting to access an element in a set using square brackets [] raises a TypeError. So, how can we convert non-subscriptable objects to subscriptable ones?

The answer is to make use of the __getitem__ method which is the method Python uses to retrieve elements from a subscriptable object. When you can implement the __getitem__ method in a non-subscriptable class, you can make it subscriptable.

Here is an example:

class Book:

def __init__(self, name, author, price): = name = author

self.price = price

def __getitem__(self, index):

if index == ‘name’:


elif index == ‘author’:


elif index == ‘price’:

return self.price


return None

book = Book(‘Learning Python’, ‘Mark Lutz’, 40)




The output will be “Learning Python”, “Mark Lutz”, and “40”, respectively. Now we have made the non-subscriptable book object subscriptable, and we can access its attributes using square brackets [].

The __getitem__ Method for Subscriptable Objects

The __getitem__ is a built-in Python method that you can use to make subscriptable objects. When you define __getitem__ on any object, Python will know how to retrieve items from that object using the square brackets [] notation.

Heres an example:

class MyList:

def __init__(self, *args): = list(args)

def __getitem__(self, index):


my_list = MyList(‘apple’, ‘banana’, ‘cherry’, ‘donut’, ‘egg’)




The output for this code would be “apple”, “banana”, and “cherry”. This way, the class MyList becomes subscriptable.


In Python, dictionaries and subscriptable objects are powerful data structures that can be used to store, manipulate, and retrieve information. Understanding their syntax and how to access them using square brackets is fundamental to writing efficient and elegant code.

By making use of the methods discussed here, Python developers can create powerful data structures that are both easily accessible and manipulatable. Learning to program in Python is a great way to improve your coding skills and build your programming knowledge.

Understanding key syntax elements and data structures in Python is crucial to writing efficient code and building complex programs and applications. This article has covered topics such as the syntax for declaring a dictionary and accessing subscriptable objects with square brackets.

In this section, we’ll provide additional resources to help you expand your knowledge on related topics. Additional Resources: Tutorials


Python documentation: One of the best resources for learning Python is the official Python documentation. The documentation is well-organized and provides in-depth information on Python syntax, libraries, and data structures, among other topics.

The documentation covers Python 2.X and 3.X, making it suitable for both beginners and advanced users. 2.

Python Crash Course: This book offers beginners a comprehensive introduction to Python programming. The book provides step-by-step instructions on Python basics, including data types, functions, and control statements.

The book also provides hands-on projects to help learners build their Python skills. 3.

Stanford cs231n: Convolutional Neural Networks for Visual Recognition: If youre interested in machine learning and neural networks, this tutorial offered by Stanford University provides an excellent introduction. The tutorial focuses on building convolutional neural networks for image recognition, but it covers other topics like numpy arrays and Python libraries.

4. DataCamp: DataCamp is an online learning platform that offers various courses on data science, statistics, and programming.

The platform provides a mix of interactive exercises and video lectures, making it easy for beginners to learn and practice. 5.

Python for Data Science Handbook: This book is an excellent resource for data science beginners, offering hands-on examples and code snippets that help readers learn how to use Python effectively for data analysis. 6.

Python DS: Python Data Structures: This course offered by the University of Michigan on Coursera is a comprehensive introduction to Python’s data structures, including lists, tuples, dictionaries, and sets. 7.

Real Python: Real Python is a community-driven learning platform that offers numerous tutorials that cover various Python topics, including web development, data analysis, and machine learning.


Python is an excellent programming language for beginners and experienced developers alike. As this article has shown, mastering Python’s syntax and data structures is essential to writing effective code and building complex programs.

These additional resources provide a valuable starting point for expanding your knowledge of Python and related topics. Through continued learning and practice, you can become a more proficient Python developer.

Python’s data structures, syntax, and methods are important and powerful tools for developers to build efficient and elegant programs. This article covered different aspects of Python data structures, including declaring dictionaries, handling TypeErrors for sets, accessing subscriptable objects using square brackets, and more.

By understanding these concepts and using additional resources to expand your knowledge of Python, you can become a more proficient developer. Whether you’re a beginner or an experienced developer, Python’s data structures and syntax offer many advantages that can help you write better code and build more complex programs.

By staying curious and continuing to learn, you can develop the skills necessary to excel in Python programming.