{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "### Lecture 6:\n", "\n", "- get a first peek at the very useful Python packages called **NumPy** and **matplotlib**\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the last lecture we learned how to create modules. These are files that contain one or more functions and variables. They can be imported and used in other programs or notebooks, saving us a lot of time and headache. \n", "\n", "A Python _package_ contains a collection of modules that are related to each other. Our first _package_ is one of the most useful ones for us science types: **NumPy**. \n", "\n", "\n", "### A first look at NumPy\n", "\n", "O.K. First of all - how do you pronounce \"NumPy\"'? It should be pronounced \"Num\" as in \"Number\" and \"Pie\" as in, well, pie, or Python. It is way more fun to say Numpee! I try to suppress this urge. \n", "\n", "Now with that out of the way, what can we do with **NumPy**? Turns out, a whole heck of a lot! But for now, we will just scratch the surface. For starters, **NumPy** can give us the value of the square root of a number with the function **numpy.sqrt( )**. Note how the package name comes first, then the function we wish to use (just as in our example from the last lecture). \n", "\n", "To use **NumPy** functions, we must first **import** the package with the command **import**. It may take a while the first time you use **import** after installing Python, but after that it should load quickly. \n", "\n", "We encountered **import** very briefly in the last lecture. Now it is time to go deeper. There are many different ways you can use the **import** command. Each way allows your program to access the functions and variables defined in the imported package, but differs in how you call the function after importing: " ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.4142135623730951" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy\n", "\n", "#This makes all the functions in NumPy available to you, \n", "#but you have to call them with the numpy.FUNC() syntax\n", "\n", "numpy.sqrt(2)\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.4142135623730951" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Here is another way to import a module: \n", "import numpy as np # or any other variable e.g.: N\n", "# This does the same as the first, but allows you to set NumPy with a nickname\n", "\n", "# In this case, you substitute \"np\" for numpy:\n", "\n", "np.sqrt(2) # or N.pi in the second case. \n", "\n", "# Note: Some folks in the NumPy community use N; I use np. \n", "# That seems to be the most common way now.\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To import all the functions from NumPy: " ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.4142135623730951" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from numpy import *\n", "\n", "# now all the functions are available directly, without the initial module name: \n", "\n", "sqrt(2)\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The '\\*' imports all the functions into the local namespace, which is a heavy load on your computer's memory. Alternatively, you can import the few, specific functions you'll use, for example, **sqrt**: \n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2.0" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from numpy import sqrt # square root\n", "\n", "sqrt(4)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Did you notice how \"sqrt(4)\", where 4 was an integer, returned a floating point variable (2.0)? \n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**TIP**: I tend to import the **NumPy** package using the **np** option above. That way I know where the functions I'm using come from. This is useful, becuase we don't use or know ALL of the functions available in any given package. AND the same function name can mean different things in different packages. So, a function defined in the package could conflict with one defined in your program. It is just good programming practice to specify the origin of the function you are using. \n", "\n", "### NumPy functions\n", "\n", "Here is a (partial) list of some useful **NumPy** functions:\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "|function | purpose|\n", "|------------ |--------------|\n", "|absolute(x) | absolute value|\n", "|arccos(x) |arccosine |\n", "|arcsin(x) | arcsine |\n", "|arctan(x) | arctangent |\n", "|arctan2(y,x) |arctangent of y/x in correct quadrant| \n", "|cos(x) |cosine |\n", "|cosh(x) | hyperbolic cosine |\n", "|exp(x) | exponential |\n", "|log(x) | natural logarithm |\n", "|log10(x) | base 10 log |\n", "|sin(x) | sine |\n", "|sinh(x) | hyperbolic sine |\n", "|sqrt(x) | square root |\n", "|tan(x) | tangent |\n", "|tanh(x) | hyperbolic tangent |\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### Numpy attributes\n", "\n", "**NumPy** has more than just _functions_; it also has _attributes_ which are variables stored in the package, for example $\\pi$. \n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3.141592653589793" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.pi" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**TIP**: In the trigonometric functions, the argument is in RADIANS!.You can convert between degrees and radians by multiplying by: np.pi/180. OR you can convert using the **NumPy** functions **np.degrees( )** which converts radians to degrees and **np.radians( )** which converts degrees to radians. \n", "\n", "\n", "Also notice how the functions have parentheses, as opposed to **np.pi** which does not. The difference is that **np.pi** is not a function but an _attribute_. It is a variable defined in **NumPy** that you can access. Every time you call the variable **np.pi**, it returns the value of $\\pi$. \n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Using NumPy Functions\n", "\n", "As already mentioned, **NumPy** has many math functions. We will use a few to generate some data sets that we can then plot using **matplotlib**, another Python module. \n", "\n", "First, let's make a list of angles ($\\theta$ or **theta**) around a circle. We begin with the list of angles in degrees, convert them to radians (using **np.radians( )**), then construct a list of sines of those angles. " ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 0.00000000e+00, 8.71557427e-02, 1.73648178e-01, 2.58819045e-01,\n", " 3.42020143e-01, 4.22618262e-01, 5.00000000e-01, 5.73576436e-01,\n", " 6.42787610e-01, 7.07106781e-01, 7.66044443e-01, 8.19152044e-01,\n", " 8.66025404e-01, 9.06307787e-01, 9.39692621e-01, 9.65925826e-01,\n", " 9.84807753e-01, 9.96194698e-01, 1.00000000e+00, 9.96194698e-01,\n", " 9.84807753e-01, 9.65925826e-01, 9.39692621e-01, 9.06307787e-01,\n", " 8.66025404e-01, 8.19152044e-01, 7.66044443e-01, 7.07106781e-01,\n", " 6.42787610e-01, 5.73576436e-01, 5.00000000e-01, 4.22618262e-01,\n", " 3.42020143e-01, 2.58819045e-01, 1.73648178e-01, 8.71557427e-02,\n", " 1.22464680e-16, -8.71557427e-02, -1.73648178e-01, -2.58819045e-01,\n", " -3.42020143e-01, -4.22618262e-01, -5.00000000e-01, -5.73576436e-01,\n", " -6.42787610e-01, -7.07106781e-01, -7.66044443e-01, -8.19152044e-01,\n", " -8.66025404e-01, -9.06307787e-01, -9.39692621e-01, -9.65925826e-01,\n", " -9.84807753e-01, -9.96194698e-01, -1.00000000e+00, -9.96194698e-01,\n", " -9.84807753e-01, -9.65925826e-01, -9.39692621e-01, -9.06307787e-01,\n", " -8.66025404e-01, -8.19152044e-01, -7.66044443e-01, -7.07106781e-01,\n", " -6.42787610e-01, -5.73576436e-01, -5.00000000e-01, -4.22618262e-01,\n", " -3.42020143e-01, -2.58819045e-01, -1.73648178e-01, -8.71557427e-02])" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "thetas_in_degrees=range(0,360,5) # list (generator) of angles from 0 to 359 at five degree intervals\n", "# uncomment the following line, if you'd like to print the list \n", "#print (list(thetas_in_degrees))\n", "thetas_in_radians=np.radians(thetas_in_degrees) # convert to radians\n", "sines=np.sin(thetas_in_radians) # calculate the sine values for all the thetas\n", "sines" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plotting data \n", "\n", "Now that we've generated some data, we can look at them. Yes, we just printed out the values, but it is way more interesting to make a plot. The easiest way to do this is using the package **matplotlib** which has many plotting functions, among them a whole module called **pyplot**. By convention, we **import** the **matplotlib.pyplot** module as **plt**. \n", "\n", "We've also included one more line that tells **pyplot** to plot the image within the notebook: The magic command: **%matplotlib inline**. Note that this does not work in other environments, like command line scripts; magic commands are only for Jupyter notebooks (lucky us!). " ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAD8CAYAAABzTgP2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3Xl8VOW9x/HPj2wsAUJICIEESCABwg4xgKiogKAouLZgVVx6bbVeFfRa2lqta622Vak7uOBSEbcLLhUBQQEBCbJvSQhLQoCEQCAkZH/uH3PwTmI2mMmcmcnv/XrNa+ZsM18OML95zvI8YoxBKaWUOq2F3QGUUkp5Fy0MSimlqtHCoJRSqhotDEopparRwqCUUqoaLQxKKaWq0cKglFKqGi0MSimlqtHCoJRSqppAuwOcjYiICNOjRw+7YyillE9Zv379EWNMZEPr+WRh6NGjB6mpqXbHUEopnyIi+xqznh5KUkopVY0WBqWUUtVoYVBKKVWNFgallFLVaGFQSilVjVsKg4i8ISK5IrK1juUiIrNEJENENovIUKdl00Qk3XpMc0cepZRSZ89dLYa3gAn1LL8USLAetwMvA4hIOPAwMBxIAR4WkQ5uyqSUUuosuOU+BmPMdyLSo55VJgNvG8c4omtEJExEooELgcXGmKMAIrIYR4F53x251Jk7UVJO1tFijpwsI/9kKfknyyitqCS8TQgdQ4OJCA2hU9sQYjq0QkTsjquUagKeusGtK5DlNJ1tzatr/s+IyO04Wht069ataVI2QyXllazfd4xVGUdYtTufLdkFVDViGPCodiGM6hnBqF6OR+f2LZs+rFLKIzxVGGr7aWnqmf/zmca8BrwGkJyc3IivLlWf3XkneWvVXj7+MZviskoCWwiDY8O46+IEkqLbEhEaQsfQECJCgwkObMHRojLyT5Zx5GQp2cdOsSYzn+VpeXyy4QAA5/TowK2j4hiXFEVggF7ToJQv81RhyAZinaZjgBxr/oU15i/3UKZmxxjDd+lHeGPlHr5NyyM4oAVXDOrCxIGdSYnrSGhI3f8cotu3Irp9q5+mbxjRnaoqw85DhSxPy+Xfa/dzx3s/0jWsFTeN7M6Uc7rRvnWQJ/5YSik3E8dhfze8keMcw+fGmP61LJsI3AVchuNE8yxjTIp18nk9cPoqpR+BYafPOdQlOTnZaF9JZ2bXoUL+/L9b+WHvUSLbhnDjiO5cP7wbEaEhbnn/yirDkh2HeXPVHtZkHqV9qyAemNCbqed0o0ULPRehlDcQkfXGmOSG1nNLi0FE3sfxyz9CRLJxXGkUBGCMeQX4EkdRyACKgVusZUdF5DFgnfVWjzZUFNSZOVlawXOL03jz+720bRnIE1f157phsQQHuvdwT0ALYXy/zozv15mtB47z2Ofb+dOnW5m/LovHrxzAgJj2bv08pVTTcVuLwZO0xdA4X287xJ8XbOXwiVKmpsTywPg+dGgT7JHPNsawYGMOj3+xg/yiUm4Y3p0/XtaXVsEBHvl8pdTPebTFoLxLeWUVT3+1k9kr9pAU3Y5XbhjGkG6evT1ERLhySFcu7tuJf36dxtzVe1m39ygv/Woo8ZGhHs2ilDozevmInzl8ooTrZ69h9oo93DiiO5/+7lyPFwVn7VoG8ZdJ/XjrlhQOnyhh0gur+M+Wg7blUUo1TAuDH1m9O5+Js1aw9cAJnp8ymMeu7E9IoHccuhmdGMnnd59Pr06h3PHejzz2+XbKK6vsjqWUqoUWBj+xYOMBbnx9Le1aBbHgrlFMHlzrfYK26hrWivm/Gcm0kd15feUefvPOekrKK+2OpZSqQQuDH3h79V7u/WAjw7p3YMHvRpEY1dbuSHUKDmzBI5P788RV/Vm2K5ebXv+BEyXldsdSSjnRwuDDjDHMWprOQwu2MaZPFHNvTaFtS9+4qexXw7sza8oQNmQdY8qra8grLLU7klLKooXBR1VVGR77fAf/XJzG1UO68soNQ2kZ5B3nExrrikFdmH1TMplHTvKLV1eTfazY7khKKbQw+CRjDI9/sYM3Vu3h5nN78PfrBvls/0QX9u7Eu7cN58jJUqbOXsPhEyV2R1Kq2fPNb5Nm7sVlGT8VhYevSPL5LieSe4Tzzm3DyT9Zxk2v/0BBcZndkZRq1rQw+Jh31uzj71+ncdWQrjx0eZLfjIkwODaM2Tcls+dIEbe+tY7isgq7IynVbGlh8CELN+Xw0IKtjOnTiaevHejzLYWaRvWKYNbUwWzMKuC37/5IWYXe56CUHbQw+IgV6XnM+GAj53QP58VfDSXIR88pNGRC/2j+evUAvkvL474PN1HVmFGDlFJupX0l+YDdeSe5870f6dUplDk3J/vc1Udn6pfndONoUTl/+2onPSPbcO/YRLsjKdWsaGHwcidKyvmvt1MJCmjBnGnJtPOR+xRc9dvR8aTnFvLcknT6dG7LhP7RdkdSqtnwz+MRfqKyynD3+xvYn1/My78aSkyH1nZH8hgR4cmrBjA4NowZ8zex89AJuyMp1Wy4pTCIyAQR2SUiGSIys5blz4rIRuuRJiIFTssqnZYtdEcef/H0op0s35XHXyb1Y3h8R7vjeFzLoABevXEYoSGB/HpuKkeL9DJWpTzB5cIgIgHAi8ClQBIwVUSSnNcxxkw3xgw2xgwG/gV84rT41OllxphJrubxFws2HuDVbzP51fBu3DCiu91xbBPVriWv3ZRMbmEpd763XntkVcoD3NFiSAEyjDGZxpgyYB4wuZ71pwLvu+Fz/Vb64UJ+//FmUuLCefiKfnbHsd3g2DD+etUA1mQe5Z+L0+yOo5Tfc0dh6ApkOU1nW/N+RkS6A3HAN06zW4pIqoisEZEr3ZDHp5WUV3LXvzfQJjiQF6YOcfvYzL7qmmExTE2J5eXlu/kuLc/uOEr5NXd869R2l1VdF59PAT4yxjh3wt/NGoP0euA5EelZ64eI3G4VkNS8PP/9Ynjs8+3sOlzIP34xiE7tWtodx6s8dHk/EqNCmTF/I7mF2qeSUk3FHYUhG4h1mo4BcupYdwo1DiMZY3Ks50xgOTCktg2NMa8ZY5KNMcmRkZGuZvZKX2w+yHtr9/Ob0fFc2LuT3XG8TqvgAF64fignSyuY8YHe/KZUU3FHYVgHJIhInIgE4/jy/9nVRSLSG+gArHaa10FEQqzXEcAoYLsbMvmcrKPFzPxkM4Njw7j/kt52x/FaiVFt+csV/ViZcYRXvtttdxyl/JLLhcEYUwHcBSwCdgDzjTHbRORREXG+ymgqMM8Y4/wzry+QKiKbgGXAU8aYZlcYyiur+O/3NwDwr6lD/La7C3f55TmxXD4wmn98ncb6fcfsjqOU35Hq39O+ITk52aSmptodw21mLU3nn4vTeOH6IVw+sIvdcXxCYUk5l81aQYAIX95zPq2D9SZ+pRoiIuutc7r10p+mNtuWc5xZS9OZNKiLFoUz0LZlEM9cO4i9+cU8/dUuu+Mo5Ve0MNiorKKK++ZvokObYB6drPcrnKkR8R25ZVQP3vp+L9/vPmJ3HKX8hhYGG81ams7OQ4U8dfUAwloH2x3HJz0wvg9xEW144KPNnCzVwX2UcgctDDbZlFXAy9/u5tphMYzpG2V3HJ/VKjiAv183kJyCUzz55Q674yjlF7Qw2KCkvJL7PtxEZGgIf748qeENVL2GdQ/nv86P599r9+td0Uq5gRYGG/zrm3Qyck/yt2sH0r5V8xhfoalNH5dIr06hzPx4M0V6SEkpl2hh8LBdhwp59dtMrhkaw+hE/7yD2w4tgwL42zUDyDleoh3tKeUiLQweVFVl+OOnW2jbMpA/Texrdxy/M6x7OL8a3o03V+1h64HjdsdRymdpYfCgeeuyWL/vGH+amER4G70KqSk8MKEP4W1C+MMnW6jUvpSUOitaGDwkt7CEv/5nByPjO3LN0Fp7JVdu0L5VEA9fkcSWA8eZ+/1eu+Mo5ZO0MHjIY5/voLS8iieu6o9IbT2VK3e5fGA0F/aO5B9f7yKn4JTdcZTyOVoYPGD5rlw+25TD7y7qRXxkqN1x/J6I8Njk/lQaw8MLt9kdRymfo4WhiZWUV/Lwwm3ER7bhtxfG2x2n2YgNb829YxNZvP0w3+w8bHccpXyKFoYm9vrKPezLL+aRSf0ICQywO06zcuuoOHpGtuHRz7ZTWlHZ8AZKKUALQ5PKKTjFC99kML5fFOcn6D0LnhYc2IKHr+jH3vxi5qzYY3ccpXyGFoYm9OSXO6gyhgcnarcXdrkgMZJLkqJ44ZsMDh7XE9FKNYZbCoOITBCRXSKSISIza1l+s4jkichG6/Frp2XTRCTdekxzRx5vsHp3Pp9vPshvR/ckNry13XGatT9fnkSVMTz55U67oyjlE1wuDCISALwIXAokAVNFpLafyB8YYwZbjznWtuHAw8BwIAV4WEQ6uJrJbhWVVTzy2Ta6hrXijgt72h2n2YsNb81vRvfks005rMnMtzuOUl7PHS2GFCDDGJNpjCkD5gGTG7nteGCxMeaoMeYYsBiY4IZMtnp3zT52Hirkz5f3pWWQnnD2BneM7knXsFb8ZeE2Kiqr7I6jlFdzR2HoCmQ5TWdb82q6RkQ2i8hHIhJ7htv6jGNFZfxzcRrn9YpgfL/OdsdRllbBATw4sS87DxXy/g/77Y6jlFdzR2Go7Tbemp3UfAb0MMYMBJYAc89gW8eKIreLSKqIpObleW+f+88vTedkaQUPXZGkdzh7mQn9OzMiPpxnl6RzoqTc7jhKeS13FIZsINZpOgbIcV7BGJNvjCm1JmcDwxq7rdN7vGaMSTbGJEdGeueln5l5J3l3zT6mpHQjMaqt3XFUDSLCgxOTOFZcxovLMuyOo5TXckdhWAckiEiciAQDU4CFziuISLTT5CTg9BiMi4BLRKSDddL5EmueT/rrf3bSMiiA6WMT7Y6i6tC/a3uuHhLDmyv3knW02O44SnkllwuDMaYCuAvHF/oOYL4xZpuIPCoik6zV7haRbSKyCbgbuNna9ijwGI7isg541Jrnc1bvzmfx9sPceVFPItuG2B1H1eN/xvemRQv421d6+apStRFjfK/P+uTkZJOammp3jJ9UVRmueGElBcXlLL1vtF6J5AP+uTiNWUvT+fiOcxnW3eevkFaqUURkvTEmuaH19M5nN/hkwwG25ZzggQm9tSj4iN9cEE+ntiE8/sV2fPHHkVJNSQuDi06VVfL3RbsYFBvGpEFd7I6jGqlNSCD3X9KbDfsL+HzzQbvjKOVVtDC46I1Vezh0ooQHJ/bVy1N9zDXDYugb3Y5nFu2irEJvelPqNC0MLjhaVMYry3czLimKc3qE2x1HnaGAFsLvJ/Rm/9FivelNKSdaGFzw4rIMisoqeGB8b7ujqLM0OjGSkfEdmWXdmKiU0sJw1rKOFvPO6n1cNyyWBL2ZzWeJCDMv7UN+URmzv8u0O45SXkELw1l6dnEaInDvuAS7oygXDYoNY+KAaGavyCSvsLThDZTyc1oYzsKOgyf4dOMBbh7Vg+j2reyOo9zgvksSKa2o4oVv0u2OopTttDCchae/2knbkEDuHN3L7ijKTeIjQ5lyTizvrd3Pvvwiu+MoZSstDGdoTWY+y3bl8buLetG+dZDdcZQb3TMmgaCAFjyzaJfdUZSylRaGM2CM4emvdtK5XUumndvD7jjKzTq1a8lt58Xx+eaDbMs5bnccpWyjheEMfLMzlx/3F3D3mATt+sJP/dcF8bRrGcg/vk6zO4pSttHC0EhVVYa/f51G946tuS45xu44qom0bxXEby/syTc7c1m/zyc7+lXKZVoYGumLLQfZcfAE08cmEhSgu82f3XxuDyJCQ3j6q13awZ5qlvQbrhEqKqt4dnEavaPacoV2lOf3WgcHctdFPVm75ygrM47YHUcpj9PC0AifbDhA5pEiZlySSEAL7SivOZg6vBtdw1rx90XaalDNj1sKg4hMEJFdIpIhIjNrWT5DRLaLyGYRWSoi3Z2WVYrIRuuxsOa2diutqOT5JekMimnPJUlRdsdRHhISGMA9YxLYlH2cr7cftjuOUh7lcmEQkQDgReBSIAmYKiJJNVbbACQbYwYCHwFPOy07ZYwZbD0m4WXm/ZDFgYJT3D++t3ar3cxcPbQr8RFt+OfXaVRWaatBNR/uaDGkABnGmExjTBkwD5jsvIIxZpkx5vTI62sAn7is51RZJS8sy2B4XDjn9YqwO47ysMCAFtw7LpFdhwv5fHOO3XGU8hh3FIauQJbTdLY1ry63Af9xmm4pIqkiskZErqxrIxG53VovNS8vz7XEjfTumn3kFZZy3yXaWmiuLh8QTe+otjy/JJ2KSh3MRzUP7igMtX1j1truFpEbgGTgGafZ3azBqa8HnhORnrVta4x5zRiTbIxJjoyMdDVzg4pKK3jl292cnxBBSpwOwtNctWghTB+XQOaRIhZs1FaDah7cURiygVin6RjgZ/+DRGQs8CdgkjHmp76NjTE51nMmsBwY4oZMLpu7ei/5RWVMH5dodxRls/H9OtOvSzueX5pOubYaVDPgjsKwDkgQkTgRCQamANWuLhKRIcCrOIpCrtP8DiISYr2OAEYB292QySWFJeW89l0mF/WOZGi3DnbHUTYTEaaPTWT/0WI++THb7jhKNTmXC4MxpgK4C1gE7ADmG2O2icijInL6KqNngFDgwxqXpfYFUkVkE7AMeMoYY3theGvVXgqKy5kxTofsVA5j+nZiUEx7Zi3NoKxCWw3KvwW6402MMV8CX9aY95DT67F1bPc9MMAdGdzl+KlyZq/IZFxSFANi2tsdR3kJEWH6uERufnMd81OzuGFE94Y3UspH6Z3PNby+cg8nSiqYPlbPLajqRidGMqx7B15clkFJeaXdcZRqMloYnBQUl/HGyj1cNqAzSV3a2R1HeRkRYca4RA4eL2HeD/vtjqNUk9HC4GTOij0UlVVwzxhtLajanduzIylx4by0fLe2GpTf0sJgOVZUxlvf7+WyAdH07tzW7jjKS4kI945NILewVFsNym9pYbDMWZlptRYS7I6ivNy5PSMYrq0G5ce0MGC1FlbtZeKAaBKjtLWgGnbv2ERyC0t5X1sNyg9pYQBmr8ikuLxSWwuq0Ub27KitBuW3mn1hOFpUxtzv93L5wC4kaGtBnYF7xyaSV1jKv9dqq0H5l2ZfGE63Fu6+uJfdUZSPGdmzIyPiw3n5W201KP/SrAuDthaUq063Gt7TVoPyI826MMxekcmp8kruGaOtBXV2RsR3ZGR8R17Wcw3KjzTbwnC0qIy3rdZCr07aWlBn756xCRw5qecalP9otoVhjp5bUG4yIl7PNSj/0iwLwzHr3MLEAdF6bkG5xT1jHOca9L4G5Q+aZWF4feUeR2tB71tQbjLS6kNJzzUof+CWwiAiE0Rkl4hkiMjMWpaHiMgH1vK1ItLDadkfrPm7RGS8O/LUp6D4//tE0ruclTtpH0rKX7hcGEQkAHgRuBRIAqaKSFKN1W4DjhljegHPAn+ztk3CMRRoP2AC8JL1fk3m9ZV7OFlawd0Xa2tBudfI+I6k9NBzDcr3uaPFkAJkGGMyjTFlwDxgco11JgNzrdcfAWNERKz584wxpcaYPUCG9X5NoqC4jDetPpG0B1XlbiLCPWMTOHyilPmpWXbHUeqsuaMwdAWc/xdkW/NqXccaI/o40LGR27rNG1Zr4b/1vgXVRM7t2ZFzenTgpWXaalC+yx2FQWqZZxq5TmO2dbyByO0ikioiqXl5eWcY0SG/qIyJA6Pp01lHZ1NNQ0S4Z0wih06U8KG2GpSPckdhyAZinaZjgJy61hGRQKA9cLSR2wJgjHnNGJNsjEmOjIw8q6BPXDWAWVOGnNW2SjXWqF4dSe7egZeW76a0QlsNyve4ozCsAxJEJE5EgnGcTF5YY52FwDTr9bXAN8YYY82fYl21FAckAD+4IVOdAlrU1khRyn1On2s4eLyE+anZdsdR6oy5XBiscwZ3AYuAHcB8Y8w2EXlURCZZq70OdBSRDGAGMNPadhswH9gOfAX8zhijP7GUzzuvVwRDu4Xx8rIMbTUonyOOH+6+JTk52aSmptodQ6l6fZeWx01v/MATV/XnV8O72x1HKURkvTEmuaH1muWdz0p5wvkJEQzpFsZLy3ZTVlFldxylGk0Lg1JNRES4d2wiBwpO8dF6PdegfIcWBqWa0AUJEQyODePFZRnaalAuqaoyHCg45ZHP0sKgVBNytBoSOFBwio9/1FaDOntfbj3I6KeXsSmroMk/SwuDUk1sdGIkg2PDeOEbbTWos1NZZXh+STpxEW3o37V9k3+eFgalmphzq0HPNaiz8eWWg6TnnuTuMQkeuRdLC4NSHnC61aDnGtSZqqwyzFqaTkKnUCYOiPbIZ2phUMoDRITp4xxXKH24XvtQUo33hdVauGdsAi081HODFgalPOQC676GF/Vcg2qk062FxKhQLuvvmdYCaGFQymNEhOljE8k5XqLjNahG+XxzDhm5J7lnTKLHWgughUEpjzo/wdGH0kvah5JqgHNr4dL+nT362VoYlPKg03dD52jPq6oBn2/OYXdekcdbC6CFQSmPOz8hgmHdO/DSsgwd5U3VqqKyiueXpNM7qq3HWwughUEpjxMRZoxL5ODxEj5Yp+ca1M8t3JRD5pEipo/z3JVIzrQwKGWDc3t2JCUunBe11aBqKK+s4vml6SRFt+OSJM+3FkALg1K2ON1qyC0s5d01++yOo7zIpz8eYF9+MTPGef7cwmkuFQYRCReRxSKSbj13qGWdwSKyWkS2ichmEfml07K3RGSPiGy0HoNdyaOULxkR35FRvTryyre7KS6rsDuO8gJlFVXM+iadgTHtGdO3k205XG0xzASWGmMSgKXWdE3FwE3GmH7ABOA5EQlzWv4/xpjB1mOji3mU8ikzxiVy5GQZb6/WVoOCD9dnkX3sFNPHJSJi3/j0rhaGycBc6/Vc4MqaKxhj0owx6dbrHCAXiHTxc5XyC8O6hzM6MZJXv93NyVJtNTRnpRWVvPBNBkO7hXFhor1fka4WhihjzEEA67neto+IpADBwG6n2U9Yh5ieFZEQF/Mo5XOmj0vkWHE5c7/fa3cUZaMP1mVx8HgJM8b1trW1AI0oDCKyRES21vKYfCYfJCLRwDvALcaY0x3F/AHoA5wDhAO/r2f720UkVURS8/LyzuSjlfJqg2PDGNu3E69+u5vjp8rtjqNsUFLuaC2kxIUzqldHu+M0XBiMMWONMf1reSwADltf+Ke/+HNrew8RaQd8ATxojFnj9N4HjUMp8CaQUk+O14wxycaY5MhIPRKl/Mv0cYmcKKlgzopMu6MoG7y9ei+5haXcZ/O5hdNcPZS0EJhmvZ4GLKi5gogEA58CbxtjPqyx7HRRERznJ7a6mEcpn9SvS3smDozm9ZV7OHKy1O44yoMKS8p5efluLkiMZHi8/a0FcL0wPAWME5F0YJw1jYgki8gca51fABcAN9dyWep7IrIF2AJEAI+7mEcpnzV9bCIl5ZW8vHx3wysrv/H6yj0cKy7n/ksS7Y7yk0BXNjbG5ANjapmfCvzaev0u8G4d21/syucr5U96dQrlmqExvLNmH78+P47o9q3sjqSa2LGiMuas2MOEfp0ZGBPW8AYeonc+K+VF7h6TgDGGWUsz7I6iPOCVb3dTVFbBDC9qLYAWBqW8Smx4a6amdOPD1Cz2HimyO45qQodPlDB39V6uHNyVxKi2dsepRguDUl7mrot6ERggPLckze4oqgm98E0GFZWGe8cm2B3lZ7QwKOVlOrVrybRze7BgUw47D52wO45qAllHi5m3bj+/OCeW7h3b2B3nZ7QwKOWF7hjdk9CQQJ75apfdUVQT+MfXu2ghwt0Xe19rAbQwKOWVwloHc8eFPVm6M5e1mfl2x1FutPXAcf53Yw63nhdH5/Yt7Y5TKy0MSnmpW86NI6pdCE99tRNjjN1xlJs8vWgX7VsF8dvRPe2OUictDEp5qVbBAdw7NpEN+wv4evthu+MoN/g+4wjfpeXxu4t60r5VkN1x6qSFQSkvdt2wGOIj2/D0VzupqKxqeAPltYwxPPXVTrq0b8lNI3vYHadeWhiU8mKBAS14YHwfducV8dH6bLvjKBd8ueUQm7OPM31cIi2DAuyOUy8tDEp5ufH9ohjSLYxnl6RxqqzS7jjqLJRXVvHMop0kRoVy9dAYu+M0SAuDUl5ORJg5oQ+HT5Tyxqo9dsdRZ2Heuiz25hfzwPg+BLSwv1vthmhhUMoHDI/vyNi+nXh5+W7tltvHFJaU89ziNFLiwhnTt95BLr2GFgalfMTMS/tyqrxSu8rwMS8t301+URkPTuzrFYPwNIYWBqV8RK9OodwwvBv/Xruf9MOFdsdRjZB1tJjXV+7h6iFdvapb7YZoYVDKh9wzNpE2IYE8+eUOu6OoRnhm0S5aCNw/vrfdUc6IS4VBRMJFZLGIpFvPHepYr9Jp9LaFTvPjRGSttf0H1jCgSqk6hLcJ5r8v7sWyXXmsSM+zO46qx4b9x1i4KYf/Oj+eLmG+NeiSqy2GmcBSY0wCsNSars0pY8xg6zHJaf7fgGet7Y8Bt7mYRym/N+3cHsSGt+KJL3ZQWaVdZXgjYwyPf7GDyLYhXt31RV1cLQyTgbnW67nAlY3dUBxnYS4GPjqb7ZVqrkICA5g5oS87DxXy0fosu+OoWvxn6yHW7zvGfeMch/58jauFIcoYcxDAeq7rWqyWIpIqImtE5PSXf0egwBhTYU1nA13r+iARud16j9S8PG1Cq+btsgGdGda9A88sSuNESbndcZSTkvJKnvxyB306t+W65Fi745yVBguDiCwRka21PCafwed0M8YkA9cDz4lIT6C267bqbBcbY14zxiQbY5IjIyPP4KOV8j8iwsNXJJFfVMqsJel2x1FOXv02k+xjp3j4in4+cTNbbRps4xhjxta1TEQOi0i0MeagiEQDuXW8R471nCkiy4EhwMdAmIgEWq2GGCDnLP4MSjVLA2PC+GVyLG99v5cpKbH06uRd4wY3R9nHinlpeQYTB0YzsmdHu+OcNVcPJS0EplmvpwELaq4gIh1EJMR6HQGMArYbRwfzy4Br69teKVW3/xnfm9bBATzy2Xao/rVRAAAQY0lEQVQds8ELPPnlDkTgj5f1tTuKS1wtDE8B40QkHRhnTSMiySIyx1qnL5AqIptwFIKnjDHbrWW/B2aISAaOcw6vu5hHqWalY2gIM8YlsiL9CIu26ZgNdlqVcYQvtxzidxf2oquPXZ5ak/jir4zk5GSTmppqdwylvEJFZRWX/2slJ0srWDJjtNd36eyPyiuruOz5FZRWVPH19Au89u9ARNZb53vrpXc+K+XjAgNa8PAV/cg+dopXvt1td5xm6e3V+0jPPcmfL0/y2qJwJrQwKOUHRvbsyMSB0by8fDf784vtjtOs5J4o4bnFaYxOjGSsj/Se2hAtDEr5iQcn9iWwhfDggq16ItqDHvl8O6WVVTx8RZLP9J7aEC0MSvmJ6PatuH98b75Ly+OzzQftjtMsLNuZyxebD3LXRb2Ijwy1O47baGFQyo/cNLIHA2Pa8+hn2zherHdEN6Xisgoe/N+t9OoUym9Gx9sdx620MCjlRwJaCE9eNYBjxeU89dVOu+P4teeXpHOg4BRPXjWAkEDfP+HsTAuDUn6mf9f23DqqB+//sJ/UvUftjuOXtuecYM7KPUw5J5aUuHC747idFgal/NC9YxPpGtaKP3yyhbKKKrvj+JXKKsMfPt1Ch9ZBzLy0j91xmoQWBqX8UJuQQB6d3I/03JO8tDzD7jh+Ze73e9mUVcCfL08irLV/ji2mhUEpPzWmbxSTB3fhhW8y2HrguN1x/EJm3kmeXrSTi/t0YtKgLnbHaTJaGJTyY49M6keHNsHc/+EmPaTkosoqw/0fbiIkMIC/Xj3Ab+5ZqI0WBqX8WFjrYJ66egA7DxUya6mO2+CKOSsy+XF/AY9M6kdUu5Z2x2lSWhiU8nNj+kZx7bAYXv52N5uyCuyO45PSDxfyj8VpjO/nODzn77QwKNUM/PnyJDq1DeG+DzdRUl5pdxyfUlFZxX0fbiI0JJAnrvLvQ0inaWFQqhlo3yqIp64ZSEbuSf7x9S674/iUl5fvZnP2cR6b3J+I0BC743iEFgalmonRiZHcMKIbs1fs4du0PLvj+ITUvUd5bmk6kwZ1YeLAaLvjeIxLhUFEwkVksYikW88dalnnIhHZ6PQoEZErrWVvicgep2WDXcmjlKrfgxOT6B3VlhkfbCT3RIndcbxaQXEZd7+/ga5hrXjiqv52x/EoV1sMM4GlxpgEYKk1XY0xZpkxZrAxZjBwMVAMfO20yv+cXm6M2ehiHqVUPVoGBfDC9UMoKqvg3g82Ulml3XPXxhjDAx9tJu9kKS9cP4S2LYPsjuRRrhaGycBc6/Vc4MoG1r8W+I8xRkcSUcomCVFteXRSf77fnc/Leld0rd5evY+vtx/m9xP6MDAmzO44HudqYYgyxhwEsJ4bGr5oCvB+jXlPiMhmEXlWROo8syMit4tIqoik5uXp8VGlXHFdcgyTBnXh2SXprNOO9qrZlnOcJ77YwcV9OnHbeXF2x7FFg4VBRJaIyNZaHpPP5INEJBoYACxymv0HoA9wDhAO/L6u7Y0xrxljko0xyZGRkWfy0UqpGkSEJ67qT0yHVtz9/gaOnCy1O5JXOH6qnLv+vYEObYL4+3WDmsWlqbVpsDAYY8YaY/rX8lgAHLa+8E9/8efW81a/AD41xvw0eogx5qBxKAXeBFJc++MopRqrbcsgXrx+KEeLyrjj3fXNvsuMyirD3e9vIOtoMf+aOpTwNv7ZQV5juHooaSEwzXo9DVhQz7pTqXEYyamoCI7zE1tdzKOUOgP9u7bnmesGsW7vMR5euK1ZjxX99Fc7+TYtj0cn9/fLMRbOhKuF4SlgnIikA+OsaUQkWUTmnF5JRHoAscC3NbZ/T0S2AFuACOBxF/Mopc7QpEFduPPCnrz/w37eXbPP7ji2+HRDNq9+l8mNI7pz/fBudsexXaArGxtj8oExtcxPBX7tNL0X6FrLehe78vlKKfe4/5Le7DpUyCOfbadXp7aM7NnR7kgesymrgN9/vIUR8eE8dEWS3XG8gt75rJSiRQvhuSmD6RHRhjvfW8/eI0V2R/KIg8dPcfs7qXRqG8JLvxpGUIB+JYIWBqWUpW3LIGbflAzADa+v5bCf3xl9tKiMG1//gaLSSmbflNysTzbXpIVBKfWTuIg2zL01hWNFZdz4+loKisvsjtQkTpZWcMubP5B1tJg505LpG93O7kheRQuDUqqagTFhzL4pmb1HirnlrXUUl1XYHcmtSisq+c07qWzNOcGL1w9lRHzzOZ/SWFoYlFI/c26vCGZNHcKmrAJ+847/3ONQUVnFPe9vZFVGPs9cO5CxSVF2R/JKWhiUUrWa0L8zT109kBXpR7jzvfU+P8BPeWUVM+Zv4qtth3jo8iSuHhpjdySvpYVBKVWnX5wTy2NX9mfpzlxufvMHCkvKG97IC50qq+T2t1NZuCmHmZf24dZm2gdSY2lhUErV68YR3Xnul4NJ3XuM62evJd/H+lU6fqqcm95Yy/K0PP569QB+O7qn3ZG8nhYGpVSDJg/uyms3DSPtcCHXvbqanIJTdkdqlLzCUqa+toaNWQX8a+oQpqboXc2NoYVBKdUoF/eJ4p3bhpN3opQrX1zl9d11b8k+zlUvrWLPkSLmTDuHywd2sTuSz9DCoJRqtJS4cD68YyStgwOY8toa5qzI9LqO94wx/Hvtfq55+Xuqqgzv3z6C0YnaVf+Z0MKglDojfTq3Y+F/n8eYPp14/Isd3Pnej15zUvpUWSX3fbiJP366heHx4Xx+9/kMjm1+I7C5SguDUuqMtWsZxKs3DuOPl/Xh6+2HmfTCKlbvzrc104/7j3Hli6v4dMMB7hmTwFu3pGg3F2dJC4NS6qyICLdf0JN//3o45ZVVTJ29hnvnbSC30LN9LB0tKmPmx5u5+qXvKThVxps3n8P0cYkEtGieo6+5g3jb8cHGSE5ONqmpqXbHUEpZSsoreWlZBq98m0lIYAumj0vkxpHdm7S30soqw/zULP721U5OllRw63lx3D0mgdAQl0YT8Gsist4Yk9zgeq4UBhG5DvgL0BdIscZhqG29CcDzQAAwxxhzekCfOGAejvGefwRuNMY02GuXFgalvNOeI0U8vHAb36Xl0bldS24c2Z3rU7rRwY2HdI6fKmf+uizmrt5L9rFTpMSF8/iV/UmMauu2z/BXnioMfYEq4FXg/toKg4gEAGk4RnjLBtYBU40x20VkPvCJMWaeiLwCbDLGvNzQ52phUMp7GWNYnpbHGyv3sCL9CCGBLbhqSFeuS45hUEwYgWfRiqisMmw9cJyPf8zmo/XZFJdVMjwunFvPi+OSpCgcowOrhjS2MLg6gtsO68PqWy0FyDDGZFrrzgMmi8gO4GLgemu9uThaHw0WBqWU9xIRLurdiYt6dyLtcCFvrtrLpxuymbcui9CQQIbHhXNurwiSu3cgql1LwtsEExz4/8WivLKKo0Vl5J4oZUPWMVamH2FNZj4nSioIDmjBpMFduGVUD/p1aW/jn9K/eeJgXFcgy2k6GxgOdAQKjDEVTvN/NvynUsp3JUa15a9XD2DmhD6szDjCqt1HWJVxhKU7c6ut175VEGGtgzh+qpyC4uqXvnYNa8WE/p0Z1SuC8xMi9UojD2iwMIjIEqBzLYv+ZIxZ0IjPqK05YeqZX1eO24HbAbp109valfIl7VsHMXFgNBMHRgOQfayYrQdOkF9UypHCMvKLSikoLqd9qyA6hgbTMTSEiDbBJHVpR7fw1nqoyMMaLAzGmLEufkY2EOs0HQPkAEeAMBEJtFoNp+fXleM14DVwnGNwMZNSykYxHVoT06G13TFUHTxxH8M6IEFE4kQkGJgCLDSOs97LgGut9aYBjWmBKKWUakIuFQYRuUpEsoGRwBcissia30VEvgSwWgN3AYuAHcB8Y8w26y1+D8wQkQwc5xxedyWPUkop1+kNbkop1Uw09nJV7RJDKaVUNVoYlFJKVaOFQSmlVDVaGJRSSlWjhUEppVQ1PnlVkojkAfvOcvMIHDfX+QLN2jQ0q/v5Sk5o3lm7G2MaHOfUJwuDK0QktTGXa3kDzdo0NKv7+UpO0KyNoYeSlFJKVaOFQSmlVDXNsTC8ZneAM6BZm4ZmdT9fyQmatUHN7hyDUkqp+jXHFoNSSql6NKvCICITRGSXiGSIyEy78zgTkb0iskVENopIqjUvXEQWi0i69dzBpmxviEiuiGx1mldrNnGYZe3jzSIy1Auy/kVEDlj7dqOIXOa07A9W1l0iMt7DWWNFZJmI7BCRbSJyjzXf6/ZtPVm9bt+KSEsR+UFENllZH7Hmx4nIWmu/fmANA4CIhFjTGdbyHjbnfEtE9jjt08HWfM/9/RtjmsUDCAB2A/FAMLAJSLI7l1O+vUBEjXlPAzOt1zOBv9mU7QJgKLC1oWzAZcB/cIzQNwJY6wVZ/wLcX8u6Sda/gxAgzvr3EeDBrNHAUOt1WyDNyuR1+7aerF63b639E2q9DgLWWvtrPjDFmv8KcIf1+k7gFev1FOADm3O+BVxby/oe+/tvTi2GFCDDGJNpjCkD5gGTbc7UkMnAXOv1XOBKO0IYY74DjtaYXVe2ycDbxmENjlH6oj2TtM6sdZkMzDPGlBpj9gAZOP6deIQx5qAx5kfrdSGO8Uq64oX7tp6sdbFt31r756Q1GWQ9DHAx8JE1v+Z+Pb2/PwLGiDT9WKL15KyLx/7+m1Nh6ApkOU1nU/8/bE8zwNcisl4c41sDRBljDoLjPybQybZ0P1dXNm/dz3dZze83nA7JeU1W6/DFEBy/Gr1639bICl64b0UkQEQ2ArnAYhwtlgLjGDisZp6fslrLj+MYOMzjOY0xp/fpE9Y+fVZEQmrmtDTZPm1OhaG2XwDedEnWKGPMUOBS4HcicoHdgc6SN+7nl4GewGDgIPAPa75XZBWRUOBj4F5jzIn6Vq1lnkfz1pLVK/etMabSGDMYx1jyKUDfevLYlrVmThHpD/wB6AOcA4TjGOnSozmbU2HIBmKdpmOAHJuy/IwxJsd6zgU+xfGP+fDppqL1nGtfwp+pK5vX7WdjzGHrP2AVMJv/P6Rhe1YRCcLxRfueMeYTa7ZX7tvasnrzvrXyFQDLcRyTDxORwFry/JTVWt6exh+OdHfOCdZhO2OMKQXexIZ92pwKwzogwboyIRjHSaaFNmcCQETaiEjb06+BS4CtOPJNs1abBiywJ2Gt6sq2ELjJuoJiBHD89GERu9Q4DnsVjn0LjqxTrKtS4oAE4AcP5hIc45zvMMb802mR1+3burJ6474VkUgRCbNetwLG4jgnsgy41lqt5n49vb+vBb4x1tleG3LudPpRIDjOgzjvU8/8/TfVWW1vfOA4q5+G43jjn+zO45QrHscVHJuAbaez4TjOuRRIt57Dbcr3Po7DBOU4frXcVlc2HM3dF619vAVI9oKs71hZNuP4zxXttP6frKy7gEs9nPU8HIcCNgMbrcdl3rhv68nqdfsWGAhssDJtBR6y5sfjKE4ZwIdAiDW/pTWdYS2PtznnN9Y+3Qq8y/9fueSxv3+981kppVQ1zelQklJKqUbQwqCUUqoaLQxKKaWq0cKglFKqGi0MSimlqtHCoJRSqhotDEopparRwqCUUqqa/wOUYTQLxpvX4QAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt # import the plotting module\n", "# call this magic command to show the plots in the notebook\n", "%matplotlib inline\n", "\n", "plt.plot(thetas_in_degrees,sines); # plot the sines with the angles" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "### Features and styling in matplotlib\n", "\n", "Every plot should at least have axis labels and can also have a title, a legend, bounds, etc. We can use **matplotlib.pyplot** to add these features and more.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# I want to plot the sine curve as a green line, so I use 'g-' to do that:\n", "plt.plot(thetas_in_degrees,sines,'g-',label='Sine') \n", "# the \"label\" argument saves this line for annotation in a legend\n", "# let's add X and Y labels\n", "plt.xlabel('Degrees') # make and X label\n", "plt.ylabel('Sine') # label the Y axis\n", "# and now change the x axis limits: \n", "plt.xlim([0,360]) # set the limits\n", "plt.title('Sine curve') # set the title\n", "plt.legend(); # put on a legend! " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now let's add the cosine curve and a bit of style! We'll plot the cosine curve as a dashed blue line ('b--'), move the legend to a different position and plot the sine curve as little red dots ('r.').\n", "For a complete list of possible symbols (markers), see: http://matplotlib.org/api/markers_api.html" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "cosines=np.cos(thetas_in_radians)\n", "# plot the sines with the angles as a green line\n", "plt.plot(thetas_in_degrees,sines,'r.',label='Sine') \n", "# plot the cosines with the angles as a dashed blue line\n", "plt.plot(thetas_in_degrees,cosines,'b--',label='Cosine') \n", "plt.xlabel('Degrees')\n", "plt.ylabel('Trig functions')\n", "plt.xlim([0,360]) # set the limits\n", "plt.legend(loc=3); # put the legend in the lower left hand corner this time" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The function **plt.plot( )** in **matplotlib.pyplot** includes many more styling options. Here's a complete list of arguments and keyword arguments that plot accepts:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on function plot in module matplotlib.pyplot:\n", "\n", "plot(*args, **kwargs)\n", " Plot y versus x as lines and/or markers.\n", " \n", " Call signatures::\n", " \n", " plot([x], y, [fmt], data=None, **kwargs)\n", " plot([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)\n", " \n", " The coordinates of the points or line nodes are given by *x*, *y*.\n", " \n", " The optional parameter *fmt* is a convenient way for defining basic\n", " formatting like color, marker and linestyle. It's a shortcut string\n", " notation described in the *Notes* section below.\n", " \n", " >>> plot(x, y) # plot x and y using default line style and color\n", " >>> plot(x, y, 'bo') # plot x and y using blue circle markers\n", " >>> plot(y) # plot y using x as index array 0..N-1\n", " >>> plot(y, 'r+') # ditto, but with red plusses\n", " \n", " You can use `.Line2D` properties as keyword arguments for more\n", " control on the appearance. Line properties and *fmt* can be mixed.\n", " The following two calls yield identical results:\n", " \n", " >>> plot(x, y, 'go--', linewidth=2, markersize=12)\n", " >>> plot(x, y, color='green', marker='o', linestyle='dashed',\n", " linewidth=2, markersize=12)\n", " \n", " When conflicting with *fmt*, keyword arguments take precedence.\n", " \n", " **Plotting labelled data**\n", " \n", " There's a convenient way for plotting objects with labelled data (i.e.\n", " data that can be accessed by index ``obj['y']``). Instead of giving\n", " the data in *x* and *y*, you can provide the object in the *data*\n", " parameter and just give the labels for *x* and *y*::\n", " \n", " >>> plot('xlabel', 'ylabel', data=obj)\n", " \n", " All indexable objects are supported. This could e.g. be a `dict`, a\n", " `pandas.DataFame` or a structured numpy array.\n", " \n", " \n", " **Plotting multiple sets of data**\n", " \n", " There are various ways to plot multiple sets of data.\n", " \n", " - The most straight forward way is just to call `plot` multiple times.\n", " Example:\n", " \n", " >>> plot(x1, y1, 'bo')\n", " >>> plot(x2, y2, 'go')\n", " \n", " - Alternatively, if your data is already a 2d array, you can pass it\n", " directly to *x*, *y*. A separate data set will be drawn for every\n", " column.\n", " \n", " Example: an array ``a`` where the first column represents the *x*\n", " values and the other columns are the *y* columns::\n", " \n", " >>> plot(a[0], a[1:])\n", " \n", " - The third way is to specify multiple sets of *[x]*, *y*, *[fmt]*\n", " groups::\n", " \n", " >>> plot(x1, y1, 'g^', x2, y2, 'g-')\n", " \n", " In this case, any additional keyword argument applies to all\n", " datasets. Also this syntax cannot be combined with the *data*\n", " parameter.\n", " \n", " By default, each line is assigned a different style specified by a\n", " 'style cycle'. The *fmt* and line property parameters are only\n", " necessary if you want explicit deviations from these defaults.\n", " Alternatively, you can also change the style cycle using the\n", " 'axes.prop_cycle' rcParam.\n", " \n", " Parameters\n", " ----------\n", " x, y : array-like or scalar\n", " The horizontal / vertical coordinates of the data points.\n", " *x* values are optional. If not given, they default to\n", " ``[0, ..., N-1]``.\n", " \n", " Commonly, these parameters are arrays of length N. However,\n", " scalars are supported as well (equivalent to an array with\n", " constant value).\n", " \n", " The parameters can also be 2-dimensional. Then, the columns\n", " represent separate data sets.\n", " \n", " fmt : str, optional\n", " A format string, e.g. 'ro' for red circles. See the *Notes*\n", " section for a full description of the format strings.\n", " \n", " Format strings are just an abbreviation for quickly setting\n", " basic line properties. All of these and more can also be\n", " controlled by keyword arguments.\n", " \n", " data : indexable object, optional\n", " An object with labelled data. If given, provide the label names to\n", " plot in *x* and *y*.\n", " \n", " .. note::\n", " Technically there's a slight ambiguity in calls where the\n", " second label is a valid *fmt*. `plot('n', 'o', data=obj)`\n", " could be `plt(x, y)` or `plt(y, fmt)`. In such cases,\n", " the former interpretation is chosen, but a warning is issued.\n", " You may suppress the warning by adding an empty format string\n", " `plot('n', 'o', '', data=obj)`.\n", " \n", " \n", " Other Parameters\n", " ----------------\n", " scalex, scaley : bool, optional, default: True\n", " These parameters determined if the view limits are adapted to\n", " the data limits. The values are passed on to `autoscale_view`.\n", " \n", " **kwargs : `.Line2D` properties, optional\n", " *kwargs* are used to specify properties like a line label (for\n", " auto legends), linewidth, antialiasing, marker face color.\n", " Example::\n", " \n", " >>> plot([1,2,3], [1,2,3], 'go-', label='line 1', linewidth=2)\n", " >>> plot([1,2,3], [1,4,9], 'rs', label='line 2')\n", " \n", " If you make multiple lines with one plot command, the kwargs\n", " apply to all those lines.\n", " \n", " Here is a list of available `.Line2D` properties:\n", " \n", " agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n", " alpha: float (0.0 transparent through 1.0 opaque) \n", " animated: bool \n", " antialiased or aa: bool \n", " clip_box: a `.Bbox` instance \n", " clip_on: bool \n", " clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n", " color or c: any matplotlib color \n", " contains: a callable function \n", " dash_capstyle: ['butt' | 'round' | 'projecting'] \n", " dash_joinstyle: ['miter' | 'round' | 'bevel'] \n", " dashes: sequence of on/off ink in points \n", " drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n", " figure: a `.Figure` instance \n", " fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n", " gid: an id string \n", " label: object \n", " linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n", " linewidth or lw: float value in points \n", " marker: :mod:`A valid marker style `\n", " markeredgecolor or mec: any matplotlib color \n", " markeredgewidth or mew: float value in points \n", " markerfacecolor or mfc: any matplotlib color \n", " markerfacecoloralt or mfcalt: any matplotlib color \n", " markersize or ms: float \n", " markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n", " path_effects: `.AbstractPathEffect` \n", " picker: float distance in points or callable pick function ``fn(artist, event)`` \n", " pickradius: float distance in points\n", " rasterized: bool or None \n", " sketch_params: (scale: float, length: float, randomness: float) \n", " snap: bool or None \n", " solid_capstyle: ['butt' | 'round' | 'projecting'] \n", " solid_joinstyle: ['miter' | 'round' | 'bevel'] \n", " transform: a :class:`matplotlib.transforms.Transform` instance \n", " url: a url string \n", " visible: bool \n", " xdata: 1D array \n", " ydata: 1D array \n", " zorder: float \n", " \n", " Returns\n", " -------\n", " lines\n", " A list of `.Line2D` objects representing the plotted data.\n", " \n", " \n", " See Also\n", " --------\n", " scatter : XY scatter plot with markers of variing size and/or color (\n", " sometimes also called bubble chart).\n", " \n", " \n", " Notes\n", " -----\n", " **Format Strings**\n", " \n", " A format string consists of a part for color, marker and line::\n", " \n", " fmt = '[color][marker][line]'\n", " \n", " Each of them is optional. If not provided, the value from the style\n", " cycle is used. Exception: If ``line`` is given, but no ``marker``,\n", " the data will be a line without markers.\n", " \n", " **Colors**\n", " \n", " The following color abbreviations are supported:\n", " \n", " ============= ===============================\n", " character color\n", " ============= ===============================\n", " ``'b'`` blue\n", " ``'g'`` green\n", " ``'r'`` red\n", " ``'c'`` cyan\n", " ``'m'`` magenta\n", " ``'y'`` yellow\n", " ``'k'`` black\n", " ``'w'`` white\n", " ============= ===============================\n", " \n", " If the color is the only part of the format string, you can\n", " additionally use any `matplotlib.colors` spec, e.g. full names\n", " (``'green'``) or hex strings (``'#008000'``).\n", " \n", " **Markers**\n", " \n", " ============= ===============================\n", " character description\n", " ============= ===============================\n", " ``'.'`` point marker\n", " ``','`` pixel marker\n", " ``'o'`` circle marker\n", " ``'v'`` triangle_down marker\n", " ``'^'`` triangle_up marker\n", " ``'<'`` triangle_left marker\n", " ``'>'`` triangle_right marker\n", " ``'1'`` tri_down marker\n", " ``'2'`` tri_up marker\n", " ``'3'`` tri_left marker\n", " ``'4'`` tri_right marker\n", " ``'s'`` square marker\n", " ``'p'`` pentagon marker\n", " ``'*'`` star marker\n", " ``'h'`` hexagon1 marker\n", " ``'H'`` hexagon2 marker\n", " ``'+'`` plus marker\n", " ``'x'`` x marker\n", " ``'D'`` diamond marker\n", " ``'d'`` thin_diamond marker\n", " ``'|'`` vline marker\n", " ``'_'`` hline marker\n", " ============= ===============================\n", " \n", " **Line Styles**\n", " \n", " ============= ===============================\n", " character description\n", " ============= ===============================\n", " ``'-'`` solid line style\n", " ``'--'`` dashed line style\n", " ``'-.'`` dash-dot line style\n", " ``':'`` dotted line style\n", " ============= ===============================\n", " \n", " Example format strings::\n", " \n", " 'b' # blue markers with default shape\n", " 'ro' # red circles\n", " 'g-' # green solid line\n", " '--' # dashed line with default color\n", " 'k^:' # black triangle_up markers connected by a dotted line\n", " \n", " .. note::\n", " In addition to the above described arguments, this function can take a\n", " **data** keyword argument. If such a **data** argument is given, the\n", " following arguments are replaced by **data[]**:\n", " \n", " * All arguments with the following names: 'x', 'y'.\n", "\n" ] } ], "source": [ "help(plt.plot)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Reading in text files\n", "\n", "One VERY useful function in **NumPy** is to read data sets into an array. Arrays are a new kind of data container, very much like lists, but with special attributes. Arrays must be all of one data type (e.g., floating point). Arrays can be operated on in one go, unlike lists that must be operated on element by element. I sneakily showed this to you by taking the cosine of the entire array returned by **np.radians( )**. It took a list and quietly turned it into an array, which I could operate on. Also, arrays don't separate the numbers with commas like lists do. We will see more benefits (and drawbacks) of arrays in the coming lectures. \n", "\n", "#### A brief comparison of lists and arrays:\n", "\n", "The _built-in_ function **range( )** makes a list generator as we have already seen. But the **NumPy** function **np.arange( )** makes and array. Let's compare the two:\n", "\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "[0 1 2 3 4 5 6 7 8 9]\n" ] } ], "source": [ "print (list(range(10)))\n", "print (np.arange(10))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "They are superficially similar (except for the missing commas), but try a simple addition trick:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(10)+2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "versus" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "unsupported operand type(s) for +: 'range' and 'int'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'range' and 'int'" ] } ], "source": [ "range(10)+2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Oh dear! We would have to go through the list one by one to do this addition using a list. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Time for some SCIENCE! \n", "\n", "Let's start with data from an earthquake. We will read in data from an Earthquake available from the IRIS website: http://ds.iris.edu/wilber3/find_event. We can read in the data using the function **np.loadtext( )**. \n", "\n", "I chose the Christmas Day, 2016 magnitude 7.6 Earthquake in Chile (latitude=-43.42, longitude=-73.95). It was recorded at a seismic station run by Scripps Institution of Oceanography called \"Pinyon Flat Observatory\" (PFO, latitude=33.3, longitude=-115.7). " ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 1807. 1749. 1694. ... -14264. -14888. -15489.]\n" ] } ], "source": [ "EQ=np.loadtxt('Datasets/seismicRecord/earthquake.txt') # read in data\n", "print (EQ)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Notice that EQ is NOT a **list** (it would have commas). In fact it is an N-dimensional array (actually only 1 dimensional in this case). You can find out what any object is using the built-in function **type( )**: " ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "numpy.ndarray" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(EQ)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We'll learn more about the _ndarray_ data structure in the next lecture. \n", "\n", "But now, let's plot the earthquake data. " ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(EQ); # the semi-colon suppresses some annoying jibberish, \n", "# try taking it out!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here, **plt.plot( )** plots the array **EQ** against the index number for the elements in the array because we didn't pass a second argument. \n", "\n", "We can decorate this plot in many ways. For example, we can add axis labels and truncate the data with plt.xlim( ), or change the color of the line to name a few: " ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(EQ,'r-') # plots as a red line\n", "plt.xlabel('Arbitrary Time') # puts a label on the X axis\n", "plt.ylabel('Velocity'); # puts a label on the Y axis" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "### Assignment #2\n", "\n", "- Make a notebook and change the name of the notebook to: YourLastNameInitial_HW_02\n", " (for example, CychB_HW_02)\n", "- In a **markdown** cell, write a description of what the notebook does\n", "- Create a **Numpy** array of numbers from 0 to 100\n", "- Create another list that is empty\n", "- Write a **for** loop that takes the square root of all the values in your list of numbers (using **np.sqrt**) and appends them to the empty list. \n", "- Print out all the numbers that are divisible by 4 (using the modulo operator).\n", "- Plot the square roots against the original list. \n", "- Create a dictionary with at least 4 key:value pairs\n", "\n", "- Write your own module that contains at least four functions and uses a dictionary and a list. Include a doc string in your module and a comment before each function that briefly describes the function. Save it with the magic command %%writefile YOURMODULENAME.py\n", "- Import the module into your notebook and call all of the functions. \n", "\n", "Hint: For the purposes of debugging, you will probably want to 'reload' your module as you refine it. To do this\n", "\n", "_from importlib import reload_\n", "\n", "then\n", "\n", "_reload(YOURMODULENAME)_ \n", "\n", "Your code must be fully commented. \n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "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.6.7" } }, "nbformat": 4, "nbformat_minor": 1 }