03 Lists and Tuples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What you learn:**\n",
    "\n",
    "In this notebook you will learn about basic data structures in Python. This includes lists and tuples.\n",
    "\n",
    "Based on a [tutorial by Zhiya Zuo](https://github.com/zhiyzuo/python-tutorial) and extended where appropriate.\n",
    "\n",
    "Jens Dittrich, [Big Data Analytics Group](https://bigdata.uni-saarland.de/), [CC-BY-SA](https://creativecommons.org/licenses/by-sa/4.0/legalcode)\n",
    "\n",
    "This notebook is available on https://github.com/BigDataAnalyticsGroup/python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list is an ordered collection of items that may contain duplicates."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initialize a list with brackets. You can store anything in a list, even if the individual elements have different types. A list may have duplicates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T00:10:24.538230Z",
     "start_time": "2018-10-09T00:10:24.528793Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(list, [42, 9, 53, 7, 9])"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# define a list:\n",
    "# variable = [el0, el1, ..., eln ]\n",
    "a_list = [42, 9, 53, 7, 9] # commas to seperate elements that are part of a list\n",
    "type(a_list), a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of a_list is: 5\n",
      "The 3rd element of a_list is: 53\n",
      "The last element of a_list is: 53\n",
      "The sum of a_list is: 120\n"
     ]
    }
   ],
   "source": [
    "print(\"Length of a_list is: %i\"%(len(a_list)))\n",
    "print(\"The 3rd element of a_list is: %s\" %(a_list[2])) # Remember Python starts with 0\n",
    "print(\"The last element of a_list is: %s\" %(a_list[-3])) # -1 means the end\n",
    "print(\"The sum of a_list is: %i\"%(sum(a_list)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T00:10:32.820098Z",
     "start_time": "2018-10-09T00:10:32.815341Z"
    }
   },
   "source": [
    "We can put different elements of different types into a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T00:10:35.486742Z",
     "start_time": "2018-10-09T00:10:35.479281Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b_list = [20, True, \"good\", \"good\"] \n",
    "b_list\n",
    "type(b_list[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modify and Update a list using __pop__, __remove__, __append__, __extend__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T00:10:41.107486Z",
     "start_time": "2018-10-09T00:10:41.102493Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[42, 9, 53, 7, 8, 2, 3, 1]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = [42, 9, 53, 7, 8, 2, 3, 1]\n",
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pop 9 out of a_list\n",
      "[42, 53, 7, 8, 2, 3, 1]\n"
     ]
    }
   ],
   "source": [
    "print(\"Pop %i out of a_list\"%a_list.pop(1)) # pop (ie.e. remove) the value at an index position\n",
    "print(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pop 7 out of a_list\n",
      "[42, 53, 8, 2, 3, 1]\n"
     ]
    }
   ],
   "source": [
    "print(\"Pop %i out of a_list\"%a_list.pop(2)) # pop (ie.e. remove) the value at an index position\n",
    "print(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T00:10:43.906572Z",
     "start_time": "2018-10-09T00:10:43.899877Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[20, True, 'good', 42, 'good', 11]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b_list = [20, True, \"good\", 42, \"good\", 11] \n",
    "b_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remove the string good from b_list:\n",
      "[20, True, 42, 'good', 11]\n"
     ]
    }
   ],
   "source": [
    "print(\"Remove the string good from b_list:\")\n",
    "b_list.remove(\"good\") # remove first occurence(!) of a specific value\n",
    "print(b_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[42, 53, 8, 2, 3, 1]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T00:10:45.307563Z",
     "start_time": "2018-10-09T00:10:45.302951Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[42, 53, 8, 2, 3, 1, 10]\n"
     ]
    }
   ],
   "source": [
    "a_list.append(10) # append integer 10 to the end of the list\n",
    "print(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([42, 53, 8, 2, 3, 1, 10], [20, True, 42, 'good', 11])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list, b_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T00:10:45.952388Z",
     "start_time": "2018-10-09T00:10:45.943473Z"
    }
   },
   "source": [
    "merge `a_list` and `b_list`, i.e. append all elements of `b_list` to the end of `a_list`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T00:12:02.249064Z",
     "start_time": "2018-10-09T00:12:02.241901Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merging a_list and b_list: [42, 53, 8, 2, 3, 1, 10, 20, True, 42, 'good', 11]\n"
     ]
    }
   ],
   "source": [
    "a_list.extend(b_list)\n",
    "print(\"Merging a_list and b_list: %s\"%(str(a_list)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T00:10:45.952388Z",
     "start_time": "2018-10-09T00:10:45.943473Z"
    }
   },
   "source": [
    "We can also use `+` as a shorthand to concatenate two lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T00:12:03.301969Z",
     "start_time": "2018-10-09T00:12:03.295626Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[42, 53, 8, 2, 3, 1, 10, 20, True, 42, 'good', 11, 20, True, 42, 'good', 11]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list + b_list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo = [] # create an empty list\n",
    "foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B', 'C']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo.append(\"A\") # add to the end\n",
    "foo.append('B') # add to the end, single or double quote makes no difference\n",
    "foo.append(\"C\") # add to the end\n",
    "foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B', 'C', 'F']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo.insert(5,\"F\")    # insert at an index\n",
    "foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(['A', 'B', 'C', 'F'], ['A', 'B', 'C', 'F'])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted_list = sorted(foo) # returns a new, sorted list\n",
    "sorted_list, foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B', 'C', 'F']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo.sort()           # in place sort\n",
    "foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'C', 'F']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo.pop(1) # return and remove the item at index 2\n",
    "foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['F', 'C', 'A']"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo.reverse()       # reverse the list\n",
    "foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo.append(\"A\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['F', 'C', 'A', 'A']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = foo.index(\"A\") # return index of \"A\"\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo.pop(foo.index(\"C\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-10-03T15:58:48.469747Z",
     "start_time": "2017-10-03T15:58:48.461327Z"
    }
   },
   "source": [
    "A tuple is a special case of a list whose elements cannot be changed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initialize a tuple with parenthesis. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T00:12:16.790034Z",
     "start_time": "2018-10-09T00:12:16.784149Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 10)\n",
      "First element of a_tuple: 1\n"
     ]
    }
   ],
   "source": [
    "a_tuple = (1, 2, 3, 10)\n",
    "print(a_tuple)\n",
    "print(\"First element of a_tuple: %i\"%a_tuple[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "#a_tuple.remove(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T00:12:17.683012Z",
     "start_time": "2018-10-09T00:12:17.672651Z"
    }
   },
   "source": [
    "You cannot change the values of a_tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T00:12:24.288097Z",
     "start_time": "2018-10-09T00:12:24.278444Z"
    }
   },
   "outputs": [],
   "source": [
    "#a_tuple[0] = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to create a single value tuple, you need to add a ',':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_tuple = (1) # this would create an int type\n",
    "type(a_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b_tuple = (42,) # this would create a tuple type, take note of the comma.\n",
    "type(b_tuple)"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.12"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "677px",
    "left": "0px",
    "right": "1111px",
    "top": "43px",
    "width": "340px"
   },
   "toc_section_display": "block",
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}