lesson1Title

lesson2Title

lesson3Title

lesson4Title

lesson5Title

lesson6Title

lesson7Title

lesson8Title

lesson9Title

lesson10Title

lesson11Title

lesson12Title

lesson13Title

lesson14Title

lesson15Title

lesson16Title

lesson17Title

lesson18Title

lesson19Title

lesson20Title

lesson21Title

lesson22Title

pythonDataAnalysisBasicChapter2Title

pythonDataAnalysisBasicChapter1Title

pythonDataAnalysisBasicChapter3Title

pythonDataAnalysisBasicChapter4Title

# Example 1: Basic try/except
try:
    print("Dividing...")
    print(8 / 0)
except ZeroDivisionError:
    print("Error: Division by zero")

print('=' * 40)

# Example 2: Multiple except blocks
try:
    value = int("abc")
except ValueError:
    print("Error: Invalid number format")
except TypeError:
    print("Error: Wrong type used")

print('=' * 40)

# Example 3: try + else + finally
try:
    num = int("25")
except ValueError:
    print("Conversion failed")
else:
    print("Conversion succeeded:", num)
finally:
    print("Finished processing")

# Exception Handling with try/except

Programs sometimes crash due to unexpected errors — such as dividing by zero or trying to open a file that doesn’t exist.

Instead of letting your program stop abruptly, you can use **exception handling** to manage errors gracefully.

Python provides four key tools for handling exceptions:

* `try`
* `except`
* `else`
* `finally`

<br/>

## 1. `try` and `except`

Wrap potentially risky code in a `try` block. If an error occurs, Python jumps to the corresponding `except` block.

```python
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Oops! You can't divide by zero.")
```

* The division causes an error.
* Python skips the crash and shows a message instead.

<br/>

## 2. Handling Multiple Error Types

You can handle multiple error types by using separate `except` blocks for each one.

```python title="Handling Multiple Error Types"
try:
    num = int("abc")
except ValueError:
    print("That's not a valid number.")
except TypeError:
    print("Type mismatch.")
```

* This handles a `ValueError` caused by `int("abc")`.

<br/>

## 3. `else` and `finally`

* `else` runs only if no exception occurs.
* `finally` runs regardless of whether an exception occurs.


```python title="else and finally"
try:
    value = int("42")
except ValueError:
    print("Conversion failed.")
else:
    print("Conversion succeeded:", value)
finally:
    print("Done checking.")
```

* `else` confirms success.
* `finally` is good for cleanup, such as closing files or connections.

<br/>

## Summary

| Keyword   | Purpose                       |
| --------- | ----------------------------- |
| `try`     | Run risky code                |
| `except`  | Handle specific errors        |
| `else`    | Runs if no exception occurred |
| `finally` | Always runs, used for cleanup |

The `finally` block is executed regardless of whether an exception is thrown or not. It is designed to run no matter what happens in the try block, making it useful for cleanup actions like closing files or releasing resources. This ensures that essential cleanup code is executed under all circumstances.

### In Python, the `finally` block in a `try`/`except` structure is only executed if an exception is thrown and caught.

Keyword	Purpose
`try`	Run risky code
`except`	Handle specific errors
`else`	Runs if no exception occurred
`finally`	Always runs, used for cleanup

Exception Handling with try/except

1. try and except

2. Handling Multiple Error Types

3. else and finally

Summary

In Python, the finally block in a try/except structure is only executed if an exception is thrown and caught.

1. `try` and `except`

3. `else` and `finally`

In Python, the `finally` block in a `try`/`except` structure is only executed if an exception is thrown and caught.