notebooks/1_Variables_supplemental.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "X8NI2UYxmAxm"
   },
   "source": [
    "# Python basics: Variables (supplemental)\n",
    "\n",
    "This notebook contains some additional materials for the topics of notebook 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Built-in data types\n",
    "\n",
    "Python natively supports the following basic types:\n",
    "\n",
    "- **Boolean**: *bool*\n",
    "\n",
    "- **None**: *NoneType*\n",
    "\n",
    "- **Numerical**: *int*, *float*, *long*, *complex*\n",
    "\n",
    "- **Sequence**: *string*, *list*, *tuple*\n",
    "\n",
    "- **Set**: *set*, *frozenset*\n",
    "\n",
    "- **Dictionaries**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HkkC6WNsmAx7",
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "#### Mutable vs. Immutable objects\n",
    "\n",
    "Python data types can be organized by distinguishing those types whose objects can change after their creation (**Mutable**) and those that do not admit such possibility (**Immutable**). If a variable is of a mutable datatype, you can _overwrite_ its value, instead of creating a new object. Assigning a new value to an existing variable is always possible. \n",
    "\n",
    "| Immutables|   Mutables|\n",
    "|:---------:|:---------:|\n",
    "|  Numerical|          -|\n",
    "|     String|          -|\n",
    "|      Tuple|       List|\n",
    "|  Frozenset|        Set|\n",
    "|          -| Dictionary|\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "j7SHu6NNmAx9",
    "tags": []
   },
   "source": [
    "#### Using Python as a Calculator\n",
    "\n",
    "We showed division, but there are a few aspects of division that have different operators:\n",
    "\n",
    "Especially the remainder (modulo) operator is more useful than you think, for example, if you want to print every 10th line of a text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8BATUPmTmAx-"
   },
   "outputs": [],
   "source": [
    "# quotient\n",
    "9 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vxUBiLgvmAx_",
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Floor division\n",
    "9 // 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "k1FBwTUrmAyA"
   },
   "outputs": [],
   "source": [
    "# The remainder of the floored quotient\n",
    "9 % 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lrfvNMITmAyA"
   },
   "source": [
    "You can combine the floor division and the remainder by using the built-in function `divmod()` ([manual](https://docs.python.org/3.8/library/functions.html#divmod))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1OEsdXnSmAyA"
   },
   "outputs": [],
   "source": [
    "divmod(9,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tO9O0Xa4mAyB"
   },
   "outputs": [],
   "source": [
    "# x to the power of y\n",
    "3 ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Wd9KcfeamAyB"
   },
   "source": [
    "Alternatively, use the built-in function `pow()` ([manual](https://docs.python.org/3.8/library/functions.html#pow))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9zMIXug6mAyC"
   },
   "outputs": [],
   "source": [
    "pow(3, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "HHYV_MUomAyC"
   },
   "outputs": [],
   "source": [
    "# Round a number to a given precision in decimal digits (default 0 digits)\n",
    "round(1.765432, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OdGDe0KbmAyE"
   },
   "source": [
    "## Changing variables\n",
    "There is also a modulo operator for this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cMPYHxWlmAyE"
   },
   "outputs": [],
   "source": [
    "# Our variable\n",
    "magic_number = 8\n",
    "magic_number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qGhhbpoTmAyG"
   },
   "outputs": [],
   "source": [
    "# In place modulus\n",
    "magic_number %= 3\n",
    "magic_number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bbse84_WmAyJ"
   },
   "source": [
    "## Iterables / sequences\n",
    "\n",
    "Here we have some additional information on **tuples** and **sets** (see the [documentation](https://docs.python.org/3.8/library/stdtypes.html#sequence-types-list-tuple-range) for the full list). \n",
    "\n",
    "Most sequence types support the following operations (where `s` and `t` are sequences, `n`, `i` and `j` integers):\n",
    "\n",
    "|   Operation|                Result|\n",
    "|:----------:|:-----------------------:|\n",
    "|      x in s|  True if an item of s is equal to x|\n",
    "|  x not in s|  False if an item of s is equal to x|\n",
    "|       s + t| Concatenation of s and t|\n",
    "|       s * n|   add s to itself n times (negative n are treated as 0)|\n",
    "|        s\\[i\\]|\tith item of s, origin 0|\n",
    "|      s\\[i:j\\]|   slice of s from i to j|\n",
    "|    s\\[i:j:k\\]| slice of s from i to j with step k|\n",
    "|      len(s)| length of s|\t \n",
    "|      min(s)| smallest item of s|\n",
    "|      max(s)| largest item of s|\n",
    "|  s.index(x)| index of the first occurrence of x in s |\n",
    "|  s.count(x)| total number of occurrences of x in s|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RgAWy8FemAyc"
   },
   "source": [
    "### Tuples\n",
    "\n",
    "Tuples are the **immutable** counterpart of the lists. \n",
    "\n",
    "They are defined by round brackets `()` and they mainly differ from the list in that they do not accept those methods that tries to manipulate its elements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cWZ2BjyWmAyc"
   },
   "outputs": [],
   "source": [
    "# Tuples can contain different types of objects (even another list like [1,2,3])\n",
    "\n",
    "demo_tuple = (\"text\", 23, 92, \"another_text\", [1,2,3])\n",
    "\n",
    "print(demo_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7mc_49sSmAyd"
   },
   "outputs": [],
   "source": [
    "# Elements can be accessed on the basis of their index...\n",
    "\n",
    "demo_tuple[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RezsQC2vmAyd"
   },
   "outputs": [],
   "source": [
    "# But, they cannot be replaced. This raises a TypeError error!\n",
    "\n",
    "demo_tuple[1] = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TqeRPC2hmAyd"
   },
   "source": [
    "For now, just know that tuples are a datatype in Python. You'll know when you need them further on in this course!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hG0TQMzOmAyr"
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JZs8oKTMmAys"
   },
   "source": [
    "### Sets\n",
    "\n",
    "Sets are collections of **unordered** and **distinct/unique** objects.\n",
    "\n",
    "They are commonly used to test membership, to remove duplicates or to compute mathematical operations such as intersection, union, difference, and symmetric difference. Being unordered collections, they do not support indexing, slicing and any other sequence-like behavior. But, this  makes them extremely efficient.\n",
    "\n",
    "In Python, sets can be create beither by using the syntax  `set([])` or by using curly braces `{}`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "95RR_DssmAys"
   },
   "source": [
    "Sets come in handy if you want to count the unique occurences in a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6YtsxauLmAys"
   },
   "outputs": [],
   "source": [
    "text = \"\"\"the quick brown fox jumps over the lazy dog\"\"\"\n",
    "words = text.split()  # 'the' is in there twice\n",
    "print(words)\n",
    "\n",
    "unique_words = set(words)\n",
    "unique_words"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Y6k8yc-TmAys"
   },
   "source": [
    "You can add elements by calling `.add()` on the set. Please note: the `.append()` is for lists only! Trying to add an element that's already in a set does not change anything."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "T8vP7NCamAys"
   },
   "outputs": [],
   "source": [
    "# Elements are added with the function add()\n",
    "unique_words.add(\"sheep\")\n",
    "unique_words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Vjsiqc03mAys"
   },
   "outputs": [],
   "source": [
    "# elements are removed with the function remove()\n",
    "unique_words.remove(\"fox\")\n",
    "unique_words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "eBy0YgnSmAyt"
   },
   "outputs": [],
   "source": [
    "# length of a set\n",
    "len(unique_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "2fRbYGu8mAyt"
   },
   "outputs": [],
   "source": [
    "# membership test\n",
    "\"sheep\" in unique_words"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "w0DYyLEdmAyt"
   },
   "source": [
    "You can use `.union()` to get all the elements from both sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Ii8aw5WPmAyt"
   },
   "outputs": [],
   "source": [
    "# the union of the two sets\n",
    "all_words = unique_words.union(set([\"pack\", \"my\", \"box\", \"with\", \"five\", \"dozen\", \"liquor\", \"jugs\"]))\n",
    "all_words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xbLPSXQjmAyt"
   },
   "outputs": [],
   "source": [
    "# Intersection of the two sets\n",
    "other_set = {\"brown\", \"dog\", \"purple\", \"fox\"}\n",
    "\n",
    "intersection = unique_words.intersection(other_set)\n",
    "intersection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kLniT592mAyt"
   },
   "outputs": [],
   "source": [
    "# Elements that are in the first but not in the second set\n",
    "unique_words.difference(other_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WmmZOVVrmAyt"
   },
   "outputs": [],
   "source": [
    "# Variables flipped\n",
    "other_set.difference(unique_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9jLMMSl2mAyu"
   },
   "outputs": [],
   "source": [
    "# Every elements of smaller_set are in all_elements?\n",
    "\n",
    "all_elements = {1, 2, 3, 4, 5, 6, 7, 8, 9}\n",
    "smaller_set = {2, 4, 6, 8}\n",
    "\n",
    "print(all_elements.issuperset(smaller_set))\n",
    "print(smaller_set.issubset(all_elements))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "t-h6XDdXmAyu"
   },
   "source": [
    "Go over the other methods that can be used on a set. You can find them including examples here: https://www.w3schools.com/python/python_ref_set.asp. For sure, check out the `.update()` and `.isdisjoint()`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-eGcr4ERmAyu"
   },
   "source": [
    "---"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "1_Basics.ipynb",
   "provenance": []
  },
  "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}