python foundation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Foundation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "print('Hello World!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Ecosystem\n",
    "\n",
    "Python relies on virtual environments and pip to create and maitaing environments and packages:\n",
    "1. **Python Virtual Environments:** create a isolated environment for your project\n",
    "2. **Python Pip:** tools that is able to download and install libraries from the repository\n",
    "\n",
    "## Python Virtual Enviroment\n",
    "1. Create a basic virtual environment\n",
    "```\n",
    "python3 -m venv venv\n",
    "```\n",
    "2. Activate a virtual environment\n",
    "```\n",
    "source venv/bin/activate\n",
    "```\n",
    "3. Deactivate a virtual environment\n",
    "```\n",
    "deactivate\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Pip\n",
    "1. Install a library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pip install jupyter --upgrade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Search a library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pip search jupyter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Uninstall a library\n",
    "```\n",
    "pip uninstall jupyter\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python requirements.txt\n",
    "\n",
    "The **requirements.txt** is a file used to store all the necessary libraries for a given project.\n",
    "\n",
    "It follows a simple structure, the library name and optionally the version.\n",
    "\n",
    "Antoher important aspect, the libraries can be imported directly from github projects.\n",
    "\n",
    "Sample with conventional and github libraries:\n",
    "\n",
    "```\n",
    "requests>=2.22.0\n",
    "certvalidator>=0.11.1\n",
    "pyOpenSSL>=19.0.0\n",
    "beautifulsoup4>=4.8.1\n",
    "-e git+https://github.com/catarinaacsilva/html-similarity.git#egg=html_similarity\n",
    "-e git+https://github.com/catarinaacsilva/check-https-utils#egg=check_https_utils\n",
    "-e git+https://github.com/catarinaacsilva/web-cache.git#egg=webcache\n",
    "```\n",
    "\n",
    "To install the requirements you can use pip with the following options:\n",
    "\n",
    "```\n",
    "pip install -r requirements.txt\n",
    "```\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python objects, basic types, and variables\n",
    "\n",
    "Everything in Python is an **object** and every object in Python has a **type**. Some of the basic types include:\n",
    "\n",
    "- **`int`** (integer; a whole number with no decimal place)\n",
    "  - `10`\n",
    "  - `-3`\n",
    "- **`float`** (float; a number that has a decimal place)\n",
    "  - `7.41`\n",
    "  - `-0.006`\n",
    "- **`str`** (string; a sequence of characters enclosed in single quotes, double quotes, or triple quotes)\n",
    "  - `'this is a string using single quotes'`\n",
    "  - `\"this is a string using double quotes\"`\n",
    "  - `'''this is a triple quoted string using single quotes'''`\n",
    "  - `\"\"\"this is a triple quoted string using double quotes\"\"\"`\n",
    "- **`bool`** (boolean; a binary value that is either true or false)\n",
    "  - `True`\n",
    "  - `False`\n",
    "- **`NoneType`** (a special type representing the absence of a value)\n",
    "  - `None`\n",
    "\n",
    "In Python, a **variable** is a name you specify in your code that maps to a particular **object**, object **instance**, or value.\n",
    "\n",
    "By defining variables, we can refer to things by names that make sense to us. Names for variables can only contain letters, underscores (`_`), or numbers (no spaces, dashes, or other characters). Variable names must start with a letter or underscore.\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic operators\n",
    "\n",
    "In Python, there are different types of **operators** (special symbols) that operate on different values. Some of the basic operators include:\n",
    "\n",
    "- arithmetic operators\n",
    "  - **`+`** (addition)\n",
    "  - **`-`** (subtraction)\n",
    "  - **`*`** (multiplication)\n",
    "  - **`/`** (division)\n",
    "  - __`**`__ (exponent)\n",
    "- assignment operators\n",
    "  - **`=`** (assign a value)\n",
    "  - **`+=`** (add and re-assign; increment)\n",
    "  - **`-=`** (subtract and re-assign; decrement)\n",
    "  - **`*=`** (multiply and re-assign)\n",
    "- comparison operators (return either `True` or `False`)\n",
    "  - **`==`** (equal to)\n",
    "  - **`!=`** (not equal to)\n",
    "  - **`<`** (less than)\n",
    "  - **`<=`** (less than or equal to)\n",
    "  - **`>`** (greater than)\n",
    "  - **`>=`** (greater than or equal to)\n",
    "\n",
    "When multiple operators are used in a single expression, **operator precedence** determines which parts of the expression are evaluated in which order. Operators with higher precedence are evaluated first (like PEMDAS in math). Operators with the same precedence are evaluated from left to right.\n",
    "\n",
    "- `()` parentheses, for grouping\n",
    "- `**` exponent\n",
    "- `*`, `/` multiplication and division\n",
    "- `+`, `-` addition and subtraction\n",
    "- `==`, `!=`, `<`, `<=`, `>`, `>=` comparisons\n",
    "\n",
    "> See https://docs.python.org/3/reference/expressions.html#operator-precedence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assigning some numbers to different variables\n",
    "num1 = 10\n",
    "num2 = -3\n",
    "num3 = 7.41\n",
    "num4 = -.6\n",
    "num5 = 7\n",
    "num6 = 3\n",
    "num7 = 11.11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Addition\n",
    "num1 + num2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-4.446"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiplication\n",
    "num3 * num4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.08571428571428572"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Division\n",
    "num4 / num5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "343"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exponent\n",
    "num5 ** num6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15.11\n"
     ]
    }
   ],
   "source": [
    "# Increment existing variable\n",
    "num7 += 4\n",
    "print(num7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "# Decrement existing variable\n",
    "num6 -= 2\n",
    "print(num6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37.05\n"
     ]
    }
   ],
   "source": [
    "# Multiply & re-assign\n",
    "num3 *= 5\n",
    "print(num3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-101.14999999999999\n"
     ]
    }
   ],
   "source": [
    "# Assign the value of an expression to a variable\n",
    "num8 = num1 + num2 * num3\n",
    "print(num8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Are these two expressions equal to each other?\n",
    "num1 + num2 == num5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Are these two expressions not equal to each other?\n",
    "num3 != num4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Is the first expression less than the second expression?\n",
    "num5 < num6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Is this expression True?\n",
    "5 > 3 > 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Is this expression True?\n",
    "5 > 3 < 4 == 3 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic containers\n",
    "\n",
    "> Note: **mutable** objects can be modified after creation and **immutable** objects cannot.\n",
    "\n",
    "Containers are objects that can be used to group other objects together. The basic container types include:\n",
    "\n",
    "- **`str`** (string: immutable; indexed by integers; items are stored in the order they were added)\n",
    "- **`list`** (list: mutable; indexed by integers; items are stored in the order they were added)\n",
    "  - `[3, 5, 6, 3, 'dog', 'cat', False]`\n",
    "- **`tuple`** (tuple: immutable; indexed by integers; items are stored in the order they were added)\n",
    "  - `(3, 5, 6, 3, 'dog', 'cat', False)`\n",
    "- **`set`** (set: mutable; not indexed at all; items are NOT stored in the order they were added; can only contain immutable objects; does NOT contain duplicate objects)\n",
    "  - `{3, 5, 6, 3, 'dog', 'cat', False}`\n",
    "- **`dict`** (dictionary: mutable; key-value pairs are indexed by immutable keys; items are NOT stored in the order they were added)\n",
    "  - `{'name': 'Jane', 'age': 23, 'fav_foods': ['pizza', 'fruit', 'fish']}`\n",
    "\n",
    "When defining lists, tuples, or sets, use commas (,) to separate the individual items. When defining dicts, use a colon (:) to separate keys from values and commas (,) to separate the key-value pairs.\n",
    "\n",
    "Strings, lists, and tuples are all **sequence types** that can use the `+`, `*`, `+=`, and `*=` operators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assign some strings to different variables\n",
    "simple_string1 = 'an example'\n",
    "simple_string2 = \"oranges \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'an example of using the + operator'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Addition\n",
    "simple_string1 + ' of using the + operator'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'an example'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Notice that the string was not modified\n",
    "simple_string1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'oranges oranges oranges oranges '"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiplication\n",
    "simple_string2 * 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'oranges '"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This string wasn't modified either\n",
    "simple_string2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Are these two expressions equal to each other?\n",
    "simple_string1 == simple_string2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Are these two expressions equal to each other?\n",
    "simple_string1 == 'an example'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'an example that re-assigned the original string'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add and re-assign\n",
    "simple_string1 += ' that re-assigned the original string'\n",
    "simple_string1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'oranges oranges oranges '"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiply and re-assign\n",
    "simple_string2 *= 3\n",
    "simple_string2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assign some containers to different variables\n",
    "list1 = [3, 5, 6, 3, 'dog', 'cat', False]\n",
    "tuple1 = (3, 5, 6, 3, 'dog', 'cat', False)\n",
    "set1 = {3, 5, 6, 3, 'dog', 'cat', False}\n",
    "dict1 = {'name': 'Jane', 'age': 23, 'fav_foods': ['pizza', 'fruit', 'fish']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 6, 3, 'dog', 'cat', False]\n"
     ]
    }
   ],
   "source": [
    "# Items in the list object are stored in the order they were added\n",
    "print(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 5, 6, 3, 'dog', 'cat', False)\n"
     ]
    }
   ],
   "source": [
    "# Items in the tuple object are stored in the order they were added\n",
    "print(tuple1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{False, 3, 5, 6, 'dog', 'cat'}\n"
     ]
    }
   ],
   "source": [
    "# Items in the set object are not stored in the order they were added\n",
    "# Also, notice that the value 3 only appears once in this set object\n",
    "print(set1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Jane', 'age': 23, 'fav_foods': ['pizza', 'fruit', 'fish']}\n"
     ]
    }
   ],
   "source": [
    "# Items in the dict object are not stored in the order they were added\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 6, 3, 'dog', 'cat', False, 5, 'grapes']\n"
     ]
    }
   ],
   "source": [
    "# Add and re-assign\n",
    "list1 += [5, 'grapes']\n",
    "print(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 5, 6, 3, 'dog', 'cat', False, 5, 'grapes')\n"
     ]
    }
   ],
   "source": [
    "# Add and re-assign\n",
    "tuple1 += (5, 'grapes')\n",
    "print(tuple1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiply\n",
    "[1, 2, 3, 4] * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiply\n",
    "(1, 2, 3, 4) * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Accessing data in containers\n",
    "\n",
    "For strings, lists, tuples, and dicts, we can use **subscript notation** (square brackets) to access data at an index.\n",
    "\n",
    "- strings, lists, and tuples are indexed by integers, **starting at 0** for first item\n",
    "  - these sequence types also support accesing a range of items, known as **slicing**\n",
    "  - use **negative indexing** to start at the back of the sequence\n",
    "- dicts are indexed by their keys\n",
    "\n",
    "> Note: sets are not indexed, so we cannot use subscript notation to access data elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# Access the first item in a sequence\n",
    "print(list1[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "grapes\n"
     ]
    }
   ],
   "source": [
    "# Access the last item in a sequence\n",
    "print(tuple1[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "examp\n"
     ]
    }
   ],
   "source": [
    "# Access a range of items in a sequence\n",
    "print(simple_string1[3:8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 5, 6, 3, 'dog', 'cat')\n"
     ]
    }
   ],
   "source": [
    "# Access a range of items in a sequence\n",
    "print(tuple1[:-3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['dog', 'cat', False, 5, 'grapes']\n"
     ]
    }
   ],
   "source": [
    "# Access a range of items in a sequence\n",
    "print(list1[4:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jane\n"
     ]
    }
   ],
   "source": [
    "# Access an item in a dictionary\n",
    "print(dict1['name'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fish\n"
     ]
    }
   ],
   "source": [
    "# Access an element of a sequence in a dictionary\n",
    "print(dict1['fav_foods'][2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python built-in functions and callables\n",
    "\n",
    "A **function** is a Python object that you can \"call\" to **perform an action** or compute and **return another object**. You call a function by placing parentheses to the right of the function name. Some functions allow you to pass **arguments** inside the parentheses (separating multiple arguments with a comma). Internal to the function, these arguments are treated like variables.\n",
    "\n",
    "Python has several useful built-in functions to help you work with different objects and/or your environment. Here is a small sample of them:\n",
    "\n",
    "- **`type(obj)`** to determine the type of an object\n",
    "- **`len(container)`** to determine how many items are in a container\n",
    "- **`callable(obj)`** to determine if an object is callable\n",
    "- **`sorted(container)`** to return a new list from a container, with the items sorted\n",
    "- **`sum(container)`** to compute the sum of a container of numbers\n",
    "- **`min(container)`** to determine the smallest item in a container\n",
    "- **`max(container)`** to determine the largest item in a container\n",
    "- **`abs(number)`** to determine the absolute value of a number\n",
    "- **`repr(obj)`** to return a string representation of an object\n",
    "\n",
    "> Complete list of built-in functions: https://docs.python.org/3/library/functions.html\n",
    "\n",
    "There are also different ways of defining your own functions and callable objects that we will explore later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the type() function to determine the type of an object\n",
    "type(simple_string1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the len() function to determine how many items are in a container\n",
    "len(dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the len() function to determine how many items are in a container\n",
    "len(simple_string2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the callable() function to determine if an object is callable\n",
    "callable(len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the callable() function to determine if an object is callable\n",
    "callable(dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-3, 1, 2, 3.6, 5, 7, 10]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the sorted() function to return a new list from a container, with the items sorted\n",
    "sorted([10, 1, 3.6, 7, 5, 2, -3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['California', 'Chicago', 'ants', 'cats', 'dogs', 'mice', 'zebras']"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the sorted() function to return a new list from a container, with the items sorted\n",
    "# - notice that capitalized strings come first\n",
    "sorted(['dogs', 'cats', 'zebras', 'Chicago', 'California', 'ants', 'mice'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25.6"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the sum() function to compute the sum of a container of numbers\n",
    "sum([10, 1, 3.6, 7, 5, 2, -3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the min() function to determine the smallest item in a container\n",
    "min([10, 1, 3.6, 7, 5, 2, -3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the min() function to determine the smallest item in a container\n",
    "min(['g', 'z', 'a', 'y'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the max() function to determine the largest item in a container\n",
    "max([10, 1, 3.6, 7, 5, 2, -3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'s'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the max() function to determine the largest item in a container\n",
    "max('gibberish')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the abs() function to determine the absolute value of a number\n",
    "abs(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the abs() function to determine the absolute value of a number\n",
    "abs(-12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"{False, 3, 5, 6, 'dog', 'cat'}\""
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the repr() function to return a string representation of an object\n",
    "repr(set1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python object attributes (methods and properties)\n",
    "\n",
    "Different types of objects in Python have different **attributes** that can be referred to by name (similar to a variable). To access an attribute of an object, use a dot (`.`) after the object, then specify the attribute (i.e. `obj.attribute`)\n",
    "\n",
    "When an attribute of an object is a callable, that attribute is called a **method**. It is the same as a function, only this function is bound to a particular object.\n",
    "\n",
    "When an attribute of an object is not a callable, that attribute is called a **property**. It is just a piece of data about the object, that is itself another object.\n",
    "\n",
    "The built-in `dir()` function can be used to return a list of an object's attributes.\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some methods on string objects\n",
    "\n",
    "- **`.capitalize()`** to return a capitalized version of the string (only first char uppercase)\n",
    "- **`.upper()`** to return an uppercase version of the string (all chars uppercase)\n",
    "- **`.lower()`** to return an lowercase version of the string (all chars lowercase)\n",
    "- **`.count(substring)`** to return the number of occurences of the substring in the string\n",
    "- **`.startswith(substring)`** to determine if the string starts with the substring\n",
    "- **`.endswith(substring)`** to determine if the string ends with the substring\n",
    "- **`.replace(old, new)`** to return a copy of the string with occurences of the \"old\" replaced by \"new\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assign a string to a variable\n",
    "a_string = 'tHis is a sTriNg'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a string'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return a capitalized version of the string\n",
    "a_string.capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'THIS IS A STRING'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return an uppercase version of the string\n",
    "a_string.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is a string'"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return a lowercase version of the string\n",
    "a_string.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tHis is a sTriNg'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Notice that the methods called have not actually modified the string\n",
    "a_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Count number of occurences of a substring in the string\n",
    "a_string.count('i')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Count number of occurences of a substring in the string after a certain position\n",
    "a_string.count('i', 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Count number of occurences of a substring in the string\n",
    "a_string.count('is')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Does the string start with 'this'?\n",
    "a_string.startswith('this')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Does the lowercase string start with 'this'?\n",
    "a_string.lower().startswith('this')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Does the string end with 'Ng'?\n",
    "a_string.endswith('Ng')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tHXYZ XYZ a sTriNg'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return a version of the string with a substring replaced with something else\n",
    "a_string.replace('is', 'XYZ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tH!s !s a sTr!Ng'"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return a version of the string with a substring replaced with something else\n",
    "a_string.replace('i', '!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tH!s !s a sTriNg'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return a version of the string with the first 2 occurences a substring replaced with something else\n",
    "a_string.replace('i', '!', 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Some methods on list objects\n",
    "\n",
    "- **`.append(item)`** to add a single item to the list\n",
    "- **`.extend([item1, item2, ...])`** to add multiple items to the list\n",
    "- **`.remove(item)`** to remove a single item from the list\n",
    "- **`.pop()`** to remove and return the item at the end of the list\n",
    "- **`.pop(index)`** to remove and return an item at an index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some methods on set objects\n",
    "\n",
    "- **`.add(item)`** to add a single item to the set\n",
    "- **`.update([item1, item2, ...])`** to add multiple items to the set\n",
    "- **`.update(set2, set3, ...)`** to add items from all provided sets to the set\n",
    "- **`.remove(item)`** to remove a single item from the set\n",
    "- **`.pop()`** to remove and return a random item from the set\n",
    "- **`.difference(set2)`** to return items in the set that are not in another set\n",
    "- **`.intersection(set2)`** to return items in both sets\n",
    "- **`.union(set2)`** to return items that are in either set\n",
    "- **`.symmetric_difference(set2)`** to return items that are only in one set (not both)\n",
    "- **`.issuperset(set2)`** does the set contain everything in the other set?\n",
    "- **`.issubset(set2)`** is the set contained in the other set?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some methods on dict objects\n",
    "\n",
    "- **`.update([(key1, val1), (key2, val2), ...])`** to add multiple key-value pairs to the dict\n",
    "- **`.update(dict2)`** to add all keys and values from another dict to the dict\n",
    "- **`.pop(key)`** to remove key and return its value from the dict (error if key not found)\n",
    "- **`.pop(key, default_val)`** to remove key and return its value from the dict (or return default_val if key not found)\n",
    "- **`.get(key)`** to return the value at a specified key in the dict (or None if key not found)\n",
    "- **`.get(key, default_val)`** to return the value at a specified key in the dict (or default_val if key not found)\n",
    "- **`.keys()`** to return a list of keys in the dict\n",
    "- **`.values()`** to return a list of values in the dict\n",
    "- **`.items()`** to return a list of key-value pairs (tuples) in the dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Formatting strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Option #1: str.format()\n",
    "\n",
    "With str.format(), the replacement fields are marked by curly braces:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, Eric. You are 74.'"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = \"Eric\"\n",
    "age = 74\n",
    "'Hello, {}. You are {}.'.format(name, age)\n",
    "# the placeholder can be indexed\n",
    "'Hello, {1}. You are {0}.'.format(age, name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, Eric. You are 74.'"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "person = {'name': 'Eric', 'age': 74}\n",
    "# the place holder can be named\n",
    "'Hello, {name}. You are {age}.'.format(name=person['name'], age=person['age'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Option #2: f-Strings\n",
    "\n",
    "Also called \"formatted string literals\", **f**-strings are string literals that have an **f** at the beginning and curly braces containing expressions that will be replaced with their values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, Eric. You are 74.'"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = \"Eric\"\n",
    "age = 74\n",
    "f\"Hello, {name}. You are {age}.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f\"{2 * 37}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating objects from arguments or other objects\n",
    "\n",
    "The basic types and containers we have used so far all provide **type constructors**:\n",
    "\n",
    "- `int()`\n",
    "- `float()`\n",
    "- `str()`\n",
    "- `list()`\n",
    "- `tuple()`\n",
    "- `set()`\n",
    "- `dict()`\n",
    "\n",
    "Up to this point, we have been defining objects of these built-in types using some syntactic shortcuts, since they are so common.\n",
    "\n",
    "Sometimes, you will have an object of one type that you need to convert to another type. Use the **type constructor** for the type of object you want to have, and pass in the object you currently have."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [Conditionals](https://docs.python.org/3/reference/compound_stmts.html#the-if-statement)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing truth value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `bool`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type of True and False: <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print('type of True and False: {}'.format(type(True)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: False, 1: True\n",
      "empty list: False, list with values: True\n",
      "empty dict: False, dict with values: True\n"
     ]
    }
   ],
   "source": [
    "print('0: {}, 1: {}'.format(bool(0), bool(1)))\n",
    "print('empty list: {}, list with values: {}'.format(bool([]), bool(['woop'])))\n",
    "print('empty dict: {}, dict with values: {}'.format(bool({}), bool({'Python': 'cool'})))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `==, !=, >, <, >=, <=`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 == 0: False\n",
      "1 != 0: True\n",
      "1 > 0: True\n",
      "1 > 1: False\n",
      "1 < 0: False\n",
      "1 < 1: False\n",
      "1 >= 0: True\n",
      "1 >= 1: True\n",
      "1 <= 0: False\n",
      "1 <= 1: True\n"
     ]
    }
   ],
   "source": [
    "print('1 == 0: {}'.format(1 == 0))\n",
    "print('1 != 0: {}'.format(1 != 0))\n",
    "print('1 > 0: {}'.format(1 > 0))\n",
    "print('1 > 1: {}'.format(1 > 1))\n",
    "print('1 < 0: {}'.format(1 < 0))\n",
    "print('1 < 1: {}'.format(1 < 1))\n",
    "print('1 >= 0: {}'.format(1 >= 0))\n",
    "print('1 >= 1: {}'.format(1 >= 1))\n",
    "print('1 <= 0: {}'.format(1 <= 0))\n",
    "print('1 <= 1: {}'.format(1 <= 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can combine these:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 <= 2 <= 3: True\n"
     ]
    }
   ],
   "source": [
    "print('1 <= 2 <= 3: {}'.format(1 <= 2 <= 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `and, or, not`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "python_is_cool = True\n",
    "java_is_cool = False\n",
    "empty_list = []\n",
    "secret_value = 3.14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Python and java are both cool: {}'.format(python_is_cool and java_is_cool))\n",
    "print('secret_value and python_is_cool: {}'.format(secret_value and python_is_cool))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python or java is cool: True\n",
      "1 >= 1.1 or 2 < float(\"1.4\"): False\n"
     ]
    }
   ],
   "source": [
    "print('Python or java is cool: {}'.format(python_is_cool or java_is_cool))\n",
    "print('1 >= 1.1 or 2 < float(\"1.4\"): {}'.format(1 >= 1.1 or 2 < float('1.4')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Java is not cool: {}'.format(not java_is_cool))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can combine multiple statements, execution order is from left to right. You can control the execution order by using brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(bool(not java_is_cool or secret_value and  python_is_cool or empty_list))\n",
    "print(bool(not (java_is_cool or secret_value and  python_is_cool or empty_list)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `if`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "statement is True\n"
     ]
    }
   ],
   "source": [
    "statement = True\n",
    "if statement:\n",
    "    print('statement is True')\n",
    "    \n",
    "if not statement:\n",
    "    print('statement is not True')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_list = []\n",
    "# With if and elif, conversion to `bool` is implicit\n",
    "if empty_list:\n",
    "    print('empty list will not evaluate to True')  # this won't be executed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value is positive and less than one or value is three\n"
     ]
    }
   ],
   "source": [
    "val = 3\n",
    "if 0 <= val < 1 or val == 3:\n",
    "    print('Value is positive and less than one or value is three')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `if-else`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict = {}\n",
    "if my_dict:\n",
    "    print('there is something in my dict')\n",
    "else:\n",
    "    print('my dict is empty :(')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `if-elif-else`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val = 88\n",
    "if val >= 100:\n",
    "    print('value is equal or greater than 100')\n",
    "elif val > 10:\n",
    "    print('value is greater than 10 but less than 100')\n",
    "else:\n",
    "    print('value is equal or less than 10')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can have as many `elif` statements as you need. In addition, `else` at the end is not mandatory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting = 'Hello fellow Pythonista!'\n",
    "language = 'Italian'\n",
    "\n",
    "if language == 'Swedish':\n",
    "    greeting = 'Hejsan!'\n",
    "elif language == 'Finnish':\n",
    "    greeting = 'Latua perkele!'\n",
    "elif language == 'Spanish':\n",
    "    greeting = 'Hola!'\n",
    "elif language == 'German':\n",
    "    greeting = 'Guten Tag!'\n",
    "    \n",
    "print(greeting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [`for` loops](https://docs.python.org/3/tutorial/controlflow.html#for-statements)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Looping lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "Python\n",
      "is\n",
      "neat\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 'Python', 'is', 'neat']\n",
    "for item in my_list:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `break`\n",
    "Stop the execution of the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for item in my_list:\n",
    "    if item == 'Python':\n",
    "        break\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `continue`\n",
    "Continue to the next item without executing the lines occuring after `continue` inside the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "Python\n",
      "is\n",
      "neat\n"
     ]
    }
   ],
   "source": [
    "for item in my_list:\n",
    "    if item == 1:\n",
    "        continue\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `enumerate()`\n",
    "In case you need to also know the index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "idx: 0, value: 1\n",
      "idx: 1, value: 2\n",
      "idx: 2, value: 3\n",
      "idx: 3, value: 4\n",
      "idx: 4, value: Python\n",
      "idx: 5, value: is\n",
      "idx: 6, value: neat\n"
     ]
    }
   ],
   "source": [
    "for idx, val in enumerate(my_list):\n",
    "    print('idx: {}, value: {}'.format(idx, val))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Looping dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hacker\n",
      "age\n",
      "name\n"
     ]
    }
   ],
   "source": [
    "my_dict = {'hacker': True, 'age': 72, 'name': 'John Doe'}\n",
    "for val in my_dict:\n",
    "    print(val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hacker=True\n",
      "age=72\n",
      "name=John Doe\n"
     ]
    }
   ],
   "source": [
    "for key, val in my_dict.items():\n",
    "    print('{}={}'.format(key, val))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `range()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for number in range(5):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for number in range(2, 5):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for number in range(0, 10, 2):  # last one is step\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [`while` loops](https://docs.python.org/3/reference/compound_stmts.html#while)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A “while-loop” allows you to repeat a block of code until a condition is no longer true:\n",
    "```\n",
    "while <condition>:\n",
    "    block of code\n",
    "```\n",
    "Where <condition> is an expression that returns True or False, or is any object on which bool can be called. The “body” of the while-loop is the code indented beneath the while-loop statement.\n",
    "\n",
    "The while-loop behaves as follows:\n",
    "\n",
    "    Call bool(<condition>) and execute the indented block of code if True is returned. Otherwise, “exit” the while-loop, skipping past the indented code.\n",
    "    If the indented block code is executed, go back to the first step.\n",
    "\n",
    "To be concrete, let’s consider the example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "# demonstrating a basic while-loop\n",
    "total = 0\n",
    "while total < 2:\n",
    "    total += 1  # equivalent to: `total = total + 1`\n",
    "\n",
    "print(total)  # `total` has the value 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type: <function my_first_function at 0x7f2844480040>\n",
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "def my_first_function():\n",
    "    print('Hello world!')\n",
    "\n",
    "print('type: {}'.format(my_first_function))\n",
    "\n",
    "my_first_function()  # Calling a function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet_us(name1, name2):\n",
    "    print('Hello {} and {}!'.format(name1, name2))\n",
    "\n",
    "greet_us('John Doe', 'Superman')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function with return value\n",
    "def strip_and_lowercase(original):\n",
    "    modified = original.strip().lower()\n",
    "    return modified\n",
    "\n",
    "uggly_string = '  MixED CaSe '\n",
    "pretty = strip_and_lowercase(uggly_string)\n",
    "print('pretty: {}'.format(pretty))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keyword arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_fancy_calculation(first, second, third):\n",
    "    return first + second - third \n",
    "\n",
    "print(my_fancy_calculation(3, 2, 1))\n",
    "\n",
    "print(my_fancy_calculation(first=3, second=2, third=1))\n",
    "\n",
    "# With keyword arguments you can mix the order\n",
    "print(my_fancy_calculation(third=1, first=3, second=2))\n",
    "\n",
    "# You can mix arguments and keyword arguments but you have to start with arguments\n",
    "print(my_fancy_calculation(3, third=1, second=2))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Default arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def create_person_info(name, age, job=None, salary=300):\n",
    "    info = {'name': name, 'age': age, 'salary': salary}\n",
    "    \n",
    "    # Add 'job' key only if it's provided as parameter\n",
    "    if job:  \n",
    "        info.update(dict(job=job))\n",
    "        \n",
    "    return info\n",
    "\n",
    "person1 = create_person_info('John Doe', 82)  # use default values for job and salary\n",
    "person2 = create_person_info('Lisa Doe', 22, 'hacker', 10000)\n",
    "print(person1)\n",
    "print(person2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Don't use mutable objects as default arguments!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def append_if_multiple_of_five(number, magical_list=[]):\n",
    "    if number % 5 == 0:\n",
    "        magical_list.append(number)\n",
    "    return magical_list\n",
    "\n",
    "print(append_if_multiple_of_five(100))\n",
    "print(append_if_multiple_of_five(105))\n",
    "print(append_if_multiple_of_five(123))\n",
    "print(append_if_multiple_of_five(123, []))\n",
    "print(append_if_multiple_of_five(123))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's how you can achieve desired behavior:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def append_if_multiple_of_five(number, magical_list=None):\n",
    "    if not magical_list:\n",
    "        magical_list = []\n",
    "    if number % 5 == 0:\n",
    "        magical_list.append(number)\n",
    "    return magical_list\n",
    "\n",
    "print(append_if_multiple_of_five(100))\n",
    "print(append_if_multiple_of_five(105))\n",
    "print(append_if_multiple_of_five(123))\n",
    "print(append_if_multiple_of_five(123, []))\n",
    "print(append_if_multiple_of_five(123))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Docstrings\n",
    "Strings for documenting your functions, methods, modules and variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_sum(val1, val2):\n",
    "    \"\"\"Function which prints the sum of given arguments.\"\"\"\n",
    "    print('sum: {}'.format(val1 + val2))\n",
    "\n",
    "print(help(print_sum))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_sum(val1, val2):\n",
    "    \"\"\"This is a longer docstring defining also the args and the return value. \n",
    "\n",
    "    Args:\n",
    "        val1: The first parameter.\n",
    "        val2: The second parameter.\n",
    "\n",
    "    Returns:\n",
    "        The sum of val1 and val2.\n",
    "        \n",
    "    \"\"\"\n",
    "    return val1 + val2\n",
    "\n",
    "print(help(calculate_sum))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`pass`](https://docs.python.org/3/reference/simple_stmts.html#the-pass-statement) statement\n",
    "`pass` is a statement which does nothing when it's executed. It can be used e.g. a as placeholder to make the code syntatically correct while sketching the functions and/or classes of your application. For example, the following is valid Python. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function(some_argument):\n",
    "    pass\n",
    "\n",
    "def my_other_function():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [File I/O](https://docs.python.org/3/tutorial/inputoutput.html#reading-and-writing-files)\n",
    "Reading and writing files."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current file: /home/catarina/git/python101/file_io.ipynb\n",
      "current directory: /home/catarina/git/python101\n",
      "data directory: /home/catarina/git/python101/data\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "current_file = os.path.realpath('file_io.ipynb')  \n",
    "print('current file: {}'.format(current_file))\n",
    "# Note: in .py files you can get the path of current file by __file__\n",
    "\n",
    "current_dir = os.path.dirname(current_file)  \n",
    "print('current directory: {}'.format(current_dir))\n",
    "# Note: in .py files you can get the dir of current file by os.path.dirname(__file__)\n",
    "\n",
    "data_dir = os.path.join(current_dir, 'data')\n",
    "print('data directory: {}'.format(data_dir))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking if path exists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exists: True\n",
      "is file: False\n",
      "is directory: True\n"
     ]
    }
   ],
   "source": [
    "print('exists: {}'.format(os.path.exists(data_dir)))\n",
    "print('is file: {}'.format(os.path.isfile(data_dir)))\n",
    "print('is directory: {}'.format(os.path.isdir(data_dir)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First line\n",
      "Second line\n",
      "Third\n",
      "And so the story goes!\n"
     ]
    }
   ],
   "source": [
    "file_path = os.path.join(data_dir, 'simple_file.txt')\n",
    "\n",
    "with open(file_path, 'r') as simple_file:\n",
    "    for line in simple_file:\n",
    "        print(line.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The [`with`](https://docs.python.org/3/reference/compound_stmts.html#the-with-statement) statement is for obtaining a [context manager](https://docs.python.org/3/reference/datamodel.html#with-statement-context-managers) that will be used as an execution context for the commands inside the `with`. Context managers guarantee that certain operations are done when exiting the context. \n",
    "\n",
    "In this case, the context manager guarantees that `simple_file.close()` is implicitly called when exiting the context. This is a way to make developers life easier: you don't have to remember to explicitly close the file you openened nor be worried about an exception occuring while the file is open. Unclosed file maybe a source of a resource leak. Thus, prefer using `with open()` structure always with file I/O.\n",
    "\n",
    "To have an example, the same as above without the `with`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First line\n",
      "Second line\n",
      "Third\n",
      "And so the story goes!\n"
     ]
    }
   ],
   "source": [
    "file_path = os.path.join(data_dir, 'simple_file.txt')\n",
    "\n",
    "# THIS IS NOT THE PREFERRED WAY\n",
    "simple_file = open(file_path, 'r')\n",
    "for line in simple_file:\n",
    "    print(line.strip())\n",
    "simple_file.close()  # This has to be called explicitly "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Writing files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_file_path = os.path.join(data_dir, 'new_file.txt')\n",
    "\n",
    "with open(new_file_path, 'w') as my_file:\n",
    "    my_file.write('This is my first file that I wrote with Python.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now go and check that there is a new_file.txt in the data directory. After that you can delete the file by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if os.path.exists(new_file_path):  # make sure it's there\n",
    "    os.remove(new_file_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [Modules and packages](https://docs.python.org/3/tutorial/modules.html#modules)\n",
    "\n",
    "> Module is a Python source code file, i.e. a file with .py extension.\n",
    "\n",
    "> Package is a directory which contains `__init__.py` file and can contain python modules and other packages.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why to organize your code into modules and packages\n",
    "* Maintainability\n",
    "* Reusability\n",
    "* Namespacing\n",
    "* People unfamiliar with your project can get a clear overview just by looking at the directory structure of your project\n",
    "* Searching for certain functionality or class is easy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to use\n",
    "\n",
    "Let's use the following directory structure as an example:\n",
    "\n",
    "      \n",
    "```\n",
    "food_store/\n",
    "    __init__.py\n",
    "    \n",
    "    product/\n",
    "        __init__.py\n",
    "        \n",
    "        fruit/\n",
    "            __init__.py\n",
    "            apple.py\n",
    "            banana.py\n",
    "            \n",
    "        drink/\n",
    "            __init__.py\n",
    "            juice.py\n",
    "            milk.py\n",
    "            beer.py\n",
    "\n",
    "    cashier/\n",
    "        __ini__.py\n",
    "        receipt.py\n",
    "        calculator.py\n",
    "```\n",
    "\n",
    "\n",
    "Let's consider that banana.py file contains:\n",
    "\n",
    "```python\n",
    "\n",
    "def get_available_brands():\n",
    "    return ['chiquita']\n",
    "\n",
    "\n",
    "class Banana:\n",
    "    def __init__(self, brand='chiquita'):\n",
    "        if brand not in get_available_brands():\n",
    "            raise ValueError('Unkown brand: {}'.format(brand))\n",
    "        self._brand = brand\n",
    "     \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing\n",
    "\n",
    "Let's say that we need access `Banana` class from banana.py file inside receipt.py. We can achive this by importing at the beginning of receipt.py:\n",
    "\n",
    "```python\n",
    "from food_store.product.fruit.banana import Banana\n",
    "\n",
    "# then it's used like this\n",
    "my_banana = Banana()\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "If we need to access multiple classes or functions from banana.py file:\n",
    "\n",
    "```python\n",
    "from food_store.product.fruit import banana\n",
    "\n",
    "# then it's used like this\n",
    "brands = banana.get_available_brands()\n",
    "my_banana = banana.Banana()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}