01. Intro to Programming/tutorial/01. arithmetic-and-variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f414f965",
   "metadata": {
    "papermill": {
     "duration": 0.012175,
     "end_time": "2022-06-06T19:02:49.482723",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.470548",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Welcome to the Intro to Programming course!  This course is for you if you have never written a single line of code, and you are interested in learning data science and machine learning.  (_If you do have programming experience and are just new to the Python language, the [Python course](http://www.kaggle.com/learn/python) is a better fit to get started._)\n",
    "\n",
    "In this course, you will learn how to use code to get a computer to perform certain tasks for you.  Python is one of the most popular programming languages for data science, and it's the language you'll learn in this course.  Once you complete this course, you'll be fully prepared to progress to the [Python course](http://www.kaggle.com/learn/python), followed by the [Intro to Machine Learning course](http://www.kaggle.com/learn/intro-to-machine-learning).\n",
    "\n",
    "In this tutorial, you'll see several examples of Python code.  You'll get a chance to write your own code in the exercise.  (_If you'd like to preview the exercise, feel free to **[take a look now](https://www.kaggle.com/kernels/fork/25258219)**.  We also provide a link to the exercise at the end of this tutorial._)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2effaa8a",
   "metadata": {
    "papermill": {
     "duration": 0.007615,
     "end_time": "2022-06-06T19:02:49.498445",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.490830",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Printing\n",
    "\n",
    "One of the simplest (and most important!) tasks you can ask a computer to do is to print a message.\n",
    "\n",
    "In Python, we ask a computer to print a message for us by writing `print()` and putting the message inside the parentheses and enclosed in quotation marks.  Below, we ask the computer to print the message `Hello, world!`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2a6432cd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-06-06T19:02:49.516100Z",
     "iopub.status.busy": "2022-06-06T19:02:49.515589Z",
     "iopub.status.idle": "2022-06-06T19:02:49.526317Z",
     "shell.execute_reply": "2022-06-06T19:02:49.525578Z"
    },
    "papermill": {
     "duration": 0.022325,
     "end_time": "2022-06-06T19:02:49.528543",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.506218",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello, world!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15586193",
   "metadata": {
    "papermill": {
     "duration": 0.007567,
     "end_time": "2022-06-06T19:02:49.544075",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.536508",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "The code is inside the box (known as a **code cell**), and the computer's response (called the **output** of the code) is shown below the box.  As you can see, the computer printed the message that we wanted.\n",
    "\n",
    "# Arithmetic\n",
    "\n",
    "We can also print the value of some arithmetic operation (such as addition, subtraction, multiplication, or division).\n",
    "\n",
    "For instance, in the next code cell, the computer adds 2 to 1 and then prints the result, which is 3.  Note that unlike when we were simply printing text, we don't use any quotation marks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2f580351",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-06-06T19:02:49.561799Z",
     "iopub.status.busy": "2022-06-06T19:02:49.561253Z",
     "iopub.status.idle": "2022-06-06T19:02:49.565929Z",
     "shell.execute_reply": "2022-06-06T19:02:49.564823Z"
    },
    "papermill": {
     "duration": 0.015997,
     "end_time": "2022-06-06T19:02:49.567927",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.551930",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(1 + 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56022893",
   "metadata": {
    "papermill": {
     "duration": 0.007757,
     "end_time": "2022-06-06T19:02:49.583862",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.576105",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "We can also do subtraction in python.  The next code cell subtracts 5 from 9 and prints the result, which is 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "83f13eba",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-06-06T19:02:49.602098Z",
     "iopub.status.busy": "2022-06-06T19:02:49.601576Z",
     "iopub.status.idle": "2022-06-06T19:02:49.605960Z",
     "shell.execute_reply": "2022-06-06T19:02:49.604835Z"
    },
    "papermill": {
     "duration": 0.01615,
     "end_time": "2022-06-06T19:02:49.608109",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.591959",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(9 - 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cd94c49",
   "metadata": {
    "papermill": {
     "duration": 0.008304,
     "end_time": "2022-06-06T19:02:49.624731",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.616427",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "You can actually do a lot of calculations with python!  See the table below for some examples.\n",
    "\n",
    "<table style=\"width: 100%;\">\n",
    "<tbody>\n",
    "<tr><th><b>Operation</b></th><th><b>Symbol</b></th><th><b>Example</b></th></tr>\n",
    "<tr>\n",
    "<td>Addition</td>\n",
    "<td>+</td>\n",
    "<td>1 + 2 = 3</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Subtraction</td>\n",
    "<td>-</td>\n",
    "<td>5 - 4 = 1</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Multiplication</td>\n",
    "<td>*</td>\n",
    "<td>2 * 4 = 8</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Division</td>\n",
    "<td>/</td>\n",
    "<td>6 / 3 = 2</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Exponent</td>\n",
    "<td>**</td>\n",
    "<td>3 ** 2 = 9</td>\n",
    "</tr>\n",
    "</tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "beb970e7",
   "metadata": {
    "papermill": {
     "duration": 0.007676,
     "end_time": "2022-06-06T19:02:49.640930",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.633254",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "You can control the order of operations in long calculations with parentheses.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "11d97a29",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-06-06T19:02:49.659462Z",
     "iopub.status.busy": "2022-06-06T19:02:49.659039Z",
     "iopub.status.idle": "2022-06-06T19:02:49.664325Z",
     "shell.execute_reply": "2022-06-06T19:02:49.663235Z"
    },
    "papermill": {
     "duration": 0.017542,
     "end_time": "2022-06-06T19:02:49.666714",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.649172",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "196.0\n"
     ]
    }
   ],
   "source": [
    "print(((1 + 3) * (9 - 2) / 2) ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0cac063",
   "metadata": {
    "papermill": {
     "duration": 0.008264,
     "end_time": "2022-06-06T19:02:49.683423",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.675159",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "In general, Python follows the [PEMDAS rule](https://www.mathsisfun.com/operation-order-pemdas.html) when deciding the order of operations.\n",
    "\n",
    "# Comments\n",
    "\n",
    "We use **comments** to annotate what code is doing.  They help other people to understand your code, and they can also be helpful if you haven't looked at your own code in a while.  So far, the code that we have written is very short, but annotations become more important when you have written a lot of code. \n",
    "\n",
    "For instance, in the next code cell, we multiply 3 by 2.  We also add a comment (`# Multiply 3 by 2`) above the code to describe what the code is doing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "aebb1b06",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-06-06T19:02:49.701956Z",
     "iopub.status.busy": "2022-06-06T19:02:49.701578Z",
     "iopub.status.idle": "2022-06-06T19:02:49.706362Z",
     "shell.execute_reply": "2022-06-06T19:02:49.705442Z"
    },
    "papermill": {
     "duration": 0.016798,
     "end_time": "2022-06-06T19:02:49.708611",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.691813",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "# Multiply 3 by 2\n",
    "print(3 * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f1bcfa3",
   "metadata": {
    "papermill": {
     "duration": 0.008558,
     "end_time": "2022-06-06T19:02:49.725507",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.716949",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "To indicate to Python that a line is comment (and not Python code), you need to write a pound sign (`#`) as the very first character.  \n",
    "\n",
    "Once Python sees the pound sign and recognizes that the line is a comment, it is completely ignored by the computer.  This is important, because just like English or Hindi (or any other language!), Python is a language with very strict rules that need to be followed.  Python is stricter than a human listener, though, and will just error if it can't understand the code.\n",
    "\n",
    "We can see an example of this, in the code cell below.  Python errors if we remove the pound sign, because the text in the comment is not valid Python code, so it can't be interpreted properly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "58c93dc4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-06-06T19:02:49.744222Z",
     "iopub.status.busy": "2022-06-06T19:02:49.743316Z",
     "iopub.status.idle": "2022-06-06T19:02:49.749689Z",
     "shell.execute_reply": "2022-06-06T19:02:49.748890Z"
    },
    "papermill": {
     "duration": 0.017812,
     "end_time": "2022-06-06T19:02:49.751698",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.733886",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (3750420471.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"/tmp/ipykernel_18/3750420471.py\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    Multiply 3 by 2\u001b[0m\n\u001b[0m             ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "Multiply 3 by 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b35eab9",
   "metadata": {
    "papermill": {
     "duration": 0.008029,
     "end_time": "2022-06-06T19:02:49.768037",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.760008",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Variables\n",
    "\n",
    "So far, you have used code to make a calculation and print the result, and the result isn't saved anywhere.  However, you can imagine that you might want to save the result to work with it later.  For this, you'll need to use **variables**.\n",
    "\n",
    "## Creating variables\n",
    "\n",
    "The next code cell creates a variable named `test_var` and assigns it the value that we get when we add 5 to 4.\n",
    "\n",
    "We then print the value that is assigned to the variable, which is 9."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2f4d7800",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-06-06T19:02:49.786981Z",
     "iopub.status.busy": "2022-06-06T19:02:49.785992Z",
     "iopub.status.idle": "2022-06-06T19:02:49.792038Z",
     "shell.execute_reply": "2022-06-06T19:02:49.790992Z"
    },
    "papermill": {
     "duration": 0.01761,
     "end_time": "2022-06-06T19:02:49.794001",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.776391",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "# Create a variable called test_var and give it a value of 4+5\n",
    "test_var = 4 + 5\n",
    "\n",
    "# Print the value of test_var\n",
    "print(test_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c24b4fb5",
   "metadata": {
    "papermill": {
     "duration": 0.008488,
     "end_time": "2022-06-06T19:02:49.811061",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.802573",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "In general, to work with a variable, you need to begin by selecting the name you want to use.  Variable names are ideally short and descriptive.  They also need to satisfy several requirements:\n",
    "- They can't have spaces (e.g., `test var` is not allowed)\n",
    "- They can only include letters, numbers, and underscores (e.g., `test_var!` is not allowed)\n",
    "- They have to start with a letter or underscore (e.g., `1_var` is not allowed)\n",
    "\n",
    "Then, to create the variable, you need to use `=` to assign the value that you want it to have. \n",
    "\n",
    "You can always take a look at the value assigned to the variable by using `print()` and putting the name of the variable in parentheses.\n",
    "\n",
    "Over time, you'll learn how to select good names for Python variables.  It's completely fine for it to feel uncomfortable now, and the best way to learn is just by viewing a lot of Python code!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76cdf68e",
   "metadata": {
    "papermill": {
     "duration": 0.008102,
     "end_time": "2022-06-06T19:02:49.827886",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.819784",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Manipulating variables\n",
    "\n",
    "You can always change the value assigned to a variable by overriding the previous value.\n",
    "\n",
    "In the code cell below, we change the value of `my_var` from 3 to 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b170db3e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-06-06T19:02:49.846911Z",
     "iopub.status.busy": "2022-06-06T19:02:49.846531Z",
     "iopub.status.idle": "2022-06-06T19:02:49.851720Z",
     "shell.execute_reply": "2022-06-06T19:02:49.850723Z"
    },
    "papermill": {
     "duration": 0.017683,
     "end_time": "2022-06-06T19:02:49.854245",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.836562",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "# Set the value of a new variable to 3\n",
    "my_var = 3\n",
    "\n",
    "# Print the value assigned to my_var\n",
    "print(my_var)\n",
    "\n",
    "# Change the value of the variable to 100\n",
    "my_var = 100\n",
    "\n",
    "# Print the new value assigned to my_var\n",
    "print(my_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6508d2f",
   "metadata": {
    "papermill": {
     "duration": 0.008282,
     "end_time": "2022-06-06T19:02:49.870999",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.862717",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Note that in general, whenever you define a variable in a code cell, all of the code cells that follow also have access to the variable.  For instance, we use the next code cell to access the values of `my_var` (from the code cell above) and `test_var` (from earlier in this tutorial)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "20031e89",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-06-06T19:02:49.889506Z",
     "iopub.status.busy": "2022-06-06T19:02:49.888863Z",
     "iopub.status.idle": "2022-06-06T19:02:49.893644Z",
     "shell.execute_reply": "2022-06-06T19:02:49.892717Z"
    },
    "papermill": {
     "duration": 0.016048,
     "end_time": "2022-06-06T19:02:49.895527",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.879479",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "print(my_var)\n",
    "print(test_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9de8f088",
   "metadata": {
    "papermill": {
     "duration": 0.008358,
     "end_time": "2022-06-06T19:02:49.912535",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.904177",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "The next code cell tells Python to increase the current value of `my_var` by 3.\n",
    "\n",
    "To do this, we still need to use `my_var =` like before.  And also just like before, the new value we want to assign to the variable is to the right of the `=` sign."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8c4f2d59",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-06-06T19:02:49.932018Z",
     "iopub.status.busy": "2022-06-06T19:02:49.931155Z",
     "iopub.status.idle": "2022-06-06T19:02:49.936761Z",
     "shell.execute_reply": "2022-06-06T19:02:49.935784Z"
    },
    "papermill": {
     "duration": 0.017809,
     "end_time": "2022-06-06T19:02:49.938881",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.921072",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "103\n"
     ]
    }
   ],
   "source": [
    "# Increase the value by 3\n",
    "my_var = my_var + 3\n",
    "\n",
    "# Print the value assigned to my_var\n",
    "print(my_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ea7656e",
   "metadata": {
    "papermill": {
     "duration": 0.008436,
     "end_time": "2022-06-06T19:02:49.956115",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.947679",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Using multiple variables\n",
    "\n",
    "It's common for code to use multiple variables.  This is especially useful when we have to do a long calculation with multiple inputs.\n",
    "\n",
    "In the next code cell, we calculate the number of seconds in four years.  This calculation uses five inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9ba4ac9b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-06-06T19:02:49.975829Z",
     "iopub.status.busy": "2022-06-06T19:02:49.975254Z",
     "iopub.status.idle": "2022-06-06T19:02:49.980850Z",
     "shell.execute_reply": "2022-06-06T19:02:49.979812Z"
    },
    "papermill": {
     "duration": 0.01814,
     "end_time": "2022-06-06T19:02:49.982938",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.964798",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "126144000\n"
     ]
    }
   ],
   "source": [
    "# Create variables\n",
    "num_years = 4\n",
    "days_per_year = 365 \n",
    "hours_per_day = 24\n",
    "mins_per_hour = 60\n",
    "secs_per_min = 60\n",
    "\n",
    "# Calculate number of seconds in four years\n",
    "total_secs = secs_per_min * mins_per_hour * hours_per_day * days_per_year * num_years\n",
    "print(total_secs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "406b07da",
   "metadata": {
    "papermill": {
     "duration": 0.008941,
     "end_time": "2022-06-06T19:02:50.000917",
     "exception": false,
     "start_time": "2022-06-06T19:02:49.991976",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "As calculated above, there are 126144000 seconds in four years.  \n",
    "\n",
    "Note it is *possible* to do this calculation without variables as just `60 * 60 * 24 * 365 * 4`, but it is much harder to check that the calculation without variables does not have some error, because it is not as readable.  When we use variables (such as `num_years`, `days_per_year`, etc), we can better keep track of each part of the calculation and more easily check for and correct any mistakes.\n",
    "\n",
    "Note that it is particularly useful to use variables when the values of the inputs can change.  For instance, say we want to slightly improve our estimate by updating the value of the number of days in a year from 365 to 365.25, to account for leap years.  Then we can change the value assigned to `days_per_year` without changing any of the other variables and redo the calculation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4412b050",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-06-06T19:02:50.020482Z",
     "iopub.status.busy": "2022-06-06T19:02:50.020029Z",
     "iopub.status.idle": "2022-06-06T19:02:50.025747Z",
     "shell.execute_reply": "2022-06-06T19:02:50.024479Z"
    },
    "papermill": {
     "duration": 0.017906,
     "end_time": "2022-06-06T19:02:50.027794",
     "exception": false,
     "start_time": "2022-06-06T19:02:50.009888",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "126230400.0\n"
     ]
    }
   ],
   "source": [
    "# Update to include leap years\n",
    "days_per_year = 365.25\n",
    "\n",
    "# Calculate number of seconds in four years\n",
    "total_secs = secs_per_min * mins_per_hour * hours_per_day * days_per_year * num_years\n",
    "print(total_secs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d259e435",
   "metadata": {
    "papermill": {
     "duration": 0.008639,
     "end_time": "2022-06-06T19:02:50.045323",
     "exception": false,
     "start_time": "2022-06-06T19:02:50.036684",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Note**: You might have noticed the .0 added at the end of the number, which might look unnecessary.  This is caused by the fact that in the second calculation, we used a number with a fractional part (365.25), whereas the first calculation multipled just numbers with no fractional part.  You'll learn more about this in Lesson 3, when we cover data types."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c17c247",
   "metadata": {
    "papermill": {
     "duration": 0.008491,
     "end_time": "2022-06-06T19:02:50.062707",
     "exception": false,
     "start_time": "2022-06-06T19:02:50.054216",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Debugging\n",
    "\n",
    "One common error when working with variables is to accidentally introduce typos.  For instance, if we spell `hours_per_day` as `hours_per_dy`, Python will error with message `NameError: name 'hours_per_dy' is not defined`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b3b017a8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-06-06T19:02:50.082707Z",
     "iopub.status.busy": "2022-06-06T19:02:50.081840Z",
     "iopub.status.idle": "2022-06-06T19:02:50.153810Z",
     "shell.execute_reply": "2022-06-06T19:02:50.152807Z"
    },
    "papermill": {
     "duration": 0.08423,
     "end_time": "2022-06-06T19:02:50.156019",
     "exception": false,
     "start_time": "2022-06-06T19:02:50.071789",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'hours_per_dy' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_18/142450907.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhours_per_dy\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'hours_per_dy' is not defined"
     ]
    }
   ],
   "source": [
    "print(hours_per_dy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4633d839",
   "metadata": {
    "papermill": {
     "duration": 0.008779,
     "end_time": "2022-06-06T19:02:50.173893",
     "exception": false,
     "start_time": "2022-06-06T19:02:50.165114",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "When you see `NameError` like this, it's an indication that you should check how you have spelled the variable that it references as \"not defined\".  Then, to fix the error, you need only correct the spelling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "fdf7ee07",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-06-06T19:02:50.193815Z",
     "iopub.status.busy": "2022-06-06T19:02:50.193414Z",
     "iopub.status.idle": "2022-06-06T19:02:50.198536Z",
     "shell.execute_reply": "2022-06-06T19:02:50.197247Z"
    },
    "papermill": {
     "duration": 0.017849,
     "end_time": "2022-06-06T19:02:50.200835",
     "exception": false,
     "start_time": "2022-06-06T19:02:50.182986",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n"
     ]
    }
   ],
   "source": [
    "print(hours_per_day)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "972553e4",
   "metadata": {
    "papermill": {
     "duration": 0.008746,
     "end_time": "2022-06-06T19:02:50.218812",
     "exception": false,
     "start_time": "2022-06-06T19:02:50.210066",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# What's next?\n",
    "\n",
    "Now it's your turn to **[practice manipulating variables with arithmetic](https://www.kaggle.com/kernels/fork/25258219)**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6e7d14a",
   "metadata": {
    "papermill": {
     "duration": 0.008932,
     "end_time": "2022-06-06T19:02:50.237336",
     "exception": false,
     "start_time": "2022-06-06T19:02:50.228404",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "---\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "*Have questions or comments? Visit the [course discussion forum](https://www.kaggle.com/learn/intro-to-programming/discussion) to chat with other learners.*"
   ]
  }
 ],
 "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.12"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 11.934503,
   "end_time": "2022-06-06T19:02:50.868611",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2022-06-06T19:02:38.934108",
   "version": "2.3.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}