Programming is not just about making code work.
It is about making code robust when things go wrong.

Errors are inevitable:

• A user enters text instead of a number ❌
• A file does not exist 📂
• A division by zero occurs ➗
• A variable name is wrong 🧠

Python provides a structured mechanism to detect, handle, and react to these situations: exceptions.

An exception is a signal that something unexpected happened during execution.

Instead of crashing immediately, Python allows you to:

• Try to execute code
• Catch problems if they occur
• Decide what to do next

This is done with the try / except structure.

try:
    print("Try this")
except:
    print("Error Execution")

Python executes the try block.

If an error occurs:

• Execution stops inside try
• Control jumps to except
• Program continues afterward.
  • Optional:
    • else only runs when no error happened
      • Good to ensure you received a value or set an important parameter, or use a substitute
    • finally:
      • Runs anyway.

⚠️ Important: A bare except: catches everything, which is usually not recommended in professional code.

You can catch specific types of exceptions to react differently depending on the problem.

try:
    inpt = int(input("What? "))
    result = 12 / inpt

except ZeroDivisionError:
    print("Nope")

except ValueError:
    print("Uh?")

except (ImportError, NameError):
    print("How?")

except Exception as e:
    print("So... ";, e)



# 📚 Common Exception Types

Here are some of the most useful built-in exceptions:


Exception      | Meaning
-------------- | --
📦 ImportError | Import failed
📏 IndexError  | List index out of range
🏷️ NameError   | Variable not defined
🧾 SyntaxError | Code cannot be parsed
🔢 TypeError   | Wrong data type
🎯 ValueError  | Correct type, wrong value
🗂️ IOError     | File issue
🧠 OSError     | System issue
🗝️ KeyError    | Dictionary key missing


# ✨ The `finally` Block — Always Runs
Sometimes you need code that runs __no matter what happens__.
Typical use cases:
- Closing files
- Releasing resources
- Cleaning temporary state

````py
try:
    main()
except:
    correction()
finally:
    LastOne()

• try → except (if needed) → finally (always)

Even if there is an error, finally executes.

You can trigger your own errors intentionally.

This is useful when detecting invalid states in your program.

print(1)
raise ValueError
print(2)   # never runs

With a message:

• raise ImportError("Something happened")

Sometimes you want to:

• Catch an error
• Do something (log, print, cleanup)
• Then propagate the error again

try:
    print(3 / 0)
except:
    print("Error happened")
    raise

This preserves the original traceback.

Think of exceptions like a signal traveling upward through the call stack.

Function A
   ↓
Function B
   ↓
Function C  ← error occurs here ⚠️
   ↑
Handled by nearest try/except

If nobody handles it → program crashes.

✅ Catch specific exceptions whenever possible
✅ Use finally for cleanup
✅ Use raise for invalid program states
✅ Provide informative messages
❌ Avoid except: without specifying the error
❌ Do not silently ignore exceptions (pass) unless justified

def safe_division(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        print("Division by zero is not allowed")
        return None

Error control allows programs to be:

• More reliable 🛡️
• More user-friendly 🤝
• Easier to debug 🔍
• Safer in production 🚀

Key tools:

• try → attempt execution
• except → handle problems
• finally → always execute
• raise → create exceptions

If you master exception handling, you move from writing scripts to writing robust software.