What Are Python Data Structures?

Python data structures are formats for organizing, storing and processing data in Python according to different types. There are four main types of built-in Python data structures: lists, tuples, sets and dictionaries.

What Is a Data Structure?

A data structure is a way to organize data in computer memory so it can be easily accessed and used by computer programs. Every data structure has a specific format for organizing, processing, retrieving and storing data, allowing data to be manipulated in various ways by users and computer systems. Data structures are fundamental to modern software and programming languages. They can be built-in or user-defined, and range from basic to advanced types.

Built-In vs. User-Defined Data Structures in Python

Built-in data structures are data structures supported by default in a programming language. They come with pre-defined syntax and behavior, and can be used without having to import additional libraries or modules. In Python, this includes data structures like lists, tuples, sets and dictionaries.

User-defined data structures are data structures created by users that aren’t supported natively in a programming language, but work to achieve similar functionality to existing programming concepts. A user-defined data structure can give users more control over data and how to manipulate it in a program, and may be implemented by importing additional libraries or modules. In Python, user-defined data structures can include arrays, stacks, queues, trees, linked lists, graphs and hash maps.

What Are the 4 Built-In Python Data Structures?

The four primary built-in data structures used in Python are lists, sets, tuples and dictionaries. 

1. Lists

Lists are a type of data structure containing an ordered collection of items. They are crucial to executing projects in Python. 

Every item contained within a list has an inherent order used to identify them, which remains consistent throughout the life of the list. Lists are mutable, allowing elements to be searched, added, moved and deleted after creation. Lists can also be nested, allowing them to contain any object, including other lists and sublists.

Creating a List in Python

#creating an empty list
my_list = []

#filling and printing the list
my_list = [1, 2, 3, “abc”, 1.5]
print(my_list)

#Output: [1, 2, 3, ‘abc’, 1.5] 

2. Tuples

A tuple contains much of the same functionality as a list, albeit with limited functionality. The primary difference between the two is that a tuple is immutable, meaning it cannot be modified or deleted once defined. Tuples are best when a user intends to keep an object intact throughout its lifetime to prevent the modification or addition of data.

Creating a Tuple in Python

#creating an empty tuple
my_tuple = ()

#filling and printing the tuple
my_tuple = (1, 2, 3, “abc”, 1.5)
print(my_tuple)

#Output: (1, 2, 3, ‘abc’, 1.5)

3. Sets

A set is a collection of unique elements with no defined order, which are utilized when an object only needs to exist within a collection of objects and its order or number of appearances are not important.

Creating a Set in Python

#creating and printing a set
my_set = {1, 2, 3, “abc”, 1.5}
print(my_set)

#output of elements in the tuple is randomized, so it can vary every time the program is run 

4. Dictionaries

Dictionaries are unique and immutable objects that consist of key-value pairs and are accessible through unique keys in the dictionary.

Creating a Dictionary in Python

#creating an empty dictionary
my_dict = {}

#filling and printing the dictionary
my_dict =	{
    "name": "Bob",
    "occupation": "Programmer",
    "start date": 1984
}

print(my_dict)

#using keys to access certain values
name = my_dict["name"]
occupation = my_dict["occupation"]

#printing the key values
print(name, ",", occupation)

What Are User-Defined Data Structures in Python?

User-defined data structures add additional functionality to Python, thereby allowing users to access, modify or preserve data in specific ways. In addition to Python’s built-in data structures, there are a number of user-defined data structures you can use, such as arrays, stacks, queues, trees and more. Many of these user-defined data structures can also be considered advanced Python data structures, since they have functionality that extends beyond the basic data structures included in Python.

• Arrays: Arrays function similarly to lists, but allow only homogeneous elements to be stored within them, whereas lists may contain heterogeneous elements.
• Stacks: Stacks are linear data structures in which the data that is published last may be accessed first. Stacks are commonly utilized in recursive programming and for undo functions in word processors.
• Queues: A queue works opposite of a stack and is based on the First-In-First-Out (FIFO) principle, that is the data entered first may be accessed last.
• Trees: Trees are non-linear data structures that incorporate roots and nodes to create a hierarchy of data. These structures are used heavily on HTML pages.
• Linked lists: Linked lists are abstract data structures where data is organized in nodes that link to each other in a list-like format. They can be efficient when needing to insert, find or remove items, in comparison to regular arrays or lists.

Related3 Ways to Write Pythonic Conditional Statements

Python Data Structures: Advantages and Disadvantages

Each data structure offers a different way of completing tasks such as sorting, inserting and finding, but efficiency depends on the situation.

No data structure is ultimately better than another, but using one for a task it is not designed to support may lead to longer workflows, or worse, skewed data. 

• Linked lists are purpose-built for inserting and deleting data but only offer sequential access to this data, which means searching and sorting can be problematic.
• Similar to a list, tuples can be used for outputting either an entire tuple or individual elements, but they use less memory space and do not allow sorting, adding, replacing or deleting elements once defined.
• Sets are intentionally designed to be limited but excel in checking for a value’s existence and avoiding duplicates in a set.
• Dictionaries allow data to be collected in key-value pairs, making them excellent for quick retrievals in unstructured documents, but are too limited to work with large amounts of tabular data.
• Arrays are easy to create and excellent for completing tasks that involve working with sequential data, but sorting, inserting and deleting items can shift positions for every item in the array.
• Stacks are excellent for adding or removing data that was last entered within the database, and queues are meant to add or remove data first entered in the data set, but if you want to pull an item from the middle of the set, you’ll benefit from using a different data structure. 
• Binary search trees allow you to access, sort and delete data quickly while maintaining the sorted order of element s once retrieved. Despite these advantages, binary search trees can require a tedious amount of work to create and manage.

Frequently Asked Questions