A Tuple is exactly the same as a List, except that it is immutable.

Once we create a tuple object, we cannot perform any changes to that object.

Because of this property, a tuple is called the Read-Only version of List.

If our data is fixed and never changes, then we should use a Tuple.

Since tuple objects are immutable, they provide better protection for fixed data.

A Python tuple has the following characteristics:

• Insertion order is preserved.
• Duplicate objects are allowed.
• Heterogeneous objects are allowed.
• Tuple objects are immutable.

1. Insertion Order is Preserved

The elements are stored in the same order in which they are inserted.

2. Duplicate Objects are Allowed

A tuple can contain duplicate values.

3. Heterogeneous Objects are Allowed

A tuple can store different types of data together.

The above tuple contains:

• Integer values
• String values
• Duplicate value (10)

Tuple objects are immutable.

Once a tuple is created, its contents cannot be changed.

Because of this property, a tuple is called the Read-Only version of List.

Since insertion order is preserved, indexes play an important role in tuples.

Indexes help us access elements and differentiate duplicate objects.

Python supports two types of indexing:

• Positive Index
• Negative Index

Positive Index	Negative Index
Starts from left to right.	Starts from right to left.
First index is 0.	Last index is -1.

Element	10	20	30	40
Positive Index	0	1	2	3
Negative Index	-4	-3	-2	-1

No output captured.

Tuple elements are represented using parentheses ().

Each element is separated by a comma (,).

Parentheses are optional, but it is recommended to use them.

An empty tuple can be created using empty parentheses.

Special care is required while creating a tuple with only one element.

The value must end with a comma (,).

Otherwise, Python will not treat it as a tuple.

Tuple elements can be accessed in two ways:

1. Using Index
2. Using Slice Operator

Python supports both positive and negative indexing.

We can access multiple elements from a tuple using the slice operator.

Topic	Description
Tuple	Read-only version of List
Insertion Order	Preserved
Duplicate Objects	Allowed
Heterogeneous Objects	Allowed
Immutable	Yes
Representation	Parentheses ()
Positive Index	Left to Right
Negative Index	Right to Left
Slice Operator	Access multiple elements

• Tuple is exactly the same as a List except that it is immutable.
• If the data never changes, we should use a Tuple.
• Tuple preserves insertion order.
• Duplicate objects are allowed.
• Heterogeneous objects are allowed.
• Tuple supports both positive and negative indexing.
• Parentheses are optional but recommended while creating a tuple.
• A single-valued tuple must end with a comma (,).
• Tuple elements can be accessed using indexes or the slice operator.
• Since tuples are immutable, their elements cannot be modified after creation.

The most important feature of a tuple is that it is immutable.

Once a tuple is created, its elements cannot be modified, added, or removed.

If we try to change any element, Python raises an error.

The tuple object is immutable.

Therefore, existing elements cannot be modified after the tuple is created.

Unlike lists, tuples do not provide methods such as append(), extend(), or insert().

This is because tuples are immutable.

• Tuple elements cannot be modified.
• New elements cannot be added.
• Existing elements cannot be removed.
• The complete tuple object can be deleted using del.

Although tuple elements cannot be deleted individually, the complete tuple object can be deleted.

Python supports several operators for tuples.

The most commonly used tuple operators are:

• Concatenation Operator (+)
• Repetition Operator (*)

The + operator joins two tuples and returns a new tuple.

The original tuples are not modified.

• The + operator creates a new tuple.
• The original tuples remain unchanged.
• Only tuples can be concatenated.

The * operator repeats the elements of a tuple.

A new tuple containing repeated elements is returned.

The original tuple is not modified.

A new tuple is created with repeated elements.

+	*
Joins two tuples.	Repeats tuple elements.
Requires two tuples.	Requires one tuple and an integer.
Returns a combined tuple.	Returns a repeated tuple.

Operator	Purpose
+	Concatenate two tuples.
*	Repeat tuple elements.

Tuples are commonly used in:

• Configuration data
• Coordinate values
• Fixed records
• Database results
• Function return values

• Tuple objects are immutable.
• Tuple elements cannot be modified after creation.
• The + operator joins two tuples.
• The * operator repeats tuple elements.
• Both operators return new tuple objects.
• The original tuples remain unchanged.

Topic	Description
Immutability	Tuple elements cannot be modified.
+	Concatenate tuples.
*	Repeat tuple elements.
del	Delete the complete tuple.

Python provides several built-in functions and methods to get information about a tuple.

The most commonly used tuple functions are:

• len()
• count()
• index()
• sorted()
• min()
• max()

These functions help us find the size, search elements, count duplicate values, sort elements, and find minimum and maximum values.

The len() function returns the total number of elements present in a tuple.

Syntax:

The len() function counts every element present in the tuple.

The data type of the elements does not affect the result.

The count() method returns the number of occurrences of a specified element.

Syntax:

If the specified element is not present, the count() method returns 0.

The index() method returns the index of the first occurrence of the specified element.

Syntax:

If duplicate elements are available, the index of the first occurrence is returned.

The sorted() function sorts tuple elements and returns them as a new list.

The original tuple remains unchanged.

Syntax:

The return type of sorted() is a list, not a tuple.

The original tuple is not modified.

The min() function returns the smallest element from the tuple.

The max() function returns the largest element from the tuple.

Function / Method	Purpose
len()	Returns the number of elements.
count()	Returns the number of occurrences.
index()	Returns the first occurrence index.
sorted()	Returns a sorted list.
min()	Returns the smallest element.
max()	Returns the largest element.

count()	index()
Returns the number of occurrences.	Returns the index of the first occurrence.
Returns 0 if the element is not available.	Raises ValueError if the element is not available.

Tuple functions are commonly used in:

• Searching records
• Finding duplicate values
• Statistical calculations
• Sorting reports
• Finding minimum and maximum values

• len() returns the total number of elements.
• count() returns the number of occurrences of an element.
• index() returns the index of the first occurrence only.
• sorted() always returns a list.
• The original tuple remains unchanged after using sorted().
• min() returns the smallest value.
• max() returns the largest value.

Function / Method	Description
len()	Returns the number of elements.
count()	Counts duplicate elements.
index()	Returns the first occurrence index.
sorted()	Returns a sorted list.
min()	Returns the smallest value.
max()	Returns the largest value.

Tuple Packing is the process of assigning multiple values to a single tuple.

Python automatically packs all values into a tuple.

Parentheses are optional while packing a tuple.

Python automatically packs all the given values into a tuple object.

This process is called Tuple Packing.

• Python automatically creates the tuple.
• Parentheses are optional.
• Multiple values are packed into a single tuple object.

Tuple Unpacking is the process of assigning tuple elements to individual variables.

The number of variables must be equal to the number of tuple elements.

The first value is assigned to the first variable.

The second value is assigned to the second variable.

The third value is assigned to the third variable.

Tuple packing and unpacking are commonly used to swap two variables without using a temporary variable.

The number of variables and tuple elements must be the same.

Otherwise, Python raises a ValueError.

The * operator collects multiple remaining elements into a list.

This is useful when the number of tuple elements is greater than the number of variables.

Tuple Packing	Tuple Unpacking
Multiple values are stored in one tuple.	Tuple elements are assigned to variables.
Creates a tuple.	Extracts values from a tuple.
One tuple object is created.	Multiple variables receive values.

Operation	Purpose
Tuple Packing	Store multiple values in a tuple.
Tuple Unpacking	Assign tuple values to variables.
* Operator	Collect remaining values during unpacking.

Tuple packing and unpacking are commonly used in:

• Returning multiple values from functions.
• Swapping variables.
• Processing database records.
• Reading CSV and Excel data.
• Handling multiple values efficiently.

• Tuple packing combines multiple values into a tuple.
• Tuple unpacking separates tuple elements into variables.
• Parentheses are optional while packing.
• The number of variables and tuple elements should normally be equal.
• The * operator collects remaining elements into a list.
• Tuple unpacking is commonly used for variable swapping.

Topic	Description
Tuple Packing	Store multiple values into one tuple.
Tuple Unpacking	Assign tuple elements to variables.
* Operator	Collect remaining elements during unpacking.
Variable Swapping	Swap values without a temporary variable.

Unlike lists, Python does not support tuple comprehension.

If we write an expression similar to list comprehension using parentheses, Python creates a Generator Object instead of a tuple.

Therefore, tuple comprehension is not available in Python.

The above expression does not create a tuple.

Instead, it creates a generator object.

The values are generated one by one whenever required.

If we want a tuple from a generator object, we can pass the generator to the tuple() function.

A generator is a special type of iterable.

It generates values one at a time instead of storing all values in memory.

This helps in saving memory when working with a large amount of data.

• Consumes less memory.
• Generates values only when required.
• Suitable for large data processing.
• Improves program performance.

List Comprehension	Tuple Expression
Creates a List.	Creates a Generator Object.
Uses square brackets [].	Uses parentheses ().
Stores all values immediately.	Generates values one by one.

List	Tuple
Mutable	Immutable
Uses square brackets [].	Uses parentheses ().
Supports append(), extend(), insert(), remove(), etc.	Does not support modification methods.
Suitable for frequently changing data.	Suitable for fixed data.
Consumes more memory.	Consumes less memory.
Slightly slower.	Slightly faster.

• When data changes frequently.
• When elements need to be added or removed.
• When the collection needs to be modified.

• When data is fixed.
• When values should not be modified.
• When better performance and less memory usage are required.

Feature	List	Tuple
Order	Preserved	Preserved
Duplicates	Allowed	Allowed
Heterogeneous Data	Allowed	Allowed
Mutable	Yes	No
Indexing	Supported	Supported
Slicing	Supported	Supported
Memory Usage	More	Less
Performance	Slower	Faster

• Python does not support tuple comprehension.
• Using parentheses with a comprehension creates a generator object.
• The tuple() function converts a generator into a tuple.
• Generators produce values one by one.
• Generators consume less memory than lists.
• Lists are mutable, whereas tuples are immutable.
• Choose a list when data changes frequently.
• Choose a tuple when data remains fixed.

Topic	Description
Tuple	Immutable ordered collection.
Indexing	Positive and Negative indexing supported.
Slicing	Supported.
Packing	Store multiple values in one tuple.
Unpacking	Assign tuple values to variables.
Tuple Expression	Creates a Generator Object.
Generator	Produces values one by one.
Use Tuple	When data should not change.