- Python Mini Projects - [Link](https://github.com/animator/learn-python/tree/main/contrib/mini-projects) **(Not accepting)**

- Python Question Bank - [Link](https://github.com/animator/learn-python/tree/main/contrib/question-bank) **(Not accepting)**

Exception Handling is a way of managing the errors that may occur during a program execution. Python's exception handling mechanism has been designed to avoid the unexpected termination of the program, and offer to either regain control after an error or display a meaningful message to the user.

- **Error** - An error is a mistake or an incorrect result produced by a program. It can be a syntax error, a logical error, or a runtime error. Errors are typically fatal, meaning they prevent the program from continuing to execute.

- **Exception** - An exception is an event that occurs during the execution of a program that disrupts the normal flow of instructions. Exceptions are typically unexpected and can be handled by the program to prevent it from crashing or terminating abnormally. It can be runtime, input/output or system exceptions. Exceptions are designed to be handled by the program, allowing it to recover from the error and continue executing.

There are plenty of built-in exceptions in Python that are raised when a corresponding error occur.

We can view all the built-in exceptions using the built-in `local()` function as follows:

print(dir(locals()['__builtins__']))

|**S.No**|**Exception**|**Description**|

|---|---|---|

|1|SyntaxError|A syntax error occurs when the code we write violates the grammatical rules such as misspelled keywords, missing colon, mismatched parentheses etc.|

|2|TypeError|A type error occurs when we try to perform an operation or use a function with objects that are of incompatible data types.|

|3|NameError|A name error occurs when we try to use a variable, function, module or string without quotes that hasn't been defined or isn't used in a valid way.|

|4|IndexError|A index error occurs when we try to access an element in a sequence (like a list, tuple or string) using an index that's outside the valid range of indices for that sequence.|

|5|KeyError|A key error occurs when we try to access a key that doesn't exist in a dictionary. Attempting to retrieve a value using a non-existent key results this error.|

|6|ValueError|A value error occurs when we provide an argument or value that's inappropriate for a specific operation or function such as doing mathematical operations with incompatible types (e.g., dividing a string by an integer.)|

|7|AttributeError|An attribute error occurs when we try to access an attribute (like a variable or method) on an object that doesn't possess that attribute.|

|8|IOError|An IO (Input/Output) error occurs when an operation involving file or device interaction fails. It signifies that there's an issue during communication between your program and the external system.|

|9|ZeroDivisionError|A ZeroDivisionError occurs when we attempt to divide a number by zero. This operation is mathematically undefined, and Python raises this error to prevent nonsensical results.|

|10|ImportError|An import error occurs when we try to use a module or library that Python can't find or import succesfully.|

The `try-except` statement allows us to anticipate potential errors during program execution and define what actions to take when those errors occur. This prevents the program from crashing unexpectedly and makes it more robust.

Here's an example to explain this:

try:

# Code that might raise an exception

result = 10 / 0

except:

print("An error occured!")

Output

An error occured!

In this example, the `try` block contains the code that you suspect might raise an exception. Python attempts to execute the code within this block. If an exception occurs, Python jumps to the `except` block and executes the code within it.

You can specify the type of expection you want to catch using the `except` keyword followed by the exception class name. You can also have multiple `except` blocks to handle different exception types.

Here's an example:

try:

# Code that might raise ZeroDivisionError or NameError

result = 10 / 0

name = undefined_variable

except ZeroDivisionError:

print("Oops! You tried to divide by zero.")

except NameError:

print("There's a variable named 'undefined_variable' that hasn't been defined yet.")

Output

Oops! You tried to divide by zero.

If you comment on the line `result = 10 / 0`, then the output will be:

There's a variable named 'undefined_variable' that hasn't been defined yet.

In this code, the `except` block are specific to each type of expection. If you want to catch both exceptions with a single `except` block, you can use of tuple of exceptions, like this:

try:

# Code that might raise ZeroDivisionError or NameError

result = 10 / 0

name = undefined_variable

except (ZeroDivisionError, NameError):

print("An error occured!")

Output

An error occured!

The `else` clause in a Python `try-except` block provides a way to execute code only when the `try` block succeeds without raising any exceptions. It's like having a section of code that runs exclusively under the condition that no errors occur during the main operation in the `try` block.

Here's an example to understand this:

def calculate_average(numbers):

if len(numbers) == 0: # Handle empty list case seperately (optional)

return None

try:

total = sum(numbers)

average = total / len(numbers)

except ZeroDivisionError:

print("Cannot calculate average for a list containing zero.")

else:

print("The average is:", average)

return average #Optionally return the average here

numbers = [10, 20, 30]

result = calculate_average(numbers)

if result is not None: # Check if result is available (handles empty list case)

print("Calculation succesfull!")

Output

The average is: 20.0

The `finally` keyword in Python is used within `try-except` statements to execute a block of code **always**, regardless of whether an exception occurs in the `try` block or not.

To understand this, let us take an example:

try:

a = 10 // 0

print(a)

except ZeroDivisionError:

print("Cannot be divided by zero.")

finally:

print("Program executed!")

Output

Cannot be divided by zero.

Program executed!

In Python, raising an exception allows you to signal that an error condition has occured during your program's execution. The `raise` keyword is used to explicity raise an exception.

Let us take an example:

def divide(x, y):

if y == 0:

raise ZeroDivisionError("Can't divide by zero!") # Raise an exception with a message

result = x / y

return result

try:

division_result = divide(10, 0)

print("Result:", division_result)

except ZeroDivisionError as e:

print("An error occured:", e) # Handle the exception and print the message

Output

An error occured: Can't divide by zero!

- **Improved Error Handling** - It allows you to gracefully handle unexpected situations that arise during program execution. Instead of crashing abruptly, you can define specific actions to take when exceptions occur, providing a smoother experience.

- **Code Robustness** - Exception Handling helps you to write more resilient programs by anticipating potential issues and providing approriate responses.

- **Enhanced Code Readability** - By seperating error handling logic from the core program flow, your code becomes more readable and easier to understand. The `try-except` blocks clearly indicate where potential errors might occur and how they'll be addressed.

- **Hiding Logic Errors** - Relying solely on exception handling might mask underlying logic error in your code. It's essential to write clear and well-tested logic to minimize the need for excessive exception handling.

- **Performance Overhead** - In some cases, using `try-except` blocks can introduce a slight performance overhead compared to code without exception handling. Howerer, this is usually negligible for most applications.

- **Overuse of Exceptions** - Overusing exceptions for common errors or control flow can make code less readable and harder to maintain. It's important to use exceptions judiciously for unexpected situations.

- [Exception Handling in Python](exception-handling.md)

- [SQLAlchemy and Aggregation Functions](sqlalchemy-aggregation.md)

SQLAlchemy is a powerful and flexible SQL toolkit and Object-Relational Mapping (ORM) library for Python. It is a versatile library that bridges the gap between Python applications and relational databases.

SQLAlchemy allows the user to write database-agnostic code that can work with a variety of relational databases such as SQLite, MySQL, PostgreSQL, Oracle, and Microsoft SQL Server. The ORM layer in SQLAlchemy allows developers to map Python classes to database tables. This means you can interact with your database using Python objects instead of writing raw SQL queries.

* Python and MySQL Server must be installed and configured.

* The library: **mysql-connector-python** and **sqlalchemy** must be installed.

pip install sqlalchemy mysql-connector-python

* If not installed, you can install them using the above command in terminal,

* Create a connection with the database using the following code snippet:

from sqlalchemy import create_engine

from sqlalchemy.orm import declarative_base

from sqlalchemy.orm import sessionmaker

DATABASE_URL = 'mysql+mysqlconnector://root:12345@localhost/gssoc'

engine = create_engine(DATABASE_URL)

Session = sessionmaker(bind=engine)

session = Session()

Base = declarative_base()

* The connection string **DATABASE_URL** is passed as an argument to **create_engine** function which is used to create a connection to the database. This connection string contains the database credentials such as the database type, username, password, and database name.

* The **sessionmaker** function is used to create a session object which is used to interact with the database

* The **declarative_base** function is used to create a base class for all the database models. This base class is used to define the structure of the database tables.

* The following code snippet creates a table named **"products"** in the database:

from sqlalchemy import Column, Integer, String, Float

class Product(Base):

__tablename__ = 'products'

id = Column(Integer, primary_key=True)

name = Column(String(50))

category = Column(String(50))

price = Column(Float)

quantity = Column(Integer)

Base.metadata.create_all(engine)

* The **Product class** inherits from **Base**, which is a base class for all the database models.

* The **Base.metadata.create_all(engine)** statement is used to create the table in the database. The engine object is a connection to the database that was created earlier.

* The following code snippet inserts data into the **"products"** table:

products = [

Product(name='Laptop', category='Electronics', price=1000, quantity=50),

Product(name='Smartphone', category='Electronics', price=700, quantity=150),

Product(name='Tablet', category='Electronics', price=400, quantity=100),

Product(name='Headphones', category='Accessories', price=100, quantity=200),

Product(name='Charger', category='Accessories', price=20, quantity=300),

]

session.add_all(products)

session.commit()

* A list of **Product** objects is created. Each Product object represents a row in the **products table** in the database.

* The **add_all** method of the session object is used to add all the Product objects to the session. This method takes a **list of objects as an argument** and adds them to the session.

* The **commit** method of the session object is used to commit the changes made to the database.

SQLAlchemy provides functions that correspond to SQL aggregation functions and are available in the **sqlalchemy.func module**.

The **COUNT** function returns the number of rows in a result set. It can be demonstrated using the following code snippet:

from sqlalchemy import func

total_products = session.query(func.count(Product.id)).scalar()

print(f'Total products: {total_products}')

The **SUM** function returns the sum of all values in a column. It can be demonstrated using the following code snippet:

total_price = session.query(func.sum(Product.price)).scalar()

print(f'Total price of all products: {total_price}')

The **AVG** function returns the average of all values in a column. It can be demonstrated by the following code snippet:

average_price = session.query(func.avg(Product.price)).scalar()

print(f'Average price of products: {average_price}')

The **MAX** function returns the maximum value in a column. It can be demonstrated using the following code snippet :

max_price = session.query(func.max(Product.price)).scalar()

print(f'Maximum price of products: {max_price}')

The **MIN** function returns the minimum value in a column. It can be demonstrated using the following code snippet:

min_price = session.query(func.min(Product.price)).scalar()

print(f'Minimum price of products: {min_price}')

In general, the aggregation functions can be implemented by utilising the **session** object to execute the desired query on the table present in a database using the **query()** method. The **scalar()** method is called on the query object to execute the query and return a single value

- [Time & Space Complexity](time-space-complexity.md)