IntroCoding_Lecture1.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists and Loops\n",
    "\n",
    "In this lesson we will get to know and become experts in:\n",
    "\n",
    "1. Lists\n",
    "    * DataCamp, [Introduction to Python](https://app.datacamp.com/learn/courses/intro-to-python-for-data-science), Chap 2\n",
    "2. Loops\n",
    "    * DataCamp, [Intermediate Python](https://campus.datacamp.com/courses/intermediate-python), Chap 4\n",
    "3. Conditions\n",
    "    * DataCamp, [Intermediate Python](https://campus.datacamp.com/courses/intermediate-python), Chap 3"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List\n",
    "\n",
    "In contrast with tuples, lists are variable length and their contents can be modified in place. Lists are mutable. You can define them using square brackets `[]` or using the `list` type function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.73, 1.68, 1.71, 1.89]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam = [1.73, 1.68, 1.71, 1.89]\n",
    "fam = list((1.73, 1.68, 1.71, 1.89))\n",
    "fam"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can `sort`, `append`,`insert`, concatenate, ... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#sorting is in place!\n",
    "fam.sort()\n",
    "fam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fam.append(2.05)\n",
    "fam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.73, 1.68, 1.71, 1.89, 1.73, 1.68, 1.71, 1.89]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam + fam"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can\n",
    "\n",
    "- Contain any type\n",
    "- Contain different types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam2 = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam2"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List of lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['liz', 1.73], ['emma', 1.68], ['mom', 1.71], ['dad', 1.89]]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam3 = [[\"liz\", 1.73],\n",
    "         [\"emma\", 1.68],\n",
    "         [\"mom\", 1.71],\n",
    "         [\"dad\", 1.89]]\n",
    "fam3"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing\n",
    "\n",
    "<p>You can select sections of most sequence types by using slice notation, which in its basic form consists of <code>start:stop</code> passed to the indexing operator <code>[]</code>:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.68, 1.71]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam[1:3]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>While the element at the <code>start</code> index is included, the <code>stop</code> index is <em>not included</em>, so that the number of elements in the result is <code>stop - start</code>.</p>\n",
    "<p>Either the <code>start</code> or <code>stop</code> can be omitted, in which case they default to the start of the sequence and the end of the sequence, respectively:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.68, 1.71, 1.89]\n",
      "[1.73, 1.68, 1.71]\n"
     ]
    }
   ],
   "source": [
    "print(fam[1:])\n",
    "print(fam[:3])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Negative indices slice the sequence relative to the end:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.73, 1.68, 1.71, 1.89]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam[-4:]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Slicing semantics takes a bit of getting used to, especially if you’re coming from R or MATLAB. See this helpful illustration of slicing with positive and negative integers. In the figure, the indices are shown at the \"bin edges\" to help show where the slice selections start and stop using positive or negative indices.</p>\n",
    "<figure id=\"figure_seq_slicing\" class=\"figure\">\n",
    "<img src=\"figures/pda3_0301.png\" class=\"figure-img\">\n",
    "<figcaption class=\"figure-caption\">\n",
    "Illustration of Python slicing conventions\n",
    "</figcaption>\n",
    "</figure>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------------------\n",
    "\n",
    "### Manipulating lists of lists\n",
    "\n",
    "The following list of lists contains names of sections in a house and their area.\n",
    "\n",
    "1. Extract the area corresponding to kitchen\n",
    "2. String Tasks:\n",
    "    - Extract the first letters of each string\n",
    "    - Capitalize all strings\n",
    "    - Replace all occurrences of \"room\" with \"rm\"\n",
    "    - count the number of \"l\" in \"hallway\" \n",
    "3. Insert a \"home office\" with area 10.75 after living room\n",
    "4. Append the total area to the end of the list\n",
    "5. **Boolean** operations:\n",
    "    - Generate one True and one False by comparing areas\n",
    "    - Generate one True and one False by comparing names\n",
    "     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "house = [['hallway', 11.25],\n",
    " ['kitchen', 18.0],\n",
    " ['living room', 20.0],\n",
    " ['bedroom', 10.75],\n",
    " ['bathroom', 9.5]]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Automation by iterating\n",
    "\n",
    "**for loops** are a powerful way of automating MANY otherwise tedious tasks that repeat.\n",
    "\n",
    "The syntax template is (watch the indentation!):\n",
    "\n",
    "````\n",
    "for var in seq :\n",
    "     expression\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.73\n",
      "1.68\n",
      "1.71\n",
      "1.89\n"
     ]
    }
   ],
   "source": [
    "#We can use lists:\n",
    "for f in fam:\n",
    "    print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.73\n",
      "1.68\n",
      "1.71\n",
      "1.89\n"
     ]
    }
   ],
   "source": [
    "#or iterators\n",
    "for i in range(len(fam)):\n",
    "    print(fam[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.73 1.73\n",
      "1.68 1.68\n",
      "1.71 1.71\n",
      "1.89 1.89\n"
     ]
    }
   ],
   "source": [
    "#or enumerate\n",
    "for i,f in enumerate(fam):\n",
    "    print(fam[i], f)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterators (Optional)\n",
    "\n",
    "An iterator is an object that contains a countable number of values.\n",
    "\n",
    "An iterator is an object that can be iterated upon, meaning that you can traverse through all the values.\n",
    "\n",
    "Technically, in Python, an iterator is an object which implements the iterator protocol, which consist of the methods `iter()` and `next()`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "banana\n"
     ]
    }
   ],
   "source": [
    "mytuple = (\"apple\", \"banana\", \"cherry\")\n",
    "myit = iter(mytuple)\n",
    "\n",
    "print(next(myit))\n",
    "print(next(myit))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "mystr = \"banana\"\n",
    "myit = iter(mystr)\n",
    "\n",
    "print(next(myit))\n",
    "print(next(myit))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are also iterable objects, containing a sequence of characters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 5)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#funny iterators\n",
    "print(range(5))\n",
    "list(range(5))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Repeat the tasks 2 and 4 from above by using a for loop\n",
    "    - using `enumerate`\n",
    "    - using `range`\n",
    "2. Create two separates new lists which contain only the names and areas separately\n",
    "3. [Clever Carl](https://nrich.maths.org/2478#:~:text=Gauss%20added%20the%20rows%20pairwise,quantity%20in%20a%20clever%20way.): Compute \n",
    "$$\n",
    "\\sum_{i=1}^{100}{i}\n",
    "$$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditions\n",
    "\n",
    "The syntax template is (watch the indentation!):\n",
    "\n",
    "````\n",
    "if condition:\n",
    "     expression\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.89\n"
     ]
    }
   ],
   "source": [
    "for f in fam:\n",
    "    if f > 1.8:\n",
    "        print(f)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Find the **max** of the areas by using `if` inside a for loop\n",
    "2. Print those elements of the list with \n",
    "    - area $> 15$\n",
    "    - strings that contain \"room\" (or \"rm\" after your substitution)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.0"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "cc4e3cb0b66e3cf40341812cc2bd10256c32822435ddcf03aec3c5d3b18cd7d2"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}