L1_Syntax, Variables, and Numbers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Intro\n",
    "\n",
    "We'll start with a brief overview of Python syntax, variable assignment, and arithmetic operators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hello, Python!\n",
    "\n",
    "Python was named for the British comedy troupe [Monty Python](https://en.wikipedia.org/wiki/Monty_Python), so we'll make our first Python program an homage to their skit about Spam?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_kg_hide-output": true
   },
   "outputs": [],
   "source": [
    "spam_amount = 0\n",
    "print(spam_amount)\n",
    "\n",
    "# Ordering Spam, egg, Spam, Spam, bacon and Spam (4 more servings of Spam)\n",
    "spam_amount = spam_amount + 4\n",
    "\n",
    "if spam_amount > 0:\n",
    "    print(\"But I don't want ANY spam!\")\n",
    "\n",
    "viking_song = \"Spam \" * spam_amount\n",
    "print(viking_song)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's a lot to unpack here! This silly program demonstrates many important aspects of what Python code looks like and how it works. Let's review the code from top to bottom."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spam_amount = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Variable assignment:** Here we create a variable called `spam_amount` and assign it the value of 0 using `=`, which is called the assignment operator.\n",
    "\n",
    "> **Aside**: If you've programmed in certain other languages (like Java or C++), you might be noticing some things Python *doesn't* require us to do here:  \n",
    "- this is called dynamic typing\n",
    "- we don't need to \"declare\" `spam_amount` before assigning to it\n",
    "- we don't need to tell Python what type of value `spam_amount` is going to refer to. In fact, we can even go on to reassign `spam_amount` to refer to a different sort of thing like a string or a boolean."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_kg_hide-output": false
   },
   "outputs": [],
   "source": [
    "print(spam_amount)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Function calls:**. `print` is a Python function that displays the value passed to it on the screen. We call functions by putting parentheses after their name, and putting the inputs (or *arguments*) to the function in those parentheses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_kg_hide-output": false
   },
   "outputs": [],
   "source": [
    "# Ordering Spam, egg, Spam, Spam, bacon and Spam (4 more servings of Spam)\n",
    "spam_amount = spam_amount + 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first line above is a **comment**. In Python, comments begin with the `#` symbol.\n",
    "\n",
    "Next we see an example of reassignment. Reassigning the value of an existing variable looks just the same as creating a variable - it still uses the `=` assignment operator.\n",
    "\n",
    "In this case, the value we're assigning to `spam_amount` involves some simple arithmetic on its previous value. When it encounters this line, Python evaluates the expression on the right-hand-side of the `=` (0 + 4 = 4), and then assigns that value to the variable on the left-hand-side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_kg_hide-output": false
   },
   "outputs": [],
   "source": [
    "if spam_amount > 0:\n",
    "    print(\"But I don't want ANY spam!\")\n",
    "\n",
    "viking_song = \"Spam Spam Spam\"\n",
    "print(viking_song)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We won't talk much about \"conditionals\" until later, but, even someone who has never coded before, can probably guess what this does. Python is prized for its readability and the simplicity. \n",
    "\n",
    "Note how we indicated which code belongs to the `if`. `\"But I don't want ANY spam!\"` is only supposed to be printed if `spam_amount` is positive. But the later code (like `print(viking_song)`) should be executed no matter what. How do we (and Python) know that?\n",
    "\n",
    "The colon (`:`) at the end of the `if` line indicates that a new \"code block\" is starting. Subsequent lines which are **indented** are part of that code block. Some other languages use `{`curly braces`}` to mark the beginning and end of code blocks. Python's use of meaningful whitespace can be surprising to programmers who are accustomed to other languages, but in practice it can lead to more consistent and readable code than languages that do not enforce indentation of code blocks. \n",
    "\n",
    "The later lines dealing with `viking_song` are not indented with an extra 4 spaces, so they're not a part of the `if`'s code block. We'll see more examples of indented code blocks later when we define functions and using loops.\n",
    "\n",
    "This code snippet is also our first sighting of a **string** in Python:\n",
    "\n",
    "```python\n",
    "\"But I don't want ANY spam!\"\n",
    "```\n",
    "\n",
    "Strings can be marked either by double or single quotation marks. (But because this particular string *contains* a single-quote character, we might confuse Python by trying to surround it with single-quotes, unless we're careful.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_kg_hide-output": false
   },
   "outputs": [],
   "source": [
    "viking_song = \"Spam \" * spam_amount\n",
    "print(viking_song)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `*` operator can be used to multiply two numbers (`3 * 3` evaluates to 9), but amusingly enough, we can also multiply a string by a number, to get a version that's been repeated that many times. Python offers a number of cheeky little time-saving tricks like this where operators like `*` and `+` have a different meaning depending on what kind of thing they're applied to. (The technical term for this is [operator overloading](https://en.wikipedia.org/wiki/Operator_overloading))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numbers and arithmetic in Python\n",
    "\n",
    "We've already seen an example of a variable containing a number above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spam_amount = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"Number\" is a fine informal name for the kind of thing, but if we wanted to be more technical, we could ask Python how it would describe the type of thing that `spam_amount` is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(spam_amount)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's an `int` - short for integer. There's another sort of number we commonly encounter in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(19.95)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `float` is a number with a decimal place - very useful for representing things like weights or proportions.\n",
    "\n",
    "`type()` is the second built-in function we've seen (after `print()`), and it's another good one to remember. It's very useful to be able to ask Python \"what kind of thing is this?\". "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A natural thing to want to do with numbers is perform arithmetic. We've seen the `+` operator for addition, and the `*` operator for multiplication (of a sort). Python also has us covered for the rest of the basic buttons on our calculator:\n",
    "\n",
    "| Operator     | Name           | Description                                            |\n",
    "|--------------|----------------|--------------------------------------------------------|\n",
    "| ``a + b``    | Addition       | Sum of ``a`` and ``b``                                 |\n",
    "| ``a - b``    | Subtraction    | Difference of ``a`` and ``b``                          |\n",
    "| ``a * b``    | Multiplication | Product of ``a`` and ``b``                             |\n",
    "| ``a / b``    | True division  | Quotient of ``a`` and ``b``                            |\n",
    "| ``a // b``   | Floor division | Quotient of ``a`` and ``b``, removing fractional parts |\n",
    "| ``a % b``    | Modulus        | Integer remainder after division of ``a`` by ``b``     |\n",
    "| ``a ** b``   | Exponentiation | ``a`` raised to the power of ``b``                     |\n",
    "| ``-a``       | Negation       | The negative of ``a``                                  |\n",
    "\n",
    "<span style=\"display:none\"></span>\n",
    "\n",
    "One interesting observation here is that, whereas a calculator probably just has one button for division, Python can do two kinds. \"True division\" is basically what a calculator does:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5 / 2)\n",
    "print(6 / 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It always gives us a `float`. \n",
    "\n",
    "The `//` operator gives us a result that's rounded down to the nearest integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5 // 2)\n",
    "print(6 // 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Type checking can be executed to evaluate the results. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(5 / 2))\n",
    "print(type(5 // 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Order of operations\n",
    "\n",
    "The arithmetic we learned in primary school has conventions about the order in which operations are evaluated. Some remember these by a mnemonic such as **PEMDAS** - **P**arentheses, **E**xponents, **M**ultiplication/**D**ivision, **A**ddition/**S**ubtraction.\n",
    "\n",
    "Python follows similar rules about which calculations to perform first. They're mostly pretty intuitive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "8 - 3 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "-3 + 4 * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes the default order of operations isn't what we want:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hat_height_cm = 25\n",
    "my_height_cm = 190\n",
    "# How tall am I, in meters, when wearing my hat?\n",
    "total_height_meters = hat_height_cm + my_height_cm / 100\n",
    "print(\"Height in meters =\", total_height_meters, \"?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parentheses are useful here. We can add them to force Python to evaluate sub-expressions in whatever order we want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total_height_meters = (hat_height_cm + my_height_cm) / 100\n",
    "print(\"Height in meters =\", total_height_meters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Builtin functions for working with numbers\n",
    "\n",
    "`min` and `max` return the minimum and maximum of their arguments, respectively..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(min(1, 2, 3))\n",
    "print(max(1, 2, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`abs` returns the absolute value of it argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(abs(32))\n",
    "print(abs(-32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to being the names of Python's two main numerical types, `int` and `float` can also be called as functions which convert their arguments to the corresponding type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(float(10))\n",
    "print(int(3.33))\n",
    "# They can even be called on strings!\n",
    "print(int('807') + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**[Week 1 - Python](https://radu-enuca.gitbook.io/ml-challenge/python)**\n",
    "\n",
    "*Have questions or comments? Visit the ML Challenge Mattermost Channel.*"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Edit Metadata",
  "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.7.4"
  },
  "learntools_metadata": {
   "lesson_index": 0,
   "type": "tutorial"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}