{"id":5799,"date":"2022-03-26T14:05:31","date_gmt":"2022-03-26T13:05:31","guid":{"rendered":"http:\/\/miro.borodziuk.eu\/?p=5799"},"modified":"2026-01-22T17:54:01","modified_gmt":"2026-01-22T16:54:01","slug":"tuples","status":"publish","type":"post","link":"http:\/\/miro.borodziuk.eu\/index.php\/2022\/03\/26\/tuples\/","title":{"rendered":"Tuples"},"content":{"rendered":"

1. Tuples<\/strong> are ordered and unchangeable (immutable) collections of data. They can be thought of as immutable lists. They are written in round brackets:<\/p>\n

\n
\n
<\/div>\n
<\/div>\n
my_tuple = (1, 2, True, \"a string\", (3, 4), [5, 6], None)\r\nprint(my_tuple)\r\n\r\nmy_list = [1, 2, True, \"a string\", (3, 4), [5, 6], None]\r\nprint(my_list)<\/pre>\n
Each tuple element may be of a different type (i.e., integers, strings, booleans, etc.). What is more, tuples can contain other tuples or lists (and the other way round).<\/p>\n<\/div>\n<\/div>\n
 <\/p>\n
2. You can create an empty tuple like this:<\/p>\n
empty_tuple = ()\r\n\r\nprint(type(empty_tuple)) # outputs: <class 'tuple'><\/pre>\n
 <\/p>\n
3. A one-element tuple may be created as follows:<\/code><\/p>\n
\n
\n
one_elem_tuple_1 = (\"one\", ) # Brackets and a comma.\r\none_elem_tuple_2 = \"one\", # No brackets, just a comma.<\/pre>\n
If you remove the comma, you will tell Python to create a variable<\/b>, not a tuple:<\/p>\n<\/div>\n<\/div>\n
\n
\n
my_tuple_1 = 1,\r\nprint(type(my_tuple_1)) # outputs: <class 'tuple'>\r\n\r\nmy_tuple_2 = 1 # This is not a tuple.\r\nprint(type(my_tuple_2)) # outputs: <class 'int'><\/pre>\n<\/div>\n<\/div>\n
 <\/p>\n
4. You can access tuple elements by indexing them:<\/p>\n
\n
\n
my_tuple = (1, 2.0, \"string\", [3, 4], (5, ), True)\r\nprint(my_tuple[3]) # outputs: [3, 4]<\/pre>\n
 <\/p>\n
5. Tuples are immutable<\/b>, which means you cannot change their elements (you cannot append tuples, or modify, or remove tuple elements). The following snippet will cause an exception:<\/p>\n<\/div>\n<\/div>\n
\n
\n
my_tuple = (1, 2.0, \"string\", [3, 4], (5, ), True)\r\nmy_tuple[2] = \"guitar\" # The TypeError exception will be raised.<\/pre>\n
However, you can delete a tuple as a whole:<\/p>\n<\/div>\n<\/div>\n
\n
\n
my_tuple = 1, 2, 3,\r\ndel my_tuple\r\nprint(my_tuple) # NameError: name 'my_tuple' is not defined<\/pre>\n
 <\/p>\n
6. You can loop through a tuple elements (Example 1), check if a specific element is (not)present in a tuple (Example 2), use the len()<\/code> function to check how many elements there are in a tuple (Example 3), or even join\/multiply tuples (Example 4):<\/p>\n
\n
\n
\n
# Example 1\r\ntuple_1 = (1, 2, 3)\r\nfor elem in tuple_1:\r\n  print(elem)\r\n\r\n# Example 2\r\ntuple_2 = (1, 2, 3, 4)\r\nprint(5 in tuple_2)\r\nprint(5 not in tuple_2)\r\n\r\n# Example 3\r\ntuple_3 = (1, 2, 3, 5)\r\nprint(len(tuple_3))\r\n\r\n# Example 4\r\ntuple_4 = tuple_1 + tuple_2\r\ntuple_5 = tuple_3 * 2\r\n\r\nprint(tuple_4)\r\nprint(tuple_5)<\/pre>\n
 <\/p>\n
7. You can also create a tuple using a Python built-in function called tuple()<\/code>. This is particularly useful when you want to convert a certain iterable (e.g., a list, range, string, etc.) to a tuple:<\/p>\n<\/div>\n<\/div>\n
\n
\n
my_tuple = tuple((1, 2, \"string\"))\r\nprint(my_tuple)\r\n\r\nmy_list = [2, 4, 6]\r\nprint(my_list) # outputs: [2, 4, 6]\r\n\r\nprint(type(my_list)) # outputs: <class 'list'>\r\ntup = tuple(my_list)\r\n\r\nprint(tup) # outputs: (2, 4, 6)\r\nprint(type(tup)) # outputs: <class 'tuple'><\/pre>\n<\/div>\n<\/div>\n
 <\/p>\n
By the same fashion, when you want to convert an iterable to a list, you can use a Python built-in function called list()<\/code>:<\/p>\n
\n
\n
tup = 1, 2, 3,\r\nmy_list = list(tup)\r\nprint(type(my_list)) # outputs: <class 'list'><\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
 <\/p>\n
 <\/p>\n
Exercise 1<\/em><\/p>\n
What happens when you attempt to run the following snippet?<\/p>\n
my_tup = (1, 2, 3) \r\nprint(my_tup[2])<\/pre>\n
 <\/p>\n
The program will print 3<\/code> to the screen.<\/p>\n
 <\/p>\n
Exercise 2<\/em><\/p>\n
What is the output of the following snippet?<\/p>\n
tup = 1, 2, 3\r\na, b, c = tup \r\nprint(a * b * c)<\/pre>\n
 <\/p>\n
The program will print 6<\/code> to the screen. The tup<\/code> tuple elements have been “unpacked” in the a<\/code>, b<\/code>, and c<\/code> variables.<\/p>\n
 <\/p>\n
Exercise 3<\/em><\/p>\n
Complete the code to correctly use the count()<\/code> method to find the number of duplicates of 2<\/code> in the following tuple.<\/p>\n
tup = 1, 2, 3, 2, 4, 5, 6, 2, 7, 2, 8, 9 \r\nduplicates = # Write your code here. \r\n\r\nprint(duplicates) # outputs: 4<\/pre>\n
Solution:<\/p>\n
tup = 1, 2, 3, 2, 4, 5, 6, 2, 7, 2, 8, 9 \r\nduplicates = tup.count(2) \r\nprint(duplicates) # outputs: 4<\/pre>\n
 <\/p>\n
\n
\n
\n
\n
\n
Ex. 4<\/div>\n<\/div>\n
\n
What is the output of the following code snippet?<\/p>\n
tpl = ('a', 'b', 'c', 'd')\r\ndel tpl[-3:-1]\r\n\r\nprint(tpl)<\/pre>\n<\/div>\n
 <\/p>\n
A TypeError<\/strong><\/code> exception<\/p>\n
    \n
  • Tuples<\/strong> are immutable<\/strong> and do not support item deletion.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
     <\/p>\n
    Ex. 5<\/p>\n
    \n
    \n
    \n
    Which of the following statements about lists<\/strong> and tuples<\/strong> are false<\/strong>?<\/p>\n
    (Select two answers)<\/p>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    \n
    \n
    \n
    \n
    Tuples have a fixed length, while lists have a variable length<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    \n
    \n
    \n
    The sort()<\/strong>, insert()<\/strong>, and append()<\/strong> methods belong to both tuples and lists<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    \n
    \n
    \n
    Lists are indexed while tuples are an unordered set<\/code><\/p>\n
    \n
    Tuples are immutable, while lists are mutable collections of data<\/code><\/p>\n<\/div>\n
    \n
    \n
    <\/div>\n
    <\/div>\n
    Correct selection<\/span><\/div>\n
    \n
    \n
    The sort()<\/strong><\/code>, insert()<\/strong><\/code>, and append()<\/strong><\/code> methods belong to both tuples and lists<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    \n
    \n
    \n
    Lists are indexed while tuples are an unordered set<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    \n
      \n
    • Both lists and tuples are indexed<\/strong> (with initial index equal to 0<\/strong><\/code>).<\/li>\n
    • sort()<\/strong><\/code>, pop()<\/strong><\/code>, and append()<\/strong><\/code> are list methods and cannot be used with tuples.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n
       <\/p>\n
      Ex. 6<\/p>\n
      \n
      \n
      \n
      According to the following code snippet, which of the following statements generates an exception<\/strong>?<\/p>\n
      (Select two answers)<\/p>\n
      \n
      \n
      tpl = (3, 'xy', ['A', 'B'], 2, (9, 10))<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
      \n
      \n
      \n
      \n
      \n
      a, b, c, d = tpl <\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
      \n
      \n
      \n
      \n
      del tpl[3:]<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
      \n
      \n
      \n
      \n
      print(tpl[4][0])<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
      \n
      \n
      \n
      \n
      print(tpl[2:100])<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
      \n
      <\/div>\n
      \n
      Correct selections:<\/span><\/p>\n
      \n
      \n
      \n
      \n
      \n
      \n
      \n
      a, b, c, d = tpl <\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
      \n
      \n
      \n
      \n
      del tpl[3:]<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
        \n
      • del tpl[3:]<\/strong><\/code> – It throws a TypeError<\/strong><\/code> exception. The del<\/strong><\/code> statement cannot delete the elements of a tuple because tuples are immutable<\/strong>.<\/li>\n
      • print(tpl[2:100])<\/strong><\/code> – It is correct<\/strong>. Even if the final index is out of range, the slice operator does not raise an error but takes all elements down to the last. Thus, in our case, it will take all elements starting from that of index <\/strong>2<\/strong><\/code>, inclusive, up to the end of the tuple:print(tpl[2:100])<\/strong><\/code> -> <\/strong>(['A', 'B'], 2, (9, 10))<\/strong><\/code>.<\/li>\n
      • a, b, c, d = tpl<\/strong><\/code>\u00a0 – This is an example of unpacking<\/strong> tuples, but the statement is wrong<\/strong> because the number of variables to the left of the equal does not match the number of elements of the tuples to the right. It raises an ValueError<\/strong><\/code> exception:step by step<\/strong>Step 1 – a, b, c, d = tpl<\/strong><\/code>Step 2 – a, b, c, d = (3, 'xy', ['A', 'B'], 2, (9, 10))<\/strong><\/code>\n
        Result – ValueError<\/strong><\/code><\/li>\n
      • print(tpl[4][0])<\/strong><\/code> – <\/strong>It is ok<\/strong>. The print()<\/strong><\/code> function prints the value of index 0<\/strong><\/code> of the last element of tpl<\/strong><\/code>:step by step<\/strong>Step 1 – print(tpl[4][0])<\/strong><\/code>Step 2 – print((9, 10)[0])<\/strong><\/code>\n
        Step 3 – print(9)<\/strong><\/code><\/p>\n
        Output – 9<\/strong><\/code><\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n
         <\/p>\n
        Ex. 7<\/p>\n
        Consider the code below:<\/p>\n<\/div>\n
            my_tuple = ('Luke', 'Leia', 'Han', 'Darth')\r\n    # Insert line of code here.\r\n    for x in my_v:\r\n        print(x, end=' ')<\/pre>\n
        Which snippet would you insert in order for the program to output the following result:<\/p>\n
        Leia Han Darth<\/code><\/p>\n
        \n
        \n
        A:\u00a0 <\/span>my_v = [my_tuple[i] for i in range(1,4)]<\/code><\/div>\n<\/div>\n<\/div>\n
        \n
        \n
        \n
        \n
        \n
        \n
        B: <\/span><\/p>\n
        del my_tuple[0]\r\nmy_v = my_tuple<\/pre>\n
        C: my_v = my_tuple.pop(0)<\/code><\/p>\n
        D: my_v = my_tuple[1:3]<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
        \n
        Explanation:<\/em><\/p>\n
        A tuple is an immutable <\/strong>sequence type !<\/p>\n
        So del my_tuple[0] <\/code>\u00a0 is not permitted and will raise an exception.<\/p>\n
        my_v = [my_tuple[i] for i in range(1,4)]<\/code>\u00a0 is a list comprehension and results in the following list:<\/p>\n
        ['Leia', 'Han', 'Darth']<\/code><\/p>\n
        which when printed element by element (with the optional end=' '<\/code> parameter within the print()<\/code> function) gives :<\/p>\n
        Leia Han Darth<\/code><\/p>\n
        my_tuple[1:3] <\/code>(slicing) returns : ('Leia', 'Han')<\/code>\u00a0 (new tuple with only the elements with index 1 and 2 from the original tuple – remember element with index 3 is not included<\/strong> in the slice).<\/p>\n
        Finally my_tuple.pop(0)<\/code>\u00a0 will raise an exception since there is no such method with tuples (it does work with lists).<\/p>\n
        Try it yourself:<\/p>\n
            my_tuple = ('Luke', 'Leia', 'Han', 'Darth')\r\n    del my_tuple[0]    # TypeError: 'tuple' object doesn't support item deletion\r\n    my_v = my_tuple\r\n    for x in my_v:\r\n        print(x, end=' ')\r\n     \r\n    print('\\n------')\r\n     \r\n    my_tuple = ('Luke', 'Leia', 'Han', 'Darth')\r\n    my_v = [my_tuple[i] for i in range(1,4)]\r\n    for x in my_v:\r\n        print(x, end=' ')  # Leia Han Darth \r\n     \r\n    print('\\n------')\r\n     \r\n    my_tuple = ('Luke', 'Leia', 'Han', 'Darth')\r\n    my_v = my_tuple[1:3]\r\n    for x in my_v:\r\n        print(x, end=' ')  # Leia Han \r\n     \r\n    print('\\n------')\r\n     \r\n    my_tuple = ('Luke', 'Leia', 'Han', 'Darth')\r\n    my_v = my_tuple.pop(0)  # AttributeError: 'tuple' object has no attribute 'pop'\r\n    for x in my_v:\r\n        print(x, end=' ')<\/pre>\n
        A.<\/p>\n<\/div>\n
         <\/p>\n","protected":false},"excerpt":{"rendered":"
        1. Tuples are ordered and unchangeable (immutable) collections of data. They can be thought of as immutable lists. They are written in round brackets:<\/p>\n","protected":false},"author":2,"featured_media":5803,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[100],"tags":[],"_links":{"self":[{"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts\/5799"}],"collection":[{"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/comments?post=5799"}],"version-history":[{"count":14,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts\/5799\/revisions"}],"predecessor-version":[{"id":6251,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts\/5799\/revisions\/6251"}],"wp:featuredmedia":[{"embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/media\/5803"}],"wp:attachment":[{"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/media?parent=5799"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/categories?post=5799"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/tags?post=5799"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}