Tuple in Python (1)

#python #tuple #ordered #immutable

Buy Me a Coffee☕

*Memo:

My post explains a tuple (2).
My post explains a tuple (3).
My post explains a tuple (4).
My post explains a tuple (5).
My post explains a tuple (6).
My post explains tuple functions.
My post explains a tuple comprehension.
My post explains a tuple shallow and deep copy.
My post explains a list (1).
My post explains a set (1).
My post explains a frozenset (1).
My post explains a dictionary (1).
My post explains an iterator (1).
My post explains a string (1).
My post explains a bytes (1).
My post explains a bytearray (1).
My post explains a range (1).

A tuple:

is the ordered immutable(hashable) collection of zero or more elements whose type is tuple:
- Ordered means that the order of each element in a tuple is kept so it guarantees that the order is always the same.
- Immutable(Hashable) means the elements of a tuple cannot be changed.
allows duplicated elements.
can have any types of elements.
can be used with len() to get the length.
is True if it's non-empty and False if it's empty, checking it with bool().
is False if it's non-empty and True if it's empty, inverting the truth value with not keyword.
can be checked if a specific element is and isn't in the tuple with in keyword and with not and in keyword respectively.
can be checked if the tuple is and isn't referred to by two variables with is keyword and with is and not keyword respectively:
- Be careful, tuple literals with is keyword and with is and not keyword get warnings so use == and != respectively.
and other tuple can be checked if all the elements in:
- them are and aren't the same with == and != respectively.
- the tuple are in other tuple with <=.
- other tuple are in the tuple with >=.
- the tuple and other elements are in other tuple with <.
- other tuple and other elements are in the tuple with >.
and other tuple cannot be checked if they have and don't have their common elements with bool() and & and with not keyword and & respectively.
can be enlarged with * and a number.
and other tuples can be concatenated with +.
and other tuples cannot return:
- all the elements in them with '|' (Union: A ∪ B).
- their common elements with '&' (Intersection: A ∩ B).
- the elements in the tuple which aren't in other tuples with '-' (Difference: A - B).
and other tuple cannot return the elements in the tuple but not in other tuple or not in the tuple but in other tuple with '^' (Symmetric Difference: A Δ B).
can be iterated with a for statement.
can be unpacked with an assignment and for statement, function and * but not with **.
can be created by () and/or ',', by tuple() with or without an iterable and by a tuple comprehension:
- For tuple(), the words type conversion are also suitable in addition to the word creation.
cannot be big because it gets MemoryError.
can be read by indexing and slicing.
cannot be changed by indexing, slicing and a del statement.
can be continuously used through multiple variables.
cannot be shallow-copied by copy.copy(), tuple().
cannot be deep-copied and even shallow-copied by copy.deepcopy().

Be careful, a big tuple gets `MemoryError`.

() and/or ',' can create a tuple as shown below:

v = ()                                   # Empty 1D tuple
v = (0,)                                 # 1D tuple
v = 0,                                   # 1D tuple
v = (0)                                  # int not tuple
v = 0                                    # int not tuple
v = (0),                                 # 1D tuple
v = (0, 1, 2, 3, 4)                      # 1D tuple
v = 0, 1, 2, 3, 4                        # 1D tuple
v = (0, 1, 2, 0, 1, 2)                   # 1D tuple
v = ((0,),)                              # 2D tuple
v = (((0),)),                            # 2D tuple
v = (0, 1, 2, 3, (4, 5, 6, 7))           # 2D tuple
v = ((0, 1, 2, 3), (4, 5, 6, 7))         # 2D tuple
v = (((0,),),)                           # 3D tuple
v = (((((0),)),)),                       # 3D tuple
v = ((0, 1, 2, 3), ((4, 5), (6, 7)))     # 3D tuple
v = (((0, 1), (2, 3)), ((4, 5), (6, 7))) # 3D tuple
# No error

v = (0, 0.0, 0.0+0.0j, False)
v = (1, 1.0, 1.0+0.0j, True)
v = ('A', b'A', bytearray(b'A'), 2, 2.3, 2.3+4.5j, True,
     [2, 3], (2, 3), {2, 3}, frozenset({2, 3}), {'A':'a'},
     range(2, 3), iter([2, 3]))
print(len((0, 1, 2, 3, 4)))
print(bool((0,)))
print(bool(((),)))
print(bool(()))
print(not (0,))
print(not ((),))
print(not ())
print('A' in ('A', ('B', 'C')))
print('A' not in ('A', ('B', 'C')))
print((0, 1, 2) is (0, 1, 2))     # It gets warning so use `==`.
print((0, 1, 2) is not (0, 1, 2)) # It gets warning so use `!=`.
print((0, 1, 2) == (0, 1, 2))
print((0, 1, 2) != (0, 1, 2))
print((0, 1, 2) <= (0, 1, 2))
print((0, 1, 2) >= (0, 1, 2))
print((0, 1, 2) < (0, 1, 2))
print((0, 1, 2) > (0, 1, 2))
v = (0, 1, 2, 3, 4) * 3
v = ('A', 'B', 'C', 'D', 'E') * 3
v = () * 3
v = (0, 1, 2) + ((3, 4),) + (((5, 6, 7, 8),),)
for x in (0, 1, 2, 3, 4): pass
for x in ((0, 1, 2, 3), (4, 5, 6, 7)): pass
for x in (((0, 1), (2, 3)), ((4, 5), (6, 7))): pass
v1, v2, v3 = (0, 1, 2)
v1, *v2, v3 = (0, 1, 2, 3, 4, 5)
for v1, v2, v3 in ((0, 1, 2), (3, 4, 5)): pass
for v1, *v2, v3 in ((0, 1, 2, 3, 4, 5), (6, 7, 8, 9, 10, 11)): pass
print(*(0, 1), 2, *(3, 4, *(5,)))
print((*(0, 1), 2, *(3, 4, *(5,))))
v = tuple(x**2 for x in (0, 1, 2, 3, 4, 5, 6, 7))
v = tuple(tuple(y**2 for y in x) for x in ((0, 1, 2, 3), (4, 5, 6, 7)))
v = tuple(tuple(tuple(z**2 for z in y) for y in x) for x in
        (((0, 1), (2, 3)), ((4, 5), (6, 7))))
# No error

print(bool((0, 1, 2) & (1, 3)))
print(not ((0, 1, 2) & (1, 3)))
print((0, 4) | (0, 2, 4) | (0, 1, 3, 4))
print((0, 4) & (0, 2, 4) & (0, 1, 3, 4))
print((0, 4) - (0, 2, 4) - (0, 1, 3, 4))
print((0, 1, 2, 3) ^ (0, 2, 4))
v = (0, 1, 2, 3, 4) * 1000000000
v = tuple(range(1000000000))
v = tuple(x for x in range(1000000000))
# Error

A tuple is the ordered immutable(hashable) collection of zero or more elements whose type is tuple as shown below:

v = (0, 1, 2, 3, 4)
v = 0, 1, 2, 3, 4

print(v)
# (0, 1, 2, 3, 4)

print(type(v))
# <class 'tuple'>

v[1] = 'X'
v[3] = 'Y'
# TypeError: 'tuple' object does not support item assignment

v = (0,)
v = 0,
v = ((0,))

print(v)
# (0,)

v = () # Empty tuple

print(v)
# ()

A tuple allows duplicated elements as shown below:

v = (0, 1, 2, 0, 1, 2)

print(v)
# (0, 1, 2, 0, 1, 2)

v = (0, 0.0, 0.0+0.0j, False)

print(v)
# (0, 0.0, 0j, False)

v = (1, 1.0, 1.0+0.0j, True)

print(v)
# (1, 1.0, (1+0j), True)

A tuple can have any types of elements as shown below:

v = ('A', b'A', bytearray(b'A'), 2, 2.3, 2.3+4.5j, True,
     [2, 3], (2, 3), {2, 3}, frozenset({2, 3}), {'A':'a'},
     range(2, 3), iter([2, 3]))
print(v)
# ('A', b'A', bytearray(b'A'), 2, 2.3, (2.3+4.5j), True,
#  [2, 3], (2, 3), {2, 3}, frozenset({2, 3}), {'A': 'a'},
#  range(2, 3), <list_iterator object at 0x000001F3B99BF250>)