1_PythonIntroduction.ipynb

{
  "cells": [
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "markdown",
      "source": "\n\n## An Introduction to Python for Physicists"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "markdown",
      "source": "This lesson teaches the basics of Python and its usefulness to us as physicists. "
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### Getting started with Python\n\nPython is an extremely versatile, straightforward coding language. This allows many people to use it and contribute across many different disciplines. Python is also absurdly high-level, which means many aspects of coding are taken care of behind the scenes, allowing it to read almost like English. Programming is an essential skill for any aspiring physicist, as it greatly increases our capacity to perform computations and data processing in a relatively short amount of time. "
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### Getting started with Jupyter\n\nThroughout this workbook, you'll see sections of code in executable code. All are meant to be run, and some may require you to write or modify code yourself in order for them to work. In order to execute a block of code, click inside the box and then either press \"Run\" at the top of your screen or press Shift-Enter together."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### The Basics of Python: Variables and Computations, Input and Output"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### 1.1 Variables\n\nComputing languages use *variables* to store and manipulate data. We'll learn about four common variable types in Python:\n - Strings `string`\n - Integers `int`\n - Float `float`\n - Booleans `bool`"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "A string is a word or a sentence or a conglomeration of letters and numbers. It's literally a *string* of characters, so you can put pretty much anything in it; put double quotes around it to mark it as a string."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "\"hi\"",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Integers and floats are both numbers. The difference is a float is allowed to have a decimal point. For example, `5` can be an integer or a float, but `5.0` must be a float. Write an example of a float below."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Finally, a boolean is a variable with only two options: `True` or `False`. These will be used more in conditional logic, which we'll talk about later."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can create variables of any of these types to store information. For example, we can name one variable `x` and one variable `y`, and assign values to these variables:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x=3\ny=2",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "And we can create a third variable, `z`, from the combination of `x` and `y`:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "z=x+y",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Now you try! Create a `string` below and assign it to the variable `name`:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "name=",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "When you choose variable names, make sure to select ones that make sense and provide information about their use. Python is case-sensitive, so the variable `name` is *different than* the variable `Name`. Generally, if you want to name a variable something with multiple words, separate the words with an underscore, as follows:\n\n`favorite_food`\n\nConventions like these help other people and potentially you read and understand your code better."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### 1.2 Print Statements\n\nBefore we are able to begin any math, we need a way for the computer to be able to talk to us. We call the results of any program we write the \"output\". One way to produce output is through Python's `print` statement. This print function allows us to write something to our computer screen with the following format:  \n\n`print(\" *insert here* \")` \n\nSo, if you want to say \"`Hello World`\", "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": " print(\"Hello World\")",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "You can print any of the basic variables, and you only have to put quotes `\"\"` around strings. Let's print an integer! Write your age in the `print` statement below."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Let's retrieve the information we stored earlier in the variable `z`."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(z)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The computer may have given you an error here. Errors indicate that you've written something that the computer can't understand. This may be a syntax mistake or a wrong type, like if you tried to divide a string by an integer. In this case, that would be because you didn't run the code above to store `x`, `y`, and `z`. If you run that code and then come back here, the error should be resolved.\n\nNow, let's try to do calculations within the print statement. Can we add two integers and print out the result?"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(2+1)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print (2-1)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can add and subtract inside a print statement just as well as with variables. \n\nCan you add two strings? *When adding strings, quotes (\" \") must go around each separate string, **not** the plus sign.*"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print (\"Yes, \" + \"you can\")",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "What about subtraction?"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(\"NO\" - \"you cannot\")",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The error tells us that we've tried to do something the computer doesn't understand: subtract strings. This is a `TypeError`, indicating that you might've mixed up the types of variables you've used. Other common errors you may encounter include:\n- Syntax Error: This is the coding equivalent of bad grammar. Perhaps you added an extra parenthesis or forgot a quotation mark?\n- Runtime Error: This could be any number of things; perhaps you called a string an integer or vice versa. \"Runtime\" just means it looked fine to the computer, and the error didn't occur until it actually had to run the code.\n- Logic Error: These will not show up as error messages. This category includes anything that might throw your calculations off even if the code executed perfectly, like if you miswrote the area for a triangle as `base*height*2`. These are the hardest to catch!!\n\nPay attention to error messages; they can help you figure out what you did wrong."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can also use a comma to add two strings:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(\"Galileo\",\"Newton\")",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Now see what happens when you write two different print statements:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(\"Electricity and\")\nprint(\"Magnetism\")",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Try some Multipication and Division down below."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Python also allows multiplication of strings and integers. This feature is fairly unique to this language and won't often be needed in your studies; however, you should try it out down below. We're retrieving the variable `name` you assigned earlier and multiplying it..."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(name*100)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### 1.3 Input\n\nWhile the `print` statement displays output, we can also read in input with the `input` command. This command can take no parameters, as follows:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "input()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Or, it can take a parameter that prompts the user:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "input(\"What's your favorite color? \")",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "If you want to make sure the input is a certain type, you can do what's called \"casting\" to that type."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "int(input(\"Integer (whole number): \"))",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "If the user gives the wrong input type, the program will throw an error. Try running the above cell again, and this time give it a `string` or `float`. You'll get a `ValueError`, which is similar to a `TypeError`."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Now, ask the user to input their name and age, and type-cast their age to a `float`:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Ask the user to input the number of siblings they have, and print out that number multiplied by 3."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Before we continue, let us briefly introduce the comment. A comment explains your code and is ignored by the computer. One line of comment is preceded by a `#`:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "#Here is my comment, explaining what I'm doing\n\n#Another comment line\n#You can have as many as you want!",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "It's good practice to comment liberally on your code, so others can understand what you're doing."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### 1.4 Computations\n\nPrograms are immensely useful for performing computations. Expressions are evaluated according to the order of operations, which is, in order from highest to lowest precedence:\n1. Parentheses `(` `)`\n2. Exponents `x**y` (equivalent to $x^y$)\n3. Multiplication and division `x*y` or `x/y`\n4. Addition and subtraction `x+y` or `x-y`\n\nOther calculation functions, like `math.sqrt()`, can be found on your function cheat sheet."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "For the following problems, write out the equation and assign it to a variable, then print out the result. You may use as many intermediate variables as needed."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "$$4+3*\\frac{7}{2}$$"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "$$6.21*10^{4+1}$$"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "$$\\sqrt{3+2\\left(4^2*7\\right)}-36$$"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Leave this next line here. It lets you use math.sqrt()\nimport math",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### 1.5 Booleans\n\nIf this is your first exposure to programming, booleans are likely the least familiar variable to you. A boolean variable has a binary state, either `True` or `False` (this is analagous to a 1 or 0 on a computer bit, or the \"on\" or \"off\" state of a light switch). Booleans can be combined in various ways, but they cannot be combined with any other variable types, and the operators used are somewhat different for booleans.\n\nThe simplest operations for booleans are `not`, `and`, and `or`, with that order of operations. These are as follows:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(True)\nprint(not True)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The `not` operator flips a boolean, from `True` to `False` or vice versa. It will be evaluated first."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(True and True)\nprint(True and False)\nprint(False and False)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The `and` operator returns `True` if and only if *both sides* evaluate to `True`."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(True or True)\nprint(True or False)\nprint(False or False)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The `or` operator return `True` if *at least one* side evaluates to `True`."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We don't have to literally code `True` or `False`, however. Certain statements can be *evaluated* to a boolean, like the following:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(12 > 10)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(4 == 4)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Note the double equals sign. `==` is used in boolean evaluations, whereas `=` is used to assign variables.\n\nWe can also check **not equals**, with the `!=` operator."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(1 != 1)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "And we can combine these statements with `and` and `or` just the same as `True` and `False` themselves."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "a = 1\nprint(2 < a and a < 4)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = 10\nprint(x%5 == 0 or x%3 == 0)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The `%` above means modulus; it's the remainder from division. If `x%3 == 0`, then `x` is evenly divisible by 3.\n\nKeep these rules in mind; they will be vital to our study of conditionals later."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "markdown",
      "source": "### The Basics of Python: Functions, Conditionals, and Loops"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "In this section we'll make use of some libraries. These are explained in section 3.1, and if you want, you can check that out now and return here. \n\n**Run this next block of code** so we can access the `math` and `random` libraries throughout the next several sections. If you leave the notebook and return later, **re-run this block** so your code will work properly."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "import math\nimport random",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### 2.1 What is a Function\n\nCoding used to be a long line of instructions executed sequentially. To make it more efficient, programming languages started to introduce *functions*, which are a way to package several commands into one. \n\nLet's take this out of the context of coding. If you want to make a PB&J sandwich, you might put down a piece of bread, then peanut butter, then jelly, then another piece of bread. This could look like the following code:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "def make_sandwich():\n    sandwich = \"bread\"\n    sandwich += \" and peanut butter\"\n    sandwich += \" and jelly\"\n    sandwich += \" and bread\"\n    return sandwich",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "There's a couple important points to note about the syntax above. A function is marked by the key word `def` and it must have a colon `:` after the name. Each line that is part of the function **must be indented** to show the program how it's intended to be executed. Also, a function often ends with a `return` statement, which gives the end result of the function.\n\nThe `+=` sign indicates concantenation, which means adding on to what's already there. If you want more explanation on that or any other symbols, refer to your function cheat sheet.\n\nOnce you define a function, you can \"call\" it later on in your program. You call it just by writing its name, as so:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "make_sandwich()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "If the function has a return value, then you can assign that value to a variable of your choice, which can be used later. For example, here we assign it to the variable `lunch` so we can print out the return value of the function."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "lunch = make_sandwich()\n\nprint(\"I am eating\", lunch)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Functions allow for your code to have better organization, flexibility, and reusability. If you wanted to change how you made your sandwich, perhaps by adding jam to one piece of bread and peanut butter to the other piece, and then combining them, you could rewrite the `make_sandwich()` function without touching any other code."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "##### Another Example\n\nLet's try a more mathematical example: calculating the area of a circle. If we were doing this without a function, we have three essential portions of the calculation: \n - One defining the radius of the circle\n - One calculating the area from the radius\n - One printing the result of the calculation\n\nRecall the formula for area of a circle:\n$$a_{circle}=\\pi*r^2$$\n \nFor our calculation, we need to know two pieces of syntax we have not yet encountered.\n1. We get the value of pi from the library `math`, which can be accessed either from import statement or by writing `math.pi` as shown below.\n2. Powers can be calculated with the `**` operator, or alternatively with the method `math.pow`. **DO NOT USE the `^` operator.** That's a completely different binary operation and will give you an incorrect answer.\n \nThis code might be done with one line or four, as shown below. That's up to personal preference and the particular needs of the program. "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "#This is a way to access a specific part of a library. See 3.1 for details.\nfrom math import pi\n\nradius = 10\narea = pi * radius**2\nprint(\"The area of circle with radius\", radius, \"is\", area)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(\"The area of circle with radius\", radius, \"is\", math.pi * (10)**2)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Check with a friend, a calculator, or Google to make sure you've got the right answer."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We are, however, still one step away from a complete function. We *can* create a function just by dropping all our code from above into a `def`, which we'll call `area_circle`."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "## Define the function\ndef area_circle():\n    radius = 10\n    area = math.pi * radius**2\n    print(\"The area of circle with radius\", radius, \"is\", area)\n    return\n\n## Call it\narea_circle()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Note that this time, the return statement of the function is blank. This is the same as not including a `return` at all, and it's called a `void` function. \n\nIn functions that return a variable, like a `string` or a `float`, calling `print(function())` will print out the return variable. In this case, the return variable is not specified, and a print statement will show this as `None`."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(area_circle())",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The first line is the output within the function, and the second line is the result of printing the return type. In the absence of any specifications on the return type, it simply returns `None`."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Now we're going to add a parameter to our function. This goes in the parenthesis by the function name, and allows us to give the function input. Our parameter will represent the radius of the circle, so we'll have to define that outside our function."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "## Define the function, for the second time\ndef area_circle(radius):\n    area = math.pi * radius**2\n    print(\"The area of circle with radius\", radius, \"is\", area)\n    return\n\n## Call it\nr = 10\narea_circle(r)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Note that we called our variable outside the function `r`, and we called the parameter `radius`. `r` is \"passed in\" to the function as the paramater `radius`, but they don't need to be called the same thing for that to work.\n\nThe benefit of parameters is having more flexible code. You could define this function once and call it as many times as you need to, with a different radius each time. Below, call it with a different radius:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "## Call area_circle with a radius of your choice:\n\n",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We've given our function input, now let's give it output. We'll give our function a *return type* of the area of the circle. We can print the result outside of our function instead."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "## Define the function, for the third and final time\ndef area_circle(radius):\n    area = math.pi * radius**2\n    return area\n\n## Call it\nr = 10\narea = area_circle(r)\nprint(\"The area of circle with radius\", r, \"is\", area)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We've now achieved the same output *five* different ways. \n- Without a function, with four lines\n- Without a function, with one line\n- With a function, no parameters and no return value\n- With a function, one parameter and no return value\n- With a function, one parameter and a return value\n\nGood job! Of all these ways, different ones will be useful in different circumstances. If you need to find the area for many different radii, one of the last two would be much more useful, but if you only needed to do it once, any of the five would be sufficient. This happens frequently in programming. Functions are one way to organize your code but they are never the only way to do something."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Now is your turn! Write a function to calculate the area of a cone with the paramters `radius` of 4 and `height` of 12. You can pass in two parameters in by separating them with commas, like so:\n\n`def function(one, two)`"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Write a function (or two, if you're feeling adventurous) to calculate the `surface area` of a sphere with an `volume` of 300."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "There is one more thing to note about functions before going forward. When our code gets complicated enough, we may choose to use a more complicated structure called a `class`. You've seen classes before: `math` is a class, and it contains its own functions (like `pow()`) and variables (like `pi`). When a function is a part of a class, we call it a \"method.\"\n\nOften classes are defined with one Main Method that does all the work. These will be named as following:<br>\n`def __main__(self)`<br>\nThe underscores are a python convention, and just part of the name like any other character. The `self` is an extra parameter that must be included for any method in a class, for reasons that only really matter to computer scientists."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "markdown",
      "source": "#### 2.2 If / Else Statements\n\nConditionals, in the form of `if`/`else` statements, allow us to control whether or not things happens. We use booleans to determine this. The basic structure is as follows:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "if True:\n    print(\"This line will execute.\")\nif False:\n    print(\"This line will NOT execute.\")",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The `if` statement evaluates the boolean statement: if `True`, the block indented after it will execute; else, it will not. We can actually use an `else` statement to capture all states not covered by the `if`. Thus, the code block above is equivalent to the block below:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "if True:\n    print(\"This line will execute.\")\nelse:\n    print(\"This line will NOT execute.\")",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "As you should recall from the Boolean section, `True` and `False` can be replaced with statements that evaluate to a boolean. Consider the example below."
    },
    {
      "metadata": {
        "trusted": true,
        "scrolled": true
      },
      "cell_type": "code",
      "source": "avgHousehold = 2.6\nmyHousehold = int(input(\"How many people in your household?\"))\n\nif(myHousehold < avgHousehold):\n    print(\"Your household has fewer people than the average.\")\nelse:\n    print(\"Your household has more people than the average.\")",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Sometimes, we want to evaluate several cases in a row. In such a situation, we can use the `elif` key word for all intermediary statements. The first conditional will be `if` and the last conditional may either be `elif` or `else`, and any middle conditionals should be `elif`."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "avgHousehold = 2.6\nmyHousehold = float(input(\"How many people in your household?\"))\n\nif(myHousehold < avgHousehold):\n    print(\"Your household has fewer people than the average.\")\nelif(myHousehold == avgHousehold):\n    print(\"Your household has exactly the average amount of people.\")\nelse:\n    print(\"Your household has more people than the average.\")",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Example: The following code allows you to input a number, and compare it to a computer-generated random number between 1 and 10. Try inputting numbers that trigger each response (a good way to debug your code)."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "def doTheyMatch(yourNum):\n    if yourNum < 1 or yourNum > 10:\n        print (\"Try a number in the range\")\n        \n    else:\n        correctNum = random.randint(1,10)\n        if yourNum == correctNum:\n                print(\"They match\")\n        else:\n                print(\"They do not match\")\n                \n    return \n    \n   ",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "doTheyMatch()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "doTheyMatch()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "doTheyMatch()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Write a function called whatIsMyGrade to determine the letter grade of 92, 60, and 72"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Write a function involving if/else loops to categorize the stars below by their letter\n- star with temperature of 6,500K\n- radius seven times the sun \n- star with luminosity 0.4 times the sun \n- star with temperature over 25,000K\n\nPlease include all of the luminosity, temperature, and solar mass classifications"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "def star ( , , , ):\n  \n\n\n    return ",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### 2.3 Loops\n\nI need to display my age 25 times! How can I do this? I could `print(\"I am 20 years old\")` 25 times..... or I can use a loop! Loops are helpful when processing large amounts of data (like we will later). There are two types of loops fundamental for programming: the `while` loop which is boolean (true/false) based, the `for` loop which is count based (for a certain number of times). Examples of each are below."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "#While Loop \n\nsum = 0\ni = 1\n\nwhile i < 10:\n    sum = sum + i #can also be written as sum += i\n    i = i + 1\nprint('The sum is',sum)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "I wonder what happens when you put the print statement inside the loop..."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "#While Loop \n\nsum = 0\ni = 1\n\nwhile i < 10:\n    sum = sum + i\n    i = i + 1       # can also be written as i += 1\n    print('The sum is',sum)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Here is an example of a `while` loop:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "i = 0\n\nwhile i < 6:\n    print(\"i value is \",i)\n    i+= 1",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "This `while` loop can then be written as what's called a `for` loop, as shown below. `For` loops automatically iterate through a collection like a range of numbers, 0 to 6. "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "#For Loops \n\nfor i in range(0,6):\n    print(\"i value is \",i)\n",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Can you see the comparisons? Lets talk about them to make sure you have an understanding. With the for loop, there is no need to declare the variable itself. The for loop does it for us. Do you see where the 0 and 6 are in the while loop? Even though they are not next to each other, these are initial value, and end value. In the for loop, they are right next to each other, making it easier to count. Another factor of the for loop is it counts (ups the value of i) within the loop itself. While the for loop (in this case) is half the amount of code as the while loop, it ultimately depends on the code you are writing to determine which to use."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We see, then, that if we wanted to print our name 25 times, this would only take two lines of code with a loop:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for i in range(0,25):\n    print(\"I am 20 years old\")",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Thus, for repetitive actions, loops can simplify your code immensely."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Write a function without recursion to give an answer for 27! (27 factorial)"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "def factorial(number):\n    \n    return",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Write a function that computes the total cost of four year's worth of tuition starting 12 years from now. This yearly tuition is $14,000 and increases seven percent annually."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "def computeTuition(years)\n\n    return",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Write a nested `for` loop that displays the following data (no need for a function). \n * Use three for loops to display the pyramid below \n\n                              1\n                         1    2   1\n                     1   2    4   2   1\n                 1   2   4    8   4   2   1\n             1   2   4   8   16   8   4   2  1 \n          1  2   4   8  16   32  16   8   4  2  1\n       1  2  4   8  16  32   64  32  16   8  4  2  1 "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "markdown",
      "source": "#### 2.4 Recursion\n\nA recursive function is best described as a function that calls itself. This type of loop (and the last we'll learn) is one of the hardest to comprehend and program. It's very easy to get caught up in these loops, so let's take some time to learn them. "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "markdown",
      "source": "Let's use the factorial example. You were able to do it with a `while` or a `for` loop, correct? Programming is about efficiency, in both writing and executing code. Fewer lines often means fewer opportunities for bugs, so a short function like that shown below is a good programming strategy."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "def factorial(n):\n    if n == 0 :\n        return 1\n    else:\n        return n * factorial(n-1)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "factorial(27)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Same number right? (or it should be). Let's walkthrough what exactly is happening. The first if statement we have is our stopping function. This is the condition to exit our recursive loop. In our function, we are subtracting 1 from n, meaning at some point it will hit zero. This is called a \"base case\". If we didn't have it, the function would run forever and will crash the computer, or it will return an error. The else statement is where the main body of our code exists. With n == 4, try tracing out the path of the code yourself before we discuss it. "
    },
    {
      "metadata": {},
      "cell_type": "raw",
      "source": "Now that you've drawn it, let's compare.\n\ndef factorial(4):                                                                      Results\n    if n == 0 :\n        return 1\n    else:  \n        return 4 * factorial(3)                                                        4 * ( 6 )\n                       |\n                       |\n                       V\n                   if n == 0 : \n                       return 1\n                   else:\n                       return 3 * factorial(2)                                         3 * ( 2 )\n                                      |\n                                      |\n                                      V\n                                  if n == 0 : \n                                      return 1\n                                  else: \n                                      return 2 * factorial(1)                          2 * ( 1 )\n                                                     |\n                                                     |\n                                                     V\n                                                 if n == 0 : \n                                                     return 1\n                                                 else: \n                                                     return 1 * factorial(0)           1 * ( 1 )\n                                                                    |\n                                                                    |\n                                                                    V\n                                                                if n == 0\n                                                                    return 1           1\n    "
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Do they match? I hope so. Recursion keeps going until it hits the stopping point, then traces itself back to the original call. Think of the stopping point as a road block. Once you hit it, you have to retrace your route back to where you started.\n\nLet's walk through another example, this one is a little more complicated. Remember, if you see something we haven't talked about (syntax or a function) please refer to the FunctionList we have provided. "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "def isPalindrome(s): \n    ## Base Case\n    if len(s) <= 1 :  \n        return True  \n    \n    ## Base Case\n    elif s[0] != s[len(s) - 1] :\n        return False    \n    \n    ## Recursive Call\n    else: \n        shorter_s = s[1 : len(s)- 1]\n        return isPalindrome(shorter_s)\n    \nisPalindrome(\"Physics\")",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Let's clarify the syntax above. If you haven't looked at the FunctionList, `len(x)` is a function that returns the length of any string (counting characters). For example, 'try' would have a length of three. Secondly, using brackets returns a specific spot within a string. Since computers begin counting at zero and if `s = 'try'`\n- `s[0]` = 't'\n- `s[1]` = 'r'\n- `s[2]` = 'y'\n\nPutting two numbers (indices) in the brackets, separated by a colon, takes the portion of the word beginning at the first index and ending right before the second index. Thus, `s[1 : len(s) - 1]` chops off the first and last characters of the string. Then we'll pass in the shorter string to test if that portion is also a palindrome. If this is still confusing, skip down to 3.2 Lists for further clarification.\n\nWith these in mind, let's run the function on another word. Pick your favorite palindrome and pass it in as a paramater to the function in the box below."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "markdown",
      "source": "Now explore the code in the function. Trace the palindrome as it would pass through the function on a spare sheet of paper (this will not be graded) until you understand more or less how the function works. In the box below, write your understanding; you will not be graded based on accuracy but on completion and effort, but the more you understand this example, the easier things will be later on."
    },
    {
      "metadata": {},
      "cell_type": "raw",
      "source": ""
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "My explanation of the code is as follows. \n\nThe function isPalindrome works by checking whether the first and last characters are the same. If they are not, no more work need be done; the function just returns `False` to indicate the word is not a palindrome. If they are, the function chops off the first and last letters and tries again with the shorter string, until either it finds that it is not a palindrome or the string is only 0 or 1 characters long. If the program gets to the point where the string is 0 or 1 characters long, the string has been confirmed to be a palindrome, and it returns `True`.\n\nFor example, consider the string 'mom'. When 'mom' is passed in to the function, it is first checked to see if it is 0 or 1 characters long. (Every 1-character-long word is a palindrome.) Since it is not, the program continures and checkes if the first and last characters are not equivalent. 'm' and 'm' _are_ equivalent, so the function continues past that conditional. It calls itself, this time with the shorter string 'o'. This string is 0 or 1 characters, so `isPalindrome('o')` returns `True`. `isPalindrome('mom')` returns what `isPalindrome('o')` returns, so we get an answer of `True`.\n\nI hope you both understand what's going on and are able to explain it in layman's terms. Both skills are important for a physicist to be able to build upon others' work and collaborate with other physicists.\n\nNow, a problem for you to tackle."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Write a recursive function that displays the Greatest Common Demoninator between two integers. Test your function with the following pairs: \n- 36 and 6\n- 84 and 189\n- 3452 and 7532\n "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### The Basics of Python: Libraries, Lists, Files, and Graphs (all the fun stuff!)"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "markdown",
      "source": "In this last section we will learn everything tied to graphs. As physicists, we use graphs perhaps more frequently than anything else covered in this section. Graphs are handy for interpreting data as well as giving us a visual. Before moving directly onto graphs, let's touch on some other subjects, that will make graphing a lot easier."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### 3.1 Libraries "
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We used libraries back in 2.1, but now we'll go more in depth. Python comes with some pre-packaged libraries like those you've seen: `math` and `random`. These libraries are collections of functions and variables that allow Python great flexibility. For example, any Python coder who wants to use a random integer in their program can call `random.randint()` with the appropriate parameters. The alternative would be to write your own random number generator whenever you needed a random number!\n\nAs touched on before, we can access libraries a couple different ways. Although many helpful libraries are installed when you install Python (or, in this case, when Azure Notebooks installs Python), any program using a library must include a reference to that library so the program knows where to look for that function or variable. You've seen these two ways before:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "import math\nprint(math.pi)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "from math import pi\nprint(pi)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The use of the variable `pi` must include a reference to its library, `math`. As you can see, this can be done by adding the prefix `math.` or by including an `import` statement.\n\nYou can import one function from a library:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "from random import randint\n\nprint( randint(-5,5) )",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Or, you can import a whole library:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "import random\n\nprint( random.randint(-5,5) )",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Sometimes, other programmers create libraries that aren't included in the original Python package. Once you download these, you can use them just like the built-in libraries. That's what we'll do when we start graphing."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Your next problem to solve is to fix the following program. All the functionality is there, but the neccessary libraries have not been referenced. You may use any of the above ways to make the program work; however, you cannot delete any code already written.\n\nYou may find your function list cheat sheet to be rather helpful on this problem.\n\n**IMPORTANT:** _Jupyter notebooks run as though all the cells are one big program, so any previously run cells with import statements may allow the below code to run without your help. That is NOT how you will be graded. In order to eliminate the possibility of a false positive while you're solving this problem, do the following:_\n- Push the \"restart the kernel\" button above. It's the circular arrow next to \"Run.\"\n- Do not run any other cells in between restarting the kernel and finishing this particular problem."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = randint(1, 20)\ny = pow(randint(1, 5),2)\n\ndef hypotenuse(a,b):\n    c2 = a**2 + b**2\n    return sqrt(c2)\n\ndef angle_degrees(x,y):\n    radians = atan(x/y)\n    return degrees(radians)\n\ndef circumference(radius):\n    return 2*pi*radius\n\nprint(\"x:\",x,\"and y:\", y)\n\nr = hypotenuse(x,y)\nprint(\"Hypotenuse:\",r)\nprint(\"Angle (degrees)\", angle_degrees(x,y))\nprint(\"Circumference:\", circumference(r))",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "When finished with the reading and assignment above, create a print statement which reads, \"I have read and understand section 3.1.\""
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### 3.2 Lists (Arrays)"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Python allows us to organize our variables in a `list`. Lists typically store objects of the same sort; you may create a list of integers or a list of strings but likely not one with integers and strings mixed together. We're able to treat a `list` much like a variable in itself: we can pass it as a parameter to a function, add lists together, and even make lists containing lists!\n\nWhen we create a list, we can either create an empty list with empty brackets `[]` as shown:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "empty_list = []",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Or, we can create a list and with objects already in it, with objects separated by commas inside the brackets:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "full_list = [4,16,-2,1,3,1]",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Lists DO allow repeated values. We can verify this by seeing that the length of our `full_list` is 6, which includes all the values above, rather than 5, which only includes the unique values."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "length = len(full_list)\nprint(length)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "This `len` command, it should be noted, gives the length of a list or a string.\n\nA related command, `count`, tells us how many times a certain object appears in the list."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "count = full_list.count(1)\nprint(count)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Note the different syntax here. `count` acts on the `list` object and takes the object to search for as its parameter. `len` is a more universal command, and takes the `list` itself as its parameter."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "If we have an existing list that to which we want to add objects to, we use the `.append()` function. Let's take our `empty_list` and fill it up with input from the user."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for i in range(0,5):\n    next_number = float(input(\"Float? \"))\n    empty_list.append(next_number)\n    print (\"My list so far is: \", empty_list)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can access any element from this list through its index. Recall that the first element in a list is referenced by **0**. So the *third* element in the \"empty\" list would be accessed with `empty_list[2]`."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can also take the subset of a list with brackets and a colon.\n\n`list[beginning_index : end_index]` gives us the general form.\n\nThis is **beginning-inclusive** and **end-exclusive**, which means that if we ask for `[0:2]`, we'll get the objects at 0 and 1, but *not* at 2. You may have noticed that ranges work the same way: above, the code `range(0,5)` gave us five numbers: 0,1,2,3,4.\n\nIf we don't write any `end_index`, the subset goes through the end of the list. "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "new_list = full_list[2:]\nprint(new_list)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Here, we've created a new list from the last four elements of our `full_list`. We can also find the maximum and minumum of a list:"
    },
    {
      "metadata": {
        "trusted": true,
        "scrolled": true
      },
      "cell_type": "code",
      "source": "minimum = min(new_list)\nmaximum = max(new_list)\nprint(minimum, \"and\", maximum)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can easily shuffle lists, through the `random` library."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "from random import shuffle\n\nshuffle(empty_list)\nprint(empty_list)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can also add lists together:"
    },
    {
      "metadata": {
        "trusted": true,
        "scrolled": true
      },
      "cell_type": "code",
      "source": "master_list = empty_list + full_list + new_list\nprint(master_list)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "And, just for fun, we can make a list of lists!"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "inception = [empty_list, full_list, new_list]\nprint(inception)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Now your turn! Create two lists, one from `random.nextint()` and one with integer input from the user. Use the function below to calculate half the length of each of the lists, and make a new list combining the first half of your first list and second half of your second list. Then print out this list, with its length, maximum, and minimum. Then print out the last item in the list."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Hint: list of length 6 will return index 3, and the first half of that list would be at indices 0,1,2.\n# List of length 5 will return index 2, and either 0,1 or 0,1,2 would be accepted as the first half of that list.\ndef find_halfway(my_list):\n    length = len(my_list)\n    return length//2\n",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### 3.3 Reading files "
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Taking a huge chunk of data, and beng able to manipulate it is what makes coding a needed skill for physicists. There a few files of data already in our files, so we'll use those for example. The first thing we need to accomplish is opening our file. When we open a file, we assign it to a variable for manipulation. The main setup of opening a file reads like so:\n\n`variableName = open(\"fileName.type\", \"action\")`\n\nThe actions when opening the file are \n - r       : open the file to read \n - w       : open a new file for writing, if the file you called already exists then it overwrites the data\n - a       : open the file to add data to the end of the file\n - x       : create a new file (only works if the file does not already exist)\n - rb      : open reads the binary data \n - wb      : open writes binary data\n \nIf I wanted to write a new file called Horses, the line of code to so would look like `horses = open(\"Horses.txt\", \"w\")`.\n\nTo read a comma-separated file called countriesofEurope, we'd write `countriesEU = open(\"countriesOfEurope.csv\", \"r\")`."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Now that the file is open, there are plenty of tasks we can use to manipulate the open file, like: \n * `write()`      : writes to the file \n * `read()`       : reads the entire file\n * `readline()`   : returns the next line \n * `readlines()`  : returns the remaining lines as a list\n * `close()`      : closes the file. \n \nIf you opened the file with read-only access, with the 'r' action, you will not be able to write to it. The action you use to open the file must match the commands you later call on it. Also, we must call `close()` for every file we open, in order to ensure proper processing. Here are a few examples. Run them to see the differences:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "example = open(\"Example1.txt\", \"r\")\n\nprint(example.read())\n\nexample.close()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "example = open(\"Example1.txt\", \"r\")\n\nprint(example.readline())\n\nexample.close()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "example = open(\"Example.txt\",\"w\")\n\nexample.write(\"Addition\")\n\nexample.close()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "example = open(\"Example.txt\", \"r\")\n\nprint(example.read())\n\nexample.close()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "markdown",
      "source": "Write code that creates a file named `Numbers.txt` . Using a `for` loop and the random integer function, write random numbers from 1 - 10 to the file. Then open the file for reading and print said random numbers."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### 3.4 Graphs "
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The last section! Congratulations on making it this far. This last section builds on the previous parts to teach us to create graphs. To be able to create graphs in python, we will use the pylab library. Before we graph, we will have to have lists of x and y values, either by reading values from a file, hardcoding them into our program, or calculating them from some equation. In the first example below we are hardcoding them into lists. "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = [1,2,10]\ny = [0,3,9]",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The command to create the actual graph is `pylab.plot(x,y)`. Optionally, we can label the axis with the methods `.xlabel()` and `.ylabel()`. All of the steps are combined in the code below."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "#renamed for easier to read code\nimport pylab\n\n#axis values \nx = [1,5,10]\ny = [0,3,9]\n\n#plotting points \npylab.plot(x,y)\n\npylab.title(\"Title\")\npylab.xlabel('x - axis')\npylab.ylabel('y - axis')",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Using the `numpy` library, we are able to plot trigonometric functions and evenly space our axes. "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "import pylab\nimport numpy\n\nx = numpy.linspace(0, 20, 1000) ## Have some fun! Mess around with these numbers\ny = numpy.sin(x)\n\npylab.plot(x,y)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Here are some handy pylab methods.\n * `.xlabel(' ')` : label the x axis \n * `.ylabel(' ')` : label the y axis\n * `.title(' ')` : title your graph \n * `.xlim(a, b)` : limit your x axis to be from a to b\n * `.ylim(a, b)` : limit your y axis to be from a to b\n \nIn the plot function itself, you're able to add additional formatting properties, like so:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "import pylab\nimport numpy\n\nx = numpy.linspace(0, 20, 1000) ## Gave some fun and mess around with these numbers\ny = numpy.sin(x)\n\npylab.plot(x,y, '-r', label='redline')\npylab.legend()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The '-r' specifies a filled in red line, and the label creates the legend shown in the corner (in combination with the call to `pylab.legend()`, which shows the created legend). Additional formats for different colors and linetypes are in the function list in this notebook."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Physicists most often create graphs by importing data. As before, we'll first have to import the pylab library. The next step is to read the file into a list as we've done before. The second line of code imports the file into a list called data:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "b = open('Example3.txt')\ndata = b.readlines()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Our data file contains many lines. Each line contains data in the format \"x,y\". In order to separate out the 'x' and 'y' data pieces, we will split each line into the piece before the comma (`line.split(',')[0]`) and the piece after the comma (`line.split(',')[1]`). "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = [line.split(',')[0] for line in data]\ny = [line.split(',')[1] for line in data]",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Next we run the pylab methods: `.plot()`, `.legend()`, `.xlabel()`, `.ylabel()`, `.title()`, `.show()`. The combined code is below."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "import pylab\n\nb = open('Example3.txt') \ndata = b.readlines()\n\nx = [line.split(',')[0] for line in data]\ny = [line.split(',')[1] for line in data]\n    \npylab.plot(x,y, label = 'Cookies per Day')        \npylab.legend()\npylab.xlabel(\"Day\")\npylab.ylabel(\"# cookies consumed\")\npylab.title(\"How Much of a Cookie Problem I Have\")\n\n# Normally we have to run pylab.show(), but Jupyter notebooks seems to do better if we don't\n#pylab.show()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Create a graph titled \"The Best Graph Ever\" using the data from \"TheBestGraph.txt\". Have the x-axis be from 0 to 45 incremented by 5 and the y axis to be from 0 to 100 incremented by 10. Make the line your favorite color (or close to) and your favorite pattern. Label the line with \"The Best Line Ever.\""
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python36",
      "display_name": "Python 3.6",
      "language": "python"
    },
    "language_info": {
      "mimetype": "text/x-python",
      "nbconvert_exporter": "python",
      "name": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.6",
      "file_extension": ".py",
      "codemirror_mode": {
        "version": 3,
        "name": "ipython"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}