Understanding

PYTHON
By,
Anand Roy Choudhury
CSE Department,
IIT Bombay.

Overview
History
Assignment and Name conventions
Basic Data types
Sequences types: Lists, Tuples, and

Strings
Mutability
Modules
Errors and Exceptions

Brief History of Python

Invented in the Netherlands, early 90s

by Guido van Rossum

Open source
It is much more than a scripting
language,
Interpreted, object oriented and
functional language

Running Python

The Python Interpreter

Download from http://python.org/download/
Typical Python implementations offer both

an interpreter and compiler

On Ubuntu :
[mooc-34@edx ~]$ python

Python 2.7.3 (default, Feb 27 2014, 19:58:35)

Type "help", "copyright", "credits" or "license" for more
information.

>>>

On Unix:
% python
>>> 3+3
6

Python prompts with >>>.

The Python Interpreter

Download from http://python.org/download/
Typical Python implementations offer both

an interpreter and compiler

On Ubuntu :
[mooc-34@edx ~]$ python

Python 2.7.3 (default, Feb 27 2014, 19:58:35)

Type "help", "copyright", "credits" or "license" for more
information.

>>>

On Unix:
% python
>>> 3+3
6

Python prompts with >>>.

Running Interactively on UNIX

To exit Python

In Unix, type CONTROL-D

In Windows, type CONTROL-Z + <Enter>

Example :

>>> def cube(x):

... return x * x * x
...
>>> map(cube, [1, 2, 3, 4])
[1, 8, 27, 64]
>>>

Running Programs on Ubuntu

Extension : .py
Calling python program via the python

interpreter
>>> python intern.py

Make a python file (For eg. intern.py)

directly executable by

Include the following line as the first line of python file

#!$/usr/bin/env python
For making the file executable run the following
command,
$ sudo chmod +x intern.py
Invoking file from Unix command line
$ ./intern.py

The Basics

Basic Datatypes
Are Immutable
4 types :
Long
Int
complex (complex numbers)
Floats x = 3.456
Strings
Can use or to specify with abc == abc
Unmatched can occur within the string:
m atts
Use triple double-quotes for multi-line strings or
strings than contain both and inside of them:
abc

Whitespace
Whitespace is meaningful in Python:
especially indentation and placement of
newlines
Use a newline to end a line of code
l

Use \ when must go to next line prematurely

No braces {} to mark blocks of code, use

consistent indentation instead

l
l

First line with less indentation is outside of the block

First line with more indentation starts a nested block

Colons start of a new block in many

constructs, e.g. function definitions, if

then clauses, for loops etc.

Comments
Start comments with #, rest of line is

ignored
Can include a documentation string as
the first line of a new function or class
you define
Development environments, debugger,
and other tools use it: its good style to
include one
def fact(n):
fact(n) assumes n is a positive integer
and returns facorial of n.
assert(n>0)
return 1 if n==1 else n*fact(n-1)

Assignment
Binding

a variable in Python means setting a

name to hold a reference to some object
Assignment

creates references, not copies

Names in Python do not have an intrinsic

type, objects have types

Python

determines the type of the reference

automatically based on what data is assigned to it

You create a name the first time it appears on

the left side of an assignment expression:

x = 3

A reference is deleted via garbage collection

after any names bound to it have passed out

of scope

Naming Rules
Names are case sensitive and cannot start

with a number. They can contain letters,

numbers, and underscores.

bob Bob _bob _2_bob_ bob_2 BoB

There are some reserved words:
and, assert, break, class, continue, def,
del, elif, else, except, exec, finally, for,
from, global, if, import, in, is, lambda,
not, or, pass, print, raise, return, try,
while

Assignment
You can assign to multiple names at

the same time

>>> x, y = 2, 3
>>> x
2
>>> y
3

This makes it easy to swap values

>>> x, y = y, x

Assignments can be chained

>>> a = b = x = 2

Accessing Non-Existent Name

Accessing a name before its been
properly created (by placing it on the left
side of an assignment), raises an error
>>> y
Traceback (most recent call last):
File "<pyshell#16>", line 1, in -toplevely
NameError: name y' is not defined
>>> y = 3
>>> y
3

Control Flow
The While statement

count = 0
while (count < 9):
print 'The count is:', count
count = count + 1

for Statements

words = ['cat', 'window', 'defenestrate']

for w in words:
print w

Control Flow
The if statement
x = int(input("Please enter an integer: "))
if x < 0:
x=0
print 'Negative changed to zero'
elif x == 0:
print 'Zero'
elif x == 1:
print 'Single'
else:
print 'More'
range() Function
for i in range(5):
print i

Control Flow

pass / break / continue Statements

for letter in 'Python':

if letter == 'h':
break
print 'Current Letter :', letter

Functions
Defining Functions:
>>> def fib(n):
# write Fibonacci series up to n.Print a Fibonacci
series up to n.
...
a, b = 0, 1
...
while a < n:
...
print a,
...
a, b = b, a+b
...
print
...
>>> # Now call the function we just defined:
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
1597

Keyword Arguments
Functions can be called using

keyword arguments of the form kwarg=value.

For instance, the following function:
def parrot(voltage, state='a stiff', action='voom', type='Norwegian'):
print "-- This parrot wouldn't", action, end=' '
print "if you put", voltage, "volts through it."
print "-- Lovely plumage, the", type
print "-- It's", state, "!"

accepts one required argument (voltage) and

three optional arguments (state, action, and

type).

Function Call
This function can be called in any of the

following ways:
parrot(1000)
parrot(voltage=1000)
parrot(voltage=1000000,

# 1 positional argument
# 1 keyword argument
action='VOOOOOM')

#2 keyword arguments
parrot(action='VOOOOOM', voltage=1000000)
# 2 keyword arguments
parrot('a
parrot('a

million', 'bereft of life', 'jump')

# 3 positional arguments

thousand', state='pushing up the daisies')

# 1 positional, 1 keyword

Java vs Python
JAVA

23

PYTHON

All variable names (along with their types) must be

explicitly declared.

In Python, you never declare anything.

Java container objects (e.g. Vector and ArrayList) hold

objects of the generic type Object, but cannot hold
primitives such as int.

Python container objects (e.g. lists and dictionaries) can

hold objects of any type, including numbers and lists.
When you retrieve an object from a container, it
remembers its type, so no casting is required.

public class HelloWorld

{
public static void main (String[] args)
{
System.out.println("Hellold!");
}
}

print "Hello, world!"

Each top-level public class must be defined in its own

file. If your application has 15 such classes, it has 15
files.

Multiple classes can be defined in a single file. If your

application has 15 classes, the entire application could
be stored in a single file,

Sequence types:
Tuples, Lists, and
Strings

Sequence Types
1.Tuple: (john, 32, [CMSC])
A simple immutable ordered sequence
of items
Items can be of mixed types, including
collection types
2.Strings: John Smith

Immutable
Conceptually very much like a tuple

3.List: [1, 2, john, (up, down)]

Mutable ordered sequence of items of
mixed types

Similar Syntax
All three sequence types (tuples,

strings, and lists) share much of the

same syntax and functionality.
Key difference:
Tuples and strings are immutable
Lists are mutable
The operations shown in this section
can be applied to all sequence types
most examples will just show the
operation performed on one

Sequence Types 1
Define tuples using parentheses and

commas
>>> tu = (23, abc, 4.56, (2,3), def)

Define lists are using square brackets

and commas
>>> li = [abc, 34, 4.34, 23]

Define strings using quotes (, , or ).

>>> st
>>> st
>>> st
string

= Hello World
= Hello World
= This is a multi-line
that uses triple quotes.

Sequence Types 2
Access individual members of a tuple,

list, or string using square bracket

array notation
Note that all are 0 based
>>> tu = (23, abc, 4.56, (2,3), def)
>>> tu[1]
# Second item in the tuple.
abc
>>> li = [abc, 34, 4.34, 23]
>>> li[1]
# Second item in the list.
34
>>> st = Hello World
>>> st[1]
# Second character in string.
e

Positive and negative indices

>>> t = (23, abc, 4.56, (2,3),

def)
Positive index: count from the left, starting
with 0
>>> t[1]
abc
Negative index: count from right, starting
with 1
>>> t[-3]
4.56

Slicing: return copy of a subset

>>> t = (23, abc, 4.56, (2,3),
def)

Return a copy of the container with a

subset of the original members. Start
copying at the first index, and stop
copying before second.
>>> t[1:4]
(abc, 4.56, (2,3))
Negative indices count from end
>>> t[1:-1]
(abc, 4.56, (2,3))

Slicing: return copy of a =subset

>>> t = (23, abc, 4.56, (2,3),
def)
Omit first index to make copy starting
from beginning of the container
>>> t[:2]
(23, abc)
Omit second index to make copy starting
at first index and going to end
>>> t[2:]
(4.56, (2,3), def)

Copying the Whole Sequence

[ : ] makes a

copy of an entire sequence

>>> t[:]
(23, abc, 4.56, (2,3), def)
Note the difference between these two
lines for mutable sequences
>>> l2 = l1 # Both refer to 1 ref,
# changing one affects both
>>> l2 = l1[:] # Independent copies,
two refs

The in Operator
Boolean test whether a value is inside a

container:

>>> t
>>> 3
False
>>> 4
True
>>> 4
False

= [1, 2, 4, 5]
in t
in t
not in t

For strings, tests for substrings

>>> a = 'abcde'
>>> 'cd' in a
True
>>> 'ac' in a
False

The + Operator
The + operator produces a new tuple, list, or
string whose value is the concatenation of its
arguments.
>>> (1, 2, 3) + (4, 5, 6)
(1, 2, 3, 4, 5, 6)
>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> Hello + + World
Hello World

The * Operator
new tuple, list, or
string that repeats the original content.

The * operator produces a

>>> (1, 2, 3) * 3
(1, 2, 3, 1, 2, 3, 1, 2, 3)
>>> [1, 2, 3] * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> Hello * 3
HelloHelloHello

Mutability:
Tuples vs. Lists

Lists are mutable

>>> li = [abc, 23, 4.34, 23]
>>> li[1] = 45
>>> li
[abc, 45, 4.34, 23]
We can change lists in place.
Name li still points to the same

memory reference when were done.

Tuples are immutable

>>> t = (23, abc, 4.56, (2,3), def)
>>> t[2] = 3.14
Traceback (most recent call last):
File "<pyshell#75>", line 1, in -topleveltu[2] = 3.14
TypeError: object doesn't support item assignment

You cant change a tuple.

You can make a fresh tuple and assign

its reference to a previously used name.

>>> t = (23, abc, 3.14, (2,3), def)

The

immutability of tuples means theyre

faster than lists.

Operations on Lists Only

>>> li = [1, 11, 3, 4, 5]
>>> li.append(a) # Note the method
syntax
>>> li
[1, 11, 3, 4, 5, a]
>>> li.insert(2, i)
>>>li
[1, 11, i, 3, 4, 5, a]

The extend method vs

+ creates a fresh list with a new memory ref

extend operates on list li in place.

>>> li.extend([9, 8, 7])

>>> li
[1, 2, i, 3, 4, 5, a, 9, 8, 7]
Potentially confusing:
extend takes a list as an argument.
append takes a singleton as an argument.
>>> li.append([10, 11, 12])
>>> li
[1, 2, i, 3, 4, 5, a, 9, 8, 7, [10, 11,
12]]

Operations on Lists Only

Lists have many methods, including index,
count, remove, reverse, sort
>>> li = [a, b, c, b]
>>> li.index(b) # index of 1st
occurrence
1
>>> li.count(b) # number of occurrences
2
>>> li.remove(b) # remove 1st occurrence
>>> li
[a, c, b]

Operations on Lists Only

>>> li = [5, 2, 6, 8]
>>> li.reverse()
>>> li
[8, 6, 2, 5]

# reverse the list *in place*

>>> li.sort()
>>> li
[2, 5, 6, 8]

# sort the list *in place*

>>> li.sort(some_function)
# sort in place using user-defined comparison

Tuple details
The comma is the tuple creation operator, not

parentheses
>>> 1,
(1,)

Python shows parentheses for clarity

>>> (1,)
(1,)

Don't forget the comma!

>>> (1)
1

Trailing comma only required for singletons

Empty tuples have a special syntactic form
>>> ()
()
>>> tuple()
()

Summary: Tuples vs. Lists

Lists slower but more powerful than tuples
Lists

can be modified, and they have lots of

handy operations and mehtods
Tuples are immutable and have fewer
features
To convert between tuples and lists use the
list() and tuple() functions:
li = list(tu)
tu = tuple(li)

MODULES
What is a Module?

A module is a file containing Python

definitions and statements. The file name is the
module name with the suffix.pyappended.
Within a module, the modules name (as a
string) is available as the value of the global
variable__name__. For instance, use your
favorite text editor to create a file called
fibo.pyin the current directory with the
following contents

fibo.py
# Fibonacci numbers module
def fib(n): # write Fibonacci series up to n
a, b = 0, 1
while b < n:
print b,
a, b = b, a+b
print
def fib2(n): # return Fibonacci series up to n
result = []
a, b = 0, 1
while b < n:
result.append(b)
a, b = b, a+b
return result

MODULE
Now enter the Python interpreter and import this module with
the following command:
>>> import fibo
This does not enter the names of the functions defined
infibodirectly in the current symbol table; it only enters the
module namefibothere. Using the module name you can access
the functions:
>>> fibo.fib(1000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'

The Module Search Path

When a module namedcreatelist.pyis imported,
the interpreter first searches for a built-in module
with that name. If not found, it then searches for a file
namedcreatelist.pyin a list of directories given by
the variablesys.path.
sys.pathis initialized from these locations:
The directory containing the input script (or the current

directory when no file is specified).

PYTHONPATH(a list of directory names, with the same syntax

as the shell variablePATH).

Errors and Exception

Syntax Errors
Syntax errors (or parsing errors), are perhaps the most common
kind of complaint you get while you are still learning Python :
>>> while True print 'Hello world
File "<stdin>", line 1, in ?
while True print 'Hello world
^
SyntaxError: invalid syntax
The parser repeats the offending line and displays a little
arrow pointing at the earliest point in the line where the error was
detected. The error is caused by (or at least detected at) the
tokenprecedingthe arrow: in the example, the error is detected at
the functionprint(), since a colon (':') is missing before it. File name
and line number are printed so you know where to look in case the
input came from a script.

Errors and Exception

Exceptions:
Even if a statement or expression is syntactically correct, it
may cause an error when an attempt is made to execute it.
Errors detected during execution are calledexceptions. Most
exceptions are not handled by programs, however, and result in
error messages as shown here:
>>> 10 * (1/0)
Traceback (most recent call last): File "<stdin>", line 1, in ?
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last): File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last): File "<stdin>", line 1, in ?
TypeError: Can't convert 'int' object to str implicitly

Handling Exception
It is possible to write programs that handle selected
exceptions. Look at the following example, which asks the user
for input until a valid integer has been entered, but allows the
user to interrupt the program (usingControl-Cor whatever the
operating system supports); note that a user-generated
interruption is signalled by raising theKeyboardInterrupt
exception.
>>> while True:
try:
x = int(input("Please enter a number: "))
break
except ValueError:
print "Oops! That was no valid number. Try again..."

Handling Exception
Thetrystatementworksasfollows.
First,thetryclause(thestatement(s)between
thetryandexceptkeywords)isexecuted.
If no exception occurs, theexcept clauseis skipped and
execution of thetrystatement is finished.
If an exception occurs during execution of the try clause,
the rest of the clause is skipped. Then if its type matches
the exception named after the exceptkeyword, the
except clause is executed, and then execution continues
after thetrystatement.
If an exception occurs which does not match the
exception named in the except clause, it is passed on to
outertrystatements; if no handler is found, it is
anunhandled exceptionand execution stops.

Enough to Understand the Code

Indentation matters to code meaning
Block structure indicated by indentation
First assignment to a variable creates it
Variable types dont need to be declared.
Python figures out the variable types on its
own.
Assignment is = and comparison is ==
For numbers + - * / % are as expected
Special use of + for string concatenation and
% for string formatting (as in Cs printf)
Logical operators are words (and, or,

not) not symbols

The basic printing command is print

End

.Thank You