01-variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Variables\n",
    "\n",
    "Within a programming workflow, variables store data (i.e. information) that you want to re-use in your code (e.g. a single value, list of values, a filename, or path to a directory). \n",
    "\n",
    "In `Python`, variables can be created without defining the type of data that it will hold (e.g. whole numbers, text string). This differs from many other programming languages that require the variable to be explicitly assigned a data type. \n",
    "\n",
    "A variable can contain a single value - such as a whole number (i.e. integer), decimal, or text string - or it can contain a list of values. In this lesson, you will work with variables that store single data values. \n",
    "\n",
    "You can create a variable to store a single numeric value by defining a name and assigning a value to that name using the equal (`=`) operator (e.g. `variablename = 1.5`). \n",
    "\n",
    "If the value is a text string, you need to add parenthesis (`\"\"`) around the value, so that `Python` knows it is a text string (e.g. `variablename = \"text\"`). \n",
    "\n",
    "Just like you want to use good naming conventions for directories on your computer, you also want to assign clear and short names to variables, avoiding spaces or complicated wording, but still specific enough that you know what it is. \n",
    "\n",
    "For example, a variable containing the average annual precipitation in millimeters (mm) for Boulder, Colorado could simply be called `precip`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "525"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "precip = 525\n",
    "\n",
    "precip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Boulder'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city = \"Boulder\"\n",
    "\n",
    "city"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lesson, you will:\n",
    "\n",
    "1. create new variables for average monthly precipitation values for Boulder, CO, U.S.A.\n",
    "2. apply arithmetic calculations to these variables to convert the values from inches to millimeters. \n",
    "\n",
    "You will use data on average monthly precipitation for <a href=\"https://www.esrl.noaa.gov/psd/boulder/Boulder.mm.precip.html\" target=\"_blank\">Boulder, Colorado provided by the U.S. National Oceanic and Atmospheric Administration (NOAA).</a> \n",
    "\n",
    "Month  | Precipitation (inches) |\n",
    "--- | --- |\n",
    "Jan | 0.70 |\n",
    "Feb | 0.75 |\n",
    "Mar | 1.85 |\n",
    "Apr | 2.93 |\n",
    "May | 3.05 |\n",
    "June | 2.02 |\n",
    "July | 1.93 |\n",
    "Aug | 1.62 |\n",
    "Sept | 1.84 |\n",
    "Oct | 1.31 |\n",
    "Nov | 1.39 |\n",
    "Dec | 0.84 |\n",
    "\n",
    "\n",
    "## Begin Writing Your Code\n",
    "\n",
    "### Add Comments to Your Python Code \n",
    "\n",
    "You have previously learned that documentation is critical for open reproducible science. `Python` provides a great way to easily document your code with comments. \n",
    "\n",
    "Adding `Python` comments before each code block can help you to document and explain what is being accomplished with that code. \n",
    "\n",
    "`Python` comments are lines in the your code that will not execute a task and can be designated using `#`. Typically, the comment is written before the lines of codes, or code bloack (e.g. `# the code below does this`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Variables\n",
    "\n",
    "Begin by creating a variable for each month to store the single value of average precipitation in that month (e.g. `jan = 0.70`). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create new variables for monthly average precipitation values (inches) for January through June\n",
    "jan = 0.70\n",
    "feb = 0.75\n",
    "mar = 1.85\n",
    "apr = 2.93\n",
    "may = 3.05\n",
    "june = 2.02"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running Arithmetic Calculations\n",
    "\n",
    "In `Python`, there are many arithmetic operators including operators for addition (`+`) , subtraction (`-`), multiplication (`*`), and division (`\\`). \n",
    "\n",
    "Run the Cells below and notice that the output is automatically generated, without the need to call the `print` function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 4\n",
    "b = 10\n",
    "\n",
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b - a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b / a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assign Calculation Results to Variable\n",
    "\n",
    "You can also assign new values to an existing variables as part of an arithmetic operation, though now you will need to use the `print` function, in order to see the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14\n"
     ]
    }
   ],
   "source": [
    "a = a + b\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the word `print` does not show up the output. Instead, you simply see the result `14`, without the quotations or parentheses. \n",
    "\n",
    "**You have now used your first `Python` function!** Functions in `Python` are commands that can take inputs that are used to produce output. \n",
    "\n",
    "We will learn more about functions as the course continues, and we will use the `print` function a lot, as it can be very handy for viewing results and for communicating the status of your code. \n",
    "\n",
    "Now that you have created individual variables to store the average precipitation (in inches) for each month, you can run arithmetic calculations on these variables to convert the values from inches to millimeters (mm). One inch is equal to 25.4 mm.\n",
    "\n",
    "Use the multiplication (`*`) operator to multiply each monthly variable by 25.4 to convert the value from inches to millimeters. Use the original variable name (e.g. `jan`) to recreate it with the new value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17.779999999999998\n"
     ]
    }
   ],
   "source": [
    "# convert the monthly variables for `jan` to `june` from inches to millimeters (1 inch = 25.4 mm)  \n",
    "jan = jan * 25.4\n",
    "feb = feb * 25.4\n",
    "mar = mar * 25.4\n",
    "apr = apr * 25.4\n",
    "may = may * 25.4\n",
    "june = june * 25.4\n",
    "\n",
    "# print the value of `jan` to check that its value has changed\n",
    "print(jan)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congratulations - you have created your first `Python` variables of this course!\n",
    "\n",
    "## <i class=\"fa fa-pencil-square-o\" aria-hidden=\"true\"></i> Optional Challenge \n",
    "\n",
    "Test your `Python` skills to:\n",
    "\n",
    "1. Create new variables for monthly average precipitation values (inches) for July through December (hint: `jan = 0.70`).\n",
    "\n",
    "2. Use the appropriate arithmetic operator to convert the monthly variables for `july` to `dec` from inches to millimeters (1 inch = 25.4 mm) (hint: `jan = jan * 25.4`).\n",
    "\n",
    "3. Print the values of `july` and `dec` to check that the values have changed (hint: `print(jan)`).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "Python [default]",
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}