Branching using Conditional Statements and Loops in Python

This tutorial covers the following topics:

• Branching with if, else and elif
• Nested conditions and if expressions
• Iteration with while loops
• Iterating over containers with for loops
• Nested loops, break and continue statements

This tutorial is an executable Jupyter notebook. Click the Open in Colab button at the top of this page to execute the code.

Jupyter Notebooks: This notebook is made of cells. Each cell can contain code written in Python or explanations in plain English. You can execute code cells and view the results instantly within the notebook. Jupyter is a powerful platform for experimentation and analysis. Don't be afraid to mess around with the code & break things - you'll learn a lot by encountering and fixing errors. You can use the "Kernel > Restart & Clear Output" menu option to clear all outputs and start again from the top.

Branching with if, else and elif

One of the most powerful features of programming languages is branching: the ability to make decisions and execute a different set of statements based on whether one or more conditions are true.

The if statement

In Python, branching is implemented using the if statement, which is written as follows:

if condition:
    statement1
    statement2

The condition can be a value, variable or expression. If the condition evaluates to True, then the statements within the if block are executed. Notice the four spaces before statement1, statement2, etc. The spaces inform Python that these statements are associated with the if statement above. This technique of structuring code by adding spaces is called indentation.

Indentation: Python relies heavily on indentation (white space before a statement) to define code structure. This makes Python code easy to read and understand. You can run into problems if you don't use indentation properly. Indent your code by placing the cursor at the start of the line and pressing the Tab key once to add 4 spaces. Pressing Tab again will indent the code further by 4 more spaces, and press Shift+Tab will reduce the indentation by 4 spaces.

For example, let's write some code to check and print a message if a given number is even.

We use the modulus operator % to calculate the remainder from the division of a_number by 2. Then, we use the comparison operator == check if the remainder is 0, which tells us whether the number is even, i.e., divisible by 2.

Since 34 is divisible by 2, the expression a_number % 2 == 0 evaluates to True, so the print statement under the if statement is executed. Also, note that we are using the string format method to include the number within the message.

Let's try the above again with an odd number.

As expected, since the condition another_number % 2 == 0 evaluates to False, no message is printed.

The else statement

We may want to print a different message if the number is not even in the above example. This can be done by adding the else statement. It is written as follows:

if condition:
    statement1
    statement2
else:
    statement4
    statement5

If condition evaluates to True, the statements in the if block are executed. If it evaluates to False, the statements in the else block are executed.

Here's another example, which uses the in operator to check membership within a tuple.

The elif statement

Python also provides an elif statement (short for "else if") to chain a series of conditional blocks. The conditions are evaluated one by one. For the first condition that evaluates to True, the block of statements below it is executed. The remaining conditions and statements are not evaluated. So, in an if, elif, elif... chain, at most one block of statements is executed, the one corresponding to the first condition that evaluates to True.

In the above example, the first 3 conditions evaluate to False, so none of the first 3 messages are printed. The fourth condition evaluates to True, so the corresponding message is printed. The remaining conditions are skipped. Try changing the value of today above and re-executing the cells to print all the different messages.

To verify that the remaining conditions are skipped, let us try another example.

Note that the message 15 is divisible by 5 is not printed because the condition a_number % 5 == 0 isn't evaluated, since the previous condition a_number % 3 == 0 evaluates to True. This is the key difference between using a chain of if, elif, elif... statements vs. a chain of if statements, where each condition is evaluated independently.

Using if, elif, and else together

You can also include an else statement at the end of a chain of if, elif... statements. This code within the else block is evaluated when none of the conditions hold true.

Conditions can also be combined using the logical operators and, or and not. Logical operators are explained in detail in the first tutorial.

Non-Boolean Conditions

Note that conditions do not necessarily have to be booleans. In fact, a condition can be any value. The value is converted into a boolean automatically using the bool operator. This means that falsy values like 0, '', {}, [], etc. evaluate to False and all other values evaluate to True.

Nested conditional statements

The code inside an if block can also include an if statement inside it. This pattern is called nesting and is used to check for another condition after a particular condition holds true.

Notice how the print statements are indented by 8 spaces to indicate that they are part of the inner if/else blocks.

Nested if, else statements are often confusing to read and prone to human error. It's good to avoid nesting whenever possible, or limit the nesting to 1 or 2 levels.

Shorthand if conditional expression

A frequent use case of the if statement involves testing a condition and setting a variable's value based on the condition.

Python provides a shorter syntax, which allows writing such conditions in a single line of code. It is known as a conditional expression, sometimes also referred to as a ternary operator. It has the following syntax:

x = true_value if condition else false_value

It has the same behavior as the following if-else block:

if condition:
    x = true_value
else:
    x = false_value

Let's try it out for the example above.

Statements and Expressions

The conditional expression highlights an essential distinction between statements and expressions in Python.

Statements: A statement is an instruction that can be executed. Every line of code we have written so far is a statement e.g. assigning a variable, calling a function, conditional statements using if, else, and elif, loops using for and while etc.

Expressions: An expression is some code that evaluates to a value. Examples include values of different data types, arithmetic expressions, conditions, variables, function calls, conditional expressions, etc.

Most expressions can be executed as statements, but not all statements are expressions. For example, the regular if statement is not an expression since it does not evaluate to a value. It merely performs some branching in the code. Similarly, loops and function definitions are not expressions (we'll learn more about these in later sections).

As a rule of thumb, an expression is anything that can appear on the right side of the assignment operator =. You can use this as a test for checking whether something is an expression or not. You'll get a syntax error if you try to assign something that is not an expression.

The pass statement

if statements cannot be empty, there must be at least one statement in every if and elif block. You can use the pass statement to do nothing and avoid getting an error.

Iteration with while loops

Another powerful feature of programming languages, closely related to branching, is running one or more statements multiple times. This feature is often referred to as iteration on looping, and there are two ways to do this in Python: using while loops and for loops.

while loops have the following syntax:

while condition:
    statement(s)

Statements in the code block under while are executed repeatedly as long as the condition evaluates to True. Generally, one of the statements under while makes some change to a variable that causes the condition to evaluate to False after a certain number of iterations.

Let's try to calculate the factorial of 100 using a while loop. The factorial of a number n is the product (multiplication) of all the numbers from 1 to n, i.e., 1*2*3*...*(n-2)*(n-1)*n.

Here's how the above code works:

• We initialize two variables, result and, i. result will contain the final outcome. And i is used to keep track of the next number to be multiplied with result. Both are initialized to 1 (can you explain why?)

• The condition i <= 100 holds true (since i is initially 1), so the while block is executed.

• The result is updated to result * i, i is increased by 1 and it now has the value 2.

• At this point, the condition i <= 100 is evaluated again. Since it continues to hold true, result is again updated to result * i, and i is increased to 3.

• This process is repeated till the condition becomes false, which happens when i holds the value 101. Once the condition evaluates to False, the execution of the loop ends, and the print statement below it is executed.

Can you see why result contains the value of the factorial of 100 at the end? If not, try adding print statements inside the while block to print result and i in each iteration.

Iteration is a powerful technique because it gives computers a massive advantage over human beings in performing thousands or even millions of repetitive operations really fast. With just 4-5 lines of code, we were able to multiply 100 numbers almost instantly. The same code can be used to multiply a thousand numbers (just change the condition to i <= 1000) in a few seconds.

You can check how long a cell takes to execute by adding the magic command %%time at the top of a cell. Try checking how long it takes to compute the factorial of 100, 1000, 10000, 100000, etc.

Here's another example that uses two while loops to create an interesting pattern.

Can you see how the above example works? As an exercise, try printing the following pattern using a while loop (Hint: use string concatenation):

          *
         **
        ***
       ****
      *****
     ******
      *****
       ****
        ***
         **
          *

Here's another one, putting the two together:

          *
         ***
        *****
       *******
      *********
     ***********
      *********
       *******
        *****
         ***
          *

Infinite Loops

Suppose the condition in a while loop always holds true. In that case, Python repeatedly executes the code within the loop forever, and the execution of the code never completes. This situation is called an infinite loop. It generally indicates that you've made a mistake in your code. For example, you may have provided the wrong condition or forgotten to update a variable within the loop, eventually falsifying the condition.

If your code is stuck in an infinite loop during execution, just press the "Stop" button on the toolbar (next to "Run") or select "Kernel > Interrupt" from the menu bar. This will interrupt the execution of the code. The following two cells both lead to infinite loops and need to be interrupted.

break and continue statements

You can use the break statement within the loop's body to immediately stop the execution and break out of the loop (even if the condition provided to while still holds true).

As you can see above, the value of i at the end of execution is 42. This example also shows how you can use an if statement within a while loop.

Sometimes you may not want to end the loop entirely, but simply skip the remaining statements in the loop and continue to the next loop. You can do this using the continue statement.

In the example above, the statement result = result * i inside the loop is skipped when i is even, as indicated by the messages printed during execution.

Logging: The process of adding print statements at different points in the code (often within loops and conditional statements) for inspecting the values of variables at various stages of execution is called logging. As our programs get larger, they naturally become prone to human errors. Logging can help in verifying the program is working as expected. In many cases, print statements are added while writing & testing some code and are removed later.

Iteration with for loops

A for loop is used for iterating or looping over sequences, i.e., lists, tuples, dictionaries, strings, and ranges. For loops have the following syntax:

for value in sequence:
    statement(s)

The statements within the loop are executed once for each element in sequence. Here's an example that prints all the element of a list.

Let's try using for loops with some other data types.

Note that while using a dictionary with a for loop, the iteration happens over the dictionary's keys. The key can be used within the loop to access the value. You can also iterate directly over the values using the .values method or over key-value pairs using the .items method.

Since a key-value pair is a tuple, we can also extract the key & value into separate variables.

Iterating using range and enumerate

The range function is used to create a sequence of numbers that can be iterated over using a for loop. It can be used in 3 ways:

• range(n) - Creates a sequence of numbers from 0 to n-1
• range(a, b) - Creates a sequence of numbers from a to b-1
• range(a, b, step) - Creates a sequence of numbers from a to b-1 with increments of step

Let's try it out.

Ranges are used for iterating over lists when you need to track the index of elements while iterating.

Another way to achieve the same result is by using the enumerate function with a_list as an input, which returns a tuple containing the index and the corresponding element.

break, continue and pass statements

Similar to while loops, for loops also support the break and continue statements. break is used for breaking out of the loop and continue is used for skipping ahead to the next iteration.

Like if statements, for loops cannot be empty, so you can use a pass statement if you don't want to execute any statements inside the loop.

Nested for and while loops

Similar to conditional statements, loops can be nested inside other loops. This is useful for looping lists of lists, dictionaries etc.

With this, we conclude our discussion of branching and loops in Python.

Further Reading and References

We've covered a lot of ground in just 3 tutorials.

Following are some resources to learn about more about conditional statements and loops in Python:

• Python Tutorial at W3Schools: https://www.w3schools.com/python/
• Practical Python Programming: https://dabeaz-course.github.io/practical-python/Notes/Contents.html
• Python official documentation: https://docs.python.org/3/tutorial/index.html

Questions for Revision

Try answering the following questions to test your understanding of the topics covered in this notebook:

1. What is branching in programming languages?
2. What is the purpose of the if statement in Python?
3. What is the syntax of the if statement? Give an example.
4. What is indentation? Why is it used?
5. What is an indented block of statements?
6. How do you perform indentation in Python?
7. What happens if some code is not indented correctly?
8. What happens when the condition within the if statement evaluates to True? What happens if the condition evaluates for false?
9. How do you check if a number is even?
10. What is the purpose of the else statement in Python?
11. What is the syntax of the else statement? Give an example.
12. Write a program that prints different messages based on whether a number is positive or negative.
13. Can the else statement be used without an if statement?
14. What is the purpose of the elif statement in Python?
15. What is the syntax of the elif statement? Give an example.
16. Write a program that prints different messages for different months of the year.
17. Write a program that uses if, elif, and else statements together.
18. Can the elif statement be used without an if statement?
19. Can the elif statement be used without an else statement?
20. What is the difference between a chain of if, elif, elif… statements and a chain of if, if, if… statements? Give an example.
21. Can non-boolean conditions be used with if statements? Give some examples.
22. What are nested conditional statements? How are they useful?
23. Give an example of nested conditional statements.
24. Why is it advisable to avoid nested conditional statements?
25. What is the shorthand if conditional expression?
26. What is the syntax of the shorthand if conditional expression? Give an example.
27. What is the difference between the shorthand if expression and the regular if statement?
28. What is a statement in Python?
29. What is an expression in Python?
30. What is the difference between statements and expressions?
31. Is every statement an expression? Give an example or counterexample.
32. Is every expression a statement? Give an example or counterexample.
33. What is the purpose of the pass statement in if blocks?
34. What is iteration or looping in programming languages? Why is it useful?
35. What are the two ways for performing iteration in Python?
36. What is the purpose of the while statement in Python?
37. What is the syntax of the white statement in Python? Give an example.
38. Write a program to compute the sum of the numbers 1 to 100 using a while loop.
39. Repeat the above program for numbers up to 1000, 10000, and 100000. How long does it take each loop to complete?
40. What is an infinite loop?
41. What causes a program to enter an infinite loop?
42. How do you interrupt an infinite loop within Jupyter?
43. What is the purpose of the break statement in Python?
44. Give an example of using a break statement within a while loop.
45. What is the purpose of the continue statement in Python?
46. Give an example of using the continue statement within a while loop.
47. What is logging? How is it useful?
48. What is the purpose of the for statement in Python?
49. What is the syntax of for loops? Give an example.
50. How are for loops and while loops different?
51. How do you loop over a string? Give an example.
52. How do you loop over a list? Give an example.
53. How do you loop over a tuple? Give an example.
54. How do you loop over a dictionary? Give an example.
55. What is the purpose of the range statement? Give an example.
56. What is the purpose of the enumerate statement? Give an example.
57. How are the break, continue, and pass statements used in for loops? Give examples.
58. Can loops be nested within other loops? How is nesting useful?
59. Give an example of a for loop nested within another for loop.
60. Give an example of a while loop nested within another while loop.
61. Give an example of a for loop nested within a while loop.
62. Give an example of a while loop nested within a for loop.

Writing Reusable Code Using Functions in Python

This tutorial is the fourth in a series on introduction to programming using the Python language. These tutorials take a practical coding-based approach, and the best way to learn the material is to execute the code and experiment with the examples.

Creating and using functions

A function is a reusable set of instructions. A function takes one or more inputs, performs certain operations, and often returns an output. Python provides many in-built functions like print, and also allows you to define your own functions.

You can define a new function using the def keyword.

Note the round brackets or parantheses () and colon : after the function's name. Both are essential parts of the syntax for defining a function. The body of the function can contain one or more statements which are to be executed when the function is called. Simlar to conditional statements and loops, the statements must be indented by 4 spaces.

The statements inside a function's body are not executed when a function is defined. To execute the statements, we need to call or invoke the function.

Function arguments

Functions can also accept one or more values as inputs (also knows as arguments or parameters). Arguments help us write flexible functions which can perform the same operation on different values. Further, functions can also return a value as a result using the return keyword, which can be stored in a variable or used in other expressions.

Here's a function that filters out the even numbers from a list.

Writing great functions in Python

As a programmer, you will spend most of your time writing and using functions, and Python offers many features to make your functions powerful and flexible. Let's explore some of these by solving a problem:

Radha is planning to buy a house that costs $1,260,000. She considering two options to finance her purchase:

• Option 1: Make an immediate down payment of $300,000, and take loan 8-year loan with an interest rate of 10% (compounded monthly) for the remaining amount.
• Option 2: Take a 10-year loan with an interest rate of 8% (compounded monthly) for the entire amount.

Both these loans have to paid back in equal monthly installments (EMIs). Which loan has a lower EMI among the two?

Since we need to compare the EMIs for two loan options, it might be helpful to define a function to calculate the EMI for a loan, given inputs like the cost of the house, the down payment, duration of the loan, rate of interest etc. We'll build this function step by step.

To begin, let's write a simple function that calculates the EMI on the entire cost of the house, assuming that the loan has to be paid back in one year, and there is no interest or down payment.

Local variables and scope

Let's add a second argument to account for the duration of the loan, in months.

Note that the variable emi defined inside the function is not accessible outside the function. The same is true for the parameters amount and duration. These are all local variables that lie within the scope of the function.

Scope: Scope refers to the region within the code where a certain variable is visible. Every function (or class definition) defines a scope within Python. Variables defined in this scope are called local variables. Variables that are available everywhere are called global variables. Scope rules allow you to use the same variable names in different functions without sharing values from one to the other.

We can now compare a 6-year loan vs. a 10-year loan (assuming no down payment or interest).

Return values

As you might expect, the EMI for the 6-year loan is higher compared to the 10-year loan. Right now we're printing out the result, but it would be better to return it and store the results in variables for easier comparison. We can do this using the return statement

Optional arguments

Let's now add another argument to account for the immediate down payment. We'll make this an optional argument, with a default value of 0.

Next, let's add the interest calculation into the function. Here's the formula used to calculate the EMI for a loan:

where:

• P is the loan amount (principal)
• n is the no. of months
• r is the rate of interest per month

The derivation of this forumula is beyond the scope of this tutorial. See this video for an explanation: https://youtu.be/Coxza9ugW4E

Note that while defining the function, required arguments like cost, duration and rate must appear before optional arguments like down_payment.

Let's calculate the EMI for Option 1

While calculating the EMI for Option 2, we need not include the down_payment argument.

Named arguments

Invoking a function with many arguments can often get confusing, and is prone to human errors. Python provides the option of invoking functions with named arguments, for better clarity. Function invocation can also be split into multiple lines.

Modules and library functions

We can already see that the EMI for Option 1 seems to be lower than the EMI for Option 2. However, it would be nice to round up the amount to full dollars, rather than including digits afer the decimal. To achieve this, we might want to write a function which can take a number and round it up to the next integer (e.g. 1.2 is rounded up to 2). That would be a good exercise to try out!

However, since rounding numbers is a fairly common operation, Python provides a function for it (along with thousands of other functions) as part of the Python Standard Library. Functions are organized into modules, which need to imported in order to use the functions they contain.

Modules: Modules are files containing Python code (variables, functions, classes etc.). They provide a way of organizing the code for large Python projects into files and folders. The key benefit offered by modules is namespaces - a module or a specific function/class/variable from a module has to imported before it can be used within a Python script or notebook. This provides encapsulation and avoid naming conflicts between your code vs. a module, or across modules.

For rounding up our EMI amounts, we can use the ceil function (short for ceiling) from the math module. Let's import the module and use it to round up the number 1.2 .

Let's now use the math.ceil function within the home_loan_emi function to round up the EMI amount.

Using function to build other functions is a great way to reuse code and implement complex business logic while still keeping the code small, understandable and manageable. Ideally, one a fuction should do one thing, and one thing only. If you find yourself doing too many things within a single function, you should consider splitting it into 2 or more smaller, independent functions. As a rule of thumb, try to limit your functions to 10 lines of code or less. Good programmers always write small, simple and readable functions.

Let's compare the EMIs and display a message for the option with the lower EMI.

Reusing and improving functions

Now we know for cetain that "Option 1" has the lower EMI among the two options. But what's even better is that we now have a handy function loan_emi that can be used to solve many other similar problems with just a few lines of code. Let's try it with a couple more problems.

Q: Shaun is currenly paying back a home loan for a house a few years go. The cost of the house was $800,000. Shaun made a down payment of 25% of the cost, and financed the remaining amount using a 6-year loan with an interest rate of 7% per annum (compounded monthly). Shaun is now buying a car worth $60,000, which he is planning to finance using a 1-year loan with an interest rate of 12% per annum. Both loans are paid back in EMIs. What is the total monthly payment Shaun makes towards loan repayment?

This question is now straightforward to solve, using the loan_emi function we've already defined.

Exceptions and try-except

Q: If you borrow $100,000 using a 10-year loan with an interest rate of 9% per annum, what is the total amount you end up paying as interest?

One way to solve this problem is to compare the EMIs for two loans: one with the given rate of interest, and another with a 0% rate of interest. The total interest paid is then simply the sum of monthly differences over the duration of the loan.

Something seems to have gone wrong! If you look at the error message above carefully, Python tells us exactly what is gone wrong. Python throws a ZeroDivisionError with a message indicating that we're trying to divide a number by zero. This is an exception that stops further execution of the program.

Exception: Even if a statement or expression is syntactically correct, it may cause an error when an attempt is made to execute it. Errors detected during execution are called exceptions. We refer to exceptions as being typically stop further execution of the program, unless they are handled within the program using try-except statements.

Python provides many built-in exceptions that are thrown when built-in operators, functions or methods are used in an incorrect manner: https://docs.python.org/3/library/exceptions.html#built-in-exceptions . You can also define your own custom exception by extending Exception class (more on that later).

You can use the try and except statements to handle and exception. Here's an example:

When an exception occurs in the code inside a try block, the rest of the statements in the block are skipped, and except statement is executed. If the type of exception throw matches the type of exception being handled by the except statement, then the code inside the except block is executed and the program execution then returns to the normal flow.

You can also handle more than one type of exception using multiple except statements. Learn more about exceptions here: https://www.w3schools.com/python/python_try_except.asp .

Let's enhance the loan_emi function to use try-execpt to handle the scenario where the rate of intersest is 0%. It's common practice to make changes/enhancements to functions over time, as new scenarios and use cases come up. It makes functions more flexible & powerful.

We can use the updated loan_emi function to solve our problem.

Q: If you borrow $100,000 using a 10-year loan with an interest rate of 9% per annum, what is the total amount you end up paying as interest?

Documenting functions using Docstrings

We can add some documentation within our function using a docstring. A docstring is simply a string that appears as the first statement within the function body, and is used by the help function. A good docstring describes what the function does, and provides some explanation about the arguments.

In the docstring above, we've provided some additional information that the duration and rate are both measured in months. You might even consider naming the arguments duration_months and rate_monthly, to avoid any confusion whatsoever. Can you think of some other ways in which the function can be improved?

Summary and Further Reading

With this we complete our discussion of functions in Python. We've covered the following topics in this tutorial:

• Creating and using functions
• Functions with one or more arguments
• Local variables and scope
• Returning values using return
• Using default arguments to make a function flexible
• Using named arguments while invoking a function
• Importing modules and using library functions
• Reusing and improving functions to handle new use cases
• Handling exceptions with try-except
• Documenting functions using docstrings

This is by no means an exhaustive or comprehensive tutorial on functions in Python. Here are few more topics to learn about:

• Functions with an arbitrary number of arguments using (*args and **kwargs)
• Defining functions inside functions (and closures)
• A function that invokes itself (recursion)
• Functions that accept other functions as arguments or return other functions
• Functions that enhance other functions (decorators)

Following are some resources to learn about more functions in Python:

• Python Tutorial at W3Schools: https://www.w3schools.com/python/
• Practical Python Programming: https://dabeaz-course.github.io/practical-python/Notes/Contents.html
• Python official documentation: https://docs.python.org/3/tutorial/index.html