ok today we will learn about classes objects and its types

Python provides two very important features to handle any unexpected error in your
Python programs and to add debugging capabilities in them -

Exception Handling - This would be covered in this tutorial. Here is a list

standard Exceptions available in Python: Standard Exceptions.

Assertions - This would be covered in Assertions in Python tutorial.

List of Standard Exceptions -

Sr.No. Exception Name & Description

1
Exception

Base class for all exceptions

2
StopIteration

Raised when the next() method of an iterator does not point to any object.

3
SystemExit

Raised by the sys.exit() function.

4
StandardError

Base class for all built-in exceptions except StopIteration and SystemExit.

5
ArithmeticError

Base class for all errors that occur for numeric calculation.

6
OverflowError

Raised when a calculation exceeds maximum limit for a numeric type.

7
FloatingPointError

Raised when a floating point calculation fails.

8
ZeroDivisionError

Raised when division or modulo by zero takes place for all numeric types.

9
AssertionError

Raised in case of failure of the Assert statement.

10
AttributeError

Raised in case of failure of attribute reference or assignment.

11
EOFError

Raised when there is no input from either the raw_input() or input() function and
the end of file is reached.

12
ImportError

Raised when an import statement fails.

13
KeyboardInterrupt

Raised when the user interrupts program execution, usually by pressing Ctrl+c.

14
LookupError

Base class for all lookup errors.

15
IndexError

Raised when an index is not found in a sequence.

16
KeyError

Raised when the specified key is not found in the dictionary.

17
NameError

Raised when an identifier is not found in the local or global namespace.

18
UnboundLocalError

Raised when trying to access a local variable in a function or method but no value
has been assigned to it.

19
EnvironmentError

Base class for all exceptions that occur outside the Python environment.

20
IOError

Raised when an input/ output operation fails, such as the print statement or the
open() function when trying to open a file that does not exist.

21
IOError
Raised for operating system-related errors.

22
SyntaxError

Raised when there is an error in Python syntax.

23
IndentationError

Raised when indentation is not specified properly.

24
SystemError

Raised when the interpreter finds an internal problem, but when this error is
encountered the Python interpreter does not exit.

25
SystemExit

Raised when Python interpreter is quit by using the sys.exit() function. If not
handled in the code, causes the interpreter to exit.

26
TypeError

Raised when an operation or function is attempted that is invalid for the specified
data type.

27
ValueError

Raised when the built-in function for a data type has the valid type of arguments,
but the arguments have invalid values specified.

28
RuntimeError

Raised when a generated error does not fall into any category.

29
NotImplementedError

Raised when an abstract method that needs to be implemented in an inherited class

is not actually implemented.

Assertions in Python
An assertion is a sanity-check that you can turn on or turn off when you are done
with your testing of the program.

The easiest way to think of an assertion is to liken it to a raise-if statement (or

to be more accurate, a raise-if-not statement). An expression is tested, and if the
result comes up false, an exception is raised.

Assertions are carried out by the assert statement, the newest keyword to Python,
introduced in version 1.5.
Programmers often place assertions at the start of a function to check for valid
input, and after a function call to check for valid output.

The assert Statement

When it encounters an assert statement, Python evaluates the accompanying
expression, which is hopefully true. If the expression is false, Python raises an
AssertionError exception.

The syntax for assert is -

assert Expression[, Arguments]

If the assertion fails, Python uses ArgumentExpression as the argument for the
AssertionError. AssertionError exceptions can be caught and handled like any other
exception using the try-except statement, but if not handled, they will terminate
the program and produce a traceback.

sir is assertion similar to try block

yes but not 100% same

two same typed exceptions
maybe there must be some special functions for it ...but usually it comes in data
science...since you are not refering that no problem ok sir

ok take 7 mins
or more study this code i gave and try to find the output without pycharm
if didnt get ask me

#!/usr/bin/python
def KelvinToFahrenheit(Temperature):
assert (Temperature >= 0),"Colder than absolute zero!"
return ((Temperature-273)*1.8)+32
print KelvinToFahrenheit(273)
print int(KelvinToFahrenheit(505.78))
print KelvinToFahrenheit(-5)

output:
32
451.004
Colder than absolute zero! is it correct?

this is an asssert error:yes or no:Colder than absolute zero! this statement is

displayed because there is an assertion error
ok

What is Exception?
An exception is an event, which occurs during the execution of a program that
disrupts the normal flow of the program's instructions. In general, when a Python
script encounters a situation that it cannot cope with, it raises an exception. An
exception is a Python object that represents an error.

When a Python script raises an exception, it must either handle the exception
immediately otherwise it terminates and quits.

Handling an exception
If you have some suspicious code that may raise an exception, you can defend your
program by placing the suspicious code in a try: block. After the try: block,
include an except: statement, followed by a block of code which handles the problem
as elegantly as possible.
ok sir

try:
You do your operations here;
......................
except ExceptionI:
If there is ExceptionI, then execute this block.
except ExceptionII:
If there is ExceptionII, then execute this block.
......................
else:
If there is no exception then execute this block.

The except Clause with Multiple Exceptions

You can also use the same except statement to handle multiple exceptions as follows
-

try:
You do your operations here;
......................
except(Exception1[, Exception2[,...ExceptionN]]]):
If there is any exception from the given exception list,
then execute this block.
......................
else:
If there is no exception then execute this block.

Creating Custom Exceptions

In Python, users can define custom exceptions by creating a new class. This
exception class has to be derived, either directly or indirectly, from the built-in
Exception class. Most of the built-in exceptions are also derived from this class.

>>> class CustomError(Exception):

... pass
...

>>> raise CustomError

Traceback (most recent call last):
...
__main__.CustomError

>>> raise CustomError("An error occurred")

Traceback (most recent call last):
...
__main__.CustomError: An error occurred
Here, we have created a user-defined exception called CustomError which inherits
from the Exception class. This new exception, like other exceptions, can be raised
using the raise statement with an optional error message.

When we are developing a large Python program, it is a good practice to place all
the user-defined exceptions that our program raises in a separate file. Many
standard modules do this. They define their exceptions separately as exceptions.py
or errors.py (generally but not always).

User-defined exception class can implement everything a normal class can do, but we
generally make them simple and concise. Most implementations declare a custom base
class and derive others exception classes from this base class. This concept is
made clearer in the following example.
Example: User-Defined Exception in Python
In this example, we will illustrate how user-defined exceptions can be used in a
program to raise and catch errors.

This program will ask the user to enter a number until they guess a stored number
correctly. To help them figure it out, a hint is provided whether their guess is
greater than or less than the stored number.

# define Python user-defined exceptions

class Error(Exception):
"""Base class for other exceptions"""
pass

class ValueTooSmallError(Error):
"""Raised when the input value is too small"""
pass

class ValueTooLargeError(Error):
"""Raised when the input value is too large"""
pass

# you need to guess this number

number = 10

# user guesses a number until he/she gets it right

while True:
try:
i_num = int(input("Enter a number: "))
if i_num < number:
raise ValueTooSmallError
elif i_num > number:
raise ValueTooLargeError
break
except ValueTooSmallError:
print("This value is too small, try again!")
print()
except ValueTooLargeError:
print("This value is too large, try again!")
print()

print("Congratulations! You guessed it correctly.")

sir when a raised exception is given will the program stops from that point
noother doubts?sir one minute
sir what is the difference if we give except without any expression and with
expression
show where?sir i did a small program yesterday where i used exception without any
expressions
then sh
your exceeption code is not working bcz you did not give any expression
ok?sir but it did not raise any error when a number is used with string function
that is what i am telling if you want the exception to work properly according to
you you need to raise an expression,only then the computer would understand what is
your need,simply giving any except statement and telling to raise an expression
wont work...it will be giga error(garbage in garbage out) ok?ok sir
Thread

In computing, a process is an instance of a computer program that is being

executed. Any process has 3 basic components:

An executable program.
The associated data needed by the program (variables, work space, buffers, etc.)
The execution context of the program (State of process)
A thread is an entity within a process that can be scheduled for execution. Also,
it is the smallest unit of processing that can be performed in an OS (Operating
System).

In simple words, a thread is a sequence of such instructions within a program that

can be executed independently of other code. For simplicity, you can assume that a
thread is simply a subset of a process!

A thread contains all this information in a Thread Control Block (TCB):

Thread Identifier: Unique id (TID) is assigned to every new thread

Stack pointer: Points to thread�s stack in the process. Stack contains the local
variables under thread�s scope.
Program counter: a register which stores the address of the instruction currently
being executed by thread.
Thread state: can be running, ready, waiting, start or done.
Thread�s register set: registers assigned to thread for computations.
Parent process Pointer: A pointer to the Process control block (PCB) of the process
that the thread lives on.

Multiple threads can exist within one process where:

Each thread contains its own register set and local variables (stored in stack).
All thread of a process share global variables (stored in heap) and the program
code.

Multithreading is defined as the ability of a processor to execute multiple threads

concurrently.
Multithreading is defined as the ability of a processor to execute multiple threads
concurrently.

Regular expression:

A Regular Expression (RegEx) is a sequence of characters that defines a search

pattern. For example,

^a...s$
The above code defines a RegEx pattern. The pattern is: any five letter string
starting with a and ending with s.

A pattern defined using RegEx can be used to match against a string.

Expression String Matched?

^a...s$ abs No match
alias Match
abyss Match
Alias No match
An abacus No match

Python has a module named re to work with RegEx. Here's an example:

import re

pattern = '^a...s$'
test_string = 'abyss'
result = re.match(pattern, test_string)

if result:
print("Search successful.")
else:
print("Search unsuccessful.")