What Is Decision Making ?

Decision making is the most foundational concept in computer science. It is the mechanism that transforms a static list of instructions into a dynamic, thinking program. Without decision making, software would execute code sequentially from top to bottom, producing the exact same outcome every time.
By implementing decision-making logic, computers mimic human reasoning. They analyze variables, evaluate environments, check inputs, and choose the most appropriate path forward.

At its core, decision making is about predicting conditions and determining the flow of execution. A condition is a mathematical or logical expression that evaluates to a boolean state: either True or False.
The Logic Flow
1. The State : The program encounters a variable or an external input (e.g., user clicks, sensor data).
2. The Condition : The program tests this data against a specific rule or threshold.
3. The Evaluation : The system evaluates the condition mathematically or logically.
4. The Branch : Based on the boolean result, control forks down a specific operational pathway.

Why Programs Require Decision Making ?

A computer program without decision-making capabilities is completely static. It executes instructions blindly from top to bottom, producing the exact same outcome every time. Introducing decision logic makes software dynamic, secure, and interactive.Here is a breakdown of why programs require decision making :
1. Enabling Dynamic Outputs : Without decision logic, code runs linearly and produces the exact same outcome every time. Decisions allow software to adapt and change its behavior based on different user inputs.
2. Managing User Authentication : Security systems rely on decisions to compare login credentials. Access is granted only if the typed password matches the database, while unauthorized attempts are blocked.
3. Preventing System Crashes : Computers cannot process invalid mathematical equations like dividing by zero. Decision logic inspects variables beforehand to intercept and block illegal actions before they freeze the CPU.
4. Validating Data Inputs : Programs use logic gates to check forms before processing them. This ensures critical formats are met, such as verifying a phone number contains only numbers or an email contains an "@" symbol.
5. Controlling Real-Time Hardware : Smart appliances use decision loops to interact with physical sensors. An automated air conditioner cuts power to its compressor the exact moment a room's ambient temperature hits the user's target setting.

The Anatomy of Conditional Logic

Every computational decision relies on two fundamental building blocks: evaluating data relations and combining truths.
1. Comparison Operations (Relational Operators) : Computers make choices by comparing pieces of data. These operations establish mathematical relationships between variables .
Equivalence (==) : Determines if two distinct values are exactly identical.
Inequality (!=) : Confirms that two values do not match.
Magnitude (>, <, >=, <=) : Evaluates order, sizing, and thresholds between numerical values.
2. Boolean Logic (Logical Operators) : Complex human decisions involve multiple factors. Similarly, programs combine multiple criteria using Boolean logic:
Conjunction (AND) : Requires every single condition to be absolutely true.
Disjunction (OR) : Requires only one condition out of many to be true.
Negation (NOT) : Inverts the logic status, turning a truth into a falsehood.

How Decision Making Works

Decision making in code acts like a train track switch. The system takes data inputs, evaluates them against strict logical boundaries, and forces the execution flow to down a specific path.

1. The Ingestion Phase (Input Data) : The computer receives variable data. This data can come from a user typing a password, a smart sensor reading the room temperature, or a database pulling account balance info.
2. The Decision Node (The Logic Gate) : The data hits a conditional boundary. The programmer defines this boundary using comparison operators (like equals ==, greater than >, or less than <).
3. The Evaluation Metric (Binary Resolution) : The machine processes the condition down to an absolute truth state. It can only ever resolve to True or False. Computer hardware cannot process a "maybe."
4. The Execution Branch (The Split Flow) : Based on the true/false resolution, the execution path forks:
True Branch : The machine unlocks and executes the designated code compartment.
False Branch : The machine completely skips that compartment and runs either a default fallback or resumes the normal sequential layout of the script.

Types Of Decision Making

In programming, decision making is achieved through Conditional Statements. These statements act as logical filters that evaluate conditions and direct the computer to execute specific paths of code based on whether a condition is true or false.

To handle different logical scenarios—ranging from a single check to multiple conditions—programming languages offer three fundamental types of decision-making structures. The chart below illustrates how these statements branch out under the core umbrella of conditional logic.

What Is If Statement ?

At the computer architecture level, an if statement is a conditional branch instruction. Computers execute code sequentially by default, moving from one memory address to the next. The if statement breaks this linear progression. It instructs the CPU to evaluate a specific state and, based on the result, dynamically change the execution path of the application.

In Python, the if statement is a control flow structure that acts as a gatekeeper. It marks out a specific block of code and ensures that this block is executed only if a specified condition evaluates to a boolean value of True. If the condition evaluates to False, the block is bypassed entirely, and the interpreter jumps directly to the first line of code written after the conditional block.

The Runtime Lifecycle of an if Statement

When Python runs an if statement, it undergoes a strict internal process :
Expression Evaluation : The runtime environment steps into the condition line and computes the expression to find its absolute value.
Boolean Typecasting: The resulting value is passed through Python’s internal __bool__() or __len__() methods to determine its absolute true/false nature.
Branch Target Calculation :
1. If True: The internal pointer jumps to the first instruction inside the indented code block.
2. If False: The internal pointer skips all indented instructions and targets the instruction memory address immediately following the block.

Structural Compilation of an if Block

The syntax of an if statement is structurally strict. Let us deconstruct its exact layout piece by piece :

if condition_expression:
    indented_statement_1
    indented_statement_2
    indented_statement_3
unindented_statement

The if Keyword : A reserved keyword in Python that signals the compiler to initiate a conditional validation branch.
The condition_expression : A variable, raw value, mathematical calculation, or function call that yields an object back to Python for evaluation.
The Colon (:) : A structural punctuation mark that signals the closing of the conditional check and mandates the opening of a new scope/block. Without this colon, the Python parser cannot separate the expression from the upcoming statements, throwing an unrecoverable SyntaxError.
The Indented Code Block : The payload lines of code that execute only when the condition passes.

If Statement With Real Code

Here is a complete, production-ready real-world example of an isolated if statement.We will build an E-commerce Fraud Detection Gate. This script analyzes a shopping transaction and automatically flags it for manual review if it looks suspicious.
Before looking at the code, let us understand the business logic. Our system needs to evaluate whether an order is highly risky based on its total cost.
The Rule : If a single transaction amount exceeds $10,000, it is flagged as a high-risk transaction.
The Action : The system must trigger a security alert, change the order status to "Hold", and notify the fraud team.
Normal Flow : If the transaction is under $10,000, the if gate stays closed. The program skips the fraud alerts and goes straight to standard payment processing.

# 1. Setting up transaction data (Mock Data)
transaction_id = "TXN-90821"
order_amount = 14500.00  # The amount is over $10,000
order_status = "Pending_Payment"
security_alert_triggered = False

print("--- Initializing Fraud Detection Gate Scan ---")

# 2. The Isolated IF Statement
# This condition checks if the order amount is strictly greater than 10000
if order_amount > 10000.00:
    print(f"[ALERT]: Suspicious activity detected on Transaction {transaction_id}!")
    print(f"Reason: Order amount (${order_amount}) exceeds high-value threshold.")
    
    # Modifying state inside the IF block
    order_status = "Hold_For_Review"
    security_alert_triggered = True
    
    print("Action Taken: Order status locked. Fraud response team notified.")

# 3. Post-Gate execution (This code runs completely outside the IF block)
print("\n--- Gate Scan Completed ---")
print(f"Current Order Status: {order_status}")
print(f"Security Alert Active: {security_alert_triggered}")

Else Statement

In software engineering, a lone if statement allows a program to make a detour only when a condition is met. However, robust applications frequently require a strict binary choice—a fork in the road where the system must execute Path A if the condition is met, OR execute Path B if the condition fails.This is where the else statement comes in.

What Is Else Statement ?

At the machine architecture level, an else statement provides an alternative execution path when a conditional branch instruction evaluates to False. It acts as a safety net or a default fallback handler.
An else statement cannot exist on its own; it is structurally bound to an if statement. Together, they create a mutually exclusive conditional block. This means one, and exactly one, of the two blocks will execute. It is impossible for both to run, and it is impossible for neither to run.

1. The Python interpreter evaluates the expression connected to the if statement.
2. If the expression evaluates to True, Python runs the if code block, completely ignores the else block, and continues down the script.
3. If the expression evaluates to False, Python skips the if code block entirely and jumps straight into the else block, executing its code before moving forward.

Syntax Of Else Statement

if condition_expression:
    # Code block starter (4 spaces)
    if_statement_1
    if_statement_2
else:
    # Alternate block starter (4 spaces)
    else_statement_1
    else_statement_2
unindented_statement

Real-World Implementation

Let us scale up our previous example. We will build an Automated Data Center Server Maintenance Gateway. This script checks a server's operational memory utilization and decides whether to trigger emergency system cleaning or report that the system status is healthy.

# 1. Setting up telemetry metrics from the cloud cluster
server_id = "NODE-US-EAST-04"
memory_utilization_percentage = 92.5  # Critical threshold is 85.0
system_status = "UNKNOWN"
maintenance_routine_triggered = False

print("--- Initiating Automated Server Telemetry Scan ---")

# 2. The Mutually Exclusive IF-ELSE Control Flow Block
if memory_utilization_percentage >= 85.0:
    print(f"[CRITICAL WARNING]: Node {server_id} memory utilization is extremely high!")
    print(f"Current Usage: {memory_utilization_percentage}% exceeds safety limits.")
    
    # State modification inside the IF block
    system_status = "OVERLOADED_MAINTENANCE"
    maintenance_routine_triggered = True
    
    print("Action Taken: Activating memory flush and garbage collection daemon threads.")

else:
    print(f"[HEALTH CHECK]: Node {server_id} is operating within nominal limits.")
    print(f"Current Usage: {memory_utilization_percentage}% is well below warning thresholds.")
    
    # State modification inside the ELSE block
    system_status = "OPTIMAL_OPERATIONAL"
    maintenance_routine_triggered = False
    
    print("Action Taken: Renewing normal cluster load balancing lease.")

# 3. Post-Gate execution (This code runs completely outside the control block)
print("\n--- Gate Scan Completed ---")
print(f"Final Node Status Assessment: {system_status}")
print(f"Maintenance Pipeline Active: {maintenance_routine_triggered}")

What Is Elif Statement ?

In Python, the elif statement stands for "else if" and is used to chain multiple conditional checks together. When you write a program, you often need to make decisions based on different scenarios. While a simple if statement handles a single condition and an else statement handles the final fallback, the elif statement allows your code to check multiple alternative conditions in a clean, sequential order.

The elif statement in Python is the key tool for handling multiple choices in your code. It is short for "else if," and it acts as an intermediate check between your initial if condition and your final fallback else statement. When your program faces a situation with more than two possible outcomes—such as grading a student, categorizing a speed limit, or checking a user's subscription tier—you use elif to inspect each potential scenario one after the other in a clean, organized manner.

How the elif Statement Works Under the Hood

When Python encounters a conditional block, it treats it as a single, connected pipeline with multiple gates. Python reads your code strictly from top to bottom, testing each gate one by one. The most critical rule to remember is that Python will only execute the very first code block that evaluates to True. The moment it finds a matching condition and runs its code, it destroys the rest of the pipeline and jumps completely out of the conditional structure. It will never look at or test any statements written below that matching point.

Step 1: The Initial Entry Point (if) : The program always enters the structure at the very top through the if block. Python evaluates this initial expression to see if it equals True or False. If this condition matches, Python opens the gate, executes Code Block 1, and instantly destroys the remaining pipeline. The code under the elif blocks and the else block is completely ignored, and the program jumps straight to the code written outside and below this entire conditional structure.
Step 2: The Second Filter Tier (elif 1) : If the first if statement evaluates to False, Python uses the down arrow pathway to drop down to the first elif block. It checks this condition only because the previous one failed. If this specific elif expression evaluates to True, Python stops dropping down, executes Code Block 2, and immediately exits the pipeline.
Step 3: Sequential Extension (elif 2) : When both the initial if and the first elif turn out to be False, Python keeps moving downward to the next available elif statement. Python treats this exactly like the previous step. It evaluates the expression; if it is True, it runs Code Block 3 and exits. You can stack dozens of these elif blocks sequentially if your application logic requires checking many different specific values.
Step 4: The Ultimate Catch-All Safety Net (else) : The final else block at the bottom has no condition attached to it. It acts as a universal fallback filter. The only way Python ever reaches this block is if every single if and elif check above it evaluated to False. If nothing else matched, Python automatically executes Code Block 4 as a default action, completing the sequence before allowing the rest of your main script to resume.

Syntax Structure of the elif Chain

The code always begins with a single if statement, followed by as many elif statements as your logic requires, and usually ends with a final else statement. Every conditional line must terminate with a colon (:), and the blocks of code that belong to them must be indented consistently with four spaces.

if initial_condition:
    # Runs only if initial_condition is True
    code_block_one
elif secondary_condition:
    # Runs only if initial_condition is False AND secondary_condition is True
    code_block_two
elif third_condition:
    # Runs only if all previous conditions are False AND third_condition is True
    code_block_three
else:
    # Runs only if every single condition above turns out to be False
    fallback_code_block

Real Python Code Example

The practical Python program below simulates an automated traffic speed violation system. It captures a driver's speed, passes it through a series of logical thresholds using elif, determines the severity of the violation, and issues the correct penalty instruction.

# Real-world traffic violation and fine calculator

def evaluate_driving_speed(current_speed):
    # Set the legal baseline speed limit
    speed_limit = 60
    
    # Establish a safe, normal driving condition first
    if current_speed <= speed_limit:
        status = "Safe Driver"
        action = "No penalty. Thank you for driving safely!"
    # Check for a minor speeding violation using the first elif
    elif current_speed <= speed_limit + 10:
        status = "Minor Speeding"
        action = "Issue a formal warning letter to the driver's profile."
    # Check for a moderate speeding violation using the second elif
    elif current_speed <= speed_limit + 25:
        status = "Moderate Speeding"
        action = "Issue a standard traffic fine of $150."
    # Handle the worst-case scenario if all previous checks fail
    else:
        status = "Reckless Driving"
        action = "Mandatory license suspension and vehicle impoundment."
        
    return f"Vehicle Status: {status} | Action Required: {action}"

# Simulating a car traveling at 82 units of speed
vehicle_speed = 82
police_report = evaluate_driving_speed(vehicle_speed)

print("--- Automated Highway Patrol Report ---")
print(police_report)

What Is Nested If ?

A nested if statement in Python is a programming structure where an if, elif, or else block is placed inside the body of another if, elif, or else block. It creates a hierarchical, multi-layered decision-making process. The inner condition is entirely dependent on the outer condition; if the outer condition evaluates to False, the inner condition is completely ignored.

Execution Flow

To understand nested if statements, you must understand how Python's interpreter handles execution flow and scoping via indentation.
Evaluation Phase 1 : Python encounters the primary (outer) if statement and evaluates its expression to a boolean value (True or False).
The Branching Point : 1. If the outer condition is False, Python skips the entire block of code indented beneath it. Execution jumps directly to the matching outer elif or else statement (if present), or moves to the next unindented line of code.
2. If the outer condition is True, Python enters the code block. It executes any sequential code statements present before the nested condition.
2. Evaluation Phase 2 : Python encounters the secondary (inner) if statement. It evaluates this new condition.
3. Final Resolution : If the inner condition is True, the inner code block runs. If it is False, the inner else block (if written) runs.

Why and When to Use Nested If Statements

While simple conditions can be handled with standard if-else or logical operators like and/or, nested structures are mandatory in specific engineering scenarios :
1. Sequential Dependencies : When Condition B cannot be logically evaluated unless Condition A is already proven true. For example, you cannot check if a specific database record contains a value if the database connection itself has failed.
2. State Machines and Phase Validations : Ideal for multi-stage workflows such as checkout pipelines, user registration forms, and game states (e.g., Check if player is alive → Check if player has keys → Check if door is unlocked).
3. Distinct Error Handling / Logging : If you need to perform specific actions or print distinct error messages at each level of failure. Combining conditions with and only tells you that the collective statement failed, not which part failed.
4. Performance Optimization : Evaluating resource-intensive conditions (like an API call or heavy math calculation) only after a lightweight condition (like checking a local cache flag) passes.

Syntax Profiles

Python uses strict 4-space indentation to define the scope of nesting. Missing or misaligned spaces will result in an IndentationError

Profile A: Basic Nested If-Else

if outer_condition:
    # Code block runs if outer_condition is True
    statement_outer_1
    
    if inner_condition:
        # Code block runs if BOTH outer and inner conditions are True
        statement_inner_true
    else:
        # Code block runs if outer is True, but inner is False
        statement_inner_false
else:
    # Code block runs if outer_condition is False
    statement_outer_false

Profile B: Multi-Tiered Complex Nesting

if level_1_condition:
    print("Passed Level 1")
    
    if level_2_condition:
        print("Passed Level 2")
        
        if level_3_condition:
            print("Passed Level 3 - Access Granted")
        else:
            print("Failed Level 3")
    else:
        print("Failed Level 2")
else:
    print("Failed Level 1")

Advanced Real-World Code Implementations

This script controls an automated smart climate control system. It evaluates the home occupancy, current temperature, and humidity levels to decide whether to activate the Air Conditioning (AC), Heat Pump, or Dehumidifier.

# System input state variables
is_home_occupied = True
current_temperature_celsius = 28.5
humidity_percentage = 72.0

print("Initializing Smart HVAC Assessment Pipeline...")

# Outer Layer: Energy-saving check. Do not run heavy appliances if home is empty.
if is_home_occupied:
    print("Status: Occupants detected. Analyzing climate metrics...")
    
    # Inner Layer 1: Check if temperature requires cooling
    if current_temperature_celsius > 25.0:
        print(f"Alert: High temperature detected ({current_temperature_celsius}°C).")
        
        # Deep Inner Layer 2: Check humidity to determine AC mode
        if humidity_percentage > 65.0:
            print("Action: Deploying Air Conditioner in 'Max Dehumidification' Mode.")
        else:
            print("Action: Deploying Air Conditioner in 'Eco Cooling' Mode.")
            
    # Inner Layer 1 Alternate: Check if temperature requires heating
    elif current_temperature_celsius < 18.0:
        print(f"Alert: Low temperature detected ({current_temperature_celsius}°C).")
        
        if humidity_percentage < 30.0:
            print("Action: Deploying Radiant Heater with Automated Humidifier.")
        else:
            print("Action: Deploying Standard Heat Pump Mode.")
            
    # Inner Layer 1 Alternate: Temperature is optimal, check humidity independently
    else:
        print("Status: Temperature is within optimal comfort zone (18°C - 25°C).")
        
        if humidity_percentage > 60.0:
            print("Action: Temperature optimal, but humidity high. Activating standalone Dehumidifier.")
        else:
            print("Action: All systems idle. Activating ceiling fans for air circulation.")

else:
    print("Status: Home is vacant. Switching HVAC systems to Eco Saver Hibernate Mode.")
    
print("HVAC Pipeline execution complete.")

Truthy and Falsy Values

In programming, Truthy and Falsy values determine how non-boolean values (like numbers, strings, or lists) behave when evaluated inside a conditional statement (if or elif).

Instead of requiring an explicit comparison (like if x == True:), Python implicitly converts the value to a boolean behind the scenes. This is called Boolean Type Coercion.

1. Falsy Values

In Python, an object is considered Falsy if it represents an empty structure, a zero value, or a state of absence. If passed into an if condition, these values will always trigger the else block.There are only a few built-in Falsy values in Python :

2. Truthy Values

By default, every other value in Python is considered Truthy. If an object contains data, has a non-zero value, or is an initialized object, it evaluates to True.
Any non-empty string : "Hello", " ", "False" (even a string containing spaces or the word "False" is Truthy).
Any non-zero number : 1, -5, 3.14.
Any non-empty collection : [1, 2], {"key": "value"}.

Syntax Architecture & Implicit Evaluation

Instead of writing verbose comparisons, clean Python code relies on implicit evaluation.

# Verbose / Non-Pythonic style
if user_name != "":
    print("Access granted.")

# Clean / Pythonic style (Leveraging Truthy nature)
if user_name:
    print("Access granted.")

Real-World Code Implementations

This script processes a registration form payload. It uses truthy and falsy rules to ensure fields aren't blank or unselected before saving data.

# Simulating a form submission payload
form_submission = {
    "username": "coder_99",
    "bio": "",                # Falsy (Empty string)
    "age": 0,                 # Falsy (Zero)
    "interests": [],          # Falsy (Empty list)
    "newsletter_opt_in": True # Truthy (Boolean)
}

print("Initiating form validation...")

# Check Username (Must be non-empty string)
if form_submission["username"]:
    print(f"Username validated: {form_submission['username']}")
else:
    print("Validation Error: Username field cannot be empty.")

# Check Bio (Optional field, providing a fallback default if falsy)
if not form_submission["bio"]:
    form_submission["bio"] = "No bio provided."
    print("System Note: Applied default bio fallback.")

# Check Age (Must be a non-zero valid number)
if form_submission["age"]:
    print(f"Age validated: {form_submission['age']}")
else:
    # 0 falls here, catching invalid or omitted input
    print("Validation Error: Age must be greater than zero.")

# Check Interests
if form_submission["interests"]:
    print("Interests recorded successfully.")
else:
    print("System Note: User left interests blank.")

Logical Operators In Decision Making

Logical operators in Python allow you to combine multiple conditional expressions or invert the truth value of a condition. They are the foundation of complex decision-making, enabling your code to evaluate multiple criteria simultaneously rather than relying on heavily nested if statements. Python features three logical operators, evaluated in a specific order of precedence: not (highest priority), followed by and, and finally or (lowest priority).

The Three Core Logical Operators

Unlike languages where logical operators strictly return boolean True or False, Python handles these evaluations dynamically. They return the value of the evaluating operand itself based on its Truthy or Falsy status.
1. The and Operator : The and operator requires all evaluation expressions to be Truthy for the compound statement to resolve as valid. If any single expression evaluates to Falsy, the whole block fails.
Under-the-Hood Rule: It evaluates expressions from left to right. It returns the first Falsy value it encounters. If all values are Truthy, it returns the final value.
Truth Table Blueprint:
True and True ---> True
True and False ---> False
False and True ---> False
False and False ---> False
2. The or Operator : The or operator requires at least one evaluation expression to be Truthy to execute its code block. It fails only when every single operand evaluates to Falsy.
Under-the-Hood Rule: It evaluates from left to right and returns the first Truthy value it encounters. If all values are Falsy, it returns the final value.
Truth Table Blueprint:
True or True ---> True
True or False ---> True
False or True ---> True
False or False ---> False
3. The not Operator : The not operator is a unary operator. It takes a single expression, evaluates its boolean value, and completely flips the result.
Under-the-Hood Rule: It explicitly returns a pure boolean value (True or False), discarding the raw original data type.
Truth Table Blueprint:
not True ---> False
not False ---> True

Short-Circuit Evaluation

Python utilizes Short-Circuit Evaluation at the interpreter level. It stops scanning an expression the exact millisecond the final output becomes mathematically certain.

and Short-Circuiting : If the left operand is Falsy, the entire expression must be False. Python ignores the right operand completely.
or Short-Circuiting : If the left operand is Truthy, the entire expression must be True. Python ignores the right operand completely.

Production Safety Pattern (Crash Prevention)

Short-circuiting protects programs from throwing runtime fatal errors like ZeroDivisionError, IndexError, or AttributeError.

# System input state
server_metrics = [] # Empty list (Falsy)
divisor = 0

# Test 1: Preventing an IndexError
# Python stops at 'server_metrics' because it's empty. It never reads server_metrics[0].
if server_metrics and server_metrics[0] == "Active":
    print("Metric check passed.")
else:
    print("Safely avoided IndexError via short-circuit.")

# Test 2: Preventing a ZeroDivisionError
# Python stops at 'divisor > 0'. It never evaluates the division by zero error on the right side.
if divisor > 0 and (100 / divisor) > 5:
    print("Calculation successful.")
else:
    print("Safely avoided ZeroDivisionError via short-circuit.")

Real-World Production Code Implementations

This module uses a mixture of and, or, and not operators to flag transactions for review based on user account health and transaction parameters.

# System state inputs
order_value = 1500.00
is_account_verified = True
is_ip_suspicious = False
has_coupon_code = True
is_coupon_valid = False

print("Starting E-Commerce Checkout Validation Pipeline...")

# Criterion 1: Order verification rules
# Block order if ip is suspicious OR if account is NOT verified
if is_ip_suspicious or not is_account_verified:
    print("Transaction Blocked: Security threshold failure.")
    
# Criterion 2: Complex promotions and pricing logic
# Apply discount if order is high value AND user has a coupon AND that coupon is valid
elif order_value > 1000.00 and has_coupon_code and is_coupon_valid:
    discount = order_value * 0.15
    print(f"Success: High-Value VIP Promo applied. Saved ${discount:.2f}")
    
# Criterion 3: Standard high-value validation
elif order_value > 1000.00 and not has_coupon_code:
    print("Success: Processing standard high-value enterprise order.")
    
else:
    print("Success: Standard order checkout cleared.")