JSS Science and Technology University, Mysuru

SRI JAYACHAMARAJENDRA COLLEGE OF ENGINEERING

Department of Computer Applications
Bachelor of Computer Applications [BCA] – IV Semester

Course Code: BCA440 Course Title: Python Programming

UNIT-01
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.
History of Python
Python was developed by Guido van Rossum in the late eighties and early nineties at the
National Research Institute for Mathematics and Computer Science in the Netherlands.
Python is derived from many other languages, including ABC, Modula-3, C, C++, Algol-68,
SmallTalk, and Unix shell and other scripting languages.
Python is copyrighted. Like Perl, Python source code is now available under the GNU
General Public License (GPL).
Python is now maintained by a core development team at the institute, although Guido van
Rossum still holds a vital role in directing its progress.
Python Features
Python's features include −
 Easy-to-learn − Python has few keywords, simple structure, and a clearly defined
syntax. This allows the student to pick up the language quickly.
 Easy-to-read − Python code is more clearly defined and visible to the eyes.
 Easy-to-maintain − Python's source code is fairly easy-to-maintain.
 A broad standard library − Python's bulk of the library is very portable and cross-
platform compatible on UNIX, Windows, and Macintosh.
 Interactive Mode − Python has support for an interactive mode which allows
interactive testing and debugging of snippets of code.
 Portable − Python can run on a wide variety of hardware platforms and has the same
interface on all platforms.
 Extendable − You can add low-level modules to the Python interpreter. These
modules enable programmers to add to or customize their tools to be more efficient.
 Databases − Python provides interfaces to all major commercial databases.
 GUI Programming − Python supports GUI applications that can be created and
ported to many system calls, libraries and windows systems, such as Windows MFC,
Macintosh, and the X Window system of Unix.
 Scalable − Python provides a better structure and support for large programs than
shell scripting.
Apart from the above-mentioned features, Python has a big list of good features, few are
listed below −

1
  It supports functional and structured programming methods as well as OOP.
 It can be used as a scripting language or can be compiled to byte-code for building
large applications.
 It provides very high-level dynamic data types and supports dynamic type checking.
 IT supports automatic garbage collection.
 It can be easily integrated with C, C++, COM, ActiveX, CORBA, and Java.

Structure of Python Program

Python is very flexible in terms of program structure. That is, the syntax does not require a
specific ordering to functions or classes within a module or methods within a class.
1) startup line (Unix)
2) module documentation
3) module imports
4) variable declarations
5) class declarations
6) function declarations
7) "main" body

Startup line

2
Generally used only in Unix environments, the startup line allows for script execution by
name only (invoking the interpreter is not required).

Module documentation
Summary of a module's functionality and significant global variables; accessible externally as
module.__doc__.

Module imports
Import all the modules necessary for all the code in current module; modules are imported
once (when this module is loaded); imports within functions are not invoked until those
functions are called.

Variable declarations
Declare here (global) variables that are used by multiple functions in this module. We favor
the use of local variables over global, for good programming style mostly, and to a lesser
extent, for improved performance and less memory usage.

Class declarations
Any classes should be declared here. A class is defined when this module is imported and the
class statement executed. Documentation variable is class.
__doc__.

Function declarations
Functions that are declared here are accessible externally as module.function() ; function is
defined when this module is imported and the def statement executed. Documentation
variable is function.__doc__.

"main" body
All code at this level is executed, whether this module is imported or started as a script;
generally does not include much functional code, but rather gives direction depending on
mode of execution.

Python Interpreter

There are two ways of using Python: either using its interactive interpreter as you have just
done, or by writing modules. The interpreter is useful for small snippets of programs we want
to try out. In general, all the examples you see in this book can be typed at the interactive
prompt (>>>). You should get into the habit of trying things out at the prompt: you can do no
harm, and it is a good way of experimenting.

However, working interactively has the serious drawback that you cannot save your work.
When you exit the interactive interpreter everything you have done is lost. If you want to
write a longer program you create a module. This is just a text file containing a list of Python
instructions. When the module is run Python simply reads through it one line after another, as
though it had been typed at the interactive prompt.

When you start up IDLE, you should see the Python interactive interpreter. You can always
recognize an interpreter window by the >>> prompt whereas new module windows are
empty. IDLE only ever creates one interpreter window: if you close it and need to get the
interpreter back, select Python shell from the Run menu. You can have multiple module

3
windows open simultaneously. Here is an example of a complete Python module. Type it into
an editor window and run it by choosing Run from the Run menu (or press the F5 key on
your keyboard)

print "Please give a number: "

a = input()
print "And another: "
b = input()
print "The sum of these numbers is: "
print a + b

If you are writing a module and you want to save your work, do so by selecting Save from
the File menu then type a name for your program in the box. The name you choose should
indicate what the program does and consist only of letters, numbers, and ``_'' the underscore
character. The name must end with a .py so that it is recognized as a Python module,
e.g. prog.py. Furthermore, do NOT use spaces in filenames or directory (folder) names.

Using Python as a Calculator

Let’s try some simple Python commands. Start the interpreter and wait for the primary
prompt, >>>. (It shouldn’t take long.)
Numbers
The interpreter acts as a simple calculator: you can type an expression at it and it will write
the value. Expression syntax is straightforward: the operators +, -, * and / work just like in
most other languages (for example, Pascal or C); parentheses (()) can be used for grouping.
For example:
>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5 # division always returns a floating point number
1.6
The integer numbers (e.g. 2, 4, 20) have type int, the ones with a fractional part (e.g. 5.0, 1.6)
have type float. We will see more about numeric types later in the tutorial.
Division (/) always returns a float. To do floor division and get an integer result (discarding
any fractional result) you can use the // operator; to calculate the remainder you can use %:
>>> 17 / 3 # classic division returns a float
5.666666666666667
>>>
>>> 17 // 3 # floor division discards the fractional part
5

4
>>> 17 % 3 # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2 # result * divisor + remainder
17
With Python, it is possible to use the ** operator to calculate powers [1]:
>>> 5 ** 2 # 5 squared
25
>>> 2 ** 7 # 2 to the power of 7
128
The equal sign (=) is used to assign a value to a variable. Afterwards, no result is displayed
before the next interactive prompt:
>>> width = 20
>>> height = 5 * 9
>>> width * height
900
If a variable is not “defined” (assigned a value), trying to use it will give you an error:
>>> n # try to access an undefined variable
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined
There is full support for floating point; operators with mixed type operands convert the
integer operand to floating point:
>>> 4 * 3.75 - 1
14.0
In interactive mode, the last printed expression is assigned to the variable _. This means that
when you are using Python as a desk calculator, it is somewhat easier to continue
calculations, for example:
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

5
This variable should be treated as read-only by the user. Don’t explicitly assign a value to it
— you would create an independent local variable with the same name masking the built-in
variable with its magic behavior.
In addition to int and float, Python supports other types of numbers, such
as Decimal and Fraction. Python also has built-in support for complex numbers, and uses
the j or J suffix to indicate the imaginary part (e.g. 3+5j).
Strings
Besides numbers, Python can also manipulate strings, which can be expressed in several
ways. They can be enclosed in single quotes ('...') or double quotes ("...") with the same
result [2]. \ can be used to escape quotes:
>>> 'spam eggs' # single quotes
'spam eggs'
>>> 'doesn\'t' # use \' to escape the single quote...
"doesn't"
>>> "doesn't" # ...or use double quotes instead
"doesn't"
>>> '"Yes," they said.'
'"Yes," they said.'
>>> "\"Yes,\" they said."
'"Yes," they said.'
>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'
In the interactive interpreter, the output string is enclosed in quotes and special characters are
escaped with backslashes. While this might sometimes look different from the input (the
enclosing quotes could change), the two strings are equivalent. The string is enclosed in
double quotes if the string contains a single quote and no double quotes, otherwise it is
enclosed in single quotes. The print() function produces a more readable output, by omitting
the enclosing quotes and by printing escaped and special characters:
>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'
>>> print('"Isn\'t," they said.')
"Isn't," they said.
>>> s = 'First line.\nSecond line.' # \n means newline
>>> s # without print(), \n is included in the output
'First line.\nSecond line.'
>>> print(s) # with print(), \n produces a new line
First line.
Second line.

6
Strings can be concatenated (glued together) with the + operator, and repeated with *:
>>> # 3 times 'un', followed by 'ium'
>>> 3 * 'un' + 'ium'
'unununium'
Two or more string literals (i.e. the ones enclosed between quotes) next to each other are
automatically concatenated.
>>> 'Py' 'thon'
'Python'
This feature is particularly useful when you want to break long strings:
>>> text = ('Put several strings within parentheses '
... 'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'
This only works with two literals though, not with variables or expressions:
>>> prefix = 'Py'
>>> prefix 'thon' # can't concatenate a variable and a string literal
...
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
...
SyntaxError: invalid syntax
If you want to concatenate variables or a variable and a literal, use +:
>>> prefix + 'thon'
'Python'
Strings can be indexed (subscripted), with the first character having index 0. There is no
separate character type; a character is simply a string of size one:
>>> word = 'Python'
>>> word[0] # character in position 0
'P'
>>> word[5] # character in position 5
'n'
Indices may also be negative numbers, to start counting from the right:
>>> word[-1] # last character
'n'

7
>>> word[-2] # second-last character
'o'
>>> word[-6]
'P'
Note that since -0 is the same as 0, negative indices start from -1.
In addition to indexing, slicing is also supported. While indexing is used to obtain individual
characters, slicing allows you to obtain substring:
>>> word[0:2] # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5] # characters from position 2 (included) to 5 (excluded)
'tho'
Note how the start is always included, and the end always excluded. This makes sure that s[:i]
+ s[i:] is always equal to s:
>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'
Slice indices have useful defaults; an omitted first index defaults to zero, an omitted second
index defaults to the size of the string being sliced.
>>> word[:2] # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:] # characters from position 4 (included) to the end
'on'
>>> word[-2:] # characters from the second-last (included) to the end
'on'
One way to remember how slices work is to think of the indices as
pointing between characters, with the left edge of the first character numbered 0. Then the
right edge of the last character of a string of n characters has index n, for example:
+---+---+---+---+---+---+
|P|y|t|h|o|n|
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
The first row of numbers gives the position of the indices 0…6 in the string; the second row
gives the corresponding negative indices. The slice from i to j consists of all characters
between the edges labeled i and j, respectively.

8
For non-negative indices, the length of a slice is the difference of the indices, if both are
within bounds. For example, the length of word[1:3] is 2.
Attempting to use an index that is too large will result in an error:
>>> word[42] # the word only has 6 characters
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range
However, out of range slice indexes are handled gracefully when used for slicing:
>>> word[4:42]
'on'
>>> word[42:]
''
If you need a different string, you should create a new one:
>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'
The built-in function len() returns the length of a string:
>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34
Lists
Python knows a number of compound data types, used to group together other values. The
most versatile is the list, which can be written as a list of comma-separated values (items)
between square brackets. Lists might contain items of different types, but usually the items all
have the same type.
>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]
Like strings (and all other built-in sequence type), lists can be indexed and sliced:
>>> squares[0] # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:] # slicing returns a new list

9
[9, 16, 25]
All slice operations return a new list containing the requested elements. This means that the
following slice returns a new (shallow) copy of the list:
>>> squares[:]
[1, 4, 9, 16, 25]
Lists also support operations like concatenation:
>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Unlike strings, which are immutable, lists are a mutable type, i.e. it is possible to change their
content:
>>> cubes = [1, 8, 27, 65, 125] # something's wrong here
>>> 4 ** 3 # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64 # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]
You can also add new items at the end of the list, by using the append() method (we will see
more about methods later):
>>> cubes.append(216) # add the cube of 6
>>> cubes.append(7 ** 3) # and the cube of 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]
Assignment to slices is also possible, and this can even change the size of the list or clear it
entirely:
>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []

10
>>> letters
[]
The built-in function len() also applies to lists:
>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4
It is possible to nest lists (create lists containing other lists), for example:
>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

Python-shell
A simple way to run Python scripts from Node.js with basic but efficient inter-process
communication and better error handling.
Features
 Reliably spawn Python scripts in a child process
 Built-in text, JSON and binary modes
 Custom parsers and formatters
 Simple and efficient data transfers through stdin and stdout streams
 Extended stack traces when an error is thrown

Lines and Indentation

Python provides no braces to indicate blocks of code for class and function definitions or
flow control. Blocks of code are denoted by line indentation, which is rigidly enforced.
The number of spaces in the indentation is variable, but all statements within the block must
be indented the same amount. For example −

if True:
print "True"
else:
print "False"

11
Thus, in Python all the continuous lines indented with same number of spaces would form a
block.
Comments in Python
A hash sign (#) that is not inside a string literal begins a comment. All characters after the #
and up to the end of the physical line are part of the comment and the Python interpreter
ignores them.

# First comment
print "Hello, Python!" # second comment

Identifiers
Identifiers are the set of valid strings that are allowed as names in a computer language. From
this all encompassing list, we segregate out those that are keywords, names that form a
construct of the language. Such identifiers are reserved words that may not be used for any
other purpose, or else a syntax error (SyntaxError exception) will occur.
Python also has an additional set of identifiers known as built-ins, and although they are not
reserved words, use of these special names is not recommended.

Valid Python Identifiers

The rules for Python identifier strings are like most other high-level programming languages
that come from the C world:
 First character must be a letter or underscore ( _ )
 Any additional characters can be alphanumeric or underscore
 Case-sensitive
 No identifiers can begin with a number, and no symbols other than the underscore are
ever allowed. The easiest way to deal with underscores is to consider them as
alphabetic characters.
 Case-sensitivity means that identifier foo is different from Foo, and both of those are
different from FOO.

Keywords
Python's keywords are listed in Table 3.1. Generally, the keywords in any language should
remain relatively stable, but should things ever change (as Python is a growing and evolving
language), a list of keywords as well as an iskeyword() function are available in the keyword
module.

Variables:
Variables are nothing but reserved memory locations to store values. This means that when
you create a variable you reserve some space in memory.
Based on the data type of a variable, the interpreter allocates memory and decides what can
be stored in the reserved memory. Therefore, by assigning different data types to variables,
you can store integers, decimals or characters in these variables.
Assigning Values to Variables
Python variables do not need explicit declaration to reserve memory space. The declaration
happens automatically when you assign a value to a variable. The equal sign (=) is used to
assign values to variables.

12
The operand to the left of the = operator is the name of the variable and the operand to the
right of the = operator is the value stored in the variable. For example −
counter = 100 # An integer assignment
miles = 1000.0 # A floating point
name = "John" # A string
Multiple Assignments
Python allows you to assign a single value to several variables simultaneously.
For example − a = b = c = 1
Here, an integer object is created with the value 1, and all three variables are assigned to the
same memory location. You can also assign multiple objects to multiple variables.
For example − a,b,c = 1,2,"john"
Here, two integer objects with values 1 and 2 are assigned to variables a and b respectively,
and one string object with the value "john" is assigned to the variable c.
Standard Data Types
The data stored in memory can be of many types. For example, a person's age is stored as a
numeric value and his or her address is stored as alphanumeric characters. Python has
various standard data types that are used to define the operations possible on them and the
storage method for each of them.
Python has five standard data types −
 Numbers
 String
 List
 Tuple
 Dictionary
Python Numbers
Number data types store numeric values. Number objects are created when you assign a
value to them. For example −
var1 = 1
var2 = 10
You can also delete the reference to a number object by using the del statement. The syntax
of the del statement is −
del var1[,var2[,var3[....,varN]]]]
You can delete a single object or multiple objects by using the del statement. For example −
del var
del var_a, var_b
Python supports four different numerical types −
 int (signed integers)
 long (long integers, they can also be represented in octal and hexadecimal)

13
  float (floating point real values)
 complex (complex numbers)
Examples
Here are some examples of numbers −

int Long float complex

10 51924361L 0.0 3.14j

100 -0x19323L 15.20 45.j

-786 0122L -21.9 9.322e-36j

080 0xDEFABCECBDAECBFBAEl 32.3+e18 .876j

-0490 535633629843L -90. -.6545+0J

-0x260 -052318172735L -32.54e100 3e+26J

0x69 -4721885298529L 70.2-E12 4.53e-7j

 Python allows you to use a lowercase l with long, but it is recommended that you use
only an uppercase L to avoid confusion with the number 1. Python displays long
integers with an uppercase L.
 A complex number consists of an ordered pair of real floating-point numbers denoted
by x + yj, where x and y are the real numbers and j is the imaginary unit.
Python Strings
Strings in Python are identified as a contiguous set of characters represented in the quotation
marks. Python allows for either pairs of single or double quotes. Subsets of strings can be
taken using the slice operator ([ ] and [:] ) with indexes starting at 0 in the beginning of the
string and working their way from -1 at the end.
The plus (+) sign is the string concatenation operator and the asterisk (*) is the repetition
operator. For example −
#!/usr/bin/python

str = 'Hello World!'

print str # Prints complete string

print str[0] # Prints first character of the string
print str[2:5] # Prints characters starting from 3rd to 5th
print str[2:] # Prints string starting from 3rd character
print str * 2 # Prints string two times

14
print str + "TEST" # Prints concatenated string
This will produce the following result −
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
Python Lists
Lists are the most versatile of Python's compound data types. A list contains items separated
by commas and enclosed within square brackets ([]). To some extent, lists are similar to
arrays in C. One difference between them is that all the items belonging to a list can be of
different data type.
The values stored in a list can be accessed using the slice operator ([ ] and [:]) with indexes
starting at 0 in the beginning of the list and working their way to end -1. The plus (+) sign is
the list concatenation operator, and the asterisk (*) is the repetition operator. For example −
#!/usr/bin/python

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]

tinylist = [123, 'john']

print list # Prints complete list

print list[0] # Prints first element of the list
print list[1:3] # Prints elements starting from 2nd till 4th
print list[2:] # Prints elements starting from 3rd element
print tinylist * 2 # Prints list two times
print list + tinylist # Prints concatenated lists

This produce the following result −

['abcd', 786, 2.23, 'john', 70.200000000000003]
abcd
[786, 2.23]
[2.23, 'john', 70.200000000000003]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john']
Python Tuples

15
A tuple is another sequence data type that is similar to the list. A tuple consists of a number
of values separated by commas. Unlike lists, however, tuples are enclosed within
parentheses.
The main differences between lists and tuples are: Lists are enclosed in brackets ( [ ] ) and
their elements and size can be changed, while tuples are enclosed in parentheses ( ( ) ) and
cannot be updated. Tuples can be thought of as read-only lists. For example −
#!/usr/bin/python

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )

tinytuple = (123, 'john')

print tuple # Prints complete list

print tuple[0] # Prints first element of the list
print tuple[1:3] # Prints elements starting from 2nd till 3rd
print tuple[2:] # Prints elements starting from 3rd element
print tinytuple * 2 # Prints list two times
print tuple + tinytuple # Prints concatenated lists
This produce the following result −

('abcd', 786, 2.23, 'john', 70.200000000000003)

abcd
(786, 2.23)
(2.23, 'john', 70.200000000000003)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john')

The following code is invalid with tuple, because we attempted to update a tuple, which is
not allowed. Similar case is possible with lists −

#!/usr/bin/python

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000 # Invalid syntax with tuple
list[2] = 1000 # Valid syntax with list

Python Dictionary
Python's dictionaries are kind of hash table type. They work like associative arrays or hashes
found in Perl and consist of key-value pairs. A dictionary key can be almost any Python
type, but are usually numbers or strings. Values, on the other hand, can be any arbitrary
Python object.

16
Dictionaries are enclosed by curly braces ({ }) and values can be assigned and accessed
using square braces ([]). For example −
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}

print dict['one'] # Prints value for 'one' key

print dict[2] # Prints value for 2 key
print tinydict # Prints complete dictionary
print tinydict.keys() # Prints all the keys
print tinydict.values() # Prints all the values
This produce the following result −

This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'john'}
['dept', 'code', 'name']
['sales', 6734, 'john']

Dictionaries have no concept of order among elements. It is incorrect to say that the
elements are "out of order"; they are simply unordered.
Operators
Operators are the constructs which can manipulate the value of operands.
Consider the expression 4 + 5 = 9. Here, 4 and 5 are called operands and + is called
operator.
Types of Operator
Python language supports the following types of operators.
 Arithmetic Operators
 Comparison (Relational) Operators
 Assignment Operators
 Logical Operators
 Bitwise Operators
 Membership Operators
 Identity Operators
Python Arithmetic Operators

17
Arithmetic operators are used to perform mathematical operations like addition, subtraction,
multiplication etc.
Assume variable a holds 10 and variable b holds 20,
Operator Description Example
+ Addition Adds values on either side of the operator. a + b = 30
- Subtraction Subtracts right hand operand from left hand a – b = -10
operand.
* Multiplies values on either side of the operator a * b = 200
Multiplication
/ Division Divides left hand operand by right hand operand b/a=2
% Modulus Divides left hand operand by right hand operand b%a=0
and returns remainder
** Exponent Performs exponential (power) calculation on a**b =10 to the power
operators 20
// Floor Division - The division of operands where 9//2 = 4 and 9.0//2.0 =
the result is the quotient in which the digits after 4.0, -11//3 = -4, -11.0//3
the decimal point are removed. But if one of the = -4.0
operands is negative, the result is floored, i.e.,
rounded away from zero (towards negative
infinity) −

Python Comparison Operators

These operators compare the values on either sides of them and decide the relation among
them. They are also called Relational operators.
Assume variable a holds 10 and variable b holds 20, then
Operator Description Example
== If the values of two operands are equal, then the condition (a == b) is not
becomes true. true.
!= If values of two operands are not equal, then condition (a != b) is true.
becomes true.
<> If values of two operands are not equal, then condition (a <> b) is true.
becomes true. This is similar
to != operator.
> If the value of left operand is greater than the value of right (a > b) is not
operand, then condition becomes true. true.
< If the value of left operand is less than the value of right (a < b) is true.
operand, then condition becomes true.
>= If the value of left operand is greater than or equal to the value (a >= b) is not
of right operand, then condition becomes true. true.
<= If the value of left operand is less than or equal to the value of (a <= b) is true.
right operand, then condition becomes true.

18
Python Assignment Operators
Assume variable a holds 10 and variable b holds 20, then −
Operator Description Example
= Assigns values from right side operands to left c = a + b assigns
side operand value of a + b into c

+= Add AND It adds right operand to the left operand and c += a is equivalent
assign the result to left operand to c = c + a

-= Subtract AND It subtracts right operand from the left operand c -= a is equivalent to
and assign the result to left operand c=c-a

*= Multiply AND It multiplies right operand with the left operand c *= a is equivalent
and assign the result to left operand to c = c * a

/= Divide AND It divides left operand with the right operand and c /= a is equivalent to
assign the result to left operand c = c / ac /= a is
equivalent to c = c / a

%= Modulus AND It takes modulus using two operands and assign c %= a is equivalent
the result to left operand to c = c % a
**= Exponent Performs exponential (power) calculation on c **= a is equivalent
AND operators and assign value to the left operand to c = c ** a

//= Floor Division It performs floor division on operators and c //= a is equivalent
assign value to the left operand to c = c // a

Python Bitwise Operators

Bitwise operator works on bits and performs bit by bit operation. Assume if a = 60; and b =
13; Now in binary format they will be as follows −
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a  = 1100 0011
There are following Bitwise operators supported by Python language
Operator Description Example
& Binary AND Operator copies a bit to the result if it (a & b) (means 0000

19
 exists in both operands 1100)
| Binary OR It copies a bit if it exists in either (a | b) = 61 (means
operand. 0011 1101)
^ Binary XOR It copies the bit if it is set in one (a ^ b) = 49 (means
operand but not both. 0011 0001)
~ Binary Ones It is unary and has the effect of (~a ) = -61 (means 1100
Complement 'flipping' bits. 0011 in 2's complement
form due to a signed
binary number.
<< Binary Left Shift The left operands value is moved left by a << 2 = 240 (means
the number of bits specified by the right 1111 0000)
operand.
>> Binary Right Shift The left operands value is moved right a >> 2 = 15 (means
by the number of bits specified by the 0000 1111)
right operand.

Python Logical Operators

There are following logical operators supported by Python language. Assume variable a
holds 10 and variable b holds 20 then
Operator Description Example
and Logical If both the operands are true then condition (a and b) is true.
AND becomes true.
or Logical OR If any of the two operands are non-zero then (a or b) is true.
condition becomes true.
not Logical Used to reverse the logical state of its operand. Not(a and b) is false.
NOT

Python Membership Operators

Python’s membership operators test for membership in a sequence, such as strings, lists, or
tuples. There are two membership operators as explained below −
Operator Description Example
in Evaluates to true if it finds a variable in the x in y, here in results in a 1 if
specified sequence and false otherwise. x is a member of sequence y.
not in Evaluates to true if it does not finds a variable in x not in y, here not in results
the specified sequence and false otherwise. in a 1 if x is not a member of
sequence y.

Python Identity Operators

Identity operators compare the memory locations of two objects. There are two Identity
operators explained below –

20
Operator Description Example
is Evaluates to true if the variables on either side x is y, here is results in 1 if id(x)
of the operator point to the same object and equals id(y).
false otherwise.
is not Evaluates to false if the variables on either side x is not y, here is notresults in 1
of the operator point to the same object and true if id(x) is not equal to id(y).
otherwise.

Decision Making Statements

Decision making is anticipation of conditions occurring while execution of the program and
specifying actions taken according to the conditions.
Decision structures evaluate multiple expressions which produce TRUE or FALSE as
outcome. You need to determine which action to take and which statements to execute if
outcome is TRUE or FALSE otherwise.
Python programming language assumes any non-zero and non-null values as TRUE, and if it
is either zero or null, then it is assumed as FALSE value.
Python programming language provides following types of decision making statements.
 If Statement
 If…else Statement
 Nested if Statement
If Statement:
It is similar to that of other languages. The if statement contains a logical expression using
which data is compared and a decision is made based on the result of the comparison.
Syntax
if expression:
statement(s)
If the Boolean expression evaluates to TRUE, then the block of statement(s) inside the if
statement is executed. If Boolean expression evaluates to FALSE, then the first set of code
after the end of the if statement(s) is executed.

Example
var1 = 100
if var1:
print "1 - Got a true expression value"
print var1
var2 = 0
if var2:
print "2 - Got a true expression value"
print var2

21
print "Good bye!"

When the above code is executed, it produces the following result −

Output 1.
1 - Got a true expression value
100
Good bye!

If….else Statement:
An else statement can be combined with an if statement. An else statement contains the
block of code that executes if the conditional expression in the if statement resolves to 0 or a
FALSE value.
The else statement is an optional statement and there could be at most only
one else statement following if.
Syntax
The syntax of the if...else statement is −
if expression:
statement(s)
else:
statement(s)

Example Program:
print("enter the two numbers")
a = input()
b = input()
if a>b:
print(a,"is largest")
else:
print(b,"is largest")

Output:
enter the two numbers
6
8
8 is largest
The elif Statement
The elif statement allows you to check multiple expressions for TRUE and execute a block
of code as soon as one of the conditions evaluates to TRUE.

22
Similar to the else, the elif statement is optional. However, unlike else, for which there can
be at most one statement, there can be an arbitrary number of elif statements following an if.
syntax
if expression1:
statement(s)
elif expression2:
statement(s)
elif expression3:
statement(s)
else:
statement(s)
Example:
print("Enter the marks")
m=int(input())
if m>=80:
print("Distinction")
elif m>=60:
print("Forst Class")
elif m>=50:
print("Second Class")
elif m>=40:
print("Pass")
else:
print("Fail")

Output:
Enter the marks
65
First Class

Nested If Statement:
There may be a situation when you want to check for another condition after a condition
resolves to true. In such a situation, you can use the nested if construct.
In a nested if construct, you can have an if...elif...elseconstruct inside
another if...elif...else construct.
Syntax
The syntax of the nested if...elif...else construct may be −
if expression1:
statement(s)
if expression2:

23
 statement(s)
elif expression3:
statement(s)
else:
statement(s)
elif expression4:
statement(s)
else:
statement(s)
Example:
print("enter three numbers")
a = int(input())
b = int(input())
c = int(input())
if a>b:
if a>c:
print(a,"is Largest")
else:
print(c,"is Largest")
elif b>c:
print(b,"is Largest")
else:
print(c,"is Largest")

Output:
enter three numbers
5
4
8
8 is Largest
Note:Core Python does not provide switch or case statements as in other languages, but
we can use if..elif...statements to simulate switch case
Iterative or Loop Statement:
In general, statements are executed sequentially: The first statement in a function is executed
first, followed by the second, and so on. There may be a situation when you need to execute
a block of code several number of times.
Programming languages provide various control structures that allow for more complicated
execution paths.
A loop statement allows us to execute a statement or group of statements multiple times.

24
Python programming language provides following types of loops to handle looping
requirements.
 While Loop
 For Loop
 Nested Loop
While Loop
A while loop statement in Python programming language repeatedly executes a target
statement as long as a given condition is true.
Syntax
The syntax of a while loop in Python programming language is −
while expression:
statement(s)
Here, statement(s) may be a single statement or a block of statements. The condition may
be any expression, and true is any non-zero value. The loop iterates while the condition is
true.
When the condition becomes false, program control passes to the line immediately following
the loop.
In Python, all the statements indented by the same number of character spaces after a
programming construct are considered to be part of a single block of code. Python uses
indentation as its method of grouping statements.
Example
count = 0
while (count < 9):
print 'The count is:', count
count = count + 1
When the above code is executed, it produces the following result −
The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
The block here, consisting of the print and increment statements, is executed repeatedly until
count is no longer less than 9. With each iteration, the current value of the index count is
displayed and then increased by 1.
The Infinite Loop
25
A loop becomes infinite loop if a condition never becomes FALSE. You must use caution
when using while loops because of the possibility that this condition never resolves to a
FALSE value. This results in a loop that never ends. Such a loop is called an infinite loop.
An infinite loop might be useful in client/server programming where the server needs to run
continuously so that client programs can communicate with it as and when required.
var = 1
while var == 1 : # This constructs an infinite loop
num = input("Enter a number :")
print "You entered: ", num

When the above code is executed, it produces the following result −

Enter a number :20
You entered: 20
Enter a number :29
You entered: 29
Enter a number :3
You entered: 3
Enter a number between :Traceback (most recent call last):
File "test.py", line 5, in <module>
num = input("Enter a number :")
KeyboardInterrupt
Above example goes in an infinite loop and you need to use CTRL+C to exit the program.
Using else Statement with Loops
Python supports to have an else statement associated with a loop statement.
 If the else statement is used with a for loop, the elsestatement is executed when the
loop has exhausted iterating the list.
 If the else statement is used with a while loop, the elsestatement is executed when the
condition becomes false.
The following example illustrates the combination of an else statement with a while
statement that prints a number as long as it is less than 5, otherwise else statement gets
executed.
count = 0
while count < 5:
print count, " is less than 5"
count = count + 1
else:
print count, " is not less than 5"

26
When the above code is executed, it produces the following result −
0 is less than 5
1 is less than 5
2 is less than 5
3 is less than 5
4 is less than 5
5 is not less than 5
For Loop:
It has the ability to iterate over the items of any sequence, such as a list or a string.
Syntax

for iterating_var in sequence:

statements(s)

If a sequence contains an expression list, it is evaluated first. Then, the first item in the
sequence is assigned to the iterating variable iterating_var. Next, the statements block is
executed. Each item in the list is assigned to iterating_var, and the statement(s) block is
executed until the entire sequence is exhausted.

Example
for letter in 'Python': # First Example
print 'Current Letter :', letter

fruits = ['banana', 'apple', 'mango']

for fruit in fruits: # Second Example
print 'Current fruit :', fruit

When the above code is executed, it produces the following result −

Current Letter: P
Current Letter: y
Current Letter: t
Current Letter: h
Current Letter: o
Current Letter: n
Current fruit: banana
Current fruit: apple
Current fruit: mango

Iterating by Sequence Index

An alternative way of iterating through each item is by index offset into the sequence itself.
Following is a simple example −
fruits = ['banana', 'apple', 'mango']
for index in range(len(fruits)):
print 'Current fruit :', fruits[index]

27
When the above code is executed, it produces the following result −

Current fruit : banana

Current fruit : apple
Current fruit : mango
Good bye!

Here, we took the assistance of the len() built-in function, which provides the total number
of elements in the tuple as well as the range() built-in function to give us the actual sequence
to iterate over.
Loop Control Statements
Loop control statements change execution from its normal sequence. When execution leaves
a scope, all automatic objects that were created in that scope are destroyed.
Python supports the following control statements.
 Break
 Continue
 Pass

Break:
It terminates the current loop and resumes execution at the next statement, just like the
traditional break statement in C.
The most common use for break is when some external condition is triggered requiring a
hasty exit from a loop. The break statement can be used in both while and for loops.
If you are using nested loops, the break statement stops the execution of the innermost loop
and start executing the next line of code after the block.

Syntax
The syntax for a break statement in Python is as follows −

break
Example:
for letter in 'Python': # First Example
if letter = = 't':
break
print(“Current Letter :”, letter)
Output:
Current Letter : P
Current Letter : y

Continue

28
It returns the control to the beginning of the while loop.. The continue statement rejects all
the remaining statements in the current iteration of the loop and moves the control back to
the top of the loop.
The continue statement can be used in both while and forloops.
Syntax

continue
Example:
for letter in 'Python': # First Example
if letter == 'h':
continue
print (“Current Letter :”, letter)

Output:
Current Letter : P
Current Letter : y
Current Letter : t
Current Letter : o
Current Letter : n
Pass:
It is used when a statement is required syntactically but you do not want any command or
code to execute.
The pass statement is a null operation; nothing happens when it executes. The pass is also
useful in places where your code will eventually go, but has not been written yet (e.g., in
stubs for example) −
Syntax

pass
Example:
for letter in 'Python':
if letter == 'h':
pass
print 'This is pass block'
print(“Current Letter :”, letter)
Output:
Current Letter : P
Current Letter : y
Current Letter : t
This is pass block
Current Letter : h
Current Letter : o
Current Letter : n

29
Numbers:

Number data types store numeric values. They are immutable data types, means that
changing the value of a number data type results in a newly allocated object.

Number objects are created when you assign a value to them. For example −

var1 = 1
var2 = 10
You can also delete the reference to a number object by using the del statement. The syntax
of the del statement is −

del var1[,var2[,var3[....,varN]]]]
You can delete a single object or multiple objects by using the del statement. For example −

del var
del var_a, var_b
Python supports four different numerical types −

 int (signed integers) − They are often called just integers or ints, are positive or
negative whole numbers with no decimal point.
 long (long integers ) − Also called longs, they are integers of unlimited size, written
like integers and followed by an uppercase or lowercase L.
 float (floating point real values) − Also called floats, they represent real numbers
and are written with a decimal point dividing the integer and fractional parts. Floats
may also be in scientific notation, with E or e indicating the power of 10 (2.5e2 = 2.5
x 102 = 250).
 complex (complex numbers) − are of the form a + bJ, where a and b are floats and J
(or j) represents the square root of -1 (which is an imaginary number). The real part
of the number is a, and the imaginary part is b. Complex numbers are not used much
in Python programming.

Mathematical Functions
Python includes following functions that perform mathematical calculations.
Sr. Function & Returns ( description ) Example
No.
1 abs(x) print(abs(-45)) : 45
The method abs() returns absolute value print(abs(100.12)) : 100
of x - the (positive) distance between x
and zero.
2 ceil(x) print(math.ceil(-45.17)) : -45.0
30
 The method ceil() returns ceiling value print(math.ceil(100.12)): 101.0
of x - the smallest integer not less than x
3 cmp(x, y) print(cmp(80,100)): -1
The method cmp() returns the sign of the print(cmp(100,80)): 1
difference of two numbers : -1 if x < y, 0 print(cmp(80,80)): 0
if x == y, or 1 if x > y
4 exp(x) print(math.exp(-45.17)): 2.425006123-20
The method exp() returns exponential of print(math.exp(100.12)): 3.030843614+43
x: ex.
5 fabs(x) print(math.fabs(-45.17)): 45.17
The method fabs() returns the absolute print(math.fabs(100.12)): 100.12
value of x
6 floor(x) print(math.floor(-45.17)): -46
The method floor() returns floor of x - the print(math.floor(100.12)): 100
largest integer not greater than x.
7 log(x) print(math.log(100.12)): 4.60636946656
The method log() returns natural logarithm
of x, for x > 0.
8 log10(x) print(math.floor(100.12)): 2.00052084094
The method log10() returns base-10
logarithm of x for x > 0.
9 max(x1, x2,...) print(max(10,5,15,45)): 45
The largest of its arguments: the value
closest to positive infinity
10 min(x1, x2,...) print(min(10,5,15,45)): 5
The smallest of its arguments: the value
closest to negative infinity
11 modf(x) print(math.modf(100.12)) :
The method modf() returns the fractional 0.12000000000000455, 100.0
and integer parts of x in a two-item tuple.
Both parts have the same sign as x. The
integer part is returned as a float.
12 pow(x, y) print(math.pow(100,2)) : 10000.0
This method returns value of xy.
13 round(x [,n]) print(round(80.23456,2)) : 80.23
x rounded to n digits from the decimal
point. Python rounds away from zero as a
tie-breaker: round(0.5) is 1.0 and round(-
0.5) is -1.0.
14 sqrt(x) print(math.sqrt(4)): 2.0
The square root of x for x > 0

Trigonometric Functions
Python includes following functions that perform trigonometric calculations.
Sr.No. Function & Description
1 acos(x)
Return the arc cosine of x, in radians.
2 asin(x)
Return the arc sine of x, in radians.

31
3 atan(x)
Return the arc tangent of x, in radians.
4 atan2(y, x)
Return atan(y / x), in radians.
5 cos(x)
Return the cosine of x radians.
6 hypot(x, y)
Return the Euclidean norm, sqrt(x*x + y*y).
7 sin(x)
Return the sine of x radians.
8 tan(x)
Return the tangent of x radians.
9 degrees(x)
Converts angle x from radians to degrees.
10 radians(x)
Converts angle x from degrees to radians.

Mathematical Constants
The module also defines two mathematical constants −
Sr.No. Constants & Description
1 Pi The mathematical constant pi.
2 E The mathematical constant e.
Strings:
Strings are amongst the most popular types in Python. We can create them simply by
enclosing characters in quotes. Python treats single quotes the same as double quotes.
Creating strings is as simple as assigning a value to a variable. For example −

var1 = 'Hello World!'

var2 = "Python Programming"

Accessing Values in Strings

Python does not support a character type; these are treated as strings of length one, thus also
considered a substring.
To access substrings, use the square brackets for slicing along with the index or indices to
obtain your substring. For example −

var1 = 'Hello World!'

var2 = "Python Programming"

print "var1[0]: ", var1[0]

print "var2[1:5]: ", var2[1:5]

When the above code is executed, it produces the following result −

32
var1[0]: H
var2[1:5]: ytho

Updating Strings
You can "update" an existing string by (re)assigning a variable to another string. The new
value can be related to its previous value or to a completely different string altogether. For
example −

var1 = 'Hello World!'

print "Updated String :- ", var1[:6] + 'Python'

When the above code is executed, it produces the following result −

Updated String :- Hello Python

String Special Operators

Assume string variable a holds 'Hello' and variable b holds 'Python', then

Operator Description Example
+ Concatenation - Adds values on either side of the a + b will
operator give
HelloPython
* Repetition - Creates new strings, concatenating a*2 will
multiple copies of the same string give -
HelloHello
[] Slice - Gives the character from the given index a[1] will
give e
[:] Range Slice - Gives the characters from the given a[1:4] will
range give ell
in Membership - Returns true if a character exists in the H in a will
given string give 1
not in Membership - Returns true if a character does not M not in a
exist in the given string will give 1

String Formatting Operator

One of Python's coolest features is the string format operator %. This operator is unique to
strings and makes up for the pack of having functions from C's printf() family. Following is
a simple example −

print "My name is %s and weight is %d kg!" % ('Zara', 21)

When the above code is executed, it produces the following result −

My name is Zara and weight is 21 kg!

Built-in String Methods

33
Python includes the following built-in methods to manipulate strings −
Sr.No. Methods with Description
1 capitalize()
Capitalizes first letter of string
2 center(width, fillchar)
Returns a space-padded string with the original string centered to a total of
width columns.
3 count(str, beg= 0,end=len(string))
Counts how many times str occurs in string or in a substring of string if
starting index beg and ending index end are given.
4 endswith(suffix, beg=0, end=len(string))
Determines if string or a substring of string (if starting index beg and
ending index end are given) ends with suffix; returns true if so and false
otherwise.
5 expandtabs(tabsize=8)
Expands tabs in string to multiple spaces; defaults to 8 spaces per tab if
tabsize not provided.
6 find(str, beg=0 end=len(string))
Determine if str occurs in string or in a substring of string if starting index
beg and ending index end are given returns index if found and -1
otherwise.
7 isalnum()
Returns true if string has at least 1 character and all characters are
alphanumeric and false otherwise.
8 isalpha()
Returns true if string has at least 1 character and all characters are
alphabetic and false otherwise.
9 isdigit()
Returns true if string contains only digits and false otherwise.
10 islower()
Returns true if string has at least 1 cased character and all cased characters
are in lowercase and false otherwise.
11 isnumeric()
Returns true if a unicode string contains only numeric characters and false
otherwise.
12 isspace()
Returns true if string contains only whitespace characters and false
otherwise.
13 istitle()
Returns true if string is properly "titlecased" and false otherwise.
14 isupper()
Returns true if string has at least one cased character and all cased
characters are in uppercase and false otherwise.
15 join(seq)
Merges (concatenates) the string representations of elements in sequence
seq into a string, with separator string.
16 len(string)
Returns the length of the string
17 lower()

34
 Converts all uppercase letters in string to lowercase.
18 lstrip()
Removes all leading whitespace in string.
19 max(str)
Returns the max alphabetical character from the string str.
20 min(str)
Returns the min alphabetical character from the string str.
21 replace(old, new [, max])
Replaces all occurrences of old in string with new or at most max
occurrences if max given.
22 split(str="", num=string.count(str))
Splits string according to delimiter str (space if not provided) and returns
list of substrings; split into at most num substrings if given.
23 startswith(str, beg=0,end=len(string))
Determines if string or a substring of string (if starting index beg and
ending index end are given) starts with substring str; returns true if so and
false otherwise.
24 upper()
Converts lowercase letters in string to uppercase.
25 isdecimal() :Returns true if a unicode string contains only decimal
characters and false otherwise.

Program to perform String methods

s1=input("Enter the first string:")
s2=input("Enter the second String:")
print("First string is:",s1)
print("Second string is:",s2)
print("Length of first string is:",len(s1))
print("Length of second string is:",len(s2))
print("Concatenated string is:",s1+s2)
if s1==s2:
print("Strings are equal")
else:
print("Strings are not equal")
s3=s2
print("copied string is:",s3)
print("Upper case string",s1.upper())
print("Lower case String",s1.lower())
print("Replaced string is",s1.replace("a","m"))

Python Lists
The list is a most versatile datatype available in Python which can be written as a list of
comma-separated values (items) between square brackets. Important thing about a list is that
items in a list need not be of the same type.
Creating a list is as simple as putting different comma-separated values between square
brackets. For example −

35
list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"]

Similar to string indices, list indices start at 0, and lists can be sliced, concatenated and so
on.
Accessing Values in Lists
To access values in lists, use the square brackets for slicing along with the index or indices
to obtain value available at that index. For example −

list1 = ['physics', 'chemistry', 1997, 2000];

list2 = [1, 2, 3, 4, 5, 6, 7 ];
print("list1[0]: ", list1[0])
print("list2[1:5]: ", list2[1:5])

When the above code is executed, it produces the following result −

list1[0]: physics
list2[1:5]: [2, 3, 4, 5]

Updating Lists
You can update single or multiple elements of lists by giving the slice on the left-hand side
of the assignment operator, and you can add to elements in a list with the append() method.
For example −

list = ['physics', 'chemistry', 1997, 2000];

print("Value available at index 2 : ")
print(list[2])
list[2] = 2001;
print("New value available at index 2 : ")
print(list[2])

Note − append() method is discussed in subsequent section.

When the above code is executed, it produces the following result −

Value available at index 2 :

1997
New value available at index 2 :
2001

Delete List Elements

To remove a list element, you can use either the del statement if you know exactly which
element(s) you are deleting or the remove() method if you do not know. For example −

36
list1 = ['physics', 'chemistry', 1997, 2000];
print(list1)
del(list1[2]);
print "After deleting value at index 2 : "
print(list1)

When the above code is executed, it produces following result −

['physics', 'chemistry', 1997, 2000]

After deleting value at index 2 :
['physics', 'chemistry', 2000]

Note − remove() method is discussed in subsequent section.

Basic List Operations
Lists respond to the + and * operators much like strings; they mean concatenation and
repetition here too, except that the result is a new list, not a string.
In fact, lists respond to all of the general sequence operations we used on strings in the prior
chapter.
Python Expression Results Description
len([1, 2, 3]) 3 Length
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] Concatenation
['Hi!'] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] Repetition
3 in [1, 2, 3] True Membership
for x in [1, 2, 3]: print 123 Iteration
x,
Indexing, Slicing, and Matrixes
Because lists are sequences, indexing and slicing work the same way for lists as they do for
strings.
Assuming following input −

L = ['spam', 'Spam', 'SPAM!']

Python Expression Results Description

L[2] 'SPAM!' Offsets start at zero
L[-2] 'Spam' Negative: count from the
right
L[1:] ['Spam', 'SPAM!'] Slicing fetches sections
Built-in List Functions & Methods
Python includes the following list functions −
Sr.No. Function with Description

37
1 cmp(list1, list2)
Compares elements of both lists.
2 len(list)
Gives the total length of the list.
3 max(list)
Returns item from the list with max value.
4 min(list)
Returns item from the list with min value.
5 list(seq)
Converts a tuple into list.

Python includes following list methods

Sr.No. Methods with Description
1 list.append(obj)
Appends object obj to list
2 list.count(obj)
Returns count of how many times obj occurs in list
3 list.extend(seq)
Appends the contents of seq to list
4 list.index(obj)
Returns the lowest index in list that obj appears
5 list.insert(index, obj)
Inserts object obj into list at offset index
6 list.pop(obj=list[-1])
Removes and returns last object or obj from list
7 list.remove(obj)
Removes object obj from list
8 list.reverse()
Reverses objects of list in place
9 list.sort([func])
Sorts objects of list, use compare func if given

List Example Program

a=[]
n = int(input("Enter the length of the List:"))
for i in range(n):

38
 a.append(int(input()))
print("Entered list is")
print(a)
a.pop()
print("List after pop")
print(a)
print("enter the element and position to insert into the list")
e = int(input())
p = int(input())
a.insert(p, e)
print("List after inserting an element")
print(a)
a.sort()
print("sorting List")
print(a)
a.reverse()
print("Reverse list is")
print(a)
print("Enter the Element To Remove")
b=int(input())
a.remove(b)
print("List after removing an Element 4")
print(a)

Tuple
A tuple is a sequence of immutable Python objects. Tuples are sequences, just like lists. The
differences between tuples and lists are, the tuples cannot be changed unlike lists and tuples
use parentheses, whereas lists use square brackets.
Creating a tuple is as simple as putting different comma-separated values. Optionally you
can put these comma-separated values between parentheses also. For example −

tup1 = ('physics', 'chemistry', 1997, 2000);

tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";

The empty tuple is written as two parentheses containing nothing −

tup1 = ();

To write a tuple containing a single value you have to include a comma, even though there is
only one value −

tup1 = (50,);

Like string indices, tuple indices start at 0, and they can be sliced, concatenated, and so on.
Accessing Values in Tuples
To access values in tuple, use the square brackets for slicing along with the index or indices
to obtain value available at that index. For example −

39
tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );
print "tup1[0]: ", tup1[0];
print "tup2[1:5]: ", tup2[1:5];

When the above code is executed, it produces the following result −

tup1[0]: physics
tup2[1:5]: [2, 3, 4, 5]

Updating Tuples
Tuples are immutable which means you cannot update or change the values of tuple
elements. You are able to take portions of existing tuples to create new tuples as the
following example demonstrates −

tup1 = (12, 34.56);

tup2 = ('abc', 'xyz');

# Following action is not valid for tuples

# tup1[0] = 100;
# So let's create a new tuple as follows
tup3 = tup1 + tup2;
print tup3;

When the above code is executed, it produces the following result −

(12, 34.56, 'abc', 'xyz')

Delete Tuple Elements

Removing individual tuple elements is not possible. There is, of course, nothing wrong with
putting together another tuple with the undesired elements discarded.
To explicitly remove an entire tuple, just use the del statement. For example −

tup = ('physics', 'chemistry', 1997, 2000);

print tup;
del tup;
print "After deleting tup : ";
print tup;

This produces the following result. Note an exception raised, this is because after del
tup tuple does not exist any more −

('physics', 'chemistry', 1997, 2000)

After deleting tup :

40
Traceback (most recent call last):
File "test.py", line 9, in <module>
print tup;
NameError: name 'tup' is not defined

Basic Tuples Operations

Tuples respond to the + and * operators much like strings; they mean concatenation and
repetition here too, except that the result is a new tuple, not a string.
In fact, tuples respond to all of the general sequence operations we used on strings in the
prior chapter −
Python Expression Results Description
len((1, 2, 3)) 3 Length
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) Concatenation
('Hi!',) * 4 ('Hi!', 'Hi!', 'Hi!', 'Hi!') Repetition
3 in (1, 2, 3) True Membership
for x in (1, 2, 3): print x, 123 Iteration
Indexing, Slicing, and Matrixes
Because tuples are sequences, indexing and slicing work the same way for tuples as they do
for strings. Assuming following input −

L = ('spam', 'Spam', 'SPAM!')

 
Python Expression Results Description
L[2] 'SPAM!' Offsets start at zero
L[-2] 'Spam' Negative: count from the
right
L[1:] ['Spam', 'SPAM!'] Slicing fetches sections

Built-in Tuple Functions

Python includes the following tuple functions −
Sr.No. Function with Description
1 cmp(tuple1, tuple2)
Compares elements of both tuples.
2 len(tuple)
Gives the total length of the tuple.
3 max(tuple)
Returns item from the tuple with max value.

41
4 min(tuple)
Returns item from the tuple with min value.
5 tuple(seq)
Converts a list into tuple.

Difference between List and Tuple

List Tuple
List is mutable  Tuples are immutable
Lists is shown by square brackets [] Tuples is shown by parentheses () 
Lists are for variable length Tuple are for fixed length
Lists have  append, insert and delete Tuples have No append, insert, and delete
operation operation

Dictionary
Dictionaries are the sole mapping type in Python. Mapping objects have a one-to-many
correspondence between hashable values (keys) and the objects they represent (values). What
makes dictionaries different from sequence type containers like lists and tuples is the way the
data are stored and accessed.

Modules
A module allows you to logically organize your Python code. Grouping related code into a
module makes the code easier to understand and use. A module is a Python object with
arbitrarily named attributes that you can bind and reference.
Simply, a module is a file consisting of Python code. A module can define functions, classes
and variables. A module can also include runnable code.
Example
The Python code for a module named aname normally resides in a file named aname.py.
Here's an example of a simple module, support.py

def print_func( par ):

print ("Hello : ", par)
return

The import Statement
You can use any Python source file as a module by executing an import statement in some
other Python source file. The importhas the following syntax −

import module1[, module2[,... moduleN]

When the interpreter encounters an import statement, it imports the module if the module is
present in the search path. A search path is a list of directories that the interpreter searches

42
before importing a module. For example, to import the module support.py, you need to put
the following command at the top of the script −

# Import module support

import support
# Now you can call defined function that module as follows
support.print_func("Zara")

When the above code is executed, it produces the following result −

Hello : Zara

A module is loaded only once, regardless of the number of times it is imported. This
prevents the module execution from happening over and over again if multiple imports
occur.
The from...import Statement
Python's from statement lets you import specific attributes from a module into the current
namespace. The from...import has the following syntax −

from modname import name1[, name2[, ... nameN]]

For example, to import the function fibonacci from the module fib, use the following
statement −

from fib import fibonacci

This statement does not import the entire module fib into the current namespace; it just
introduces the item fibonacci from the module fib into the global symbol table of the
importing module.
The from...import * Statement
It is also possible to import all names from a module into the current namespace by using the
following import statement −

from modname import *

This provides an easy way to import all the items from a module into the current namespace;
however, this statement should be used sparingly.
Locating Modules
When you import a module, the Python interpreter searches for the module in the following
sequences −
 The current directory.
 If the module isn't found, Python then searches each directory in the shell variable
PYTHONPATH.
 If all else fails, Python checks the default path. On UNIX, this default path is
normally /user/local/lib/python/.
The module search path is stored in the system module sys as the sys.path variable. The
sys.path variable contains the current directory, PYTHONPATH, and the installation-
dependent default.

43
The PYTHONPATH Variable
The PYTHONPATH is an environment variable, consisting of a list of directories. The
syntax of PYTHONPATH is the same as that of the shell variable PATH.
Here is a typical PYTHONPATH from a Windows system −

set PYTHONPATH = c:\python20\lib;

And here is a typical PYTHONPATH from a UNIX system −

set PYTHONPATH = /usr/local/lib/python

Namespaces and Scoping

Variables are names (identifiers) that map to objects. A namespace is a dictionary of
variable names (keys) and their corresponding objects (values).
A Python statement can access variables in a local namespaceand in the global namespace.
If a local and a global variable have the same name, the local variable shadows the global
variable.
Each function has its own local namespace. Class methods follow the same scoping rule as
ordinary functions.
Python makes educated guesses on whether variables are local or global. It assumes that any
variable assigned a value in a function is local.
Therefore, in order to assign a value to a global variable within a function, you must first use
the global statement.
The statement global VarName tells Python that VarName is a global variable. Python stops
searching the local namespace for the variable.
For example, we define a variable Money in the global namespace. Within the
function Money, we assign Money a value, therefore Python assumes Money as a local
variable. However, we accessed the value of the local variable Moneybefore setting it, so an
UnboundLocalError is the result. Uncommenting the global statement fixes the problem.

Money = 2000
def AddMoney():
# Uncomment the following line to fix the code:
# global Money
Money = Money + 1

print Money
AddMoney()
Print(Money)

Module inbuilt Methods

The dir( ) Function
The dir() built-in function returns a sorted list of strings containing the names defined by a
module.

44
The list contains the names of all the modules, variables and functions that are defined in a
module. Following is a simple example −

# Import built-in module math

import math
content = dir(math)
print content

When the above code is executed, it produces the following result −

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan',

'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp',
'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh',
'sqrt', 'tan', 'tanh']

Here, the special string variable __name__ is the module's name, and __file__ is the
filename from which the module was loaded.
The globals() and locals() Functions
The globals() and locals() functions can be used to return the names in the global and local
namespaces depending on the location from where they are called.
If locals() is called from within a function, it will return all the names that can be accessed
locally from that function.
If globals() is called from within a function, it will return all the names that can be accessed
globally from that function.
The return type of both these functions is dictionary. Therefore, names can be extracted
using the keys() function.
The reload() Function
When the module is imported into a script, the code in the top-level portion of a module is
executed only once.
Therefore, if you want to reexecute the top-level code in a module, you can use
the reload() function. The reload() function imports a previously imported module again.
The syntax of the reload() function is this −

reload(module_name)

Here, module_name is the name of the module you want to reload and not the string
containing the module name. For example, to reload hello module, do the following −

reload(hello)

Date and Time Function:

45
A Python program can handle date and time in several ways. Converting between date
formats is a common chore for computers. Python's time and calendar modules help track
dates and times.
What is Tick?
Time intervals are floating-point numbers in units of seconds. Particular instants in time are
expressed in seconds since 12:00am, January 1, 1970(epoch).
There is a popular time module available in Python which provides functions for working
with times, and for converting between representations. The function time.time() returns the
current system time in ticks since 12:00am, January 1, 1970(epoch).
Example

import time; # This is required to include time module.

ticks = time.time()
print "Number of ticks since 12:00am, January 1, 1970:", ticks

This would produce a result something as follows −

Number of ticks since 12:00am, January 1, 1970: 7186862.73399

Date arithmetic is easy to do with ticks. However, dates before the epoch cannot be
represented in this form. Dates in the far future also cannot be represented this way - the
cutoff point is sometime in 2038 for UNIX and Windows.
What is TimeTuple?
Many of Python's time functions handle time as a tuple of 9 numbers, as shown below −
Index Field Values
0 4-digit year 2008
1 Month 1 to 12
2 Day 1 to 31
3 Hour 0 to 23
4 Minute 0 to 59
5 Second 0 to 61 (60 or 61 are leap-seconds)
6 Day of Week 0 to 6 (0 is Monday)
7 Day of year 1 to 366 (Julian day)
The above tuple is equivalent to struct_time structure. This structure has following
attributes −
Index Attributes Values
0 tm_year 2008
1 tm_mon 1 to 12
2 tm_mday 1 to 31
3 tm_hour 0 to 23
4 tm_min 0 to 59
46
 5 tm_sec 0 to 61 (60 or 61 are leap-seconds)
6 tm_wday 0 to 6 (0 is Monday)
7 tm_yday 1 to 366 (Julian day)
Getting current time
To translate a time instant from a seconds since the epochfloating-point value into a time-
tuple, pass the floating-point value to a function (e.g., localtime) that returns a time-tuple
with all nine items valid.

import time;

localtime = time.localtime(time.time())
print "Local current time :", localtime

This would produce the following result, which could be formatted in any other presentable
form −

Local current time : time.struct_time(tm_year=2013, tm_mon=7,

tm_mday=17, tm_hour=21, tm_min=26, tm_sec=3, tm_wday=2, tm_yday=198, tm_isdst=0)

Getting formatted time

You can format any time as per your requirement, but simple method to get time in readable
format is asctime() −

import time;
localtime = time.asctime( time.localtime(time.time()) )
print "Local current time :", localtime

This would produce the following result −

Local current time : Tue Jan 13 10:17:09 2009

Getting calendar for a month

The calendar module gives a wide range of methods to play with yearly and monthly
calendars. Here, we print a calendar for a given month ( Jan 2008 ) −

import calendar
cal = calendar.month(2008, 1)
print "Here is the calendar:"
print cal

This would produce the following result −

Here is the calendar:

January 2008

47
Mo Tu We Th Fr Sa Su
1 2 3 4 5 6
7 8 9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30 31

The time Module
There is a popular time module available in Python which provides functions for working
with times and for converting between representations. Here is the list of all available
methods −
Sr.No. Function with Description
1 time.asctime([tupletime])
Accepts a time-tuple and returns a readable 24-character string
such as 'Tue Dec 11 18:07:14 2008'.
2 time.clock( )
Returns the current CPU time as a floating-point number of
seconds. To measure computational costs of different approaches,
the value of time.clock is more useful than that of time.time().
3 time.ctime([secs])
Like asctime(localtime(secs)) and without arguments is like
asctime( )
4 time.localtime([secs])
Accepts an instant expressed in seconds since the epoch and
returns a time-tuple t with the local time (t.tm_isdst is 0 or 1,
depending on whether DST applies to instant secs by local rules).
5 time.sleep(secs)
Suspends the calling thread for secs seconds.
6 time.strftime(fmt[,tupletime])
Accepts an instant expressed as a time-tuple in local time and
returns a string representing the instant as specified by string fmt.
7 time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')
Parses str according to format string fmt and returns the instant in
time-tuple format.
8 time.time( )
Returns the current time instant, a floating-point number of
seconds since the epoch.

The calendar Module

48
The calendar module supplies calendar-related functions, including functions to print a text
calendar for a given month or year.
By default, calendar takes Monday as the first day of the week and Sunday as the last one.
To change this, call calendar.setfirstweekday() function.
Here is a list of functions available with the calendar module −

Sr.No. Function with Description

1 calendar.calendar(year,w=2,l=1,c=6)
Returns a multiline string with a calendar for year year formatted
into three columns separated by c spaces. w is the width in
characters of each date; each line has length 21*w+18+2*c. l is
the number of lines for each week.

2 calendar.firstweekday( )
Returns the current setting for the weekday that starts each week.
By default, when calendar is first imported, this is 0, meaning
Monday.

3 calendar.isleap(year)
Returns True if year is a leap year; otherwise, False.

4 calendar.leapdays(y1,y2)
Returns the total number of leap days in the years within
range(y1,y2).

5 calendar.month(year,month,w=2,l=1)
Returns a multiline string with a calendar for month month of
year year, one line per week plus two header lines. w is the width
in characters of each date; each line has length 7*w+6. l is the
number of lines for each week.

6 calendar.monthcalendar(year,month)
Returns a list of lists of ints. Each sublist denotes a week. Days
outside month month of year year are set to 0; days within the
month are set to their day-of-month, 1 and up.

7 calendar.monthrange(year,month)
Returns two integers. The first one is the code of the weekday
for the first day of the month month in year year; the second one
is the number of days in the month. Weekday codes are 0
(Monday) to 6 (Sunday); month numbers are 1 to 12.

8 calendar.prcal(year,w=2,l=1,c=6)

49
 Like print calendar.calendar(year,w,l,c).

9 calendar.prmonth(year,month,w=2,l=1)
Like print calendar.month(year,month,w,l).

10 calendar.setfirstweekday(weekday)
Sets the first day of each week to weekday code weekday.
Weekday codes are 0 (Monday) to 6 (Sunday).

11 calendar.timegm(tupletime)
The inverse of time.gmtime: accepts a time instant in time-tuple
form and returns the same instant as a floating-point number of
seconds since the epoch.

12 calendar.weekday(year,month,day)
Returns the weekday code for the given date. Weekday codes are
0 (Monday) to 6 (Sunday); month numbers are 1 (January) to 12
(December).

import calendar
import time
cal=calendar.month(1970, 8,w=2,l=1)
print(cal)
cal1=calendar.calendar(2018,w=2,l=1,c=6)
print(cal1)
c1=calendar.isleap(2018)
print(c1)
c2=calendar.leapdays(2004,2018
print(c2)
localtime = time.asctime()
print("Local current time :", localtime)

50