Contents
Roadmap info from roadmap website
Typecasting
The process of converting the value of one data type (integer, string, float, etc.) to another data type is called type conversion. Python has two types of type conversion: Implicit and Explicit.
Visit the following resources to learn more:
- @article@Type Conversion and Casting
- @article@Python Exceptions: An Introduction
- @article@Errors and Exceptions
- @article@Python Exception Handling
- @article@Python Try Except
| Feature | Implicit Type Conversion | Explicit Type Conversion |
|---|---|---|
| Definition | Automatic conversion performed by Python without programmer intervention. | Manual conversion where the programmer explicitly converts one type to another. |
| Commonly Used | When combining operations with different types that Python can safely convert. | When you need to control or force the conversion between types. |
| Syntax | Performed automatically, e.g., int_var + float_var | Uses built-in functions, e.g., str(var), int(var), float(var) |
| Examples | int_var + float_var (int to float) <br> bool_var + int_var (bool to int) | str(10) (int to string) <br> int("5") (string to int) <br> float(3) (int to float) |
| Risk of Data Loss | Minimal, as Python handles it automatically and safely. | Possible if the conversion isn’t appropriate (e.g., int("abc") raises an error). |
| Error Handling | Rarely raises errors since Python checks compatibility. | May raise errors if conversion fails (e.g., converting a string with non-numeric characters to an integer). |
| Control | Less control, relies on Python’s internal logic to decide when and how to convert. | Full control over what and when to convert. |
| Performance Impact | Generally efficient but might add a small overhead. | Can be optimized by the programmer, but may require additional processing. |
| Use Case | Simplifies code where conversions are safe and obvious, such as mathematical operations. | Necessary for user input, data processing, or when combining different data types deliberately. |
Exceptions
Python exceptions are events that occur during the execution of a program and disrupt the normal flow of the program’s instructions. When an exception is raised, it indicates that an error has occurred. Python provides a way to handle these exceptions using try-except blocks, allowing developers to manage errors gracefully and ensure the program can continue or exit smoothly.
- officialExceptions Documentation
- articlePython Exceptions: An Introduction
- articleErrors and Exceptions
- articlePython Exception Handling
- articlePython Try Except
- videoException Handling in Python
| Characteristic | Description |
|---|---|
| Definition | Exceptions are events that occur during program execution and disrupt normal flow. |
| Syntax | Exceptions are handled using try, except, else, and finally blocks. |
| Hierarchy | Python has a built-in exception hierarchy, with BaseException at the top and specific exceptions inheriting from it (e.g., Exception, ValueError, TypeError). |
| Raising Exceptions | Use raise to manually trigger an exception (e.g., raise ValueError("error message")). |
| Catching Exceptions | Use except to catch and handle specific exceptions (e.g., except ValueError:). |
| Multiple Exceptions | Multiple exceptions can be handled in one block using tuple syntax (e.g., except (TypeError, ValueError):). |
| Else Clause | The else block runs if no exceptions were raised in the try block, allowing code to execute only when the try succeeds. |
| Finally Clause | The finally block runs no matter what, whether an exception was raised or not, typically used for cleanup actions like closing files. |
| Custom Exceptions | Custom exceptions can be defined by subclassing Exception (e.g., class MyError(Exception): pass). |
| Unhandled Exceptions | If an exception is not caught, it propagates up the call stack and eventually terminates the program with a traceback message. |
| Built-in Exceptions | Python provides many built-in exceptions (e.g., ValueError, IndexError, KeyError, TypeError) for common error situations. |
| Chained Exceptions | Python supports chaining exceptions with raise ... from to indicate that one exception was caused by another. |
| Logging Exceptions | Exceptions can be logged using the logging module, providing context and traceback information. |
| Exception Object | When caught, an exception instance can be accessed, allowing you to retrieve its message or attributes (e.g., except Exception as e:). |
| Context Management | Exceptions are often used with context managers (with statements) to ensure that resources are managed properly, even in the face of errors. |
| Performance | Raising and handling exceptions is more expensive than normal control flow, so they should be used for exceptional conditions, not regular control flow. |