Python Language Tuple
Internal
TODO
- TO PROCESS: PyOOP "Tuples and named tuples", "Named tuples"
Overview
A tuple is a immutable sequence type that contains zero or more elements and whose elements can be of different types. Once a tuple is defined, you can't add, delete or change items. A tuple is similar to a constant list, and could be used instead of a list, if we can afford the "list" to be immutable. Naturally, the list's mutating functions append(), insert() do not exist on tuples. There are several advantages of using a tuple instead of a list: a tuple uses less space than a list and they cannot be mutated by mistake. Positional function arguments can be grouped together and provided as a tuple in the function body (*args).
Declaration
A tuple is declared by specifying commas after each of its elements, with the exception of the empty tuple, that uses ():
empty_tuple = ()
one_element_tuple = 1, # the trailing comma is mandatory
two_element_tuple = 1,2, # for two or more elements, the trailing comma is optional
For aesthetic reasons, and also to make the tuple more visible, the comma-driven declaration can be enclosed in optional parentheses:
empty_tuple = ()
one_element_tuple = (1,) # the trailing comma is mandatory
two_element_tuple = (1,2,) # for two or more elements, the trailing comma is optional
Access a Tuple
To access the elements of a tuple, use the same bracket notation as for a list. The index is 0-based:
t = ('a', 'b', 'c')
assert 'a' == t[0]
Conversion from other Data Structures with tuple()
The tuple() converts lists, or iterables, in general, to tuples:
l = ['a', 'b', 'c']
t = tuple(l)
print(t)
assert 'a' == t[0]
assert 'b' == t[1]
assert 'c' == t[2]
Tuple Concatenation
Tuple Concatenation with +
Tuples can be concatenate with the + operator:
t = (1, 2, 3) + (4, 5)
Tuple Concatenation with *
Multiplying the tuple by an integer has the effect of concatenating that many copies of the tuple. t = (1, 2) * 3 # (1, 2, 1, 2, 1, 2) </syntaxhighlight>
Tuple Unpacking
Assigning multiple variable at once is called "tuple unpacking":
t = (1, 'B', 3.0)
a, b, c = t
print(a) # will print 1
print(b) # will print 'B'
print(c) # will print 3.0
A common use of variable unpacking is iterating over sequences of tuples of lists:
seq = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
for a, b, c in seq:
printf(f'{a}, {b}, {c}')
Exchanging Variable Values
Tuple unpacking can be used to swap to variable values without using a third temporary variable.
v1 = 'A'
v2 = 'B'
v1, v2 = v2, v1
print(v1) # will print B
print(v2) # will print A
Plucking a Few Elements from the Beginning of a Tuple
t = (1, 2, 3, 4, 5)
a, b, *rest = values # a is 1, b is 2 and rest is (3, 4, 5)
If you want to discard the rest:
t = (1, 2, 3, 4, 5)
a, b, *_ = values
Named Tuples
Named tuples can be a simple alternative to objects.