02-simple-data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8z5cONg8rUrX",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Variables, expressions and statements\n",
    "\n",
    "## Programming Fundamentals (NB02)\n",
    "\n",
    "### MIEIC/2020-21\n",
    "\n",
    "#### João Correia Lopes\n",
    "\n",
    "FEUP/DEI and INESC TEC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MZzE7pYorju5",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Goals\n",
    "\n",
    "\n",
    "By the end of this class, the student should be able to:\n",
    "\n",
    "- Describe and distinguish the concepts of variable, location, value, type\n",
    "\n",
    "- Identify the Python reserved words\n",
    "\n",
    "- Describe the concepts of statement and expression\n",
    "\n",
    "- Identify some of the Python operands and their precedence\n",
    "\n",
    "- Use operators with suitable operands\n",
    "\n",
    "- Describe the Python type conversion operations and use them\n",
    "\n",
    "- Describe how to get input, at runtime, from an user of the program"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "eR5Lh1jNroE2",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Bibliography\n",
    "\n",
    "\n",
    "* Peter Wentworth, Jeffrey Elkner, Allen B. Downey, and Chris Meyers, *How to Think Like a Computer Scientist — Learning with Python 3* (Chapter 2)\n",
    "[[PDF](https://media.readthedocs.org/pdf/howtothink/latest/howtothink.pdf)] \n",
    "[[HTML](http://openbookproject.net/thinkcs/python/english3e/)]\n",
    "\n",
    "* Brad Miller and David Ranum, *How to Think Like a Computer Scientist: Interactive Edition*. (Chapter 2)\n",
    "    [[HTML](https://runestone.academy/runestone/books/published/thinkcspy/SimplePythonData/toctree.html)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Z8WW57Uj8bJg",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "If you like videos, see the Runestone Interactive vídeo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XKa-IV0363yA",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('vNfCfowr-pQ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "pPfDMznP1B1k",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Simple Python Data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sWBpWyCZ1GY-",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python\n",
    "\n",
    "You may download a Python program from GitHug and play with it using the IDE Spyder.\n",
    "\n",
    "$\\Rightarrow$ \n",
    "https://github.com/fpro-feup/public/blob/master/lectures/01/basics.py\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JNGjfMPrXw2J",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#!/usr/bin/env python3\n",
    "\n",
    "import datetime\n",
    "now = datetime.datetime.now()\n",
    "\n",
    "# 1\n",
    "print()\n",
    "print(\"Current date and time using str method of datetime object:\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pO2vDxBY8Fvk",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# 2 \n",
    "print()\n",
    "print(str(now))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "D1OUslox8JKU",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# 3\n",
    "print()\n",
    "print(\"Current date and time using instance attributes:\")\n",
    "print()\n",
    "print(\"Current year: %d\" % now.year)\n",
    "print(\"Current month: %d\" % now.month)\n",
    "print(\"Current day: %d\" % now.day)\n",
    "print(\"Current hour: %d\" % now.hour)\n",
    "print(\"Current minute: %d\" % now.minute)\n",
    "print(\"Current second: %d\" % now.second)\n",
    "print(\"Current microsecond: %d\" % now.microsecond)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "oTsclRTe8OMT",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# 4\n",
    "print()\n",
    "print(\"Current date and time using strftime:\")\n",
    "print(now.strftime(\"%Y-%m-%d %H:%M\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MagKTtyv1QlU",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 2.1 Values and data types\n",
    "\n",
    "\n",
    "- A **value** is one of the fundamental things that a program\n",
    "    manipulates (like `5` ou `\"Hello world!\"`)\n",
    "\n",
    "- The values are refered to as **objects** in Python\n",
    "\n",
    "- Values are classified into different classes, or **data types** (`5` is an integer and `\"Hello world!\"` is a string)\n",
    "\n",
    "- **type()** is a function that tell us the type of a value\n",
    "\n",
    "\n",
    "Try running the following code and think about the results you get:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hobcz42boLn6",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(type(\"Hello, World!\"))\n",
    "print(type(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4ggrLK_WpR15",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(type(\"3.2\"))\n",
    "print(type(3.2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "me-eKXqK89nX",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(\"Hello, World\")\n",
    "type('Hello, World!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Twkb-b6BqBZk",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(42000)\n",
    "print(42,000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KPbwopsmp0pm",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(42, 17, 56, 34, 11, 4.35, 32)\n",
    "print(3.4, \"hello\", 45)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ez_5o9ir2oDq",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 2.2 Variables\n",
    "\n",
    "\n",
    "- A variable is a **name** that refers to a **value**\n",
    "\n",
    "- The **assignment statement** gives a value to a variable\n",
    "\n",
    "- The assignment statement binds a *name*, on the left-hand side of\n",
    "    the operator, to a *value*, on the right-hand side\n",
    "\n",
    "- Later, one can assign a different value to the same variable (this\n",
    "    is different from maths!)\n",
    "\n",
    "- The assignment token, `=`, should not be confused with the equals\n",
    "    token, `==`\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1lGCHgs18eab",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Runestone Interactive vídeo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "R3khzUvP7Mat",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('1uQM-TVlaMo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Cwe-RAYoZEwa",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Assignment\n",
    "\n",
    "Assignment statements create new variables and also give them values to refer to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "sEgRXRafZJPZ",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "message = \"What's up, Doc?\"\n",
    "n = 17\n",
    "pi = 3.14159\n",
    "\n",
    "message = \"For something completely different.\"\n",
    "\n",
    "print(message)\n",
    "print(n)\n",
    "print(pi)\n",
    "\n",
    "print(type(message))\n",
    "print(type(n))\n",
    "print(type(pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GF1tOcZFZKmM",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Copy the previous code and Visualise a **state snapshot** in Python Tutor\n",
    "\n",
    "$\\Rightarrow$ \n",
    "[pytontutor](http://www.pythontutor.com/visualize.html#mode=edit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jrr9ZZgwEr04",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Equality\n",
    "\n",
    "- It is important to note that in mathematics, a statement of equality is always true. \n",
    "  * If a is equal to b now, then a will always equal to b.\n",
    "  \n",
    "- In Python, an assignment statement can make two variables refer to the same object and therefore have the same value. \n",
    "\n",
    "- They appear to be equal. \n",
    "\n",
    "- However, because of the possibility of reassignment, they don’t have to stay that way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XDhnh5mYFCFE",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "a = 5\n",
    "b = a      # after executing this line, a and b are now equal\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = 3      # after executing this line, a and b are no longer equal\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = a + 1  # update with a new value \n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "F8ry2fjOFMu0",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Copy the previous code and Visualise a **state snapshot**\n",
    "\n",
    "$\\Rightarrow$ \n",
    "[pytontutor](http://www.pythontutor.com/visualize.html#mode=edit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lEU7DVfQ3Dcr",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 2.3 Variable names and keywords\n",
    "\n",
    "\n",
    "### Variable names\n",
    "\n",
    "- **Variable names** can be arbitrarily long\n",
    "\n",
    "- They can contain both letters and digits, but they have to begin\n",
    "    with a letter or an underscore\n",
    "\n",
    "- It is legal to use uppercase letters, but it is not done (by\n",
    "    convention)\n",
    "\n",
    "- Names should be \"meaningful to the human readers\" (not to be\n",
    "    confused with \"meaningful to the computer\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ndal8aHn3Lej",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Keywords\n",
    "\n",
    "- Keywords define the language's syntax rules and structure\n",
    "\n",
    "- They cannot be used as variable names\n",
    "\n",
    "|  |  |  |  |  |  |\n",
    "|:--------|:------|:-------|:---------|:-------|:---------|\n",
    "| and     | as    | assert | break    | class  | continue |\n",
    "| def     | del   | elif   | else     | except | exec     |\n",
    "| finally | for   | from   | global   | if     | import   |\n",
    "| in      | is    | lambda | nonlocal | not    | or       |\n",
    "| pass    | raise | return | try      | while  | with     |\n",
    "| yield   | True  | False  | None     |        |          |\n",
    "          "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YBNnVF7EaZKu",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "True = \"True\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nSKeZN4OakEZ",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "true = False\n",
    "print(true)\n",
    "print(type(true))\n",
    "\n",
    "true = \"False\"\n",
    "print(true)\n",
    "print(type(true))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GzAzTYG63qTF",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 2.4 Statements\n",
    "\n",
    "\n",
    "- A **statement** is an instruction that the Python interpreter can\n",
    "    execute\n",
    "\n",
    "- Statements don't produce any result\n",
    "\n",
    "- Further to the assignment statement, there are others (`while`\n",
    "    statements, `for` statements, `if` statements, `import` statements)\n",
    "\n",
    "- (There are other kinds too!)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VZ0_aBxk8hcG",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Runestone Interactive vídeo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "441hI6mi7xEH",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('3WgmLIsXFkI')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1vWbvpEA3yxE",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 2.5 Evaluating expressions\n",
    "\n",
    "\n",
    "- An **expression** is a combination of values, variables, operators,\n",
    "    and calls to functions\n",
    "\n",
    "- The Python interpreter evaluates expressions and displays its result\n",
    "    (a value)\n",
    "\n",
    "- A value all by itself is a simple expression, and so is a variable\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aXxPbVzSbQ6z",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(1 + 1)\n",
    "print(len(\"hello\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "domY3_rBbYMB",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "y = 3.14\n",
    "x = len(\"hello\")\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bsWZDXm_bliu",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "You may use Spyder3 to see the differences between statements and expression in the Python shell."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "CjmNjO7K38mG",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 2.6 Operators and operands\n",
    "\n",
    "\n",
    "- **Operators** are special tokens that represent computations like\n",
    "    addition, multiplication and division\n",
    "\n",
    "- The values the operator uses are called **operands**\n",
    "\n",
    "- Operations in Python (`+`, `-`, `/`) mean what they mean in\n",
    "    mathematics\n",
    "\n",
    "- Asterisk ( `*` ) is the token for multiplication, and `**` is the\n",
    "    token for exponentiation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "eH_9OmPC6NiF",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(2 + 3)\n",
    "print(2 - 3)\n",
    "print(2 * 3)\n",
    "print(2 ** 3)\n",
    "print(3 ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UYucGUm16iYs",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    " When a variable name appears in the place of an operand, it is\n",
    "    replaced with its value before the operation is performed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QcZxxJN46pXo",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "minutes = 645\n",
    "hours = minutes / 60\n",
    "print(hours)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3xse6J8l4E5J",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 2.7 Type conversion functions\n",
    "\n",
    "\n",
    "- Type conversion functions `int()`, `float()` and `str()`\n",
    "\n",
    "- will (attempt to) convert their arguments into types `int`, `float`\n",
    "    and `str` respectively\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "R-Rx9_4kYKcT",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(3.14, int(3.14))\n",
    "print(3.9999, int(3.9999))        # This doesn't round to the closest int!\n",
    "print(3.0, int(3.0))\n",
    "print(-3.999, int(-3.999))        # Note that the result is closer to zero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(\"2345\", int(\"2345\"))        # parse a string to produce an int\n",
    "print(17, int(17))                # int even works on integers\n",
    "print(int(\"23bottles\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "M6IJ_posYYm3",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The type converter `float` can turn an integer, a float, or a syntactically legal string into a float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "o5JyTBPxYXwZ",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(float(\"123.45\"))\n",
    "print(type(float(\"123.45\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HrRrrM3iYooN",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The type converter `str` turns its argument into a string. Remember that when we print a string, the quotes are removed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jQYahc_aYsuF",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(str(17))\n",
    "print(str(123.45))\n",
    "print(type(str(123.45)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Integer division\n",
    "\n",
    "To have an interger division one may use the operand `//`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cZRuyrE79AlC",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(7 / 4)     # division\n",
    "print(7 // 4)    # integer division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LuWB8wa16xHw",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 2.12 The modulus operator\n",
    "\n",
    "\n",
    "- The **modulus operator** works on integers (and integer expressions)\n",
    "\n",
    "  - and gives the remainder when the first number is divided by the\n",
    "    second\n",
    "\n",
    "- In Python, the modulus operator is a percent sign (`%`)\n",
    "\n",
    "- It has the same precedence as the multiplication operator\n",
    "\n",
    "\n",
    "Try with Spyder:\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/02/remainder.py>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NLkBO8bl4MtV",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 2.8 Order of operations\n",
    "\n",
    "\n",
    "- When more than one operator appears in an expression, the order of\n",
    "    evaluation depends on the **rules of precedence**\n",
    "\n",
    "- Python follows the same precedence rules for its mathematical\n",
    "    operators that mathematics does\n",
    "    * PEMDAS =  Parentheses, Exponents, Multiplication/Division, Addition/Subtraction\n",
    "\n",
    "- Operators with the same precedence are evaluated from left-to-right\n",
    "    (*left-associative*)\n",
    "\n",
    "- An exception to the left-to-right left-associative rule is the\n",
    "    exponentiation operator `**`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Rules of precedence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Ivlxb-m__hnk",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(2 * 3 - 1)\n",
    "print(2 * (3-1))   #  force the evaluation order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "mUCLiQlV_QUP",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(2 ** 3 ** 2)     # the right-most ** operator gets done first!\n",
    "print((2 ** 3) ** 2)   # use parentheses to force the order you want!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GsBWNeF59idt",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Runestone Interactive video:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1vf3s1Wj9kMU",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('Ezve3QJv6Aw')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4S79Tply4SCl",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 2.9 Operations on strings\n",
    "\n",
    "\n",
    "- One cannot perform mathematical operations on strings, even if the\n",
    "    strings look like numbers\n",
    "\n",
    "- The `+` operator represents concatenation, not addition\n",
    "\n",
    "- The `*` operator also works on strings; it performs repetition\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2fuIPQXsHufZ",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "message = \"Hi\"\n",
    "message - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hk23U3RMH5Yp",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(message + \" \" + \"John Snow\")\n",
    "print(message * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JhAHpRed4fHw",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 2.10 Input\n",
    "\n",
    "\n",
    "- There is a built-in function in Python, `input()`, for getting input\n",
    "    from the user\n",
    "\n",
    "- The user of the program can enter the input and click OK\n",
    "\n",
    "- The `input()` function always return a string (without the new-line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "UAZFQM8h9ygk",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "n = input(\"Please enter your name: \")\n",
    "print(\"Hello\", n)\n",
    "print(\"n of \", type(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9zOucsmI8Uzc",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Runestone Interactive vídeo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zpugFN4Y8Hp3",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('2KYixkCBXSQ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nl2HIiIy5e12",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 2.11 Composition\n",
    "\n",
    "\n",
    "- One of the most useful features of programming languages is their\n",
    "    ability to take small building blocks and **compose** them into\n",
    "    larger chunks.\n",
    "\n",
    "- Let's do four-step program that asks the user to input a value for\n",
    "    the radius of a circle, and then computes the area of the circle\n",
    "    from the formula $\\pi r^{2}$\n",
    "\n",
    "\n",
    "Try with Spyder:\n",
    "\n",
    ">   TIP: try to make code as simple as you can for the human to follow\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/02/area.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kiX4OWRo7HAa",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Ticket to Leave"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WFz9dmO07Tes",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Moodle activity\n",
    "\n",
    "\n",
    "[LE02: Simple Python Data](https://moodle.up.pt/mod/quiz/view.php?id=27079)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4NDZSZIG7Rid",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "\n",
    "$\\Rightarrow$ \n",
    "[Go back to the Table of Contents](00-contents.ipynb)\n",
    "\n",
    "$\\Rightarrow$ \n",
    "[Read the Preface](00-preface.ipynb)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "colab": {
   "collapsed_sections": [
    "8z5cONg8rUrX"
   ],
   "name": "02-simple-data.ipynb",
   "private_outputs": true,
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}