What are the common Python control structures?

Common Python Control Structures

In Python, control structures are the fundamental building blocks that allow you to control the flow of execution in your code. These structures enable you to make decisions, iterate over data, and handle exceptional situations. The most common Python control structures are:

1. Conditional Statements
2. Loops
3. Exception Handling

Let's dive into each of these control structures in detail:

1. Conditional Statements

Conditional statements in Python allow you to make decisions based on certain conditions. The most common conditional statements are:

1. if-elif-else: This structure allows you to check multiple conditions and execute different blocks of code based on the result.

age = 25
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.")

2. Ternary Operator: This is a concise way to write a simple if-else statement in a single line.

# Traditional if-else
is_adult = True
if is_adult:
    status = "Adult"
else:
    status = "Minor"

# Ternary Operator
status = "Adult" if is_adult else "Minor"

2. Loops

Loops in Python allow you to repeatedly execute a block of code until a certain condition is met. The most common loop structures are:

1. for loop: This loop is used to iterate over a sequence (such as a list, tuple, or string).

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

2. while loop: This loop continues to execute as long as a certain condition is true.

count = 0
while count < 5:
    print(count)
    count += 1

3. Nested Loops: Loops can be nested within other loops to handle more complex scenarios.

for i in range(3):
    for j in range(3):
        print(f"i={i}, j={j}")

3. Exception Handling

Exception handling in Python allows you to handle unexpected or exceptional situations that may occur during the execution of your code. The most common exception handling structures are:

1. try-except: This structure allows you to catch and handle specific exceptions.

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Error: Division by zero")

2. try-except-else: This structure allows you to define a block of code to be executed if no exceptions are raised.

try:
    result = 10 / 2
except ZeroDivisionError:
    print("Error: Division by zero")
else:
    print(f"Result: {result}")

3. try-except-finally: This structure allows you to define a block of code to be executed regardless of whether an exception is raised or not.

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Error: Division by zero")
finally:
    print("This block will always execute.")

Here's a Mermaid diagram that summarizes the core Python control structures:

By understanding these common Python control structures, you can write more robust, flexible, and maintainable code. Remember, the key is to choose the appropriate control structure based on the specific requirements of your program.