{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Table of Contents\n",
"\n",
"- [Introduction: Conditionals](#introduction--conditionals)\n",
"- [College Application Example](#college-application-example)\n",
"- [Introduction: Iterations](#introduction--iterations)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Introduction: Conditionals \n",
"\n",
"We use conditionals all the time in our daily lives without even realizing it. However, they aren't written in Python. We use conditionals in choices ranging from deciding what to wear in the morning to life-changing decisions like selecting a job.\n",
"\n",
"I would cross the street if the light turns green; otherwise, I would wait. If the sun comes up, I would get out of bed; otherwise, I would go back to sleep again. Okay, it's not quite that simple, but when we make decisions based on circumstances, our brain behaves similarly to a machine: it evaluates the conditions and acts on the results.\n",
"\n",
"Conditions - usually in the form of `if statements` - are one of the key features of a programming language, and Python is no exception. `If statements` are control flow statements which allow us to run a particular code and make a decision only when a certain condition is met. Most of the time, this decision depends on the value of variables or arithmetic expressions. \n",
"\n",
"Conditional statements represent the set of instructions that allow us to make these decisions and perform computations depending on whether the code (a specific Boolean constraint) evaluates to `True or False`. Therefore, in a programming language, there are often two parts to a sample of code: One which will be executed, if the condition is `True`, and another one, if it is `False`. In the upcoming chapter, you will get to experiement with conditionals with an extedend example!\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# College Application Example \n",
"\n",
"## Additional Material: Operators\n",
"\n",
"Before starting looking at `if and else statements`, we will dive deeper into the basic operators that we will use in the next examples. The `if`, `if-else` or `elif` statements, that we will see, will contain these operators. Here is a short list of operators that we have included in our programs:\n",
"\n",
"`Assignment operators`: `=` (assign)\n",
"\n",
"`Comparison operators`: `==` (equal), `!=` (not equal)\n",
"\n",
"`Logical operators`: `and` (Returns True if both statements are true), `or` (Returns `True` if one or both of the statements are true)\n",
"\n",
"It must be added that, in Python, `==` and `=` do not have the same meaning. `=` assigns a value to a variable, for example `age=5` implies that the value 5 is assigned to `age`. In contrast, `==` is the equal sign, that we commonoly use in mathematics. The latter symbol is used to check whether two expressions give the same value. For instance, (x==y) would result in `False` if we had assigned different values to x and y.\n",
"\n",
"## If and else statements\n",
"\n",
"In this example, we put ourselves in the shoes of a college applicant, who is looking to submit both his essay and grade transcript to his college of choice. The university's application portal verifies whether the application is successful by asking the applicant to type in `Completed` if the applicant wrote his essay and `Sent` if he sent his grades.\n",
"The indented block will only be executed (the application will only be successful) if the words `Completed` and `Sent` are typed in. If the user enters any other set of words, nothing happens. Please remember to add quotation marks (\" \") to the instructions that you want the applicant to see, as the text represents a string (a sequence of characters) and not including the quotation marks would give you a Syntax error."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"If you have completed your essay please type in 'Completed': Completed\n",
"If you have submitted your grades please type in 'Sent': Sent\n",
"Application successful!\n"
]
}
],
"source": [
"essay_application = input(\"If you have completed your essay please type in 'Completed': \")\n",
"grades = input(\"If you have submitted your grades please type in 'Sent': \")\n",
"if essay_application == 'Completed' and grades == 'Sent':\n",
" print('Application successful!')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We will strengthen our code in case the applicant disregards the capital letter at the start of `Completed` and `Sent`. After all, the university doesn't want an applicant who has completed all of the required tasks to not be considered because of a technicality. In the following case, the applicant can type in `completed` and `sent` and his application will still be successful. As you can see, we used the expression `or` to make sure that the application portal also accepts the words `completed` and `sent` in addition to `Completed` and `Sent`."
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"If you have completed your essay please type in 'Completed': Completed\n",
"If you have submitted your grades please type in 'Sent':sent\n",
"Application successful!\n"
]
}
],
"source": [
"essay_application = input(\"If you have completed your essay please type in 'Completed': \")\n",
"grades = input(\"If you have submitted your grades please type in 'Sent': \")\n",
"if (essay_application == 'Completed' or essay_application == 'completed') and (grades == 'Sent' or grades == 'sent'):\n",
" print('Application successful!'')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We will now introduce the `else statement` by adding a code block that lets the applicant know that his application is unsucessful. It must be noted that, there can be an `if` statement without an `else statement`. However, it is not possible to have an `else` statement if previously there is no `if` statement. Furthermore, it is important to know that Python will never execute the `if and the else statements` together as they are mutually exclusive. \n",
"\n",
"The university also decided to improve user experience by addressing applicants by their name. Hence, the variable name `name` was added to the code, and `.format(name)` inserts the applican't name into the brackets."
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Enter your name please: Alex\n",
"If you have completed your essay please type in 'Completed': completed\n",
"If you have submitted your grades please type in 'Sent':Sent\n",
"Application successful, Alex!\n"
]
}
],
"source": [
"name = input('Enter your name please: ')\n",
"essay_application = input(\"If you have completed your essay please type in 'Completed': \")\n",
"grades = input(\"If you have submitted your grades please type in 'Sent':\")\n",
"if (essay_application == 'Completed' or essay_application == 'completed') and (grades == 'Sent' or grades == 'sent'):\n",
" print('Application successful, {}!'.format(name))\n",
"else:\n",
" print('Application unsuccessful, {}!'.format(name))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You are free to experiment with the code youself by selecting the cell containing the code and running the code in your Jupyter Notebook. \n",
"\n",
"## Elif statements\n",
"\n",
"In the next example we will modify our code so that we get an introduction to the `elif statement`. Let's imagine that the university wants to let applicants know why their application is unsuccessful. Hence, it wants applicants to know whether the applicant failed either the essay or the grade requirement, or whether he failed both requirements.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Enter your name please: Alex\n",
"If you have completed your essay please type in 'Completed': Completed\n",
"If you have submitted your grades please type in 'Sent':not sent\n",
"Grade requirement failed, your application was unsuccessful, Alex!\n"
]
}
],
"source": [
"name = input('Enter your name please: ')\n",
"essay_application = input(\"If you have completed your essay please type in 'Completed': \")\n",
"grades = input(\"If you have submitted your grades please type in 'Sent':\")\n",
"if (essay_application == 'Completed' or essay_application == 'completed') and (grades == 'Sent' or grades == 'sent'):\n",
" print('Application successful, {}!'.format(name))\n",
"elif (essay_application == 'Completed' or essay_application == 'completed') and (grades != 'Sent' and grades != 'sent'):\n",
" print('Grade requirement failed, your application was unsuccessful, {}!'.format(name))\n",
"elif (essay_application != 'Completed' and essay_application != 'completed') and (grades == 'Sent' or grades == 'sent'):\n",
" print('Essay requirement failed, your application was unsuccessful, {}!'.format(name))\n",
"else:\n",
" print('Both requirements failed, your application was unsuccessful, {}!'.format(name))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"Since the code is getting longer and more complex, let's review it more clearly:\n",
"\n",
"
The above code works in the exact same way as the code sections mentioned earlier in the chapter, with the only difference being the elif statement. As we know, the applicant will ony have a successful application when both grades and essay requirements are met.
\n",
"
If the first if statement holds True, then the applicant will be successful. If it doesn't, we move on to the first elif statement.
\n",
"
If the first elif statement holds True, it means that the grade requirement failed. If the statement holds False, we move on to the last elif statement.
\n",
"
If that last elif statement holds True, then the essay requirement failed.
\n",
"
Lastly, if the last elif statement fails, we automatically move on to the else statement, where both requirements fail. This else statement can be considered a default parameter as it always holds valid as long as all other statements in the code hold False.
\n",
"\n",
"\n",
"The above code does function properly; however, it's not well structured and is error-prone. In this situation, we are not troubled by the repetition of `elif statements` . Nevertheless, with thousands of lines of code, it gets more difficult to differentiate the outcomes of the code.\n",
"Thus, it is good practice in Computer and Data Science to keep your Code **DRY (Don't Repeat Yourself!)**.\n",
"\n",
"In the next example, we are improving the code by clearly marking the difference between a successful and an unsuccessful application with an `else statement`:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Enter your name please: Alex\n",
"If you have completed your essay please type in 'Completed': Completed\n",
"If you have submitted your grades please type in 'Sent':s\n",
"Grade requirement failed, your application was unsuccessful, Alex!\n"
]
}
],
"source": [
"name = input('Enter your name please: ')\n",
"essay_application = input(\"If you have completed your essay please type in 'Completed': \")\n",
"if essay_application != 'Completed' and essay_application != 'completed':\n",
" print('Essay requirement failed, your application was unsuccessful, {}'.format(name))\n",
"else:\n",
" grades = input(\"If you have submitted your grades please type in 'Sent': \")\n",
" if grades == 'Sent' or grades == 'sent':\n",
" print('Application successful, {}!'.format(name))\n",
" else:\n",
" print('Grade requirement failed, your application was unsuccessful, {}!'.format(name))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's review the code again:\n",
"\n",
"In this example, we used the same intuition as before, however the school now made sure that the application could only move on once the essay condition is satisfied. Now, the application process is sequential and more concise. Here, we see that we can integrate if, elif and else statements into a more general `else statement`. \n",
"\n",
"\n",
"## Summary\n",
"\n",
"To help you out, we have created for you an interactive example that summarizes the concepts that we have seen so far. This particular example asks you for your cat's age and converts that age to human years. \n",
"\n",
"
Start by asking the user for his input. Make sure to treat the input as a floating number using float() or as an integer using int(). If you do not add any of these two options, you will get a Type Error as the conditions will not recognize the input as a number. In this case, float () was used as the user might decide to specify a more precise age for the cat (2.5,4.5,.. years old). If the user used int() and typed in a number such as 2.5, there would be an error.
\n",
"
Add your if statement when you want to introduce your first condition. Remember to add ' : ' at the end of the line of code if you don't want to get a Syntax Error. Once you have written the line of code and pressed ' Enter ', Python will bring you to the following line with an indent. All indented lines of code will be executed as part of the condition that was set by the if statement.
\n",
"
In this example, the first if statement is followed by an else statement because we want to seperate incalculable values (negative age) from calculable values. The else statement possesses all of the calculable values. The else statement will run only if the age value given is nonnegative.
\n",
"
The else statement contains a number of elif statements that will only get executed if the previous if or elif statement is False. The if and elif statements contained in the else statement represent new conditions and thus you return to the same tabulation level than the first if (in the else statement).\n",
"\n",
"At the end, you cannot add an `else` to consider all other situations, as the other situations are already taken into consideration. Thus, it is essential to understand that the `else` only refers to the last `if`."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Age of the cat: 7\n",
"Human years: 47.0\n"
]
}
],
"source": [
"age = float(input('Age of the cat: ')) #float: treat user's input as a floating point number, which can possess decimal values \n",
"if age < 0:\n",
" print ('This cannot be true!')\n",
"else:\n",
" if age == 0:\n",
" print ('about 0 human years')\n",
" elif age == 1:\n",
" print ('about 14 human years')\n",
" elif age == 2:\n",
" print ('about 22 human years')\n",
" elif age > 2:\n",
" human = 22 + (age -2)*5\n",
" print ('Human years: ', human)\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Introduction: Iterations \n",
"\n",
"Software programs come in handy when you have to do a lot of the same things over and over again. They can perform the same calculations with minor, but important, variations without complaining or getting bored and tired, like humans would. As a result, we use machines to perform massively repetitive tasks that we would rather not do.\n",
"\n",
"We need effective ways of asking the machine to perform these repetitive tasks; we don't want to have to pause and tell the computer to repeat the process for a slightly different case every time it completes one iteration. We just want to tell the computer once, “Do this job 1000 times with slightly different conditions and report back to me when you are finished”. In general, we don't want the machine to stop its calculations and ask us what it should do if its calculations produce a particular result. \" Look, if you get result X during your calculations, do this. If you don't, do this instead,” we may suggest. \n",
"**As such, combining conditionals and iterations, which are essential when completing these computational tasks, allows the user to control the flow of a program**. In the following chapter, we will see how iterations are implemented in a number of ways in Python.\n",
"\n",
"Iterations and loops are conceptually similar, and the terms are often used interchangeably. The next few paragraphs illustrate how iterations are used on various containers and in various contexts. Now, let's get to some illustrative examples!\n",
"\n",
"## For Loops \n",
"\n",
"Python `for loops` are widely used in data science to loop through an iterable object (such as a list, tuple, sequence, etc.) and perform the same action for each entry. A `for loop`, for example, allows you to iterate through a list of objects, performing the same action on each one.\n",
"\n",
"The `for` command must end with a colon character, and the body of the `for-loop` is whitespace-delimited.\n",
"\n",
"\n",
"\n",
"## Simple Iteration\n",
"\n",
"The example below shows how to iterate over a list of people:"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Alessandro\n",
"Alexandre\n",
"Sara\n"
]
}
],
"source": [
"people = ['Alessandro', 'Alexandre', 'Sara']\n",
"for person in people:\n",
" print(person)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The `for` loop instructs the Python interpreter to iterate through the `people` list (this shouldn't necessarily be a list and could be another type of container object). The Python interpreter will exit the for-loop without running its body if the iterable (`people`) is empty. The first element of `people` is then assigned to `person` (variable `person` becomes defined if it was not previously defined). The script then runs the indented code block, which prints the person's name (`Alessandro`) on the computer. The iteration then moves on to the list's second element, repeating this same process.\n",
"\n",
"## Enumerating iterations\n",
"\n",
"The `enumerate` function in Python makes it simple to count the number of iterations:"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"Alessandro\n",
"1\n",
"Alexandre\n",
"2\n",
"Sara\n"
]
}
],
"source": [
"people_list = ['Alessandro', 'Alexandre', 'Sara']\n",
"for n, person in enumerate(people_list):\n",
" print(n)\n",
" print (person)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The above code iterates over the list `people` as before, but instead of assigning `Alessandro`, `Alexandre`, and `Sara` to `person`, it also assigns the iteration number (starting at 0) to `n`.\n",
"\n",
"## Iterating over a file"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {},
"outputs": [],
"source": [
"filename = ('/Users/Documents/my_file.txt')\n",
"with open(filename) as file:\n",
" for line in file:\n",
" print(line)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"PS: The code block is just an example. Do not run the cells if you do not possess an adequate file with filename `/Users/Documents/my_file.txt`.\n",
"\n",
"The above code has the role of assigning `filename` to `file` and proceeds by printing each line element in `file`.\n",
"\n",
"## Iterating over ranges\n",
"\n",
"One can also iterate over a range. In this example, the range function generates integers\n",
"ranging from 0 to 100, starting from 0 and printing all multiples of 5. The resulting range may be iterated using the `for` command, and the results appear on the screen."
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"5\n",
"10\n",
"15\n",
"20\n",
"25\n",
"30\n",
"35\n",
"40\n",
"45\n",
"50\n",
"55\n",
"60\n",
"65\n",
"70\n",
"75\n",
"80\n",
"85\n",
"90\n",
"95\n"
]
}
],
"source": [
"for n in (range(0,100,5)):\n",
" print(n)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Iterating over a string\n",
"\n",
"Although strings are primitive data types, they can be viewed as more complex data structures that contain a number of different elements. As a consequence, it is possible to iterate across a string in the same way that it is possible to iterate across a set. In the example below, note how we iterate over a nine-letter string:"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"H\n",
"I\n",
"J\n",
"K\n",
"L\n",
"M\n",
"N\n",
"O\n",
"P\n"
]
}
],
"source": [
"string = 'HIJKLMNOP'\n",
"for element in string:\n",
" print(element)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Nested iterations\n",
"\n",
"An iteration within an iteration is known as a nested iteration. Nested iterations are very common in Python code because they are a great way to combine values in order to construct permutations of those values. The nested iteration below, for example, produces 16 di-nucleotide permutations of the four DNA nucleotide bases."
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"AA\n",
"AG\n",
"AC\n",
"AT\n",
"GA\n",
"GG\n",
"GC\n",
"GT\n",
"CA\n",
"CG\n",
"CC\n",
"CT\n",
"TA\n",
"TG\n",
"TC\n",
"TT\n"
]
}
],
"source": [
"bases_list = ['A', 'G', 'C', 'T']\n",
"for base_1 in bases_list:\n",
" for base_2 in bases_list:\n",
" print(base_1 + base_2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## While Loops\n",
"\n",
"As stated earlier in this course, with most of the Python code, even a novice can make a fair guess at what a line of code does simply by looking at the meaning of the words in English. \n",
"Another such example is the `while loop`, which means \"keep looping while this statement holds true\" in simple terms.\n",
"\n",
"\n",
"\n",
"Consider the following scenario:\n"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2\n",
"3\n",
"4\n",
"5\n",
"6\n"
]
}
],
"source": [
"x = 2\n",
"while(x < 7):\n",
" print(x)\n",
" x += 1 #incrementing x by 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In this code, x is assigned the value 2. We then move onto the loop, which will be repeated as long as x is less than 7. There is a colon at the end of this line of text, followed by a four-space line indentation on the next line. For each loop, this indented code will be executed.\n",
"The print statement shows the value of x on the screen before incrementing the value of x by one. This will print the values 2 to 6 (not 7, since x must be less than 7) to the screen.\n",
"It's worth mentioning that if the increment command had been omitted, x would have been set to 2 and the loop would have proceeded indefinitely; we would have ended up with an infinite loop. **When writing code, keep an eye out for these. Recheck that you haven't mistakenly created an endless loop if a program or procedure hasn't terminated for a much longer time than expected.**\n",
"\n",
"\n",
"\n",
"\n",
"## Do-while loop\n",
"\n",
"`Do-while loops` are a variant of the basic `while loops`. Although, they do not exist in Python themselves, we can write a Python program that functions like a `do-while loop`. As stated previously, in a `while loop` the condition is checked before running the loop. Hence, with a basic `while loop`, if the condition is not met, then the body of the loop is not executed. To avoid such a situation, with a `do-while loop` the computer will first execute the body of the loop and then check whether the condition is fulfilled. As long as the condition holds, the loop will keep running. Once the condition is not fulfilled anymore, the next statement is executed. A `do-while loop` can be quite useful when one wants to initialize a program and make the loop run at least once."
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"7\n"
]
}
],
"source": [
"i = 7 \n",
"while True: \n",
" print(i) \n",
" i = i + 1 \n",
" if(i > 6): \n",
" break "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In the code above, we see that although i>6, the loop will run at least once and the print statement will print `7` on your screen. There is no initial barrier to entry, which will stop the loop from running at least once, if i>6.\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Break Statements\n",
"\n",
"`Break` is a Python command that leads to a program exiting a loop early. Even if the `for loop` hasn't run for a defined number of times, `break` allows the program to exit it. Morevoer, even if the logical condition that determines the loop is still True, break allows the program to exit `while loops`. \n",
"Below are two examples of using break in a `for loop and a while loop`:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n",
"2\n",
"3\n",
"4\n",
"5\n",
"We have exited the loop.\n"
]
}
],
"source": [
"for i in range(50):\n",
" print(i)\n",
" if i == 5:\n",
" break\n",
"print('We have exited the loop.')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"When the loop reaches i=5, ``break`` comes into play and the program exits the loop.\n",
"In the next example, we will see how ``break`` works in a while loop:"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"type g to exit the loop: j\n",
"type g to exit the loop: g\n",
"We have exited the loop.\n"
]
}
],
"source": [
"while True:\n",
" get_out = input('type g to exit the loop: ')\n",
" if get_out == 'g':\n",
" break\n",
"print('We have exited the loop.')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The `while loop` above asks the user for his input and keeps asking the user for his input until the user inserts `g`. At this point, we have exited the loop and the program stops."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Pass Statement\n",
"\n",
"``Pass`` statements are useful when a segment of code is not fully finished but will be implemented in the future. Indeed, the ``pass`` allows software developers to keep incomplete functions and loops, which would result in an error and which have no functional purpose. In this way, the parts which are not finished will not block the whole program from working."
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {},
"outputs": [],
"source": [
"sequence = {'w', 'o', 'r', 'k'}\n",
"for value in sequence:\n",
" pass"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Continue Statements\n",
"\n",
"The keyword `continue` causes the program to stop running code in a loop and return to the initial `for statement`. Note that the keyword ``break`` is used to escape a loop. `Continue` is similar to stop, except it allows the program to stop the current iteration of the loop and begin the next one at the start. \n",
"\n",
"Below, we have demonstrated how to use a continue statement for a `for and a while loop`:"
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"2\n",
"3\n",
"4\n",
"5\n",
"6\n"
]
}
],
"source": [
"for i in range(7):\n",
" if i==1:\n",
" continue\n",
" print(i)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"When the code above is run, the number 1 is not printed at all. This is because when i=1, the program reaches the `continue statement`. Thus, the line print(i) isn't executed when i=1, and the program returns to the initial 'for statement' with the following number i=2. Below, we will see how the `continue statement` works with a `while loop`:"
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"7\n",
"6\n",
"5\n",
"4\n",
"3\n",
"2\n",
"0\n",
"The loop has ended.\n"
]
}
],
"source": [
"n = 8\n",
"while n > 0:\n",
" n -= 1 #decrement (decrease) of 'n' by 1\n",
" if n == 1:\n",
" continue\n",
" print(n)\n",
"print('The loop has ended.')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This time, when n is 1, the `continue` statement causes the iteration to end. As a consequence, the number 1 is not printed. We then return to the initial `while loop` condition and re-evaluate it. If it is still valid, the loop resumes until it reaches n equals 0.\n",
"\n",
"## Else Statement\n",
"\n",
"An `else` statement can be added at the end of any loop. In the example below, the body of this `else` statement will run only if the loop was not exited via a `break` statement:"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1 ...keep iterating\n",
"3 ...keep iterating\n",
"5 ...keep iterating\n",
"If you are seeing this, then the loop completed without a 'break'.\n"
]
}
],
"source": [
"for number in [1, 3, 5]:\n",
" if number == 2: \n",
" print(number, ' ...break!')\n",
" break\n",
" print(number, ' ...keep iterating')\n",
"else:\n",
" print(\"If you are seeing this, then the loop completed without a 'break'.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The section of code above will exit the for loop if it identifies `2` in [1,3,5]. In this case, however, as there is no `2` , the code will never run the break statement. It will print all of the numbers in the list given and complete the loop without a `break`.\n",
"\n",
"### What is the difference between a for loop and a while loop?\n",
"\n",
"`For Loop`:\n",
"On the one hand, computer scientists typically use the `for loop` when they know with certainty the number of times that the loop needs to be excuted.\n",
"\n",
"`While Loop`:\n",
"On the other hand, the `while loop` is necessary when a programmer isn't certain about the number of times that the loop needs to be excuted beforehand.\n",
"\n",
"## Advanced Example: Estimation of $\\pi$ for Quantitative Analysis\n",
"\n",
"Now that we know the basic functioning of the for-loop, let us look at some more interesting examples to demonstrate how versatile this tool really is.\n",
"\n",
"### How can we find the value of π using a for loop? \n",
"\n",
"The main idea is to use the formula for the area of circle, i.e. $ A = \\pi\\times r^2 $ . We will create a set-up that will allow us, thanks to random numbers, to find $\\pi$. We’ll create a square of length 2 and a circle of radius 1, such that the circle is inside the square. Where, $A_s$ is the area of the square and $A_c$ is the area of the circle."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"\n",
"What we will do now is generate pairs of random numbers $(x, y)$, such that $|x| < 1, |y| < 1$. This way, we can represent each pair of numbers as a point in the square. The objective now is to find the area in green and extract from that the value of $\\pi$. But how does this work?\n",
"The key is looking at the ratio between the area of the circle and the area of the square. We know $A_s =2\\times 2=4 $, and $A_c =\\pi\\times 1^2 =\\pi$. Thus,\n",
"\n",
"$$\\frac{A_c}{A_s}=\\frac{\\pi}{4}, \\quad\\text{and}\\quad \\pi=4\\frac{A_c}{A_s}$$\n",
"\n",
"Now, we can estimate the ratio $\\pi = 4 \\frac{A_c}{A_s}$ , by generating random points and counting how many points fall\n",
"inside the circle and dividing by the total number of points.\n",
"\n",
"$$\\pi\\approx4\\frac{\\text{Number of points in the circle}}{\\text{Total number of points}}$$ \n",
"\n",
"To check whether a point is in the circle or not, we used the following condition $x^2 + y^2 ≤ 1$. This comes from the equation of a circle, $x$ and $y$ are coordinates of a random point on the circle and one is the length of the radius.\n",
"\n",
"\n",
"\n",
"Here, we generated 100 random points. 77 points were in the circle, while 23 were outside. We can now calculate our ratio and multiply it by 4, as explained previously. \n",
"\n",
"$$4*\\frac{77}{100}=3.08\\approx \\pi$$\n",
"\n",
"\n",
"\n",
"Our accuracy increases with the number of points generated. Here, we generate 1000 points, and we got:\n",
"\n",
"$$4*\\frac{782}{1000}=3.128\\approx \\pi$$ \n",
"\n",
"Let us now try to get a numerical estimation with the following code. The code computed pi by looking only at one quadrant of a circle. However, it does not change anything to the formula if we use one quadrant or the whole circle. Indeed, as it is a ratio, the numerator and the denomiator increase in the same proportion if we use the whole square.\n",
"\n",
"The previously mentionned formula ( $\\frac{\\text{Points in the circle}}{\\text{Total number of points}}$ ) tells us how to mathemically procede. If we generate thousands of points, then we can precisely compute $\\pi$.\n",
"\n",
"The output of the code gives us a representation of $\\pi$. In green, you can see the points in the circle and in red the points in the square but not in the circle.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3.1236\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"import matplotlib.pyplot as plt\n",
" \n",
"import numpy as np #import this library\n",
"from random import random\n",
"\n",
"in_circle = 0 #counter that counts the points in the circle \n",
"n = 10**4 #number of iterations\n",
"\n",
"x_in, x_out, y_in, y_out = ([]for i in range(4)) #defining 4 arrays\n",
"\n",
"for _ in range(n): #generating n random points (x,y) between 0 and 1, the for loop iterates n times\n",
" x = random() #by default random gives values between 0 and 1\n",
" y = random()\n",
" if x**2+y**2 <= 1: #test if (x,y) is inside the unit circle\n",
" in_circle += 1 #if point is inside we increase our counter by 1 \n",
" x_in.append(x) #add one to the count 'x_in'\n",
" y_in.append(y) #add one to the count 'y_in'\n",
" else: \n",
" x_out.append(x) #add one to the count 'x_out'\n",
" y_out.append(y) #add one to the count 'y_out'\n",
"pi = 4*in_circle/n # calculate pi by multiplying by 4 the ratio of points in the circle to the total amount of points\n",
"print(pi) #show the reuslts for pi calulcated that way\n",
"\n",
"fig, ax = plt.subplots() #it returns a figure\n",
"fig.suptitle('Pi approximation with for loop') # it gives a name to the figure\n",
"ax.set_aspect('equal') # x and y axes are similar\n",
"ax.scatter(x_in, y_in, color='g', marker='o', s=4) #it indicates the color of the points in the circle (green), as well as the form (o) and the size (4) of the points\n",
"ax.scatter(x_out, y_out, color='r', marker='o', s=4) # it indicates the color of the points outside the circle (red) as well as the form (o) and the size (4) of the points\n",
"plt.show() #it shows the plot"
]
}
],
"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.8.5"
}
},
"nbformat": 4,
"nbformat_minor": 2
}