{"nbformat":4,"nbformat_minor":0,"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.5.4"},"colab":{"name":"Day2_solutions.ipynb","provenance":[],"collapsed_sections":[]}},"cells":[{"cell_type":"markdown","metadata":{"id":"g6nwUXpCaZdl"},"source":["# Introduction to Python Day 2:\n","# If Statements, For Loops, Functions and Plotting\n","\n","### written by Jackie Champagne (UT Austin), adapted by Hannah Hasson (U of Rochester)  \n","&nbsp;  \n","\n","Welcome back! Hopefully now you should be comfortable with some basic Python syntax. Let's get into something a bit more interesting today: control structure! This allows you to actually build up your code.\n","\n","&nbsp;\n","\n","Today we will go over if statements, for loops, and functions, and then we will do a debugging exercise.\n","\n","&nbsp;\n","\n","As last time, let's start by importing numpy as np"]},{"cell_type":"code","metadata":{"id":"WjBzjgQDaZdm","executionInfo":{"status":"ok","timestamp":1646872394079,"user_tz":300,"elapsed":136,"user":{"displayName":"Hannah Hasson","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GioHAVrb-zeqnC3J8ovKfnzU9k_CuARLJ5xw4AiYQ=s64","userId":"03023097431734290550"}}},"source":["import numpy as np"],"execution_count":13,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"8PXvVwCAaZdq"},"source":["# **If statements**\n","\n","This is a conditional statement where **the code will proceed only if the condition is met**. Otherwise the code will stop or move on to the next condition.\n","\n","The condition in an `if` statement is a comparison that produces `True` or `False` (**boolean**). Here's a reminder of all the boolean operators you will probably be using:\n","\n","    ==   equal to\n","    !=   not equal to\n","    <    less than\n","    <=   less than or equal to\n","    >    greater than\n","    >=   greater than or equal to\n","\n","&nbsp;\n","\n","\n","The syntax for `if` statements is the following:\n","\n","    if condition_is_met:\n","        do something\n","        \n","Note the indentation of the second line! Python is very picky about this, though some other coding languages are not.\n","\n","&nbsp;\n","\n","\n","Now if you want to give the code a different option if the first fails, use `else`.\n","\n","    if condition_is_met:\n","        do something\n","    else:\n","        do a different thing\n","\n"," &nbsp;\n","        \n","Thus, the code will **only** move to `else` if the first condition is false. To include multiple options, use `elif`, short for 'else if'.\n","\n","    if condition_is_met:\n","        do something\n","    elif different_condition_is_met:\n","        do something else\n","    else:\n","        do another thing\n","\n","**Notice the way that things are indented.** Each of the actions belonging to a conditional statement is **indented below it**. Also make sure you don't forget the colon (**`:`**) at the end of each conditional line!\n","\n","&nbsp;\n","\n","### Question 1: Try a simple if statement: if 1 equals 1, print \"yes!\" Then write a second if statement after it: if one does not equal one, print \"no!\" What happens?"]},{"cell_type":"code","metadata":{"id":"Tw24t46yaZdr","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1646872394201,"user_tz":300,"elapsed":10,"user":{"displayName":"Hannah Hasson","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GioHAVrb-zeqnC3J8ovKfnzU9k_CuARLJ5xw4AiYQ=s64","userId":"03023097431734290550"}},"outputId":"0ed55d2b-becb-4077-9dc1-5ff82081e056"},"source":["# solution here\n","\n","if 1 == 1:\n","    print(\"yes!\")\n","    \n","if 1 != 1:\n","    print(\"no!\")"],"execution_count":14,"outputs":[{"output_type":"stream","name":"stdout","text":["yes!\n"]}]},{"cell_type":"markdown","metadata":{"id":"c_ixdFW3aZdu"},"source":["You probably noticed that the code stopped after printing \"yes!\", since the statement is false. If we don't want the code to stop, we would put in an else statement. \n","\n","&nbsp;\n","\n","Try it again: \n","\n","### Change your if statement from above. If one does not equal one, print \"1 does not equal 1??!!\" Otherwise, print \"1 always equals 1, duh.\" (Use an if and an else here)"]},{"cell_type":"code","metadata":{"id":"neqRF6idaZdv","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1646872394202,"user_tz":300,"elapsed":10,"user":{"displayName":"Hannah Hasson","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GioHAVrb-zeqnC3J8ovKfnzU9k_CuARLJ5xw4AiYQ=s64","userId":"03023097431734290550"}},"outputId":"9319d803-5a0d-4171-b7cf-91420f350971"},"source":["#solution here\n","\n","if 1 != 1:\n","    print(\"1 does not equal 1??!!\")\n","else:\n","    print(\"1 always equals 1, duh\")"],"execution_count":15,"outputs":[{"output_type":"stream","name":"stdout","text":["1 always equals 1, duh\n"]}]},{"cell_type":"markdown","metadata":{"id":"rXc0RMMkaZdy"},"source":["&nbsp;\n","### Question 2: Let's review some boolean logic. Go ahead and define that `b = 10`. Write an `if` statement that checks if b is equal to 10 or 2 (all on one line), and if so, print the value of b."]},{"cell_type":"code","metadata":{"id":"RcLADZv2aZdy","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1646872394203,"user_tz":300,"elapsed":8,"user":{"displayName":"Hannah Hasson","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GioHAVrb-zeqnC3J8ovKfnzU9k_CuARLJ5xw4AiYQ=s64","userId":"03023097431734290550"}},"outputId":"b2f3997a-913c-4eb9-bfa2-dfe8024505d1"},"source":["# solution here\n","\n","b = 10\n","\n","if b == 10 or b == 2:\n","    print(b)"],"execution_count":16,"outputs":[{"output_type":"stream","name":"stdout","text":["10\n"]}]},{"cell_type":"markdown","metadata":{"id":"KxyElzUTaZd1"},"source":["&nbsp;\n","\n","Like we mentioned yesterday, the syntax of arrays and indices can all be combined. \n","\n","### Question 3: Create a linear array (np.linspace) with 10 values between 0 and 1.  Write an if statement that checks whether the last entry in the array is less than one. If so, have it print out the last entry. If not, have it print out \"[last entry] is not less than one.\" \n","\n"]},{"cell_type":"code","metadata":{"id":"17sdSqLnaZd2","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1646872394204,"user_tz":300,"elapsed":7,"user":{"displayName":"Hannah Hasson","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GioHAVrb-zeqnC3J8ovKfnzU9k_CuARLJ5xw4AiYQ=s64","userId":"03023097431734290550"}},"outputId":"47dca790-406c-4856-fbfd-1407bc6c4ced"},"source":["# solution here\n","\n","linarray = np.linspace(0, 1, 10)\n","\n","if linarray[-1] < 1:\n","    print(linarray[-1])\n","else:\n","    print(linarray[-1], \"is not < 1\")\n","    #print(\"%i is not < 1\" % linarray[-1])"],"execution_count":17,"outputs":[{"output_type":"stream","name":"stdout","text":["1.0 is not < 1\n"]}]},{"cell_type":"markdown","metadata":{"id":"Uy6aYiTbaZd5"},"source":["&nbsp; \n","\n","# **For loops**\n","\n","For loops allow you to loop through all the values in an array and perform some operation or check a condition. \n","\n","The basic syntax is \"for x in arrayname.\" \n","\n","    for x in arrayname:\n","        do something\n","        \n","\"x\" refers to each element within your array, so \"x\" could have been any random character, but \"arrayname\" has to be the actual array or list you're looping over. \n","\n","&nbsp;\n","\n","For example:\n","\n","\n","\n"]},{"cell_type":"code","metadata":{"id":"bNCte3L5aZd5","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1646872394358,"user_tz":300,"elapsed":17,"user":{"displayName":"Hannah Hasson","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GioHAVrb-zeqnC3J8ovKfnzU9k_CuARLJ5xw4AiYQ=s64","userId":"03023097431734290550"}},"outputId":"89f2190e-b9b3-4ab9-d718-934193ab9cab"},"source":["shrek = ['Shrek', 'Donkey', 'Fiona', 'Lord Farquaad']\n","\n","for name in shrek:\n","  print(name)"],"execution_count":18,"outputs":[{"output_type":"stream","name":"stdout","text":["Shrek\n","Donkey\n","Fiona\n","Lord Farquaad\n"]}]},{"cell_type":"markdown","metadata":{"id":"UpefjBw3zse7"},"source":["&nbsp;\n","\n","### Question 4: Here's an array. Try writing a for loop that prints out \"Barnacles, [name]!\" for each element of the list individually. (Remember: to stick a string next to a variable in a print statement, separate them with a comma)\n"]},{"cell_type":"code","metadata":{"id":"6kW-CDVc0G7_","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1646872394359,"user_tz":300,"elapsed":17,"user":{"displayName":"Hannah Hasson","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GioHAVrb-zeqnC3J8ovKfnzU9k_CuARLJ5xw4AiYQ=s64","userId":"03023097431734290550"}},"outputId":"95426900-5627-432c-b0c5-12de571d9582"},"source":["bikinibottom = np.array(['Gary', 'Spongebob','Patrick', 'Squidward', 'Sandy'])\n","\n","# solution here\n","\n","for friend in bikinibottom:\n","  print(\"Barnacles,\", friend  + \"!\")"],"execution_count":19,"outputs":[{"output_type":"stream","name":"stdout","text":["Barnacles, Gary!\n","Barnacles, Spongebob!\n","Barnacles, Patrick!\n","Barnacles, Squidward!\n","Barnacles, Sandy!\n"]}]},{"cell_type":"markdown","metadata":{"id":"Elz1CwiAaZd8"},"source":["&nbsp;\n","\n","Another way to write a for loop is to loop over the **indices** of the array or list. This allows you, for instance, to index multiple arrays, or to keep track of both the index and the value of an array. You'll see what I mean in a minute. If you do it this way, the syntax goes like this:\n","\n","    for i in range(len(array)):\n","        do something to array[i]\n","\n","`len(array)` gives you the length of the array. Feeding that number into `range()` returns a list of indices of that length.\n","\n","**Now \"i\" is the index value rather than the value of the array**. Here's an example:"]},{"cell_type":"code","metadata":{"id":"MLnnYZtmaZd9","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1646872394360,"user_tz":300,"elapsed":16,"user":{"displayName":"Hannah Hasson","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GioHAVrb-zeqnC3J8ovKfnzU9k_CuARLJ5xw4AiYQ=s64","userId":"03023097431734290550"}},"outputId":"ac63813b-4d95-4eda-992a-e9c6977f94dd"},"source":["array = np.linspace(0, 10, 21)\n","\n","for i in array:\n","    print(\"a =\", i)\n","\n","for i in range(len(array)):\n","    print(\"the\", i, \"th value of array is\", array[i])"],"execution_count":20,"outputs":[{"output_type":"stream","name":"stdout","text":["a = 0.0\n","a = 0.5\n","a = 1.0\n","a = 1.5\n","a = 2.0\n","a = 2.5\n","a = 3.0\n","a = 3.5\n","a = 4.0\n","a = 4.5\n","a = 5.0\n","a = 5.5\n","a = 6.0\n","a = 6.5\n","a = 7.0\n","a = 7.5\n","a = 8.0\n","a = 8.5\n","a = 9.0\n","a = 9.5\n","a = 10.0\n","the 0 th value of array is 0.0\n","the 1 th value of array is 0.5\n","the 2 th value of array is 1.0\n","the 3 th value of array is 1.5\n","the 4 th value of array is 2.0\n","the 5 th value of array is 2.5\n","the 6 th value of array is 3.0\n","the 7 th value of array is 3.5\n","the 8 th value of array is 4.0\n","the 9 th value of array is 4.5\n","the 10 th value of array is 5.0\n","the 11 th value of array is 5.5\n","the 12 th value of array is 6.0\n","the 13 th value of array is 6.5\n","the 14 th value of array is 7.0\n","the 15 th value of array is 7.5\n","the 16 th value of array is 8.0\n","the 17 th value of array is 8.5\n","the 18 th value of array is 9.0\n","the 19 th value of array is 9.5\n","the 20 th value of array is 10.0\n"]}]},{"cell_type":"markdown","metadata":{"id":"Svs7e5ouaZeA"},"source":["&nbsp;\n","\n","Combo time! You can also embed if statements into for loops, which checks the conditional statement for every value of the array. \n","\n","### Question 5. \n","### a) Use `np.array` to create an array containing the values [0.5, 2, 3, 7]. \n","\n","### b) Then make a `for` loop that goes through each element of the array and adds two. \n","\n","### c) After adding 2, use `if` and `elif` inside the `for` loop to check if the value is now less than 5, equal to 5, or greater than 5. If a condition is satisfied, have it print that (e.g. '4 < 5'). \n","\n"]},{"cell_type":"code","metadata":{"id":"3dz1_QVtaZeA","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1646872394360,"user_tz":300,"elapsed":13,"user":{"displayName":"Hannah Hasson","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GioHAVrb-zeqnC3J8ovKfnzU9k_CuARLJ5xw4AiYQ=s64","userId":"03023097431734290550"}},"outputId":"b1990ca8-e72b-479d-e300-c635fb36855b"},"source":["#solution here\n","\n","# A\n","array2 = np.array([0.5, 2., 3., 7.])\n","\n","# B and C\n","for x in array2:\n","    b = x+2.\n","    if b < 5:\n","        print(b, \"< 5\")\n","    elif b == 5.:\n","        print(\"%i = 5\" % float(b))\n","    elif b > 5.:\n","        print(\"%i > 5.\" % float(b))"],"execution_count":21,"outputs":[{"output_type":"stream","name":"stdout","text":["2.5 < 5\n","4.0 < 5\n","5 = 5\n","9 > 5.\n"]}]},{"cell_type":"markdown","metadata":{"id":"D_2NDwg2CSYg"},"source":["&nbsp; \n","&nbsp; \n","-------\n","#PAUSE HERE AND TAKE A BREAK!\n","-------"]},{"cell_type":"markdown","metadata":{"id":"5H2Ouo8KaZeD"},"source":["&nbsp; \n","\n","# **User-defined functions**\n","\n","This is where the true programming comes in. Basically any code you write will be a series of functions that accomplish some task. Functions include mathematical expressions, list/array sorting, statistical operations, and many more. \n","\n","&nbsp;\n","\n","The syntax goes like this:\n","\n","    def function(a, b, c):\n","        do something with a, b, and c\n","        return something\n","    \n","First you define the function using \"def\". The definition of the function includes the name of the function and the arguments required for the function to work. You should leave the arguments as variables, and you will give the variables values when you call the function to use it.\n","\n","&nbsp;\n","\n","Inside the function, some operation will be performed on the variables you've provided. However, the function won't actually give you any output unless you use **return**. Return tells the function what to give you back.\n","\n","&nbsp;\n","\n","Here's an example:"]},{"cell_type":"code","metadata":{"id":"G-5IiAlhaZeD","executionInfo":{"status":"ok","timestamp":1646872394361,"user_tz":300,"elapsed":12,"user":{"displayName":"Hannah Hasson","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GioHAVrb-zeqnC3J8ovKfnzU9k_CuARLJ5xw4AiYQ=s64","userId":"03023097431734290550"}}},"source":["def line(x, m, b):\n","    y = m * x + b\n","    return y"],"execution_count":22,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"7DGatVtvaZeG"},"source":["Now, to run the function, you call its name and then supply values for the arguments:\n","\n"]},{"cell_type":"code","metadata":{"id":"_H7ADwutaZeG","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1646872394361,"user_tz":300,"elapsed":11,"user":{"displayName":"Hannah Hasson","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GioHAVrb-zeqnC3J8ovKfnzU9k_CuARLJ5xw4AiYQ=s64","userId":"03023097431734290550"}},"outputId":"a95011a3-f33f-461d-b93f-1d4adeaffb2e"},"source":["my_x = 1\n","my_m = 2\n","my_b = 3\n","\n","one_value = line(my_x, my_m, my_b)\n","print(one_value)\n","\n","#Confirm this is doing what we think\n","print(2*1+3)"],"execution_count":23,"outputs":[{"output_type":"stream","name":"stdout","text":["5\n","5\n"]}]},{"cell_type":"markdown","metadata":{"id":"f_7XF1oc73UR"},"source":["**You can feed the function an array as an argument as well.** It will calculate an answer for each element of the array and make an array of outputs."]},{"cell_type":"code","metadata":{"id":"3UfVJA957n_L","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1646872394362,"user_tz":300,"elapsed":10,"user":{"displayName":"Hannah Hasson","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GioHAVrb-zeqnC3J8ovKfnzU9k_CuARLJ5xw4AiYQ=s64","userId":"03023097431734290550"}},"outputId":"fa718363-681c-46de-9bf2-ef7984acfa68"},"source":["xarray = np.linspace(0, 5, 100)\n","\n","array_of_values = line(xarray, 1, 2)\n","\n","print(array_of_values)"],"execution_count":24,"outputs":[{"output_type":"stream","name":"stdout","text":["[2.         2.05050505 2.1010101  2.15151515 2.2020202  2.25252525\n"," 2.3030303  2.35353535 2.4040404  2.45454545 2.50505051 2.55555556\n"," 2.60606061 2.65656566 2.70707071 2.75757576 2.80808081 2.85858586\n"," 2.90909091 2.95959596 3.01010101 3.06060606 3.11111111 3.16161616\n"," 3.21212121 3.26262626 3.31313131 3.36363636 3.41414141 3.46464646\n"," 3.51515152 3.56565657 3.61616162 3.66666667 3.71717172 3.76767677\n"," 3.81818182 3.86868687 3.91919192 3.96969697 4.02020202 4.07070707\n"," 4.12121212 4.17171717 4.22222222 4.27272727 4.32323232 4.37373737\n"," 4.42424242 4.47474747 4.52525253 4.57575758 4.62626263 4.67676768\n"," 4.72727273 4.77777778 4.82828283 4.87878788 4.92929293 4.97979798\n"," 5.03030303 5.08080808 5.13131313 5.18181818 5.23232323 5.28282828\n"," 5.33333333 5.38383838 5.43434343 5.48484848 5.53535354 5.58585859\n"," 5.63636364 5.68686869 5.73737374 5.78787879 5.83838384 5.88888889\n"," 5.93939394 5.98989899 6.04040404 6.09090909 6.14141414 6.19191919\n"," 6.24242424 6.29292929 6.34343434 6.39393939 6.44444444 6.49494949\n"," 6.54545455 6.5959596  6.64646465 6.6969697  6.74747475 6.7979798\n"," 6.84848485 6.8989899  6.94949495 7.        ]\n"]}]},{"cell_type":"markdown","metadata":{"id":"0v_IrBfuaZeK"},"source":["### Question 6: Write a function that takes the y-intercept, x value, and a constant m and returns a *quadratic* curve of the form y = mx^2 + b. Then call your function, plugging the following values in together: m=2, x=3, b=4. Confirm that you get 22."]},{"cell_type":"code","metadata":{"id":"X-6q4qszaZeK","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1646872390351,"user_tz":300,"elapsed":119,"user":{"displayName":"Hannah Hasson","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GioHAVrb-zeqnC3J8ovKfnzU9k_CuARLJ5xw4AiYQ=s64","userId":"03023097431734290550"}},"outputId":"78fb23cd-a7e7-4d0b-ce6e-8fb2c8ee3a25"},"source":["#solution here\n","\n","def quad(x, m, b):\n","    fx = m * x**2 + b\n","    return fx\n","\n","quad(3, 2, 4)"],"execution_count":12,"outputs":[{"output_type":"execute_result","data":{"text/plain":["22"]},"metadata":{},"execution_count":12}]},{"cell_type":"markdown","metadata":{"id":"znA33GzxyMwp"},"source":["&nbsp;\n","\n","# **Plotting basics!**\n","\n","A surprisingly large part of research is making pretty plots, so let's explore that now! \n","\n","To do some plotting, we will need to import the matplotlib package. Matplotlib is a **mat**hematical **plot**ting **lib**rary containing most of the functions you will ever need to plot something. You will need to use matplotlib.pyplot, which most people import as plt."]},{"cell_type":"code","metadata":{"id":"uICZH-g0ybre"},"source":["import matplotlib.pyplot as plt"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"LjPaGwGky9tI"},"source":["&nbsp;\n","\n","Making a basic plot with this is quite simple. The only required arguments are x-values and y-values, and anything else is #aesthetic.\n","\n","So the syntax is like this:\n","\n","    plt.plot(x, y, other, optional, arguments)\n","\n","&nbsp;\n","\n","Here is a very bare-bones example to start with:\n","First we make a set of x values using linspace, and then we define a function that computes $x^2$ and compute the y values by feeding our x values into it."]},{"cell_type":"code","metadata":{"id":"0U07r0X0zDJ0","colab":{"base_uri":"https://localhost:8080/","height":265},"executionInfo":{"status":"ok","timestamp":1625174616974,"user_tz":240,"elapsed":335,"user":{"displayName":"Hannah Hasson","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GioHAVrb-zeqnC3J8ovKfnzU9k_CuARLJ5xw4AiYQ=s64","userId":"03023097431734290550"}},"outputId":"95e5100b-1684-4281-882f-93deea627f7f"},"source":["#Define function for taking square\n","\n","def squared(x):\n","  return x**2\n","\n","#Make x and y values\n","xvals = np.linspace(0,10,20) #ranges from 0 to 10 with 20 points total\n","yvals = squared(xvals)\n","\n","#Plot\n","plt.plot(xvals, yvals, label=\"x^2\")\n","plt.legend()\n","plt.show() #Marks the end of the commands for this plot"],"execution_count":null,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 432x288 with 1 Axes>"]},"metadata":{"tags":[],"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"id":"jr-xIGAmaZeN"},"source":["&nbsp;\n","\n","There are many details that you can add to the plots through what are called **keywords**. You just add these as additional arguments after your x and y values. For example, the `label` option was used in the above example, which we used to assign the curve a label in the legend. \n","\n","&nbsp;\n","\n","Some of the customizations include:\n","\n","    marker: o (circles), ^ (triangles), * (stars), . (small points), etc\n","    linestyle: - (solid line), -- (dotted line), : (fine dotted line), etc\n","    color: b (blue), r (red), c (cyan), m (magenta), y (yellow), k (black), g (green), etc\n","    alpha: opacity, a float set between 0 and 1\n","    label: name of that dataset to be used in the legend\n","    \n","Every keyword argument besides alpha should be given as a string. Note that the order of the arguments in `plt.plot` matters for the required xvals and yvals, but order is flexible for all the optional arguments. You can always google a function to check what arguments it takes in what order. [Here](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html?highlight=plot#matplotlib.pyplot.plot) is the documentation for `matplotlib.pyplot.plot()`.\n","\n","&nbsp;\n","    \n","After plt.plot(), you will want to add some other information.\n","\n","    plt.xlabel() - x axis label\n","    plt.ylabel() - y axis label\n","    plt.axis([]) - in the brackets list x_lowerlimit, x_upperlimit, y_lowerlimit, y_upperlimit for axis display\n","    plt.title() - plot title\n","    plt.legend() - adds a legend, but plt.plot() must contain a \"label\" argument\n","    plt.show() - displays your plot\n","\n","&nbsp;\n","\n","Here's a detailed example. By the way, you can use shorthand for the marker/line style and the color, so instead of typing out `marker=\"o\", color=\"blue\"`, it will also understand simply `\"ob\"` (blue circles)."]},{"cell_type":"code","metadata":{"id":"ZwTlxQ7WaZeN","colab":{"base_uri":"https://localhost:8080/","height":300},"executionInfo":{"status":"ok","timestamp":1625174623527,"user_tz":240,"elapsed":349,"user":{"displayName":"Hannah Hasson","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GioHAVrb-zeqnC3J8ovKfnzU9k_CuARLJ5xw4AiYQ=s64","userId":"03023097431734290550"}},"outputId":"b87db1b0-bc33-49d0-8084-087de283204c"},"source":["a = np.array([0, 1, 2, 3])\n","b = np.array([7, 6, 5, 4])\n","\n","plt.plot(a, b+2, 'ob',alpha=0.1, markersize=15, label='blue circles') #plot the b+2 as blue circles\n","plt.plot(a, b**2, '^m', label='pink triangles') #plot b^2 as magenta triangles\n","plt.xlabel(\"x label\", fontsize=16)\n","plt.ylabel(\"y label\", fontsize=16)\n","plt.title('scatter plot')\n","plt.legend(loc=1, frameon=True) #'loc' moves the legend around, frameon puts a box around the legend\n","plt.savefig(\"customfig.jpg\")\n","plt.show()\n"],"execution_count":null,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 432x288 with 1 Axes>"]},"metadata":{"tags":[],"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"id":"3cJRWXn1aZeP"},"source":["### Question 7: Run your quadratic function for y = 2 * x^2 + 5, where x goes between -5 and 5. Plot it with a green dashed line and label it in the legend. Include axes labels and a title."]},{"cell_type":"code","metadata":{"id":"XKpJ9GZ4aZeQ","colab":{"base_uri":"https://localhost:8080/","height":303},"executionInfo":{"status":"ok","timestamp":1646849945879,"user_tz":300,"elapsed":270,"user":{"displayName":"Tyler Mason","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"08701255294625460731"}},"outputId":"3f813e96-0691-4998-8911-f78ef1280dab"},"source":["#solution here\n","\n","fig = plt.figure()\n","\n","xarray = np.linspace(-5, 5, 200)\n","quadfx = quad(xarray, 5, 2)\n","\n","plt.plot(xarray, quadfx, 'g--', label=\"quad function\")\n","plt.legend(loc=9, frameon=True, fontsize=14)\n","\n","#these are the symbols for solar and earth mass- might be helpful to you!\n","plt.xlabel(\"M$_{\\odot}$\", fontsize=16)\n","plt.ylabel(\"M$_{\\oplus}$\", fontsize=16)\n","\n","plt.title(\"quad function\")\n","\n","fig.savefig('quadfx.jpg')"],"execution_count":null,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 432x288 with 1 Axes>"]},"metadata":{"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"id":"n7-q0qXaaZeS"},"source":["Finally, to save a figure, write fig = plt.figure() before your plot, and before you call plt.show(), write fig.savefig('filename.jpg'). \n"]},{"cell_type":"markdown","metadata":{"id":"j9LT5OUDjsnK"},"source":["##Don't forget to do the exercises in the Exercises.ipynb file for Day 2! Collaboration with your peers is encouraged :)"]}]}