Study of motorcies (tuple) in Python: creation, properties and application for storing immutable data

Tuples in Python are ordered immutable collections of objects. They are one of the main built-in data types in Python and can contain elements of various types: numbers, strings, lists, and other tuples. Due to their immutability, tuples take up less memory compared to lists, which makes them more efficient for temporary data storage.

Creating a tuple

Parentheses () are used to create a tuple. or the tuple() function:

my_tuple = (1, 2, 3)
empty_tuple = ()
single_element_tuple = (4,) # tuple of one element

# Creating a tuple using the tuple()
function tuple_from_list = tuple([1, 2, 3])
tuple_from_string = tuple("hello")
print(tuple_from_string) # Outputs: ('h', 'e', 'l', 'l', 'o')

Important: when creating a tuple of a single element, you must put a comma after the element, otherwise Python will not recognize it as a tuple.

Features of working with tuples

Indexing and cross-sections

Like lists, tuples support indexing and slicing of elements:

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[0])     # Outputs: 1
print(my_tuple[-1]) # Outputs: 5 (last element)
print(my_tuple[2:4]) # Outputs: (3, 4)
print(my_tuple[:3]) # Outputs: (1, 2, 3)
print(my_tuple[::2]) # Will output: (1, 3, 5)

Immutability of tuples

Once a tuple is created, it cannot be changed - you cannot change its elements, delete or add new ones.:

my_tuple = (1, 2, 3)
# my_tuple[0] = 10 # This will result in a TypeError error

However, if the tuple contains mutable objects (for example, lists), then these objects themselves can be changed:

tuple_with_list = (1, [2, 3], 4)
tuple_with_list[1].append(5)
print(tuple_with_list) # Outputs: (1, [2, 3, 5], 4)

Practical application of tuples

Unpacking tuples

Tuples support unpacking, which allows you to assign values to multiple variables at the same time:

coordinates = (10, 20)
x, y = coordinates
print(f"x = {x}, y = {y}")  # Outputs: x = 10, y = 20

# Exchange values of variables
a, b = 1, 2
a, b = b, a
print(a, b) # Outputs: 2 1

Usage in functions

Tuples are often used to return multiple values from a function.:

def get_coordinates():
    return (10, 20)

def get_name_age():
return "Ivan", 25

x, y = get_coordinates()
name, age = get_name_age()
print(f"Coordinates: x={x}, y={y}")  # Outputs: Coordinates: x=10, y=20
print(f"Name: {name}, Age: {age}")  # Will output: Name: Ivan, Age: 25

Use in cycles

Tuples can be used in loops to iterate through the elements.:

my_tuple = (1, 2, 3)
for item in my_tuple:
    print(item)

# Iteration with indexes
for index, value in enumerate(my_tuple):
print(f"Index {index}: {value}")

Methods and functions for working with tuples

Built-in tuple methods

count()

The count() method returns the number of occurrences of the specified value in the tuple:

my_tuple = (1, 2, 3, 2, 4, 2)
print(my_tuple.count(2)) # Outputs: 3
print(my_tuple.count(10)) # Outputs: 0

index()

The index() method returns the index of the first occurrence of the specified value:

my_tuple = (1, 2, 3, 2, 4, 2)
print(my_tuple.index(2)) # Outputs: 1
# print(my_tuple.index(10)) # Will cause a ValueError

Built-in functions for tuples

len()

The len() function returns the number of elements in the tuple:

my_tuple = (1, 2, 3, 4, 5)
print(len(my_tuple))  # Will output: 5

sorted()

The sorted() function returns a sorted list of tuple elements:

my_tuple = (4, 2, 1, 3, 5)
sorted_list = sorted(my_tuple)
print(sorted_list) # Will output: [1, 2, 3, 4, 5]

# Sort in descending
order sorted_desc = sorted(my_tuple, reverse=True)
print(sorted_desc) # Outputs: [5, 4, 3, 2, 1]

max() and min()

The max() and min() functions return the maximum and minimum elements:

my_tuple = (4, 2, 1, 3, 5)
print(max(my_tuple))  # Outputs: 5
print(min(my_tuple))  # Will output: 1

sum()

The sum() function returns the sum of the elements in the tuple:

my_tuple = (1, 2, 3)
print(sum(my_tuple))  # Will output: 6

Operations with tuples

Concatenation and multiplication

Tuples support concatenation and multiplication operations:

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined = tuple1 + tuple2
print(combined) # Will output: (1, 2, 3, 4, 5, 6)

repeated = tuple1 * 3
print(repeated) # Outputs: (1, 2, 3, 1, 2, 3, 1, 2, 3)

Checking the accessory

To check the presence of an element in the tuple, the in operator is used:

my_tuple = (1, 2, 3, 4, 5)
print(3 in my_tuple) # Outputs: True
print(10 in my_tuple)    # Outputs: False
print(10 not in my_tuple) # Outputs: True

Advantages of using tuples

1. Immutability: protects data from accidental modification
2. Memory efficiency: they take up less memory compared to lists
3. Speed: faster when creating and iterating
4. Hashability: can be used as dictionary keys
5. Semantic clarity: shows that data should not change

When to use tuples

Tuples are ideal for:

• Storing coordinates and other immutable data
• Return multiple values from functions
• Creating data structures that should not change
• Using dictionaries as keys
• Configuration data

Tuples are an important Python tool for working with immutable sequences of data. Using them correctly will help you create more efficient and reliable code.