Conditional Logic in Python

Python has no switch statement; this is a deliberate design choice, not an oversight.

Programming

Following the Backup Workflow

Conditional logic becomes easier to understand when you follow the values moving through a complete task. A file backup workflow combines directory management, date and time formatting, string manipulation, and a decision about whether the user supplied a comment. The workflow first prepares a main backup directory, then prepares a date-based subdirectory, then creates a filename from the current time and optional comment, and finally constructs and executes a zip command.

What happens next as the script prepares directories, builds a filename, and runs the backup command?

Key point

The important habit is to trace one decision at a time. Directory existence decisions control whether os.mkdir runs. Comment length controls which filename branch runs. The result of os.system controls whether the script reports success or failure.

Preparing Directories Safely

The backup script creates a two-level directory structure. It checks the main backup directory first. If os.path.exists reports that the directory does not exist, the not operator reverses the result and the condition becomes true, so os.mkdir creates the directory. The same pattern is then used for a date-based subdirectory inside the main directory. Checking before creating allows the script to run repeatedly without attempting to create a directory that is already present.

Code walkthrough

import os

backup_dir = "backups"
date_dir = backup_dir + os.sep + "20240115"

if not os.path.exists(backup_dir):
    os.mkdir(backup_dir)

if not os.path.exists(date_dir):
    os.mkdir(date_dir)

print(date_dir)

1
Import os so the script can use path checks, directory creation, and the operating-system path separator.
2
Set the main backup directory name.
3
Build the date-based subdirectory path with os.sep.
4
Create the main directory only when os.path.exists says it is missing.
5
Create the date-based subdirectory only when it is missing.
6
Print the path so the execution can be traced.

How does the script decide whether to create each directory?

Building a Dynamic Filename

The filename uses the current time and an optional user comment. time.strftime formats the current date and time. The format string %Y%m%d produces a date with no separators, while %H%M%S produces a time with no separators. The date is used for the subdirectory, and the time and optional comment form the filename.

python

import time

current_date = time.strftime("%Y%m%d")
current_time = time.strftime("%H%M%S")
comment = "evening files"

if len(comment) == 0:
    filename = current_time + ".zip"
else:
    safe_comment = comment.replace(" ", "_")
    filename = current_time + "_" + safe_comment + ".zip"

print(current_date)
print(filename)

import time

current_date = time.strftime("%Y%m%d")
current_time = time.strftime("%H%M%S")
comment = "evening files"

if len(comment) == 0:
    filename = current_time + ".zip"
else:
    safe_comment = comment.replace(" ", "_")
    filename = current_time + "_" + safe_comment + ".zip"

print(current_date)
print(filename)

Output (expected)

20240115
143025_evening_files.zip

How does the original comment become part of a filename with spaces replaced by underscores?

Worked example

Tracing Empty and Nonempty Comments

Determine which filename branch runs when the comment is empty and when it contains the text morning files.

1
Empty comment
len(comment) is zero, so the condition len(comment) == 0 is true. The filename contains only the time and the .zip extension.
2
Comment with text
len(comment) is not zero, so the other branch runs. replace changes the space to an underscore before the comment is appended.
3
Directory placement
The date string identifies the date-based subdirectory, while the generated filename identifies the backup inside that directory.

Result

The two cases produce different filenames because conditional logic selects the filename structure according to the comment length.

Choosing One Branch with If Chains

Python has no switch statement. This is a deliberate design choice rather than an oversight. The direct replacement for a C or C++ switch is an if..elif..else chain: each elif corresponds to another case, and else corresponds to the default case. Python evaluates the conditions in order. Once one branch executes, the entire chain is finished, so the branches are mutually exclusive and there is no fall-through.

python

operation = "backup"

if operation == "backup":
    result = "run backup"
elif operation == "restore":
    result = "run restore"
else:
    result = "unknown operation"

print(result)

operation = "backup"

if operation == "backup":
    result = "run backup"
elif operation == "restore":
    result = "run restore"
else:
    result = "unknown operation"

print(result)

Output (expected)

run backup

How does control flow move through an if..elif..else chain, and why is only one matching branch executed?

From Switch Cases to Python

Decision feature	C or C++ switch	Python if..elif..else
Branch selection	Cases compare against a switch expression	Conditions are checked in order
Default behavior	default handles unmatched cases	else handles unmatched conditions
Multiple branch execution	Can fall through when break is omitted	Only one branch executes
Stopping a branch	break is commonly used to prevent fall-through	No break is needed for the chain

The source describes if..elif..else as the direct, mutually exclusive replacement for switch logic.

What is the difference between automatic fall-through in a C or C++ switch and Python's explicit branch selection?

python

choice = 2

if choice == 1:
    action = "first case"
elif choice == 2:
    action = "second case"
else:
    action = "default case"

print(action)

choice = 2

if choice == 1:
    action = "first case"
elif choice == 2:
    action = "second case"
else:
    action = "default case"

print(action)

Output (expected)

second case

This translation preserves the central decision: compare one value with several alternatives and select the matching action. The Python version makes the end of each alternative explicit through indentation and the structure of the chain, rather than relying on break statements to prevent later cases from running.

Scaling Branches with Dictionary Dispatch

An if..elif..else chain is the recommended starting point because it is clear, straightforward, and requires no setup. When there are many branches, or when operation names should map directly to functions, dictionary dispatch can make the decision logic more modular. A dictionary maps keys such as strings or integers to functions or values. Looking up a key returns the corresponding function, which can then be called.

python

def make_backup():
    return "backup selected"

def restore_backup():
    return "restore selected"

actions = {
    "backup": make_backup,
    "restore": restore_backup
}

operation = "backup"
result = actions[operation]()
print(result)

def make_backup():
    return "backup selected"

def restore_backup():
    return "restore selected"

actions = {
    "backup": make_backup,
    "restore": restore_backup
}

operation = "backup"
result = actions[operation]()
print(result)

Output (expected)

backup selected

Notes on the code

The dictionary associates each operation name with a function.
The lookup returns the function associated with the operation key.
The parentheses call the returned function.

How does an input key map directly to the function or action that should be executed?

Best practice

Start with if..elif..else for most decisions. Consider dictionary dispatch when you have more than five or six elif branches, when simple values map directly to choices, or when functions should be selected dynamically. Dictionary dispatch separates the decision about which function to call from the execution performed by that function.

Debugging Branch and Syntax Problems

A multi-step automation script is easiest to debug when each stage exposes its values. Print the directory paths, the generated filename, and the zip command before execution. Then inspect the status code returned by os.system: zero indicates success, while any other value indicates failure. Testing several inputs, including an empty comment and a comment containing spaces, helps verify that both filename branches work.

Common mistake
Creating a directory without checking whether it already exists.
What it looks like
os.mkdir(backup_dir) runs every time the script starts.
Why it fails
Repeated runs can attempt to create an existing directory.
Do this instead
```
Use if not os.path.exists(backup_dir): before os.mkdir(backup_dir).
```
Common mistake
Using the unsanitized comment directly in the filename.
What it looks like
```
filename = current_time + "_" + comment + ".zip"
```
Why it fails
The source notes that spaces in filenames can cause problems in many contexts.
Do this instead
Replace spaces with underscores before appending the comment.
Common mistake
Putting the comment branch outside the conditional structure.
What it looks like
Both the empty-comment and nonempty-comment filename statements execute as ordinary sequential statements.
Why it fails
The filename should have one structure when len(comment) is zero and another when it is not.
Do this instead
Use if len(comment) == 0 followed by else, with each assignment indented inside its branch.
Common mistake
Expecting Python if..elif..else to fall through like a switch with a missing break.
What it looks like
A matching branch executes and the learner expects the following branch to execute too.
Why it fails
Python chains are mutually exclusive and finish after one branch executes.
Do this instead
Put all intended actions in the selected branch; no break statement is needed.
Common mistake
Ignoring the status code from os.system.
What it looks like
os.system(command) runs, but the script never checks the returned value.
Why it fails
The script cannot report whether the command succeeded or failed.
Do this instead
Store the return value and treat zero as success and any other value as failure.

Code walkthrough

import os
import time

backup_dir = "backups"
date_name = time.strftime("%Y%m%d")
date_dir = backup_dir + os.sep + date_name
comment = "weekly files"

if not os.path.exists(backup_dir):
    os.mkdir(backup_dir)

if not os.path.exists(date_dir):
    os.mkdir(date_dir)

current_time = time.strftime("%H%M%S")
if len(comment) == 0:
    filename = current_time + ".zip"
else:
    comment = comment.replace(" ", "_")
    filename = current_time + "_" + comment + ".zip"

target = date_dir + os.sep + filename
source = ["notes.txt", "report.txt"]
command = "zip {} {}".format(target, " ".join(source))
print(date_dir)
print(filename)
print(command)
status = os.system(command)

if status == 0:
    print("backup succeeded")
else:
    print("backup failed")

1
The os and time modules provide the directory, path, date, and time operations used by the workflow.
2
The date string becomes part of the subdirectory path.
3
Each directory is checked before os.mkdir is called.
4
The comment is tested with len and sanitized with replace when it is nonempty.
5
The target path combines the date directory and generated filename.
6
join places spaces between source paths for the zip command.
7
format inserts the target and source text into the command template.
8
The command is printed before execution so the generated values can be inspected.
9
The returned status code is checked after os.system finishes.

Practice the Decision Trace

MEDIUM

Trace this generated scenario without running it. The main backup directory already exists, the date-based subdirectory does not exist, and the user enters the comment "project notes". Identify which os.mkdir call runs, which filename branch runs, what the sanitized comment becomes, and whether the if..elif..else rule would allow a second branch to run after the first match.

Hints

For each directory, ask what os.path.exists returns before applying not.
Compare the comment length with zero.
Apply replace to the space before constructing the filename.
Remember that one matching if..elif..else branch ends the chain.

Your attempt (not saved)

What do you think happens?

The comment is empty. Which filename form does the backup workflow select?

The current time followed by .zip
The current time followed by an underscore and the comment
The date followed by the unmodified empty comment

Reveal answer

Answer:

The current time followed by .zip

When len(comment) is zero, the empty-comment branch creates a filename containing only the time and the .zip extension.

Key Takeaways

1
A reliable backup workflow checks each directory with os.path.exists before calling os.mkdir.
2
time.strftime supplies compact date and time strings, while len and replace support conditional filename generation and sanitization.
3
Python has no switch statement; if..elif..else is its direct, mutually exclusive alternative.
4
Unlike switch fall-through, a Python conditional chain ends after one branch executes.
5
Dictionary dispatch maps keys directly to functions or values and is useful for larger or more dynamic branching systems.

At a glance

Conditional logic controls directory creation, filename selection, and operation selection in Python automation.
Check paths before creating directories, sanitize comments before using them in filenames, and print intermediate values while debugging.
Use if..elif..else as the clear replacement for C or C++ switch logic because Python branches do not fall through.
Use dictionary dispatch when many keys should map directly to functions or values.

Related concepts

Debugging Python Programs

More concepts starting with C

Following the Backup Workflow

Preparing Directories Safely

Building a Dynamic Filename

Choosing One Branch with If Chains

From Switch Cases to Python

Scaling Branches with Dictionary Dispatch

Debugging Branch and Syntax Problems

Practice the Decision Trace

Key Takeaways

At a glance

Related Topics

Related concepts