{"id":2646,"date":"2026-10-19T10:27:29","date_gmt":"2026-10-19T10:27:29","guid":{"rendered":"https:\/\/prwatech.in\/blog\/?p=2646"},"modified":"2026-10-20T05:20:28","modified_gmt":"2026-10-20T05:20:28","slug":"python-tuple-tutorials-with-examples","status":"publish","type":"post","link":"https:\/\/prwatech.in\/blog\/python\/python-data-types\/python-tuple-tutorials-with-examples\/","title":{"rendered":"Python Tuple Tutorial with Examples"},"content":{"rendered":"

Python Tuple Tutorial for Beginners<\/b><\/strong><\/h1>\n

Some information should not change once you have written it. The latitude and longitude of Kolkata. The days of the week. The red, green and blue values of a colour. Python has a data type made for exactly these cases: the tuple. It holds a group of values together, in order, and then locks them.<\/p>\n

A tuple looks a lot like a list, and it is the list’s quieter cousin. The big difference is that a tuple cannot be changed after it is created. That sounds like a limit, but it is a useful promise. When you see a tuple in code, you know its contents will not shift under you. Python also uses tuples everywhere behind the scenes, for example when a function returns two values at once.<\/p>\n

In this tutorial, we explain what a tuple is and how to create one, including the one item tuple that trips up many beginners. We cover repeating, nesting, slicing, and what immutable really means, including a trap where a tuple appears to change. Then we go through the tuple operations: length, count, index, conversion, comparison and membership. We add unpacking, a comparison with lists, common mistakes and the full program. Every output on this page comes from a real run on Python 3.13.<\/p>\n

What is a Python Tuple?<\/h2>\n

A tuple is an ordered collection of values written in round brackets, with commas between the values. Here is what defines it:<\/p>\n

    \n
  • Ordered.<\/strong> The values keep the order you gave them.<\/li>\n
  • Indexed.<\/strong> You reach each value by position, starting at 0.<\/li>\n
  • Immutable.<\/strong> You cannot change, add or remove values after the tuple is created.<\/li>\n
  • Allows duplicates.<\/strong> The same value can appear more than once.<\/li>\n
  • Can mix types.<\/strong> Numbers, text and other objects can sit in one tuple.<\/li>\n<\/ul>\n

    Lists use square brackets and can be changed. Tuples use round brackets and cannot.<\/p>\n

    How to Create a Tuple in Python?<\/h2>\n
    \n
    python<\/div>\n
    tup1 = (1, 2, 3, 6, 7, 8)\r\ntup2 = (\"green\", \"yellow\", \"red\")\r\ntup3 = \"green\", \"red\", \"yellow\"\r\nprint(tup1, tup2, tup3)<\/pre>\n
    output<\/div>\n
    (1, 2, 3, 6, 7, 8) ('green', 'yellow', 'red') ('green', 'red', 'yellow')<\/pre>\n<\/div>\n
    Notice that tup3<\/code> has no brackets at all. It is the comma that makes a tuple, not the brackets. Brackets are only there to make it easier to read. Writing values separated by commas is called tuple packing.<\/p>\n
    An Empty Tuple<\/h3>\n
    \n
    python<\/div>\n
    empty = ()\r\nprint(empty)<\/pre>\n
    output<\/div>\n
    ()<\/pre>\n<\/div>\n
    A Tuple With One Item<\/h3>\n
    This is the most common beginner mistake. A single value in brackets is not a tuple. You need a comma after it.<\/p>\n
    \n
    python<\/div>\n
    single = (15,)\r\nnot_a_tuple = (15)\r\nprint(single, type(single), type(not_a_tuple))<\/pre>\n
    output<\/div>\n
    (15,) <class 'tuple'> <class 'int'><\/pre>\n<\/div>\n
    The brackets in (15)<\/code> only group a number, so it stays an integer.<\/p>\n
    Using the tuple() Function<\/h3>\n
    \n
    python<\/div>\n
    print(tuple([1, 2, 3]))<\/pre>\n
    output<\/div>\n
    (1, 2, 3)<\/pre>\n<\/div>\n
    Repeating Tuples N Times<\/h2>\n
    The star repeats whatever sits before it. With a plain bracketed string, you get one long string. Add a comma and you get a tuple of repeated items.<\/p>\n
    \n
    python<\/div>\n
    print((\"stats\") * 4)\r\nprint((\"stats\",) * 4)<\/pre>\n
    output<\/div>\n
    statsstatsstatsstats\r\n('stats', 'stats', 'stats', 'stats')<\/pre>\n<\/div>\n
    Nested Tuples in Python<\/h2>\n
    A tuple can hold other tuples. The result keeps its layers. It is not flattened.<\/p>\n
    \n
    python<\/div>\n
    a = (0, 4, 8, 12)\r\nb = (\"tuple\", \"python\")\r\nnested = (a, b)\r\nprint(nested)\r\nprint(nested[1][0])<\/pre>\n
    output<\/div>\n
    ((0, 4, 8, 12), ('tuple', 'python'))\r\ntuple<\/pre>\n<\/div>\n
    Use one index per layer. nested[1]<\/code> is the second inner tuple, and nested[1][0]<\/code> is the first item inside it.<\/p>\n
    If you do want a single flat tuple, join them with a plus sign instead:<\/p>\n
    \n
    python<\/div>\n
    a = (0, 4, 8, 12)\r\nb = (\"tuple\", \"python\")\r\nprint(a + b)<\/pre>\n
    output<\/div>\n
    (0, 4, 8, 12, 'tuple', 'python')<\/pre>\n<\/div>\n
    Immutable Tuple in Python<\/h2>\n
    Try to change an item and Python refuses:<\/p>\n
    \n
    python<\/div>\n
    tup = (0, 1, \"x\", \"y\")\r\ntry:\r\n    tup[0] = 4\r\nexcept TypeError as error:\r\n    print(\"TypeError:\", error)<\/pre>\n
    output<\/div>\n
    TypeError: 'tuple' object does not support item assignment<\/pre>\n<\/div>\n
    To get a changed version, build a new tuple. Joining and slicing both create new tuples and leave the original as it was.<\/p>\n
    The Trap: A Tuple Can Hold a List<\/h2>\n
    Immutable means the tuple cannot swap one item for another. But if an item is itself a list, that list can still change:<\/p>\n
    \n
    python<\/div>\n
    mixed = (1, [2, 3])\r\nmixed[1].append(4)\r\nprint(mixed)<\/pre>\n
    output<\/div>\n
    (1, [2, 3, 4])<\/pre>\n<\/div>\n
    The tuple still holds the same list. The list changed inside it. Keep this in mind if you rely on a tuple being fully fixed.<\/p>\n
    Slicing a Tuple in Python<\/h2>\n
    Slicing works exactly like it does for strings and lists. The pattern is tuple[start:end:step]<\/code>. The start is included, and the end is not.<\/p>\n
    \n
    python<\/div>\n
    test = (0, 2, 4, 5, 6, 7, 8, 9, 12)\r\nprint(test[1:])\r\nprint(test[2:5])\r\nprint(test[::-1])\r\nprint(test[-3:-1])<\/pre>\n
    output<\/div>\n
    (2, 4, 5, 6, 7, 8, 9, 12)\r\n(4, 5, 6)\r\n(12, 9, 8, 7, 6, 5, 4, 2, 0)\r\n(8, 9)<\/pre>\n<\/div>\n
    The reverse slice, with a step of minus one, goes backward through the whole tuple.<\/p>\n
    \n\n\n\n\n\n\n\n\n
    Tuple slice examples<\/caption>\n
    Slice<\/th>\nMeaning<\/th>\nResult<\/th>\n<\/tr>\n<\/thead>\n
    test[1:]<\/th>\nFrom position 1 to the end<\/td>\n(2, 4, 5, 6, 7, 8, 9, 12)<\/td>\n<\/tr>\n
    test[2:5]<\/th>\nPositions 2, 3 and 4<\/td>\n(4, 5, 6)<\/td>\n<\/tr>\n
    test[::-1]<\/th>\nEverything, backward<\/td>\n(12, 9, 8, 7, 6, 5, 4, 2, 0)<\/td>\n<\/tr>\n
    test[-3:-1]<\/th>\nFrom the 3rd last to before the last<\/td>\n(8, 9)<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
    Tuple Operations in Python<\/h2>\n
    Deleting a Tuple<\/h3>\n
    You cannot delete one item from a tuple. You can delete the whole tuple with del<\/code>.<\/p>\n
    \n
    python<\/div>\n
    gone = (0, 1, \"a\", \"b\")\r\ndel gone\r\ntry:\r\n    print(gone)\r\nexcept NameError as error:\r\n    print(\"NameError:\", error)<\/pre>\n
    output<\/div>\n
    NameError: name 'gone' is not defined<\/pre>\n<\/div>\n
    The error names the tuple that was deleted. If you only want to remove one item, convert to a list, remove it, and convert back, or build a new tuple by slicing.<\/p>\n
    Length of a Tuple<\/h3>\n
    \n
    python<\/div>\n
    print(len((1, 2, 5, \"testing\", \"length\", \"of\", \"tuple\")))<\/pre>\n
    output<\/div>\n
    7<\/pre>\n<\/div>\n
    count()<\/h3>\n
    count<\/code> tells you how many times a value appears.<\/p>\n
    \n
    python<\/div>\n
    counts = (0, 1, 2, 3, 1, 2, 4, 5, 6, 1, 2, 1)\r\nprint(counts.count(1))<\/pre>\n
    output<\/div>\n
    4<\/pre>\n<\/div>\n
    index()<\/h3>\n
    index<\/code> gives the position of the first match. If the value is missing, it raises a ValueError.<\/p>\n
    \n
    python<\/div>\n
    words = (1, 2, 5, \"a\", \"python\", \"tuple\")\r\nprint(words.index(\"python\"))\r\ntry:\r\n    words.index(\"zzz\")\r\nexcept ValueError as error:\r\n    print(\"ValueError:\", error)<\/pre>\n
    output<\/div>\n
    4\r\nValueError: tuple.index(x): x not in tuple<\/pre>\n<\/div>\n
    These two, count<\/code> and index<\/code>, are the only methods a tuple has. That is because it cannot change, so it has no append, remove or sort.<\/p>\n
    Converting Between Lists, Strings and Tuples<\/h3>\n
    The conversion only happens when you call tuple()<\/code>:<\/p>\n
    \n
    python<\/div>\n
    lis1 = [1, 2, 4, \"a\", \"b\", \"c\", \"e\"]\r\nprint(lis1)\r\nprint(tuple(lis1))<\/pre>\n
    output<\/div>\n
    [1, 2, 4, 'a', 'b', 'c', 'e']\r\n(1, 2, 4, 'a', 'b', 'c', 'e')<\/pre>\n<\/div>\n
    A string turns into a tuple of its characters:<\/p>\n
    \n
    python<\/div>\n
    print(tuple(\"python tuple\"))<\/pre>\n
    output<\/div>\n
    ('p', 'y', 't', 'h', 'o', 'n', ' ', 't', 'u', 'p', 'l', 'e')<\/pre>\n<\/div>\n
    To change a tuple, go through a list and back:<\/p>\n
    \n
    python<\/div>\n
    tup = (0, 1, \"x\", \"y\")\r\nas_list = list(tup)\r\nas_list[0] = 4\r\nprint(tuple(as_list))<\/pre>\n
    output<\/div>\n
    (4, 1, 'x', 'y')<\/pre>\n<\/div>\n
    Comparing Tuples<\/h3>\n
    The old cmp()<\/code> function was removed in Python 3. Use the comparison signs, or min and max. Python compares tuples item by item from the left, and the first difference decides. If one tuple is a prefix of the other, the shorter one is smaller.<\/p>\n
    \n
    python<\/div>\n
    t1 = (1, 2, 3, 4, 5)\r\nt2 = (1, 2, 3, 4, 5, 6)\r\nprint(min(t1, t2), max(t1, t2))\r\nprint(t1 < t2, t1 == t2, (1, 9) < (2, 0))<\/pre>\n
    output<\/div>\n
    (1, 2, 3, 4, 5) (1, 2, 3, 4, 5, 6)\r\nTrue False True<\/pre>\n<\/div>\n
    The last comparison is True because 1 is less than 2, and that first difference settles it. The 9 and 0 never matter.<\/p>\n
    Checking for an Element in a Tuple<\/h3>\n
    \n
    python<\/div>\n
    check = (1, 2, 3, \"a\", \"b\", \"c\")\r\nprint(3 in check, \"x\" in check, \"x\" not in check)<\/pre>\n
    output<\/div>\n
    True False True<\/pre>\n<\/div>\n
    Packing and Unpacking<\/h2>\n
    Unpacking is where tuples shine in real code. You can pull the values out into separate names in one line. The number of names must match the number of values, unless you use a star to collect the rest.<\/p>\n
    \n
    python<\/div>\n
    point = (3, 5)\r\nx, y = point\r\nprint(x, y)\r\nx, y = y, x\r\nprint(x, y)\r\nfirst, *rest = (10, 20, 30, 40)\r\nprint(first, rest)<\/pre>\n
    output<\/div>\n
    3 5\r\n5 3\r\n10 [20, 30, 40]<\/pre>\n<\/div>\n
    The second line swaps two values with no temporary variable. This works because Python packs the right side into a tuple and then unpacks it. Functions that return two values are really returning one tuple.<\/p>\n
    Why Use a Tuple Instead of a List?<\/h2>\n
      \n
    • Safety.<\/strong> The values cannot be changed by mistake.<\/li>\n
    • Signals intent.<\/strong> A tuple tells the reader this group is fixed.<\/li>\n
    • Dictionary keys.<\/strong> A tuple can be a dictionary key, but a list cannot, because a list can change.<\/li>\n
    • Slightly lighter.<\/strong> A tuple generally uses less memory than a list of the same items.<\/li>\n<\/ul>\n
      \n
      python<\/div>\n
      locations = {(22.57, 88.36): \"Kolkata\"}\r\nprint(locations[(22.57, 88.36)])<\/pre>\n
      output<\/div>\n
      Kolkata<\/pre>\n<\/div>\n
      \n\n\n\n\n\n\n\n\n\n
      Tuple compared with list<\/caption>\n
      Point<\/th>\nTuple<\/th>\nList<\/th>\n<\/tr>\n<\/thead>\n
      Brackets<\/th>\nRound, ( )<\/td>\nSquare, [ ]<\/td>\n<\/tr>\n
      Changeable<\/th>\nNo<\/td>\nYes<\/td>\n<\/tr>\n
      Methods<\/th>\nOnly count and index<\/td>\nMany, such as append, remove and sort<\/td>\n<\/tr>\n
      Use as a dictionary key<\/th>\nYes, if its items are unchangeable<\/td>\nNo<\/td>\n<\/tr>\n
      Best for<\/th>\nFixed groups, such as coordinates<\/td>\nCollections that grow or change<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
      Common Mistakes to Avoid<\/h2>\n
        \n
      • Forgetting the comma in a one item tuple.<\/strong> (15)<\/code> is an integer. Write (15,)<\/code>.<\/li>\n
      • Trying to change an item.<\/strong> It raises a TypeError. Build a new tuple instead.<\/li>\n
      • Assuming a tuple is fully frozen.<\/strong> A list inside it can still change.<\/li>\n
      • Using cmp().<\/strong> It does not exist in Python 3.<\/li>\n
      • Capital P in Print.<\/strong> Python is case sensitive, so use print<\/code>.<\/li>\n
      • Mismatched names when unpacking.<\/strong> Two names for three values raises a ValueError.<\/li>\n
      • Expecting a tuple to flatten when nested.<\/strong> It stays layered. Use plus to join.<\/li>\n<\/ul>\n
        Try It Yourself: The Full Program<\/h2>\n
        The program below holds every example in this tutorial. Copy it into a file, run it, and compare your output with what you see above.<\/p>\n
        \n
        python<\/div>\n
        import sys\r\nprint(\"Python\", sys.version_info.major, sys.version_info.minor)\r\n\r\n# Creating tuples\r\ntup1 = (1, 2, 3, 6, 7, 8)\r\ntup2 = (\"green\", \"yellow\", \"red\")\r\ntup3 = \"green\", \"red\", \"yellow\"\r\nempty = ()\r\nsingle = (15,)\r\nnot_a_tuple = (15)\r\nprint(tup1, tup2, tup3)\r\nprint(empty, single, type(single), type(not_a_tuple))\r\nprint(tuple([1, 2, 3]))\r\n\r\n# Repeating\r\nprint((\"stats\") * 4)\r\nprint((\"stats\",) * 4)\r\n\r\n# Nested tuples\r\na = (0, 4, 8, 12)\r\nb = (\"tuple\", \"python\")\r\nnested = (a, b)\r\nprint(nested)\r\nprint(nested[1][0])\r\nprint(a + b)\r\n\r\n# Immutable\r\ntup = (0, 1, \"x\", \"y\")\r\ntry:\r\n    tup[0] = 4\r\nexcept TypeError as error:\r\n    print(\"TypeError:\", error)\r\n\r\n# A tuple can hold a list, and the list can change\r\nmixed = (1, [2, 3])\r\nmixed[1].append(4)\r\nprint(mixed)\r\n\r\n# Slicing\r\ntest = (0, 2, 4, 5, 6, 7, 8, 9, 12)\r\nprint(test[1:])\r\nprint(test[2:5])\r\nprint(test[::-1])\r\nprint(test[-3:-1])\r\n\r\n# Operations\r\nprint(len((1, 2, 5, \"testing\", \"length\", \"of\", \"tuple\")))\r\ncounts = (0, 1, 2, 3, 1, 2, 4, 5, 6, 1, 2, 1)\r\nprint(counts.count(1))\r\nwords = (1, 2, 5, \"a\", \"python\", \"tuple\")\r\nprint(words.index(\"python\"))\r\ntry:\r\n    words.index(\"zzz\")\r\nexcept ValueError as error:\r\n    print(\"ValueError:\", error)\r\n\r\n# Converting\r\nlis1 = [1, 2, 4, \"a\", \"b\", \"c\", \"e\"]\r\nprint(lis1)\r\nprint(tuple(lis1))\r\nprint(tuple(\"python tuple\"))\r\nas_list = list(tup)\r\nas_list[0] = 4\r\nprint(tuple(as_list))\r\n\r\n# Comparing\r\nt1 = (1, 2, 3, 4, 5)\r\nt2 = (1, 2, 3, 4, 5, 6)\r\nprint(min(t1, t2), max(t1, t2))\r\nprint(t1 < t2, t1 == t2, (1, 9) < (2, 0))\r\n\r\n# Membership\r\ncheck = (1, 2, 3, \"a\", \"b\", \"c\")\r\nprint(3 in check, \"x\" in check, \"x\" not in check)\r\n\r\n# Packing and unpacking\r\npoint = (3, 5)\r\nx, y = point\r\nprint(x, y)\r\nx, y = y, x\r\nprint(x, y)\r\nfirst, *rest = (10, 20, 30, 40)\r\nprint(first, rest)\r\n\r\n# A tuple can be a dictionary key, a list cannot\r\nlocations = {(22.57, 88.36): \"Kolkata\"}\r\nprint(locations[(22.57, 88.36)])\r\n\r\n# Deleting a whole tuple\r\ngone = (0, 1, \"a\", \"b\")\r\ndel gone\r\ntry:\r\n    print(gone)\r\nexcept NameError as error:\r\n    print(\"NameError:\", error)<\/pre>\n<\/div>\n