Tuple in Python (4)

Buy Me a Coffee☕

*Memo:

• My post explains a tuple (1).
• My post explains a tuple (2).
• My post explains a tuple (3).
• My post explains a tuple (5).
• My post explains a tuple (6).

tuple() can create a tuple with or without an iterable as shown below:

*Memo:

• The 1st argument is iterable(Optional-Default:()-Type:Iterable):
  • Don't use iterable=.

# Empty tuple
print(tuple())
print(tuple(()))
# ()

print(tuple([0, 1, 2, 3, 4]))                      # list
print(tuple((0, 1, 2, 3, 4)))                      # tuple
print(tuple({0, 1, 2, 3, 4}))                      # set
print(tuple(frozenset([0, 1, 2, 3, 4]) ))          # frozenset
print(tuple(iter([0, 1, 2, 3, 4])))                # iterator
print(tuple(range(5)))                             # range
# (0, 1, 2, 3, 4)

print(tuple({'name': 'John', 'age': 36}))          # dict
print(tuple({'name': 'John', 'age': 36}.keys()))   # dict.keys()
# ('name', 'age')

print(tuple({'name': 'John', 'age': 36}.values())) # dict.values()
# ('John', 36)

print(tuple({'name': 'John', 'age': 36}.items()))  # dict.items()
# (('name', 'John'), ('age', 36))

print(tuple('Hello'))                              # str
# ('H', 'e', 'l', 'l', 'o')

print(tuple(b'Hello'))                             # bytes
print(tuple(bytearray(b'Hello')))                  # bytearray
# (72, 101, 108, 108, 111)

A tuple comprehension can create a tuple as shown below:

<1D tuple>:

sample = (0, 1, 2, 3, 4, 5, 6, 7)

v = tuple(x**2 for x in sample)

print(v)
# (0, 1, 4, 9, 16, 25, 36, 49)

<2D tuple>:

sample = ((0, 1, 2, 3), (4, 5, 6, 7))

v = tuple(tuple(y**2 for y in x) for x in sample)

print(v)
# ((0, 1, 4, 9), (16, 25, 36, 49))

<3D tuple>:

sample = (((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 sample)

print(v)
# (((0, 1), (4, 9)), ((16, 25), (36, 49)))

Be careful, a big tuple gets MemoryError as shown below:

v = (0, 1, 2, 3, 4) * 1000000000
# MemoryError

v = range(100000000)

print(tuple(v))
# MemoryError

v = tuple(x for x in range(1000000000))
# MemoryError

A tuple can be read by indexing as shown below:

*Memo:

• Indexing can be done with one or more [index] in the range [The 1st index, The last index]:
  • index(Required-Type:int):
    • Don't use index=.
  • index can be signed indices(zero and positive and negative indices).
  • Error occurs if index is out of range.

<1D tuple>:

v = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')
v = 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'

print(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7])
print(v[-8], v[-7], v[-6], v[-5], v[-4], v[-3], v[-2], v[-1])
# A B C D E F G H

v = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')

print(v[-9], v[8])
# IndexError: tuple index out of range

<2D tuple>:

v = (('A', 'B', 'C', 'D'), ('E', 'F', 'G', 'H'))

print(v[0], v[1])
print(v[-2], v[-1])
# ('A', 'B', 'C', 'D') ('E', 'F', 'G', 'H')

print(v[0][0], v[0][1], v[0][2], v[0][3], v[1][0], v[1][1], v[1][2], v[1][3])
print(v[-2][-4], v[-2][-3], v[-2][-2], v[-2][-1],
      v[-1][-4], v[-1][-3], v[-1][-2], v[-1][-1])
# A B C D E F G H

<3D tuple>:

v = ((('A', 'B'), ('C', 'D')), (('E', 'F'), ('G', 'H')))

print(v[0], v[1])
print(v[-2], v[-1])
# (('A', 'B'), ('C', 'D')) (('E', 'F'), ('G', 'H'))

print(v[0][0], v[0][1], v[1][0], v[1][1])
print(v[-2][-2], v[-2][-1], v[-1][-2], v[-1][-1])
# ('A', 'B') ('C', 'D') ('E', 'F') ('G', 'H')

print(v[0][0][0], v[0][0][1], v[0][1][0], v[0][1][1], v[1][0][0],
      v[1][0][1], v[1][1][0], v[1][1][1])
print(v[-2][-2][-2], v[-2][-2][-1], v[-2][-1][-2], v[-2][-1][-1],
      v[-1][-2][-2], v[-1][-2][-1], v[-1][-1][-2], v[-1][-1][-1])
# A B C D E F G H