Chapter 3: Control Flow and Decision-Making in Python
Control flow in Python determines the order in which statements are executed. It allows you to create dynamic programs that make decisions and repeat actions. Here's a breakdown of the essential elements:
Conditional Statements:
• if statement: Executes a block of code if a condition is true.
if x > 0:
print("x is positive")
• elif statement: (short for "else if") Allows you to check multiple conditions sequentially.
if x > 0:
print("x is positive")
elif x == 0:
print("x is zero")
• else statement: Executes a block of code if none of the preceding conditions are true.
if x > 0:
print("x is positive")
else:
print("x is not positive")
Loops:
• for loop: Iterates over a sequence (like a list, tuple, or string).
for fruit in ["apple", "banana", "orange"]:
print(fruit)
• while loop: Repeats a block of code as long as a condition is true.
count = 0
while count < 5:
print(count)
count += 1
Control Flow Statements:
• break statement: Exits a loop prematurely.
for number in range(10):
if number == 5:
break
print(number)
• continue statement: Skips the current iteration of a loop and moves to the next.
for number in range(10):
if number % 2 == 0:
continue
print(number)
Indentation:
• Python uses indentation to define code blocks. This means that the code within an if statement, elif statement, else statement, for loop, or while loop must be indented consistently.
Example:
age = 20
if age < 18:
print("You are a minor.")
elif age >= 18 and age < 65:
print("You are an adult.")
else:
print("You are a senior citizen.")
Keywords :
Control Flow, Decision-Making, `if` Statement, `if-else` Statement, Loop, Indentation
Learning Outcomes
After undergoing this article you will be able to understand the Control Flow and Decision-Making in Python.
Overview
Decision control structures are used to control the flow of a program based on certain conditions. If the condition is true, the statement(s) will be executed. Otherwise, they will be skipped. In Python, blocks are groups of statements that are executed together based on a specific condition or control structure.
So let's learn in details about Control Flow and Decision-Making in Python
Control flow structures are the backbone of programming, enabling developers to determine the logical sequence of actions. Python offers versatile tools for decision-making, loops, and control mechanisms that allow for efficient program execution. This chapter delves into these aspects, providing a comprehensive guide to understanding and applying them effectively.
---
### **3.1 Decision-Making Statements in Python**
Decision-making statements enable programs to respond to various conditions. Python provides several constructs for implementing conditional logic:
#### **3.1.1 The `if` Statement**
The `if` statement executes a block of code if a specified condition is true.
```python
x = 10
if x > 5:
print("x is greater than 5")
```
#### **3.1.2 The `if-else` Statement**
The `if-else` statement provides an alternate block of code to execute when the condition is false.
```python
x = 10
if x > 5:
print("x is greater than 5")
else:
print("x is 5 or less")
```
#### **3.1.3 The `if-elif-else` Statement**
This allows multiple conditions to be checked in sequence.
```python
x = 10
if x > 10:
print("x is greater than 10")
elif x == 10:
print("x is equal to 10")
else:
print("x is less than 10")
```
---
### **3.2 Loops in Python**
Loops are used to repeat a block of code as long as a condition is met. Python offers two main types of loops:
#### **3.2.1 The `for` Loop**
The `for` loop iterates over a sequence (like lists, strings, or ranges).
```python
for i in range(5):
print(i)
```
#### **3.2.2 The `while` Loop**
The `while` loop executes a block of code as long as its condition remains true.
```python
x = 0
while x < 5:
print(x)
x += 1
```
---
### **3.3 Looping Techniques in Python**
Python simplifies iteration with powerful techniques:
#### **3.3.1 Iterating Over a Dictionary**
Use `.items()` to loop through key-value pairs.
```python
data = {'a': 1, 'b': 2, 'c': 3}
for key, value in data.items():
print(f"{key}: {value}")
```
#### **3.3.2 Enumerate**
The `enumerate()` function adds a counter to an iterable.
```python
fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
print(index, fruit)
```
#### **3.3.3 Zip**
The `zip()` function combines two or more iterables.
```python
names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
for name, age in zip(names, ages):
print(f"{name} is {age} years old")
```
---
### **3.4 Control Statements in Python**
Control statements modify the flow of loops. Python includes:
#### **3.4.1 `break` Statement**
The `break` statement exits a loop prematurely.
```python
for i in range(10):
if i == 5:
break
print(i)
```
#### **3.4.2 `continue` Statement**
The `continue` statement skips the rest of the current iteration.
```python
for i in range(5):
if i == 3:
continue
print(i)
```
#### **3.4.3 `pass` Statement**
The `pass` statement serves as a placeholder, doing nothing when executed.
```python
for i in range(5):
if i == 3:
pass
print(i)
```
#### **3.4.4 `else` with Loops**
The `else` block in loops executes only if the loop completes without a `break`.
```python
for i in range(5):
if i == 10:
break
else:
print("Loop completed successfully")
```
---
### **3.5 Chaining Comparison in Python**
Python allows chaining multiple comparisons for concise and readable conditions.
#### **3.5.1 Simple Comparison**
Chained comparisons combine multiple relational operations.
```python
x = 10
if 5 < x < 15:
print("x is between 5 and 15")
```
#### **3.5.2 Logical Comparisons**
You can combine comparisons using logical operators.
```python
x, y = 10, 20
if x > 5 and y > 15:
print("Both conditions are true")
```
#### **3.5.3 Benefits of Chaining**
Chaining reduces verbosity and improves readability compared to traditional combinations with `and` or `or`.
---
### **Summary**
In this chapter, we explored the essential control flow tools in Python, including decision-making statements, looping mechanisms, and advanced techniques like chaining comparisons. These constructs provide a foundation for building efficient and logical Python programs. Mastering them is key to writing clean, maintainable, and effective code.
References
[1] https://www.scaler.com/topics/python/control-flow-statements-in-python/
[2] https://www.linkedin.com/pulse/control-flow-python-mastering-conditional-statements-loops-shaik
[3] https://github.com/milaan9/03_Python_Flow_Control/blob/main/000_Python_Flow_Control_statement%20.ipynb
Comments
Post a Comment
"Thank you for seeking advice on your career journey! Our team is dedicated to providing personalized guidance on education and success. Please share your specific questions or concerns, and we'll assist you in navigating the path to a fulfilling and successful career."