Core python programming tutorial

1 “Core Python Programming”
"Core PYTHON PROGRAMMING "
Prepared by:
AMARjeetsingh thakur

Contents
1. INTRODUCTION
 What is Python?
 Python Features
 Python Applications
 Python and PyCharm Installation
 Python IDE
 Python Code Basics
 Getting Started
 Keywords & Identifiers
 Statements & Comments
 Python Variables
 Python Datatypes
 Python Type Conversion
 Python I/O and Import
 Python Operators
 Python Namespace
2. FLOW CONTROL
 Python if...else
 Python for Loop
 while Loop
 break and continue
 Pass Statement
 Looping Technique
3. FUNCTIONS
 Python Function
 Function Argument
 Python Recursion
 Python Global, Local and Nonlocal
 Python Global Keyword
 Python Modules
 Python Packages
4. DATATYPES
 Python Numbers
 Python List
 Python Tuple
 Python String
 Python Set
 Python Dictionary
 Python Nested Dictionary
 Python Arrays
 Python Matrix
 List Comprehension

5. PYTHON OOPS
 Python Class
 Python Inheritance

1. INTRODUCTION
Python is a high-level, object-oriented, interpreted programming language, which has
garnered worldwide attention. Stack Overflow found out that 38.8% of its users mainly use
Python for their projects. According to the website’s survey, Python’s popularity surpassed
that of C# in 2018 – just like it surpassed PHP in 2017. On the GitHub platform, Python
surpassed Java as the second-most used programming language, with 40% more pull requests
opened in 2017 than in 2016. This makes Python certification one of the most sought-after
programming certifications.
1.1 What is Python?
Python is an open-source object-oriented programming language. It first appeared in 1991
and has become extremely popular among data scientists. StackOverflow calls it as the fastest
growing programming language.
But, what is interpreted language? let’s understand what is an interpreter first.
1.2 Python Interpreter

An interpreter is a computer program that directly executes, i.e. performs, instructions written
in a programming or scripting language, without requiring them previously to have been
compiled into a machine language program. So unlike Java, Python uses an interpreter.
Let us now install Python.
1.3 Python Installation
Following are the steps to install Python
1. Go to www.python.org/downloads/
2. Select the Operating System and also the version of Python. Open the installer and click on
“Run”.
3. Click on “Install Now” and check on “Add Python 3.6 to PATH”.

4. Start IDLE which is a Python GUI and start scripting.
Usually It’s not preferred using IDLE for coding in Python, instead, we will download
PyCharm which is an IDE (Integrated Development Environment).
1.3.1 Python IDE (Integrated Development Environment)
IDE typically provides code editor, compiler/ interpreter and debugger in one GUI (Graphical
User Interface). It encapsulates the entire process of code creation, compilation and testing
which increases the productivity of developers.

A developer working with an IDE starts with a model, which the IDE translates into suitable
code. The IDE then debugs and tests the model-driven code, with a high level of
automation. Once the build is successful and properly tested, it can be deployed for
further testing through the IDE or other tools outside of the IDE.
We are going to use PyCharm, you can use any other IDE that you want.
Installing PyCharm (Python IDE):
Go to www.jetbrains.com/pycharm/download/#section=windows
Here, the community version is free, but for the professional version, you need to
buy the license. We will be working on the PyCharm community version.
Now, let us have a look at why one should even consider Python as a preferred or
first programming language.
1.4 Why Learn Python?
Python’s syntax is very easy to understand. The lines of code required for a task is less
compared to other languages. Let’s give you an example – If you have to print “Welcome To
Bangalore” all you have to type:
print (“Welcome To Bangalore!”)
Let’s look at some cool features of Python:
1. Simple and easy to learn
2. Free and Open Source
3. Portable
4. Supports different programming paradigm
5. Extensible
If you are wondering where you can use Python (Python Application)
1.5 Python Applications:
1. Artificial Intelligence
2. Desktop Application
3. Automation
4. Web Development
5. Data Wrangling, Exploration And Visualization etc.

Let us now start coding in Python, as we have mentioned above we will be using PyCharm.
1.6 Python Variables
A variable is a named location used to store data in the memory. It is helpful to think
of variables as a container that holds data which can be changed later throughout
programming. For example,
number = 10
Here, we have created a variable named number. We have assigned value 10 to the variable.
You can think variable as a bag to store books in it and those books can be replaced at any
time.
number = 10
number = 1.1
Initially, the value of number was 10. Later it's changed to 1.1.
Note: In Python, we don't assign values to the variables, whereas Python gives the reference
of the object (value) to the variable.
1.6.1 Assigning a value to a Variable in Python
As you can see from the above example, you can use the assignment operator = to assign a
value to a variable.
Example 1: Declaring and assigning a value to a variable
website = "apple.com"
print(website)
When you run the program, the output will be:
apple.com
In the above program, we assigned a value apple.com to the variable website. Then we print
the value assigned to website i.e. apple.com
Note : Python is a type inferred language; it can automatically know apple.com is a string
and declare website as a string.
Example 2: Changing the value of a variable
website = "apple.com"
print(website)
# assigning a new variable to website
website = "programiz.com"

print(website)
apple.com
programiz.com
In the above program, we have assigned apple.com to the website variable initially.
Then, it's value is changed to programiz.com.
Example 3: Assigning multiple values to multiple variables
a, b, c = 5, 3.2, "Hello"
print (a)
print (b)
print (c)
If we want to assign the same value to multiple variables at once, we can do this as
x = y = z = "same"
print (x)
print (y)
print (z)
The second program assigns the same string to all the three variables x, y and z.
1.7 Constants
A constant is a type of variable whose value cannot be changed. It is helpful to think
of constants as containers that hold information which cannot be changed later.
Non technically, you can think of constant as a bag to store some books and those
books cannot be replaced once placed inside the bag.
1.7.1 Assigning value to a constant in Python
In Python, constants are usually declared and assigned on a module. Here, the
module means a new file containing variables, functions etc., which is imported to
main file. Inside the module, constants are written in all capital letters and
underscores separating the words.
Example 3: Declaring and assigning value to a constant
Create a constant.py

1. PI = 3.14
2. GRAVITY = 9.8
Create a main.py
1. import constant
2.
3. print(constant.PI)
4. print(constant.GRAVITY)
3.14
9.8
In the above program, we create a constant.py module file. Then, we assign the
constant value to PI and GRAVITY. After that, we create a main.py file and import
the constant module. Finally, we print the constant value.
Note: In reality, we don't use constants in Python. The globals or constants module is
used throughout the Python programs.
Rules and Naming convention for variables and constants
1. Create a name that makes sense. Suppose, vowel makes more sense than v.
2. Use camel Case notation to declare a variable. It starts with lowercase letter. For
example:
myName
myAge
myAddress
3. Use capital letters where possible to declare a constant. For example:
PI
G
MASS
TEMP
4. Never use special symbols like !, @, #, $, %, etc.
5. Don't start name with a digit.
6. Constants are put into Python modules and meant not be changed.
7. Constant and variable names should have combination of letters in lowercase (a to
z) or uppercase (A to Z) or digits (0 to 9) or an underscore (_). For example:
snake_case
MACRO_CASE
camelCase
CapWords

1.8 Literals
Literal is a raw data given in a variable or constant. In Python, there are various
types of literals they are as follows:
1.8.1 Numeric Literals
Numeric Literals are immutable (unchangeable). Numeric literals can belong to 3
different numerical types Integer, Float and Complex.
Example 4: How to use Numeric literals in Python?
a = 0b1010 #Binary Literals
b = 100 #Decimal Literal
c = 0o310 #Octal Literal
d = 0x12c #Hexadecimal Literal
#Float Literal
float_1 = 10.5
float_2 = 1.5e2
#Complex Literal
x = 3.14j
print(a, b, c, d)
print(float_1, float_2)
print(x, x.imag, x.real)
10 100 200 300
10.5 150.0
3.14j 3.14 0.0
In the above program,
 We assigned integer literals into different variables. Here, a is binary literal, b is a
decimal literal, c is an octal literal and d is a hexadecimal literal.
 When we print the variables, all the literals are converted into decimal values.
 10.5 and 1.5e2 are floating point literals. 1.5e2 is expressed with exponential and is
equivalent to 1.5 * 102
.
 We assigned a complex literal i.e 3.14j in variable x. Then we use imaginary literal
(x.imag) and real literal (x.real) to create imaginary and real part of complex number.
1.8.2 String literals

A string literal is a sequence of characters surrounded by quotes. We can use both
single, double or triple quotes for a string. And, a character literal is a single
character surrounded by single or double quotes.
Example 7: How to use string literals in Python?
strings = "This is Python"
char = "C"
multiline_str = """This is a multiline string with more than one line code."""
unicode = u"u00dcnicu00f6de"
raw_str = r"raw n string"
print(strings)
print(char)
print(multiline_str)
print(unicode)
print(raw_str)
This is Python
C
This is a multiline string with more than one line code.
Ünicöde
raw n string
In the above program, This is Python is a string literal and C is a character literal.
The value with triple-quote """ assigned in the multiline_str is multi-line string
literal. The u"u00dcnicu00f6de" is a unicode literal which supports characters other
than English and r"raw n string" is a raw string literal.
1.8.3 Boolean literals
A Boolean literal can have any of the two values: True or False.
Example 8: How to use boolean literals in Python?
x = (1 == True)
y = (1 == False)
a = True + 4
b = False + 10
print("x is", x)
print("y is", y)
print("a:", a)
print("b:", b)

x is True
y is False
a: 5
b: 10
In the above program, we use boolean literal True and False. In
Python, True represents the value as 1 and False as 0. The value
of x is True because 1 is equal to True. And, the value of y is False because 1 is not
equal to False.
Similarly, we can use the True and False in numeric expressions as the value. The
value of a is 5 because we add Truewhich has value of 1 with 4.
Similarly, b is 10 because we add the False having value of 0 with 10.
1.8.4 Special literals
Python contains one special literal i.e. None. We use it to specify to that field that is
not created.
Example 9: How to use special literals in Python?
drink = "Available"
food = None
def menu(x):
if x == drink:
print(drink)
else:
print(food)
menu(drink)
menu(food)
Available
None
In the above program, we define a menu function. Inside menu, when we set parameter
as drink then, it displays Available. And, when the parameter is food, it
displays None.
1.9 Literal Collections
There are four different literal collections i.e., List literals, Tuple literals, Dict literals,
and Set literals.
Example 10: How to use literals collections in Python?
fruits = ["apple", "mango", "orange"] #list

numbers = (1, 2, 3) #tuple
alphabets = {'a':'apple', 'b':'ball', 'c':'cat'} #dictionary
vowels = {'a', 'e', 'i' , 'o', 'u'} #set
print(fruits)
print(numbers)
print(alphabets)
print(vowels)
['apple', 'mango', 'orange']
(1, 2, 3)
{'a': 'apple', 'b': 'ball', 'c': 'cat'}
{'e', 'a', 'o', 'i', 'u'}
In the above program, we created a list of fruits, tuple of numbers,
dictionary dict having values with keys desginated to each value and set of vowels.
1.10 Python Data Types
Data types in Python
Every value in Python has a data type. Since everything is an object in Python
programming, data types are actually classes and variables are instance (object) of
these classes.There are various data types in Python. Some of the important types
are listed below.
Python Numbers
Integers, floating point numbers and complex numbers falls under Python
numbers category. They are defined as int, float and complex class in Python.
We can use the type() function to know which class a variable or a value belongs to
and the isinstance() function to check if an object belongs to a particular class.
a = 5
print(a, "is of type", type(a))
a = 2.0
print(a, "is of type", type(a))
a = 1+2j
print(a, "is complex number?", isinstance(1+2j,complex))
Integers can be of any length, it is only limited by the memory available.

A floating point number is accurate up to 15 decimal places. Integer and floating
points are separated by decimal points. 1 is integer, 1.0 is floating point number.
Complex numbers are written in the form, x + yj, where x is the real part and y is the
imaginary part. Here are some examples.
1. >>> a = 1234567890123456789
2. >>> a
3. 1234567890123456789
4. >>> b = 0.1234567890123456789
5. >>> b
6. 0.12345678901234568
7. >>> c = 1+2j
8. >>> c
9. (1+2j)
Notice that the float variable b got truncated.
1.11 Python List
List is an ordered sequence of items. It is one of the most used data type in Python
and is very flexible. All the items in a list do not need to be of the same type.
Declaring a list is pretty straight forward. Items separated by commas are enclosed within
brackets [ ].
1. >>> a = [1, 2.2, 'python']
We can use the slicing operator [ ] to extract an item or a range of items from a list.
Index starts form 0 in Python.
a = [5,10,15,20,25,30,35,40]
# a[2] = 15
print("a[2] = ", a[2])
# a[0:3] = [5, 10, 15]
print("a[0:3] = ", a[0:3])
# a[5:] = [30, 35, 40]
print("a[5:] = ", a[5:])
Lists are mutable, meaning, value of elements of a list can be altered.
1. >>> a = [1,2,3]
2. >>> a[2]=4
3. >>> a
4. [1, 2, 4]
1.12 Python Tuple
Tuple is an ordered sequence of items same as list. The only difference is that tuples
are immutable. Tuples once created cannot be modified. Tuples are used to write-

protect data and are usually faster than list as it cannot change dynamically. It is
defined within parentheses () where items are separated by commas.
1. >>> t = (5,'program', 1+3j)
We can use the slicing operator [] to extract items but we cannot change its value.
t = (5,'program', 1+3j)
# t[1] = 'program'
print("t[1] = ", t[1])
# t[0:3] = (5, 'program', (1+3j))
print("t[0:3] = ", t[0:3])
# Generates error
# Tuples are immutable
t[0] = 10
1.13 Python Strings
String is sequence of Unicode characters. We can use single quotes or double
quotes to represent strings. Multi-line strings can be denoted using triple
quotes, ''' or """.
1. >>> s = "This is a string"
2. >>> s = '''a multiline
Like list and tuple, slicing operator [ ] can be used with string. Strings are immutable.
s = 'Hello world!'
# s[4] = 'o'
print("s[4] = ", s[4])
# s[6:11] = 'world'
print("s[6:11] = ", s[6:11])
# Generates error
# Strings are immutable in Python
s[5] ='d'
1.14 Python Set
Set is an unordered collection of unique items. Set is defined by values separated by
comma inside braces { }. Items in a set are not ordered.
a = {5,2,3,1,4}
# printing set variable
print("a = ", a)

# data type of variable a
print(type(a))
We can perform set operations like union, intersection on two sets. Set have unique
values. They eliminate duplicates.
1. >>> a = {1,2,2,3,3,3}
2. >>> a
3. {1, 2, 3}
Since, sets are unordered collection, indexing has no meaning. Hence the slicing
operator [] does not work.
1. >>> a = {1,2,3}
2. >>> a[1]
3. Traceback (most recent call last):
4. File "<string>", line 301, in runcode
5. File "<interactive input>", line 1, in <module>
6. TypeError: 'set' object does not support indexing
1.15 Python Dictionary
Dictionary is an unordered collection of key-value pairs. It is generally used when we
have a huge amount of data. Dictionaries are optimized for retrieving data. We must
know the key to retrieve the value.
In Python, dictionaries are defined within braces {} with each item being a pair in the
form key:value. Key and value can be of any type.
1. >>> d = {1:'value','key':2}
2. >>> type(d)
3. <class 'dict'>
We use key to retrieve the respective value. But not the other way around.
d = {1:'value','key':2}
print(type(d))
print("d[1] = ", d[1]);
print("d['key'] = ", d['key']);
# Generates error
print("d[2] = ", d[2]);
1.16 Conversion between data types
We can convert between different data types by using different type conversion
functions like int(), float(), str() etc.
1. >>> float(5)
2. 5.0

Conversion from float to int will truncate the value (make it closer to zero).
1. >>> int(10.6)
2. 10
3. >>> int(-10.6)
4. -10
Conversion to and from string must contain compatible values.
1. >>> float('2.5')
2. 2.5
3. >>> str(25)
4. '25'
5. >>> int('1p')
9. ValueError: invalid literal for int() with base 10: '1p'
We can even convert one sequence to another.
1. >>> set([1,2,3])
2. {1, 2, 3}
3. >>> tuple({5,6,7})
4. (5, 6, 7)
5. >>> list('hello')
6. ['h', 'e', 'l', 'l', 'o']
To convert to dictionary, each element must be a pair
1. >>> dict([[1,2],[3,4]])
2. {1: 2, 3: 4}
3. >>> dict([(3,26),(4,44)])
4. {3: 26, 4: 44}
1.17 Python Type Conversion and Type Casting
Before learning Type Conversion in Python, you should have
knowledge about Python Data Types.
1.17.1 Type Conversion:
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.
1. Implicit Type Conversion
2. Explicit Type Conversion
Implicit Type Conversion:

In Implicit type conversion, Python automatically converts one data type to another
data type. This process doesn't need any user involvement.
Let's see an example where Python promotes conversion of lower data type (integer)
to higher data type (float) to avoid data loss.
Example 1: Converting integer to float
num_int = 123
num_flo = 1.23
num_new = num_int + num_flo
print("datatype of num_int:",type(num_int))
print("datatype of num_flo:",type(num_flo))
print("Value of num_new:",num_new)
print("datatype of num_new:",type(num_new))
When we run the above program, the output will be
datatype of num_int: <class 'int'>
datatype of num_flo: <class 'float'>
Value of num_new: 124.23
datatype of num_new: <class 'float'>
 We add two variables num_int and num_flo, storing the value in num_new.
 We will look at the data type of all three objects respectively.
 In the output we can see the data type of num_int is an integer, data type
of num_flo is a float.
 Also, we can see the num_new has float data type because Python always converts
smaller data type to larger data type to avoid the loss of data.
Now, let's try adding a string and an integer, and see how Python treats it.
Example 2: Addition of string (higher) data type and integer(lower) data type
num_int = 123
num_str = "456"
print("Data type of num_int:",type(num_int))
print("Data type of num_str:",type(num_str))
print(num_int+num_str)

Data type of num_int: <class 'int'>
Data type of num_str: <class 'str'>
Traceback (most recent call last):
File "python", line 7, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
 We add two variable num_int and num_str.
 As we can see from the output, we got type error. Python is not able use Implicit
Conversion in such condition.
 However Python has the solution for this type of situation which is know as Explicit
Conversion.
Explicit Type Conversion:
In Explicit Type Conversion, users convert the data type of an object to required data
type. We use the predefined functions like int(), float(), str(), etc to perform
explicit type conversion. This type conversion is also called typecasting because the
user casts (change) the data type of the objects.
Syntax :
(required_datatype)(expression)
Typecasting can be done by assigning the required data type function to the
expression.
Example 3: Addition of string and integer using explicit conversion
num_int = 123
num_str = "456"
print("Data type of num_int:",type(num_int))
print("Data type of num_str before Type Casting:",type(num_str))
num_str = int(num_str)
print("Data type of num_str after Type Casting:",type(num_str))
num_sum = num_int + num_str
print("Sum of num_int and num_str:",num_sum)
print("Data type of the sum:",type(num_sum))

Data type of num_int: <class 'int'>
Data type of num_str before Type Casting: <class 'str'>
Data type of num_str after Type Casting: <class 'int'>
Sum of num_int and num_str: 579
Data type of the sum: <class 'int'>
In above program,
 We add num_str and num_int variable.
 We converted num_str from string(higher) to integer(lower) type using int() function
to perform the addition.
 After converting num_str to a integer value Python is able to add these two variable.
 We got the num_sum value and data type to be integer.
Key Points to Remember:
1. Type Conversion is the conversion of object from one data type to another data
type.
2. Implicit Type Conversion is automatically performed by the Python interpreter.
3. Python avoids the loss of data in Implicit Type Conversion.
4. Explicit Type Conversion is also called Type Casting, the data types of object are
converted using predefined function by user.
5. In Type Casting loss of data may occur as we enforce the object to specific data
type.
1.18 Python Input, Output and Import
Python provides numerous built-in functions that are readily available to us at the
Python prompt.
Some of the functions like input() and print() are widely used for standard input
and output operations respectively. Let us see the output section first.
1.18.1 Python Output Using print() function
We use the print() function to output data to the standard output device (screen).
We can also output data to a file, but this will be discussed later. An example use is
given below.
print('This sentence is output to the screen')
# Output: This sentence is output to the screen
a = 5
print('The value of a is', a)
# Output: The value of a is 5

In the second print() statement, we can notice that a space was added between
the string and the value of variable a. This is by default, but we can change it.
The actual syntax of the print() function is
print(*objects, sep=' ', end='n', file=sys.stdout, flush=False)
Here, objects is the value(s) to be printed.
The sep separator is used between the values. It defaults into a space character.
After all values are printed, end is printed. It defaults into a new line.
The file is the object where the values are printed and its default value
is sys.stdout (screen). Here are an example to illustrate this.
print(1,2,3,4)
# Output: 1 2 3 4
print(1,2,3,4,sep='*')
# Output: 1*2*3*4
print(1,2,3,4,sep='#',end='&')
# Output: 1#2#3#4&
Output formatting
Sometimes we would like to format our output to make it look attractive. This can be
done by using the str.format() method. This method is visible to any string object.
1. >>> x = 5; y = 10
2. >>> print('The value of x is {} and y is {}'.format(x,y))
3. The value of x is 5 and y is 10
Here the curly braces {} are used as placeholders. We can specify the order in which
it is printed by using numbers (tuple index).
print('I love {0} and {1}'.format('bread','butter'))
# Output: I love bread and butter
print('I love {1} and {0}'.format('bread','butter'))
# Output: I love butter and bread
We can even use keyword arguments to format the string.
1. >>> print('Hello {name}, {greeting}'.format(greeting = 'Goodmorning', name
= 'John'))
2. Hello John, Goodmorning
We can even format strings like the old sprintf() style used in C programming
language. We use the % operator to accomplish this.
1. >>> x = 12.3456789

2. >>> print('The value of x is %3.2f' %x)
3. The value of x is 12.35
1.18.2 Python Input
Up till now, our programs were static. The value of variables were defined or hard
coded into the source code.
To allow flexibility we might want to take the input from the user. In Python, we have
the input() function to allow this. The syntax for input() is
input([prompt])
where prompt is the string we wish to display on the screen. It is optional.
1. >>> num = input('Enter a number: ')
2. Enter a number: 10
3. >>> num
4. '10'
Here, we can see that the entered value 10 is a string, not a number. To convert this
into a number we can use int() or float() functions.
1. >>> int('10')
2. 10
3. >>> float('10')
4. 10.0
This same operation can be performed using the eval() function. But it takes it
further. It can evaluate even expressions, provided the input is a string
1. >>> int('2+3')
5. ValueError: invalid literal for int() with base 10: '2+3'
6. >>> eval('2+3')
7. 5
1.18.3 Python Import
When our program grows bigger, it is a good idea to break it into different modules.
A module is a file containing Python definitions and statements. Python
modules have a filename and end with the extension .py.
Definitions inside a module can be imported to another module or the interactive
interpreter in Python. We use the import keyword to do this.
For example, we can import the math module by typing in import math.
import math
print(math.pi)

Now all the definitions inside math module are available in our scope. We can also
import some specific attributes and functions only, using the from keyword. For
example:
1. >>> from math import pi
2. >>> pi
3. 3.141592653589793
While importing a module, Python looks at several places defined in sys.path. It is a
list of directory locations.
1. >>> import sys
2. >>> sys.path
3. ['',
4. 'C:Python33Libidlelib',
5. 'C:Windowssystem32python33.zip',
6. 'C:Python33DLLs',
7. 'C:Python33lib',
8. 'C:Python33',
9. 'C:Python33libsite-packages']
We can add our own location to this list as well.
1.19 Python Operators
What are operators in python?
Operators are special symbols in Python that carry out arithmetic or logical
computation. The value that the operator operates on is called the operand.
For example:
1. >>> 2+3
2. 5
Here, + is the operator that performs addition. 2 and 3 are the operands and 5 is the
output of the operation.
1.19.1 Arithmetic operators
Arithmetic operators are used to perform mathematical operations like addition,
subtraction, multiplication etc.
Operator Meaning Example
+ Add two operands or unary plus
x + y
+2
- Subtract right operand from the left or unary minus
x - y
-2
* Multiply two operands x * y

/
Divide left operand by the right one (always results
into float) x / y
%
Modulus - remainder of the division of left operand
by the right
x % y (remainder
of x/y)
//
Floor division - division that results into whole
number adjusted to the left in the number line x // y
** Exponent - left operand raised to the power of right
x**y (x to the
power y)
Arithmetic operators in Python
Example #1: Arithmetic operators in Python
1. x = 15
2. y = 4
3.
4. # Output: x + y = 19
5. print('x + y =',x+y)
6.
7. # Output: x - y = 11
8. print('x - y =',x-y)
9.
10.# Output: x * y = 60
11.print('x * y =',x*y)
12.
13.# Output: x / y = 3.75
14.print('x / y =',x/y)
15.
16.# Output: x // y = 3
17.print('x // y =',x//y)
18.
19.# Output: x ** y = 50625
20.print('x ** y =',x**y)
x + y = 19
x - y = 11
x * y = 60
x / y = 3.75
x // y = 3
x ** y = 50625
1.19.2 Comparison operators
Comparison operators are used to compare values. It either
returns True or False according to the condition.

> Greater that - True if left operand is greater than the right x > y
< Less that - True if left operand is less than the right x < y
== Equal to - True if both operands are equal x == y
!= Not equal to - True if operands are not equal x != y
>=
Greater than or equal to - True if left operand is greater than
or equal to the right x >= y
<=
Less than or equal to - True if left operand is less than or
equal to the right x <= y
Example #2: Comparison operators in Python
1. x = 10
2. y = 12
3.
4. # Output: x > y is False
5. print('x > y is',x>y)
6.
7. # Output: x < y is True
8. print('x < y is',x<y)
9.
10.# Output: x == y is False
11.print('x == y is',x==y)
12.
13.# Output: x != y is True
14.print('x != y is',x!=y)
15.
16.# Output: x >= y is False
17.print('x >= y is',x>=y)
18.
19.# Output: x <= y is True
20.print('x <= y is',x<=y)
1.19.3 Logical operators
Logical operators are the and, or, not operators.
and True if both the operands are true x and y
or True if either of the operands is true x or y

not True if operand is false (complements the operand) not x
Example #3: Logical Operators in Python
1. x = True
2. y = False
3.
4. # Output: x and y is False
5. print('x and y is',x and y)
6.
7. # Output: x or y is True
8. print('x or y is',x or y)
9.
10.# Output: not x is False
11.print('not x is',not x)
1.19.4 Bitwise operators
Bitwise operators act on operands as if they were string of binary digits. It operates
bit by bit, hence the name.
For example, 2 is 10 in binary and 7 is 111.
In the table below: Let x = 10 (0000 1010 in binary) and y = 4 (0000 0100 in binary)
& Bitwise AND x& y = 0 (0000 0000)
| Bitwise OR x | y = 14 (0000 1110)
~ Bitwise NOT ~x = -11 (1111 0101)
^ Bitwise XOR x ^ y = 14 (0000 1110)
>> Bitwise right shift x>> 2 = 2 (0000 0010)
<< Bitwise left shift x<< 2 = 40 (0010 1000)
1.19.5 Assignment operators
Assignment operators are used in Python to assign values to variables.

a = 5 is a simple assignment operator that assigns the value 5 on the right to the
variable a on the left.
There are various compound operators in Python like a += 5 that adds to the
variable and later assigns the same. It is equivalent to a = a + 5.
Operator Example Equivalent to
= x = 5 x = 5
+= x += 5 x = x + 5
-= x -= 5 x = x – 5
*= x *= 5 x = x * 5
/= x /= 5 x = x / 5
%= x %= 5 x = x % 5
//= x //= 5 x = x // 5
**= x **= 5 x = x ** 5
&= x &= 5 x = x & 5
|= x |= 5 x = x | 5
^= x ^= 5 x = x ^ 5
>>= x >>= 5 x = x >> 5
<<= x <<= 5 x = x << 5
1.19.6 Special operators
Python language offers some special type of operators like the identity operator or
the membership operator. They are described below with examples.
Identity operators
is and is not are the identity operators in Python. They are used to check if two
values (or variables) are located on the same part of the memory. Two variables that
are equal does not imply that they are identical.
is
True if the operands are identical (refer to the same
object) x is True

is not
True if the operands are not identical (do not refer to the
same object)
x is not
True
Example #4: Identity operators in Python
1. x1 = 5
2. y1 = 5
3. x2 = 'Hello'
4. y2 = 'Hello'
5. x3 = [1,2,3]
6. y3 = [1,2,3]
7.
8. # Output: False
9. print(x1 is not y1)
10.
11.# Output: True
12.print(x2 is y2)
13.
14.# Output: False
15.print(x3 is y3)
Here, we see that x1 and y1 are integers of same values, so they are equal as well
as identical. Same is the case with x2 and y2 (strings).
But x3 and y3 are list. They are equal but not identical. It is because interpreter
locates them separately in memory although they are equal.
Membership operators
in and not in are the membership operators in Python. They are used to test
whether a value or variable is found in a sequence
(string, list, tuple, set and dictionary).
In a dictionary we can only test for presence of key, not the value.
in True if value/variable is found in the sequence 5 in x
not in True if value/variable is not found in the sequence 5 not in x
Example #5: Membership operators in Python
1. x = 'Hello world'
2. y = {1:'a',2:'b'}
3.
4. # Output: True
5. print('H' in x)
6.
7. # Output: True
8. print('hello' not in x)
9.
10.# Output: True
11.print(1 in y)
12.

13.# Output: False
14.print('a' in y)
Here, 'H' is in x but 'hello' is not present in x (remember, Python is case sensitive).
Similary, 1 is key and 'a' is the value in dictionary y. Hence, 'a' in y returns False.
1.20 Python Namespace and Scope
1.20.1 What is Name in Python?
If you have ever read 'The Zen of Python' (type "import this" in Python interpreter),
the last line states, Namespaces are one honking great idea -- let's do more of
those! So what are these mysterious namespaces? Let us first look at what name is.
Name (also called identifier) is simply a name given to objects. Everything in Python
is an object. Name is a way to access the underlying object.
For example, when we do the assignment a = 2, here 2 is an object stored in
memory and a is the name we associate it with. We can get the address (in RAM) of
some object through the built-in function, id(). Let's check it.
# Note: You may get different value of id
a = 2
# Output: id(2)= 10919424
print('id(2) =', id(2))
# Output: id(a) = 10919424
print('id(a) =', id(a))
Result
id(2) = 10914400
id(a) = 10914400
Here, both refer to the same object. Let's make things a little more interesting
# Note: You may get different value of id
a = 2
# Output: id(a) = 10919424
a = a+1
# Output: id(a) = 10919456

# Output: id(3) = 10919456
print('id(3) =', id(3))
b = 2
# Output: id(2)= 10919424
print('id(2) =', id(2))
What is happening in the above sequence of steps? A diagram will help us explain
this.
Initially, an object 2 is created and the name a is associated with it, when we do a =
a+1, a new object 3 is created and now a associates with this object.
Note that id(a) and id(3) have same values.
Furthermore, when we do b = 2, the new name b gets associated with the previous
object 2.
This is efficient as Python doesn't have to create a new duplicate object. This
dynamic nature of name binding makes Python powerful; a name could refer to any
type of object.
1. >>> a = 5
2. >>> a = 'Hello World!'
3. >>> a = [1,2,3]
All these are valid and a will refer to three different types of object at different
instances. Functions are objects too, so a name can refer to them as well.
def printHello():
print("Hello")
a = printHello()
# Output: Hello
Our same name a can refer to a function and we can call the function through it, pretty neat.

1.20.2 What is a Namespace in Python?
So now that we understand what names are, we can move on to the concept of
namespaces.To simply put it, namespace is a collection of names. In Python, you
can imagine a namespace as a mapping of every name, you have defined, to
corresponding objects. Different namespaces can co-exist at a given time but are
completely isolated.
A namespace containing all the built-in names is created when we start the Python
interpreter and exists as long we don't exit.
This is the reason that built-in functions like id(), print() etc. are always available to
us from any part of the program. Each module creates its own global namespace.
These different namespaces are isolated. Hence, the same name that may exist in
different modules do not collide.
Modules can have various functions and classes. A local namespace is created
when a function is called, which has all the names defined in it. Similar, is the case
with class. Following diagram may help to clarify this concept.
1.20.3 Python Variable Scope
Although there are various unique namespaces defined, we may not be able to
access all of them from every part of the program. The concept of scope comes into
play.
Scope is the portion of the program from where a namespace can be accessed
directly without any prefix.

At any given moment, there are at least three nested scopes.
1. Scope of the current function which has local names
2. Scope of the module which has global names
3. Outermost scope which has built-in names
When a reference is made inside a function, the name is searched in the local
namespace, then in the global namespace and finally in the built-in namespace.
If there is a function inside another function, a new scope is nested inside the local
scope.
Example of Scope and Namespace in Python
def outer_function():
b = 20
def inner_func():
c = 30
a = 10
Here, the variable a is in the global namespace. Variable b is in the local namespace
of outer_function() and c is in the nested local namespace of inner_function().
When we are in inner_function(), c is local to us, b is nonlocal and a is global. We
can read as well as assign new values to c but can only
read b and a from inner_function().
If we try to assign as a value to b, a new variable b is created in the local namespace
which is different than the nonlocal b. Same thing happens when we assign a value
to a.
However, if we declare a as global, all the reference and assignment go to the
global a. Similarly, if we want to rebind the variable b, it must be declared as
nonlocal. The following example will further clarify this.
a = 20
def inner_function():
a = 30
print('a =',a)
inner_function()
print('a =',a)
a = 10
outer_function()
print('a =',a)
As you can see, the output of this program is
a = 30

a = 20
a = 10
In this program, three different variables a are defined in separate namespaces and
accessed accordingly. While in the following program,
global a
a = 20
def inner_function():
global a
a = 30
print('a =',a)
inner_function()
print('a =',a)
a = 10
outer_function()
print('a =',a)
The output of the program is.
a = 30
a = 30
a = 30
Here, all reference and assignment are to the global a due to the use of keyword global.

2. FLOW CONTROL
2.1 Python if...else Statement
2.1.1 What are if...else statement in Python?
Decision making is required when we want to execute a code only if a certain
condition is satisfied.
The if…elif…else statement is used in Python for decision making.
Python if Statement Syntax
if test expression:
statement(s)
Here, the program evaluates the test expression and will execute statement(s) only
if the text expression is True.
If the text expression is False, the statement(s) is not executed.
In Python, the body of the if statement is indicated by the indentation. Body starts
with an indentation and the first unindented line marks the end.
Python interprets non-zero values as True. None and 0 are interpreted as False.
2.1.2 Python if Statement Flowchart
Example: Python if Statement
# If the number is positive, we print an appropriate message

num = 3
if num > 0:
print(num, "is a positive number.")
print("This is always printed.")
num = -1
if num > 0:
print(num, "is a positive number.")
print("This is also always printed.")
3 is a positive number
This is always printed
This is also always printed.
In the above example, num > 0 is the test expression.
The body of if is executed only if this evaluates to True.
When variable num is equal to 3, test expression is true and body inside body of if is
executed.
If variable num is equal to -1, test expression is false and body inside body of if is
skipped.
The print() statement falls outside of the if block (unindented). Hence, it is
executed regardless of the test expression.
Python if...else Statement
Syntax of if...else
if test expression:
Body of if
else:
Body of else
The if..else statement evaluates test expression and will execute body of if only
when test condition is True.
If the condition is False, body of else is executed. Indentation is used to separate the
blocks.

Python if..else Flowchart
Example of if...else
# Program checks if the number is positive or negative
# And displays an appropriate message
num = 3
# Try these two variations as well.
# num = -5
# num = 0
if num >= 0:
print("Positive or Zero")
else:
print("Negative number")
Result:
Positive or Zero
In the above example, when num is equal to 3, the test expression is true and body
of if is executed and body of else is skipped.
If num is equal to -5, the test expression is false and body of else is executed and
body of if is skipped.
If num is equal to 0, the test expression is true and body of if is executed and body of
else is skipped.
2.2 Python if...elif...else Statement

2.2.1 Syntax of if...elif...else
if test expression:
Body of if
elif test expression:
Body of elif
else:
Body of else
The elif is short for else if. It allows us to check for multiple expressions.
If the condition for if is False, it checks the condition of the next elif block and so
on.
If all the conditions are False, body of else is executed.
Only one block among the several if...elif...else blocks is executed according to
the condition.
The if block can have only one else block. But it can have multiple elif blocks.
2.2.2 Flowchart of if...elif...else

Example of if...elif...else
# In this program,
# we check if the number is positive or
# negative or zero and
# display an appropriate message
num = 3.4
# Try these two variations as well:
# num = 0
# num = -4.5
if num > 0:
print("Positive number")
elif num == 0:
print("Zero")
else:
print("Negative number")
Result:
Positive number
When variable num is positive, Positive number is printed.
If num is equal to 0, Zero is printed.
If num is negative, Negative number is printed
2.3 Python Nested if statements
We can have a if...elif...else statement inside
another if...elif...else statement. This is called nesting in computer
programming.
Any number of these statements can be nested inside one another. Indentation is
the only way to figure out the level of nesting. This can get confusing, so must be
avoided if we can.
Python Nested if Example
1. # In this program, we input a number
2. # check if the number is positive or
3. # negative or zero and display
4. # an appropriate message
5. # This time we use nested if
6.
7. num = float(input("Enter a number: "))
8. if num >= 0:
9. if num == 0:
10. print("Zero")
11. else:
12. print("Positive number")
13.else:
14. print("Negative number")

Output 1
Enter a number: 5
Positive number
Output 2
Enter a number: -1
Negative number
Output 3
Enter a number: 0
Zero
2.4 Python for Loop
2.4.1 What is for loop in Python?
The for loop in Python is used to iterate over a sequence (list, tuple, string) or other
iterable objects. Iterating over a sequence is called traversal.
Syntax of for Loop
for val in sequence:
Body of for
Here, val is the variable that takes the value of the item inside the sequence on each
iteration.
Loop continues until we reach the last item in the sequence. The body of for loop is
separated from the rest of the code using indentation.
Flowchart of for Loop

Example: Python for Loop
# Program to find the sum of all numbers stored in a list
# List of numbers
numbers = [6, 5, 3, 8, 4, 2, 5, 4, 11]
# variable to store the sum
sum = 0
# iterate over the list
for val in numbers:
sum = sum+val
# Output: The sum is 48
print("The sum is", sum)
when you run the program, the output will be:
The sum is 48
The range() function
We can generate a sequence of numbers using range() function. range(10) will
generate numbers from 0 to 9 (10 numbers).
We can also define the start, stop and step size as range(start,stop,step size).
step size defaults to 1 if not provided.

This function does not store all the values in memory, it would be inefficient. So it
remembers the start, stop, step size and generates the next number on the go.
To force this function to output all the items, we can use the function list().
The following example will clarify this.
# Output: range(0, 10)
print(range(10))
# Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(10)))
# Output: [2, 3, 4, 5, 6, 7]
print(list(range(2, 8)))
# Output: [2, 5, 8, 11, 14, 17]
print(list(range(2, 20, 3)))
We can use the range() function in for loops to iterate through a sequence of numbers. It can
be combined with the len() function to iterate though a sequence using indexing. Here is an
example.
# Program to iterate through a list using indexing
genre = ['pop', 'rock', 'jazz']
# iterate over the list using index
for i in range(len(genre)):
print("I like", genre[i])
I like pop
I like rock
I like jazz
2.4.2 for loop with else

A for loop can have an optional else block as well. The else part is executed if the
items in the sequence used in for loop exhausts.
break statement can be used to stop a for loop. In such case, the else part is
ignored.
Hence, a for loop's else part runs if no break occurs.
Here is an example to illustrate this.
digits = [0, 1, 5]
for i in digits:
print(i)
else:
print("No items left.")
0
1
5
No items left.
Here, the for loop prints items of the list until the loop exhausts. When the for loop
exhausts, it executes the block of code in the else and prints
No items left.
2.5 Python while Loop
What is while loop in Python?
The while loop in Python is used to iterate over a block of code as long as the test
expression (condition) is true.
We generally use this loop when we don't know beforehand, the number of times to
iterate.
Syntax of while Loop in Python
while test_expression:
Body of while

In while loop, test expression is checked first. The body of the loop is entered only if
the test_expression evaluates to True. After one iteration, the test expression is
checked again. This process continues until the test_expression evaluates to False.
In Python, the body of the while loop is determined through indentation.
Body starts with indentation and the first unindented line marks the end.
Python interprets any non-zero value as True. None and 0 are interpreted as False.
Flowchart of while Loop
Example: Python while Loop
# Program to add natural
# numbers upto
# sum = 1+2+3+...+n
# To take input from the user,
# n = int(input("Enter n: "))
n = 10
# initialize sum and counter
sum = 0
i = 1
while i <= n:
sum = sum + i

i = i+1 # update counter
# print the sum
print("The sum is", sum)
Enter n: 10
The sum is 55
In the above program, the test expression will be True as long as our counter
variable i is less than or equal to n (10 in our program).
We need to increase the value of counter variable in the body of the loop. This is
very important (and mostly forgotten). Failing to do so will result in an infinite loop
(never ending loop).
Finally the result is displayed.
2.6 while loop with else
Same as that of for loop, we can have an optional else block with while loop as well.
The else part is executed if the condition in the while loop evaluates to False.
The while loop can be terminated with a break statement. In such case, the else part
is ignored. Hence, a while loop's else part runs if no break occurs and the condition
is false.
Here is an example to illustrate this.
# Example to illustrate
# the use of else statement
# with the while loop
counter = 0
while counter < 3:
print("Inside loop")
counter = counter + 1
else:
print("Inside else")
Output
Inside loop
Inside loop
Inside loop
Inside else
Here, we use a counter variable to print the string Inside loop three times.

On the forth iteration, the condition in while becomes False. Hence, the else part is
executed.
2.7 Python break and continue
2.7.1 What is the use of break and continue in Python?
In Python, break and continue statements can alter the flow of a normal loop.
Loops iterate over a block of code until test expression is false, but sometimes we
wish to terminate the current iteration or even the whole loop without checking test
expression.
The break and continue statements are used in these cases.
2.7.2 Python break statement
The break statement terminates the loop containing it. Control of the program flows
to the statement immediately after the body of the loop.
If break statement is inside a nested loop (loop inside another loop), break will
terminate the innermost loop.
Syntax of break
break
Flowchart of break

The working of break statement in for loop and while loop is shown below.

Example: Python break
# Use of break statement inside loop
for val in "string":
if val == "i":
break
print(val)
print("The end")
Output
s
t
r
The end
In this program, we iterate through the "string" sequence. We check if the letter
is "i", upon which we break from the loop. Hence, we see in our output that all the
letters up till "i" gets printed. After that, the loop terminates.
2.7.3 Python continue statement
The continue statement is used to skip the rest of the code inside a loop for the
current iteration only. Loop does not terminate but continues on with the next
iteration.
Syntax of Continue

continue
Flowchart of continue
The working of continue statement in for and while loop is shown below.

Example: Python continue
# Program to show the use of continue statement inside loops
for val in "string":
if val == "i":
continue
print(val)
print("The end")
Output
s
t
r
n
g
The end
This program is same as the above example except the break statement has been
replaced with continue.
We continue with the loop, if the string is "i", not executing the rest of the block.
Hence, we see in our output that all the letters except "i" gets printed.
2.8 Python pass statement
What is pass statement in Python?

In Python programming, pass is a null statement. The difference between
a comment and pass statement in Python is that, while the interpreter ignores a
comment entirely, pass is not ignored.
However, nothing happens when pass is executed. It results into no operation
(NOP).
Syntax of pass
pass
We generally use it as a placeholder.
Suppose we have a loop or a function that is not implemented yet, but we want to
implement it in the future. They cannot have an empty body. The interpreter would
complain. So, we use the pass statement to construct a body that does nothing.
Example: pass Statement
# pass is just a placeholder for
# functionality to be added later.
sequence = {'p', 'a', 's', 's'}
for val in sequence:
pass
We can do the same thing in an empty function or class as well.
1.
2. def function(args):
3. pass
1.
2. class example:
3. pass
2.9 Python Looping Techniques
Python programming offers two kinds of loop, the for loop and the while loop. Using
these loops along with loop control statements like break and continue, we can
create various forms of loop.
2.9.1 The infinite loop
We can create an infinite loop using while statement. If the condition of while loop is
always True, we get an infinite loop.
Example #1: Infinite loop using while
1. # An example of infinite loop
2. # press Ctrl + c to exit from the loop
3.
4. while True:
5. num = int(input("Enter an integer: "))
6. print("The double of",num,"is",2 * num)
Output

Enter an integer: 3
The double of 3 is 6
Enter an integer: 5
Enter an integer: 6
Enter an integer:
Traceback (most recent call last):
2.9.2 Loop with condition at the top
This is a normal while loop without break statements. The condition of the while loop
is at the top and the loop terminates when this condition is False.
Flowchart of Loop With Condition at Top
Example #2: Loop with condition at the top
# Program to illustrate a loop with condition at the top
# Try different numbers
n = 10
# Uncomment to get user input
#n = int(input("Enter n: "))
# initialize sum and counter
sum = 0
i = 1

while i <= n:
sum = sum + i
i = i+1 # update counter
# print the sum
print("The sum is",sum)
The sum is 55
2.9.3 Loop with condition in the middle
This kind of loop can be implemented using an infinite loop along with a conditional
break in between the body of the loop.
Flowchart of Loop with Condition in Middle
Example #3: Loop with condition in the middle
1. # Program to illustrate a loop with condition in the middle.
2. # Take input from the user untill a vowel is entered
3.
4. vowels = "aeiouAEIOU"
5.
6. # infinite loop
7. while True:
8. v = input("Enter a vowel: ")
9. # condition in the middle

10. if v in vowels:
11. break
12. print("That is not a vowel. Try again!")
13.
14.print("Thank you!")
Output
Enter a vowel: r
That is not a vowel. Try again!
Enter a vowel: 6
Enter a vowel: ,
Enter a vowel: u
Thank you!
2.9.4 Loop with condition at the bottom
This kind of loop ensures that the body of the loop is executed at least once. It can
be implemented using an infinite loop along with a conditional break at the end. This
is similar to the do...while loop in C.
Flowchart of Loop with Condition at Bottom
Example #4: Loop with condition at the bottom
1.
2. # Python program to illustrate a loop with condition at the bottom
3. # Roll a dice untill user chooses to exit
4.
5. # import random module

6. import random
7.
8. while True:
9. input("Press enter to roll the dice")
10.
11. # get a number between 1 to 6
12. num = random.randint(1,6)
13. print("You got",num)
14. option = input("Roll again?(y/n) ")
15.
16. # condition
17. if option == 'n':
18. break
19.
Output
Press enter to roll the dice
You got 1
Roll again?(y/n) y
Press enter to roll the dice
You got 5
Roll again?(y/n) n

3. Python Functions
3.1 What is a function in Python?
In Python, function is a group of related statements that perform a specific task.
Functions help break our program into smaller and modular chunks. As our program
grows larger and larger, functions make it more organized and manageable.
Furthermore, it avoids repetition and makes code reusable.
Syntax of Function
def function_name(parameters):
"""docstring"""
statement(s)
Above shown is a function definition which consists of following components.
1. Keyword def marks the start of function header.
2. A function name to uniquely identify it. Function naming follows the same rules of writing
identifiers in Python.
3. Parameters (arguments) through which we pass values to a function. They are optional.
4. A colon (:) to mark the end of function header.
5. Optional documentation string (docstring) to describe what the function does.
6. One or more valid python statements that make up the function body. Statements must have
same indentation level (usually 4 spaces).
7. An optional return statement to return a value from the function.
Example of a function
def greet(name):
"""This function greets to
the person passed in as
parameter"""
print("Hello, " + name + ". Good morning!")
3.2 How to call a function in python?
Once we have defined a function, we can call it from another function, program or
even the Python prompt. To call a function we simply type the function name with
appropriate parameters.
>>> greet('Paul')

Hello, Paul. Good morning!
3.3 Docstring
The first string after the function header is called the docstring and is short for
documentation string. It is used to explain in brief, what a function does.
Although optional, documentation is a good programming practice. Unless you can
remember what you had for dinner last week, always document your code.
In the above example, we have a docstring immediately below the function header.
We generally use triple quotes so that docstring can extend up to multiple lines. This
string is available to us as __doc__ attribute of the function.
For example:
Try running the following into the Python shell to see the output.
1. >>> print(greet.__doc__)
2. This function greets to
3. the person passed into the
4. name parameter
5.
3.4 The return statement
The return statement is used to exit a function and go back to the place from where
it was called.
Syntax of return
return [expression_list]
This statement can contain expression which gets evaluated and the value is
returned. If there is no expression in the statement or the return statement itself is
not present inside a function, then the function will return the None object.
For example:
1. >>> print(greet("May"))
2. Hello, May. Good morning!
3. None
4.
Here, None is the returned value.
Example of return

def absolute_value(num):
"""This function returns the absolute
value of the entered number"""
if num >= 0:
return num
else:
return -num
# Output: 2
print(absolute_value(2))
# Output: 4
print(absolute_value(-4))
Result:
2
4
3.5 How Function works in Python?
3.6 Scope and Lifetime of variables
Scope of a variable is the portion of a program where the variable is recognized.
Parameters and variables defined inside a function is not visible from outside.
Hence, they have a local scope.
Lifetime of a variable is the period throughout which the variable exits in the memory.
The lifetime of variables inside a function is as long as the function executes.

They are destroyed once we return from the function. Hence, a function does not
remember the value of a variable from its previous calls.
Here is an example to illustrate the scope of a variable inside a function.
def my_func():
x = 10
print("Value inside function:",x)
x = 20
my_func()
print("Value outside function:",x)
Output
Value inside function: 10
Value outside function: 20
Here, we can see that the value of x is 20 initially. Even though the
function my_func() changed the value of x to 10, it did not effect the value outside the
function.
This is because the variable x inside the function is different (local to the function)
from the one outside. Although they have same names, they are two different
variables with different scope.
On the other hand, variables outside of the function are visible from inside. They
have a global scope.
We can read these values from inside the function but cannot change (write) them.
In order to modify the value of variables outside the function, they must be declared
as global variables using the keyword global.
3.7 Types of Functions
Basically, we can divide functions into the following two types:
1. Built-in functions - Functions that are built into Python.
2. User-defined functions - Functions defined by the users themselves.
3.8 Python Function Arguments
3.8.1 Arguments
In user-defined function topic, we learned about defining a function and calling it.
Otherwise, the function call will result into an error. Here is an example.

def greet(name,msg):
"""This function greets to
the person with the provided message"""
print("Hello",name + ', ' + msg)
greet("Monica","Good morning!")
Output
Hello Monica, Good morning!
Here, the function greet() has two parameters.
Since, we have called this function with two arguments, it runs smoothly and we do
not get any error.
If we call it with different number of arguments, the interpreter will complain. Below is
a call to this function with one and no arguments along with their respective error
messages.
>>> greet("Monica") # only one argument
TypeError: greet() missing 1 required positional argument: 'msg'
>>> greet() # no arguments
TypeError: greet() missing 2 required positional arguments: 'name' and
'msg'
3.8.2 Variable Function Arguments
Up until now functions had fixed number of arguments. In Python there are other
ways to define a function which can take variable number of arguments.
Three different forms of this type are described below.
3.8.3 Python Default Arguments
Function arguments can have default values in Python.
We can provide a default value to an argument by using the assignment operator (=).
Here is an example.
def greet(name, msg = "Good morning!"):
"""
This function greets to
the person with the

provided message.
If message is not provided,
it defaults to "Good
morning!"
"""
print("Hello",name + ', ' + msg)
greet("Kate")
greet("Bruce","How do you do?")
Result:
Hello Kate, Good morning!
Hello Bruce, How do you do?
In this function, the parameter name does not have a default value and is required
(mandatory) during a call.
On the other hand, the parameter msg has a default value of "Good morning!". So, it
is optional during a call. If a value is provided, it will overwrite the default value.
Any number of arguments in a function can have a default value. But once we have
a default argument, all the arguments to its right must also have default values.
This means to say, non-default arguments cannot follow default arguments. For
example, if we had defined the function header above as:
def greet(msg = "Good morning!", name):
We would get an error as:
SyntaxError: non-default argument follows default argument
3.8.4 Python Keyword Arguments
When we call a function with some values, these values get assigned to the
arguments according to their position.
For example, in the above function greet(), when we called it as greet("Bruce","How
do you do?"), the value "Bruce" gets assigned to the argument name and
similarly "How do you do?" to msg.
Python allows functions to be called using keyword arguments. When we call
functions in this way, the order (position) of the arguments can be changed.
Following calls to the above function are all valid and produce the same result.

>>> # 2 keyword arguments
>>> greet(name = "Bruce",msg = "How do you do?")
>>> # 2 keyword arguments (out of order)
>>> greet(msg = "How do you do?",name = "Bruce")
>>> # 1 positional, 1 keyword argument
>>> greet("Bruce",msg = "How do you do?")
As we can see, we can mix positional arguments with keyword arguments during a
function call. But we must keep in mind that keyword arguments must follow
positional arguments.
Having a positional argument after keyword arguments will result into errors. For
example the function call as follows:
greet(name="Bruce","How do you do?")
Will result into error as:
SyntaxError: non-keyword arg after keyword arg
3.8.5 Python Arbitrary Arguments
Sometimes, we do not know in advance the number of arguments that will be passed
into a function.Python allows us to handle this kind of situation through function calls
with arbitrary number of arguments.
In the function definition we use an asterisk (*) before the parameter name to denote
this kind of argument. Here is an example.
def greet(*names):
"""This function greets all
the person in the names tuple."""

# names is a tuple with arguments
for name in names:
print("Hello",name)
greet("Monica","Luke","Steve","John")
Output
Hello Monica
Hello Luke
Hello Steve
Hello John
Here, we have called the function with multiple arguments. These arguments get
wrapped up into a tuple before being passed into the function. Inside the function, we
use a for loop to retrieve all the arguments back.
3.9 Python Recursion
3.9.1 What is recursion in Python?
Recursion is the process of defining something in terms of itself.
A physical world example would be to place two parallel mirrors facing each other.
Any object in between them would be reflected recursively.
3.9.2 Python Recursive Function
We know that in Python, a function can call other functions. It is even possible for the
function to call itself. These type of construct are termed as recursive functions.
Following is an example of recursive function to find the factorial of an integer.
Factorial of a number is the product of all the integers from 1 to that number. For
example, the factorial of 6 (denoted as 6!) is 1*2*3*4*5*6 = 720.
Example of recursive function
# An example of a recursive function to
# find the factorial of a number
def calc_factorial(x):
"""This is a recursive function
to find the factorial of an integer"""
if x == 1:
return 1

else:
return (x * calc_factorial(x-1))
num = 4
print("The factorial of", num, "is", calc_factorial(num))
The factorial of 4 is 24
In the above example, calc_factorial() is a recursive functions as it calls itself.
When we call this function with a positive integer, it will recursively call itself by
decreasing the number.
Each function call multiples the number with the factorial of number 1 until the
number is equal to one. This recursive call can be explained in the following steps.
1.
2. calc_factorial(4) # 1st call with 4
3. 4 * calc_factorial(3) # 2nd call with 3
4. 4 * 3 * calc_factorial(2) # 3rd call with 2
5. 4 * 3 * 2 * calc_factorial(1) # 4th call with 1
6. 4 * 3 * 2 * 1 # return from 4th call as number=1
7. 4 * 3 * 2 # return from 3rd call
8. 4 * 6 # return from 2nd call
9. 24 # return from 1st call
Our recursion ends when the number reduces to 1. This is called the base condition.
Every recursive function must have a base condition that stops the recursion or else
the function calls itself infinitely.
3.9.3 Advantages of Recursion
1. Recursive functions make the code look clean and elegant.
2. A complex task can be broken down into simpler sub-problems using recursion.
3. Sequence generation is easier with recursion than using some nested iteration.
3.9.4 Disadvantages of Recursion
1. Sometimes the logic behind recursion is hard to follow through.
2. Recursive calls are expensive (inefficient) as they take up a lot of memory and time.
3. Recursive functions are hard to debug.

3.10 Python Global, Local and Nonlocal variables
3.10.1 Global Variables
In Python, a variable declared outside of the function or in global scope is known as
global variable. This means, global variable can be accessed inside or outside of the
function.
Let's see an example on how a global variable is created in Python.
Example 1: Create a Global Variable
x = "global"
def foo():
print("x inside :", x)
foo()
print("x outside:", x)
When we run the code, the will output be:
x inside : global
x outside: global
In above code, we created x as a global variable and defined a foo() to print the
global variable x. Finally, we call the foo() which will print the value of x.
What if you want to change value of x inside a function?
x = "global"
def foo():
x = x * 2
print(x)
foo()
UnboundLocalError: local variable 'x' referenced before assignment
The output shows an error because Python treats x as a local variable and x is also
not defined inside foo().
To make this work we use global keyword, to learn more visit Python Global
Keyword.

3.10.2 Local Variables
A variable declared inside the function's body or in the local scope is known as local
variable.
Example 2: Accessing local variable outside the scope
def foo():
y = "local"
foo()
print(y)
NameError: name 'y' is not defined
The output shows an error, because we are trying to access a local variable y in a
global scope whereas the local variable only works inside foo() or local scope.
Let's see an example on how a local variable is created in Python.
Example 3: Create a Local Variable
Normally, we declare a variable inside the function to create a local variable.
def foo():
y = "local"
print(y)
foo()
When we run the code, it will output:
local
Let's take a look to the earlier problem where x was a global variable and we wanted
to modify x inside foo().
3.10.3 Global and local variables
Here, we will show how to use global variables and local variables in the same code.

Example 4: Using Global and Local variables in same code
x = "global"
def foo():
global x
y = "local"
x = x * 2
print(x)
print(y)
foo()
global global
local
In the above code, we declare x as a global and y as a local variable in the foo().
Then, we use multiplication operator * to modify the global variable x and we print
both x and y.
After calling the foo(), the value of x becomes global global because we used the x
* 2 to print two times global. After that, we print the value of local
variable y i.e local.
Example 5: Global variable and Local variable with same name
x = 5
def foo():
x = 10
print("local x:", x)
foo()
print("global x:", x)
local x: 10
global x: 5
In above code, we used same name x for both global variable and local variable. We
get different result when we print same variable because the variable is declared in
both scopes, i.e. the local scope inside foo() and global scope outside foo().
When we print the variable inside the foo() it outputs local x: 10, this is called local
scope of variable.
Similarly, when we print the variable outside the foo(), it outputs global x: 5, this is
called global scope of variable.
3.10.4 Nonlocal Variables

Nonlocal variable are used in nested function whose local scope is not defined. This
means, the variable can be neither in the local nor the global scope.
Let's see an example on how a global variable is created in Python.
We use nonlocal keyword to create nonlocal variable.
Example 6: Create a nonlocal variable
def outer():
x = "local"
def inner():
nonlocal x
x = "nonlocal"
print("inner:", x)
inner()
print("outer:", x)
outer()
inner: nonlocal
outer: nonlocal
In the above code there is a nested function inner(). We use nonlocal keyword to
create nonlocal variable. The inner() function is defined in the scope of another
function outer().
Note : If we change value of nonlocal variable, the changes appears in the local
variable.
3.11 Python Global Keyword
3.11.1 Introduction to global Keyword
In Python, global keyword allows you to modify the variable outside of the current
scope. It is used to create a global variable and make changes to the variable in a
local context.
Rules of global Keyword
The basic rules for global keyword in Python are:
 When we create a variable inside a function, it’s local by default.
 When we define a variable outside of a function, it’s global by default. You don’t have
to use global keyword.
 We use global keyword to read and write a global variable inside a function.

 Use of global keyword outside a function has no effect
Use of global Keyword (With Example)
Let’s take an example.
Example 1: Accessing global Variable From Inside a Function
c = 1 # global variable
def add():
print(c)
add()
When we run above program, the output will be:
1
However, we may have some scenarios where we need to modify the global variable
from inside a function.
Example 2: Modifying Global Variable From Inside the Function
def add():
c = c + 2 # increment c by 2
print(c)
add()
When we run above program, the output shows an error:
UnboundLocalError: local variable 'c' referenced before assignment
This is because we can only access the global variable but cannot modify it from
inside the function.
The solution for this is to use the global keyword.
Example 3: Changing Global Variable From Inside a Function using global

def add():
global c
c = c + 2 # increment by 2
print("Inside add():", c)
add()
print("In main:", c)
Inside add(): 2
In main: 2
In the above program, we define c as a global keyword inside the add() function.
Then, we increment the variable c by 1, i.e c = c + 2. After that, we call
the add() function. Finally, we print global variable c.
As we can see, change also occured on the global variable outside the function, c =
2.
3.11.2 Global Variables Across Python Modules
In Python, we create a single module config.py to hold global variables and share
information across Python modules within the same program.
Here is how we can share global variable across the python modules.
Example 4 : Share a global Variable Across Python Modules
Create a config.py file, to store global variables
1. a = 0
2. b = "empty"
Create a update.py file, to change global variables
1. import config
2.
3. config.a = 10
4. config.b = "alphabet"
Create a main.py file, to test changes in value
1. import config
2. import update
3.
4. print(config.a)
5. print(config.b)
When we run the main.py file, the output will be
10
alphabet
In the above, we create three files: config.py, update.py and main.py.
The module config.py stores global variables of a and b. In update.py file, we import
the config.py module and modify the values of a and b. Similarly, in main.py file we
import both config.py and update.py module. Finally, we print and test the values of
global variables whether they are changed or not.

3.11.3 Global in Nested Functions
Here is how you can use a global variable in nested function.
Example 5: Using a Global Variable in Nested Function
def foo():
x = 20
def bar():
global x
x = 25
print("Before calling bar: ", x)
print("Calling bar now")
bar()
print("After calling bar: ", x)
foo()
print("x in main : ", x)
The output is :
Before calling bar: 20
Calling bar now
After calling bar: 20
x in main : 25
In the above program, we declare global variable inside the nested function bar().
Inside foo() function, x has no effect of global keyword.
Before and after calling bar(), the variable x takes the value of local variable i.e x =
20. Outside of the foo() function, the variable x will take value defined in
the bar() function i.e x = 25. This is because we have used global keyword in x to
create global variable inside the bar() function (local scope).
If we make any changes inside the bar() function, the changes appears outside the
local scope, i.e. foo().
3.12 Python Modules
3.12.1 What are modules in Python?
Modules refer to a file containing Python statements and definitions.
A file containing Python code, for e.g.: example.py, is called a module and its module
name would be example.

We use modules to break down large programs into small manageable and
organized files. Furthermore, modules provide reusability of code.
We can define our most used functions in a module and import it, instead of copying
their definitions into different programs.
Let us create a module. Type the following and save it as example.py.
1. # Python Module example
2.
3. def add(a, b):
4. """This program adds two
5. numbers and return the result"""
6.
7. result = a + b
8. return result
Here, we have defined a function add() inside a module named example. The
function takes in two numbers and returns their sum.
3.12.2 How to import modules in Python?
We can import the definitions inside a module to another module or the interactive
interpreter in Python. We use the import keyword to do this. To import our previously
defined module example we type the following in the Python prompt.
>>> import example
This does not enter the names of the functions defined in example directly in the
current symbol table. It only enters the module name example there.
Using the module name we can access the function using the dot . operator. For
example:
>>> example.add(4,5.5)
9.5
Python has a ton of standard modules available.
You can check out the full list of Python standard modules and what they are for.
These files are in the Lib directory inside the location where you installed Python.
Standard modules can be imported the same way as we import our user-defined
modules. There are various ways to import modules. They are listed as follows.
3.12.3 Python import statement

We can import a module using import statement and access the definitions inside it
using the dot operator as described above. Here is an example.
# import statement example
# to import standard module math
import math
print("The value of pi is", math.pi)
The value of pi is 3.141592653589793
3.12.4 Import with renaming
We can import a module by renaming it as follows.
# import module by renaming it
import math as m
print("The value of pi is", m.pi)
Result:
The value of pi is 3.141592653589793
We have renamed the math module as m. This can save us typing time in some
cases.
Note that the name math is not recognized in our scope. Hence, math.pi is
invalid, m.pi is the correct implementation.
3.12.5 Python from...import statement
We can import specific names from a module without importing the module as a
whole. Here is an example.
# import only pi from math module
from math import pi
print("The value of pi is", pi)
Result:
The value of pi is 3.141592653589793
We imported only the attribute pi from the module.

In such case we don't use the dot operator. We could have imported multiple
attributes as follows.
>>> from math import pi, e
>>> pi
3.141592653589793
>>> e
2.718281828459045
3.12.6 Import all names
We can import all names(definitions) from a module using the following construct.
# import all names from the standard module math
from math import *
print("The value of pi is", pi)
Result:
The value of pi is 3.141592653589793
We imported all the definitions from the math module. This makes all names except
those beginnig with an underscore, visible in our scope.
Importing everything with the asterisk (*) symbol is not a good programming practice.
This can lead to duplicate definitions for an identifier. It also hampers the readability
of our code.
3.12.7 Python Module Search Path
While importing a module, Python looks at several places. Interpreter first looks for a
built-in module then (if not found) into a list of directories defined in sys.path. The
search is in this order.
 The current directory.
 PYTHONPATH (an environment variable with a list of directory).
 The installation-dependent default directory.
>>> import sys
>>> sys.path
['',
'C:Python33Libidlelib',
'C:Windowssystem32python33.zip','C:Python33DLLs','C:Python33lib'
,'C:Python33',
'C:Python33libsite-packages']
We can add modify this list to add our own path.

3.12.8 Reloading a module
The Python interpreter imports a module only once during a session. This makes
things more efficient. Here is an example to show how this works.
Suppose we have the following code in a module named my_module.
1. # This module shows the effect of
2. # multiple imports and reload
3.
4. print("This code got executed")
Now we see the effect of multiple imports.
>>> import my_module
This code got executed
We can see that our code got executed only once. This goes to say that our module
was imported only once.
Now if our module changed during the course of the program, we would have to
reload it.One way to do this is to restart the interpreter. But this does not help much.
Python provides a neat way of doing this. We can use the reload() function inside
the imp module to reload a module. This is how its done.
>>> import imp
>>> imp.reload(my_module)
<module 'my_module' from '.my_module.py'>
3.12.9 The dir() built-in function
We can use the dir() function to find out names that are defined inside a module.
For example, we have defined a function add() in the module example that we had in
the beginning.
>>> dir(example)
['__builtins__',
'__cached__',
'__doc__',
'__file__',
'__initializing__',
'__loader__',
'__name__',
'__package__',

'add']
Here, we can see a sorted list of names (along with add). All other names that begin
with an underscore are default Python attributes associated with the module (we did
not define them ourself).
For example, the __name__ attribute contains the name of the module.
>>> import example
>>> example.__name__
'example'
All the names defined in our current namespace can be found out using
the dir() function without any arguments.
>>> a = 1
>>> b = "hello"
>>> import math
>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'b', 'math', 'pyscripter']
3.13 Python Package
3.13.1 What are packages?
We don't usually store all of our files in our computer in the same location. We use a
well-organized hierarchy of directories for easier access.
Similar files are kept in the same directory, for example, we may keep all the songs
in the "music" directory. Analogous to this, Python has packages for directories
and modules for files.
As our application program grows larger in size with a lot of modules, we place
similar modules in one package and different modules in different packages. This
makes a project (program) easy to manage and conceptually clear.
Similar, as a directory can contain sub-directories and files, a Python package can
have sub-packages and modules.
A directory must contain a file named __init__.py in order for Python to consider it
as a package. This file can be left empty but we generally place the initialization
code for that package in this file.
Here is an example. Suppose we are developing a game, one possible organization
of packages and modules could be as shown in the figure below.

3.13.2 Importing module from a package
We can import modules from packages using the dot (.) operator.
For example, if want to import the start module in the above example, it is done as
follows.
1. import Game.Level.start
Now if this module contains a function named select_difficulty(), we must use the
full name to reference it.
1. Game.Level.start.select_difficulty(2)
If this construct seems lengthy, we can import the module without the package prefix
as follows.
1. from Game.Level import start
We can now call the function simply as follows.
1. start.select_difficulty(2)
Yet another way of importing just the required function (or class or variable) form a
module within a package would be as follows.
1. from Game.Level.start import select_difficulty
Now we can directly call this function.
1. select_difficulty(2)

Although easier, this method is not recommended. Using the full namespace avoids
confusion and prevents two same identifier names from colliding.
While importing packages, Python looks in the list of directories defined in sys.path,
similar as for module search path.

4. DATATYPES
4.1 Number Data Type in Python
Python supports integers, floating point numbers and complex numbers. They are
defined as int, float and complex class in Python. Integers and floating points are
separated by the presence or absence of a decimal point. 5 is integer whereas 5.0 is
a floating point number. Complex numbers are written in the form, x + yj, where x is
the real part and y is the imaginary part. We can use the type() function to know
which class a variable or a value belongs to and isinstance() function to check if it
belongs to a particular class.
a = 5
# Output: <class 'int'>
print(type(a))
# Output: <class 'float'>
print(type(5.0))
# Output: (8+3j)
c = 5 + 3j
print(c + 3)
# Output: True
print(isinstance(c, complex))
Result:
<class 'int'>
<class 'float'>
(8+3j)
True
While integers can be of any length, a floating point number is accurate only up to 15
decimal places (the 16th place is inaccurate).
Numbers we deal with everyday are decimal (base 10) number system. But
computer programmers (generally embedded programmer) need to work with binary
(base 2), hexadecimal (base 16) and octal (base 8) number systems.
In Python, we can represent these numbers by appropriately placing a prefix before
that number. Following table lists these prefix.
Number System Prefix
Binary '0b' or '0B'

Octal '0o' or '0O'
Hexadecimal '0x' or '0X'
Number system prefix for Python numbers
Here are some examples
# Output: 107
print(0b1101011)
# Output: 253 (251 + 2)
print(0xFB + 0b10)
# Output: 13
print(0o15)
107
253
13
4.2 Type Conversion
We can convert one type of number into another. This is also known as coercion.
Operations like addition, subtraction coerce integer to float implicitly (automatically),
if one of the operand is float.
1. >>> 1 + 2.0
2. 3.0
We can see above that 1 (integer) is coerced into 1.0 (float) for addition and the
result is also a floating point number. We can also use built-in functions
like int(), float() and complex() to convert between types explicitly. These
functions can even convert from strings.
1. >>> int(2.3)
2. 2
3. >>> int(-2.8)
4. -2
5. >>> float(5)
6. 5.0
7. >>> complex('3+5j')

8. (3+5j)
When converting from float to integer, the number gets truncated (integer that is
closer to zero).
4.2.1 Python Decimal
Python built-in class float performs some calculations that might amaze us. We all
know that the sum of 1.1 and 2.2 is 3.3, but Python seems to disagree.
1. >>> (1.1 + 2.2) == 3.3
2. False
What is going on?
It turns out that floating-point numbers are implemented in computer hardware as
binary fractions, as computer only understands binary (0 and 1). Due to this reason,
most of the decimal fractions we know, cannot be accurately stored in our computer.
Let's take an example. We cannot represent the fraction 1/3 as a decimal number.
This will give 0.33333333... which is infinitely long, and we can only approximate it.
Turns out decimal fraction 0.1 will result into an infinitely long binary fraction of
0.000110011001100110011... and our computer only stores a finite number of it.
This will only approximate 0.1 but never be equal. Hence, it is the limitation of our
computer hardware and not an error in Python.
1. >>> 1.1 + 2.2
2. 3.3000000000000003
To overcome this issue, we can use decimal module that comes with Python. While
floating point numbers have precision up to 15 decimal places, the decimal module
has user settable precision.
import decimal
# Output: 0.1
print(0.1)
#Output:
Decimal('0.1000000000000000055511151231257827021181583404541015625')
print(decimal.Decimal(0.1))
Result:
0.1

0.1000000000000000055511151231257827021181583404541015625
This module is used when we want to carry out decimal calculations like we learned
in school.
It also preserves significance. We know 25.50 kg is more accurate than 25.5 kg as it
has two significant decimal places compared to one.
from decimal import Decimal as D
# Output: Decimal('3.3')
print(D('1.1') + D('2.2'))
# Output: Decimal('3.000')
print(D('1.2') * D('2.50'))
Notice the trailing zeroes in the above example.
We might ask, why not implement Decimal every time, instead of float? The main
reason is efficiency. Floating point operations are carried out must faster than
Decimal operations.
4.2.2 When to use Decimal instead of float?
We generally use Decimal in the following cases.
 When we are making financial applications that need exact decimal representation.
 When we want to control the level of precision required.
 When we want to implement the notion of significant decimal places.
 When we want the operations to be carried out like we did at school
4.2.3 Python Fractions
Python provides operations involving fractional numbers through
its fractions module. A fraction has a numerator and a denominator, both of which
are integers. This module has support for rational number arithmetic.
We can create Fraction objects in various ways.
import fractions
# Output: 3/2
print(fractions.Fraction(1.5))
# Output: 5
print(fractions.Fraction(5))

# Output: 1/3
print(fractions.Fraction(1,3))
While creating Fraction from float, we might get some unusual results. This is due
to the imperfect binary floating point number representation as discussed in the
previous section.
Fortunately, Fraction allows us to instantiate with string as well. This is the preferred
options when using decimal numbers.
import fractions
# As float
# Output: 2476979795053773/2251799813685248
print(fractions.Fraction(1.1))
# As string
# Output: 11/10
print(fractions.Fraction('1.1'))
This datatype supports all basic operations. Here are few examples.
from fractions import Fraction as F
# Output: 2/3
print(F(1,3) + F(1,3))
# Output: 6/5
print(1 / F(5,6))
# Output: False
print(F(-3,10) > 0)
# Output: True
print(F(-3,10) < 0)
4.3 Python Mathematics
Python offers modules like math and random to carry out different mathematics like
trigonometry, logarithms, probability and statistics, etc.
# Output: 3.141592653589793
print(math.pi)
# Output: -1.0
print(math.cos(math.pi))
# Output: 22026.465794806718
print(math.exp(10))
# Output: 3.0

print(math.log10(1000))
# Output: 1.1752011936438014
print(math.sinh(1))
# Output: 720
print(math.factorial(6))
import random
# Output: 16
print(random.randrange(10,20))
x = ['a', 'b', 'c', 'd', 'e']
# Get random choice
print(random.choice(x))
# Shuffle x
random.shuffle(x)
# Print the shuffled x
print(x)
# Print random element
print(random.random())
Result:
18
e
['c', 'b', 'e', 'd', 'a']
0.03573840512568016
4.4 Python List
Python offers a range of compound datatypes often referred to as sequences. List is
one of the most frequently used and very versatile datatype used in Python.
4.4.1 How to create a list?
In Python programming, a list is created by placing all the items (elements) inside a
square bracket [ ], separated by commas. It can have any number of items and they
may be of different types (integer, float, string etc.).
1. # empty list
2. my_list = []
3.
4. # list of integers
5. my_list = [1, 2, 3]
6.

7. # list with mixed datatypes
8. my_list = [1, "Hello", 3.4]
Also, a list can even have another list as an item. This is called nested list.
# nested list
my_list = ["mouse", [8, 4, 6], ['a']]
4.4.2 How to access elements from a list?
There are various ways in which we can access the elements of a list.
List Index
We can use the index operator [] to access an item in a list. Index starts from 0. So,
a list having 5 elements will have index from 0 to 4.
Trying to access an element other that this will raise an IndexError. The index must
be an integer. We can't use float or other types, this will result into TypeError.
Nested list are accessed using nested indexing.
1. my_list = ['p','r','o','b','e']
2. # Output: p
3. print(my_list[0])
4.
5. # Output: o
7.
8. # Output: e
10.
11.# Error! Only integer can be used for indexing
12.# my_list[4.0]
13.
14.# Nested List
15.n_list = ["Happy", [2,0,1,5]]
16.
17.# Nested indexing
18.
19.# Output: a
20.print(n_list[0][1])
21.
22.# Output: 5
23.print(n_list[1][3])

Negative indexing
Python allows negative indexing for its sequences. The index of -1 refers to the last
item, -2 to the second last item and so on.
1. my_list = ['p','r','o','b','e']
2.
3. # Output: e
4. print(my_list[-1])
5.
6. # Output: p
7. print(my_list[-5])
4.4.3 How to slice lists in Python?
We can access a range of items in a list by using the slicing operator (colon).
1. my_list = ['p','r','o','g','r','a','m','i','z']
2. # elements 3rd to 5th
3. print(my_list[2:5])
4.
5. # elements beginning to 4th
6. print(my_list[:-5])
7.
8. # elements 6th to end
9. print(my_list[5:])
10.
11.# elements beginning to end
12.print(my_list[:])
Slicing can be best visualized by considering the index to be between the elements
as shown below. So if we want to access a range, we need two indices that will slice
that portion from the list.

4.4.4 How to change or add elements to a list?
List are mutable, meaning, their elements can be changed unlike string or tuple.
We can use assignment operator (=) to change an item or a range of items.
1. # mistake values
2. odd = [2, 4, 6, 8]
3.
4. # change the 1st item
5. odd[0] = 1
6.
7. # Output: [1, 4, 6, 8]
8. print(odd)
9.
10.# change 2nd to 4th items
11.odd[1:4] = [3, 5, 7]
12.
13.# Output: [1, 3, 5, 7]
14.print(odd)
We can add one item to a list using append() method or add several items
using extend() method.
1. odd = [1, 3, 5]
2.
3. odd.append(7)
4.
5. # Output: [1, 3, 5, 7]
6. print(odd)
7.
8. odd.extend([9, 11, 13])
9.
10.# Output: [1, 3, 5, 7, 9, 11, 13]
11.print(odd)
We can also use + operator to combine two lists. This is also called concatenation.
The * operator repeats a list for the given number of times.
1. odd = [1, 3, 5]
2.
3. # Output: [1, 3, 5, 9, 7, 5]
4. print(odd + [9, 7, 5])

5.
6. #Output: ["re", "re", "re"]
7. print(["re"] * 3)
Furthermore, we can insert one item at a desired location by using the
method insert() or insert multiple items by squeezing it into an empty slice of a list.
1. odd = [1, 9]
2. odd.insert(1,3)
3.
4. # Output: [1, 3, 9]
5. print(odd)
6.
7. odd[2:2] = [5, 7]
8.
9. # Output: [1, 3, 5, 7, 9]
10.print(odd)
4.4.5 How to delete or remove elements from a list?
We can delete one or more items from a list using the keyword del. It can even
delete the list entirely.
1. my_list = ['p','r','o','b','l','e','m']
2.
3. # delete one item
4. del my_list[2]
5.
6. # Output: ['p', 'r', 'b', 'l', 'e', 'm']
7. print(my_list)
8.
9. # delete multiple items
10.del my_list[1:5]
11.
12.# Output: ['p', 'm']
13.print(my_list)
14.
15.# delete entire list
16.del my_list
17.
18.# Error: List not defined
19.print(my_list)
We can use remove() method to remove the given item or pop() method to remove
an item at the given index. The pop() method removes and returns the last item if
index is not provided. This helps us implement lists as stacks (first in, last out data
structure).
We can also use the clear() method to empty a list.
1. my_list = ['p','r','o','b','l','e','m']
2. my_list.remove('p')
3.
4. # Output: ['r', 'o', 'b', 'l', 'e', 'm']
5. print(my_list)
6.
7. # Output: 'o'

8. print(my_list.pop(1))
9.
10.# Output: ['r', 'b', 'l', 'e', 'm']
11.print(my_list)
12.
13.# Output: 'm'
14.print(my_list.pop())
15.
16.# Output: ['r', 'b', 'l', 'e']
17.print(my_list)
18.
19.my_list.clear()
20.
21.# Output: []
22.print(my_list)
Finally, we can also delete items in a list by assigning an empty list to a slice of
elements.
1. >>> my_list = ['p','r','o','b','l','e','m']
2. >>> my_list[2:3] = []
3. >>> my_list
4. ['p', 'r', 'b', 'l', 'e', 'm']
5. >>> my_list[2:5] = []
6. >>> my_list
7. ['p', 'r', 'm']
4.4.6 Python List Methods
Methods that are available with list object in Python programming are tabulated
below. They are accessed as list.method(). Some of the methods have already
been used above.
Python List Methods
append() - Add an element to the end of the list
extend() - Add all elements of a list to the another list
insert() - Insert an item at the defined index
remove() - Removes an item from the list
pop() - Removes and returns an element at the given index
clear() - Removes all items from the list
index() - Returns the index of the first matched item

count() - Returns the count of number of items passed as an argument
sort() - Sort items in a list in ascending order
reverse() - Reverse the order of items in the list
copy() - Returns a shallow copy of the list
Some examples of Python list methods:
1. my_list = [3, 8, 1, 6, 0, 8, 4]
2.
3. # Output: 1
4. print(my_list.index(8))
5.
6. # Output: 2
7. print(my_list.count(8))
8.
9. my_list.sort()
10.
11.# Output: [0, 1, 3, 4, 6, 8, 8]
12.print(my_list)
13.
14.my_list.reverse()
15.
16.# Output: [8, 8, 6, 4, 3, 1, 0]
17.print(my_list)
4.4.7 List Comprehension: Elegant way to create new List
List comprehension is an elegant and concise way to create new list from an existing
list in Python. List comprehension consists of an expression followed by for
statement inside square brackets.
Here is an example to make a list with each item being increasing power of 2.
1. pow2 = [2 ** x for x in range(10)]
2.
3. # Output: [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
4. print(pow2)
This code is equivalent to
1. pow2 = []
2. for x in range(10):
3. pow2.append(2 ** x)
A list comprehension can optionally contain more for or if statements. An
optional if statement can filter out items for the new list. Here are some examples.

1. >>> pow2 = [2 ** x for x in range(10) if x > 5]
2. >>> pow2
3. [64, 128, 256, 512]
4. >>> odd = [x for x in range(20) if x % 2 == 1]
5. >>> odd
6. [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
7. >>> [x+y for x in ['Python ','C '] for y in ['Language','Programming']]
8. ['Python Language', 'Python Programming', 'C Language', 'C Programming']
4.4.8 Other List Operations in Python
List Membership Test
We can test if an item exists in a list or not, using the keyword in.
1. my_list = ['p','r','o','b','l','e','m']
2.
3. # Output: True
4. print('p' in my_list)
5.
6. # Output: False
7. print('a' in my_list)
8.
9. # Output: True
10.print('c' not in my_list)
4.4.9 Iterating Through a List
Using a for loop we can iterate though each item in a list.
1. for fruit in ['apple','banana','mango']:
2. print("I like",fruit)
4.5 Python Tuple
A tuple in Python is similar to a list. The difference between the two is that we cannot
change the elements of a tuple once it is assigned whereas, in a list, elements can
be changed.
4.5.1 Creating a Tuple
A tuple is created by placing all the items (elements) inside parentheses (),
separated by commas. The parentheses are optional, however, it is a good practice
to use them.
A tuple can have any number of items and they may be of different types (integer,
float, list, string, etc.).
# Empty tuple
my_tuple = ()

print(my_tuple) # Output: ()
# Tuple having integers
my_tuple = (1, 2, 3)
print(my_tuple) # Output: (1, 2, 3)
# tuple with mixed datatypes
my_tuple = (1, "Hello", 3.4)
print(my_tuple) # Output: (1, "Hello", 3.4)
# nested tuple
my_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
# Output: ("mouse", [8, 4, 6], (1, 2, 3))
print(my_tuple)
A tuple can also be created without using parentheses. This is known as tuple
packing.
my_tuple = 3, 4.6, "dog"
print(my_tuple) # Output: 3, 4.6, "dog"
# tuple unpacking is also possible
a, b, c = my_tuple
print(a) # 3
print(b) # 4.6
print(c) # dog
Creating a tuple with one element is a bit tricky.
Having one element within parentheses is not enough. We will need a trailing
comma to indicate that it is, in fact, a tuple.
my_tuple = ("hello")
print(type(my_tuple)) # <class 'str'>
# Creating a tuple having one element
my_tuple = ("hello",)
print(type(my_tuple)) # <class 'tuple'>
# Parentheses is optional
my_tuple = "hello",
print(type(my_tuple)) # <class 'tuple'>
Result:
<class 'str'>
<class 'tuple'>
<class 'tuple'>

4.5.2 Access Tuple Elements
There are various ways in which we can access the elements of a tuple.
1. Indexing
We can use the index operator [] to access an item in a tuple where the index starts
from 0.
So, a tuple having 6 elements will have indices from 0 to 5. Trying to access an
element outside of tuple (for example, 6, 7,...) will raise an IndexError.
The index must be an integer; so we cannot use float or other types. This will result
in TypeError.
Likewise, nested tuples are accessed using nested indexing, as shown in the
example below.
my_tuple = ('p','e','r','m','i','t')
print(my_tuple[0]) # 'p'
print(my_tuple[5]) # 't'
# IndexError: list index out of range
# print(my_tuple[6])
# Index must be an integer
# TypeError: list indices must be integers, not float
# my_tuple[2.0]
# nested tuple
n_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
# nested index
print(n_tuple[0][3]) # 's'
print(n_tuple[1][1]) # 4
2. Negative Indexing
Python allows negative indexing for its sequences. The index of -1 refers to the last
item, -2 to the second last item and so on.
my_tuple = ('p','e','r','m','i','t')
# Output: 't'
print(my_tuple[-1])
# Output: 'p'
print(my_tuple[-6])
3. Slicing

We can access a range of items in a tuple by using the slicing operator - colon ":".
my_tuple = ('p','r','o','g','r','a','m','i','z')
# elements 2nd to 4th
# Output: ('r', 'o', 'g')
print(my_tuple[1:4])
# elements beginning to 2nd
# Output: ('p', 'r')
print(my_tuple[:-7])
# elements 8th to end
# Output: ('i', 'z')
print(my_tuple[7:])
# elements beginning to end
# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
print(my_tuple[:])
as shown below. So if we want to access a range, we need the index that will slice
the portion from the tuple.
4.5.3 Changing a Tuple
Unlike lists, tuples are immutable.
This means that elements of a tuple cannot be changed once it has been assigned.
But, if the element is itself a mutable datatype like list, its nested items can be
changed.
We can also assign a tuple to different values (reassignment).
my_tuple = (4, 2, 3, [6, 5])
# TypeError: 'tuple' object does not support item assignment
# my_tuple[1] = 9

# However, item of mutable element can be changed
my_tuple[3][0] = 9 # Output: (4, 2, 3, [9, 5])
print(my_tuple)
# Tuples can be reassigned
# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
print(my_tuple)
We can use + operator to combine two tuples. This is also called concatenation.
We can also repeat the elements in a tuple for a given number of times using
the * operator.
Both + and * operations result in a new tuple.
# Concatenation
# Output: (1, 2, 3, 4, 5, 6)
print((1, 2, 3) + (4, 5, 6))
# Repeat
# Output: ('Repeat', 'Repeat', 'Repeat')
print(("Repeat",) * 3)
4.5.4 Deleting a Tuple
As discussed above, we cannot change the elements in a tuple. That also means we
cannot delete or remove items from a tuple.
But deleting a tuple entirely is possible using the keyword del.
# can't delete items
# TypeError: 'tuple' object doesn't support item deletion
# del my_tuple[3]
# Can delete an entire tuple
del my_tuple
# NameError: name 'my_tuple' is not defined
print(my_tuple)
4.5.5 Tuple Methods
Methods that add items or remove items are not available with tuple. Only the
following two methods are available.
Method Description

count(x) Returns the number of items x
index(x) Returns the index of the first item that is equal to x
Python Tuple Method
Some examples of Python tuple methods:
my_tuple = ('a','p','p','l','e',)
print(my_tuple.count('p')) # Output: 2
print(my_tuple.index('l')) # Output: 3
4.5.6 Other Tuple Operations
1. Tuple Membership Test
We can test if an item exists in a tuple or not, using the keyword in.
my_tuple = ('a','p','p','l','e',)
# In operation
# Output: True
print('a' in my_tuple)
# Output: False
print('b' in my_tuple)
# Not in operation
# Output: True
print('g' not in my_tuple)
2. Iterating Through a Tuple
Using a for loop we can iterate through each item in a tuple.
# Output:
# Hello John
# Hello Kate
for name in ('John','Kate'):
print("Hello",name)
4.5.7 Advantages of Tuple over List
Since tuples are quite similar to lists, both of them are used in similar situations as
well. However, there are certain advantages of implementing a tuple over a list.
Below listed are some of the main advantages:

 We generally use tuple for heterogeneous (different) datatypes and list for
homogeneous (similar) datatypes.
 Since tuples are immutable, iterating through tuple is faster than with list. So there is
a slight performance boost.
 Tuples that contain immutable elements can be used as a key for a dictionary. With
lists, this is not possible.
 If you have data that doesn't change, implementing it as tuple will guarantee that it
remains write-protected.
4.6 Python Strings
4.6.1 What is String in Python?
A string is a sequence of characters. A character is simply a symbol. For example,
the English language has 26 characters.
Computers do not deal with characters, they deal with numbers (binary). Even
though you may see characters on your screen, internally it is stored and
manipulated as a combination of 0's and 1's.
This conversion of character to a number is called encoding, and the reverse
process is decoding. ASCII and Unicode are some of the popular encoding used.
In Python, string is a sequence of Unicode character. Unicode was introduced to
include every character in all languages and bring uniformity in encoding.
4.6.2 How to create a string in Python?
Strings can be created by enclosing characters inside a single quote or double
quotes. Even triple quotes can be used in Python but generally used to represent
multiline strings and docstrings.
# all of the following are equivalent
my_string = 'Hello'
print(my_string)
my_string = "Hello"
print(my_string)
my_string = '''Hello'''
print(my_string)
# triple quotes string can extend multiple lines
my_string = """Hello, welcome to
the world of Python"""

print(my_string)
Hello
Hello
Hello
Hello, welcome to
the world of Python
4.6.3 How to access characters in a string?
We can access individual characters using indexing and a range of characters using
slicing. Index starts from 0. Trying to access a character out of index range will raise
an IndexError. The index must be an integer. We can't use float or other types, this
will result into TypeError.
Python allows negative indexing for its sequences.
The index of -1 refers to the last item, -2 to the second last item and so on. We can
access a range of items in a string by using the slicing operator (colon).
str = 'programiz'
print('str = ', str)
#first character
print('str[0] = ', str[0])
#last character
print('str[-1] = ', str[-1])
#slicing 2nd to 5th character
print('str[1:5] = ', str[1:5])
#slicing 6th to 2nd last character
print('str[5:-2] = ', str[5:-2])
If we try to access index out of the range or use decimal number, we will get errors.
1. # index must be in range
2. >>> my_string[15]
3. ...
4. IndexError: string index out of range
5.
6. # index must be an integer

7. >>> my_string[1.5]
8. ...
9. TypeError: string indices must be integers
as shown below. If we want to access a range, we need the index that will slice the
portion from the string.
4.6.4 How to change or delete a string?
Strings are immutable. This means that elements of a string cannot be changed
once it has been assigned. We can simply reassign different strings to the same
name.
1. >>> my_string = 'programiz'
2. >>> my_string[5] = 'a'
3. ...
4. TypeError: 'str' object does not support item assignment
5. >>> my_string = 'Python'
6. >>> my_string
7. 'Python'
We cannot delete or remove characters from a string. But deleting the string entirely
is possible using the keyword del.
1. >>> del my_string[1]
2. ...
3. TypeError: 'str' object doesn't support item deletion
4. >>> del my_string
5. >>> my_string
6. ...
7. NameError: name 'my_string' is not defined
4.6.5 Python String Operations
There are many operations that can be performed with string which makes it one of
the most used datatypes in Python.
Concatenation of Two or More Strings:

Joining of two or more strings into a single one is called concatenation.
The + operator does this in Python. Simply writing two string literals together also
concatenates them.
The * operator can be used to repeat the string for a given number of times.
str1 = 'Hello'
str2 ='World!'
# using +
print('str1 + str2 = ', str1 + str2)
# using *
print('str1 * 3 =', str1 * 3)
Writing two string literals together also concatenates them like + operator.
If we want to concatenate strings in different lines, we can use parentheses.
1. >>> # two string literals together
2. >>> 'Hello ''World!'
3. 'Hello World!'
4.
5. >>> # using parentheses
6. >>> s = ('Hello '
7. ... 'World')
8. >>> s
9. 'Hello World'
Iterating Through String:
Using for loop we can iterate through a string. Here is an example to count the
number of 'l' in a string.
count = 0
for letter in 'Hello World':
if(letter == 'l'):
count += 1
print(count,'letters found')
String Membership Test:
We can test if a sub string exists within a string or not, using the keyword in.
1. >>> 'a' in 'program'
2. True
3. >>> 'at' not in 'battle'
4. False
4.6.6 Built-in functions to Work with Python
Various built-in functions that work with sequence, works with string as well.

Some of the commonly used ones are enumerate() and len().
The enumerate() function returns an enumerate object. It contains the index and
value of all the items in the string as pairs. This can be useful for iteration.
Similarly, len() returns the length (number of characters) of the string.
str = 'cold'
# enumerate()
list_enumerate = list(enumerate(str))
print('list(enumerate(str) = ', list_enumerate)
#character count
print('len(str) = ', len(str))
Output:
list(enumerate(str) = [(0, 'c'), (1, 'o'), (2, 'l'), (3, 'd')]
len(str) = 4
4.6.7 Python String Formatting
Escape Sequence:
If we want to print a text like -He said, "What's there?"- we can neither use single
quote or double quotes. This will result into SyntaxError as the text itself contains
both single and double quotes.
1. >>> print("He said, "What's there?"")
2. ...
3. SyntaxError: invalid syntax
4. >>> print('He said, "What's there?"')
5. ...
6. SyntaxError: invalid syntax
One way to get around this problem is to use triple quotes. Alternatively, we can use
escape sequences.
An escape sequence starts with a backslash and is interpreted differently. If we use
single quote to represent a string, all the single quotes inside the string must be
escaped. Similar is the case with double quotes. Here is how it can be done to
represent the above text.
# using triple quotes
print('''He said, "What's there?"''')
# escaping single quotes
print('He said, "What's there?"')
# escaping double quotes
print("He said, "What's there?"")
Output:

He said, "What's there?"
Here is a list of all the escape sequence supported by Python.
Escape Sequence Description
newline Backslash and newline ignored
Backslash
' Single quote
" Double quote
a
ASCII Bell
b ASCII Backspace
f ASCII Formfeed
n ASCII Linefeed
r ASCII Carriage Return
t ASCII Horizontal Tab
v ASCII Vertical Tab
ooo Character with octal value ooo
xHH Character with hexadecimal value HH
Escape Sequence in Python
Here are some examples
1. >>> print("C:Python32Lib")
2. C:Python32Lib
3.
4. >>> print("This is printednin two lines")
5. This is printed
6. in two lines
7.

8. >>> print("This is x48x45x58 representation")
9. This is HEX representation
Raw String to ignore escape sequence:
Sometimes we may wish to ignore the escape sequences inside a string. To do this
we can place r or R in front of the string. This will imply that it is a raw string and any
escape sequence inside it will be ignored.
1. >>> print("This is x61 ngood example")
2. This is a
3. good example
4. >>> print(r"This is x61 ngood example")
5. This is x61 ngood example
The format() Method for Formatting Strings:
The format() method that is available with the string object is very versatile and
powerful in formatting strings. Format strings contains curly braces {} as
placeholders or replacement fields which gets replaced.
We can use positional arguments or keyword arguments to specify the order.
# default(implicit) order
default_order = "{}, {} and {}".format('John','Bill','Sean')
print('n--- Default Order ---')
print(default_order)
# order using positional argument
positional_order = "{1}, {0} and {2}".format('John','Bill','Sean')
print('n--- Positional Order ---')
print(positional_order)
# order using keyword argument
keyword_order = "{s}, {b} and {j}".format(j='John',b='Bill',s='Sean')
print('n--- Keyword Order ---')
print(keyword_order)
Output:
--- Default Order ---
John, Bill and Sean
--- Positional Order ---
Bill, John and Sean
--- Keyword Order ---
Sean, Bill and John

The format() method can have optional format specifications. They are separated
from field name using colon. For example, we can left-justify <, right-justify > or
center ^ a string in the given space. We can also format integers as binary,
hexadecimal etc. and floats can be rounded or displayed in the exponent format.
There are a ton of formatting you can use.
1. >>> # formatting integers
2. >>> "Binary representation of {0} is {0:b}".format(12)
3. 'Binary representation of 12 is 1100'
4.
5. >>> # formatting floats
6. >>> "Exponent representation: {0:e}".format(1566.345)
7. 'Exponent representation: 1.566345e+03'
8.
9. >>> # round off
10.>>> "One third is: {0:.3f}".format(1/3)
11.'One third is: 0.333'
12.
13.>>> # string alignment
14.>>> "|{:<10}|{:^10}|{:>10}|".format('butter','bread','ham')
15.'|butter | bread | ham|'
Old style formatting:
We can even format strings like the old sprintf() style used in C programming
language. We use the % operator to accomplish this.
1. >>> x = 12.3456789
4.6.8 Common Python String Methods
There are numerous methods available with the string object. The format() method
that we mentioned above is one of them. Some of the commonly used methods
are lower(), upper(), join(), split(), find(), replace() etc.
1. >>> "PrOgRaMiZ".lower()
2. 'programiz'
3. >>> "PrOgRaMiZ".upper()
4. 'PROGRAMIZ'
5. >>> "This will split all words into a list".split()
6. ['This', 'will', 'split', 'all', 'words', 'into', 'a', 'list']
7. >>> ' '.join(['This', 'will', 'join', 'all', 'words', 'into', 'a',
'string'])
8. 'This will join all words into a string'
9. >>> 'Happy New Year'.find('ew')
10.7

11.>>> 'Happy New Year'.replace('Happy','Brilliant')
12.'Brilliant New Year'
4.7 Python Sets
4.7.1 What is a set in Python?
A set is an unordered collection of items. Every element is unique (no duplicates)
and must be immutable (which cannot be changed). However, the set itself is
mutable. We can add or remove items from it. Sets can be used to perform
mathematical set operations like union, intersection, symmetric difference etc.
4.7.2 How to create a set?
A set is created by placing all the items (elements) inside curly braces {}, separated
by comma or by using the built-in function set().
It can have any number of items and they may be of different types (integer, float,
tuple, string etc.). But a set cannot have a mutable element, like list, set or dictionary,
as its element.
# set of integers
my_set = {1, 2, 3}
print(my_set)
# set of mixed datatypes
my_set = {1.0, "Hello", (1, 2, 3)}
print(my_set)
Output:
{1, 2, 3}
{'Hello', 1.0, (1, 2, 3)}
Try the following examples as well.
# set do not have duplicates
# Output: {1, 2, 3, 4}
my_set = {1,2,3,4,3,2}
print(my_set)
# set cannot have mutable items
# here [3, 4] is a mutable list
# If you uncomment line #12,
# this will cause an error.
# TypeError: unhashable type: 'list'
#my_set = {1, 2, [3, 4]}
# we can make set from a list
# Output: {1, 2, 3}
my_set = set([1,2,3,2])

print(my_set)
Creating an empty set is a bit tricky.
Empty curly braces {} will make an empty dictionary in Python. To make a set without
any elements we use the set() function without any argument.
# initialize a with {}
a = {}
# check data type of a
# Output: <class 'dict'>
print(type(a))
# initialize a with set()
a = set()
# check data type of a
# Output: <class 'set'>
print(type(a))
4.7.3 How to change a set in Python?
Sets are mutable. But since they are unordered, indexing have no meaning. We
cannot access or change an element of set using indexing or slicing. Set does not
support it.
We can add single element using the add() method and multiple elements using
the update() method. The update() method can take tuples, lists, strings or other
sets as its argument. In all cases, duplicates are avoided.
# initialize my_set
my_set = {1,3}
print(my_set)
# if you uncomment line 9,
# you will get an error
# TypeError: 'set' object does not support indexing
#my_set[0]
# add an element
# Output: {1, 2, 3}
my_set.add(2)
print(my_set)
# add multiple elements
# Output: {1, 2, 3, 4}
my_set.update([2,3,4])
print(my_set)

# add list and set
# Output: {1, 2, 3, 4, 5, 6, 8}
my_set.update([4,5], {1,6,8})
print(my_set)
{1, 3}
{1, 2, 3}
{1, 2, 3, 4}
{1, 2, 3, 4, 5, 6, 8}
4.7.4 How to remove elements from a set?
A particular item can be removed from set using methods, discard() and remove().
The only difference between the two is that, while using discard() if the item does
not exist in the set, it remains unchanged. But remove() will raise an error in such
condition.
The following example will illustrate this.
# initialize my_set
my_set = {1, 3, 4, 5, 6}
print(my_set)
# discard an element
# Output: {1, 3, 5, 6}
my_set.discard(4)
print(my_set)
# remove an element
# Output: {1, 3, 5}
my_set.remove(6)
print(my_set)
# discard an element
# not present in my_set
# Output: {1, 3, 5}
my_set.discard(2)
print(my_set)
# remove an element
# not present in my_set
# If you uncomment line 27,
# you will get an error.
# Output: KeyError: 2

#my_set.remove(2)
Similarly, we can remove and return an item using the pop() method. Set being
unordered, there is no way of determining which item will be popped. It is completely
arbitrary.
We can also remove all items from a set using clear().
# initialize my_set
# Output: set of unique elements
my_set = set("HelloWorld")
print(my_set)
# pop an element
# Output: random element
print(my_set.pop())
# pop another element
# Output: random element
my_set.pop()
print(my_set)
# clear my_set
#Output: set()
my_set.clear()
print(my_set)
Output:
{'r', 'o', 'H', 'W', 'e', 'l', 'd'}
r
{'H', 'W', 'e', 'l', 'd'}
set()
4.7.5 Python Set Operations
Sets can be used to carry out mathematical set operations like union, intersection,
difference and symmetric difference. We can do this with operators or methods.
Let us consider the following two sets for the following operations.
1. >>> A = {1, 2, 3, 4, 5}
2. >>> B = {4, 5, 6, 7, 8}
Set Union:

Union of A and B is a set of all elements from both sets.
Union is performed using | operator. Same can be accomplished using the
method union().
# initialize A and B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}
# use | operator
# Output: {1, 2, 3, 4, 5, 6, 7, 8}
print(A | B)
Set Intersection:
Intersection of A and B is a set of elements that are common in both sets.
Intersection is performed using & operator. Same can be accomplished using the
method intersection().
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# use & operator
# Output: {4, 5}
print(A & B)
Set Difference:
Difference of A and B (A - B) is a set of elements that are only in A but not in B.
Similarly, B - A is a set of element in B but not in A.
Difference is performed using - operator. Same can be accomplished using the
method difference().
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}
# use - operator on A
# Output: {1, 2, 3}
print(A - B)
Set Symmetric Difference:

Symmetric Difference of A and B is a set of elements in both A and B except those
that are common in both.
Symmetric difference is performed using ^ operator. Same can be accomplished
using the method symmetric_difference().
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}
# use ^ operator
# Output: {1, 2, 3, 6, 7, 8}
print(A ^ B)
4.7.6 Different Python Set Methods
There are many set methods, some of which we have already used above. Here is a
list of all the methods that are available with set objects.
Method Description
add() Adds an element to the set
clear() Removes all elements from the set
copy() Returns a copy of the set
difference() Returns the difference of two or more sets as a new set
difference_update() Removes all elements of another set from this set
discard()
Removes an element from the set if it is a member. (Do
nothing if the element is not in set)
intersection() Returns the intersection of two sets as a new set
intersection_update() Updates the set with the intersection of itself and another
isdisjoint() Returns True if two sets have a null intersection

issubset() Returns True if another set contains this set
issuperset() Returns True if this set contains another set
pop()
Removes and returns an arbitary set element.
Raise KeyError if the set is empty
remove()
Removes an element from the set. If the element is not a
member, raise a KeyError
symmetric_difference() Returns the symmetric difference of two sets as a new set
symmetric_difference_update()
Updates a set with the symmetric difference of itself and
another
union() Returns the union of sets in a new set
update() Updates the set with the union of itself and others
Python Set Methods
4.7.7 Other Set Operations
Set Membership Test:
We can test if an item exists in a set or not, using the keyword in.
# initialize my_set
my_set = set("apple")
# check if 'a' is present
# Output: True
print('a' in my_set)
# check if 'p' is present
# Output: False
print('p' not in my_set)
Iterating Through a Set:
Using a for loop, we can iterate though each item in a set.

1. >>> for letter in set("apple"):
2. ... print(letter)
3. ...
4. a
5. p
6. e
7. l
Built-in Functions with Set:
Built-in functions
like all(), any(), enumerate(), len(), max(), min(), sorted(), sum() etc. are
commonly used with set to perform different tasks.
Function Description
all() Return True if all elements of the set are true (or if the set is empty).
any() Return True if any element of the set is true. If the set is empty, return False.
enumerate()
Return an enumerate object. It contains the index and value of all the items of
set as a pair.
len() Return the length (the number of items) in the set.
max() Return the largest item in the set.
min() Return the smallest item in the set.
sorted() Return a new sorted list from elements in the set(does not sort the set itself).
sum() Retrun the sum of all elements in the set.
Built-in Functions with Set

4.8 Python Dictionary
4.8.1 What is dictionary in Python?
Python dictionary is an unordered collection of items. While other compound data
types have only value as an element, a dictionary has a key: value pair. Dictionaries
are optimized to retrieve values when the key is known.
4.8.2 How to create a dictionary?
Creating a dictionary is as simple as placing items inside curly braces {} separated
by comma. An item has a key and the corresponding value expressed as a pair, key:
value. While values can be of any data type and can repeat, keys must be of
immutable type (string, number or tuple with immutable elements) and must be
unique.
1. # empty dictionary
2. my_dict = {}
3.
4. # dictionary with integer keys
5. my_dict = {1: 'apple', 2: 'ball'}
6.
7. # dictionary with mixed keys
8. my_dict = {'name': 'John', 1: [2, 4, 3]}
9.
10.# using dict()
11.my_dict = dict({1:'apple', 2:'ball'})
12.
13.# from sequence having each item as a pair
14.my_dict = dict([(1,'apple'), (2,'ball')])
4.8.3 How to access elements from a dictionary?
While indexing is used with other container types to access values, dictionary uses
keys. Key can be used either inside square brackets or with the get() method.
The difference while using get() is that it returns None instead of KeyError, if the key
is not found.
my_dict = {'name':'Jack', 'age': 26}
# Output: Jack
print(my_dict['name'])
# Output: 26
print(my_dict.get('age'))
# Trying to access keys which doesn't exist throws error

# my_dict.get('address')
# my_dict['address']
4.8.4 How to change or add elements in a dictionary?
Dictionary are mutable. We can add new items or change the value of existing items
using assignment operator. If the key is already present, value gets updated, else a
new key: value pair is added to the dictionary.
my_dict = {'name':'Jack', 'age': 26}
# update value
my_dict['age'] = 27
#Output: {'age': 27, 'name': 'Jack'}
print(my_dict)
# add item
my_dict['address'] = 'Downtown'
# Output: {'address': 'Downtown', 'age': 27, 'name': 'Jack'}
print(my_dict)
4.8.5 How to delete or remove elements from a dictionary?
We can remove a particular item in a dictionary by using the method pop(). This
method removes as item with the provided key and returns the value.
The method, popitem() can be used to remove and return an arbitrary item (key,
value) form the dictionary. All the items can be removed at once using
the clear() method.
We can also use the del keyword to remove individual items or the entire dictionary
itself.
# create a dictionary
squares = {1:1, 2:4, 3:9, 4:16, 5:25}
# remove a particular item
# Output: 16
print(squares.pop(4))
# Output: {1: 1, 2: 4, 3: 9, 5: 25}
print(squares)
# remove an arbitrary item
# Output: (1, 1)
print(squares.popitem())
# Output: {2: 4, 3: 9, 5: 25}
print(squares)

# delete a particular item
del squares[5]
# Output: {2: 4, 3: 9}
print(squares)
# remove all items
squares.clear()
# Output: {}
print(squares)
# delete the dictionary itself
del squares
# Throws Error
# print(squares)
4.8.6 Python Dictionary Methods
Methods that are available with dictionary are tabulated below. Some of them have
already been used in the above examples.
Method Description
clear() Remove all items form the dictionary.
copy() Return a shallow copy of the dictionary.
fromkeys(seq[, v])
Return a new dictionary with keys from seq and value equal
to v (defaults to None).
get(key[,d]) Return the value of key. If key doesnot exit, return d (defaults to None).
items() Return a new view of the dictionary's items (key, value).
keys() Return a new view of the dictionary's keys.
pop(key[,d])
Remove the item with key and return its value or d if key is not found.
If d is not provided and key is not found, raises KeyError.
popitem()
Remove and return an arbitary item (key, value). Raises KeyError if the
dictionary is empty.
setdefault(key[,d])
If key is in the dictionary, return its value. If not, insert key with a value
of d and return d (defaults to None).

update([other])
Update the dictionary with the key/value pairs from other, overwriting
existing keys.
values() Return a new view of the dictionary's values
Python Dictionary Methods
Here are a few example use of these methods.
marks = {}.fromkeys(['Math','English','Science'], 0)
# Output: {'English': 0, 'Math': 0, 'Science': 0}
print(marks)
for item in marks.items():
print(item)
# Output: ['English', 'Math', 'Science']
list(sorted(marks.keys()))

5. Python Object Oriented Programming
5.1 Introduction to OOPs in Python
Python is a multi-paradigm programming language. Meaning, it supports different
programming approach.
One of the popular approach to solve a programming problem is by creating objects.
This is known as Object-Oriented Programming (OOP).
An object has two characteristics:
 attributes
 behavior
Let's take an example:
Parrot is an object,
 name, age, color are attributes
 singing, dancing are behavior
The concept of OOP in Python focuses on creating reusable code. This concept is
also known as DRY (Don't Repeat Yourself).
In Python, the concept of OOP follows some basic principles:
Inheritance
A process of using details from a new class without modifying
existing class.
Encapsulation Hiding the private details of a class from other objects.
Polymorphism
A concept of using common operation in different ways for different
data input.
5.2 Class
A class is a blueprint for the object.
We can think of class as an sketch of a parrot with labels. It contains all the details
about the name, colors, size etc. Based on these descriptions, we can study about
the parrot. Here, parrot is an object.
The example for class of parrot can be :

class Parrot:
pass
Here, we use class keyword to define an empty class Parrot. From class, we
construct instances. An instance is a specific object created from a particular class.
5.3 Object
An object (instance) is an instantiation of a class. When class is defined, only the
description for the object is defined. Therefore, no memory or storage is allocated.
The example for object of parrot class can be:
obj = Parrot()
Here, obj is object of class Parrot.
Suppose we have details of parrot. Now, we are going to show how to build the class
and objects of parrot.
Example 1: Creating Class and Object in Python
class Parrot:
# class attribute
species = "bird"
# instance attribute
def __init__(self, name, age):
self.name = name
self.age = age
# instantiate the Parrot class
blu = Parrot("Blu", 10)
woo = Parrot("Woo", 15)
# access the class attributes
print("Blu is a {}".format(blu.__class__.species))
print("Woo is also a {}".format(woo.__class__.species))
# access the instance attributes
print("{} is {} years old".format( blu.name, blu.age))
print("{} is {} years old".format( woo.name, woo.age))
When we run the program, the output will be:

Blu is a bird
Woo is also a bird
Blu is 10 years old
Woo is 15 years old
In the above program, we create a class with name Parrot. Then, we define
attributes. The attributes are a characteristic of an object.
Then, we create instances of the Parrot class. Here, blu and woo are references
(value) to our new objects.
Then, we access the class attribute using __class __.species. Class attributes are
same for all instances of a class. Similarly, we access the instance attributes
using blu.name and blu.age. However, instance attributes are different for every
instance of a class.
5.4 Methods
Methods are functions defined inside the body of a class. They are used to define
the behaviors of an object.
Example 2 : Creating Methods in Python
class Parrot:
# instance attributes
def __init__(self, name, age):
self.name = name
self.age = age
# instance method
def sing(self, song):
return "{} sings {}".format(self.name, song)
def dance(self):
return "{} is now dancing".format(self.name)
# instantiate the object
blu = Parrot("Blu", 10)
# call our instance methods
print(blu.sing("'Happy'"))
print(blu.dance())
When we run program, the output will be:
Blu sings 'Happy'
Blu is now dancing

In the above program, we define two methods i.e sing() and dance(). These are
called instance method because they are called on an instance object i.e blu.
5.5 Inheritance
Inheritance is a way of creating new class for using details of existing class without
modifying it. The newly formed class is a derived class (or child class). Similarly, the
existing class is a base class (or parent class).
Example 3: Use of Inheritance in Python
# parent class
class Bird:
def __init__(self):
print("Bird is ready")
def whoisThis(self):
print("Bird")
def swim(self):
print("Swim faster")
# child class
class Penguin(Bird):
def __init__(self):
# call super() function
super().__init__()
print("Penguin is ready")
def whoisThis(self):
print("Penguin")
def run(self):
print("Run faster")
peggy = Penguin()
peggy.whoisThis()
peggy.swim()
peggy.run()
When we run this program, the output will be:
Bird is ready
Penguin is ready
Penguin
Swim faster

Run faster
In the above program, we created two classes i.e. Bird (parent class)
and Penguin (child class). The child class inherits the functions of parent class. We
can see this from swim() method. Again, the child class modified the behavior of
parent class. We can see this from whoisThis() method. Furthermore, we extend the
functions of parent class, by creating a new run() method.
Additionally, we use super() function before __init__() method. This is because we
want to pull the content of __init__() method from the parent class into the child
class.
5.6 Encapsulation
Using OOP in Python, we can restrict access to methods and variables. This prevent
data from direct modification which is called encapsulation. In Python, we denote
private attribute using underscore as prefix i.e single “ _ “ or double “ __“.
Example 4: Data Encapsulation in Python
class Computer:
def __init__(self):
self.__maxprice = 900
def sell(self):
print("Selling Price: {}".format(self.__maxprice))
def setMaxPrice(self, price):
self.__maxprice = price
c = Computer()
c.sell()
# change the price
c.__maxprice = 1000
c.sell()
# using setter function
c.setMaxPrice(1000)
c.sell()
When we run this program, the output will be:
Selling Price: 900
Selling Price: 900
Selling Price: 1000

In the above program, we defined a class Computer. We use __init__() method to
store the maximum selling price of computer. We tried to modify the price. However,
we can’t change it because Python treats the __maxprice as private attributes. To
change the value, we used a setter function i.e setMaxPrice() which takes price as
parameter.
5.7 Polymorphism
Polymorphism is an ability (in OOP) to use common interface for multiple form (data
types).
Suppose, we need to color a shape, there are multiple shape option (rectangle,
square, circle). However we could use same method to color any shape. This
concept is called Polymorphism.
Example 5: Using Polymorphism in Python
class Parrot:
def fly(self):
print("Parrot can fly")
def swim(self):
print("Parrot can't swim")
class Penguin:
def fly(self):
print("Penguin can't fly")
def swim(self):
print("Penguin can swim")
# common interface
def flying_test(bird):
bird.fly()
#instantiate objects
blu = Parrot()
peggy = Penguin()
# passing the object
flying_test(blu)
flying_test(peggy)
Parrot can fly
Penguin can't fly

In the above program, we defined two classes Parrot and Penguin. Each of them
have common method fly() method. However, their functions are different. To allow
polymorphism, we created common interface i.e flying_test() function that can take
any object. Then, we passed the objects blu and peggy in the flying_test() function,
it ran effectively.
Key Points to Remember:
 The programming gets easy and efficient.
 The class is sharable, so codes can be reused.
 The productivity of programmars increases
 Data is safe and secure with data abstraction.
5.8 Python Objects and Class
5.8.1 What are classes and objects in Python?
Python is an object oriented programming language. Unlike procedure oriented
programming, where the main emphasis is on functions, object oriented
programming stress on objects.
Object is simply a collection of data (variables) and methods (functions) that act on
those data. And, class is a blueprint for the object.
We can think of class as a sketch (prototype) of a house. It contains all the details
about the floors, doors, windows etc. Based on these descriptions we build the
house. House is the object.
As, many houses can be made from a description, we can create many objects from
a class. An object is also called an instance of a class and the process of creating
this object is called instantiation.
5.8.2 Defining a Class in Python
Like function definitions begin with the keyword def, in Python, we define a class
using the keyword class.
The first string is called docstring and has a brief description about the class.
Although not mandatory, this is recommended.
Here is a simple class definition.
1. class MyNewClass:
2. '''This is a docstring. I have created a new class'''
3. pass
A class creates a new local namespace where all its attributes are defined. Attributes
may be data or functions.

There are also special attributes in it that begins with double underscores (__). For
example, __doc__ gives us the docstring of that class.
As soon as we define a class, a new class object is created with the same name.
This class object allows us to access the different attributes as well as to instantiate
new objects of that class.
class MyClass:
"This is my second class"
a = 10
def func(self):
print('Hello')
# Output: 10
print(MyClass.a)
# Output: <function MyClass.func at 0x0000000003079BF8>
print(MyClass.func)
# Output: 'This is my second class'
print(MyClass.__doc__)
10
<function 0x7feaa932eae8="" at="" myclass.func="">
This is my second class
5.8.3 Creating an Object in Python
We saw that the class object could be used to access different attributes.
It can also be used to create new object instances (instantiation) of that class. The
procedure to create an object is similar to a function call.
1. >>> ob = MyClass()
This will create a new instance object named ob. We can access attributes of objects
using the object name prefix.
Attributes may be data or method. Method of an object are corresponding functions
of that class. Any function object that is a class attribute defines a method for objects
of that class.
This means to say, since MyClass.func is a function object (attribute of
class), ob.func will be a method object.

class MyClass:
"This is my second class"
a = 10
def func(self):
print('Hello')
# create a new MyClass
ob = MyClass()
# Output: <function MyClass.func at 0x000000000335B0D0>
print(MyClass.func)
# Output: <bound method MyClass.func of <__main__.MyClass object at
0x000000000332DEF0>>
print(ob.func)
# Calling function func()
# Output: Hello
ob.func()
You may have noticed the self parameter in function definition inside the class but,
we called the method simply as ob.func() without any arguments. It still worked.
This is because, whenever an object calls its method, the object itself is passed as
the first argument. So, ob.func() translates into MyClass.func(ob).
In general, calling a method with a list of n arguments is equivalent to calling the
corresponding function with an argument list that is created by inserting the method's
object before the first argument.
For these reasons, the first argument of the function in class must be the object
itself. This is conventionally called self. It can be named otherwise but we highly
recommend to follow the convention.
Now you must be familiar with class object, instance object, function object, method
object and their differences.
5.9 Constructors in Python
Class functions that begins with double underscore (__) are called special functions
as they have special meaning.
Of one particular interest is the __init__() function. This special function gets called
whenever a new object of that class is instantiated.
This type of function is also called constructors in Object Oriented Programming
(OOP). We normally use it to initialize all the variables.
class ComplexNumber:
def __init__(self,r = 0,i = 0):

self.real = r
self.imag = i
def getData(self):
print("{0}+{1}j".format(self.real,self.imag))
# Create a new ComplexNumber object
c1 = ComplexNumber(2,3)
# Call getData() function
# Output: 2+3j
c1.getData()
# Create another ComplexNumber object
# and create a new attribute 'attr'
c2 = ComplexNumber(5)
c2.attr = 10
# Output: (5, 0, 10)
print((c2.real, c2.imag, c2.attr))
# but c1 object doesn't have attribute 'attr'
# AttributeError: 'ComplexNumber' object has no attribute 'attr'
c1.attr
In the above example, we define a new class to represent complex numbers. It has
two functions, __init__() to initialize the variables (defaults to zero) and getData() to
display the number properly.
An interesting thing to note in the above step is that attributes of an object can be
created on the fly. We created a new attribute attr for object c2 and we read it as
well. But this did not create that attribute for object c1.
5.10 Deleting Attributes and Objects
Any attribute of an object can be deleted anytime, using the del statement. Try the
following on the Python shell to see the output.
1. >>> c1 = ComplexNumber(2,3)
2. >>> del c1.imag
3. >>> c1.getData()
5. ...
6. AttributeError: 'ComplexNumber' object has no attribute 'imag'
7.
8. >>> del ComplexNumber.getData
9. >>> c1.getData()
10.Traceback (most recent call last):
11....

12.AttributeError: 'ComplexNumber' object has no attribute 'getData'
We can even delete the object itself, using the del statement.
1. >>> c1 = ComplexNumber(1,3)
2. >>> del c1
3. >>> c1
5. ...
6. NameError: name 'c1' is not defined
Actually, it is more complicated than that. When we do c1 = ComplexNumber(1,3), a
new instance object is created in memory and the name c1 binds with it.
On the command del c1, this binding is removed and the name c1 is deleted from the
corresponding namespace. The object however continues to exist in memory and if
no other name is bound to it, it is later automatically destroyed.
This automatic destruction of unreferenced objects in Python is also called garbage
collection.
5.11 Python Inheritance
What is Inheritance?
Inheritance is a powerful feature in object oriented programming.
It refers to defining a new class with little or no modification to an existing class. The
new class is called derived (or child) class and the one from which it inherits is
called the base (or parent) class.
Python Inheritance Syntax
class BaseClass:
Body of base class
class DerivedClass(BaseClass):

Body of derived class
Derived class inherits features from the base class, adding new features to it. This
results into re-usability of code.
Example of Inheritance in Python
To demonstrate the use of inheritance, let us take an example.
A polygon is a closed figure with 3 or more sides. Say, we have a class
called Polygon defined as follows.
1. class Polygon:
2. def __init__(self, no_of_sides):
3. self.n = no_of_sides
4. self.sides = [0 for i in range(no_of_sides)]
5.
6. def inputSides(self):
7. self.sides = [float(input("Enter side "+str(i+1)+" : ")) for i in
range(self.n)]
8.
9. def dispSides(self):
10. for i in range(self.n):
11. print("Side",i+1,"is",self.sides[i])
This class has data attributes to store the number of sides, n and magnitude of each
side as a list, sides.
Method inputSides() takes in magnitude of each side and similarly, dispSides() will
display these properly.
A triangle is a polygon with 3 sides. So, we can created a class
called Triangle which inherits from Polygon. This makes all the attributes available in
class Polygon readily available in Triangle. We don't need to define them again
(code re-usability). Triangle is defined as follows.
1. class Triangle(Polygon):
2. def __init__(self):
3. Polygon.__init__(self,3)
4.
5. def findArea(self):
6. a, b, c = self.sides
7. # calculate the semi-perimeter
8. s = (a + b + c) / 2
9. area = (s*(s-a)*(s-b)*(s-c)) ** 0.5
10. print('The area of the triangle is %0.2f' %area)
However, class Triangle has a new method findArea() to find and print the area of
the triangle. Here is a sample run.
1. >>> t = Triangle()
2.
3. >>> t.inputSides()
4. Enter side 1 : 3
5. Enter side 2 : 5
6. Enter side 3 : 4

7.
8. >>> t.dispSides()
9. Side 1 is 3.0
10.Side 2 is 5.0
11.Side 3 is 4.0
12.
13.>>> t.findArea()
14.The area of the triangle is 6.00
We can see that, even though we did not define methods
like inputSides() or dispSides() for class Triangle, we were able to use them.
If an attribute is not found in the class, search continues to the base class. This
repeats recursively, if the base class is itself derived from other classes.

For more information contact:
amarjeetsinght@gmail.com
linkedin.com/in/amarjeetsingh-thakur-54915955
Mob: +91-9035508516

Core python programming tutorial

More Related Content

What's hot (20)

Similar to Core python programming tutorial (20)

More from Amarjeetsingh Thakur (20)

Recently uploaded (20)

Core python programming tutorial