{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "# Conditionals and Loops\n", "\n", "Computer programs are useful for performing repetitive tasks. Without\n", "complaining, getting bored, or growing tired, they can repetitively\n", "perform the same calculations with minor, but important, variations over\n", "and over again. Humans share with computers none of these qualities. And\n", "so we humans employ computers to perform the massive repetitive tasks we\n", "would rather avoid. However, we need efficient ways of telling the\n", "computer to do these repetitive tasks; we don't want to have stop to\n", "tell the computer each time it finishes one iteration of a task to do\n", "the task again, but for a slightly different case. We want to tell it\n", "once, \"Do this task 1000 times with slightly different conditions and\n", "report back to me when you are done.\" This is what **loops** were made\n", "for.\n", "\n", "In the course of doing these repetitive tasks, computers often need to\n", "make decisions. In general, we don't want the computer to stop and ask\n", "us what it should do if a certain result is obtained from its\n", "calculations. We might prefer to say, \"Look, if you get result A during\n", "your calculations, do this, otherwise, do this other thing.\" That is, we\n", "often want to tell the computer ahead of time what to do if it\n", "encounters different situations. This is what **conditionals** were made\n", "for.\n", "\n", "Conditionals and loops control the flow of a program. They are essential\n", "to performing virtually any significant computational task. Python, like\n", "most computer languages, provides a variety of ways of implementing\n", "loops and conditionals.\n", "\n", "single: conditionals\n", "\n", "Conditionals\n", "------------\n", "\n", "Conditional statements allow a computer program to take different\n", "actions based on whether some condition, or set of conditions is true or\n", "false. In this way, the programmer can control the flow of a program.\n", "\n", "### `if`, `elif`, and `else` statements\n", "\n", "The `if`, `elif`, and `else` statements are used to define conditionals\n", "in Python. We illustrate their use with a few examples.\n", "\n", "#### `if`-`elif`-`else` example\n", "\n", "Suppose we want to know if the solutions to the quadratic equation\n", "\n", "$$ax^2 + bx + c = 0$$\n", "\n", "are real, imaginary, or complex for a given set of coefficients $a$,\n", "$b$, and $c$. Of course, the answer to that question depends on the\n", "value of the discriminant $d=b^2-4ac$. The solutions are real if\n", "$d \\ge 0$, imaginary if $b=0$ and $d < 0$, and complex if $b \\ne 0$ and\n", "$d < 0$. The program below implements the above logic in a Python\n", "program.\n", "\n", "``` python\n", "a = float(raw_input(\"What is the coefficients a? \"))\n", "b = float(raw_input(\"What is the coefficients b? \"))\n", "c = float(raw_input(\"What is the coefficients c? \"))\n", "\n", "d = b*b - 4.*a*c\n", "\n", "if d >= 0.0:\n", " print(\"Solutions are real\") # block 1\n", "elif b == 0.0:\n", " print(\"Solutions are imaginary\") # block 2\n", "else:\n", " print(\"Solutions are complex\") # block 3\n", "\n", "print(\"Finished!\")\n", "```\n", "\n", "After getting the inputs of from the user, the program evaluates the\n", "discriminant $d$. The code `d >= 0.0` has a boolean truth value of\n", "either `True` or `False` depending on whether or not $d \\ge 0$. You can\n", "check this out in the interactive IPython shell by typing the following\n", "set of commands\n", "\n", "``` ipython\n", "In [2]: d = 5\n", "\n", "In [3]: d >= 2\n", "Out[3]: True\n", "\n", "In [4]: d >= 7\n", "Out[4]: False\n", "```\n", "\n", "Therefore, the `if` statement in line 7 is simply testing to see if the\n", "statement `d >= 0.0` if `True` or `False`. If the statement is `True`,\n", "Python executes the indented block of statements following the `if`\n", "statement. In this case, there is only one line in indented block. Once\n", "it executes this statement, Python skips past the `elif` and `else`\n", "blocks and executes the `print(\"Finished!\")` statement.\n", "\n", "If the `if` statement in line 7 is `False`, Python skips the indented\n", "block directly below the `if` statement and executes the `elif`\n", "statement. If the condition `b == 0.0` is `True`, it executes the\n", "indented block immediately below the `elif` statement and then skips the\n", "`else` statement and the indented block below it. It then executes the\n", "`print(\"Finished!\")` statement.\n", "\n", "Finally, if the `elif` statement is `False`, Python skips to the `else`\n", "statement and executes the block immediately below the `else` statement.\n", "Once finished with that indented block, it then executes the\n", "`print(\"Finished!\")` statement.\n", "\n", "As you can see, each time a `False` result is obtained in an `if` or\n", "`elif` statement, Python skips the indented code block associated with\n", "that statement and drops down to the next conditional statement, that\n", "is, the next `elif` or `else`. A flowchart of the if-elif-else code is\n", "shown below.\n", "\n", "
\n", "\"\"
Flowchart for if-elif-else code.
\n", "
\n", "\n", "At the outset of this problem we stated that the solutions to the\n", "quadratic equation are imaginary only if $b=0$ and $d < 0$. In the\n", "`elif b == 0.0` statement on line 9, however, we only check to see if\n", "$b=0$. The reason that we don't have to check if $d < 0$ is that the\n", "`elif` statement is executed only if the condition `if d >= 0.0` on line\n", "7 is `False`. Similarly, we don't have to check if if $b=0$ and $d < 0$\n", "for the final `else` statement because this part of the `if`, `elif`,\n", "and `else` block will only be executed if the preceding `if` and `elif`\n", "statements are `False`. This illustrates a key feature of the `if`,\n", "`elif`, and `else` statements: these statements are executed\n", "sequentially until one of the `if` or `elif` statements is found to be\n", "`True`. Therefore, Python reaches an `elif` or `else` statement only if\n", "all the preceding `if` and `elif` statements are `False`.\n", "\n", "The `if`-`elif`-`else` logical structure can accomodate as many `elif`\n", "blocks as desired. This allows you to set up logic with more than the\n", "three possible outcomes illustrated in the example above. When designing\n", "the logical structure you should keep in mind that once Python finds a\n", "true condition, it skips all subsequent `elif` and `else` statements in\n", "a given `if`, `elif`, and `else` block, irrespective of their truth\n", "values.\n", "\n", "#### `if`-`else` example\n", "\n", "You will often run into situations where you simply want the program to\n", "execute one of two possible blocks based on the outcome of an `if`\n", "statement. In this case, the `elif` block is omitted and you simply use\n", "an `if`-`else` structure. The following program testing whether an\n", "integer is even or odd provides a simple example.\n", "\n", "``` ipython\n", "a = int(raw_input(\"Please input an integer: \"))\n", "if a%2 == 0:\n", " print(\"{0:0d} is an even number.\".format(a))\n", "else:\n", " print(\"{0:0d} is an odd number.\".format(a))\n", "```\n", "\n", "The flowchart below shows the logical structure of an `if`-`else`\n", "structure.\n", "\n", "
\n", "\"\"
Flowchart for if-else code.
\n", "
\n", "\n", "#### `if` example\n", "\n", "The simplest logical structure you can make is a simple `if` statement,\n", "which executes a block of code if some condition is met but otherwise\n", "does nothing. The program below, which takes the absolute value of a\n", "number, provides a simple example of such a case.\n", "\n", "``` ipython\n", "a = eval(raw_input(\"Please input a number: \"))\n", "if a < 0:\n", " a = -a\n", "print(\"The absolute value is {0}\".format(a))\n", "```\n", "\n", "When the block of code in an `if` or `elif` statement is only one line\n", "long, you can write it on the same line as the `if` or `elif` statement.\n", "For example, the above code can be written as follows.\n", "\n", "``` ipython\n", "a = eval(raw_input(\"Please input a number: \"))\n", "if a < 0: a = -a\n", "print(\"The absolute value is {0}\".format(a))\n", "```\n", "\n", "This works exactly as the preceding code. Note, however, that if the\n", "block of code associated with an `if` or `elif` statement is more than\n", "one line long, the entire block of code should be written as indented\n", "text below the `if` or `elif` statement.\n", "\n", "The flowchart below shows the logical structure of a simple `if`\n", "structure.\n", "\n", "
\n", "\"\"
Flowchart for if code.
\n", "
\n", "\n", "single: logical operators\n", "\n", "### Logical operators\n", "\n", "It is important to understand that \"`==`\" in Python is not the same as\n", "\"`=`\". The operator \"`=`\" is the assignment operator: `d = 5` assigns\n", "the value of 5 to the valiable `d`. On the other hand \"`==`\" is the\n", "*logical equals operator* and `d == 5` is a *logical truth statement*.\n", "It tells Python to check to see if `d` is equal to `5` or not, and\n", "assigns a value of `True` or `False` to the statement `d == 5` depending\n", "on whether or not `d` is equal to `5`. The table below summarizes the\n", "various logical operators available in Python.\n", "\n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", "> \n", ">
operatorfunction
<less than
<=less than or equal to
>greater than
>=greater than or equal to
==equal
!=not equal
andboth must be true
orone or both must be true
notreverses the truth value
\n", ">\n", "> Logical operators in Python\n", "\n", "The table above list three logical operators, `and`, `or`, and `not`,\n", "that we haven't encountered before. There are useful for combining\n", "different logical conditions. For example, suppose you want to check if\n", "$a>2$ and $b<10$ simultaneously. To do so, you would write\n", "`a>2 and b<10`. The code below illustrates the use of the logical\n", "operators `and`, `or`, and `not`.\n", "\n", "``` ipython\n", "In [5]: a = 5\n", "\n", "In [6]: b = 10\n", "\n", "In [7]: a != 5 # a is not equal to 5\n", "Out[7]: False\n", "\n", "In [8]: a>2 and b<20\n", "Out[8]: True\n", "\n", "In [9]: a>2 and b>10\n", "Out[9]: False\n", "\n", "In [10]: a>2 or b>10\n", "Out[10]: True\n", "\n", "In [11]: a>2\n", "Out[11]: True\n", "\n", "In [12]: not a>2\n", "Out[12]: False\n", "```\n", "\n", "Logical statements like those above can be used in `if`, `elif`, and, as\n", "we shall see below, `while` statements, according to your needs.\n", "\n", "single: loops\n", "\n", "Loops\n", "-----\n", "\n", "In computer programming a *loop* is statement or block of statements\n", "that is executed repeatedly. Python has two kinds of loops, a `for` loop\n", "and a `while` loop. We first introduce the `for` loop and illustrate its\n", "use for a variety of tasks. We then introduce the `while` loop and,\n", "after a few illustrative examples, compare the two kinds of loops and\n", "discuss when to use one or the other.\n", "\n", "single: loops; for loops\n", "\n", "### `for` loops\n", "\n", "The general form of a `for` loop in Python is\n", "\n", "``` python\n", "for in :\n", " \n", "```\n", "\n", "where `` is a variable, `` is a sequence such as\n", "list or string or array, and `` is a series of Python commands to\n", "be executed repeatedly for each element in the ``. The\n", "`` is indented from the rest of the text, which difines the extent\n", "of the loop. Let's look at a few examples.\n", "\n", "``` python\n", "for dogname in [\"Max\", \"Molly\", \"Buster\", \"Maggie\", \"Lucy\"]:\n", " print(dogname)\n", " print(\" Arf, arf!\")\n", "print(\"All done.\")\n", "```\n", "\n", "Running this program produces the following output.\n", "\n", "``` ipython\n", "In [1]: run doggyloop.py\n", "Max\n", " Arf, arf!\n", "Molly\n", " Arf, arf!\n", "Buster\n", " Arf, arf!\n", "Maggie\n", " Arf, arf!\n", "Lucy\n", " Arf, arf!\n", "All done.\n", "```\n", "\n", "The `for` loop works as follows: the *iteration variable* or *loop\n", "index* `dogname` is set equal to the first element in the list, `\"Max\"`,\n", "and then the two lines in the indented body are executed. Then `dogname`\n", "is set equal to second element in the list, `\"Molly\"`, and the two lines\n", "in the indented body are executed. The loop cycles through all the\n", "elements of the list, and then moves on to the code that follows the\n", "`for` loop and prints `All done.`\n", "\n", "When indenting a block of code in a Python `for` loop, it is critical\n", "that every line be indented by the same amount. Using the **\\**\n", "key causes the Code Editor to indent 4 spaces. Any amount of indentation\n", "works, as long as it is the same for all lines in a `for` loop. While\n", "code editors designed to work with Python (including Canopy and Spyder)\n", "translate the **\\** key to 4 spaces, not all text editors do. In\n", "those cases, 4 spaces are not equivalent to a **\\** character even\n", "if they appear the same on the display. Indenting some lines by 4 spaces\n", "and other lines by a **\\** character will produce an error. So\n", "beware!\n", "\n", "The figure below shows the flowchart for a `for` loop. It starts with an\n", "implicit conditional asking if there are any more elements in the\n", "sequence. If there are, it sets the iteration variable equal to the next\n", "element in the sequence and then executes the body---the indented\n", "text---using that value of the iteration variable. It then returns to\n", "the beginning to see if there are more elements in the sequence and\n", "continues the loop until there is none remaining.\n", "\n", "
\n", "\"\"
Flowchart for for-loop.
\n", "
\n", "\n", "### Accumulators\n", "\n", "Let's look at another application of Python's `for` loop. Suppose you\n", "want to calculate the sum of all the odd numbers between 1 and 100.\n", "Before writing a computer program to do this, let's think about how you\n", "would do it by hand. You might start by adding 1+3=4. Then take the\n", "result 4 and add the next odd integer, 5, to get 4+5=9; then 9+7=16,\n", "then 16+9=25, and so forth. You are doing repeated additions, starting\n", "with 1+3, while keeping track of the running sum, until you reach the\n", "last number 99.\n", "\n", "In developing an algorithm for having the computer sum the series of\n", "numbers, we are going to do the same thing: add the numbers one at a\n", "time while keeping track of the running sum, until we reach the last\n", "number. We will keep track of the running sum with the variable `s`,\n", "which is called the *accumulator*. Initially `s=0`, since we haven't\n", "adding any numbers yet. Then we add the first number, 1, to `s` and `s`\n", "becomes 1. Then we add then next number, 3, in our sequence of odd\n", "numbers to `s` and `s` becomes 4. We continue doing this over and over\n", "again using a `for` loop while the variable `s` accumulates the running\n", "sum until we reach the final number. The code below illustrates how to\n", "do this.\n", "\n", "``` python\n", "s = 0\n", "for i in range(1, 100, 2):\n", " s = s+i\n", "print(s)\n", "```\n", "\n", "The `range` function defines the list `[1, 3, 5, ..., 97, 99]`. The\n", "`for` loop successively adds each number in the list to the running sum\n", "until it reaches the last element in the list and the sum is complete.\n", "Once the `for` loop finishes, the program exits the loop and the final\n", "value of `s`, which is the sum of the odd numbers from 1 to 99, is\n", "printed out. Copy the above program and run it. You should get an answer\n", "of 2500.\n", "\n", "single: loops; while loops\n", "\n", "### `while` loops\n", "\n", "The general form of a `while` loop in Python is\n", "\n", "``` python\n", "while :\n", " \n", "```\n", "\n", "where `` is a statement that can be either `True` or `False`\n", "and `` is a series of Python commands that is executed repeatedly\n", "until `` becomes false. This means that somewhere in\n", "``, the truth value of \\ must be changed so that it\n", "becomes false after a finite number of iterations. Consider the\n", "following example.\n", "\n", "Suppose you want to calculate all the Fibonacci numbers smaller than\n", "1000. The Fibonacci numbers are determined by starting with the integers\n", "0 and 1. The next number in the sequence is the sum of the previous two.\n", "So, starting with 0 and 1, the next Fibonacci number is $0+1=1$, giving\n", "the sequence $0, 1, 1$. Continuing this process, we obtain\n", "$0, 1, 1, 2, 3, 5, 8, ...$ where each element in the list is the sum of\n", "the previous two. Using a `for` loop to calculate the Fibonacci numbers\n", "is impractical because we do not know ahead of time how many Fibonacci\n", "numbers there are smaller than 1000. By contrast a `while` loop is\n", "perfect for calculating all the Fibonacci numbers because it keeps\n", "calculating Fibonacci numbers until it reaches the desired goal, in this\n", "case 1000. Here is the code using a `while` loop.\n", "\n", "``` python\n", "x, y = 0, 1\n", "while x < 1000:\n", " print(x)\n", " x, y = y, x+y\n", "```\n", "\n", "We have used the multiple assignment feature of Python in this code.\n", "Recall that all the values on the left are assigned using the original\n", "values of `x` and `y`.\n", "\n", "The figure below shows the flowchart for the `while` loop. The loop\n", "starts with the evaluation of a condition. If the condition is `False`,\n", "the code in the body is skipped, the flow exits the loop, and then\n", "continues with the rest of the program. If the condition is `True`, the\n", "code in the body---the indented text---is executed. Once the body is\n", "finished, the flow returns to the condition and proceeds along the\n", "`True` or `False` branches depending on the truth value of the\n", "condition. Implicit in this loop is the idea that somewhere during the\n", "execution of the body of the while loop, the variable that is evaluated\n", "in the condition is changed in some way. Eventually that change will\n", "cause the condition to return a value of `False` so that the loop will\n", "end.\n", "\n", "
\n", "\"\"
Flowchart for while loop.
\n", "
\n", "\n", "One danger of a `while` loop is that it entirely possible to write a\n", "loop that never terminates---an *infinite loop*. For example, if we had\n", "written `while y > 0:`, in place of `while x < 1000:`, the loop would\n", "never end. If you execute code that has an infinite loop, you can often\n", "terminate the program from the keyboard by typing **ctrl-C** a couple of\n", "times. If that doesn't work, you may have to terminate and then restart\n", "Python.\n", "\n", "For the kind of work we do in science and engineering, we generally find\n", "that the `for` loop is more useful than the `while` loop. Nevertheless,\n", "there are times when using a `while` loop is better suited to a task\n", "than is a `for` loop.\n", "\n", "### Loops and array operations\n", "\n", "Loops are often used to sequentially modify the elements of an array.\n", "For example, suppose we want to square each element of the array\n", "`a = np.linspace(0, 32, 1e7)`. This is a hefty array with 10 million\n", "elements. Nevertheless, the following loop does the trick.\n", "\n", "``` python\n", "import numpy as np\n", "a = np.linspace(0, 32, 1e7)\n", "print(a)\n", "for i in range(len(a)):\n", " a[i] = a[i]*a[i]\n", "print(a)\n", "```\n", "\n", "Running this on my computer returns the result in about 8 seconds---not\n", "bad for having performed 10 million multiplications. Of course we could\n", "have performed the same calculation using the array multiplication we\n", "learned in Chapter 3 (`chap3`). Here is the code.\n", "\n", "``` python\n", "import numpy as np\n", "a = np.linspace(0, 32, 1e7)\n", "print(a)\n", "a = a*a\n", "print(a)\n", "```\n", "\n", "Running this on my computer returns the results faster than I can\n", "discern, but certainly much less than a second. This illustrates an\n", "important point: **for loops are slow**. Array operations run much\n", "faster and are therefore to be preferred in any case where you have a\n", "choice. Sometimes finding an array operation that is equivalent to a\n", "loop can be difficult, especially for a novice. Nevertheless, doing so\n", "pays rich rewards in execution time. Moreover, the array notation is\n", "usually simpler and clearer, providing further reasons to prefer array\n", "operations over loops.\n", "\n", "single: list comprehension\n", "\n", "List Comprehensions\n", "-------------------\n", "\n", "List comprehensions are a special feature of core Python for processing\n", "and constructing lists. We introduce them here because they use a\n", "looping process. They are used quite commonly in Python coding and they\n", "often provide elegant compact solutions to some common computing tasks.\n", "\n", "Consider, for example the $3 \\times 3$ matrix\n", "\n", "``` ipython\n", "In [1]: x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n", "```\n", "\n", "Suppose we want to construct a vector from the diagonal elements of this\n", "matrix. We could do so with a `for` loop with an accumulator as follows\n", "\n", "``` ipython\n", "In [2]: diag = []\n", " ...: for i in [0, 1, 2]:\n", " ...: diag.append(x[i][i])\n", " ...:\n", "\n", "In [3]: diag\n", "Out[3]: [1, 5, 9]\n", "```\n", "\n", "List comprehensions provide a simpler, cleaner, and faster way of doing\n", "the same thing\n", "\n", "``` ipython\n", "In [4]: diagLC = [x[i][i] for i in [0, 1, 2]]\n", "\n", "In [5]: diagLC\n", "Out[5]: [1, 5, 9]\n", "```\n", "\n", "A one-line list comprehension replaces a three-line accumulator plus\n", "loop code.\n", "\n", "Suppose we now want the square of this list:\n", "\n", "``` ipython\n", "In [6]: [y*y for y in diagLC]\n", "Out[6]: [1, 25, 81]\n", "```\n", "\n", "Notice here how `y` serves as a dummy variable accessing the various\n", "elements of the list `diagLC`.\n", "\n", "Extracting a column from a 2-dimensaional array such as `x` is quite\n", "easy. For example the second row is obtained quite simply in the\n", "following fashion\n", "\n", "``` ipython\n", "In [7]: x[1]\n", "Out[7]: [4, 5, 6]\n", "```\n", "\n", "Obtaining a column is not as simple, but a list comprehension makes it\n", "quite straightforward:\n", "\n", "``` ipython\n", "In [7]: c1 = [a[1] for a in x]\n", "In [8]: c1\n", "Out[8]: [2, 5, 8]\n", "```\n", "\n", "Another, slightly less elegant way to accomplish the same thing is\n", "\n", "``` ipython\n", "In [9]: [x[i][1] for i in range(3)]\n", "Out[9]: [2, 5, 8]\n", "```\n", "\n", "Suppose you have a list of numbers and you want to extract all the\n", "elements of the list that are divisible by three. A slightly fancier\n", "list comprehension accomplishes the task quite simply and demonstrates a\n", "new feature:\n", "\n", "``` ipython\n", "In [10]: y = [-5, -3, 1, 7, 4, 23, 27, -9, 11, 41]\n", "In [14]: [a for a in y if a%3==0]\n", "Out[14]: [-3, 27, -9]\n", "```\n", "\n", "As we see in this example, a conditional statement can be added to a\n", "list comprehension. Here it serves as a filter to select out only those\n", "elements that are divisible by three.\n", "\n", "Exercises\n", "---------\n", "\n", "1. Write a program to calculate the factorial of a positive integer\n", " input by the user. Recall that the factorial function is given by\n", " $x! = x (x-1) (x-2) ... (2) (1)$ so that $1!=1$, $2!=2$, $3!=6$,\n", " $4!=24$, ...\n", "\n", " 1. Write the factorial function using a Python `while` loop.\n", " 2. Write the factorial function using a Python `for` loop.\n", "\n", " Check your programs to make sure they work for 1, 2, 3, 5, and\n", " beyond, but especially for the first 5 integers.\n", "\n", "2. The following Python program finds the smallest non-trivial (not 1)\n", " prime factor of a positive integer.\n", "\n", " ``` python\n", " n = int(raw_input(\"Input an integer > 1: \"))\n", " i = 2 \n", "\n", " while (n % i) != 0:\n", " i += 1\n", "\n", " print(\"The smallest factor of n is:\", i )\n", " ```\n", "\n", " 1. Type this program into your computer and verify that it works as\n", " advertised. Then briefly explain how it works and why the while\n", " loop always terminates.\n", " 2. Modify the program so that it tells you if the integer input is\n", " a prime number or not. If it is not a prime number, write your\n", " program so that it prints out the smallest prime factor. Using\n", " your program verify that the following integers are prime\n", " numbers: 101, 8191, 947431.\n", "\n", "3. Consider the matrix list `x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]`.\n", " Write a list comprehension to extract the last column of the matrix\n", " \\[3, 6, 9\\]. Write another list comprehension to create a vector of\n", " twice the square of the middle column `[8, 50, 128]`.\n", "\n", "4. Write a program that calculates the value of an investment after\n", " some number of years specified by the user if\n", "\n", " 1. the principal is compounded annually\n", " 2. the principle is compounded monthly\n", " 3. the principle is compounded daily\n", "\n", " Your program should ask the user for the initial investment\n", " (principal), the interest rate in percent, and the number of years\n", " the money will be invested (allow for fractional years). For an\n", " initial investment of \\$1000 at an interest rate of 6%, after 10\n", " years I get \\$1790.85 when compounded annually, \\$1819.40 when\n", " compounded monthly, and \\$1822.03 when compounded daily, assuming 12\n", " months in a year and 365.24 days in a year, where the monthly\n", " interest rate is the annual rate divided by 12 and the daily rate is\n", " the annual rate divided by 365 (don't worry about leap years).\n", "\n", "5. Write a program that determines the day of the week for any given\n", " calendar date after January 1, 1900, which was a Monday. Your\n", " program will need to take into account leap years, which occur in\n", " every year that is divisible by 4, except for years that are\n", " divisible by 100 but are not divisible by 400. For example, 1900 was\n", " not a leap year, but 2000 was a leap year. Test that your program\n", " gives the following answers: Monday 1900 January 1, Tuesday 1933\n", " December 5, Wednesday 1993 June 23, Thursday 1953 January 15, Friday\n", " 1963 November 22, Saturday 1919 June 28, Sunday 2005 August 28." ] } ], "metadata": { "jupytext": { "cell_metadata_filter": "all", "formats": "ipynb,py:percent", "notebook_metadata_filter": "all,-language_info,-toc,-latex_envs" }, "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.7.6" } }, "nbformat": 4, "nbformat_minor": 2 }