{ "cells": [ { "cell_type": "markdown", "metadata": { "hide_cell": true }, "source": [ "Make me look good. Click on the cell below and press Ctrl+Enter." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "hide_cell": true }, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from IPython.core.display import HTML\n", "HTML(open('css/custom.css', 'r').read())" ] }, { "cell_type": "markdown", "metadata": { "hide_cell": true }, "source": [ "
SM286D · Introduction to Applied Mathematics with Python · Spring 2020 · Uhan
\n", "\n", "
Lesson 2.
\n", "\n", "

Loops, slicing, and plotting

" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## This lesson..." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Loops\n", "- Slicing\n", "- Building lists of numbers\n", "- Plotting with `matplotlib`" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Loops" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- A __for loop__ allows you to perform the same task or set of tasks on every item in a list.\n", "\n", "- For example, suppose we have a list of band member names. We can use a `for` loop to print each name in the list:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Robbie Robertson\n", "Levon Helm\n", "Richard Manuel\n", "Rick Danko\n", "Garth Hudson\n", "And those are the members of The Band!\n" ] } ], "source": [ "# A list containing the names of the members of The Band\n", "the_band = ['Robbie Robertson', 'Levon Helm', 'Richard Manuel', 'Rick Danko', 'Garth Hudson']\n", "\n", "# Print each member's name\n", "for name in the_band:\n", " print(name)\n", " \n", "# How do we write code outside the for loop?\n", "print('And those are the members of The Band!')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Note the __indentation__ in the above code. In particular, the above code is not the same as\n", "\n", "```python\n", "for name in the_band:\n", "print(name)\n", "```\n", "- Always use Tab to indent – this will keep your indentation consistent." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Often we will want to write a `for` loop over consecutive integers. \n", "\n", "- We can do this using the `range()` function, like this:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n" ] } ], "source": [ "# Print the first five integers, starting at 0\n", "for i in range(5):\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- `range(n)` starts at `0`, increases by `1` until `n - 1`.\n", "- `range(start, stop)` starts at `start`, increases by `1` until `stop - 1`.\n", "- `range(start, stop, step)` starts at `start`, increases by `step` until `stop - 1` is reached or passed." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Example.__ Use a `for` loop to print the even numbers starting at 10 and ending at 20." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10\n", "12\n", "14\n", "16\n", "18\n", "20\n" ] } ], "source": [ "# Write your code here\n", "for i in range(10, 21, 2):\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- We can use `for` loops to repeatedly do something to a variable.\n", "\n", "- For example, we can add the integers from 1 to 10:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "55\n" ] } ], "source": [ "# Create a variable to stored the total value\n", "total = 0\n", "\n", "# Add 1 to 10 to the total value, one at a time\n", "for i in range(1, 11):\n", " # total += i is the same as total = total + i\n", " total += i\n", "\n", "# Print the total\n", "print(total)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Let's take a look at what this code is doing step-by-step. Run the cell below, and a [Python Tutor](http://pythontutor.com) visualization should appear:\n", " - You can use Python Tutor with your own code — just use the link above to go to the Python Tutor website." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from IPython.display import IFrame\n", "IFrame('http://pythontutor.com/iframe-embed.html#code=%23%20Create%20a%20variable%20to%20stored%20the%20total%20value%0Atotal%20%3D%200%0A%0A%23%20Add%201%20to%2010%20to%20the%20total%20value,%20one%20at%20a%20time%0Afor%20i%20in%20range%281,%2011%29%3A%0A%20%20%20%20%23%20total%20%2B%3D%20i%20is%20the%20same%20as%20total%20%3D%20total%20%2B%20i%0A%20%20%20%20total%20%2B%3D%20i%0A%0A%23%20Print%20the%20total%0Aprint%28total%29&codeDivHeight=400&codeDivWidth=350&cumulative=false&curInstr=0&heapPrimitives=nevernest&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false', width=800, height=450)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Note that `total += i` is indented, while `print(total)` is not indented.\n", "\n", "- These indentation levels are very important in Python code!\n", "\n", "- See what happens if you move the `print()` statement inside the `for` loop by changing its indentation level to match that of `total += i`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Slicing lists" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Recall list indexing from the previous lesson.\n", "\n", "- __Quick review.__ How do we get the 3rd element of the list defined below?" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "pear\n" ] } ], "source": [ "# Define a list of fruits\n", "fruits = ['banana', 'apple', 'pear', 'orange', 'grapes', 'watermelon', 'kiwi']\n", "\n", "# Print the 3rd element of the list of fruits\n", "print(fruits[2])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Slicing is like indexing on steroids. 🤪\n", "\n", "- A __slice__ is a specific group of items in a list.\n", "\n", "- `my_list[start:stop]` gives you a new list containing the elements of `my_list` whose indices start at `start` and end at `stop - 1`.\n", "\n", "- `my_list[start:stop:step]` gives you a new list containing the elements of `my_list` whose indices start at `start`, and increase by `step` until `stop - 1` is reached or passed." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['pear', 'orange', 'grapes']\n" ] } ], "source": [ "# Print the 3rd, 4th, and 5th fruits\n", "print(fruits[2:5])" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['banana', 'pear', 'grapes']\n" ] } ], "source": [ "# Print the 1st, 3rd, and 5th fruits\n", "print(fruits[0:5:2])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- If you omit `start`, Python automatically starts your slice at the beginning of `my_list`.\n", "\n", "- If you omit `stop`, Python automatically ends your slice at the end of `my_list`.\n", "\n", "- If you omit `step`, Python automatically assumes a step value of 1." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['orange', 'grapes', 'watermelon', 'kiwi']\n" ] } ], "source": [ "# Print the 4th fruit onwards\n", "print(fruits[3:])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Building lists of numbers" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Using `list()` and `range()`" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- One task we'll need to do often is to build lists of numbers with a particular pattern.\n", "\n", "- One way to do this is to use `list()` with `range()`.\n", "\n", "- If we want a list of the integers between 1 and 5 (inclusive), we can write:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 2, 3, 4, 5]\n" ] } ], "source": [ "# Create list of numbers between 1 and 5 inclusive\n", "integers = list(range(1, 6))\n", "\n", "# Print the list\n", "print(integers)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Using `.append()`" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- We can add an item to the end of a list using `.append()`:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['banana', 'apple', 'pear', 'orange', 'grapes', 'watermelon', 'kiwi', 'guava']\n" ] } ], "source": [ "# Add guava to the list of fruits defined above\n", "fruits.append('guava')\n", "\n", "# Print the list of fruits\n", "print(fruits)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- So, to build a list of numbers, we can start with an empty list and add one number at a time to the list, like this:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 2, 3, 4, 5]\n" ] } ], "source": [ "# Start with empty list\n", "another_integers = []\n", "\n", "# Iterate over the numbers between 1 and 5\n", "# Add each of these numbers to the list\n", "for i in range(1, 6):\n", " another_integers.append(i)\n", " \n", "# Print the list\n", "print(another_integers)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Let's take a look at what this code is doing step-by-step. Run the cell below to make the Python Tutor visualization appear:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from IPython.display import IFrame\n", "IFrame('http://pythontutor.com/iframe-embed.html#code=%23%20Start%20with%20empty%20list%0Aanother_integers%20%3D%20%5B%5D%0A%0A%23%20Iterate%20over%20the%20numbers%20between%201%20and%205%0A%23%20Add%20each%20of%20these%20numbers%20to%20the%20list%0Afor%20i%20in%20range%281,%206%29%3A%0A%20%20%20%20another_integers.append%28i%29%0A%20%20%20%0A%23%20Print%20the%20list%0Aprint%28another_integers%29&codeDivHeight=400&codeDivWidth=350&cumulative=false&curInstr=0&heapPrimitives=false&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false', width=800, height=450)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- This is more flexible, especially when the numbers you want to include are not consecutive integers." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Example.__ Build a list of the decimal numbers $1.0, 1.1, 1.2, \\dots, 4.9, 5.0$. Print the list." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7000000000000002, 1.8, 1.9, 2.0, 2.1, 2.2, 2.3, 2.4000000000000004, 2.5, 2.6, 2.7, 2.8, 2.9000000000000004, 3.0, 3.1, 3.2, 3.3000000000000003, 3.4000000000000004, 3.5, 3.6, 3.7, 3.8000000000000003, 3.9000000000000004, 4.0, 4.1, 4.2, 4.300000000000001, 4.4, 4.5, 4.6, 4.7, 4.800000000000001, 4.9, 5.0]\n" ] } ], "source": [ "# Write your code here\n", "decimals = []\n", "\n", "for i in range(41):\n", " decimals.append(1.0 + 0.1 * i)\n", "\n", "print(decimals)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plotting with Matplotlib" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* If you want to do something in Python, there's a very good chance that there's a package that will help you out.\n", "\n", "* Anaconda, the Python distribution we're using in this class, comes with _many_ useful libraries.\n", "\n", "* You can also install libraries pretty easily — we'll do this later in the course. (Actually, we already did it with Pyomo.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Matplotlib is a Python 2D plotting library that we will use throughout this course.\n", " - Here's the Matplotlib [User's Guide](https://matplotlib.org/users/index.html)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* To use Matplotlib, we first need to `import` it so that we can access its functions, like this:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* `as plt` in the cell above lets us refer to `matplotlib.pyplot` as `plt`.\n", " - This helps us save some keystrokes and keeps our code a bit cleaner." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- The code cell below produces a plot of the parabola $y = x^2$ using Matplotlib. \n", " - Sometimes, you have to run the first cell with Matplotlib code twice in your Jupyter notebook in order for the image to appear." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Create a figure\n", "fig = plt.figure()\n", "\n", "# Draw axes on the figure\n", "ax = fig.add_subplot(1, 1, 1)\n", "\n", "# Create list of values on the x-axis between 0 and 5, with an increment of 0.1\n", "x_values = []\n", "for i in range(51):\n", " x_values.append(0.1 * i)\n", "\n", "# Create list of corresponding y values\n", "y_values = []\n", "for x in x_values:\n", " y_values.append(x**2)\n", "\n", "# Plot the data on the axes\n", "ax.plot(x_values, y_values)\n", "\n", "# Label the axes\n", "ax.set_xlabel('x')\n", "ax.set_ylabel('y')\n", "\n", "# Give the plot a title\n", "ax.set_title('A Parabola Using Matplotlib')\n", "\n", "# Show the figure\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Some notes about the above code:\n", " - `x_values` and `y_values` are lists of the same size.\n", " - `plt.plot(x_values, y_values)` plots the points\n", " \n", " (`x_values[0]`, `y_values[0]`), (`x_values[1]`, `y_values[1]`), (`x_values[2]`, `y_values[2]`), ...\n", " \n", " and connects all these points (by default). You can change this behavior (connected or not connected, colors, shapes, etc.): see [the documentation](https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.plot.html).\n", " - `ax.set_xlabel()` and `ax.set_ylabel()` label the horizontal and vertical axes, respectively. \n", " - `ax.set_title()` sets the title for the axes." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Classwork — on your own!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Problem 1.__ (PCC 4-1: Pizzas) Think of at least three kinds of your favorite pizza. Store these pizza names in a list, and then use a `for` loop to print the name of each pizza.\n", "\n", "- Modify your `for` loop to print a sentence using the name of the pizza instead of printing just the name of the pizza. For each pizza you should have one line of output containing a simple statement like:\n", " \n", "```\n", "I like pepperoni pizza.\n", "```\n", "\n", "- Add a line at the end of your program, outside the for loop, that states how much you like pizza. The output should consist of three or more lines about the kinds of pizza you like and then an additional sentence, such as:\n", " \n", "```\n", "I really love pizza!\n", "```" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Mushroom\n", "Pepperoni\n", "Sausage and Pineapple\n", "I like Mushroom pizza.\n", "I like Pepperoni pizza.\n", "I like Sausage and Pineapple pizza.\n", "I really love pizza!\n" ] } ], "source": [ "# Write your code here\n", "# Build list of pizzas\n", "pizzas = ['Mushroom', 'Pepperoni', 'Sausage and Pineapple']\n", "\n", "# Print pizza names\n", "for p in pizzas:\n", " print(p)\n", "\n", "# Print sentences about pizzas\n", "for p in pizzas:\n", " print(f'I like {p} pizza.')\n", " \n", "# Print a final sentence about pizza\n", "print('I really love pizza!')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Problem 2.__ (PCC 4-11: My Pizzas, Your Pizzas) \n", "\n", "Read about copying lists on page 63 of PCC.\n", "\n", "Start with your code from Problem 1. Make a copy of the list of pizzas, and call it `friend_pizzas`. Then, do the following:\n", "\n", "- Add a new pizza to the original list.\n", "- Add a different pizza to the list `friend_pizzas`.\n", "- Prove that you have two separate lists. \n", " - Print the message, `My favorite pizzas are:`, and then use a `for` loop to print the first list. \n", " - Print the message, `My friend’s favorite pizzas are:`, and then use a `for` loop to print the second list. \n", " - Make sure each new pizza is stored in the appropriate list." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "My favorite pizzas are:\n", "Mushroom\n", "Pepperoni\n", "Sausage and Pineapple\n", "Black Olives\n", "My friend's favorite pizzas are:\n", "Mushroom\n", "Pepperoni\n", "Sausage and Pineapple\n", "Kale and Broccoli\n" ] } ], "source": [ "# Write your code here\n", "# Create copy of list of pizza names called friend_pizzas\n", "friend_pizzas = pizzas[:]\n", "\n", "# Add a new pizza to the original list\n", "pizzas.append('Black Olives')\n", "\n", "# Add a different pizza to the new list\n", "friend_pizzas.append('Kale and Broccoli')\n", "\n", "# Print my favorite pizzas\n", "print('My favorite pizzas are:')\n", "for p in pizzas: \n", " print(p)\n", " \n", "# Print my friend's favorite pizzas\n", "print(\"My friend's favorite pizzas are:\")\n", "for p in friend_pizzas: \n", " print(p)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Problem 3.__ (PCC 4-15: Code Review) \n", "\n", "Read about styling your code on pages 68-70 of PCC.\n", "\n", "Modify the code that you've written for Problems 1 and 2 to comply with PEP 8:\n", "\n", "- Use four spaces for each indentation level. Jupyter should do this automatically. \n", "- Use less than 80 characters on each line. Some Integrated Development Environments (like Spyder) show you a vertical guideline at the 80th character position, but Jupyter does not.\n", "- Don’t use blank lines excessively in your program files." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Problem 4.__ Construct a list consisting of all the odd numbers from 1 to 55. Print the list." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55]\n", "[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55]\n" ] } ], "source": [ "# Write your code here\n", "# Using list() and range()\n", "odd_numbers = list(range(1, 56, 2))\n", "print(odd_numbers)\n", "\n", "# Alternative solution: using .append()\n", "odd_numbers2 = []\n", "for i in range(28):\n", " odd_numbers2.append(1 + 2 * i)\n", "print(odd_numbers2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Problem 5.__ Use a `for` loop to find $\\sum_{k=1}^{1000} \\frac{1}{k^3}$." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The sum evaluates to 1.2020564036593433.\n", "The sum evaluates to 1.2020564036593433.\n" ] } ], "source": [ "# Write your code here\n", "# Initialize the total value of the sum to zero\n", "total = 0\n", "\n", "# Iterate k from 1 to 1000, adding 1/k^3 at each step\n", "for k in range(1, 1001):\n", " total += (1 / k**3)\n", "print(f'The sum evaluates to {total}.')\n", "\n", "# Alternative solution: build a list of the values of 1/k^3 first, then use sum()\n", "values = []\n", "for k in range(1, 1001):\n", " values.append(1 / k**3)\n", "total2 = sum(values)\n", "print(f'The sum evaluates to {total2}.')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Problem 6.__ Using Matplotlib, plot a graph of $y = \\sin(x)$ for values of $x$ between 0 and 5. Use points on the $x$-axis that are 0.1 apart. Label your axes and title your plot.\n", "\n", "You can use the `sin()` function from the `math` library. Make sure to import the `math` library first:\n", "\n", "```python\n", "import math\n", "```\n", "\n", "Then to compute $\\sin(x)$, you can write `math.sin(x)`." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Write your code here\n", "import matplotlib.pyplot as plt\n", "import math\n", "\n", "# Create a figure object\n", "fig = plt.figure()\n", "\n", "# Draw an axis object on the figure\n", "ax = fig.add_subplot(1, 1, 1)\n", "\n", "# Create list of sample points on the x-axis\n", "# between 0 and 5, with an increment of 0.1.\n", "x_values = []\n", "for i in range(51):\n", " x_values.append(0.1 * i)\n", "\n", "# Create list of corresponding points in the y-direction\n", "y_values = []\n", "for x in x_values:\n", " y_values.append(math.sin(x))\n", "\n", "# Plot the data\n", "plt.plot(x_values, y_values)\n", "\n", "# Label the axes\n", "ax.set_xlabel('x')\n", "ax.set_ylabel('y')\n", "\n", "# Give the plot a title\n", "ax.set_title('sin(x)')\n", "\n", "# Show the figure\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Problem 7.__ Compute the sum of the numbers 1, 2, ..., 1000. You can use a `for` loop, or you can use the `sum()` function applied to a list. \n", "\n", "
\n", "There is a story about Carl Friedrich Gauss, pictured below. This problem was assigned to his class when he was a child; his teacher anticipated being able to relax while the children worked. But Gauss summed the list immediately.
\n", "\n", "Let `L` be the list of numbers 1, 2, ..., 1000. Let `M = sorted(L, reverse=True)`. Add `L` and `M`. What do you notice? Is it easy to add the numbers in `L + M`? Can you do it in your head? How are the sums of `L`, `M` and `L + M` related? Can you see what Gauss did? If so, you should be able to give an algebraic expression for the sum of the numbers from 1 to 1000, without using Python. \n", "\n", "\n", "\n", "C. F. Gauss is featued on the German 10DM bill, alongside the graph of the Gaussian distribution from Statistics, buildings at the University of Göttingen, and (on the reverse side), an outline of the German state of Hannover, which Gauss surveyed. Some of the greatest mathematicians were professors at Göttingen, including Gauss, Riemann and Hilbert.\n", "
" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The sum of the numbers 1, 2, ..., 1000 is 500500\n", "The sum of the numbers 1, 2, ..., 1000 is 500500\n" ] } ], "source": [ "# Write your code here\n", "# Using a for loop\n", "sum_of_numbers = 0\n", "for i in range(0, 1001):\n", " sum_of_numbers += i\n", "print(f'The sum of the numbers 1, 2, ..., 1000 is {sum_of_numbers}')\n", "\n", "# Using sum()\n", "list_of_numbers = list(range(0, 1001))\n", "sum_of_numbers2 = sum(list_of_numbers)\n", "print(f'The sum of the numbers 1, 2, ..., 1000 is {sum_of_numbers2}')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Problem 8.__ The Fibonacci numbers are defined in the following way. The first and second Fibonacci numbers $F_1$ and $F_2$ are both equal to 1. The following Fibonacci numbers are defined according to the rule \n", "\n", "\\begin{equation*}\n", "F_{n} = F_{n-1} + F_{n-2},\n", "\\end{equation*}\n", "\n", "for $n \\geq 3$. Create a list of the first 100 Fibonacci numbers. Print the list.\n", "\n", "_Hint._ Read about __negative indexing__ on page 35 of PCC.\n", "\n", "
\n", "Note. It is a fascinating fact that \n", "\\begin{equation*}\n", "F_n = \\left \\lfloor{\\frac{\\phi^n}{\\sqrt{5}} + \\frac{1}{2}} \\right \\rfloor,\n", "\\end{equation*}\n", "where \n", "\\begin{equation*}\n", "\\phi = \\frac{1+\\sqrt{5}}{2}\n", "\\end{equation*} \n", " is the golden ratio. This is a situation where an approximate computation leads to a closed form formula. The Fibonacci numbers are so fascinating that a whole journal, the Fibonacci Quarterly, is devoted to their study. Consecutive Fibonacci numbers arise in many biological applications, including: the arrangements of leaves on a plant stem, the arrangement of pinecone bracts, and the fruit sprouts of a pineapple. See the image below for the appearance in Yellow Chamomile. (source)\n", "\n", "
" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049, 12586269025, 20365011074, 32951280099, 53316291173, 86267571272, 139583862445, 225851433717, 365435296162, 591286729879, 956722026041, 1548008755920, 2504730781961, 4052739537881, 6557470319842, 10610209857723, 17167680177565, 27777890035288, 44945570212853, 72723460248141, 117669030460994, 190392490709135, 308061521170129, 498454011879264, 806515533049393, 1304969544928657, 2111485077978050, 3416454622906707, 5527939700884757, 8944394323791464, 14472334024676221, 23416728348467685, 37889062373143906, 61305790721611591, 99194853094755497, 160500643816367088, 259695496911122585, 420196140727489673, 679891637638612258, 1100087778366101931, 1779979416004714189, 2880067194370816120, 4660046610375530309, 7540113804746346429, 12200160415121876738, 19740274219868223167, 31940434634990099905, 51680708854858323072, 83621143489848422977, 135301852344706746049, 218922995834555169026, 354224848179261915075]\n" ] } ], "source": [ "# Write your code here\n", "fib = [1, 1]\n", "for i in range(0, 98):\n", " fib.append(fib[-1] + fib[-2])\n", " \n", "print(fib) " ] } ], "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.4" } }, "nbformat": 4, "nbformat_minor": 2 }