2 - basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2 - Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python\n",
    "\n",
    "Python is a high level programming language. A high level programming language is a programming language that is closer to English than bits and bytes. \n",
    "\n",
    "### What can you do with Python?\n",
    "\n",
    "You can do math!\n",
    "\n",
    "To run the code cell below, select the cell and press the _Cntrl_ key and the _Enter_ key at the same time. You can also press the _Shift_ and _Enter_ keys at the same time. Another way to run the code cell is to press the _Run_ button at the top of the screen. Feel free to try some of your own math using other operators such as minus ' - ', multiply ' \\* ' and  divide ' / ' !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3+8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modules\n",
    "\n",
    "Sometimes you want to use code that has already been written. You can do this by using the import command. Python has a lot of useful code grouped by function/use; these are called libraries.\n",
    "\n",
    "For example, the library used in the cell below, 'numpy', has many math constants and functions already defined. Let's import the numpy libray and alias it (or nickname it) as np. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access constants and functions in a library, write the library name followed by a period and the name of the constant/function.\n",
    "\n",
    "In the example below, we will display the constant value pi to the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an example of a library function. The np function 'round\\_' is used to round a decimal value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.round_(1.234)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using a library, documentation is always your best friend. You can read more about numpy's mathematical constants and functions in it's reference documentation [here](https://docs.scipy.org/doc/numpy-1.13.0/reference/routines.math.html)!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color:blue\"> Exercise 1.1 </span>\n",
    "\n",
    "Now it's your turn to try out some of numpy's functions! Here are some tasks:\n",
    "\n",
    "1. The integer below represents a measurement in degrees. We would like to convert that into radians, but don't want to do all the tricky math! Find a function in the numpy documentation linked above that converts degrees to radians.\n",
    "\n",
    "    * **NOTE:** Make sure you ran the _import numpy as np_ cell\n",
    "    \n",
    "    \n",
    "2. Now that degrees has been converted to radians, we can apply trigonometric equations to it! Use your result from part 1 as input for numpy's cosine equation. The expected output should be 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Do your work here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "You can assign names to values! This is useful if the values change or you use the value more than once. In the cell below, the values of epsilon0, charge and radius are stored as variables and are used to calculate the force variable.\n",
    "\n",
    "Special Notes: \n",
    "- the '\\*\\*' in the force equation represents an exponent (for example: 2\\**2 in python is the same as 2^2 in math) \n",
    "- the hashtags are comments! They are used to explain what is happening in the code. They do not effect the code at all.\n",
    "- <span style=\"color:green\">e</span> is another way of expressing base 10 exponents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "epsilon0 = 8.85e-12  # C^2 / N m^2\n",
    "charge  = 9e-9       # C\n",
    "radius  = 2e-3       # m \n",
    "force   = 1./(4*np.pi * epsilon0) * charge**2 / radius**2\n",
    "force"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color:blue\"> Exercise 1.2 </span>\n",
    "\n",
    "Lets make some more physics equations! This time we will create a variable (F) for [Newton's equation for universal gravitation](https://en.wikipedia.org/wiki/Newton%27s_law_of_universal_gravitation). \n",
    "\n",
    "Given:\n",
    "* the mass of the Earth (5.972 × 10^24 kg)\n",
    "* the mass of the moon (7.347 × 10^22 kg) \n",
    "* and the average distance of the moon's orbit around the Earth (384,402 km)\n",
    "* the Gravitational constant (G) (6.674 × 10^−11 m^3/(kg x s^2))\n",
    "\n",
    "Find the average force of gravitational attraction between the Earth and the moon! Create a variable for each given value and create a force equation (F) using these variables!\n",
    "\n",
    "<img src=\"infiles/Gravity.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create your variables here!\n",
    "\n",
    "\n",
    "# include your equation here\n",
    "F = \n",
    "\n",
    "print(F)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Types\n",
    "\n",
    "Variables in python have a 'type'. This is to show what kind of data is stored in the variable. The different types include:\n",
    "\n",
    "- Boolean Types\n",
    "- Numeric Types\n",
    "- String Types\n",
    "- List Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boolean Types\n",
    "\n",
    "Booleans can have only two possible values: True or False. These types are useful when you want to add a flag to a computation. \n",
    "\n",
    "For example, let's say you wanted to keep track of which of your particles were electrons. Then you could use Boolean flags for that. (FYI: a particle with the mass and absolute value of charge of an electron is a positron, or an anti-matter electron.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mass = 5.11e-31    #kg\n",
    "charge = -1.6e-19  #C\n",
    "isElectron = True  # this is my electron\n",
    "\n",
    "mass = 5.11e-31 #kg\n",
    "charge = 1.6e-19   # C\n",
    "isElectron = False # this is my positron"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also create mathematical expressions that represent true and false values. One of the most commonly used are **relational operators**, such as:\n",
    "* _==_ (equals) \n",
    "* _!=_ (does not equal)\n",
    "* _>_ (greater than)\n",
    "* _<_ (less than)\n",
    "* _<=_ and _>=_ (less than / greater than or equal to)\n",
    "\n",
    "Run the code boxes below and predict what Boolean values are returned!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 > 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# notice that testing equality uses two equal signs \n",
    "# (one equal sign is for variable creation/mutation)\n",
    "3 == 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(3 ** 3) / 9 >= np.sqrt(16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numeric Types\n",
    "\n",
    "There are two types of Numeric Types: Integers and Floats. Integers are the same as integers in math. Floats are simply numbers with decimals.\n",
    "\n",
    "What Numeric type would the force variable from earlier be? \n",
    "Use the type command below to check your answer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(force)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String Types\n",
    "\n",
    "String types are variables that hold text. You show that the data is text by surrounding it with either single or double quotes. Example: 'cheese' or \"cheese\" are both valid strings.\n",
    "\n",
    "#### <span style=\"color:blue\"> Mini Exercise! </span>\n",
    "\n",
    "Try making a string, name, that names the electron \"electron\" the positron \"positron\" in the above example. (or go madlibs style!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mass = 5.11e-31    #kg\n",
    "charge = -1.6e-19  #C\n",
    "isElectron = True  # this is my electron\n",
    "\n",
    "# add your string here\n",
    "name = \"\"\n",
    "\n",
    "print(\"This item is an \" + name)\n",
    "print(\"An \" + name + \" has a mass of\", mass, \"kg and a charge of\", charge, \"C\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mass = 5.11e-31 #kg\n",
    "charge = 1.6e-19   # C\n",
    "isElectron = False # this is my positron\n",
    "\n",
    "# change the string here\n",
    "name = \"pancake\"\n",
    "\n",
    "print(\"This item is a \" + name)\n",
    "print(\"A \" + name + \" has a mass of\", mass, \"kg and a charge of\", charge, \"C\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List Types\n",
    "\n",
    "A list stores a collection of values seperated by commas. They start and end with square brackets. The list energy_kcal below holds several floats. \n",
    "\n",
    "To get the length of a list, use the 'len' function!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "energy_kcal = [-13.4, -2.7, 5.4, 42.1]\n",
    "length = len(energy_kcal)\n",
    "print('The length of this list is', length)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But what if we want to get a particular value from the list? We can access an item using an **index**. The index is the position in the list where the value is stored. \n",
    "\n",
    "**IMPORTANT!** Counting the index starts at **zero**.\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(energy_kcal[0])\n",
    "print(energy_kcal[1]) \n",
    "print(energy_kcal[2]) \n",
    "print(energy_kcal[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index values in a list can be changed, or **mutated**, just like variables can be changed! Just access the index and set it equal to something else!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Before changing the values:\", energy_kcal)\n",
    "\n",
    "# changing the first value to a string because why not?!?\n",
    "energy_kcal[0] = \"Hello World!\"\n",
    "\n",
    "print(\"After changing the value at index 0:\", energy_kcal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# multiplying the second item in the list by 4.1\n",
    "energy_kcal[1] = energy_kcal[1]*4.1\n",
    "\n",
    "print(\"After changing the value at index 1:\", energy_kcal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Casting\n",
    "\n",
    "What if the variable is the wrong type?\n",
    "\n",
    "Say for example what if we add two strings that are supposed to represent numbers?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'3' + '7'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What actually happend was string concatenation. This is when one string is added to the end of another. To get the value of 3 + 7, we need to use casting. Casting is the act of changing a variable's type.\n",
    "\n",
    "Using the float function, we can change the string '5' into the float 5.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('The type and value of the label variable:')\n",
    "label = '5'\n",
    "print(type(label))\n",
    "print(label)\n",
    "\n",
    "print('\\nAfter casting the label variable to a float:')\n",
    "\n",
    "label = float(label)\n",
    "print(type(label))\n",
    "print(label)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# adding strings with integers\n",
    "a = '3'\n",
    "b = '7'\n",
    "\n",
    "int(a) + int(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# adding strings with floats\n",
    "c = '5.7'\n",
    "d = '3.14'\n",
    "\n",
    "float(c) + float(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color:blue\"> Exercise 1.3 </span>\n",
    "\n",
    "We've covered a lot of material! Let's see how much you remember!\n",
    "\n",
    "We have a list that has a couple of problems with it. (run the cell below)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [2.14159 , \"9.81\", \"euler\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to use the numpy function _sum_ to take the sum of all the values in my_list, but the values are not in the correct format. Do the following operations to fix the variables in the list:\n",
    "\n",
    "1. Add 1 to the first value\n",
    "2. Cast the type of the second value as a float \n",
    "3. Change the third value to euler's number ( [use the numpy constant](https://docs.scipy.org/doc/numpy/reference/constants.html) ) ! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mutate the list here!\n",
    "my_list[] = \n",
    "my_list[] =\n",
    "my_list[] = \n",
    "\n",
    "# Let's make some math soup!\n",
    "# call np.sum on my_list here!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For Loops\n",
    "\n",
    "What if you want to access every element of a list in order? We can use a _for loop_ to acheive this. The for loop below iterates over the energy_kcal list. It starts from the beginning of the list (0-index) and goes until the end of the list. \n",
    "\n",
    "Inside the _for loop_ is the action we want to do for each item in the list. In this _for loop_ below, each value in enery_kcal is multiplled by 4.184 and printed. See for yourself!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "energy_kcal = [-13.4, -2.7, 5.4, 42.1]\n",
    "\n",
    "for number in energy_kcal:\n",
    "    kJ = number*4.184\n",
    "    print(kJ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the code inside the for loop is indented. Indentation is **very important** because it tells the python interpretor what code will be run in the loop.\n",
    "\n",
    "If we want to save these calculations, we can create a new list to store them in. A new list variable can be created by setting a variable equal to empty square brackets (energy_kJ). \n",
    "\n",
    "To add the new calculations to this list, use the append function. This adds the new values to the end of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "energy_kJ = []\n",
    "for number in energy_kcal:\n",
    "    kJ = number*4.184\n",
    "    energy_kJ.append(kJ)\n",
    "\n",
    "print(energy_kJ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Say you wanted to change each number in the list based on its position in the list. The for loop is great for that. \n",
    "\n",
    "We can index the list using a by using [enumerate](http://book.pythontips.com/en/latest/enumerate.html) and then add a value that depends on the index. Note that enumerate returns the position in the list, but that we can still get the number from the list all in the same line. It's the same as if we used idx to index the list, as you can see in the print statement.\n",
    "\n",
    "Note that we use the += operation in our loop. This tells python to add the new value to the old value. So x += 3 is really $x = x + 3$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for idx, number in enumerate(energy_kcal):\n",
    "    # let's say I ate (positive) or burned (negative) \n",
    "    # idx of each item in my list.\n",
    "    kcal_i_ate += number * idx\n",
    "    print(idx, number, energy_kcal[idx], kcal_i_ate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional Statements\n",
    "\n",
    "What if we only wanted to run certain lines of code _sometimes_. We can use **conditional statements** to run code when certain conditions are met. Let's first examine **if statements**.\n",
    "\n",
    "An **if statement** includes a boolean expression, which is something that is either true or false. If the expression is true, the **indented code** below the if statement will run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if True:\n",
    "    print(\"this will run\")\n",
    "\n",
    "if False:\n",
    "    print(\"this will not run\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# what stuff will print out?\n",
    "x = 2 + 3\n",
    "\n",
    "if x > 0:\n",
    "    print(\"this runs\\n\")\n",
    "\n",
    "if x == 20:\n",
    "    print(\"but this doesn't :(\\n\")\n",
    "\n",
    "print(\"that's all folks!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, you will want some other code to run when a condition is not true. That's where **else statements** come in handy! The code below an **else statement** is run only if the **if statement** above is false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# try changing y to different negative and positive values\n",
    "\n",
    "y = 20\n",
    "\n",
    "# the code below makes y positive if it is negative\n",
    "# otherwise it adds 5 to y\n",
    "\n",
    "if y < 0:\n",
    "    y = y * -1\n",
    "else:\n",
    "    y += 5\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's do one more example with loops. Let's say you want to split the energy_kcallist into two lists of positive and negative numbers. Using an else statement we can put the negative numbers in a seperate list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(energy_kcal) # for reference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "positives = []\n",
    "negatives = []\n",
    "for number in energy_kcal:\n",
    "    if number > 0:\n",
    "        positives.append(number)\n",
    "    else:\n",
    "        negatives.append(number)\n",
    "        \n",
    "print(positives)\n",
    "print(negatives)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color:blue\"> Exercise 1.4 </span>\n",
    "\n",
    "Now this problem will surely throw you for a loop! Let's say we have a list of integers and we want to find its mean. We could use a function from a stats library (this would actually be better), but we really enjoy using for loops! \n",
    "\n",
    "Here's our list below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "broken_list = [1, 2, \"muhahaha!!!\", 3, 4, \"you can't use this list! >:D\", 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oh no! Someone added strings to our list which will mess up our calculations! We should clean this list up before attempting to use it. Make a loop that stores all the integers in a new list (conveniently named integers).\n",
    "\n",
    "* **HINT!** [Use the _isinstance_ function](https://codeyarns.com/2010/01/28/python-checking-type-of-variable/) to check types! (returns a boolean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "integers = []\n",
    "for x in broken_list:\n",
    "    # make an if condition below"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now calculate the mean of the integers list. Don't just type in each integer from the list to calculate their sum! You should create a for loop that adds up every integer and stores the result into _my_sum_. Then divide by the length of the list using the list function _len_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statistics as s\n",
    "\n",
    "my_sum = 0\n",
    "\n",
    "# make your for loop here\n",
    "\n",
    "# calculate mean \n",
    "my_mean = \n",
    "\n",
    "# check if your answer is correct\n",
    "my_mean == s.mean(integers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color:blue\"> Challenge! </span>\n",
    "\n",
    "Using your previous calculations and more for loops, calculate the standard deviation of the cell!\n",
    "\n",
    "<img src=\"infiles/sd.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Want to try writing your own code? Click the + button in the tool bar above to add a new coding cell!\n",
    "\n",
    "Interested in learning more? Click [here](https://docs.python.org/3/tutorial/index.html)!"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}