Free Python Course | Programming Tutorials
599 subscribers
9 photos
2 files
6 links
Join Noob to Pro in Python in 100 Days! 🚀 Learn Python with daily lessons, practical examples, free code samples, exercises, and homework. Ideal for beginners and those looking to advance their skills. Start your journey to becoming a Python pro! 🐍
Download Telegram
Exception Handling with try and except
Python provides the try and except blocks to handle exceptions and prevent program crashes

Basic 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 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 else Clause
You 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 finally Clause
The 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 raise
In 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 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 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 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 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 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

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 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?
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:
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
Python comes with a wide range of built-in modules that provide functionality for common tasks. Some popular built-in modules include:


math: Mathematical functions
random: Random number generation
datetime: Working with dates and times
os: Interacting with the operating system
sys: System-specific parameters and functions

Example: Using the math Module
import math

print(math.sqrt(16)) # Output: 4.0
print(math.pi) # Output: 3.141592653589793


Example: Using the random Module
import random

print(random.randint(1, 10)) # Output: Random integer between 1 and 10


Example: Using the datetime Module
import 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:
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 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 Library
pip 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.
Finding and Installing External Packages
To find packages:
- Visit the Python Package Index (PyPI) to browse and search for Python packages.

To install a package globally (available for all projects):
pip install package_name


To install a package locally in a virtual environment:
1. Create a virtual environment:
python -m venv myenv

2. Activate the virtual environment:
# Windows
myenv\Scripts\activate

# Mac/Linux
source myenv/bin/activate

3. Install the package:
pip install package_name
Managing Dependencies with requirements.txt
In larger projects, you may want to specify which external packages (dependencies) your project needs. This is typically done using a requirements.txt file.

Creating requirements.txt
You can automatically generate this file with the following command:
pip freeze > requirements.txt

This command lists all installed packages and their versions in the requirements.txt file.

Installing Dependencies from requirements.txt
To install all the packages listed in a requirements.txt file, use the following command:
pip install -r requirements.txt
Practice Exercises for Day 12

Exercise 1: Simple Module

Create a Python module with functions for addition, subtraction, multiplication, and division. Import the module in another script and use its functions.

Exercise 2: Math and Random Modules
Use the built-in math and random modules to generate random numbers and calculate their square roots.

Exercise 3: Package Creation
Create a package with two modules: one for basic math operations (addition, subtraction) and one for advanced operations (power, square root). Import these modules in a script and use their functions.

Exercise 4: External Package
Install the requests module using pip and write a Python script to fetch and display data from a public API (e.g., a list of posts from JSONPlaceholder).

Exercise 5: Virtual Environment
Create a virtual environment, activate it, install the requests module, and use it in a Python script.
👍1