notebooks/Lecture 9.3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "be8ff415",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lecture 9.3. \n",
    "\n",
    "# Fri, Oct 28\n",
    "\n",
    "# Lists (continued)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c100b42c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "rainbow = [\"Red\", \"Orange\", \"Yellow\", \"Green\", \"Blue\", \"Indigo\", \"Violet\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86cbd345",
   "metadata": {},
   "source": [
    "![list](https://i.ibb.co/GJkSBQ7/Screen-Shot-2022-10-27-at-1-21-19-PM.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "425779e6",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 9.3.1. Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a5b14d7",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* **Slicing** allows accessing a sublist within a list\n",
    "    * Think of it as grabbing a slice of pizza/pie/bread\n",
    "\n",
    "* You can slice a list using a **range of indices** that specify where to **start** and where to **end** the slice \n",
    "    * Syntax: **`list_variable[start:end]`** where start and end are indices. \n",
    "    * Indices are **always integers**!\n",
    "    * Starting index is **included**. Ending index is **excluded**. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc81d76a",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* When slicing a list, the **return value will be the new _list_** with the relevant items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "id": "97f63a49",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Red', 'Orange']\n"
     ]
    }
   ],
   "source": [
    "rainbow = [\"Red\", \"Orange\", \"Yellow\", \"Green\", \"Blue\", \"Indigo\", \"Violet\"]\n",
    "print(rainbow[0: 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3aa7c93b",
   "metadata": {},
   "source": [
    "<center><img width=1000 src=\"https://i.ibb.co/mC5fhS5/Screen-Shot-2022-10-27-at-1-43-54-PM.png\" /></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1496738",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* When `start` index is not explicitly stated in slicing, the default value is 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "id": "ea0d1109",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Red', 'Orange', 'Yellow', 'Green']\n",
      "['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet']\n"
     ]
    }
   ],
   "source": [
    "print(rainbow[:4])\n",
    "\n",
    "print(rainbow)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4376cf01",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<center><img width=\"1000\" src=\"https://i.ibb.co/VNYGKyt/Screen-Shot-2022-10-27-at-5-56-57-PM.png\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c4dbfb1",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* When `end` index is not explicitly stated in slicing, the default value is `len(list)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "id": "c3394a25",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Green', 'Blue', 'Indigo', 'Violet']\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(rainbow[3:])\n",
    "\n",
    "print(rainbow[3:len(rainbow)]==rainbow[3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d9390fa",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<center><img width=1000 src=\"https://i.ibb.co/0jWbzPW/Screen-Shot-2022-10-27-at-5-57-13-PM.png\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8955f41d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* `start` index has default value `0`\n",
    "* `end`   index has default value `len(list)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "id": "70261633",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet']\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(rainbow[:])\n",
    "print(rainbow[:] == rainbow[0:len(rainbow)])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b89ae51",
   "metadata": {},
   "source": [
    "![all](https://i.ibb.co/zmJpbHD/Screen-Shot-2022-10-27-at-6-07-40-PM.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1995dfe2",
   "metadata": {},
   "source": [
    "* <span style=\"color:red\">**When slicing, any indices  `>= len(list)` will _NOT_ result in `IndexError`**</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "id": "1716e1c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet']"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rainbow[1:9]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e12209b3",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 9.3.2. Negative indices"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "559fde85",
   "metadata": {},
   "source": [
    "* **Negative indices** allow accessing items in the **opposite direction**\n",
    "\n",
    "* _Largest_ negative index is `-1` which refers to the last item, `-2` refers to the second last item and so on.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "id": "5825a281",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet']"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rainbow[-8:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "id": "9aa7a77a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 227,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rainbow[-3] == rainbow[4]\n",
    "\n",
    "rainbow[0] == rainbow[-1*len(rainbow)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0330d0ae",
   "metadata": {},
   "source": [
    "<img src=\"https://i.ibb.co/Pw1gsgW/Screen-Shot-2022-10-27-at-10-17-05-PM.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c02d88c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* **Slicing** with **negative indices** works in the **same direction** as when slicing with positive indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "id": "1494e3ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Red', 'Orange', 'Yellow', 'Green']"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rainbow[-7: 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9a78af8",
   "metadata": {},
   "source": [
    "<img src=\"https://i.ibb.co/dGwY4LG/Screen-Shot-2022-10-27-at-11-49-37-PM.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46a759a2",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 9.3.3. Matrices (Nested Lists)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "id": "55da5eb3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 243,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colors_matrix = [ [\"Red\", \"Orange\", \"Maroon\"],\\\n",
    "                 [\"Blue\", \"Indigo\", \"Violet\"],\\\n",
    "                 [\"Green\", \"Lime\", \"Olive\"] ]\n",
    "\n",
    "first_row = colors_matrix[0]\n",
    "first_item = first_row[0]\n",
    "\n",
    "first_item==colors_matrix[0][0]#, colors_matrix[1][0], colors_matrix[2][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "746c0306",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<center><img width=\"700\" src=\"https://i.ibb.co/syWsKkS/matrix.png\"></center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "id": "50768da4",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Red', 'Orange', 'Maroon']"
      ]
     },
     "execution_count": 245,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colors_matrix = [ [\"Red\", \"Orange\", \"Maroon\"], [\"Blue\", \"Indigo\", \"Violet\"], [\"Green\", \"Lime\", \"Olive\"]]\n",
    "colors_matrix[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3e38716",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<center><img width=800 src=\"https://i.ibb.co/dPH1yn6/matrix1.png\" /></center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "id": "4cc3ad45",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 251,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colors_matrix = [ [\"Red\", \"Orange\", \"Maroon\"], None,\\\n",
    "                 [\"Blue\", \"Indigo\", \"Violet\"], [\"Green\", \"Lime\", \"Olive\"], \\\n",
    "                True, 8.0, 99]\n",
    "type(colors_matrix[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f29bac1",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<center><img width=\"800\" src=\"https://i.ibb.co/jR0hnQ1/matrix2.png\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82f5ded8",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 4.2.3.  Arguments (Inputs) of type `int`, `float`, `bool` and `str` are passed by value "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77c8cd64",
   "metadata": {},
   "source": [
    "* Arguments (Inputs) to a function, of type `int`, `float`, `bool` and `str`, are passed by value\n",
    "\n",
    "\n",
    "* This means the input/arguments variables inside of a function are **copies** of variables from the caller. \n",
    "\n",
    "\n",
    "* Thus changing value of variables of these types inside a function does not change their values on the caller's end. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "id": "3dc8d88f",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Line 12 - Before function call x = 1\n",
      "Line 3 - Inside function and before updating, x = 1\n",
      "Line 7 - Inside function and after updating, x = 2\n",
      "Line 16 - After function call x = 1\n"
     ]
    }
   ],
   "source": [
    "def myfunc(x):\n",
    "\n",
    "    print(\"Line 3 - Inside function and before updating, x =\", x)\n",
    "    \n",
    "    x = x + 1\n",
    "    \n",
    "    print(\"Line 7 - Inside function and after updating, x =\", x)\n",
    "\n",
    "\n",
    "x = 1\n",
    "\n",
    "print(\"Line 12 - Before function call x =\", x)\n",
    "\n",
    "myfunc(x)\n",
    "\n",
    "print(\"Line 16 - After function call x =\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bf0262f",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 9.3.3. Lists passed to Functions by Reference "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8ed0f45",
   "metadata": {},
   "source": [
    "* Variables of type `list` passed to functions are **_NOT_ passed by value** but **by Reference**\n",
    "\n",
    "* This means the input/arguments variables inside of a function are **_NOT_ copies** of variables from the caller\n",
    "\n",
    "* **_Changing value of list variables inside a function also changes their values on the caller's end._**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d31850d0",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center><img width=\"700\" src=\"http://www.differencebetween.info/sites/default/files/images_articles_d7_1/call-by-value-and-call-by-reference1.gif\"></center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "id": "4a2e220b",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Passed by value: \n",
    "Integers, Booleans, Floats, \n",
    "\"\"\"\n",
    "def func(val):\n",
    "    val = 10\n",
    "    \n",
    "val = 2\n",
    "func(val)\n",
    "print(val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "id": "d15cbeb4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 10]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Passed by reference\"\"\"\n",
    "def func(list_input):\n",
    "    list_input.append(10)\n",
    "    \n",
    "my_list = [1, 2, 3]\n",
    "func(my_list)\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6cfc6a7",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 9.3.4. Concatenating lists using `+`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73a6f2e6",
   "metadata": {},
   "source": [
    "* Multiple lists can be concatenated using the `+` operator in Python\n",
    "\n",
    "* The `list1 + list2` performs the following operations in this order: \n",
    "1. Creates a new empty list for output\n",
    "    * Operands lists remain unchanged\n",
    "2. Appends all items of list1 in the newly created list\n",
    "3. Appends all items of list2 in the newly created list\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "id": "df0ae792",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 2, 4]"
      ]
     },
     "execution_count": 272,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 3] + [2, 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "id": "b9fd291b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "([1, 2, 3] + [4, 5, 6]) + [7, 8, 9]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f461254",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 9.3.5 Multiplying lists using `*`\n",
    "\n",
    "* When a list is multiplied with a integer, say `x`, the list is concantenated to itself `x` times. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "id": "a3069194",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 1, 2, 3, 1, 2, 3]"
      ]
     },
     "execution_count": 288,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2, 3] * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bfae72b",
   "metadata": {},
   "source": [
    "* Multiplication of lists with negative numbers results in empty lists \n",
    "\n",
    "* Multiplication with floating point numbers not allowed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b494181",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5e46096e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 9.3.6. Operators not allowed with lists"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e171e2bc",
   "metadata": {},
   "source": [
    "* Python operations **not allowed** with lists (neither between **two or more lists** nor between **list and numeric data types**): \n",
    "    \n",
    "  * Subtraction `-`\n",
    "  * Division (`/`)\n",
    "  * Modulus (`%`)\n",
    "  * Floor Division (`//`)\n",
    "  * Exponential (`**`)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce35082c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 9.3.7. Recall `[] == False`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "id": "f829fadc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, False, False, False, True, True)"
      ]
     },
     "execution_count": 289,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(None), bool(0), bool([]), bool(\"\"), bool(\" \"), bool(\"a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "id": "3d4f9a0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b\n"
     ]
    }
   ],
   "source": [
    "if []:\n",
    "    print('a')\n",
    "else:\n",
    "    print('b')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9b031a1",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Implement `csc121_min` which takes as input a list `x` and returns the minimum value within x.\n",
    "\n",
    "**Using built-in functions not allowed**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc8bc6ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "def csc121_min(x):\n",
    "    \n",
    "    return min_value\n",
    "\n",
    "assert csc121_min([9, 8, 7, 0, 10]) == 0,    \"Test case 1 failed\"\n",
    "assert csc121_min([])               == None, \"Test case 2 failed\"\n",
    "assert csc121_min([1])              == 1,    \"Test case 3 failed\"\n",
    "assert csc121_min([-99, 0, 99])     == -99,  \"Test case 4 failed\"\n",
    "assert csc121_min([0, None, 99])    == 0,  \"Test case 4 failed\""
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}