Session 1

PYTHON
Introduction
 Introduction
• Python is an easy to learn, powerful programming language. It
has efficient high-level data structures and a simple but
effective approach to object-oriented programming.
• Python’s elegant syntax and dynamic typing, together with its
interpreted nature, make it an ideal language for scripting and
rapid application development in many areas on most
platforms.
• The Python interpreter and the extensive standard library are
freely available in source or binary form for all major
platforms from the Python Web site, 
https://www.python.org/, and may be freely distributed.
• The Python interpreter is easily extended with new functions
and data types implemented in C or C++ (or other languages
callable from C).
What is Python (Programming)? - The Basics

• Python is a general-purpose language. It has wide range of

applications from Web development (like: Django and Bottle),
scientific and mathematical computing (Orange, SymPy,
NumPy) to desktop graphical user Interfaces (Pygame,
Panda3D).
• The syntax of the language is clean and length of the code is
relatively short.
• It's fun to work in Python because it allows you to think about
the problem rather than focusing on the syntax.
 History of Python
• Python is a fairly old language created by Guido Van Rossum.
The design began in the late 1980s and was first released in
February 1991.

Why Python was created?

• In late 1980s, Guido Van Rossum was working on the Amoeba
distributed operating system group. He wanted to use an
interpreted language like ABC (ABC has simple easy-to-
understand syntax) that could access the Amoeba system
calls.
• So, he decided to create a language that was extensible. This
led to design of a new language which was later named
Python.
 Why the name Python?
• No. It wasn't named after a dangerous snake. Rossum was fan
of a comedy series from late seventies. The name "Python"
was adopted from the same series "Monty Python's Flying
Circus".
• Release Dates of Different Versions
Version Release Data
Python 1.0 (first standard release) January 1994
Python 1.6 (Last minor version) September 5, 2000
Python 2.0 (Introduced list
October 16, 2000
comprehensions) July 3, 2010
Python 2.7 (Last minor version)
Python 3.0 (Emphasis on removing
December 3, 2008
duplicative constructs and module)
September 13, 2015
Python 3.5
Python 3.8.1 Latest updated version in 2019
 Reason for increasing popularity
• Emphasis on code readability, shorter codes, ease of writing
• Programmers can express logical concepts in fewer lines of
code in comparison to languages such as C++ or Java.
• Python supports multiple programming paradigms, like
object-oriented, imperative and functional programming or
procedural.
• There exists inbuilt functions for almost all of the frequently
used concepts.
• Philosophy is “Simplicity is the best”.
 Features of Python Programming
A simple language which is easier to learn
• Python has a very simple and elegant syntax. It's much easier
to read and write Python programs compared to other
languages like: C++, Java, C#. Python makes programming fun
and allows you to focus on the solution rather than syntax.
If you are a newbie, it's a great choice to start your journey
with Python.
Free and open-source
• You can freely use and distribute Python, even for commercial
use. Not only can you use and distribute softwares written in
it, you can even make changes to the Python's source code.
Python has a large community constantly improving it in each
iteration.
Portability
• You can move Python programs from one platform to another,
and run it without any changes.
It runs seamlessly on almost all platforms including Windows,
Mac OS X and Linux.
Extensible and Embeddable
• Suppose an application requires high performance. You can
easily combine pieces of C/C++ or other languages with
Python code.
This will give your application high performance as well as
scripting capabilities which other languages may not provide
out of the box.
A high-level, interpreted language
• Unlike C/C++, you don't have to worry about daunting tasks like
memory management, garbage collection and so on.
Likewise, when you run Python code, it automatically converts
your code to the language your computer understands. You
don't need to worry about any lower-level operations.
Large standard libraries to solve common tasks
• Python has a number of standard libraries which makes life of a
programmer much easier since you don't have to write all the
code yourself. For example: Need to connect MySQL database
on a Web server? You can use MySQLdb library using import
MySQLdb .
Standard libraries in Python are well tested and used by
hundreds of people. So you can be sure that it won't break
your application.
Object-oriented
• Everything in Python is an object. Object oriented
programming (OOP) helps you solve a complex problem
intuitively.
With OOP, you are able to divide these complex problems into
smaller sets by creating objects.
Python is a Beginner's Language 
• Python is a great language for the beginner-level
programmers and supports the development of a wide range
of applications from simple text processing to WWW browsers
to games.
 Applications of Python
Web Applications
• You can create scalable Web Apps using frameworks and CMS
(Content Management System) that are built on Python. Some
of the popular platforms for creating Web Apps are: Django,
Flask, Pyramid, Plone, Django CMS.
• Sites like Mozilla, Reddit, Instagram and PBS are written in
Python.
Scientific and Numeric Computing
• There are numerous libraries available in Python for scientific
and numeric computing. There are libraries like: SciPy and
NumPy that are used in general purpose computing. And, there
are specific libraries like: EarthPy for earth science, AstroPy for
Astronomy and so on.
• Also, the language is heavily used in machine learning, data
mining and deep learning.
Creating software Prototypes
• Python is slow compared to compiled languages like C++ and
Java. It might not be a good choice if resources are limited
and efficiency is a must.
• However, Python is a great language for creating prototypes.
For example: You can use Pygame (library for creating games)
to create your game's prototype first. If you like the
prototype, you can use language like C++ to create the actual
game.
Good Language to Teach Programming
• Python is used by many companies to teach programming to
kids and newbies.
• It is a good language with a lot of features and capabilities.
Yet, it's one of the easiest language to learn because of its
simple easy-to-use syntax.
Pros:
• Ease of use
• Multi-paradigm Approach
Cons:
• Slow speed of execution compared to C,C++
• Absence from mobile computing and browsers
• For the C,C++ programmers switching to python can be
irritating as the language requires proper indentation of code.
Certain variable names commonly used like sum are functions
in python. So C, C++ programmers have to look out for these.
 Advantages
1. Presence of third-party modules
2. Extensive support libraries(NumPy for numerical calculations,
Pandas for data analytics etc)
3. Open source and community development
4. Easy to learn
5. User-friendly data structures
6. High-level language
7. Dynamically typed language(No need to mention data type
based on value assigned, it takes data type)
8. Object-oriented language
9. Portable and Interactive
10. Portable across Operating systems
 Organizations using Python
1) Google (Components of Google spider and Search
Engine)
2) Yahoo(Maps)
3) YouTube
4) Mozilla
5) Dropbox
6) Microsoft
7) Cisco
8) Spotify
9) Quora
 Python – Fastest Growing Programming
Language
• There was a time when the word “Python” meant a
particularly large snake but now it is a programming language
that is all the rage!!! According to the TIOBE Index, Python is
the fourth most popular programming language in the world
currently and this extraordinary growth is only set to increase
as observed by Stack Overflow Trends. So the question
arises…Why is Python the Fastest Growing Programming
Language?
• Well, there are many factors that contribute to the success of
Python. One of these is its popularity in web development.
Many top companies such as Google, Facebook, Mozilla,
Quora, etc. use Python Web Framework. Another well-known
factor for the rapid growth of Python is its use in Data
Science.
 Hello World using Python.
• print ("Hello, Python!");
Interactive Mode Programming
• Invoking the interpreter without passing a script file as a
parameter brings up the following prompt −

Script Mode Programming

• Invoking the interpreter with a script parameter begins
execution of the script and continues until the script is
finished. When the script is finished, the interpreter is no
longer active.
 Python Keywords and Identifier,
Python Statement, Indentation and Comments
 Python Keywords
• Keywords are the reserved words in Python.
• We cannot use a keyword as variable name, function name or
any other identifier. They are used to define the syntax and
structure of the Python language.
• In Python, keywords are case sensitive.
• There are 33 keywords in Python 3. This number can vary
slightly in course of time.
• All the keywords except True, False and None are in lowercase
and they must be written as it is. The list of all the keywords
are given below.
Keywords in Python programming language

False class finally is return

None continue for lambda try

True def from nonlocal while

and del global not with

as elif if or yield
assert else import pass  
break except in raise
 Python Identifiers
• Identifier is the name given to entities like class, functions, variables
etc. in Python. It helps differentiating one entity from another.
Rules for writing identifiers
1. Identifiers can be a combination of letters in lowercase (a to z) or
uppercase (A to Z) or digits (0 to 9) or an underscore (_). Names
like myClass, var_1 and print_this_to_screen, all are valid example.
2. An identifier cannot start with a digit. 1variable is invalid,
but variable1 is perfectly fine.
3. Keywords cannot be used as identifiers.
4. We cannot use special symbols like !, @, #, $, % etc. in our identifier.
5. Identifier can be of any length.
 Things to care about
• Python is a case-sensitive language. This means, Variable and
variable are not the same. Always name identifiers that make
sense.
• While, c = 10 is valid. Writing count = 10 would make more
sense and it would be easier to figure out what it does even
when you look at your code after a long gap.
• Multiple words can be separated using an underscore,
this_is_a_long_variable.
• We can also use camel-case style of writing, i.e., capitalize
every first letter of the word except the initial word without
any spaces. For example: camelCaseExample
 Python Statement
• Instructions that a Python interpreter can execute are called statements.
For example, a = 1 is an assignment
statement. if statement, for statement, while statement etc. are other
kinds of statements which will be discussed later.
• Multi-line statement
• In Python, end of a statement is marked by a newline character. But we
can make a statement extend over multiple lines with the line
continuation character (\). For example:
a=1+2+3+\
4+5+6+\
7+8+9
• This is explicit line continuation. In Python, line continuation is implied
inside parentheses ( ), brackets [ ] and braces { }. For instance, we can
implement the above multi-line statement as
a = (1 + 2 + 3 +
4+5+6+
7 + 8 + 9)
• Here, the surrounding parentheses ( ) do the line continuation
implicitly. Same is the case with [ ] and { }. For example:
• colors = ['red',
'blue',
'green']
• We could also put multiple statements in a single line using
semicolons, as follows
a = 1; b = 2; c = 3
 Python Indentation
• Most of the programming languages like C, C++, Java use braces { }
to define a block of code. Python uses indentation.
• A code block (body of a function, loop etc.) starts with indentation
and ends with the first unindented line. The amount of indentation
is up to you, but it must be consistent throughout that block.
• Generally four whitespaces are used for indentation and is
preferred over tabs. Here is an example.
for i in range(1,11):
print(i)
if i == 5:
break
• The enforcement of indentation in Python makes the code
look neat and clean. This results into Python programs that
look similar and consistent.
• Indentation can be ignored in line continuation. But it's a good
idea to always indent. It makes the code more readable. For
example:
if True:
print('Hello')
a=5
And
if True: print('Hello'); a = 5
• both are valid and do the same thing. But the former style is
clearer.
• Incorrect indentation will result into IndentationError.
 Python Comments
• Comments are very important while writing a program. It
describes what's going on inside a program so that a person
looking at the source code does not have a hard time figuring it
out.
• You might forget the key details of the program you just wrote in a
month's time. So taking time to explain these concepts in form of
comments is always fruitful.
• In Python, we use the hash (#) symbol to start writing a comment.
• It extends up to the newline character. Comments are for
programmers for better understanding of a program. Python
Interpreter ignores comment. 
#This is a comment
#print out Hello
print('Hello')
 Multi-line comments
• If we have comments that extend multiple lines, one way of
doing it is to use hash (#) in the beginning of each line. For
example:
#This is a long comment
#and it extends
#to multiple lines
• Another way of doing this is to use triple quotes,
either ''' or """.
• These triple quotes are generally used for multi-line strings.
But they can be used as multi-line comment as well. Unless
they are not docstrings, they do not generate any extra code.
"""This is also a
perfect example of
multi-line comments"""
 Docstring in Python
• Docstring is short for documentation string.
• It is a string that occurs as the first statement in a module,
function, class, or method definition. We must write what a
function/class does in the docstring.
• Triple quotes are used while writing docstrings. For example:
def double(num):
"""Function to double the value"""
return 2*num
• Docstring is available to us as the attribute __doc__ of the
function. Issue the following code in shell once you run the
above program.
• >>> print(double.__doc__)
• Function to double the value
Python Variables, Constants and Literals
 Variable
• In most of the programming languages a variable is a named
location used to store data in the memory. Each variable must
have a unique name called identifier. It is helpful to think
of variables as container that hold data which can be changed
later throughout programming.
• Non technically, you can suppose variable as a bag to store
books in it and those books can be replaced at anytime.
• Note: In Python we don't assign values to the variables,
whereas Python gives the reference of the object (value) to
the variable.
 Declaring Variables in Python
• In Python, variables do not need declaration to reserve memory
space. The "variable declaration" or "variable initialization"
happens automatically when we assign a value to a variable.
• Assigning value to a Variable in Python
• You can use the assignment operator = to assign the value to a
variable.
website = "Apple.com“
print(website)
• When you run the program, the output will be:
Apple.com
• Note : Python is a type inferred language, it can automatically
infer (know) Apple.com is a String and declare website as a
String.
• 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)
 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.
• 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.
Declaring and assigning value to a constant

• Create a constant.py
PI = 3.14
GRAVITY = 9.8
• Create a main.py
import constant
print(constant.PI)
print(constant.GRAVITY)
• When you run the program, the output will be:
3.14
9.8
• 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
• Create a name that makes sense. Suppose, vowel makes more sense
than v.
• Use camelCase notation to declare a variable. It starts with lowercase
letter. For example:
myName myAge myAddress
• Use capital letters where possible to declare a constant. For example:
PI G MASS TEMP
• Never use special symbols like !, @, #, $, %, etc.
• Don't start name with a digit.
• Constants are put into Python modules and meant not be changed.
• 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
 Literals
• Literal is a raw data given in a variable or constant. In Python, there are
various types of literals they are as follows:
• Numeric Literals
• Numeric Literals are immutable (unchangeable). Numeric literals can
belong to 3 different numerical types Integer, Float and Complex.
• For e.g.
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)

• When you run the program, the output will be:

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.
 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: 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"\u00dcnic\u00f6de“
raw_str = r"raw \n string“
print(strings)
print(char)
print(multiline_str)
print(unicode)
print(raw_str)
• When you run the program, the output will be:
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"\u00dcnic\u00f6de" is a unicode literal which supports
characters other than English and r"raw \n string" is a raw string literal.
 Boolean literals
• A Boolean literal can have any of the two values: True or False.
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)
• When you run the program, the output will be:
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 True which has value
of 1 with 4.
• Similarly, b is 10 because we add the False having value
of 0 with 10.
 Special literals
• Python contains one special literal i.e. None. We use it to
specify to that field that is not created.
drink = "Available“
food = None

def menu(x):
if x == drink:
print(drink)
else:
print(food)
menu(drink)
menu(food)
• When you run the program, the output will be:
Available
None
 Literal Collections
• There are four different literal collections List literals, Tuple
literals, Dict literals, and Set literals.
• Example: 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)
• When you run the program, the output will be:
• ['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
designated to each value and set of vowels.
Python Data Types
 Data types in Python
• Every value in Python has a datatype. 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.
• >>> a = 1234567890123456789
• >>> a 1234567890123456789
• >>> b = 0.1234567890123456789
• >>> b 0.12345678901234568
• >>> c = 1+2j
• >>> c (1+2j)
 Boolean
• Data with one of two built-in values True or False.
• Notice that 'T' and 'F' are capital. true and false are not valid
booleans and Python will throw an error for them.
 Sequence Type
• A sequence is an ordered collection of similar or different data
types. Python has the following built-in sequence data types:
• String: A string value is a collection of one or more characters
put in single, double or triple quotes.
• List : A list object is an ordered collection of one or more data
items, not necessarily of the same type, put in square
brackets.
• Tuple: A Tuple object is an ordered collection of one or more
data items, not necessarily of the same type, put in
parentheses.
 Python List
• List is an ordered sequence of items. It is one of the most used
datatype 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 [ ].
• >>> 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.
>>> a = [1,2,3]
>>> a[2]=4
>>> a [1, 2, 4]
 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.
• >>> t = (5,'program', 1+3j)
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
 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 """.
• >>> s = "This is a string"
• >>> 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'
 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.
• >>> a = {1,2,2,3,3,3}
• >>> a {1, 2, 3}
• Since, set are unordered collection, indexing has no meaning.
Hence the slicing operator [] does not work.
• >>> a = {1,2,3}
• >>> a[1]
Traceback (most recent call last):
File "<string>", line 301, in runcode
File "<interactive input>", line 1, in <module>
TypeError: 'set' object does not support indexing
 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.
• >>> d = {1:'value','key':2}
• >>> type(d)
• <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]);
 Conversion between data types
• We can convert between different data types by using different type conversion
functions like int(), float(), str() etc.
• >>> float(5)
• 5.0
• Conversion from float to int will truncate the value (make it closer to zero).
• >>> int(10.6) 10
• >>> int(-10.6) -10
• Conversion to and from string must contain compatible values.
>>> float('2.5')
2.5
>>> str(25)
'25'
>>> int('1p')
Taceback (most recent call last):
File "<string>", line 301, in runcode
File "<interactive input>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '1p'
• We can even convert one sequence to another.
>>> set([1,2,3])
{1, 2, 3}
>>> tuple({5,6,7})
(5, 6, 7)
>>> list('hello')
['h', 'e', 'l', 'l', 'o']
• To convert to dictionary, each element must be a pair
>>> dict([[1,2],[3,4]])
{1: 2, 3: 4}
>>> dict([(3,26),(4,44)])
{3: 26, 4: 44}
Python Type Conversion and Type Casting
• 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.
• Implicit Type Conversion
• 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
datatype (integer) to higher data type (float) to avoid data loss.
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'>
• In the above program,
• 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 datatype of num_int is an integer,
datatype 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.
 Example: Addition of string(higher) data
type and integer(lower) datatype
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)
• When we run the above program, the output will be
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'
• In the above program,
• We add two variable num_int and num_str.
• As we can see from the output, we got typeerror. 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: 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))
• When we run the above program, the output will be
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:
• Type Conversion is the conversion of object from one data
type to another data type.
• Implicit Type Conversion is automatically performed by the
Python interpreter.
• Python avoids the loss of data in Implicit Type Conversion.
• Explicit Type Conversion is also called Type Casting, the data
types of object are converted using predefined function by
user.
• In Type Casting loss of data may occur as we enforce the
object to specific data type.
Python Input, Output and Import
 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.
 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.
>>> x = 5; y = 10
>>> print('The value of x is {} and y is {}'.format(x,y))
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.
• >>> print('Hello {name}, {greeting}'.format(greeting =
'Goodmorning', name = 'John')) 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.
• >>> x = 12.3456789
• >>> print('The value of x is %3.2f' %x)
• The value of x is 12.35
• >>> print('The value of x is %3.4f' %x)
• The value of x is 12.3457
 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.
>>> num = input('Enter a number: ')
Enter a number: 10
>>> num
'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.
>>> int('10')
10
>>> float('10')
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
• >>> int('2+3')
• Traceback (most recent call last):
– File "<string>", line 301, in runcode
– File "<interactive input>", line 1, in <module>
• ValueError: invalid literal for int() with base 10: '2+3'
• >>> eval('2+3')
• 5
 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:
• >>> from math import pi
• >>> pi
• 3.141592653589793
• While importing a module, Python looks at several places defined
in sys.path. It is a list of directory locations.
• >>> import sys
• >>> sys.path
• ['',
– 'C:\\Python33\\Lib\\idlelib',
– 'C:\\Windows\\system32\\python33.zip',
– 'C:\\Python33\\DLLs', 'C:\\Python33\\lib',
– 'C:\\Python33', 'C:\\Python33\\lib\\site-packages']