builtins_module_list/notebook.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Builtins Module: The List Class (list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ```list``` class is the mutable counterpart to the ```tuple```. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Categorize_Identifiers Module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook will use the following functions ```dir2```, ```variables``` and ```view``` in the custom module ```categorize_identifiers``` which is found in the same directory as this notebook file. ```dir2``` is a variant of ```dir``` that groups identifiers into a ```dict``` under categories and ```variables``` is an IPython based a variable inspector. ```view``` is used to view a ```Collection``` in more detail:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from categorize_identifiers import dir2, variables, view"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialisation Signature"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that a ```tuple``` is an immutable ```Collection``` where the fundamental unit is a reference to an ```object```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "object1 = object()\n",
    "object2 = object()\n",
    "object3 = object()\n",
    "object4 = object()\n",
    "object5 = object()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "archive = (object1, object2, object3, object4, object5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t object               \t 1      \t <object object at 0x000001E6F656C5E0> \t\n",
      "1 \t object               \t 1      \t <object object at 0x000001E6F656C590> \t\n",
      "2 \t object               \t 1      \t <object object at 0x000001E6F656C600> \t\n",
      "3 \t object               \t 1      \t <object object at 0x000001E6F656C610> \t\n",
      "4 \t object               \t 1      \t <object object at 0x000001E6F656C620> \t\n"
     ]
    }
   ],
   "source": [
    "view(archive)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A ```list``` is the mutable counterpart to the ```tuple``` and instantiated in a similar way using ```[]``` opposed to parenthesis ```()```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "active_archive = [object1, object2, object3, object4, object5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t object               \t 1      \t <object object at 0x000001E6F656C5E0> \t\n",
      "1 \t object               \t 1      \t <object object at 0x000001E6F656C590> \t\n",
      "2 \t object               \t 1      \t <object object at 0x000001E6F656C600> \t\n",
      "3 \t object               \t 1      \t <object object at 0x000001E6F656C610> \t\n",
      "4 \t object               \t 1      \t <object object at 0x000001E6F656C620> \t\n"
     ]
    }
   ],
   "source": [
    "view(active_archive)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The initialisation signature of a ```list``` is generally used for type casting:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1;31mInit signature:\u001b[0m \u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0miterable\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m/\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
       "\u001b[1;31mDocstring:\u001b[0m     \n",
       "Built-in mutable sequence.\n",
       "\n",
       "If no argument is given, the constructor creates a new empty list.\n",
       "The argument must be an iterable if specified.\n",
       "\u001b[1;31mType:\u001b[0m           type\n",
       "\u001b[1;31mSubclasses:\u001b[0m     _List, _HashedSeq, StackSummary, _Threads, ConvertingList, DeferredConfigList, _ymd, _Accumulator, SList, _ImmutableLineList, ..."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "list?"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A ```list```, like a ```tuple``` is instantiated from an iterable. For example a ```list``` can be cast from the ```tuple``` instance ```archive```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<object at 0x1e6f656c5e0>,\n",
       " <object at 0x1e6f656c590>,\n",
       " <object at 0x1e6f656c600>,\n",
       " <object at 0x1e6f656c610>,\n",
       " <object at 0x1e6f656c620>]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(archive)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or the ```str``` instance ```'hello'```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['h', 'e', 'l', 'l', 'o']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list('hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A ```list``` instance can be instantiated using square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_active_archive = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "single_element_active_archive = ['hello']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "multiple_element_active_archive = [1, True, 3.14, 'hello', b'hello', bytearray(b'hello')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Type</th>\n",
       "      <th>Size/Shape</th>\n",
       "      <th>Value</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Instance Name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>archive</th>\n",
       "      <td>tuple</td>\n",
       "      <td>5</td>\n",
       "      <td>(&lt;object object at 0x000001E6F656C5E0&gt;, &lt;object object at 0x000001E6F656C590&gt;, &lt;object object at 0x000001E6F656C600&gt;, &lt;object object at 0x000001E6F656C610&gt;, &lt;object object at 0x000001E6F656C620&gt;)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>active_archive</th>\n",
       "      <td>list</td>\n",
       "      <td>5</td>\n",
       "      <td>[&lt;object object at 0x000001E6F656C5E0&gt;, &lt;object object at 0x000001E6F656C590&gt;, &lt;object object at 0x000001E6F656C600&gt;, &lt;object object at 0x000001E6F656C610&gt;, &lt;object object at 0x000001E6F656C620&gt;]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>empty_active_archive</th>\n",
       "      <td>list</td>\n",
       "      <td>0</td>\n",
       "      <td>[]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>single_element_active_archive</th>\n",
       "      <td>list</td>\n",
       "      <td>1</td>\n",
       "      <td>['hello']</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>multiple_element_active_archive</th>\n",
       "      <td>list</td>\n",
       "      <td>6</td>\n",
       "      <td>[1, True, 3.14, 'hello', b'hello', bytearray(b'hello')]</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                  Type  Size/Shape  \\\n",
       "Instance Name                                        \n",
       "archive                          tuple           5   \n",
       "active_archive                    list           5   \n",
       "empty_active_archive              list           0   \n",
       "single_element_active_archive     list           1   \n",
       "multiple_element_active_archive   list           6   \n",
       "\n",
       "                                                                                                                                                                                                                               Value  \n",
       "Instance Name                                                                                                                                                                                                                         \n",
       "archive                          (<object object at 0x000001E6F656C5E0>, <object object at 0x000001E6F656C590>, <object object at 0x000001E6F656C600>, <object object at 0x000001E6F656C610>, <object object at 0x000001E6F656C620>)  \n",
       "active_archive                   [<object object at 0x000001E6F656C5E0>, <object object at 0x000001E6F656C590>, <object object at 0x000001E6F656C600>, <object object at 0x000001E6F656C610>, <object object at 0x000001E6F656C620>]  \n",
       "empty_active_archive                                                                                                                                                                                                              []  \n",
       "single_element_active_archive                                                                                                                                                                                              ['hello']  \n",
       "multiple_element_active_archive                                                                                                                                              [1, True, 3.14, 'hello', b'hello', bytearray(b'hello')]  "
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "variables()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Square brackets can be used to create an empty ```list``` and for a 1 element ```list```, there is no need for a trailing comma as there is no confusion with parenthesis like in the case of a ```tuple```:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The square brackets ```[ ]``` are also used in Python for indexing and slicing. Generally there is no confusion with regards to the terminology. For example the third index (zero-order indexing) from the ```list``` above can be accessed using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.14"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, True, 3.14, 'hello', b'hello', bytearray(b'hello')][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The syntax below should be clear, the left hand side square brackets are used to enclose the contents in the ```list``` and the right hand square brackets are used to index into the ```list``` rerieving the 3rd element (zero-order indexing):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2, 3][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Identifiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The immutable counterpart has a ```___hash__``` identifier that was not ```None``` meaning it is hashable and all its methods are mutable with a ```return``` value. The mutable counterpart on the other hand has a ```__hash__``` identifier that is ```None``` meaning it cannot be hashed and some of its methods modify the instance in place without a ```return``` value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple.__hash__ == None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list.__hash__ == None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the ```list``` is the mutable counterpart to the ```tuple``` it has consistent immutable methods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'method': ['count', 'index'],\n",
      " 'datamodel_attribute': ['__doc__', '__hash__'],\n",
      " 'datamodel_method': ['__add__',\n",
      "                      '__class__',\n",
      "                      '__class_getitem__',\n",
      "                      '__contains__',\n",
      "                      '__delattr__',\n",
      "                      '__dir__',\n",
      "                      '__eq__',\n",
      "                      '__format__',\n",
      "                      '__ge__',\n",
      "                      '__getattribute__',\n",
      "                      '__getitem__',\n",
      "                      '__getstate__',\n",
      "                      '__gt__',\n",
      "                      '__init__',\n",
      "                      '__init_subclass__',\n",
      "                      '__iter__',\n",
      "                      '__le__',\n",
      "                      '__len__',\n",
      "                      '__lt__',\n",
      "                      '__mul__',\n",
      "                      '__ne__',\n",
      "                      '__new__',\n",
      "                      '__reduce__',\n",
      "                      '__reduce_ex__',\n",
      "                      '__repr__',\n",
      "                      '__rmul__',\n",
      "                      '__setattr__',\n",
      "                      '__sizeof__',\n",
      "                      '__str__',\n",
      "                      '__subclasshook__']}\n"
     ]
    }
   ],
   "source": [
    "dir2(list, tuple, consistent_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It also has the following mutable methods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'method': ['append',\n",
      "            'clear',\n",
      "            'copy',\n",
      "            'extend',\n",
      "            'insert',\n",
      "            'pop',\n",
      "            'remove',\n",
      "            'reverse',\n",
      "            'sort'],\n",
      " 'datamodel_method': ['__delitem__',\n",
      "                      '__iadd__',\n",
      "                      '__imul__',\n",
      "                      '__reversed__',\n",
      "                      '__setitem__']}\n"
     ]
    }
   ],
   "source": [
    "dir2(list, tuple, unique_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall the ```bytes``` and ```bytearrays``` are also immutable and mutable counterparts. If the mutable identifiers in the ```bytearray``` as examined, notice the consistency with the ```list```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bytes.__hash__ == None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bytearray.__hash__ == None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'method': ['append',\n",
      "            'clear',\n",
      "            'copy',\n",
      "            'extend',\n",
      "            'insert',\n",
      "            'pop',\n",
      "            'remove',\n",
      "            'reverse'],\n",
      " 'datamodel_method': ['__alloc__',\n",
      "                      '__delitem__',\n",
      "                      '__iadd__',\n",
      "                      '__imul__',\n",
      "                      '__release_buffer__',\n",
      "                      '__setitem__']}\n"
     ]
    }
   ],
   "source": [
    "dir2(bytearray, bytes, unique_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is because the ```list``` and ```bytearray``` are both follow the design pattern of a ```MutableCollection```."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mutatable Methods"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ```list``` is the mutable counterpart to the immutable ```tuple```. Both follow the design pattern of a ```Collection``` and have a fundamental unit that is a reference to an ```object```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Type</th>\n",
       "      <th>Size/Shape</th>\n",
       "      <th>Value</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Instance Name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>archive</th>\n",
       "      <td>tuple</td>\n",
       "      <td>5</td>\n",
       "      <td>(&lt;object object at 0x000001E6F656C5E0&gt;, &lt;object object at 0x000001E6F656C590&gt;, &lt;object object at 0x000001E6F656C600&gt;, &lt;object object at 0x000001E6F656C610&gt;, &lt;object object at 0x000001E6F656C620&gt;)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>active_archive</th>\n",
       "      <td>list</td>\n",
       "      <td>5</td>\n",
       "      <td>[&lt;object object at 0x000001E6F656C5E0&gt;, &lt;object object at 0x000001E6F656C590&gt;, &lt;object object at 0x000001E6F656C600&gt;, &lt;object object at 0x000001E6F656C610&gt;, &lt;object object at 0x000001E6F656C620&gt;]</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 Type  Size/Shape  \\\n",
       "Instance Name                       \n",
       "archive         tuple           5   \n",
       "active_archive   list           5   \n",
       "\n",
       "                                                                                                                                                                                                              Value  \n",
       "Instance Name                                                                                                                                                                                                        \n",
       "archive         (<object object at 0x000001E6F656C5E0>, <object object at 0x000001E6F656C590>, <object object at 0x000001E6F656C600>, <object object at 0x000001E6F656C610>, <object object at 0x000001E6F656C620>)  \n",
       "active_archive  [<object object at 0x000001E6F656C5E0>, <object object at 0x000001E6F656C590>, <object object at 0x000001E6F656C600>, <object object at 0x000001E6F656C610>, <object object at 0x000001E6F656C620>]  "
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del empty_active_archive, single_element_active_archive, multiple_element_active_archive\n",
    "variables()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t object               \t 1      \t <object object at 0x000001E6F656C5E0> \t\n",
      "1 \t object               \t 1      \t <object object at 0x000001E6F656C590> \t\n",
      "2 \t object               \t 1      \t <object object at 0x000001E6F656C600> \t\n",
      "3 \t object               \t 1      \t <object object at 0x000001E6F656C610> \t\n",
      "4 \t object               \t 1      \t <object object at 0x000001E6F656C620> \t\n"
     ]
    }
   ],
   "source": [
    "view(archive)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t object               \t 1      \t <object object at 0x000001E6F656C5E0> \t\n",
      "1 \t object               \t 1      \t <object object at 0x000001E6F656C590> \t\n",
      "2 \t object               \t 1      \t <object object at 0x000001E6F656C600> \t\n",
      "3 \t object               \t 1      \t <object object at 0x000001E6F656C610> \t\n",
      "4 \t object               \t 1      \t <object object at 0x000001E6F656C620> \t\n"
     ]
    }
   ],
   "source": [
    "view(active_archive)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both the ```tuple``` and ```list``` have the immutable method ```__getitem__``` (*dunder getitem*) and a reference to an ```object``` can be accessed from its numeric index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<object at 0x1e6f656c590>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "archive[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<object at 0x1e6f656c590>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "active_archive[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However only the ```list``` has the mutable methods ```__setitem__``` (*dunder setitem*) and ```__delitem__``` (*dunder delitem*). This means it is possible to index into a ```list``` and replace a reference to an ```object``` with a new reference or to use ```del``` to delete the reference:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "active_archive[1] = object() # Mutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t object               \t 1      \t <object object at 0x000001E6F656C5E0> \t\n",
      "1 \t object               \t 1      \t <object object at 0x000001E6F656C680> \t\n",
      "2 \t object               \t 1      \t <object object at 0x000001E6F656C600> \t\n",
      "3 \t object               \t 1      \t <object object at 0x000001E6F656C610> \t\n",
      "4 \t object               \t 1      \t <object object at 0x000001E6F656C620> \t\n"
     ]
    }
   ],
   "source": [
    "view(active_archive)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "del active_archive[1] # Mutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t object               \t 1      \t <object object at 0x000001E6F656C5E0> \t\n",
      "1 \t object               \t 1      \t <object object at 0x000001E6F656C600> \t\n",
      "2 \t object               \t 1      \t <object object at 0x000001E6F656C610> \t\n",
      "3 \t object               \t 1      \t <object object at 0x000001E6F656C620> \t\n"
     ]
    }
   ],
   "source": [
    "view(active_archive)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the object that was at index ```1``` has been deleted. All other objects that had a lower index are shunted down by ```1```. The ```list``` now has a length of ```4```."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recreating the ```list``` instance ```active``` from the ```tuple``` instance ```archive```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "active_archive = list(archive)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ```+``` operator performs concatenation in a ```Collection``` returning a new concatenated ```Collection```. This is defined by the addition datamodel method ```__add__``` (*dunder add*):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<object at 0x1e6f656c5e0>,\n",
       " <object at 0x1e6f656c590>,\n",
       " <object at 0x1e6f656c600>,\n",
       " <object at 0x1e6f656c610>,\n",
       " <object at 0x1e6f656c620>,\n",
       " '',\n",
       " '')"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "archive + (str(), str()) # Return value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<object at 0x1e6f656c5e0>,\n",
       " <object at 0x1e6f656c590>,\n",
       " <object at 0x1e6f656c600>,\n",
       " <object at 0x1e6f656c610>,\n",
       " <object at 0x1e6f656c620>,\n",
       " '',\n",
       " '']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "active_archive + [str(), str()] # Return value"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a subtle difference with the ```+=``` operator which performs \"inplace\" concatenation for the mutable ```list``` and uses the mutable datamodel method ```__iadd__``` (*dunder iadd*). This mutates the original instance inplace and therefore the ```list``` has the same id before and after the inplace concatenation. For the immutable ```tuple``` there are two operations concatenation which returns a new instance and then reassignment of the instance name to the new instance. Because reassignment is used to a new instance, the ID changes after the \"inplace\" operator is used:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Type</th>\n",
       "      <th>Size/Shape</th>\n",
       "      <th>Value</th>\n",
       "      <th>ID</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Instance Name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>archive</th>\n",
       "      <td>tuple</td>\n",
       "      <td>5</td>\n",
       "      <td>(&lt;object object at 0x000001E6F656C5E0&gt;, &lt;object object at 0x000001E6F656C590&gt;, &lt;object object at 0x000001E6F656C600&gt;, &lt;object object at 0x000001E6F656C610&gt;, &lt;object object at 0x000001E6F656C620&gt;)</td>\n",
       "      <td>2091507843120</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>active_archive</th>\n",
       "      <td>list</td>\n",
       "      <td>5</td>\n",
       "      <td>[&lt;object object at 0x000001E6F656C5E0&gt;, &lt;object object at 0x000001E6F656C590&gt;, &lt;object object at 0x000001E6F656C600&gt;, &lt;object object at 0x000001E6F656C610&gt;, &lt;object object at 0x000001E6F656C620&gt;]</td>\n",
       "      <td>2091507843360</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 Type  Size/Shape  \\\n",
       "Instance Name                       \n",
       "archive         tuple           5   \n",
       "active_archive   list           5   \n",
       "\n",
       "                                                                                                                                                                                                              Value  \\\n",
       "Instance Name                                                                                                                                                                                                         \n",
       "archive         (<object object at 0x000001E6F656C5E0>, <object object at 0x000001E6F656C590>, <object object at 0x000001E6F656C600>, <object object at 0x000001E6F656C610>, <object object at 0x000001E6F656C620>)   \n",
       "active_archive  [<object object at 0x000001E6F656C5E0>, <object object at 0x000001E6F656C590>, <object object at 0x000001E6F656C600>, <object object at 0x000001E6F656C610>, <object object at 0x000001E6F656C620>]   \n",
       "\n",
       "                           ID  \n",
       "Instance Name                  \n",
       "archive         2091507843120  \n",
       "active_archive  2091507843360  "
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "variables(show_id=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "archive += (str(), str()) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "active_archive += [str(), str()] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Type</th>\n",
       "      <th>Size/Shape</th>\n",
       "      <th>Value</th>\n",
       "      <th>ID</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Instance Name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>archive</th>\n",
       "      <td>tuple</td>\n",
       "      <td>7</td>\n",
       "      <td>(&lt;object object at 0x000001E6F656C5E0&gt;, &lt;object object at 0x000001E6F656C590&gt;, &lt;object object at 0x000001E6F656C600&gt;, &lt;object object at 0x000001E6F656C610&gt;, &lt;object object at 0x000001E6F656C620&gt;, ...</td>\n",
       "      <td>2091467248432</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>active_archive</th>\n",
       "      <td>list</td>\n",
       "      <td>7</td>\n",
       "      <td>[&lt;object object at 0x000001E6F656C5E0&gt;, &lt;object object at 0x000001E6F656C590&gt;, &lt;object object at 0x000001E6F656C600&gt;, &lt;object object at 0x000001E6F656C610&gt;, &lt;object object at 0x000001E6F656C620&gt;, ...</td>\n",
       "      <td>2091506724400</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 Type  Size/Shape  \\\n",
       "Instance Name                       \n",
       "archive         tuple           7   \n",
       "active_archive   list           7   \n",
       "\n",
       "                                                                                                                                                                                                                  Value  \\\n",
       "Instance Name                                                                                                                                                                                                             \n",
       "archive         (<object object at 0x000001E6F656C5E0>, <object object at 0x000001E6F656C590>, <object object at 0x000001E6F656C600>, <object object at 0x000001E6F656C610>, <object object at 0x000001E6F656C620>, ...   \n",
       "active_archive  [<object object at 0x000001E6F656C5E0>, <object object at 0x000001E6F656C590>, <object object at 0x000001E6F656C600>, <object object at 0x000001E6F656C610>, <object object at 0x000001E6F656C620>, ...   \n",
       "\n",
       "                           ID  \n",
       "Instance Name                  \n",
       "archive         2091467248432  \n",
       "active_archive  2091506724400  "
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "variables(show_id=True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The mutated ```list``` can be viewed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t object               \t 1      \t <object object at 0x000001E6F656C5E0> \t\n",
      "1 \t object               \t 1      \t <object object at 0x000001E6F656C590> \t\n",
      "2 \t object               \t 1      \t <object object at 0x000001E6F656C600> \t\n",
      "3 \t object               \t 1      \t <object object at 0x000001E6F656C610> \t\n",
      "4 \t object               \t 1      \t <object object at 0x000001E6F656C620> \t\n",
      "5 \t str                  \t 0      \t                                \t\n",
      "6 \t str                  \t 0      \t                                \t\n"
     ]
    }
   ],
   "source": [
    "view(active_archive)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The mutable ```list``` method ```append```, appends a reference to a single ```object``` at the end of a ```list```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "active_archive.append(bytes()) # No return value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t object               \t 1      \t <object object at 0x000001E6F656C5E0> \t\n",
      "1 \t object               \t 1      \t <object object at 0x000001E6F656C590> \t\n",
      "2 \t object               \t 1      \t <object object at 0x000001E6F656C600> \t\n",
      "3 \t object               \t 1      \t <object object at 0x000001E6F656C610> \t\n",
      "4 \t object               \t 1      \t <object object at 0x000001E6F656C620> \t\n",
      "5 \t str                  \t 0      \t                                \t\n",
      "6 \t str                  \t 0      \t                                \t\n",
      "7 \t bytes                \t 0      \t b''                            \t\n"
     ]
    }
   ],
   "source": [
    "view(active_archive)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If this object is a ```Collection``` such as a ```tuple```, the reference will be appended as a single element, that appears to be nested:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "active_archive.append(('a', 'b', 'c')) # No return value"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The mutated ```list``` can then be viewed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t object               \t 1      \t <object object at 0x000001E6F656C5E0> \t\n",
      "1 \t object               \t 1      \t <object object at 0x000001E6F656C590> \t\n",
      "2 \t object               \t 1      \t <object object at 0x000001E6F656C600> \t\n",
      "3 \t object               \t 1      \t <object object at 0x000001E6F656C610> \t\n",
      "4 \t object               \t 1      \t <object object at 0x000001E6F656C620> \t\n",
      "5 \t str                  \t 0      \t                                \t\n",
      "6 \t str                  \t 0      \t                                \t\n",
      "7 \t bytes                \t 0      \t b''                            \t\n",
      "8 \t tuple                \t 3      \t ('a', 'b', 'c')                \t\n"
     ]
    }
   ],
   "source": [
    "view(active_archive)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The list mutable method ```extend``` will instead extend a ```list``` using the contents of a ```Collection```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "active_archive.extend((1, 2, 3)) # No return value"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The mutated ```list``` can be viewed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t object               \t 1      \t <object object at 0x000001E6F656C5E0> \t\n",
      "1 \t object               \t 1      \t <object object at 0x000001E6F656C590> \t\n",
      "2 \t object               \t 1      \t <object object at 0x000001E6F656C600> \t\n",
      "3 \t object               \t 1      \t <object object at 0x000001E6F656C610> \t\n",
      "4 \t object               \t 1      \t <object object at 0x000001E6F656C620> \t\n",
      "5 \t str                  \t 0      \t                                \t\n",
      "6 \t str                  \t 0      \t                                \t\n",
      "7 \t bytes                \t 0      \t b''                            \t\n",
      "8 \t tuple                \t 3      \t ('a', 'b', 'c')                \t\n",
      "9 \t int                  \t 1      \t 1                              \t\n",
      "10 \t int                  \t 1      \t 2                              \t\n",
      "11 \t int                  \t 1      \t 3                              \t\n"
     ]
    }
   ],
   "source": [
    "view(active_archive)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The mutable ```list``` method ```insert``` can be used to insert a reference to a single object at a specific index behaving similarly to ```append```. Any references that are at this index and later indexes get shunted up by ```1```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "active_archive.insert(2, ('d', 'e', 'f')) # No return value"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The mutated ```list``` can then be viewed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t object               \t 1      \t <object object at 0x000001E6F656C5E0> \t\n",
      "1 \t object               \t 1      \t <object object at 0x000001E6F656C590> \t\n",
      "2 \t tuple                \t 3      \t ('d', 'e', 'f')                \t\n",
      "3 \t object               \t 1      \t <object object at 0x000001E6F656C600> \t\n",
      "4 \t object               \t 1      \t <object object at 0x000001E6F656C610> \t\n",
      "5 \t object               \t 1      \t <object object at 0x000001E6F656C620> \t\n",
      "6 \t str                  \t 0      \t                                \t\n",
      "7 \t str                  \t 0      \t                                \t\n",
      "8 \t bytes                \t 0      \t b''                            \t\n",
      "9 \t tuple                \t 3      \t ('a', 'b', 'c')                \t\n",
      "10 \t int                  \t 1      \t 1                              \t\n",
      "11 \t int                  \t 1      \t 2                              \t\n",
      "12 \t int                  \t 1      \t 3                              \t\n"
     ]
    }
   ],
   "source": [
    "view(active_archive)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The mutable ```list``` method ```remove``` can be used to ```remove``` the first reference to a value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "active_archive.remove('') # No return value"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The mutated ```list``` can be viewed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t object               \t 1      \t <object object at 0x000001E6F656C5E0> \t\n",
      "1 \t object               \t 1      \t <object object at 0x000001E6F656C590> \t\n",
      "2 \t tuple                \t 3      \t ('d', 'e', 'f')                \t\n",
      "3 \t object               \t 1      \t <object object at 0x000001E6F656C600> \t\n",
      "4 \t object               \t 1      \t <object object at 0x000001E6F656C610> \t\n",
      "5 \t object               \t 1      \t <object object at 0x000001E6F656C620> \t\n",
      "6 \t str                  \t 0      \t                                \t\n",
      "7 \t bytes                \t 0      \t b''                            \t\n",
      "8 \t tuple                \t 3      \t ('a', 'b', 'c')                \t\n",
      "9 \t int                  \t 1      \t 1                              \t\n",
      "10 \t int                  \t 1      \t 2                              \t\n",
      "11 \t int                  \t 1      \t 3                              \t\n"
     ]
    }
   ],
   "source": [
    "view(active_archive)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The order of the elements in the ```list``` can be sorted using their ordinal value with the ```list``` mutable method ```sort```. This method requires a ```list``` instance where each element is ordinal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "text_active_archive = list('AaBbCcDdEe')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t str                  \t 1      \t A                              \t\n",
      "1 \t str                  \t 1      \t a                              \t\n",
      "2 \t str                  \t 1      \t B                              \t\n",
      "3 \t str                  \t 1      \t b                              \t\n",
      "4 \t str                  \t 1      \t C                              \t\n",
      "5 \t str                  \t 1      \t c                              \t\n",
      "6 \t str                  \t 1      \t D                              \t\n",
      "7 \t str                  \t 1      \t d                              \t\n",
      "8 \t str                  \t 1      \t E                              \t\n",
      "9 \t str                  \t 1      \t e                              \t\n"
     ]
    }
   ],
   "source": [
    "view(text_active_archive)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "text_active_archive.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t str                  \t 1      \t A                              \t\n",
      "1 \t str                  \t 1      \t B                              \t\n",
      "2 \t str                  \t 1      \t C                              \t\n",
      "3 \t str                  \t 1      \t D                              \t\n",
      "4 \t str                  \t 1      \t E                              \t\n",
      "5 \t str                  \t 1      \t a                              \t\n",
      "6 \t str                  \t 1      \t b                              \t\n",
      "7 \t str                  \t 1      \t c                              \t\n",
      "8 \t str                  \t 1      \t d                              \t\n",
      "9 \t str                  \t 1      \t e                              \t\n"
     ]
    }
   ],
   "source": [
    "view(text_active_archive)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "65 A\n",
      "66 B\n",
      "67 C\n",
      "68 D\n",
      "69 E\n",
      "97 a\n",
      "98 b\n",
      "99 c\n",
      "100 d\n",
      "101 e\n"
     ]
    }
   ],
   "source": [
    "for char in text_active_archive:\n",
    "    print(ord(char), char)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The order of elements in a ```list``` instance can be reversed in a ```list``` by using the mutable ```list``` method ```reverse```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "text_active_archive.reverse() # No return method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t str                  \t 1      \t e                              \t\n",
      "1 \t str                  \t 1      \t d                              \t\n",
      "2 \t str                  \t 1      \t c                              \t\n",
      "3 \t str                  \t 1      \t b                              \t\n",
      "4 \t str                  \t 1      \t a                              \t\n",
      "5 \t str                  \t 1      \t E                              \t\n",
      "6 \t str                  \t 1      \t D                              \t\n",
      "7 \t str                  \t 1      \t C                              \t\n",
      "8 \t str                  \t 1      \t B                              \t\n",
      "9 \t str                  \t 1      \t A                              \t\n"
     ]
    }
   ],
   "source": [
    "view(text_active_archive)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The mutable ```list``` method ```clear``` will clear all the references in the ```list``` instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "text_active_archive.clear() # No return value"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The updated empty ```Collection``` of references can be viewed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n"
     ]
    }
   ],
   "source": [
    "view(text_active_archive)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The mutable ```list``` methof ```pop``` is the outlier mutable method that has a ```return``` value. It pops off a reference to a Python ```object``` returning the popped reference and mutating the ```list``` inplace:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t object               \t 1      \t <object object at 0x000001E6F656C5E0> \t\n",
      "1 \t object               \t 1      \t <object object at 0x000001E6F656C590> \t\n",
      "2 \t tuple                \t 3      \t ('d', 'e', 'f')                \t\n",
      "3 \t object               \t 1      \t <object object at 0x000001E6F656C600> \t\n",
      "4 \t object               \t 1      \t <object object at 0x000001E6F656C610> \t\n",
      "5 \t object               \t 1      \t <object object at 0x000001E6F656C620> \t\n",
      "6 \t str                  \t 0      \t                                \t\n",
      "7 \t bytes                \t 0      \t b''                            \t\n",
      "8 \t tuple                \t 3      \t ('a', 'b', 'c')                \t\n",
      "9 \t int                  \t 1      \t 1                              \t\n",
      "10 \t int                  \t 1      \t 2                              \t\n",
      "11 \t int                  \t 1      \t 3                              \t\n"
     ]
    }
   ],
   "source": [
    "view(active_archive)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reference to the value popped is returned:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "active_archive.pop()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The mutated ```list``` can be viewed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t object               \t 1      \t <object object at 0x000001E6F656C5E0> \t\n",
      "1 \t object               \t 1      \t <object object at 0x000001E6F656C590> \t\n",
      "2 \t tuple                \t 3      \t ('d', 'e', 'f')                \t\n",
      "3 \t object               \t 1      \t <object object at 0x000001E6F656C600> \t\n",
      "4 \t object               \t 1      \t <object object at 0x000001E6F656C610> \t\n",
      "5 \t object               \t 1      \t <object object at 0x000001E6F656C620> \t\n",
      "6 \t str                  \t 0      \t                                \t\n",
      "7 \t bytes                \t 0      \t b''                            \t\n",
      "8 \t tuple                \t 3      \t ('a', 'b', 'c')                \t\n",
      "9 \t int                  \t 1      \t 1                              \t\n",
      "10 \t int                  \t 1      \t 2                              \t\n"
     ]
    }
   ],
   "source": [
    "view(active_archive)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```pop``` by default pops off the last value, however an index can be selected:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "active_archive.pop(6)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The mutated ```list``` can be viewed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t object               \t 1      \t <object object at 0x000001E6F656C5E0> \t\n",
      "1 \t object               \t 1      \t <object object at 0x000001E6F656C590> \t\n",
      "2 \t tuple                \t 3      \t ('d', 'e', 'f')                \t\n",
      "3 \t object               \t 1      \t <object object at 0x000001E6F656C600> \t\n",
      "4 \t object               \t 1      \t <object object at 0x000001E6F656C610> \t\n",
      "5 \t object               \t 1      \t <object object at 0x000001E6F656C620> \t\n",
      "6 \t bytes                \t 0      \t b''                            \t\n",
      "7 \t tuple                \t 3      \t ('a', 'b', 'c')                \t\n",
      "8 \t int                  \t 1      \t 1                              \t\n",
      "9 \t int                  \t 1      \t 2                              \t\n"
     ]
    }
   ],
   "source": [
    "view(active_archive)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mutability and Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Supposing the following ```tuple``` is instantiated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "archive1 = ('a', 'b', 'c', 'd')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions have their own local scope but can access variables from the global scope. For immutable methods they can only ```return``` a value using their ```return``` statement. The global scope can otherwise not access variables from the local scope."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function can be created which accesses the immutable ```tuple```, creates a local variable value using concatenation and then has a ```return``` statement that this value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun():\n",
    "    value = archive1 + ('E', 'F', 'G', 'H')\n",
    "    return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If this function is called, the ```return``` value is shown:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('a', 'b', 'c', 'd', 'E', 'F', 'G', 'H')"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fun()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And the immutable ```tuple``` is unmodified:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('a', 'b', 'c', 'd')"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "archive1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables assigned in a function are local:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun():\n",
    "    local_variable = (1, 2, 3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that when the function is called, there is nothing in the cell output as the function has no ```return``` value. When a ```return``` value is not specified, the function will ```return None```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "fun()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This ```local_variable``` cannot be accessed outside the functions local scope. Attempting to do so will result in a ```NameError``` as ```local_variable``` does not exist in the global scope:\n",
    "\n",
    "\n",
    "```python\n",
    "local_variable\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Therefore a function can assign an instance name to an instance in its local scope that already exists in the global scope:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun():\n",
    "    archive1 = ('E', 'F', 'G', 'H')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function has no ```return``` value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "fun()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The instance name in the global instance is unmodified: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('a', 'b', 'c', 'd')"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "archive1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the function tries to access an existing instance name in the global scope and then tries to reassign it in the local scope:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun():\n",
    "    archive1 = archive1 + ('E', 'F', 'G', 'H')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling the function will give an ```UnboundLocalError```:\n",
    "\n",
    "```python\n",
    "fun()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now supposing the following ```list``` instance is instantiated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "active1 = [1, 2, 3, 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function can access a global instance and uses a mutable method on the global instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun():\n",
    "    active1.clear()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function has no ```return``` value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "fun()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However the global instance will be updated inplace:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "active1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Supposing the following ```tuple``` and ```list``` instances are instantiated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "archive1 = ('a', 'b', 'c', 'd')\n",
    "archive2 = ('e', 'f', 'g', 'h')\n",
    "\n",
    "active1 = [1, 2, 3, 4]\n",
    "active2 = [5, 6, 7, 8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are typically configured to reference an instance from the global scope using input arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun(t1):\n",
    "    value = t1 * 2\n",
    "    return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This allows them to be used again and again on different data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('a', 'b', 'c', 'd', 'a', 'b', 'c', 'd')"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fun(archive1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('e', 'f', 'g', 'h', 'e', 'f', 'g', 'h')"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fun(archive2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fun(active1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7, 8, 5, 6, 7, 8]"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fun(active2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Care needs to be taken if a function is configured to reference a global mutable instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun(l1):\n",
    "    l1.clear()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because the input argument is a local instance name or reference to a global mutable instance, the global mutable instance is mutated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "fun(active1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "active1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When there is no intention to mutate the original instance, a ```copy``` of it can be created in the functions local namespace:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun(l1):\n",
    "    l2 = l1.copy()\n",
    "    l2.clear()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling the function creates a local copy of ```active2``` and mutates it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "fun(active2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Leaving ```active2``` unchanged:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7, 8]"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "active2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Care should be taken when mutable methods are used in a function with a ```return``` value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun(l1):\n",
    "    popped_val = l1.pop()\n",
    "    return (popped_val, ) * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If ```active2``` is examined:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7, 8]"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "active2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling the above function will return a ```tuple``` that replicates the popped value 3 times:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8, 8, 8)"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fun(active2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that ```active2``` is however mutated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7]"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "active2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If instead a ```copy``` is made in the function and that is operated on:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun(l1):\n",
    "    l2 = l1.copy()\n",
    "    popped_val = l2.pop()\n",
    "    return (popped_val, ) * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The return ```value``` is similar to before:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7, 7, 7)"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fun(active2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However the mutatable ```list``` supplied as a reference via the functions input argument is not mutated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7]"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "active2"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Advantages of Immutability"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most beginner tutorials tend to overuse the ```list``` class and underuse the ```tuple``` class. Although the ```list``` has some additional functionality due to being mutable, this mutability comes with a number of drawbacks which include:\n",
    "\n",
    "* Possible unwanted mutability for example the potential unwanted mutating of a global variable within the local scope of a function\n",
    "* Larger memory overhead\n",
    "* Slower access due to larger memory overhead\n",
    "\n",
    "In general a ```tuple``` should preferentially be used instead of a ```list``` when a ```Collection``` is used to group data that is later read in a program and not modified.\n",
    "\n",
    "An example is the ```return``` statement in a function. This can manually be configured to ```return``` a ```list``` instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun1():\n",
    "    return [1, 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or a ```tuple``` instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun2():\n",
    "    return (1, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If parenthesis aren't specified, a ```tuple``` will also be returned (as the default ```Collection```) using ```tuple``` unpacking:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun3():\n",
    "    return 1, 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be seen in the ```return``` values of these functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4]"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fun1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 4)"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fun2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 4)"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fun3()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Normally the values returned from the function are assigned to variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1, num2 = fun1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same form can be used for ```fun2```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1, num2 = fun2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And ```fun3```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1, num2 = fun3()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above syntax creates a ```tuple``` with the two instance names in it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "(num1, num2) = fun1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the ```tuple``` instance on the left hand side itself is not assigned to an instance name. This is because its only purpose is for a single time use to instantiate the two instance names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the ```enumerate``` class is used on a ```Collection```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index \t Type                 \t Size   \t Value                         \n",
      "0 \t str                  \t 1      \t h                              \t\n",
      "1 \t str                  \t 1      \t e                              \t\n",
      "2 \t str                  \t 1      \t l                              \t\n",
      "3 \t str                  \t 1      \t l                              \t\n",
      "4 \t str                  \t 1      \t o                              \t\n"
     ]
    }
   ],
   "source": [
    "view('hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each element in it is a ```tuple```, this can be seen by casting to a ```tuple```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((0, 'h'), (1, 'e'), (2, 'l'), (3, 'l'), (4, 'o'))"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple(enumerate('hello'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that the ```enumerate``` class is normally used in a ```for``` loop and each element is only used to read data during its specific iteration of the ```for``` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 h\n",
      "1 e\n",
      "2 l\n",
      "3 l\n",
      "4 o\n"
     ]
    }
   ],
   "source": [
    "for index, value in enumerate('hello'):\n",
    "    print(index, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since there are two inbuilt ```Collections```, distinguished by two different types of brackets. They are sometimes used to distinguish nested ```Collections``` from the outer ```Collection```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'h'), (1, 'e'), (2, 'l'), (3, 'l'), (4, 'o')]"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(enumerate('hello'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Return to Python Tutorials](../readme.md)"
   ]
  }
 ],
 "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.12.1"
  },
  "vscode": {
   "interpreter": {
    "hash": "4648373dafda34926c036cc9e466ef2f8d360789320441bb704a9be21d427d2a"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}