01 Variables, assignment and operator precedence.ipynb

{
  "cells": [
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Introduction\n\nWe begin with assignment to variables and familiar mathematical operations.\n\n\n## Objectives\n\n- Introduce expressions and basic operators\n- Introduce operator precedence\n- Understand variables and assignment"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Evaluating expressions: simple operators\n\nWe can use Python like a calculator. Consider the simple expression $3 + 8$. We can evaluate and print this by:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "3 + 8",
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 1,
          "data": {
            "text/plain": "11"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Another simple calculation is the gravitational potential $V$ of a body of mass $m$ (point mass) at a distance $r$ from a body of mass $M$, which is given by\n\n$$\nV = \\frac{G M m}{r}\n$$\n\nwhere $G$ is the *gravitational constant*. A good approximation is $G = 6.674 \\times 10^{-11}$ N m$^{2}$ kg$^{-2}$.\n\nFor the case $M = 1.65 \\times 10^{12}$ kg, $m = 6.1 \\times 10^2$ kg and $r = 7.0 \\times 10^3$ m, we can compute the  gravitational potential $V$:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "6.674e-11*1.65e12*6.1e2/7.0e3",
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 2,
          "data": {
            "text/plain": "9.59625857142857"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We have used 'scientific notation' to input the values. For example, the number $8 \\times 10^{-2}$ can be input as `0.08` or `8e-2`. We can easily verify that the two are the same via subtraction:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "0.08 - 8e-2",
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 3,
          "data": {
            "text/plain": "0.0"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "A common operation is raising a number to a power. To compute $3^4$:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "3**4",
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 4,
          "data": {
            "text/plain": "81"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The remainder is computed using the modulus operator '`%`':"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "11 % 3",
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 5,
          "data": {
            "text/plain": "2"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "To get the quotient we use 'floor division', which uses the symbol '`//`':"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "11 // 3",
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 6,
          "data": {
            "text/plain": "3"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Operator precedence\n\nOperator precedence refers to the order in which operations are performed, e.g. multiplication before addition.\nIn the preceding examples, there was no ambiguity as to the order of the operations. However, there are common cases where order does matter, and there are two points to consider:\n\n- The expression should be evaluated correctly; and \n- The expression should be simple enough for someone else reading the code to understand what operation is being \n  performed.\n\nIt is possible to write code that is correct, but which might be very difficult for someone else (or you) to check.\n\nMost programming languages, including Python, follow the usual mathematical rules for precedence. We explore this through some examples."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Consider the expression $4 \\cdot (7 - 2) = 20$. If we are careless, "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "4*7 - 2",
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 7,
          "data": {
            "text/plain": "26"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "In the above, `4*7` is evaluated first, then `2` is subtracted because multiplication (`*`) comes before subtraction (`-`) in terms of precedence. We can control the order of the operation using brackets, just as we would on paper:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "4*(7 - 2)",
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 8,
          "data": {
            "text/plain": "20"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "A common example where readability is a concern is \n\n$$\n\\frac{10}{2 \\times 50} = 0.1\n$$\n\nThe code"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "10/2*50",
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 9,
          "data": {
            "text/plain": "250.0"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "is incorrect. The multiplication and division have the same precedence, so the expression is evaluated 'left-to-right'. The correct result is computed from "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "10/2/50",
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 10,
          "data": {
            "text/plain": "0.1"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "but this is hard to read and could easily lead to errors in a program. I would recommend using brackets to make the order clear:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "10/(2*50)",
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 11,
          "data": {
            "text/plain": "0.1"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Here is an example that computes $2^{3} \\cdot 4 = 32$ which is technically correct but not ideal in terms of readability:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "2**3*4",
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 12,
          "data": {
            "text/plain": "32"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Better would be:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "(2**3)*4",
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 13,
          "data": {
            "text/plain": "32"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Variables and assignment\n\nThe above code snippets were helpful for doing some arithmetic, but we could easily do the same with a pocket calculator. Also, the snippets are not very helpful if we want to change the value of one of the numbers in an expression, and not very helpful if we wanted to use the value of the expression in a subsequent computation. To improve things, we need *assignment*.\n\nWhen we compute something, we usually want to store the result so that we can use it in subsequent computations. *Variables* are what we use to store something, e.g.:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "c = 10\nprint(c)",
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": "10\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Above, the variable `c` is used to 'hold' the value `10`. The function `print` is used to print the value of a variable to the output (more on functions later).\n\nSay we want to compute $c = a + b$, where $a = 2$ and $b = 11$:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "a = 2\nb = 11\nc = a + b\nprint(c)",
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": "13\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "What is happening above is that the expression on the right-hand side of the assignment operator '`=`' is evaluated and then stored as the variable on the left-hand side. You can think of the variable as a 'handle' for a value.\nIf we want to change the value of $a$ to $4$ and recompute the sum, we would just replace `a = 2` with `a = 4` and execute the code (try this yourself by running this notebook interactively).\n\nThe above looks much like standard algebra. There are however some subtle differences. Take for example:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "a = 2\nb = 11\na = a + b\nprint(a)",
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": "13\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "This is not a valid algebraic statement since '`a`' appears on both sides of '`=`', but it is a very common statement in a computer program. What happens is that the expression on the right-hand side is evaluated (the values assigned to `a` and `b` are summed), and the result is assigned to the left-hand side (to the variable `a`). There is a mathematical notation for this type of assignment:\n\n$$\na \\leftarrow a +b \n$$\n\nwhich says 'sum $a$ and $b$, and copy the result to $a$'. You will see this notation in some books, especially when looking at *algorithms*."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Shortcuts\n\nAdding or subtracting variables is such a common operation that most languages provides shortcuts. For addition:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Long-hand addition\na = 1\na = a + 4\nprint(a)\n\n# Short-hand addition\na = 1\na += 4\nprint(a)",
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": "5\n5\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "> In Python, any text following the hash (`#`) symbol is a 'comment'. Comments are not executed by the program; \n> they help us document and explain what our programs do. Use lots of comments in your programs.\n\nFor subtraction:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Long-hand subtraction\na = 1\nb = 4\na = a - b\nprint(a)\n\n# Short-hand subtraction\na = 1\nb = 4\na -= b\nprint(a)",
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": "-3\n-3\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Analogous assignment operators exist for multiplication and division:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Long-hand multiplication\na = 10\nc = 2\na = c*a\nprint(a)\n\n# Short-hand multiplication\na = 10\nc = 2\na *= c\nprint(a)\n\n# Long-hand division\na = 1\na = a/4\nprint(a)\n\n# Short-hand division\na = 1\na /= 4\nprint(a)",
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": "20\n20\n0.25\n0.25\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Naming variables\n\nIt is good practice to use meaningful variable names in a computer program. Say you used  '`x`' for time, and '`t`' for position, you or someone else will almost certainly make errors at some point.\nIf you do not use well considered variable names:\n\n1. You're much more likely to make errors.\n1. When you come back to your program after some time, you will have trouble recalling and understanding \n   what the program does.\n1. It will be difficult for others to understand your program - serious programming is almost always a team effort.\n\nLanguages have rules for what charcters can be used in variable names. As a rough guide, in Python variable names can use letters and digits, but cannot start with a digit.\n\nSometimes for readability it is useful to have variable names that are made up of two words. A convention is\nto separate the words in the variable name using an underscore '`_`'. For example, a good variable name for storing the number of days would be \n```python\nnum_days = 10\n```\nPython is a case-sensitive language, e.g. the variables '`A`' and '`a`' are different. Some languages, such as\nFortran, are case-insensitive.\n\nLanguages have reserved keywords that cannot be used as variable names as they are used for other purposes. The reserved keywords in Python are:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "import keyword\nprint(keyword.kwlist)",
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": "['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "If you try to assign something to a reserved keyword, you will get an error.\n\nPython 3 supports Unicode, which allows you to use a very wide range of symbols, including Greek characters:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "θ = 10\nα = 12\nβ = θ + α\nprint(β)",
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": "22\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Greek symbols and other symbols can be input in a Jupyter notebook by typing the LaTeX command for the symbol and then pressing the `tab` key, e.g. '`\\theta`' followed by pressing the `tab` key."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Exercises\n\nComplete now the [01 Exercises](Exercises/01%20Exercises.ipynb) notebook."
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3",
      "language": "python"
    },
    "language_info": {
      "mimetype": "text/x-python",
      "nbconvert_exporter": "python",
      "name": "python",
      "file_extension": ".py",
      "version": "3.5.4",
      "pygments_lexer": "ipython3",
      "codemirror_mode": {
        "version": 3,
        "name": "ipython"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 1
}