{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 4. Tuple\n",
"\n",
"In this section, we'll explore the concept of tuples in Python. \n",
"\n",
"**Tuples** are ordered, immutable sequences that can store various types of data. We'll learn how to create, access, and manipulate tuples effectively.\n",
"\n",
"We'll learn about the following topics:\n",
"\n",
" - [4.1. Creating Tuples](#Creating_Tuples)\n",
" - [4.2. Built-in Tuple Functions](#Builtin_Tuple_Functions)\n",
" - [4.3. Tuple Indexing and Slicing](#Tuple_Indexing_and_Slicing)\n",
" - [4.4. Tuple Properties](#Tuple_Properties)\n",
" - [4.5. Tuple Operators](#Tuple_Operators)\n",
" - [4.6. Built-in Tuple Methods](#Builtin_Tuple_Methods)\n",
" - [4.7. Nesting Tuples](#Nesting_Tuples)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<p align=\"center\">\n",
" <img width=\"550\" height=\"300\" src=\"https://realpython.com/cdn-cgi/image/width=960,format=auto/https://files.realpython.com/media/Mutable-and-Immutable-Data-Types-in-Python_Watermarked.2566c67a719d.jpg\">\n",
"</p>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<table>\n",
" <thead>\n",
" <tr>\n",
" <th>Name</th>\n",
" <th>Type in Python</th>\n",
" <th>Description</th>\n",
" <th>Example</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <td>Tuples</td>\n",
" <td>tuple</td>\n",
" <td>Comma-separated ordered immutable sequence of objects in parentheses ( ).</td>\n",
" <td>(10,'hello', 15.9)</td> \n",
" </tr>\n",
" </tbody>\n",
"</table>"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tuple"
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type((23, 98.3, 'hello'))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name='Creating_Tuples'></a>\n",
"\n",
"## 4.1. Creating Tuples:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Tuples in Python are created using parentheses `()`. You can include elements within the parentheses, separated by commas. "
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"a = ('one', 23, 98.3, 'hello')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If you try to define a tuple with one item."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"int"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type((2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To tell Python that you really want to define a singleton tuple, include a trailing comma (,) just before the closing parenthesis."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tuple"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type((2,))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This is another way to define a tuple's items."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(4, 5, 6)\n"
]
},
{
"data": {
"text/plain": [
"tuple"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x1, x2, x3 = 4, 5, 6\n",
"t = x1, x2, x3\n",
"print(t)\n",
"type(t)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name='Builtin_Tuple_Functions'></a>\n",
"\n",
"## 4.2. Built-in Tuple Functions:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- **`len()`**:Python's built-in len() function determines the total number of elements within a tuple's sequence."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"a = ('one', 23, 98.3, 'hello')"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"4"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"len(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name='Tuple_Indexing_and_Slicing'></a>\n",
"\n",
"## 4.3. Tuple Indexing and Slicing:"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"('one', 23, 98.3, 'hello')\n"
]
}
],
"source": [
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Elements in a tuple can be accessed individually by using square brackets and an index, just like accessing individual characters in a string. All lists, tuples, and strings indexing follow a zero-based approach.\n",
"\n",
"<p align=\"center\">\n",
" <img width=\"550\" height=\"300\" src=\"https://files.realpython.com/media/t.eb0b38e642c5.png\">\n",
"</p>"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'one'"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Grab element at index 0\n",
"a[0]"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(23, 98.3, 'hello')"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Grab index 1 and everything past it\n",
"a[1:]"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"('one', 23)"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Grab everything UP TO index 2\n",
"a[:2]"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(98.3, 'hello')"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a[2:len(a)]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Negative indexing allows counting from the end of the tuple.\n",
"\n",
"<p align=\"center\">\n",
" <img width=\"550\" height=\"300\" src=\"https://files.realpython.com/media/t.c11ea56e8ca2.png\">\n",
"</p>"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'hello'"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a[-1]"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"('one',)"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a[:-3]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`[start:stop:step]`\n",
"\n",
"- start: numerical index for the slice index\n",
"- stop: index you will go up to but not include\n",
"- step: the size of jump you take"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"('one', 98.3)"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a[::2]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can specify a negative step value as well, in which case Python steps backward through the tuple. In that case, the starting/first index should be greater than the ending/second index."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"('one', 23, 98.3, 'hello')"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"('hello', 23)"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a[4:0:-2]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This is a common paradigm for reversing a tuple."
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"('hello', 98.3, 23, 'one')"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a[::-1]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name='Tuple_Properties'></a>\n",
"\n",
"## 4.4. Tuple Properties:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- **Ordered**: A tuple in Python is not just a collection of objects; it is an ordered collection where the sequence in which elements are specified upon tuple creation becomes an inherent characteristic of that tuple, preserved throughout its lifetime."
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
"a = ('one', 23, 98.3, 'hello')\n",
"\n",
"b = (23, 98.3, 'one', 'hello')"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a is b"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a == b"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- **Immutability**: Tuples are immmutable meaning that when a tuple is created, the elements within it cannot be changed or replaced.\n",
"\n",
"This is the biggest difference between Tuples and Lists."
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"('one', 23, 98.3, 'hello')"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"ename": "TypeError",
"evalue": "'tuple' object does not support item assignment",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_18304\\4221126460.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
]
}
],
"source": [
"a[0] = 2"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"ename": "AttributeError",
"evalue": "'tuple' object has no attribute 'append'",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_18304\\2298863157.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'new'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[1;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
]
}
],
"source": [
"a.append('new')"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"ename": "TypeError",
"evalue": "can only concatenate tuple (not \"str\") to tuple",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_18304\\1405506363.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'new'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[1;31mTypeError\u001b[0m: can only concatenate tuple (not \"str\") to tuple"
]
}
],
"source": [
"a = a + ('new')"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"ename": "AttributeError",
"evalue": "'tuple' object has no attribute 'remove'",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_18304\\3225995218.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'one'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[1;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'remove'"
]
}
],
"source": [
"a.remove('one')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Nothing can be added/removed/replaced in tuples unlike lists."
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"ename": "TypeError",
"evalue": "'tuple' object doesn't support item deletion",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_18304\\3074760810.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mdel\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[1;31mTypeError\u001b[0m: 'tuple' object doesn't support item deletion"
]
}
],
"source": [
"del a[0]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- **Repetition**: We can use the multiplication symbol to create repetition."
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"('one', 23, 98.3, 'hello', 'one', 23, 98.3, 'hello')"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a * 2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name='Tuple_Operators'></a>\n",
"\n",
"## 4.5. Tuple Operators:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- **`in`**: Python also provides a membership operator that can be used with tuples. The in operator returns True if the first operand is contained within the second, and False otherwise."
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"'one' in a"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- **`not in`**: Python also provides a membership operator that can be used with tuples. The not in operator returns True if the first operand is not contained within the second, and False otherwise."
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"'one' not in a"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name='Builtin_Tuple_Methods'></a>\n",
"\n",
"## 4.6. Built-in Tuple Methods:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<table>\n",
" <thead>\n",
" <tr>\n",
" <th>Method</th>\n",
" <th>Description</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <td>index(m,a(optional),b(optional))</td>\n",
" <td>the index of first occurrence of m for a given substring indicated by a and b</td>\n",
" </tr>\n",
" <tr>\n",
" <td>count(m,a(optional),b(optional))</td>\n",
" <td>number of occurrences of m within the substring indicated by a and b</td>\n",
" </tr> \n",
" </tbody>\n",
"</table>"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a.index(23)"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a.count('one')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To be honest, tuples are not used as often as lists in programming, but are used when immutability is necessary. If in your program you are passing around an object and need to make sure it does not get changed, then a tuple becomes your solution. It provides a convenient source of data integrity."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name='Nesting_Tuples'></a>\n",
"\n",
"## 4.7. Nesting Tuples:"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [],
"source": [
"b = ([1,'hello'], (26.3, 56))"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"([1, 'hello'], (26.3, 56))\n"
]
}
],
"source": [
"print(b)"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'hello'"
]
},
"execution_count": 35,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"b[0][1]"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"56"
]
},
"execution_count": 36,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"b[1][1]"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 4
}