Conditional Execution with if Statements

When Input Goes Wrong

Programs often receive input that does not match what they expect. Imagine a temperature converter asking for a Fahrenheit temperature. If the user enters hello instead of 98.6, Python cannot convert that text to a floating-point number with float(). Python raises a ValueError, and without error handling the program stops with a crash report.

The try-except Relationship

A try-except block gives Python two possible paths. The try clause contains code that might fail. If every operation in that clause succeeds, execution continues after the complete try-except structure. If an operation raises an error, Python immediately leaves the remaining code in the try clause and runs the except clause. The except clause therefore contains the response your program should use when the expected error occurs.

try:
    risky_operation()
except ErrorType:
    handle_the_error()

Tracing Both Execution Paths

inp = input("Enter a Fahrenheit temperature: ")

try:
    fahrenheit = float(inp)
    print("A number was entered:", fahrenheit)
except ValueError:
    print("Please enter a number")

In this example, input() is placed before the try clause. The conversion with float(inp) is inside the try clause because converting user input is the operation likely to raise a ValueError. The print operation that depends on a successful conversion is also inside the try clause. If the input is hello, Python fails at float(inp), skips the remaining line in the try clause, and runs the except clause. The user sees Please enter a number rather than an unhandled crash.

Choosing the Protected Code

A useful rule is to place code that might raise an exception in the try clause. In the temperature example, float(inp) is the main risky operation. The calculation that follows can also remain in the try clause because it depends on the conversion succeeding. If conversion fails, there is no point in attempting the calculation.

Keep the try clause focused. Code that is not at risk of raising an exception in this context does not need to be placed there. The source example identifies input() as an operation that could be placed before the try clause, while the conversion and dependent calculation belong inside it.

Crash Reports and Friendly Messages

Mistakes to Avoid

• Putting the risky conversion outside the try clause

  If the input cannot be converted, the error occurs before Python reaches the try clause, so the exception is not handled by that block.

  Fix: Place the float(inp) operation inside the try clause.

• Expecting the except clause to run every time

  The except clause runs only when an error occurs in the try clause.

  Fix: Treat except as the error path, not as a second block that always runs.

• Continuing with dependent work after conversion fails

  When float(inp) raises ValueError, Python immediately jumps to the except clause and does not execute the remaining lines in the try clause.

  Fix: Keep calculations that depend on a successful conversion in the try clause so they are skipped when conversion fails.

• Replacing a clear response with an unhelpful crash

  The user receives a poor experience and the program stops without a response designed by the programmer.

  Fix: Use the except clause to provide a clear message such as Please enter a number.

Practice the Control Flow

1. Identify the operation that might fail.
2. Place that operation in the try clause.
3. Place the response for the expected error in the except clause.
4. Trace what happens when the operation succeeds.
5. Trace what happens when the operation raises an exception.