{"id":334,"date":"2021-05-15T17:18:04","date_gmt":"2021-05-15T16:18:04","guid":{"rendered":"https:\/\/glennrowe.net\/programmingpages\/?p=334"},"modified":"2021-05-31T12:14:33","modified_gmt":"2021-05-31T11:14:33","slug":"tuples","status":"publish","type":"post","link":"https:\/\/glennrowe.net\/programmingpages\/2021\/05\/15\/tuples\/","title":{"rendered":"Tuples"},"content":{"rendered":"

A Python tuple is an ordered, immutable set of data items. By\u00a0ordered<\/em>, we mean that the items in a tuple are stored in a definite order, not necessarily that they are sorted. By\u00a0immutable,<\/em> we mean that the elements of a tuple cannot be altered or deleted, and the tuple itself cannot be extended or contracted.<\/p>\n

It might seem that a tuple is just a crippled version of a list<\/a>, but in fact, it appears from documentation that tuples and lists are intended to be used in different applications. Although Python is dynamically typed, so that data of different types can be mixed together within both lists and tuples, a list is primarily intended to be used for collections of data of the same type, much like an array in other languages. A tuple, on the other hand, is primarily intended to store a collection of related items, such as the name, date of birth and nationality of a person. Thus a tuple might be used to store data on one particular person, while data for all persons in a group might be stored as a list of tuples. Viewed in this way, a Python tuple is similar to a struct in C# or C++ (although data in structs can<\/em> be altered, so the comparison isn’t entirely accurate).<\/p>\n

A tuple can be defined by listing the data fields separated by commas and (optionally) enclosed in parentheses. Open a Python PowerShell<\/a> and try the following:<\/p>\n

tup = 1, 2, 3\r\ntup<\/pre>\n
You’ll get (1, 2, 3) printed out. When displaying a tuple, the elements are always enclosed in parentheses, but the parentheses are optional when defining a tuple. Thus, we could have typed tup = (1, 2, 3)<\/code> instead of the first line above.<\/p>\n
To create a tuple with a single element you can type either tup = 1,<\/code> or tup = (1,)<\/code>. The trailing comma is needed to tell Python that you want a tuple and not just a primitive int.<\/p>\n
Accessing tuple elements<\/h2>\n
Although a tuple is immutable, we can access (in a read-only sense) its elements using the same subscripting and slicing syntax that we introduced in the discussion lists<\/a>. Try the following in the PowerShell:<\/p>\n
tup = tuple(x for x in range(12))\r\ntup\r\ntup[6]\r\ntup[0:8]\r\ntup[8:0]\r\ntup[1:5:2]\r\ntup[::-1]\r\n\r\n<\/pre>\n
The first line uses the tuple constructor to create a tuple by using a\u00a0generator<\/em>. This is similar to list comprehension<\/a> that we looked at earlier, but in the case of tuples, we need to explicitly use the constructor name rather than just enclosing the generator in parentheses. That is, tup = (x for x in range(12))<\/code> won’t give you a tuple (try it!). It’s not an invalid statement though; rather it returns a generator object, which isn’t of much use here.<\/p>\n
Returning to the above example, line 2 produces the tuple (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11). Line 3 produces the seventh element tup[6]<\/code>, which is 6 here. Line 4 returns a tuple consisting of elements 0 through 7 (remember that the ‘end’ index is the index\u00a0after<\/em> the last one included), so we get (0, 1, 2, 3, 4, 5, 6, 7). The expression tup[8:0]<\/code> gives an impossible index range, so it returns an empty tuple ()<\/code>.<\/p>\n
Next, tup[1:5:2]<\/code> starts at tup[1]<\/code> and proceeds to tup[4]<\/code> in steps of 2, so we get (1, 3). Finally, tup[::-1]<\/code> starts at the end and proceeds backwards through tuple in steps of 1, so it returns the tuple in reverse order: (11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0).<\/p>\n
It’s important to note that, in all the cases where we used a slice (that is, one or two colons), the expression returns a\u00a0new <\/em>tuple containing the desired elements. The original tuple is unchanged.<\/p>\n
Joining tuples<\/h2>\n
Tuples can be joined using the + operator. Consider:<\/p>\n
tup = tuple(x for x in range(12))\r\nxup = tuple(x for x in range(12, 20, 2))\r\ntup\r\nxup\r\nyup = tup + xup\r\nyup\r\nyup += xup\r\n<\/pre>\n
This generates tup as the same tuple as before: (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11), and xup as the tuple starting at 12 and ending at 19, in steps of 2, so we have xup = (12, 14, 16, 18).<\/p>\n
The statement yup = tup + xup<\/code> generates a new tuple consisting of xup joined onto the end of tup, so we have yup = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16, 18).<\/p>\n
The last line might come as a surprise. It\u00a0is<\/em> a valid statement, and if you print out yup afterwards, you’ll get (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 12, 14, 16, 18), so it seems that yup has been modified by appending another copy of xup. However, this statement doesn’t actually violate the immutability of tuples. What the statement yup += xup<\/code> is doing is effectively the statement\u00a0 yup = yup + xup<\/code>. The right-hand side generates a new tuple which is the concatenation of yup and xup, and then this new tuple is assigned to the variable yup. In other words, yup now points at a brand new tuple and the old version of yup is lost. Immutability is preserved.<\/p>\n
Packing and unpacking<\/h2>\n
The statement tup = 1, 2, 3<\/code> that we started with is an example of\u00a0packing<\/em> data into a tuple. Tuples allow their contents to be\u00a0unpacked<\/em> into individual variables as well. Consider:<\/p>\n
tup = 1, 2, 3\r\na, b, c = tup\r\na\r\nb\r\nc\r\n<\/pre>\n
Line 2 unpacks tup into 3 separate variables, so we have a = 1, b = 2 and c = 3 afterwards. Unpacking requires that the number of variables on the left-hand side exactly matches the number of elements in the tuple.<\/p>\n
Tuples and lists<\/h2>\n
You can convert a tuple into a list and vice versa by using the corresponding constructor. For example:<\/p>\n
tup = 1, 2, 3\r\ntupList = list(tup)\r\ntupList[1] = 9\r\ntup = tuple(tupList)\r\ntup\r\n<\/pre>\n
We create the tuple (1, 2, 3) and convert it the list tupList<\/code>. Since lists are mutable, we can change its element 1 to 9, and then convert it back to a tuple, which now reads (1, 9, 3). Although this sort of thing is possible, it’s probably not the best program design, since it indicates that you’re not using the right data type (tuple vs list) in the first place.<\/p>\n
Exercise<\/h2>\n
Write a program that asks the user to input a sequence of shopping items where each item has a name and a price. The data for each item should be stored in a tuple, and the program should maintain a list of these tuples. When the user enters ‘quit’, the program should then calculate and print the total cost of the items in the list.<\/p>\n
The cost of each item should be in the usual format of pounds and pence, or dollars and cents, so the numeric value of the cost will require 2 digits after the decimal point. Use the Decimal data type<\/a> to store the cost.<\/p>\nSee answer<\/span>
\n
from decimal import *\r\nshopList = []\r\nwhile True:\r\n    item = input('Enter item\\'s name and price separated by a comma, or \\'quit\\': ')\r\n    if item == 'quit':\r\n        break\r\n    itemData = item.split(',')\r\n    itemTup = itemData[0], Decimal(itemData[1])\r\n    shopList += [itemTup]\r\ncost = Decimal('0.0')\r\nfor tup in shopList:\r\n    cost += tup[1]\r\nprint('Total cost =', cost)\r\n\r\n<\/pre>\n
After reading in the data on line 4, we check for ‘quit’. If we’re still adding an item, we split the input string on the comma on line 7, then store the two parts of the data in a tuple on line 8. Since a Decimal<\/code> requires a string argument to store the value without roundoff error, we can pass itemData[1]<\/code> directly to the Decimal<\/code> constructor. We then add itemTup<\/code> to shopList<\/code>, but note that we need to enclose itemTup<\/code> in square brackets [itemTup]<\/code> so that the tuple gets added as a single element to the list shopList<\/code>. If we omitted the brackets, the individual elements of itemTup<\/code> would be added to shopList<\/code>, and not the tuple.<\/p>\n
After the user enters ‘quit’, control passes to the for loop on line 11, where we add up the costs of the items.<\/p>\n<\/div>\n
Named tuples<\/h2>\n
Since one of the main uses of tuples is the creation of structured data types for storing data fields of mixed, but fixed, types, having to refer to the individual data fields by their index number can lead to obscure program code that is hard to read. There is a special type of tuple called the\u00a0namedtuple<\/em> available in the collections<\/code> module. We won’t go into great detail here, but will give a simple example of how you can define and use a named tuple.<\/p>\n
from collections import *\r\nEmployee = namedtuple('Employee', ['name', 'age', 'nationality'])\r\nempList = []\r\nwhile True:\r\n    empData = input('Name, age, nationality (or quit): ')\r\n    if empData == 'quit':\r\n        break\r\n    empData = empData.split()\r\n    emp = Employee(empData[0], int(empData[1]), empData[2])\r\n    empList += [emp]\r\nprint('Employees\\'s names:')\r\nfor x in empList:\r\n    print(x.name)\r\n    \r\n\r\n<\/pre>\n
Line 1 imports the collections<\/code> module, which includes the definition of namedtuple<\/code>. On line 2, we define a namedtuple called Employee<\/code> (the object to the left of the =). The constructor for namedtuple takes 2 arguments. The first is a string which is the name of the data type (which we’re calling Employee<\/code>). The second argument is a list of strings which define the names of the data fields in the tuple. Here, we’re storing the name, age and nationality of each employee. Note that, due to dynamic typing, we do\u00a0not<\/em> define the data types of these data fields.<\/p>\n
The while<\/code> loop on line 4 allows the user to enter the name, age and nationality of a number of employees. We’re not doing any error checking on the input, but in a real application you would, of course, need to do this.<\/p>\n
On line 9, we create an Employee<\/code> namedtuple called emp<\/code>, and store the name, age and nationality in this tuple. Line 10 adds the tuple to the master list empList<\/code>. Note that we want each entry in empList<\/code> to be a tuple, so we need to enclose emp<\/code> in brackets, as [emp]<\/code>. Otherwise, each element within emp<\/code> would be added to empList as a separate item, and the namedtuple would be lost.<\/p>\n
Line 12 loops over the entries in empList<\/code> to print out only the employees’ names. Note that on line 13 we can refer to the data field by using its label ‘name’ rather than having to use the index notation [0]. This makes the code clearer and easier to read.<\/p>\n
Exercise<\/h2>\n
Rewrite the shopping list program from the first exercise so that it uses a namedtuple to store the name and cost for each item.<\/p>\nSee answer<\/span>
\n
from decimal import *\r\nfrom collections import *\r\nItem = namedtuple('Item', ['name', 'cost'])\r\nshopList = []\r\nwhile True:\r\n    item = input('Enter item\\'s name and price separated by a comma, or \\'quit\\': ')\r\n    if item == 'quit':\r\n        break\r\n    itemData = item.split(',')\r\n    itemTup = Item(itemData[0], Decimal(itemData[1]))\r\n    shopList += [itemTup]\r\ncost = Decimal('0.0')\r\nfor tup in shopList:\r\n    cost += tup.cost\r\nprint('Total cost =', cost)\r\n\r\n\r\n<\/pre>\n
The changes from the first version are:<\/p>\n
    \n
  • importing the collections module on line 2<\/li>\n
  • defining the Item namedtuple on line 3<\/li>\n
  • creating an Item tuple on line 10 to store the data for a single item<\/li>\n
  • using the name ‘cost’ of the data field rather than its index number on line 14<\/li>\n<\/ul>\n<\/div>\n
     <\/p>\n","protected":false},"excerpt":{"rendered":"
    A Python tuple is an ordered, immutable set of data items. By\u00a0ordered, we mean that the items in a tuple are stored in a definite order, not necessarily that they are sorted. By\u00a0immutable, we mean that the elements of a tuple cannot be altered or deleted, and the tuple itself cannot be extended or contracted. […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-334","post","type-post","status-publish","format-standard","hentry","category-python","entry"],"_links":{"self":[{"href":"https:\/\/glennrowe.net\/programmingpages\/wp-json\/wp\/v2\/posts\/334","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/glennrowe.net\/programmingpages\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/glennrowe.net\/programmingpages\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/glennrowe.net\/programmingpages\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/glennrowe.net\/programmingpages\/wp-json\/wp\/v2\/comments?post=334"}],"version-history":[{"count":9,"href":"https:\/\/glennrowe.net\/programmingpages\/wp-json\/wp\/v2\/posts\/334\/revisions"}],"predecessor-version":[{"id":351,"href":"https:\/\/glennrowe.net\/programmingpages\/wp-json\/wp\/v2\/posts\/334\/revisions\/351"}],"wp:attachment":[{"href":"https:\/\/glennrowe.net\/programmingpages\/wp-json\/wp\/v2\/media?parent=334"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/glennrowe.net\/programmingpages\/wp-json\/wp\/v2\/categories?post=334"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/glennrowe.net\/programmingpages\/wp-json\/wp\/v2\/tags?post=334"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}