In Python, a
tuple is an immutable, ordered collection of items. Like lists, tuples can
store a sequence of items of different data types (integers, strings, etc.),
but once a tuple is created, you cannot change its contents (i.e., you cannot
add, remove, or modify items).
### Creating
Tuples
You can
create a tuple by placing items inside parentheses `()`, separated by commas.
For example:
```python
# An empty
tuple
empty_tuple
= ()
# A tuple
with integers
int_tuple =
(1, 2, 3)
# A tuple
with mixed data types
mixed_tuple
= (1, "hello", 3.14)
# A tuple
without parentheses (optional)
no_parentheses_tuple
= 1, 2, 3
# A tuple
with a single element (comma is required)
single_element_tuple
= (5,)
```
###
Accessing Tuple Items
You can
access items in a tuple using their index, just like with lists. Python uses
zero-based indexing:
```python
fruits =
("apple", "banana", "cherry")
print(fruits[0]) # Output: apple
print(fruits[1]) # Output: banana
print(fruits[2]) # Output: cherry
```
You can also
use negative indexing to access items from the end of the tuple:
```python
print(fruits[-1]) # Output: cherry
print(fruits[-2]) # Output: banana
```
### Slicing
Tuples
You can
extract a part of a tuple (a subtuple) using slicing. Slicing returns a new
tuple containing the elements between the specified start and end indices:
```python
numbers =
(10, 20, 30, 40, 50)
print(numbers[1:4]) # Output: (20, 30, 40)
print(numbers[:3]) # Output: (10, 20, 30)
print(numbers[2:]) # Output: (30, 40, 50)
```
### Tuple
Immutability
Since tuples
are immutable, you cannot change, add, or remove items once the tuple is
created. If you try to modify a tuple, Python will raise an error:
```python
numbers =
(10, 20, 30)
# Trying to
change an element will raise an error
# numbers[1]
= 25 # TypeError: 'tuple' object does
not support item assignment
# Trying to
append or remove an element will raise an error
#
numbers.append(40) # AttributeError:
'tuple' object has no attribute 'append'
#
numbers.remove(10) # AttributeError:
'tuple' object has no attribute 'remove'
```
### Tuple
Operations
Although
tuples are immutable, you can perform various operations on them, such as:
- **Concatenation**:
You can concatenate two or more tuples using the `+` operator.
```python
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
result = tuple1 + tuple2
print(result)
# Output: (1, 2, 3, 4, 5, 6)
```
-
**Repetition**: You can repeat a tuple using the `*` operator.
```python
fruits = ("apple",
"banana")
result = fruits * 3
print(result)
# Output: ('apple', 'banana', 'apple', 'banana', 'apple', 'banana')
```
-
**Membership Testing**: You can check if an item is in a tuple using the `in`
keyword.
```python
fruits = ("apple",
"banana", "cherry")
print("banana" in fruits) # Output: True
print("orange" in fruits) # Output: False
```
-
**Length**: You can find the number of items in a tuple using the `len()`
function.
```python
numbers = (10, 20, 30, 40)
print(len(numbers)) # Output: 4
```
-
**Iteration**: You can iterate over the items in a tuple using a `for` loop.
```python
for fruit in fruits:
print(fruit)
# Output:
# apple
# banana
# cherry
```
### Tuple
Methods
Tuples have
a few built-in methods:
-
**`count()`**: Returns the number of occurrences of a specified value.
```python
numbers = (1, 2, 2, 3, 4, 2)
print(numbers.count(2)) # Output: 3
```
-
**`index()`**: Returns the index of the first occurrence of a specified value.
```python
print(numbers.index(3)) # Output: 3
```
### Tuple
Packing and Unpacking
- **Tuple
Packing**: Packing is the process of assigning multiple values to a single
tuple.
```python
my_tuple = 1, "hello", 3.14
print(my_tuple) # Output: (1, 'hello', 3.14)
```
- **Tuple
Unpacking**: Unpacking is the process of extracting values from a tuple into
individual variables.
```python
a, b, c = my_tuple
print(a)
# Output: 1
print(b)
# Output: hello
print(c)
# Output: 3.14
```
### Nested
Tuples
Tuples can
contain other tuples, creating a nested tuple.
```python
nested_tuple
= ((1, 2), (3, 4), (5, 6))
print(nested_tuple[1]) # Output: (3, 4)
print(nested_tuple[1][0]) # Output: 3
```
### When to
Use Tuples
Tuples are
useful in situations where you want to ensure that the data cannot be modified
after creation. They are often used for:
-
**Returning multiple values from a function**.
- **Storing
related data** that should not change (e.g., coordinates, dates, etc.).
- **Using as
keys in dictionaries**, since tuples are hashable (unlike lists).
###
Conclusion
Python
tuples are a simple and efficient way to store ordered, immutable collections
of items. They are similar to lists but with the key difference of
immutability, making them ideal for storing data that should not change.
Understanding tuples and how to use them will enhance your ability to write
robust and efficient Python programs.
