Error handling in python and Multiprocessing and Multithreading overview.

1. Advanced Python

2. Exception Handling in Python

3. An exception is an error which happens at the time of execution
of a program. However, while running a program, Python
generates an exception that should be handled to avoid your
program to crash. In Python language, exceptions trigger
automatically on errors, or they can be triggered and intercepted
by your code.
The exception indicates that, although the event can occur, this
type of event happens infrequently.When the method is not able
to handle the exception, it is thrown to its caller function.
Eventually, when an exception is thrown out of the main
function, the program is terminated abruptly.
What is an Exception in Python?

4. • Division by Zero
• Accessing a file which does not exist.
• Addition of two incompatible types
• Trying to access a nonexistent index of a sequence
• Removing the table from the disconnected database server.
• ATM withdrawal of more than the available amount
Common Examples of Exception:

5. • Exceptions must be class objects
• For class exceptions, you can use try statement with an except clause
which mentions a particular class.
• Even if a statement or expression is syntactically correct, it may
display an error when an attempt is made to execute it.
• Errors found during execution are called exceptions, and they are not
unconditionally fatal.
Rules of Exceptions

6. Exceptional Handling
Mechanism
try catch
finally throw

7. A try statement includes keyword try, followed by a colon (:)
and a suite of code in which exceptions may occur. It has one or
more clauses.
During the execution of the try statement, if no exceptions
occurred then, the interpreter ignores the exception handlers
for that specific try statement.
In case, if any exception occurs in a try suite, the try suite
expires and program control transfers to the matching except
handler following the try suite.
TheTry Statement

8. Catch blocks take one argument at a time, which is the type of exception
that it is likely to catch.These arguments may range from a specific type of
exception which can be varied to a catch-all category of exceptions.
The catch Statement
Rules for catch block:
• You can define a catch block by using the keyword catch
• Catch Exception parameter is always enclosed in parentheses
• It always represents the type of exception that catch block handles.
• An exception handling code is written between two {} curly braces.
• You can place multiple catch block within a single try block.
• You can use a catch block only after the try block.
• All the catch block should be ordered from subclass to superclass
exception.

9. Finally Block
Finally block always executes irrespective of an exception
being thrown or not. The final keyword allows you to create a
block of code that follows a try-catch block.
Finally, clause is optional. It is intended to define clean-up
actions which should be that executed in all conditions.

10. The Raise Statement
The raise statement specifies an argument which
exception object. Here, a comma follows the exception
and argument or tuple of the argument that follows
In this syntax, the argument is optional, and at the time
of execution, the exception argument value is always
none.
Example:
A Python exception can be any value like a string, class,
number, or an object. Most of these exceptions which are
raised by Python core are classes with an argument which
is an instance of the class.

11. Multithreading vs Multiprocessing
What's the difference?

12. A multiprocessing system has more than two processors.
The CPUs are added to the system that helps to increase
the computing speed of the system. Every CPU has its own
set of registers and main memory.
However, because each CPU are separate, it may happen
that one CPU may not have anything to process. One
processor may sit idle, and the other may be overloaded
with the specific processes. In such a case, the process and
resources are shared dynamically among the processors.
What is Multiprocessing?

13. Multithreading is a program execution technique
that allows a single process to have multiple code
segments (like threads). It also runs concurrently
within the "context" of that process. Multi-threaded
applications are applications that have two or more
threads that run concurrently.Therefore, it is also
known as concurrency.
What is Multithreading?

14. • A multiprocessing system has more than two processors whereas
Multithreading is a program execution technique that allows a single process
to have multiple code segments
• Multiprocessing improves the reliability of the system while in the
multithreading process, each thread runs parallel to each other.
• Multiprocessing helps you to increase computing power whereas
multithreading helps you create computing threads of a single process
• In Multiprocessing, the creation of a process, is slow and resource-specific
whereas, in Multiprogramming, the creation of a thread is economical in time
and resource.
• Multithreading avoids pickling, whereas Multiprocessing relies on pickling
objects in memory to send to other processes.
• Multiprocessing system takes less time whereas for job processing a moderate
amount of time is taken.
Key DIFFERENCES:

15. • The biggest advantage of a multiprocessor system is that it helps you to get
more work done in a shorter period.
• The code is usually straightforward.
• Takes advantage of multipleCPU & cores
• Helps you to avoid GIL limitations for CPython
• Remove synchronization primitives unless if you use shared memory.
• Child processes are mostly interruptible/killable
• It helps you to get work done in a shorter period.
• These types of systems should be used when very high speed is required to
process a large volume of data.
• Multiprocessing systems save money compared to single processor systems as
processors can share peripherals and power supplies.
Advantage of Multiprocessing

16. Disadvantage of
Multiprocessing
• IPC(Inter-Process Communication) a quite complicated
with more overhead
• Has a larger memory footprint

17. • Threads share the same address space
• Threads are lightweight which has a low memory footprint
• The cost of communication between threads is low.
• Access to memory state from another context is easier
• It allows you to make responsive UIs easily
• An ideal option for I/O-bound applications
• Takes lesser time to switch between two threads within the shared
memory and time to terminate
• Threads are faster to start than processes and also faster in task-
switching.
• AllThreads share a process memory pool that is very beneficial.
• Takes lesser time to create a new thread in the existing process than a
new process
Advantage of Multithreading

18. • Multithreading system is not interruptible/killable
• If not following a command queue and message pump model
then manual use of synchronization needed which becomes a
necessity
• Code is usually harder to understand and increases the potential
for race conditions increases dramatically
Disadvantage of multithreading