Add flow control

Author: macdems

02 Constants, Variables and Basic Operations/1 Constants and their types.md

@@ -144,7 +144,7 @@ type(1 + 2)
 type(1 + 2.0)
 ```
 
-As you can see above, Python is able to convert numeric types by itself so that the result of a given action makes sense. However, it is possible to force type conversions manually by directly using their names as functions. This is especially useful when you want to convert a string to a number. For example: 
+As you can see above, Python is able to convert numeric types by itself so that the result of a given action makes sense. However, it is possible to force type conversions manually by directly using their names as functions. This is especially useful when you want to convert a string to a number. For example:
 
 ```python
 float("2.5")

03 Flow Control/1 Conditions.md

@@ -0,0 +1,111 @@
+# Conditions
+
+All previous programs have been executed sequentially, line by line. No line could be skipped.
+
+Consider the following problem: for a given real number, determine its absolute value. If number > 0, the program should print its value, otherwise it should print –number . This behavior cannot be achieved by using a sequential program. The program should conditionally select the next step. The following command used for this purpose is called if:
+
+```python
+number = float(input("Enter a number:"))
+
+if number > 0:
+    absolute_value = number
+else:
+    absolute_value = -number
+
+print(absolute_value)
+```
+
+This program uses a conditional statement **`if`** . After that, we put a condition `number > 0` after a colon. We then insert a block of statements that will only be executed if the condition is true (i.e. the value of the expression `number > 0` is equal to  `True`). This block can be followed by a word  else, a colon, and another block of instructions that will only be executed if the condition is false (i.e., has the value `False`).
+
+## Blocks in Python
+
+In Python, blocks are marked with indentation i.e. spaces at the beginning of the line. The number of these spaces is arbitrary, but it is important that there are enough of them to make the block visually stand out. Each block  must be identified by a colon (**`:`**) at the end of the  preceding line. Of course, only some commands can start a new block. In the example above, these are the commands if and else. The blocks assigned to them will be executed only if the condition is met (**`if`**) or not met (**`else`**). We finish the block by removing the indentation of the first non-block line.
+
+Blocks can be nested: next levels are marked by increasing the number of spaces at the beginning (e.g. 4, 8, 12 etc.), and each of them is finished by undoing the indentation accordingly. (8, 4, 0). It is possible to remove indentations corresponding to several blocks at once — then we finish them all at once.
+
+The way of marking blocks with indentation is specific to Python. Other programming languages use special characters (usually braces) to mark the beginning and end of a block.
+
+In summary, a conditional statement in Python has the following syntax:
+
+<pre>
+<b>if</b> <i>condition</i><b>:</b>
+    any number of commands
+    executed if the condition is True
+<b>else:</b>
+    any number of commands
+    executed if the condition is False
+</pre>
+
+the keyword else along with its corresponding block can be omitted if nothing should be done if the condition is false. For example, we can replace the variable with number with its absolute value as follows:
+
+```python
+number = float(input("Enter a number:"))
+
+if number < 0:
+    number = -number
+
+print(number)
+```
+
+In this example, the variable `number` is assigned the value `-number` only if `number < 0`. On the other hand, the command `print(number)` is executed every time because it is not indented, so it does not belong to the block that is executed only when the tested condition is true.
+
+## Nesting conditions
+
+Each Python statement can be placed in any of the blocks, including a different conditional statement. Thus, we obtain nested conditions. Internal condition blocks are indented with more spaces (e.g., 8 spaces). Let's see an example. Given the coordinates of a point on the plane, print a quarter of it:
+
+```python
+x = float(input("Enter x coordinate:"))
+y = float(input("Enter y coordinate:"))
+
+if x > 0:
+    if y > 0:
+        # x is greater than 0, y is greater than 0
+        print("Quadrant I")
+    else:
+        # x is greater than 0, y is less than or equal to 0
+        print("Quadrant IV")
+else:
+    if y > 0:
+        # x is less than or equal to 0, y is greater than 0
+        print("Quadrant II")
+    else:
+        # x is less than or equal to 0, y is less than or equal to 0
+        print("Quadrant III")
+```
+
+If we have more than two options to distinguish using the conditional operator, we can use the statement **`if ... elif ... else`** (**`elif`** is short for *else if*):
+
+<pre>
+<b>if</b> <i>condition1</i><b>:</b>
+    any number of commands
+    executed if condition1 is True
+<b>elif</b> <i>condition2</i><b>:</b>
+    any number of commands
+    executed if the condition1 if False and condition2 is True
+<b>elif</b> <i>condition3</i><b>:</b>
+    any number of commands
+    executed if the condition1 and condition2 are False and condition3 is True
+<b>else:</b>
+    any number of commands
+    executed if all conditions are False
+</pre>
+
+Let's show how it works by rewriting the example above:
+
+```python
+x = float(input("Enter x coordinate:"))
+y = float(input("Enter y coordinate:"))
+
+if x > 0 and y > 0:
+    print("Quadrant I")
+elif x > 0 and y < 0:
+    print("Quadrant IV")
+elif y > 0:
+    print ("Quadrant II")
+else:
+    print ("Quadrant III")
+```
+
+<hr/>
+
+Published under [Creative Commons Attribution-NonCommercial-ShareAlike](https://creativecommons.org/licenses/by-nc-sa/4.0/) license.

03 Flow Control/1.md

@@ -0,0 +1,76 @@
+# While loops
+
+To be useful any programming language must allow you to repeat a portion of a program more than once. These types of repetitions are called loops. There are two kinds of loops in Python. Below, we will discuss the first of them: the **while** loop. It is used to repeat a given block as long as a certain condition is met. This loop looks like this:
+
+<pre>
+<b>while</b> <i>condition</i><b>:</b>
+    block of statements executed
+    as long as the condition
+    is True
+</pre>
+
+Please note the colon after the condition and the block indentation — the same rules for defining blocks apply as for the **if** statement. Sample code:
+
+```python
+number = 0
+while number < 1 or number > 10:
+     number = int(input("Enter an integer from 1 to 10:"))
+print("Your number is", number)
+```
+
+In the above example, the user will be prompted to enter a `number` as long as the value of the variable number to which the value is assigned is either less than 1 or greater than 10.
+
+<u>The condition in the **while** loop is checked at the very beginning, before the loop is executed for the first time.</u> This means that the loop may not be executed even once if the condition is not met at the very beginning. Please note the first line of the example above `number = 0`. It defines a variable `number` and sets its value to zero, which guarantees that the first time it checks, the **while** loop will be true (0 < 1) i.e. the user will be prompted for a number at least once.
+
+## Breaking the loop
+
+The standard termination of the while loop occurs when the condition has a value False. When set to value True, the entire loop block is executed. This is not always what you want. Therefore, it is possible to interrupt execution of a loop inside its block with an instruction break. Let's see an example of a primitive version of the 21 game:
+
+```python
+sum = 0 
+given_number = int(input("Enter a number: ")) 
+while given_number != 0:
+    sum += given_number   # this entry is a shortened version of the assignment sum + = sum + given_number
+    if sum > 21:
+        print("You have exceeded 21 and you lost! ")
+        sum = 0
+        break
+    given_number = int(input("Enter a number (0 to end): ")) 
+print("Your score is", sum)
+```
+
+Normal loop break occurs when the user enters the number 0 (the condition will not be fulfilled then `given_number != 0`). However, when the calculated sum exceeds 21, the loop is stopped abnormally using the break command. In both cases, the program will continue from the first command outside the loop block (`print("Your score is", sum)`).
+
+After a completed loop block, it is possible to add a command **`else`** followed by a block, which will only be executed if the loop ended normally (that is, not via a command **`break`**). Using this, you can write the above example in a slightly more elegant way:
+
+```python
+sum = 0
+given_number = int(input("Enter a number: "))
+while given_number != 0:
+    sum += given_number
+    if sum > 21:
+        print("You've exceeded 21 and lost!")
+        break
+    given_number = int(input("Enter number (0 to finish): ")) 
+else:
+    print("You won! Your score is", sum)
+```
+
+The last line will only be printed when the loop ends with a zero, not by exceeding 21.
+
+## Continuation of the loop
+
+Another statement that is used to control loop execution is **`continue`**. If the Python interpreter hits **`continue`** somewhere in the middle of a loop iteration, it skips all remaining statements and proceeds to the next iteration. Example:
+
+```python
+i = -11
+while i < 10:
+    i += 1
+    if i == 0:
+        continue
+    print(1 / i)
+```
+
+<hr/>
+
+Published under [Creative Commons Attribution-NonCommercial-ShareAlike](https://creativecommons.org/licenses/by-nc-sa/4.0/) license.

03 Flow Control/2 While loops.md

@@ -0,0 +1,155 @@
+# For loops
+
+Another type of loop in Python is the for loop. It is used when we are able to predict in advance how many times we want to perform this loop, or when we want to repeat it for each element of the sequence. The for loop syntax is as follows:
+
+<pre>
+<b>for</b> <i>pointer</i> <b>in</b> <i>sequence_which_we_iterate</i><b>:</b>
+    block repeated for each element of the sequence,
+    the identifier given as a pointer will
+    point at each element of the sequence in every iteration
+</pre>
+
+In the above syntax  we give the correct variable name as the pointer. This variable does not have to be previously defined (and if it was, its previous value will be removed). Each time the loop passes, this variable will take the next values ​​in the sequence we iterate through. Of course, the sequence must exist: either be given as a constant or assigned to a variable.
+
+So far, two sequence types have been introduced: string and tuple. The following is an example of a loop in which all the elements of a tuple are summed:
+
+```python
+numbers = (1, 2, 3, 5, 7)
+sum = 0
+for number in numbers:
+    sum += number
+print("Sum of numbers is", sum)
+```
+
+> **Attention!** In Python, many basic operations (such as adding the elements of a set) can be done with one command or function (in this case, it would be enough to write `result = sum(liczby)`). In normal programs, use these abbreviated forms as they are clearer and usually run faster. However, for the purposes of examples and exercises, we will write many of these simple operations by hand — for illustration purposes only.
+
+You can also iterate over elements of a text string:
+
+```python
+name = input("What is your name:")
+for letter in name:
+     print(letter)
+```
+
+The above example will ask the user for their first name and then print each letter in a separate line.
+
+## Caesar cipher
+
+Now let's look at a more advanced example. We will implement the [Caesar cipher](https://en.wikipedia.org/wiki/Caesar_cipher) (although we will limit ourselves to the alphabet used in the English language). First, however, it is necessary to explain how the characters are stored in the computer's memory. Well, every computer is a device that can carry out operations on numbers and only on numbers. Therefore, in order to save any text in the computer's memory, each character must be assigned a numerical value. Which number corresponds to which letter defined by the ASCII and Unicode standards. There are two functions in Python that let you find out which number corresponds to which character and vice versa. The first is a function `ord(character)` whose argument can only be one character (that is, a text string containing exactly one element). It will return the numeric code of this character. The inverse function `chr(code)` will return the character represented by the numeric code given as its argument. Please check in the interactive console:
+
+```python
+print(ord('A'))
+
+print(chr(122))
+```
+
+The above functions will be used in the encryption program using the Caesar cipher. We will use an alphabetic shift of 13, because the English alphabet has 26 letters, so double encrypted messages will restore it (in other words, the same program can be used to encrypt and decrypt messages — this variant of the Caesar cipher is called ROT-13).
+
+```python
+# We read the text to be encrypted
+original_text = input("Enter the text to be encrypted: ")
+ 
+# The ciphertext is empty for now; we will add further characters to it
+encrypted_text = ''
+
+# In the loop we iterate over each
+for character in original_text:
+
+    if 'A' <= character <='Z':  # condition a < x <b is the same as: a < x and x < b
+        # We have a capital letter; we calculate its sequence number
+        # (so that the letter "A" corresponds to 0)
+        code = ord(character) - ord('A')
+
+        # We encrypt the character: add 13 and wrap up to 26 characters (remainder from division)
+        new_code = (code + 13) % 26
+
+        # We add a new ciphertext: 
+        # first "shift" the new code so that the letter "A" has the correct code, 
+        # then convert it to a character and add it to the string with the result
+        encrypted_text += chr(new_code + ord('A'))
+
+    elif 'a' <= character <= 'z':  # we do the same for lower case letters
+        code = ord(character) - ord('a')   # subtract lower case code "a"
+        new_code = (code + 13) % 26
+        encrypted_text += chr (new_code + ord('a'))
+
+    else: 
+         # Rewrite the remaining characters unchanged
+         encrypted_text += character
+
+# Print the results 
+print(encrypted_text)
+```
+
+Please copy the example below to a new file (e.g. `rot13.py`), and then run. Please carefully analyze its syntax so that you understand each line. As part of the classes, you will write more advanced programs than the above.
+
+If in doubt, please post on the forum.
+
+## Numeric ranges
+
+It is very often necessary to repeat the loop a specific number of times. We can then use the following form:
+
+<pre>
+<b>for</b> <i>counter</i> in <b>range</b>(<i>number_of_repetitions</i>)<b>:</b>
+     block repeated a given number of times
+</pre>
+
+As this loop runs, the counter will go from 0 to the value of *repetitions*–1. Try the following example:
+
+```python
+for i in range(10): 
+    print(i)
+```
+
+Please note that the number 10 has not been printed.
+
+In fact, `range` is a function that generates a sequence of numbers on the fly, and the **for** loop just iterates over that generated sequence. It can be used in three ways: The most basic and most frequently used `range(stop)` will form a sequence from 0 to the preceding value `stop`. We can also provide the function of two arguments `range(start, stop)`. Then the countdown will start from the value given as `start` (if *start* ≥ *stop*, the range will be empty and the loop will not run even once). So *range(stop)* is equivalent of *range(0, stop)*. The third version is `range(start, stop, step)` that adds a step used to change the value each time. In this case, the iteration will end when the next value reaches or exceeds the `stop` value.
+
+So to print the numbers from 1 to 10 we can use:
+
+```python
+for i in range(1, 11): 
+    print(i)
+```
+
+and to do it backwards:
+
+```python
+for i in range (10, 0, -1): 
+    print(i)
+```
+
+## Exercise
+
+Write a program that asks the user for an integer, then calculates and prints its factorial (that is, the product of the numbers from 1 up to and including the given number ). Your work may be based on the above example for calculating the sum of numbers and on the examples of the range function. Please check if you have calculated 5! is equal to 120 and 10! = 3 628 800.
+
+## Breaking and continuing the loop
+
+As with the while loop, the **`break`** and **`continue`** commands and can be used in the for loop. Their operation is the same as in the case described earlier. Here, too, it is possible to use the **`else:`** block, which will be executed only when the loop ends normally (that is, after it has finished iteration over all elements).
+
+```python
+trap = int(input("Enter the trap value:"))
+
+for i in range (1, 11):
+    if i == trap:
+        print ("You felt into the trap!") 
+        break
+    print(i) 
+else: 
+    print ("You successfully avoided the trap.")
+```
+
+## Loop nesting
+
+There are no obstacles to place the other inside one loop. It is only important to use different pointer (counter) names in nested loops. For example, to display the names of all fields on a chessboard, we can use the following program:
+
+```python
+for row in range(8, 0, -1):                   # numbers from 8 to 1 (inclusive) backwards (row 8 will be on top)
+    for column in "ABCDEFGH":
+        print(column, row, sep='', end=' ')   # the meaning of sep and end was explained before
+    print()                                   # at the end of each row we only print a newline (default end)
+```
+
+<hr/>
+
+Published under [Creative Commons Attribution-NonCommercial-ShareAlike](https://creativecommons.org/licenses/by-nc-sa/4.0/) license.