What Are Conditional Statements – Complete Guide

Welcome to the world of conditional statements, an essential element in programming that steers the flow of execution based on certain conditions. Imagine you’re crafting a game where a character must make decisions: to attack or retreat, to collect a power-up, or to solve a puzzle based on environmental clues. These decisions are deeply ingrained in programming through conditional statements that intuitively mirror such decision-making processes. Embracing and mastering these can be both rewarding and fun, unlocking a deeper understanding of how to craft interactive and intelligent programs.

What Are Conditional Statements?

Conditional statements are the backbone of decision making in programming. They allow a program to execute certain segments of code based on specified conditions. Just as you decide whether to grab an umbrella based on whether it’s raining, a program can decide whether to execute a piece of code based on the evaluation of a condition as true or false.

What Are Conditional Statements Used For?

Conditional statements are crucial in programming as they offer:

  • The ability to perform different actions based on different inputs.
  • The control over the flow of the program, directing the execution path.
  • A method to handle decisions, validations, and computations effectively.

Why Should I Learn Conditional Statements?

Understanding conditional statements is key for any coder, whether you’re a beginner or an experienced professional aiming to refresh your skills. You’ll find them in virtually every program and application:

  • They are the building blocks for creating complex logic and functionalities.
  • Learning conditional statements is critical to making your code interactive and responsive to user inputs.
  • They are fundamental in every programming language, including Python, which we’re using for our examples, making this knowledge transferrable and universal.

So, strap in as we embark on an engaging journey through the essentials of conditional statements!

CTA Small Image

Basic If-Statement in Python

An if-statement evaluates a condition and executes a block of code if the condition is true. Here’s the simplest form of an if-statement:

if condition:
    # Code to execute if the condition is true

Let’s look at a concrete example. Suppose we want to print a message if a character’s health is low:

health = 10

if health < 20:
    print("Character's health is low!")

When `health` is less than 20, the character’s dire state is printed to the console. Notice how the `print` statement is indented to indicate it’s part of the if-statement.

Adding an Else Statement

An else statement follows an if statement and is executed when the if condition is not met. Here’s an example:

score = 95

if score >= 90:
    print("You passed with flying colors!")
    print("You'll need to try a bit harder.")

This code checks if the score is 90 or above. If it is, it prints a congratulatory message. Otherwise, it advises more effort.

Introducing Elif for Multiple Conditions

Sometimes, you have multiple conditions to check before deciding what to execute. The `elif` (else if) statement serves this purpose:

temperature = 30

if temperature > 25:
    print("It's a hot day!")
elif temperature >= 15:
    print("It's a nice day!")
    print("It's cold outside!")

This block checks the temperature: for hotness, niceness, and coldness, providing a customized message for each range.

Nested If-Statements

You can nest if statements within each other for more complex logic. Here’s how:

age = 25
membership = True

if age > 18:
    if membership:
        print("Welcome to our club!")
        print("You're of age but you need a membership.")
    print("Sorry, you're too young to enter.")

The first condition checks age. If the person is over 18, it then checks if they have a club membership to determine the access message.

Through these examples, not only can we comprehend the basics of conditional statements in Python, but we also lay the foundation for creating intricate and compelling program logic. Let’s continue to build on this knowledge in the next section with more intricate examples.Continuing from where we left off, we’ll dive into more complex uses of conditional statements, providing us with a richer toolkit for programming.

Using Logical Operators in Conditions

Python’s logical operators (`and`, `or`, `not`) can combine multiple conditions within a single if-statement. Here’s how to use the `and` operator:

speed = 95
is_raining = True

if speed > 90 and is_raining:
    print("Slow down! It's dangerous to drive so fast in the rain.")

This checks if two conditions are true: the speed being above 90 and whether it is raining. Both conditions must be met to trigger the warning.

Using the `or` operator, we can execute code if at least one of the conditions is true:

temperature = -5
is_snowing = False

if temperature < 0 or is_snowing:
    print("Potential for ice. Drive carefully.")

This warns about icy conditions if either the temperature is below zero or it is snowing.

Combining Elif with Logical Operators

You can also use logical operators within `elif` statements for more granular control:

hours_worked = 40
overtime_rate = 1.5

if hours_worked  40 and hours_worked <= 60:
    print("Pay includes overtime at 1.5x the rate!")
    print("Pay includes double overtime!")

This checks the number of worked hours and applies different pay rates accordingly, using both `elif` and `and` for fine-tuned logic.

Inline If-Else Statements

For a more concise expression, Python allows inline if-else statements (often called ternary operators):

age = 20
adult_status = "Adult" if age >= 18 else "Minor"

This one-liner determines adult status based on age, demonstrating how a conditional can be compact and readable even in a single line of code.

Conditional Expressions in Loops

Conditional statements inside loops enable us to make decisions in each iteration:

for number in range(1, 11):
    if number % 2 == 0:
        print(f"{number} is even.")
        print(f"{number} is odd.")

Here, we iterate through a range of numbers, printing whether each number is even or odd. The modulo operator (`%`) is used to check the evenness of the number.

Value-Based Conditions

Python also lets us make decisions based on whether a variable has a certain value:

mode = "hardcore"

if mode == "easy":
    print("You're playing on easy mode.")
elif mode == "medium":
    print("You've selected medium difficulty.")
elif mode == "hardcore":
    print("Welcome to hardcore mode. Good luck!")

Based on the value of `mode`, a different message is printed. This type of check is especially common in game development for setting game modes or difficulty levels.

By grasping these concepts and learning to implement them with Python, we become more adept at creating programs that not only make decisions but also respond to a multitude of conditions and user inputs. Through practice, these patterns will become second nature, enabling you to write more sophisticated and intelligent code with ease.As we delve deeper into Python’s conditional statements, we’ll explore a variety of scenarios which often occur in real-world programming. This will help illuminate the flexibility and power these constructs add to your coding repertoire.

Complex Conditionals and Nested Logical Operators

In more intricate scenarios, you may need to nest logical operators within your conditional statements:

is_raining = True
temperature = 15
is_windy = False

if is_raining and (temperature < 20 or not is_windy):
    print("Take your umbrella and a jacket.")
elif is_raining and is_windy:
    print("Stay inside if you can, weather conditions are bad.")
    print("Enjoy your day outside!")

Here, we have nested conditions within our `if` statement, checking for multiple weather variables. This creates a nuanced decision-making process where specific advice is given based on various weather conditions.

Using Conditional Statements with Lists

Conditional statements can also interact with lists to perform checks on collections of items:

grocery_list = ['apple', 'banana', 'cucumber', 'bread']

if 'apple' in grocery_list:
    print("Don't forget to get the apples!")
    print("You should probably add apples to your list.")

This simple check swiftly determines whether ‘apple’ is an item in the `grocery_list` and responds accordingly.

We can also use conditions to filter items from a list:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = [num for num in numbers if num % 2 == 0]

print("Even numbers:", even_numbers)

Using a list comprehension with an `if` condition, we extract all even numbers from our `numbers` list.

Conditional Expressions in Function Parameters

When defining functions, we can use conditional expressions to provide default parameter values:

def greet(name=None):
    name = name if name is not None else "stranger"
    print(f"Hello, {name}!")


The function `greet` uses a conditional expression to print a greeting, using a default name if one isn’t provided.

Switch-Case Like Conditions Using Dictionaries

While Python does not have a built-in switch-case statement, we can mimic its behavior using dictionaries and functions.

def perform_operation(operation, x, y):
    def add(a, b):
        return a + b
    def subtract(a, b):
        return a - b
    def multiply(a, b):
        return a * b
    def divide(a, b):
        return a / b
    operations = {
        'add': add,
        'subtract': subtract,
        'multiply': multiply,
        'divide': divide
    return operations.get(operation, lambda a, b: "Invalid operation")(x, y)

print(perform_operation('add', 10, 5))  # Output: 15
print(perform_operation('divide', 20, 4))  # Output: 5
print(perform_operation('unknown', 20, 4))  # Output: Invalid operation

In this example, we’ve created a function that simulates a switch-case through a dictionary that maps strings to functions. It uses the `get` dictionary method with a lambda as the default value for handling invalid operations.

Python’s conditional statements give us the capacity to create detailed and smart code paths. They transform static procedures into dynamic experiences that react to user actions and program states. To truly master programming, there’s no doubt that understanding and effectively using these conditional constructs is key. Continue to experiment with these examples to witness how conditionally controlled code can heighten the sophistication of your projects.

Continuing Your Python Journey

The journey of learning Python doesn’t stop with mastering conditional statements. These are just the building blocks for what can become a highly skilled and fulfilling endeavor in programming. As you’ve started to understand the logic and structure behind decision-making in code, it’s now time to amplify your skills and knowledge.

We at Zenva know that the learning journey is an ongoing process, and we have structured our Python Mini-Degree to cater to your growing need for advanced knowledge. This mini-degree will guide you beyond the basics and delve into more in-depth concepts such as algorithms, object-oriented programming, game development, and app creation. Whether you’re looking to start a career in programming or simply want to expand your current skill set, our Python Mini-Degree is a gateway to mastering one of the most in-demand languages in the tech industry.

Don’t just stop here; explore our broad collection of Programming courses designed to take your skills to the next level. With flexible online access, you can learn at your own pace and on your own schedule. Start building your portfolio of projects, earn certificates of completion, and take your next steps towards becoming a proficient Python programmer with Zenva.


As you’ve journeyed through the world of Python’s conditional statements with us, you’ve equipped yourself with the ability to give your programs the gift of decision-making. Grasping these concepts is just the start; applying them in various challenging and creative ways is where the real adventure lies. We invite you to continue this thrilling voyage of discovery on Zenva’s Python Programming Mini-Degree, where you’ll not only reinforce what you’ve learned but also unlock new realms of programming expertise.

Whether you aspire to develop the next hit game or craft powerful software solutions, the knowledge you’ve gained here is a solid foundation. And we, at Zenva, are excited to be part of your ongoing story, helping turn your enthusiasm and efforts into tangible, rewarding skills. Dive deeper into Python with us, and let’s keep coding, creating, and conquering challenges together!

Did you come across any errors in this tutorial? Please let us know by completing this form and we’ll look into it!

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.