DEV Community

Super Kai (Kazuya Ito)
Super Kai (Kazuya Ito)

Posted on • Edited on

Tuple in Python (1)

#python #tuple #ordered #immutable

Buy Me a Coffee☕

*Memo:

  • My post explains tuple functions and the tuple with indexing.
  • My post explains the tuple with slicing and copy.
  • My post explains a tuple comprehension.
  • My post explains the shallow copy and deep copy of a tuple.
  • My post explains a list and the list with indexing.
  • My post explains a set and the set with copy.
  • My post explains a frozenset (1).
  • My post explains a dictionary (1).
  • My post explains an iterator (1).
  • My post explains a string.
  • My post explains a bytes.
  • My post explains a bytearray.
  • My post explains a range (1).

A tuple:

  • is the ordered 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.
  • cannot be huge because it gets MemoryError.
  • allows duplicated elements (even with different types).
  • is immutable(hashable) so it cannot be changed.
  • can have any types of elements.
  • can be iterated with a for statement.
  • can be unpacked with an assignment and for statement, function and * but not with **.
  • is False if it's empty.
  • can be checked if a specific element is in the tuple with in keyword.
  • can be checked if the tuple is referred to by two variables with is keyword.
  • can be enlarged with * and a number.
  • can be created by (), ,, tuple() with or without an iterable or tuple comprehension:
    • For tuple(), the words type conversion are also suitable in addition to the word creation.
  • can be used with len() to get the length.
  • can be read but cannot be changed by indexing or slicing.
  • can be continuously used through multiple variables.
  • can be shallow-copied and deep-copied.

() 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]))
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 = (0, 1, 2, 3, 4) * 3
v = ('A', 'B', 'C', 'D', 'E') * 3
v = () * 3
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

v = (0, 1, 2, 3, 4) * 1000000000
v = tuple(range(1000000000))
# Error
Enter fullscreen mode Exit fullscreen mode

A tuple is the ordered 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'>
Enter fullscreen mode Exit fullscreen mode 
v = (0,)
v = 0,
v = ((0,))

print(v)
# (0,)
Enter fullscreen mode Exit fullscreen mode 
v = () # Empty tuple

print(v)
# ()
Enter fullscreen mode Exit fullscreen mode

A tuple allows duplicated elements (even with different types) as shown below:

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

print(v)
# (0, 1, 2, 0, 1, 2)
Enter fullscreen mode Exit fullscreen mode 
v = (0, 0.0, 0.0+0.0j, False)

print(v)
# (0, 0.0, 0j, False)
Enter fullscreen mode Exit fullscreen mode 
v = (1, 1.0, 1.0+0.0j, True)

print(v)
# (1, 1.0, (1+0j), True)
Enter fullscreen mode Exit fullscreen mode

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>)
Enter fullscreen mode Exit fullscreen mode

A tuple can be iterated with a for statement as shown below:

<1D tuple>: 

for x in (0, 1, 2, 3, 4):
    print(x)
# 0
# 1
# 2
# 3
# 4
Enter fullscreen mode Exit fullscreen mode

<2D tuple>: 

for x in ((0, 1, 2, 3), (4, 5, 6, 7)):
    for y in x:
        print(y)
# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
Enter fullscreen mode Exit fullscreen mode

<3D tuple>: 

for x in (((0, 1), (2, 3)), ((4, 5), (6, 7))):
    for y in x:
        for z in y:
            print(z)
# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
Enter fullscreen mode Exit fullscreen mode

A tuple can be unpacked with an assignment and for statement, function and * but not with ** as shown below:

v1, v2, v3 = (0, 1, 2)

print(v1, v2, v3)
# 0 1 2
Enter fullscreen mode Exit fullscreen mode 
v1, *v2, v3 = (0, 1, 2, 3, 4, 5)

print(v1, v2, v3)  # 0 [1, 2, 3, 4] 5
print(v1, *v2, v3) # 0 1 2 3 4 5
Enter fullscreen mode Exit fullscreen mode 
for v1, v2, v3 in ((0, 1, 2), (3, 4, 5)):
    print(v1, v2, v3)
# 0 1 2
# 3 4 5
Enter fullscreen mode Exit fullscreen mode 
for v1, *v2, v3 in ((0, 1, 2, 3, 4, 5), (6, 7, 8, 9, 10, 11)):
    print(v1, v2, v3)
    print(v1, *v2, v3)
# 0 [1, 2, 3, 4] 5
# 0 1 2 3 4 5
# 6 [7, 8, 9, 10] 11
# 6 7 8 9 10 11
Enter fullscreen mode Exit fullscreen mode 
print(*(0, 1), 2, *(3, 4, *(5,)))
# 0 1 2 3 4 5
Enter fullscreen mode Exit fullscreen mode 
print((*(0, 1), 2, *(3, 4, *(5,))))
# (0, 1, 2, 3, 4, 5)
Enter fullscreen mode Exit fullscreen mode 
def func(p1='a', p2='b', p3='c', p4='d', p5='e', p6='f'):
    print(p1, p2, p3, p4, p5, p6)

func()
# a b c d e f

func(*(0, 1, 2, 3), *(4, 5))
# 0 1 2 3 4 5
Enter fullscreen mode Exit fullscreen mode 
def func(p1='a', p2='b', *args):
    print(p1, p2, args)
    print(p1, p2, *args)
    print(p1, p2, ['A', 'B', *args, 'C', 'D'])

func()
# a b ()
# a b Nothing
# a b ['A', 'B', 'C', 'D']

func(*(0, 1, 2, 3), *(4, 5))
# 0 1 (2, 3, 4, 5)
# 0 1 2 3 4 5
# 0 1 ['A', 'B', 2, 3, 4, 5, 'C', 'D']
Enter fullscreen mode Exit fullscreen mode

An empty tuple is False as shown below:

print(bool(()))    # Empty tuple
# False

print(bool((0,)))  # tuple
print(bool(((),))) # tuple(Empty tuple)
# True
Enter fullscreen mode Exit fullscreen mode

A tuple can be checked if a specific element is in the tuple with in keyword as shown below:

v = ('A', 'B', ('C', 'D'))

print('B' in v)
# True

print(('C', 'D') in v)
# True

print('b' in v)
# False
Enter fullscreen mode Exit fullscreen mode

A tuple can be enlarged with * and a number as shown below:

<1D tuple>: 

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

print(v)
# (0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4)
Enter fullscreen mode Exit fullscreen mode 
v = ('A', 'B', 'C', 'E', 'D') * 3

print(v)
# ('A', 'B', 'C', 'E', 'D', 'A', 'B', 'C', 'E', 'D', 'A', 'B', 'C', 'E', 'D')
Enter fullscreen mode Exit fullscreen mode 
v = () * 3

print(v)
# ()
Enter fullscreen mode Exit fullscreen mode

<2D tuple>: 

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

print(v)
# ((0, 1, 2, 3, 4), (0, 1, 2, 3, 4), (0, 1, 2, 3, 4))
Enter fullscreen mode Exit fullscreen mode 
v = (('A', 'B', 'C', 'D', 'E'),) * 3

print(v)
# (('A', 'B', 'C', 'D', 'E'),
#  ('A', 'B', 'C', 'D', 'E'),
#  ('A', 'B', 'C', 'D', 'E'))
Enter fullscreen mode Exit fullscreen mode 
v = ((),) * 3

print(v)
# ((), (), ())
Enter fullscreen mode Exit fullscreen mode

<3D tuple>: 

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

print(v)
# (((0, 1, 2, 3, 4),), ((0, 1, 2, 3, 4),), ((0, 1, 2, 3, 4),))
Enter fullscreen mode Exit fullscreen mode 
v = ((('A', 'B', 'C', 'D', 'E'),),) * 3

print(v)
# ((('A', 'B', 'C', 'D', 'E'),),
#  (('A', 'B', 'C', 'D', 'E'),),
#  (('A', 'B', 'C', 'D', 'E'),))
Enter fullscreen mode Exit fullscreen mode 
v = (((),),) * 3

print(v)
# (((),), ((),), ((),))
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

<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))
Enter fullscreen mode Exit fullscreen mode

<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)))
Enter fullscreen mode Exit fullscreen mode

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

v = (0, 1, 2, 3, 4) * 1000000000
# MemoryError
Enter fullscreen mode Exit fullscreen mode 
v = range(100000000)

print(tuple(v))
# MemoryError
Enter fullscreen mode Exit fullscreen mode

A tuple can be used with len() to get the length as shown below:

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

print(len(v))
# 5
Enter fullscreen mode Exit fullscreen mode

Top comments (0)