{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Lecture 5\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "-Histograms: [>>](#Histograms) \n", "--What we saw last week: [>>](#What-we-saw-last-week) \n", "-Plotting a histogram: [>>](#Plotting-a-histogram) \n", "--A detail: [>>](#A-detail) \n", "--Another plot: [>>](#Another-plot) \n", "--Effects of bin width in histograms: [>>](#Effects-of-bin-width-in-histograms) \n", "-Functions in Python: [>>](#Functions-in-Python) \n", "--Built-in functions: [>>](#Built-in-functions) \n", "--Numpy functions: [>>](#Numpy-functions) \n", "-Writing functions: [>>](#Writing-functions) \n", "-Python flow control: [>>](#Python-flow-control) \n", "--For loop: [>>](#For-loop) \n", "--Loops and slices: [>>](#Loops-and-slices) \n", "--Alternative forms of the for loop: [>>](#Alternative-forms-of-the-for-loop) \n", "--While statement: [>>](#While-statement) \n", "--If statement: [>>](#If-statement) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Histograms\n", "\n", "### What we saw last week\n", "\n", "As we have seen before, import `numpy` and `matplotlib.pyplot`, and use the *line magic* `%matplotlib inline` to ensure plots appear in the Notebook!" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline" ] }, { "cell_type": "raw", "metadata": {}, "source": [ "Read in an array:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " \n", "poisson_array \n", " [ 3. 6. 4. 6. 4. 3. 4. 3. 5. 3. 3. 4. 3. 4. 3. 2. 8. 2.\n", " 5. 6. 6. 6. 7. 8. 4. 7. 5. 6. 2. 5. 6. 4. 4. 3. 0. 6.\n", " 5. 3. 5. 4. 2. 7. 2. 1. 2. 4. 5. 5. 4. 5. 4. 2. 1. 5.\n", " 7. 3. 4. 10. 4. 2. 4. 6. 5. 5. 7. 5. 1. 7. 7. 3. 5. 2.\n", " 2. 3. 6. 6. 7. 3. 6. 3. 3. 3. 4. 3. 8. 5. 4. 2. 6. 9.\n", " 7. 2. 4. 6. 6. 3. 4. 4. 6. 3. 5. 5. 5. 5. 5. 2. 1. 8.\n", " 4. 4. 7. 6. 6. 7. 6. 7. 5. 4. 3. 5. 4. 3. 5. 2. 1. 5.\n", " 7. 3. 2. 4. 7. 7. 5. 9. 3. 6. 5. 8. 5. 2. 7. 3. 3. 2.\n", " 4. 5. 5. 6. 6. 4. 12. 8. 4. 6. 2. 3. 1. 5. 3. 5. 6. 1.\n", " 5. 5. 4. 3. 2. 8. 5. 1. 1. 6. 5. 6. 2. 9. 4. 5. 4. 9.\n", " 6. 8. 2. 2. 7. 2. 6. 6. 5. 5. 2. 2. 1. 6. 2. 3. 2. 5.\n", " 8. 5. 3. 3. 1. 1. 8. 4. 5. 7. 4. 9. 4. 5. 6. 0. 6. 6.\n", " 5. 2. 8. 2. 4. 4. 4. 4. 3. 7. 8. 1. 7. 6. 5. 0. 4. 4.\n", " 4. 2. 4. 5. 3. 6. 1. 4. 6. 5. 6. 6. 5. 4. 4. 2. 7. 6.\n", " 6. 5. 3. 4. 4. 4. 6. 10. 3. 6. 7. 8. 1. 7. 3. 0. 4. 5.\n", " 7. 3. 3. 4. 2. 5. 0. 8. 6. 4. 8. 5. 3. 5. 5. 6. 4. 1.\n", " 1. 6. 2. 6. 5. 5. 7. 6. 4. 3. 5. 5. 1. 5. 1. 5. 5. 6.\n", " 3. 7. 7. 5. 4. 4. 3. 5. 9. 3. 6. 2. 2. 1. 7. 4. 7. 4.\n", " 7. 6. 3. 8. 2. 2. 5. 4. 8. 3. 2. 3. 9. 5. 3. 4. 2. 2.\n", " 7. 8. 5. 5. 3. 4. 5. 1. 8. 5. 7. 7. 6. 2. 6. 0. 4. 6.\n", " 8. 1. 2. 6. 1. 3. 5. 2. 5. 5. 6. 2. 6. 3. 5. 5. 9. 3.\n", " 4. 2. 6. 1. 4. 7. 7. 3. 5. 3. 11. 2. 6. 6. 5. 6. 1. 3.\n", " 1. 7. 2. 7. 3. 2. 8. 6. 9. 4. 4. 5. 6. 3. 6. 5. 4. 4.\n", " 5. 2. 7. 7. 5. 6. 8. 4. 6. 1. 1. 3. 3. 2. 7. 2. 5. 6.\n", " 2. 4. 6. 1. 4. 6. 4. 0. 1. 6. 6. 4. 3. 5. 6. 4. 6. 6.\n", " 6. 6. 10. 4. 3. 7. 5. 2. 4. 3. 5. 5. 8. 7. 7. 4. 6. 7.\n", " 7. 3. 3. 4. 6. 7. 4. 8. 1. 7. 6. 4. 4. 4. 7. 4. 5. 11.\n", " 7. 1. 2. 5. 6. 6. 7. 5. 4. 4. 6. 5. 4. 2. 7. 2. 6. 3.\n", " 3. 9. 4. 7. 3. 5. 6. 4. 3. 2. 5. 6. 6. 4. 4. 3. 3. 4.\n", " 6. 3. 8. 7. 2. 8. 9. 4. 0. 5. 8. 3. 5. 1. 5. 6. 6. 6.\n", " 3. 5. 2. 2. 1. 3. 3. 8. 3. 6. 7. 5. 2. 4. 4. 3. 2. 4.\n", " 9. 4. 2. 5. 5. 1. 3. 2. 7. 3. 1. 4. 3. 5. 4. 5. 1. 2.\n", " 5. 3. 5. 2. 5. 6. 4. 4. 3. 4. 11. 5. 5. 7. 4. 3. 2. 1.\n", " 3. 4. 8. 2. 5. 4. 2. 3. 4. 3. 6. 4. 10. 8. 5. 5. 7. 1.\n", " 4. 2. 9. 6. 5. 1. 5. 10. 5. 5. 2. 4. 6. 1. 7. 5. 5. 4.\n", " 5. 1. 7. 4. 3. 4. 3. 3. 6. 6. 4. 7. 7. 6. 5. 10. 2. 7.\n", " 5. 1. 3. 3. 7. 10. 5. 3. 4. 9. 4. 4. 5. 2. 2. 1. 4. 2.\n", " 7. 9. 3. 5. 9. 4. 4. 3. 1. 4. 6. 7. 6. 10. 3. 3. 3. 4.\n", " 8. 1. 9. 1. 4. 4. 2. 4. 4. 3. 3. 3. 8. 5. 6. 2. 5. 4.\n", " 2. 7. 4. 6. 6. 4. 3. 7. 6. 4. 3. 2. 4. 4. 1. 10. 5. 4.\n", " 3. 2. 1. 5. 7. 4. 3. 4. 4. 6. 4. 7. 6. 8. 6. 5. 4. 5.\n", " 0. 0. 5. 6. 10. 2. 2. 5. 5. 2. 6. 8. 6. 7. 3. 3. 2. 5.\n", " 2. 4. 1. 4. 3. 2. 6. 3. 3. 7. 6. 5. 2. 4. 2. 3. 5. 6.\n", " 4. 5. 9. 5. 2. 7. 3. 6. 3. 4. 5. 4. 6. 3. 3. 1. 4. 5.\n", " 4. 4. 5. 4. 6. 3. 2. 5. 4. 4. 7. 5. 6. 7. 11. 1. 6. 4.\n", " 5. 7. 3. 8. 7. 3. 5. 4. 8. 6. 8. 6. 4. 5. 5. 4. 6. 3.\n", " 9. 3. 3. 6. 5. 7. 2. 3. 4. 3. 2. 2. 3. 4. 4. 2. 6. 4.\n", " 6. 4. 4. 4. 4. 5. 6. 5. 6. 5. 6. 10. 5. 3. 4. 2. 4. 5.\n", " 3. 6. 3. 2. 6. 5. 4. 4. 5. 3. 3. 4. 3. 3. 4. 5. 7. 3.\n", " 3. 3. 3. 6. 2. 4. 3. 5. 5. 5. 2. 4. 4. 4. 5. 8. 3. 2.\n", " 6. 0. 5. 7. 4. 4. 6. 0. 3. 6. 7. 5. 4. 3. 3. 6. 5. 7.\n", " 3. 6. 7. 6. 8. 3. 5. 3. 4. 6. 8. 5. 5. 6. 4. 4. 7. 3.\n", " 2. 3. 4. 4. 4. 9. 10. 4. 2. 5. 5. 5. 4. 6. 5. 6. 7. 6.\n", " 5. 4. 3. 5. 2. 4. 4. 4. 3. 9. 7. 1. 5. 6. 6. 2. 9. 5.\n", " 7. 2. 3. 3. 4. 4. 3. 5. 6. 5. 4. 4. 4. 4. 3. 4. 7. 2.\n", " 8. 3. 2. 3. 4. 7. 3. 6. 1. 4.]\n" ] } ], "source": [ "poisson_array = np.loadtxt('poissonDistArr.csv')\n", "print(\" \")\n", "print(\"poisson_array \\n\",poisson_array)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plotting a histogram\n", "\n", "The histogram shows how often numbers occur in our array, or, more precisely, how often numbers occur within particular ranges. Use Numpy to define the edges of the ranges (\"bins\") in which we will count up the occurrences." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " \n", "Histogram bins start at -1.0 finish at 14.0\n", "Number of bins is 15 and width of bins is 1.0\n", "The bin edges are:\n", " [-1. 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14.]\n" ] } ], "source": [ "bin_bot = -1.0\n", "bin_top = 14.0\n", "bin_number = 15\n", "bin_edges, bin_width = np.linspace(bin_bot, bin_top, bin_number + 1, retstep = True)\n", "print(\" \")\n", "print(\"Histogram bins start at\",bin_bot,\"finish at\",bin_top)\n", "print(\"Number of bins is\",bin_number,\"and width of bins is\",bin_width)\n", "print(\"The bin edges are:\\n\",bin_edges)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Calculate some statistics." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " \n", "Number of entries in array is 1000\n", "Mean is 4.531 +- 0.06640059487685333\n", "Standard deviation is 2.099771178009642\n" ] } ], "source": [ "#\n", "# the number of entries in the array\n", "n_events = len(poisson_array) \n", "#\n", "# calculate arithmetic mean of numbers in array\n", "mu = np.mean(poisson_array) \n", "#\n", "# calculate standard deviation (error on a single value - you have looked at this in Phys107!)\n", "sigma = np.std(poisson_array) \n", "#\n", "# calculate error of mean\n", "mu_error = sigma/np.sqrt(n_events) \n", "print(\" \")\n", "print(\"Number of entries in array is\",n_events)\n", "print(\"Mean is\",mu,\"+-\",mu_error)\n", "print(\"Standard deviation is\",sigma)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we wrote this down in a practical, we would have some unhappy demonstrators. So here's a first quick look at how we can improve the print statements, using *format strings* or *f-strings*!" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " \n", "Number of entries in array is 1000.\n", "Mean is 4.53 +- 0.07.\n", "Standard deviation is 2.10.\n" ] } ], "source": [ "print(\" \")\n", "print(f\"Number of entries in array is {n_events}.\")\n", "print(f\"Mean is {mu:.2f} +- {mu_error:.2f}.\")\n", "print(f\"Standard deviation is {sigma:.2f}.\")" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "#\n", "# y coordinate at which to plot mean\n", "y_mu = 1.1*n_events/20 \n", "#\n", "# y coordinate at which to plot RMS\n", "y_sigma = 1.2*n_events/20 \n", "#\n", "plt.figure(figsize = (7, 5))\n", "plt.title('Poisson distribution', fontsize = 14)\n", "plt.xlabel('Data')\n", "plt.ylabel('Relative frequency')\n", "plt.hist(poisson_array, bins = bin_edges, color = 'b')\n", "plt.errorbar(mu, y_mu, xerr = mu_error, marker = '+', color = 'r', label = 'Mean with its error')\n", "plt.errorbar(mu, y_sigma, xerr = sigma/2, marker = '', color = 'c', label = 'RMS')\n", "plt.grid(color = 'g')\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### A detail\n", "\n", "Note how the line showing the size of the RMS is plotted. As `xerr` is used to show quantities like $\\mu \\pm \\mu_{error}$, the total length of the line showing the error is $2\\mu_{error}$ (one $\\mu_{error}$ above and one below the central value). If we want to use `xerr` to plot a line of length $\\sigma$ with $\\mu$ at its centre, we must plot half of the RMS $(\\sigma/2)$ above the central value and half below.\n", "\n", "### Another plot\n", "An alternative way of plotting the line indicating the RMS is shown in the following cell." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "#\n", "# Arrays containing end-points of RMS line\n", "x_RMS = np.array([mu - sigma/2, mu + sigma/2])\n", "y_RMS = np.array([y_sigma, y_sigma])\n", "#\n", "plt.figure(figsize = (7, 5))\n", "plt.title('Poisson distribution', fontsize = 14)\n", "plt.xlabel('Data')\n", "plt.ylabel('Relative frequency')\n", "plt.hist(poisson_array, bins = bin_edges, color = 'b')\n", "#\n", "# Draw line using RMS end-point arrays in 'plt.plot'\n", "plt.plot(x_RMS, y_RMS, marker = '', color = 'c', label = 'RMS')\n", "#\n", "# Can also use lists to define the x and y values in 'plt.plot'; use new y value so can see both RMS lines!\n", "y_sigma_new = 1.3*n_events/20 \n", "plt.plot([mu - sigma/2, mu + sigma/2], [y_sigma_new, y_sigma_new], marker = '', color = 'r', label = 'RMS using list')\n", "#\n", "plt.grid(color = 'g')\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Effects of bin width in histograms\n", "\n", "Look first at the numbers drawn from a Poisson distribution in the `poisson_array` above. Note, these are all integer values (although they are represented as real numbers here - because that's the Numpy default!)." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "bin_bot = -1.0\n", "bin_top = 14.0\n", "bin_number = 30\n", "bin_edges, bin_width = np.linspace(bin_bot, bin_top, bin_number + 1, retstep = True)\n", "#\n", "plt.figure(figsize = (7, 5))\n", "plt.title('Poisson distribution, bin width ' + str(bin_width), fontsize = 14)\n", "plt.xlabel('Data')\n", "plt.ylabel('Relative frequency')\n", "plt.hist(poisson_array, bins = bin_edges, color = 'b')\n", "plt.grid(color = 'g')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Look at a triangular distribution as an example for a distribution containing floats (real numbers)." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " \n", "First 100 entries in triangle_array: \n", " [3.42270998 1.50000018 4.54723958 9.56333691 3.70920304 4.0350516\n", " 3.79709654 2.61050528 2.47534894 4.39091454 3.47972353 8.31760472\n", " 9.39960903 4.14318103 2.17589416 2.86072403 3.8509043 4.8599877\n", " 5.59636802 0.93859185 7.96941263 3.48327613 5.92730479 4.93773275\n", " 4.98444858 2.4048588 0.31143644 6.6443638 6.55949557 0.54321913\n", " 1.19135625 7.47845973 3.42947395 4.40944915 2.74208465 3.61447888\n", " 8.9898208 1.67812173 4.78104148 5.3456935 7.93794701 3.34031007\n", " 4.69363447 5.50194789 3.13033626 6.62140044 6.93219315 7.36509974\n", " 0.91238332 4.80647923 7.393632 4.10596663 3.11315157 9.24419354\n", " 3.80923248 5.19190739 7.03467767 4.28923692 4.75468468 1.01264103\n", " 4.18717193 7.83143009 2.38604016 4.84674895 5.58182481 5.15183149\n", " 2.73564797 3.7788022 7.26491833 1.00783321 5.39289853 4.73521589\n", " 5.40528462 1.97553058 3.30746211 1.39147539 0.8462459 3.36626957\n", " 5.98260299 5.08381204 3.23770275 4.26604267 4.15426704 1.44106924\n", " 6.31845577 5.38838138 2.40231113 3.67024343 7.43990898 3.96631798\n", " 2.57164424 1.76365054 6.04318203 2.19387422 4.37864543 9.36976029\n", " 3.26204173 7.07767596 9.15764621 3.1401759 ]\n" ] } ], "source": [ "triangle_array = np.loadtxt('triangleDistArr.csv')\n", "n_plot = 100\n", "print(\" \")\n", "print(\"First\",n_plot,\"entries in triangle_array: \\n\", triangle_array[0:n_plot])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can set the precision of the printout for Numpy arrays as follows:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "First 100 entries in triangle_array: \n", " [3.423 1.5 4.547 9.563 3.709 4.035 3.797 2.611 2.475 4.391 3.48 8.318\n", " 9.4 4.143 2.176 2.861 3.851 4.86 5.596 0.939 7.969 3.483 5.927 4.938\n", " 4.984 2.405 0.311 6.644 6.559 0.543 1.191 7.478 3.429 4.409 2.742 3.614\n", " 8.99 1.678 4.781 5.346 7.938 3.34 4.694 5.502 3.13 6.621 6.932 7.365\n", " 0.912 4.806 7.394 4.106 3.113 9.244 3.809 5.192 7.035 4.289 4.755 1.013\n", " 4.187 7.831 2.386 4.847 5.582 5.152 2.736 3.779 7.265 1.008 5.393 4.735\n", " 5.405 1.976 3.307 1.391 0.846 3.366 5.983 5.084 3.238 4.266 4.154 1.441\n", " 6.318 5.388 2.402 3.67 7.44 3.966 2.572 1.764 6.043 2.194 4.379 9.37\n", " 3.262 7.078 9.158 3.14 ]\n" ] } ], "source": [ "np.set_printoptions(precision = 3)\n", "print(\"First\",n_plot,\"entries in triangle_array: \\n\", triangle_array[0:n_plot])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now draw the triangle describing the distribution and plot a histogram of the numbers in `triangle_array`." ] }, { "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": [ "n_events = len(triangle_array) \n", "#\n", "# Parameters describing triangle\n", "left = 0.0\n", "mode = 3.5\n", "right = 10.0\n", "#\n", "# Define histogram bins\n", "bin_bot = -1.0\n", "bin_top = 12.0\n", "bin_number = 64\n", "bin_edges, bin_width = np.linspace(bin_bot, bin_top, bin_number + 1, retstep = True)\n", "#\n", "plt.figure(figsize = (7, 5))\n", "plt.title('Triangular distribution, bin width ' + str(bin_width), fontsize = 14)\n", "plt.xlabel('Data')\n", "plt.ylabel('Relative frequency')\n", "plt.hist(triangle_array, bins = bin_edges, color = 'b')\n", "plt.grid(color = 'g')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Functions in Python\n", "\n", "### Built-in functions\n", "We have already seen how we can use functions in Python. Some of these are part of the language, called *built-in* functions." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " \n", "x = -3.14 and the absolute value of x is 3.14.\n" ] } ], "source": [ "print(\" \")\n", "x = -3.14\n", "abs_x = abs(x)\n", "print(f\"x = {x} and the absolute value of x is {abs_x}.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A complete list of these functions is given at: https://docs.python.org/3/library/functions.html.\n", "As these are part of the language, they do not require that any packages are loaded before they are used. \n", "\n", "### Numpy functions\n", "We have also seen examples of functions that are part of the Numpy package." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x = -3.140 and the exponential of x is 0.043.\n" ] } ], "source": [ "import numpy as np\n", "#\n", "exp_x = np.exp(x)\n", "print(f\"x = {x:.3f} and the exponential of x is {exp_x:.3f}.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mathematical functions are also available in the Math package" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x = -3.14 and the exponential of x is 0.043.\n" ] } ], "source": [ "import math\n", "exp_x = math.exp(x)\n", "print(f\"x = {x} and the exponential of x is {exp_x:.3f}.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There is a difference between the Math and Numpy functions; Maths functions will not take arrays as arguments:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "only size-1 arrays can be converted to Python scalars", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mx_array\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1.1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m13.2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mmath_exp_x_array\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmath\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx_array\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mTypeError\u001b[0m: only size-1 arrays can be converted to Python scalars" ] } ], "source": [ "x_array = np.linspace(1.1, 13.2, 3)\n", "math_exp_x_array = math.exp(x_array)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Numpy functions will." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x = [ 1.1 7.15 13.2 ] and the exponentials of x (respectively) are [3.004e+00 1.274e+03 5.404e+05].\n" ] } ], "source": [ "exp_x_array = np.exp(x_array)\n", "print(f\"x = {x_array} and the exponentials of x (respectively) are {exp_x_array}.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For this reason, we will always use the Numpy versions of mathematical functions!\n", "\n", "## Writing functions\n", "\n", "We can also easily create functions in Python. For example, the following function calculates the area of a triangle." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "def triangle_area(base, height):\n", " area = 0.5*base*height\n", " return area" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once we have defined, we can use it as follows:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Area of triangle with base 4.00 mm and height 5.00 mm is 10.00 mm^2.\n" ] } ], "source": [ "b = 4 # mm\n", "h = 5 # mm\n", "a = triangle_area(b, h)\n", "print(f\"Area of triangle with base {b:.2f} mm and height {h:.2f} mm is {a:.2f} mm^2.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can use a function to calculate more than one value:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Area of circle with radius 5.00 mm is 78.54 mm^2, perimeter is 31.42 mm.\n" ] } ], "source": [ "def circle_properties(radius):\n", " area = np.pi*radius**2\n", " perimeter = 2*np.pi*radius\n", " return area, perimeter\n", "#\n", "r = 5 # mm\n", "a, p = circle_properties(r)\n", "print(f\"Area of circle with radius {r:.2f} mm is {a:.2f} mm^2, perimeter is {p:.2f} mm.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We could write the output of the function into a tuple." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Area of circle with radius 5.00 mm is 78.54 mm^2, perimeter is 31.42 mm.\n", "Properties of circle with radius 5.00 mm are \n", "(78.53981633974483, 31.41592653589793).\n" ] } ], "source": [ "props = circle_properties(r)\n", "print(f\"Area of circle with radius {r:.2f} mm is {props[0]:.2f} mm^2, perimeter is {props[1]:.2f} mm.\")\n", "print(f\"Properties of circle with radius {r:.2f} mm are \\n{props}.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As it's a tuple, we can't alter the values in `prop`. " ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "'tuple' object does not support item assignment", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprops\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0.9\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" ] } ], "source": [ "props[0] = 0.9" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Do these functions allow arrays to be used?" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Areas of circles with radii [2. 2.5 3. ] mm are [12.566 19.635 28.274] mm^2 and perimeters are [12.566 15.708 18.85 ] mm, respectively.\n" ] } ], "source": [ "r_array = np.linspace(2, 3, 3)\n", "a_array, p_array = circle_properties(r_array) \n", "print(f\"Areas of circles with radii {r_array} mm are {a_array} mm^2 and perimeters are {p_array} mm, respectively.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Yes! This shows some of the power of using Numpy and Python programs.\n", "\n", "Note that you do have to use Numpy arrays to make this \"vector processing\" work. Look what happens if we try and use a list of values instead of an array:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "unsupported operand type(s) for ** or pow(): 'list' and 'int'", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mr_list\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m2.0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2.5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3.0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0ma_list\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mp_list\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcircle_properties\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mr_list\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Areas of circles with radii {r_list} mm are {a_list} mm^2 and perimeters are {p_list} mm, respectively.\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[1;32m\u001b[0m in \u001b[0;36mcircle_properties\u001b[1;34m(radius)\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mcircle_properties\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mradius\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0marea\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpi\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mradius\u001b[0m\u001b[1;33m**\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3\u001b[0m \u001b[0mperimeter\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpi\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mradius\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0marea\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mperimeter\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;31m#\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for ** or pow(): 'list' and 'int'" ] } ], "source": [ "r_list = [2.0, 2.5, 3.0]\n", "a_list, p_list = circle_properties(r_list) \n", "print(f\"Areas of circles with radii {r_list} mm are {a_list} mm^2 and perimeters are {p_list} mm, respectively.\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "anaconda-cloud": {}, "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.8.5" } }, "nbformat": 4, "nbformat_minor": 4 }