Day 11: Handling Exceptions in Python
Welcome to Day 11 of the "Noob to Pro in Python" course! Today, we’ll focus on exceptions in Python, learning how to handle errors effectively. Exception handling is crucial for writing robust, error-free programs that behave predictably even when things go wrong. You’ll understand how to catch exceptions, raise errors, and use custom exceptions.
What is an Exception?
Common built-in exceptions include:
An exception is an event that occurs during the execution of a program that disrupts its normal flow. When a Python program encounters an error, it raises an exception, which terminates the program unless the error is handled.
Common built-in exceptions include:
ZeroDivisionError: Raised when dividing by zero.FileNotFoundError: Raised when a file or directory is requested but doesn't exist.ValueError: Raised when a function receives an argument of the correct type but inappropriate value.TypeError: Raised when an operation is performed on an inappropriate type.Exception Handling with
Python provides the
Basic Syntax:
Example:
In this example, trying to divide by zero would normally crash the program. Instead, we catch the
try and exceptPython provides the
try and except blocks to handle exceptions and prevent program crashesBasic Syntax:
try:
# Code that might raise an exception
risky_code()
except ExceptionType:
# Code to handle the exception
handle_exception()
Example:
try:
result = 10 / 0
except ZeroDivisionError:
print("Cannot divide by zero!")
In this example, trying to divide by zero would normally crash the program. Instead, we catch the
ZeroDivisionError and print a message.👍1
Catching Multiple Exceptions
You can catch different types of exceptions and handle them separately by specifying multiple
Example:
In this example:
FileNotFoundError is raised if the file does not exist.
ZeroDivisionError is raised if there’s an attempt to divide by zero.
You can catch different types of exceptions and handle them separately by specifying multiple
except blocks.Example:
try:
file = open("non_existent_file.txt", "r")
result = 10 / 0
except FileNotFoundError:
print("File not found!")
except ZeroDivisionError:
print("Cannot divide by zero!")
In this example:
FileNotFoundError is raised if the file does not exist.
ZeroDivisionError is raised if there’s an attempt to divide by zero.
The
You can use an
Example:
If no exception occurs, the code in the
else ClauseYou can use an
else clause to define a block of code to be executed if no exceptions are raised in the try block.Example:
try:
result = 10 / 2
except ZeroDivisionError:
print("Cannot divide by zero!")
else:
print("Division successful:", result)
If no exception occurs, the code in the
else block will execute.The
The
Example:
Here, the
finally ClauseThe
finally block is always executed, regardless of whether an exception occurred or not. It’s commonly used for cleaning up resources, such as closing files or network connections.Example:
try:
file = open("example.txt", "r")
result = 10 / 0
except ZeroDivisionError:
print("Cannot divide by zero!")
finally:
print("This will always be executed.")
file.close()
Here, the
finally block ensures that the file is closed, even if an error occurs during execution.Raising Exceptions with
In Python, you can
Example:
In this example, we manually raise a
raiseIn Python, you can
raise exceptions manually using the raise keyword. This is useful when you want to trigger an exception under specific conditions.Example:
def check_age(age):
if age < 18:
raise ValueError("Age must be 18 or above.")
return "Valid age"
try:
check_age(16)
except ValueError as e:
print(e)
In this example, we manually raise a
ValueError if the age is below 18.Custom Exceptions
You can create your own exceptions by subclassing the built-in
Example:
Here, we define a custom exception called
You can create your own exceptions by subclassing the built-in
Exception class. Custom exceptions allow you to define your own error types for more precise control over program flow.Example:
class InvalidAgeError(Exception):
"""Custom exception for invalid age."""
pass
def check_age(age):
if age < 18:
raise InvalidAgeError("You must be at least 18 years old.")
return "Valid age"
try:
check_age(16)
except InvalidAgeError as e:
print(e)
Here, we define a custom exception called
InvalidAgeError and raise it if the age is below 18.Exception Hierarchy
All exceptions in Python inherit from the base class
Example:
The
All exceptions in Python inherit from the base class
BaseException. Common exceptions such as ZeroDivisionError, ValueError, and TypeError inherit from Exception, which in turn inherits from BaseException.Example:
try:
raise ValueError("An error occurred")
except Exception as e:
print("Caught an exception:", e)
The
Exception class will catch any standard exception.👍1
Using assert for Simple Debugging
The
Syntax:
Example:
If the condition fails, an
The
assert statement allows you to test if a condition in your code is True. If the condition is False, it raises an AssertionError.Syntax:
assert condition, message
Example:
age = 15
assert age >= 18, "Age must be 18 or above!"
If the condition fails, an
AssertionError is raised with the given message.Best Practices for Exception Handling
Be specific with exceptions: Catch only the exceptions you expect. Avoid using a generic
Clean up resources: Always clean up resources (e.g., files, database connections) using
Avoid silent failures: Don’t just catch exceptions and do nothing. Always log errors or take meaningful action.
Use custom exceptions for better clarity: When writing large applications, create custom exceptions for more meaningful error reporting.
Be specific with exceptions: Catch only the exceptions you expect. Avoid using a generic
except Exception for everything.Clean up resources: Always clean up resources (e.g., files, database connections) using
finally or context managers (with).Avoid silent failures: Don’t just catch exceptions and do nothing. Always log errors or take meaningful action.
Use custom exceptions for better clarity: When writing large applications, create custom exceptions for more meaningful error reporting.
Practice Exercises for Day 11
Exercise 1: Division by Zero
Write a function that divides two numbers. Use exception handling to catch division by zero and print an appropriate message.
Exercise 2: File Handling with Exceptions
Write a Python program to open a file and read its content. Use exception handling to catch and handle a
Exercise 3: Age Validator
Write a function that checks if a person’s age is valid (age >= 18). Raise a custom exception
Exercise 4: Password Validation
Write a function that takes a password as input. Raise a
Exercise 5: Custom Exception
Create a custom exception called
Exercise 1: Division by Zero
Write a function that divides two numbers. Use exception handling to catch division by zero and print an appropriate message.
Exercise 2: File Handling with Exceptions
Write a Python program to open a file and read its content. Use exception handling to catch and handle a
FileNotFoundError.Exercise 3: Age Validator
Write a function that checks if a person’s age is valid (age >= 18). Raise a custom exception
InvalidAgeError if the age is below 18.Exercise 4: Password Validation
Write a function that takes a password as input. Raise a
ValueError if the password is shorter than 8 characters or doesn't contain a number.Exercise 5: Custom Exception
Create a custom exception called
NegativeNumberError. Write a function that raises this exception if a negative number is passed.Homework for Day 11
Simple Calculator
kindly submit your homework at @kidscoderchat with #py_homework
Simple Calculator
Write a Python program that implements a calculator with functions for addition, subtraction, multiplication, and division. Use exception handling to catch invalid inputs and division by zero.
kindly submit your homework at @kidscoderchat with #py_homework
Summary
In Day 11, we covered:
Exceptions: What they are and why they occur.
Handling exceptions using
Raising exceptions manually with the
Creating custom exceptions to handle specific situations.
The
Effective exception handling ensures that your programs can manage unexpected situations without crashing. This is essential for building reliable, maintainable software. Practice these techniques by solving the exercises and applying them in real-world scenarios. Keep coding and refining your skills!
In Day 11, we covered:
Exceptions: What they are and why they occur.
Handling exceptions using
try, except, else, and finally blocks.Raising exceptions manually with the
raise keyword.Creating custom exceptions to handle specific situations.
The
assert statement for simple debugging and validation.Effective exception handling ensures that your programs can manage unexpected situations without crashing. This is essential for building reliable, maintainable software. Practice these techniques by solving the exercises and applying them in real-world scenarios. Keep coding and refining your skills!
👍2
Day 12: Working with Modules and Packages in Python
Welcome to Day 12 of the "Noob to Pro in Python" course! Today, we will learn about modules and packages in Python. Understanding how to organize your code into modules and packages is crucial for creating maintainable, reusable, and scalable programs. We will also explore Python’s built-in modules and learn how to create your own.
What is a Module?
Advantages of Modules:
Code organization
Code reuse
Avoids redundancy
Better maintainability
Creating a Simple Module
Let’s create a module named
You can then import and use this module in another Python script.
Example of importing and using a module:
A module is simply a Python file (with a .py extension) that contains Python code. It may contain functions, classes, variables, and runnable code. Instead of writing all your code in a single file, you can split it into multiple files (modules) and use them in different parts of your project.
Advantages of Modules:
Code organization
Code reuse
Avoids redundancy
Better maintainability
Creating a Simple Module
Let’s create a module named
mymodule.py:# This is a simple module with a function
def greet(name):
return f"Hello, {name}!"
You can then import and use this module in another Python script.
Example of importing and using a module:
import mymodule
print(mymodule.greet("Alice")) # Output: Hello, Alice!
Importing Modules
There are several ways to import modules in Python:
1. Import the entire module:
Access the module’s functions or variables using
2. Import specific functions or variables:
In this case, you can directly use the
3. Import with an alias:
4. Import everything from a module:
This imports all functions and variables from the module. Use this carefully to avoid name conflicts.
There are several ways to import modules in Python:
1. Import the entire module:
import mymodule
Access the module’s functions or variables using
mymodule.function_name().2. Import specific functions or variables:
from mymodule import greet
In this case, you can directly use the
greet() function without the module prefix.3. Import with an alias:
import mymodule as mm
print(mm.greet("Bob")) # Output: Hello, Bob!
4. Import everything from a module:
from mymodule import *
This imports all functions and variables from the module. Use this carefully to avoid name conflicts.
Exploring Built-in Modules
Example: Using the
Example: Using the
Example: Using the
Python comes with a wide range of built-in modules that provide functionality for common tasks. Some popular built-in modules include:
math: Mathematical functionsrandom: Random number generationdatetime: Working with dates and timesos: Interacting with the operating systemsys: System-specific parameters and functionsExample: Using the
math Moduleimport math
print(math.sqrt(16)) # Output: 4.0
print(math.pi) # Output: 3.141592653589793
Example: Using the
random Moduleimport random
print(random.randint(1, 10)) # Output: Random integer between 1 and 10
Example: Using the
datetime Moduleimport datetime
now = datetime.datetime.now()
print(now) # Output: Current date and time
What is a Package?
A package is a collection of modules organized in directories that provide a hierarchical structure. Packages allow you to organize your project into multiple modules and sub-packages.
Creating a Package
A package is simply a directory that contains one or more modules and a special file named __init__.py. The __init__.py file is required to make Python treat the directory as a package. It can be empty or contain initialization code for the package.
Package Structure:
Example: Creating a Package
1. Create a directory named
2. Inside the directory, create the following files:
3. Now you can import the package modules in your Python code:
Example:
A package is a collection of modules organized in directories that provide a hierarchical structure. Packages allow you to organize your project into multiple modules and sub-packages.
Creating a Package
A package is simply a directory that contains one or more modules and a special file named __init__.py. The __init__.py file is required to make Python treat the directory as a package. It can be empty or contain initialization code for the package.
Package Structure:
mypackage/
__init__.py
module1.py
module2.py
Example: Creating a Package
1. Create a directory named
mypackage.2. Inside the directory, create the following files:
mypackage/__init__.py:# This is the initialization file for the package
mypackage/module1.py:def add(a, b):
return a + b
mypackage/module2.py:def subtract(a, b):
return a - b
3. Now you can import the package modules in your Python code:
Example:
from mypackage import module1, module2
print(module1.add(10, 5)) # Output: 15
print(module2.subtract(10, 5)) # Output: 5
❤1
Installing and Using External Packages (PIP)
Python has a huge collection of third-party packages available via the Python Package Index (PyPI). You can install these packages using the
Installing a Package with PIP
To install an external package, use the command:
Example: Installing and Using the
Once installed, you can use the
This will print the JSON response from the given URL.
Python has a huge collection of third-party packages available via the Python Package Index (PyPI). You can install these packages using the
pip tool.Installing a Package with PIP
To install an external package, use the command:
pip install package_name
Example: Installing and Using the
requests Librarypip install requests
Once installed, you can use the
requests module to make HTTP requests:import requests
response = requests.get("https://jsonplaceholder.typicode.com/posts/1")
print(response.json())
This will print the JSON response from the given URL.