Maison >développement back-end >Tutoriel Python >Tuples Python : un guide complet avec des exemples
In Python, tuples are one of the four built-in data structures, alongside lists, sets, and dictionaries. A tuple is an immutable, ordered collection of elements. This means that once a tuple is created, its elements cannot be changed, added, or removed. Tuples are especially useful when you want to ensure that a collection of values remains constant throughout your program.
Tuples are created by enclosing elements in parentheses () and separating them with commas. Let’s look at a few examples:
my_tuple = (1, 2, 3) print(my_tuple)
Output:
(1, 2, 3)
In the above example, we created a tuple with three integer elements.
Tuples can hold elements of different types, including strings, integers, floats, and even other tuples or lists.
mixed_tuple = (1, "Hello", 3.5) print(mixed_tuple)
Output:
(1, 'Hello', 3.5)
This tuple contains an integer, a string, and a float.
Interestingly, you can create a tuple without using parentheses—by simply separating the values with commas:
tuple_without_parentheses = 10, 20, 30 print(tuple_without_parentheses)
Output:
(10, 20, 30)
However, using parentheses makes the code more readable and is a preferred practice.
Since tuples are ordered, you can access elements in them using index positions. Indexing in Python starts at 0, so the first element has an index of 0, the second element has an index of 1, and so on.
my_tuple = (10, 20, 30, 40) print(my_tuple[1]) # Output: 20 print(my_tuple[3]) # Output: 40
You can slice tuples to access a range of elements. This is done using the syntax tuple[start:end], where start is the starting index (inclusive) and end is the ending index (exclusive).
my_tuple = (10, 20, 30, 40, 50) print(my_tuple[1:4]) # Output: (20, 30, 40)
In this example, we sliced the tuple to extract elements from index 1 to 3.
Tuple unpacking allows you to assign the elements of a tuple to individual variables in a single operation.
my_tuple = (1, 2, 3) a, b, c = my_tuple print(a) # Output: 1 print(b) # Output: 2 print(c) # Output: 3
Tuple unpacking is especially useful when you need to work with the individual elements of a tuple.
Just like lists, tuples can be nested. This means that a tuple can contain other tuples or even other data structures like lists or dictionaries.
nested_tuple = (1, (2, 3), [4, 5]) print(nested_tuple)
Output:
(1, (2, 3), [4, 5])
In this example, the tuple contains an integer, another tuple, and a list.
A key feature of tuples is that they are immutable, meaning you cannot change the values of an existing tuple. Let’s see what happens when you try to modify an element of a tuple:
my_tuple = (1, 2, 3) my_tuple[0] = 10 # This will raise an error
Error:
TypeError: 'tuple' object does not support item assignment
As shown above, you cannot assign a new value to an element of a tuple once it has been created.
Here are a few basic operations you can perform on tuples:
tuple1 = (1, 2) tuple2 = (3, 4) result = tuple1 + tuple2 print(result) # Output: (1, 2, 3, 4)
my_tuple = (1, 2) result = my_tuple * 3 print(result) # Output: (1, 2, 1, 2, 1, 2)
my_tuple = (1, 2, 3) print(2 in my_tuple) # Output: True print(4 in my_tuple) # Output: False
my_tuple = (1, 2, 3) print(len(my_tuple)) # Output: 3
Tuples are a powerful and efficient data structure in Python, particularly when you need to work with immutable collections of items. They are ideal for cases where you want to ensure that the data does not change throughout your program. With the ability to store heterogeneous data, support for slicing, tuple unpacking, and other useful operations, tuples offer a versatile way to organize and manage data in Python.
By understanding how tuples work and how to use them effectively, you can write cleaner, more efficient, and more secure Python code.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!