Python try except blocks keep your scripts running even when bad data tries to break them. Yesterday, my weather script crashed at 6:00 AM because an online service sent a blank number. One tiny line of bad text shut down the whole thing. A quick error check saved the day and kept the program alive.
When you wrap risky lines in a try block, Python tests the code first. If something goes wrong, the except part catches the mistake and runs a backup plan instead of stopping your code. It works like a safety net for your daily scripts.
Why Does Your Python Code Keep Crashing?
Programs break because the real world is full of surprises. You ask a user for their age, and they type the word five instead of the number 5. You try to open a photo from your desktop, but you moved it to a new folder ten minutes ago. Python panics when it sees these mistakes. It prints a big red message on your screen and stops everything right away.
Stopping completely is bad if your script does a long job. Imagine running a script that downloads 100 files. If file number 50 drops out, you do not want to lose the first 49 files you saved. You want the script to skip the broken file, write a small note in a log, and keep moving to file 51. That is why error handling matters so much for real tools.
Building strong scripts takes practice, but the core tools stay simple. You can read our full guide on Python Functions: How to Write and Use Them in Your Code to see how block structures clean up your scripts. Once you put riskier actions inside isolated blocks, your program stays up during strange edge cases.
How Do You Write a Basic Try Except Block?
Writing your first safety block takes only four lines. You start with the word try followed by a colon. On the next line, you indent your normal code. Underneath that, you write except, followed by a colon and the backup steps. Here is how that looks when dividing numbers.
try:
answer = 10 / 0
except:
print("You cannot divide a number by zero!")
When Python sees this code, it enters the try area first. It attempts to divide 10 by zero. Math rules do not allow that, so Python stops the try section right away. It skips to the except section and prints your custom message. Your program stays open, and you control what the user reads next.
If the math works fine, Python runs the code inside try and skips the except part entirely. Try it with 10 divided by 2. Python prints 5.0 and moves to the bottom of the block. Nothing breaks, and no red error text fills your screen.
How to Catch Specific Python Errors
Catching every error with a blank except statement sounds easy, but it can hide serious bugs. If you make a typo in a variable name inside a blind try block, Python treats it like a normal file error. You end up sitting at your desk for an hour trying to guess what broke. It helps to call out the exact error name you expect.
Python gives names to different problems. Math errors often trigger a ZeroDivisionError. Missing files trigger a FileNotFoundError. Bad user typing often leads to a ValueError. You can list these exact names next to your except keyword so Python knows how to handle each one.
try:
user_input = input("Enter a number: ")
number = int(user_input)
result = 100 / number
print(result)
except ValueError:
print("Please type digits like 5 or 10, not letters.")
except ZeroDivisionError:
print("You cannot enter zero.")
Look at how clear that code is for anyone using it. If a user inputs the word dog, the script hits the ValueError section and gives a helpful tip. If they type 0, it jumps to the ZeroDivisionError check instead. You can find more practical script patterns by reading our guide on Python programming basics for new developers. Matching errors to custom messages makes your software feel smooth and friendly.
Using Else and Finally for Extra Control
Python gives you two extra words to attach to your error blocks: else and finally. These extra tools let you order your steps with high care. They help when working with external data, hardware, or web connections that need cleanup work later.
The else block runs only if the try block runs with zero errors. Put code there if it relies on the try block working, but you do not want to catch errors inside it. The finally block runs no matter what happens. Even if your code crashes hard, Python always runs the code inside finally before stopping.
try:
my_file = open("notes.txt", "r")
except FileNotFoundError:
print("That file is not in your folder.")
else:
content = my_file.read()
print(content)
finally:
print("Checking process finished.")
Think about saving a photo or closing a database link. You want to close open connections even if your download breaks halfway through. Placing your file cleanup lines inside a finally block ensures your computer frees up memory every single time. It protects system memory from filling up during long automated tasks.
How to Pass or Log Errors Silently
Sometimes you expect an action to fail, and you do not want to show a message to the user. You can use the pass keyword inside an except block. Python moves past the error without writing anything to the console window. It keeps your output screen completely clean.
Imagine cleaning up a list of 500 phone numbers pulled from old spreadsheets. Some slots contain broken symbols instead of digits. You try to convert each line to a clean number. If it fails, you use pass to skip that line and continue working through the big list.
clean_numbers = []
raw_inputs = ["555-0199", "invalid_data", "555-0143"]
for item in raw_inputs:
try:
# Pretend we do a complex cleanup action here
if "invalid" in item:
raise ValueError
clean_numbers.append(item)
except ValueError:
pass
print(clean_numbers)
Using pass is helpful, but do not hide every mistake. If you ignore real bugs, your code might give incorrect outputs without throwing warnings. Another great technique is using Python Functions: How to Write and Use Them in Your Code to isolate failure zones so you can print detailed log files in the background while users see a plain screen.
Raising Your Own Errors on Purpose
As you write larger projects, you will want your own code to throw errors when something goes wrong. Python lets you use the raise keyword to trigger an error on demand. This helps when someone passes dangerous values into your functions, like a negative age or a blank password field.
Raising errors early saves you from bigger bugs later down the line. If a user sets an account balance to minus 50 dollars, you can raise a ValueError instantly. That stops the bad data from entering your main database before any real damage happens.
def set_user_age(age):
if age < 0:
raise ValueError("Age cannot be a negative number.")
print(f"Age set to {age}")
try:
set_user_age(-5)
except ValueError as error_message:
print(f"Data error: {error_message}")
Notice how we wrote except ValueError as error_message in that block. That pattern saves Python's exact text message into a variable name. You can print that variable directly to show the exact reason why your function stopped. It helps you catch bad inputs at the entry gate of your apps.
Building strong checks is a key skill for writing real automation tools. You can view our collection of helpful Python coding articles to learn how top developers structure their daily projects. Catching problems early keeps your scripts reliable for weeks without hands-on fixes.
Three Simple Tips for Writing Safe Python Code Today
Making your software resistant to crashes does not take extra days of work. Following three simple habits keeps your project files stable and easy to maintain.
- Keep try blocks small. Put only the one or two risky lines inside the try area. If you put 30 lines inside one try block, finding the bug becomes very hard.
- Name your error types. Avoid using bare except statements by themselves. Name specific errors like
KeyErrororTypeErrorso you only catch problems you know how to handle. - Write helpful message notes. Tell your users what to do next when a crash happens. Say "File missing, check your inputs folder" instead of "Error 404".
How do you handle bad inputs in your daily scripts? Try adding one specific except block to your current Python project today and watch how much smoother your code runs!
