Python Tuples are a very important and efficient data structure in Programming Languages that are generally designed to store the ordered and immutable collection of data. With this Python Tuples Tutorial, you are going to learn everything about the Tuples from creating and accessing its elements to advanced operations like iterations and memory view function. Whether you are a beginner who is just getting started with Python or an experienced professional who just wants to brush up concept of Python tuples, this tutorial will help you to write efficient and optimized programs for various tasks like performance optimization, data integrity, and handling any fixed collections of data.
Table of Contents:
What are Tuples in Python?
Python Tuples are one of the fundamental built-in data structures in the Python Programming Language. Tuples in Python are generally designed to store ordered and immutable sequences of data. Unlike Lists, tuples cannot be modified after creation which makes them an ideal choice for representing data in the fixed collection. Their immutability simply ensures the data integrity and performance which is why tuples are used in various fields for solving complex problems and building robust projects.
Key Features of Python Tuples
- Immutable: Python Tuples are immutable, which means once they are created or initialized, we cannot change or modify their elements.
- Ordered: When storing elements in Tuples, the order remains the same like elements remain in the same order in which you have defined them.
- Heterogeneous: In Python Tuples, you can store multiple types of data types like integers, strings, and floats in a single tuple.
- Memory Efficient: They are also memory efficient as they consume less memory than a list while storing the same data.
Learn Python the Right Way
Structured Learning Path to Python Programming for Beginners and Experts
Creating a Tuple in Python
A Python tuple is created using parentheses around the elements in the tuple. Although using parentheses is only optional, it is considered a good practice to use them.
Elements in the tuple can be of different data types or of the same data type. A tuple in Python can have any number of elements.
1. Creating Tuple Using Round Brackets () in Python
Python allows you to create tuples with the use of round brackets (). You can just write the tuple elements within these brackets separated by commas, and assign them to a variable.
Example:
Output:
2. Creating Tuple Using Separated Comma
You can also create the tuples using separated commas without the round braces. This method is also called tuple packing where commas are enough to define tuples.
Example:
Output:
3. Creating Tuple from Other Data Structures in Python
You can also create tuples using other data structures in Python like lists, strings, and dictionaries by using the tuple() function.
Example:
Output:
How to Find the Length of Tuple in Python
To evaluate the length of a tuple of the number of items it has, you can use the len() function.
Example:
Output:
Get 100% Hike!
Master Most in Demand Skills Now!
Accessing Tuple Elements in Python
We can use three different ways of accessing elements in a tuple, that is, indexing, reverse indexing, and using the slice operator.
1. Using Indexes of Tuples in Python
To access an element of a tuple, we simply use the index of that element. We use square brackets around that index number as shown in the example below:
Example:
Output:
2. Using Reverse Indexes of Tuples in Python
Much similar to regular indexing, here, we use the index inside the square brackets to access the elements, with only one difference, that is, we use the index in a reverse manner. Meaning, that the indexing of the elements would start from the last element. Here, we use indexes as −1, −2, −3, and so on, where −1 represents the last element.
The following code block is an example of accessing elements using reverse indexing.
Output:
3. Using the Slicing Operator of Tuples in Python
Using the slicing operator to access elements is nothing new, as we have seen in previous modules as well. As the name suggests, we will slice, that is, extract some elements from the tuple and display them. To do this, we use a colon between the index from where we want to start slicing and the index to where we want to perform it.
The following code block is an example to show how to access elements using the slicing operator:
Output:
Modifying Elements in a Python Tuple
Again, since a tuple is immutable, it is impossible to change or modify the value of a particular element. However, we can take some portion of an existing tuple and create a new tuple using the concatenating operator, as shown in the example below:
Output:
Deleting Python Tuple Elements
Since a tuple in Python is an immutable data type in Python, deleting particular elements in a tuple is not possible. But you can delete the whole tuple by using the del keyword on it.
Output:
This error occurs because the tuple(tup1) has been deleted successfully.
Python Developer Certification
Gain In-Depth Knowledge of Python for Development, Data, and AI
Tuple Methods in Python
There are many built-in Python methods for Python Tuples to perform certain methods:
1. count() Method in Python
The count() method is generally used to count the total number of occurrences of a particular element in Python.
Example:
Output:
2. index() Method in Python
The index() method simply gives the elements of the specified index that are mentioned in the index() parameter.
Example:
Output:
3. Most commonly used tuple methods in Python:
| Method |
Description |
| count(value) |
Returns the number of times a value appears in the tuple. |
| index(value) |
Returns the index of the first occurrence of a value. |
| len(tuple) |
Returns the number of elements in the tuple. |
| min(tuple) |
Returns the smallest element in the tuple. |
| max(tuple) |
Returns the largest element in the tuple. |
| sum(tuple) |
Returns the sum of all elements (for numeric tuples). |
| sorted(tuple) |
Returns a sorted list of tuple elements. |
| tuple(iterable) |
Converts an iterable (list, set, etc.) into a tuple. |
Nested Tuples in Python
Nested Tuples mean that Python Tuples can contain one or more tuples in a single existing Tuple. It is very useful in hierarchical data structures.
Example:
Output:
Iteration over Python Tuples
1. Using Python For Loop
With Python for loop, you can print every value of Python Tuples in a single attempt.
Example:
Output:
2. Using Python enumerate() Function
With the Python enumerate() Function, you can print the Python Tuple elements with their indices.
Example:
Output:
Tuple Operations in Python
Following is the list of some of the most frequently used operations in a Python tuple along with their descriptions and examples.
1. Concatenation Operator in Python Tuples
With the concatenation operator “+”, you can simply join two more tuples in a single tuple without modifying the original tuple.
Example:
Output:
2. Repetition in Python Tuples
If you want to repeat or duplicate the elements of Python tuples you can use the repetition concept.
Example:
Output:
3. Membership Test in Python
In order to check whether the particular element is present in Python Tuple or not, you can do a membership test for it. The True will give the element is present and False will give the element is not present.
Example:
Output:
Python for Data Science and Automation
Automate Tasks and Analyze Data with Python’s Powerful Libraries
Conversion Between Tuples and Lists
1. Convert a Tuple into List in Python
You can convert any tuples into a Python list by simply passing the tuple into the parameter of the list() function. Check out the below example for a better understanding:
Example:
Output:
2. Convert a List into a Tuple in Python
Similarly, you can convert Python Tuples to List by simply passing the list into the parameter of the tuple() function. Check out the below example for a better understanding:
Example:
Output:
Tuple Unpacking
Tuple unpacking basically allows you to assign the tuple elements to multiple variables in just a single statement.
Example:
Output:
Python List of Tuples
Here is the Python code for creating a list of tuples in Python.
Output:
List vs Tuples in Python
The table below explains the differences between lists and tuples in Python.
| Lists |
Tuples |
| Lists are mutable. |
Tuples are immutable. |
| Iterations are time-consuming. |
Iterations are comparatively faster. |
To perform operations like insert,
delete, etc., lists are better. |
Tuples are better for accessing elements |
| Lists have many built-in methods |
Tuples have fewer built-in methods |
| Lists consume more memory. |
Tuples consume less memory than lists. |
Advanced Tuple Operations for Performance Optimization
1. Memory View with Python Tuples
The memoryview() function in Python generally provides direct access to the memory of an object without making any copy of it. It is typically used with byte-like objects in Python such as bytes, bytearray() that simply allows efficient data manipulation without additional memory overhead.
However, Tuples in Python does not support the memoryview() directly as they only store the references of the objects, not raw bytes. But you can use the tuples in conjunction with the memoryview() when you need to deal with immutable byte-like data structures.
Using tuples with memoryview() indirectly with bytes:
Output:
Importance of memoryview() in Python Tuples:
Memory View in Python Tuples is generally very useful when you want to reduce memory consumption at times of handling larger data sets. Also, it helps in many performance-critical applications like image processing and networking.
2. Tuple Caching and Internals
2.1. How Python Optimizes Tuples Internally
For optimizing the tuples internally, Python simply caches small tuples of length up to 0-20 elements in order to improve the performance. However, the caching behaviors are complex and vary based on the Python version. Instead of creating any new tuple object every time, Python simply reuses the previously allocated tuple whenever it is possible.
Example: Tuple caching mechanism
Output:
2.2. Why does this happen?
- Small Integer Optimization: Python generally caches the tuples of small immutable integers.
- Tuple Interning: Also, some short tuples are reused in order to save memory.
- Immutable Optimization: As you cannot change the tuples after their declaration, they are safe to use.
3. Tuple vs Generator
Tuples are basically fixed and immutable data structures in Python. They are very fast for small unchangeable data just like coordinates or days of the week because they are stored at once and as a single object in Python whereas generators store the data in a one-by-one manner whenever required. You can use the generators when you are working with larger and endless data sets.
| Factor |
Tuple |
Generator |
| Memory Usage |
High (stores all elements in RAM) |
Low (generates elements on demand) |
| Speed (Random Access) |
Faster (O(1) indexing) |
Slower (elements generated one by one) |
| Iteration Speed |
Faster for repeated iterations |
Faster for one-time iteration |
| Immutability |
Immutable (safe and optimized) |
Mutable (can track state) |
| Use Case |
Small, frequently accessed datasets |
Large, one-time or infinite datasets |
Named Tuples vs Regular Tuples
A named tuple in Python is simply an upgraded or enhanced version of the tuple that generally allows to access the elements by name instead of just an index. These named tuples are typically created using the collections.namedtuple() which simply makes the code more readable and self-documenting.
Here we have compared the named tuples with the regular ones based on many features:
| Feature |
Regular Tuple |
Named Tuple |
| Access Method |
Index-based (tup[0]) |
Name-based (tup.name) |
| Readability |
Low (hard to interpret) |
High (self-descriptive) |
| Mutability |
Immutable |
Immutable |
| Memory Usage |
Lower |
Slightly higher (due to named fields) |
| Use Case |
Small collections |
Struct-like data representation |
Example of a Regular Tuple:
Example for Named Tuple:
When You Should Use Named Tuples?
- You can use the named tuples when you are working with structured data like records, database rows, and API responses.
- You can use it wherever the code readability is important.
- You can also use the named tuples where the tuple immutability is required but with the descriptive field names.
Memory Optimization: Tuple vs Other Data Structures
| Feature |
Tuple |
List |
Dictionary |
Set |
| Mutability |
Immutable |
Mutable |
Mutable |
Mutable |
| Memory Usage |
Low |
Higher |
Highest |
High |
| Performance |
Faster (fixed size) |
Slower (resizable) |
Slow (hashing) |
Medium (hashing) |
| Use Case |
Fixed collections |
Dynamic collections |
Key-value pairs |
Unique elements |
Best Practices For Using Python Tuples
- Use Python Tuples for Immutable Data: If you want to make sure that the sequence of data you have created must not be modified by others in the future, you need to use Python Tuples for it.
- Use Python Tuples for small collections: For smaller collections of data and maintain the overall performance of the system, you can use Python Tuples for it.
With this, we come to the end of this tutorial on Python Tuples. By learning these Python Tuples, you will be able to write more effective and efficient Python Code in order to solve any complex Python Problems.
Useful Resources:
Now, if you want to know why Python is the most preferred language for data science, you can go through this Python for Data Science course by Intellipaat. Further, check out our offers for Python training Courses and also refer to the trending Python coding interview questions prepared by industry experts.
FAQs
Why are Tuples immutable in Python?
Tuples are generally immutable in Python in order to maintain data integrity and optimize the overall performance. With its immutability feature, tuples are hashable and it also safeguards the data against unintended modifications.
How do I create a Python Tuple?
You can simply create a Python tuple using round braces and initialize it with some name of your choice. There are also other methods to create tuples like using separated commas and using tuple() constructor.
What is the difference between a List and a Tuple?
Lists are simply mutable in Python which means that data present in the list can be changed or modified whereas Tuples are immutable in Python as you cannot change or modify the data present in it.
How to Create an Empty Tuple in Python?
In order to create an empty tuple in Python, you can either use empty brackets() or an empty tuple() constructor.
Can a Tuple in Python store elements of different data types?
Yes, Tuples in Python can store different data types like integers, strings, lists, etc, in a single sequence of elements
