Let’s Learn Python An introduction to Python

Let’s Learn Python
An introduction to Python

Jaganadh G
Project Lead NLP R&D
365Media Pvt. Ltd.
jaganadhg@gmail.com

KiTE, Coimbatore

19 July 2011

Jaganadh G Let’s Learn Python

Just a word about me !!

Working in Natural Language Processing (NLP), Machine
Learning, Data Mining
Passionate about Free and Open source :-)
When gets free time teaches Python and blogs at
http://jaganadhg.freeﬂux.net/blog reviews books for
Packt Publishers.
Works for 365Media Pvt. Ltd. Coimbatore India.
Member of Indian Python Software Society


Python

Python is an easy to learn, powerful programming
language.
It has eﬃcient high-level data structures and a simple but
eﬀective approach to object-oriented programming.
Elegant syntax
Dynamic typing
Interpreted
Ideal for scripting and rapid application development
Developed by Guido Van Rossum
Free and Open Source


Features of Python
Simple
1 Python is a simple and minimalist language
2 Reading a good Python program feels almost like
reading English
Easy to Learn
1 Python is extremely easy to get started with
2 Python has an extraordinarily simple syntax
Free and Open Source
High-level Language
Portable, You can use Python on
1 Linux
2 Microsoft Windows
3 Macintosh
4 ...........

Features of Python

Interpreted
Object Oriented
Extensible
Embeddable
Batteries included


Installing Python
If you are using a Linux distribution such as Fedora or
Ubuntu then you probably already have Python installed
on your system.
To test it open a shell program like gnome-terminal or
konsole and enter the command python -V

If you are using windows - go to
http://www.python.org/download/releases/2.7/ and
download
http://www.python.org/ftp/python/2.7/python-2.7.msi.
Then double click and install it.
You may need to set PATH variable in Environment
Settings

Hello world !!!

Lets write a ”Hello world!!” program
Fire-up the terminal and invoke Python interpreter

Type print ”Hello World !!! ”


Hello world !!!

#!/usr/bin/env python
#Just a Hello World !! program
print "Hello World!!"

You can write the code in you favorite editor, save and
run it.
Extension for the ﬁlename should be .py
Save it as hello.py and make it as executable !
#chmod +x hello.py
Run the program #python hello.py


Using the Python Interpreter

The Python iterpreter can be used as a calculator !!


Keywords

The following are keywords or reserved words in Python
These words can’t be used as variable names or function
names or class names
and del for is raise assert elif from lambda return break else
global not try class except if or while continue exec import
pass yield def ﬁnally in print


Variables

age = 32
year = 1997
avg = 12.5
Note:
There is no need to specify the type as like in C or Java


String

name = ”jagan”
anname = ’jagan’
annname = ”””jagan”””
Note:
There is no need to specify the type as like in C or Java


Identifier Naming

Identifiers
Identifiers are names given to identify something.
Rules to follow for naming identifiers
1 The first character of the identifier must be a letter of
the alphabet (upper or lowercase) or an underscore (’ ’).
2 The rest of the identifier name can consist of letters
(upper or lowercase), underscores (’ ’) or digits (0-9).
3 Identifier names are case-sensitive. For example,
myname andmyName are not the same. Note the
lowercase n in the former and the uppercaseN in te
latter.
4 Examples of valid identifier names arei, my name,
name 23 and a1b c3 .
5 Examples of invalid identifier names are 2things, this is
spaced out and my-name.


Operators

+ Plus
- Minus
/ divide
* Multiply
** Power
// Floor Division
% Modulo
< Less than
> Greater than
<= Less than or equal to
>= Greater than equal to
== Equal to


Basic Math

!= Not equal to
not Boolian NOT
and Boolian AND
or Boolian OR
& Bitwise AND

Note:
Operator precedence is as same as of other programming
languages


Data Structure: List

A list is a data structure that holds an ordered collection
of items
fruits = [’apple’,’banana’,’orange’]
marks = [12,15,17]
avgs = [1.5, 4.5,7.8]
avgm = [1.5, 4.5,7.8,avgs]
lists are mutable
elemnts can be accessed by index numbers
either positive index or negative index can be used to
access elements



elemnts can be accessed by index numbers
fruits[0]
elements can be accessed with positive or negative index
avgs[-1]
new elements can be appended to a list
fruits.append(’cherry’)
list can be sorted or reversed
fruits.sort()
fruits.reverse()
length of a list can be identiﬁed by the ’len’ function
len(fruits)



elements can be deleted del fruits[0]
list can be sliced new list = fruits[1:3]
lists can be extended
flowers = [’rose’,’lilly’,’tulip’]
fruits.extend(flowers)
the index method can be used to find index of an item in
a list
fruits.index(’apple’)



The pop method removes an element from a list
fruits.pop()
The remove method is used to remove the first
occurrence of a value:
flowers = [’rose’,’lilly’,’tulip’,’rose’]
flowers.remove(’rose’)
The reverse method reverses the elements in the list.
flowers.reverse()
The sort method is used to sort lists in place
flowers.sort()



>>> numbers = [5, 2, 9, 7]
>>> numbers.sort(cmp)
>>> numbers
[2, 5, 7, 9]
>>> x = [’aardvark’, ’abalone’, ’acme’,
’add’, ’aerate’]
>>> x.sort(key=len)
>>> x
[’add’, ’acme’, ’aerate’, ’abalone’, ’aardvark’]
>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort(reverse=True)


Data Structure: Tuple

Tuples are sequences like lists .
The only diﬀerence is that tuples are immutable
Values in a tuple are enclosed in parentheses (())
mytuple = (2,3,4,5,6,7,8)
Elements in a tuple can be accessed by index value
It is not possible to sort or reverse tuple


Data Structure: Tuple

There is a way to sort and reverse tuple
atuple = (9,6,4,8,3,7,2)
sortuple = tuple(sorted(atuple))
revtuple = tuple((reversed(atuple))

Note:
A tuple can be converted to list and vice versa

tup = (1,2,3)
li = list(tup)
atup = tuple(li)


Data Structure: Dictionary

Another useful data type built into Python is the
dictionary
Dictionaries are sometimes found in other languages as
associative memories or associative arrays.
Dictionaries consist of pairs (called items) of keys and
their corresponding values
phonebook = {’Alice’: ’2341’, ’Beth’: ’9102’,
’Cecil’: ’3258’}
phonebook[’Alice’] #’2341’


Basic Dictionary Operations

len(d) returns the number of items (key-value pairs) in d
d = {’Alice’: ’2341’, ’Beth’: ’9102’, ’Cecil’: ’325
len(d)
3
d[’Alice’] returns the value associated with the key k ie
”2341”
d[’Alice’] = ’456’ associates the value ’456’ with the key
’Alice’
del d[’Alice’] deletes the item with key ’Alice’
’Alice’ in d checks whether there is an item in d that has
the key ’Alice’



Key types: Dictionary keys dont have to be integers
(though they may be). They may be any immutable type,
such as ﬂoating-point (real) numbers, strings, or tuples.
Automatic addition: You can assign a value to a key, even
if that key isnt in the dictionary to begin with; in that
case, a new item will be created. You cannot assign a
value to an index outside the lists range (without using
append or something like that).
phonebook[’Ravi’] = ’567’
Membership: The expression k in d (where d is a
dictionary) looks for a key, not a value.
’Alice’ in phonebook



All the keys in a dictionary can be accessed as a list
phonebook.keys()
[’Beth’, ’Alice’, ’Cecil’]

All the values in a dictionary can be accessed as a list
phonebook.values()
[’9102’, ’2341’, ’3258’]
The keys and values in a dictionary can be accessed as a
list of tuples
phonebook.items()
[(’Beth’, ’9102’), (’Alice’, ’2341’),
(’Cecil’, ’3258’)]


Control Flow:The if statement

The if statement is used to check a condition and if the
condition is true, we run a block of statements (called the
if-block), else we process another block of statements (called
the else-block). The else clause is optional.

if <test1>: #if test
<statement1> #associated block
elif <test2>: # Optional else if (elif)
<statement2>
else: #optional else
<statement3>


Control Flow:The if statement

name = raw_input(""Enter your name: "")
if name == "trisha":
print "Hi trisha have you seen my chitti"
elif name == "aishwarya":
print "Hai Aishu have u seen my chitti"
else:
print "Oh!! my chitti !!!!"


Control Flow:The while statement

The while statement allows you to repeatedly execute a block
of statements as long as a condition is true. A while statement
is an example of what is called a looping statement. A while
statement can have an optional else clause.The structure of
while loop is

while <test>:
<statement>
else:
<statement>


Control Flow:The while statement

#!/usr/bin/python
a = 0
b = 10
while a < b:
print a
a += 1
#0123456789


Control Flow:The for loop

The for..in statement is another looping statement which
iterates over a sequence of objects i.e. go through each item
in a sequence.

for <target> in <object>:
<statement>
else:
statement



#!/usr/bin/python
names = [’Jaganadh’,’Biju’,’Sreejith’,
’Kenneth’,’Sundaram’]
for name in names:
print "Hello %s" %name



#!/usr/bin/python

for i in range(1, 5):
print i
else:
print ’The for loop is over’


Control Flow: The break,continue and pass
statement

The break statement is used to break out of a loop statement
i.e. stop the execution of a looping state-ment, even if the
loop condition has not become False or the sequence of items
has been completely iterated over.

while <test1>:
<statement>
if <test1>:break
else <test2>:continue
else:
<statement>


Control Flow: continue

#Example for continue
x = 10
while x:
x = x -1
if x % 2 != 0: continue
print x


Control Flow:break

#Example for break
while True:
s = raw_input(’Enter something : ’)
if s == ’quit’:
break
print ’Length of the string is’, len(s)
print ’Done’


Control Flow:pass

#Example for pass
while 1:
pass


Functions
Functions are reusable pieces of programs. They allow you to
give a name to a block of statements and you can run that
block using that name anywhere in your program and any
number of times. This is known as calling the function.
Deﬁning Functions
def <name>(arg1,arg2,...argN):
<statement>
#!/usr/bin/python
# Filename: function1.py
def sayHello():
print ’Hello World!’
# End of function
sayHello() # call the function


Functions with parameters
A function can take parameters which are just values you
supply to the function so that the function can do something
utilising those values.
#!/usr/bin/python
# Filename: func_param.py
def printMax(a, b):
if a > b:
print a, ’is maximum’
else:
print b, ’is maximum’

printMax(3, 4) # directly give literal values
x = 5
y = 7
printMax(x, y)

Functions: Using Keyword Arguments

#!/usr/bin/python
# Filename: func_key.py
def func(a, b=5, c=10):
print ’a is’, a, ’and b is’, b, ’and c is’, c

func(3, 7)
func(25, c=24)
func(c=50, a=100)


Functions: Return Statement

#!/usr/bin/python
# Filename: func_return.py
def maximum(x, y):
if x > y:
return x
else:
return y

print maximum(2, 3)


Functions: Arbitrary Arguments

def minimum(*args):
res = args[0]
for arg in args[1:]:
if arg < res:
res = arg
return res

print minimum(3,4,1,2,5)


Functions: Arbitrary Arguments

def arbArg(**args):
print args

print arbArg(a=1,b=2,c=6)
#{’a’: 1, ’c’: 6, ’b’: 2}


Object Oriented Programming

#!/usr/bin/python
# Filename: simplestclass.py
class Person:
pass # An empty block

p = Person()
print p


Object Oriented Programming:Using Object
Methods

Class/objects can have methods just like functions except that
we have an extra self variable.

class Person:
def sayHi(self):
print ’Hello, how are you?’

p = Person()
p.sayHi()


Object Oriented Programming:The init
method
The init method is run as soon as an object of a class is
instantiated. The method is useful to do any initialization you
want to do with your object. Notice the double underscore
both in the beginning and at the end in the name.
#!/usr/bin/python
# Filename: class_init.py
class Person:
def __init__(self, name):
self.name = name
def sayHi(self):
print ’Hello, my name is’, self.name

p = Person(’Jaganadh G’)
p.sayHi()

Object Oriented Programming:Class and
Object Variables
There are two types of fields - class variables and object
variables which are classified depending on whether the class
or the object owns the variables respectively.
Class variables are shared in the sense that they are accessed
by all objects (instances) of that class.There is only copy of
the class variable and when any one object makes a change to
a class variable, the change is reflected in all the other
instances as well.
Object variables are owned by each individual object/instance
of the class. In this case, each object has its own copy of the
field i.e. they are not shared and are not related in any way to
the field by the samen name in a different instance of the
same class.

Object Variables

#!/usr/bin/python
# Filename: objvar.py
class Person:
’’’Represents a person.’’’
population = 0
def __init__(self, name):
’’’Initializes the person’s data.’’’
self.name = name
print ’(Initializing %s)’ % self.name
Person.population += 1


Object Variables
def __del__(self):
’’’I am dying.’’’
print ’%s says bye.’ % self.name
Person.population -= 1
if Person.population == 0:
print ’I am the last one.’
else:
print ’There are still %d people left.’
% Person.population

def sayHi(self):
’’’Greeting by the person.
Really, that’s all it does.’’’
print ’Hi, my name is %s.’ % self.name

Object Variables
def howMany(self):
’’’Prints the current population.’’’
if Person.population == 1:
print ’I am the only person here.’
else:
print ’We have %d persons here.’
% Person.population

swaroop = Person(’Swaroop’)
swaroop.sayHi()
swaroop.howMany()
kalam = Person(’Abdul Kalam’)
kalam.sayHi()
kalam.howMany()

Object Oriented Programming: Inheritance
#!/usr/bin/python
# Filename: inherit.py

class SchoolMember:
’’’Represents any school member.’’’
def __init__(self, name, age):
self.name = name
self.age = age
print ’(Initialized SchoolMember: %s)’
% self.name

def tell(self):
’’’Tell my details.’’’
print ’Name:"%s" Age:"%s"’ % (self.name,
self.age),


class Teacher(SchoolMember):
’’’Represents a teacher.’’’
def __init__(self, name, age, salary):
SchoolMember.__init__(self, name, age)
self.salary = salary
print ’(Initialized Teacher: %s)’ % self.name

def tell(self):
SchoolMember.tell(self)
print ’Salary: "%d"’ % self.salary


class Student(SchoolMember):
’’’Represents a student.’’’
def __init__(self, name, age, marks):
SchoolMember.__init__(self, name, age)
self.marks = marks
print ’(Initialized Student: %s)’ % self.name

def tell(self):
SchoolMember.tell(self)
print ’Marks: "%d"’ % self.marks
t = Teacher(’Mrs. Shrividya’, 40, 30000)
s = Student(’Swaroop’, 22, 75)
members = [t, s]
for member in members:
member.tell()

Modules

A module is basically a file containing all your functions and
variables that you have defined. To reuse the module in other
programs, the filename of the module must have a .py
extension.
By using the import statement you can use built-in modules in
Python

import sys , os
sys.argv[1]
os.name
os.curdir
import math
math.sqrt(9)


I/O Operations

#File reading
myfile = open("help.txt",’r’)
filetext = myfile.read()
myfile.close()

#file reading 2
myfile = open("help.txt",’r’)
filetext = myfile.readlines()
myfile.close()


I/O Operations

with open(help.txt, r) as f:
read_data = f.read()

#file writing
out = open(’out.txt’,’w’)
out.write("Hello out file")
out.close()


Handling Exceptions

while True:
try:
x = int(raw_input("Please enter a number: "))
break
except ValueError:
print "Oops! That was no valid number.Try again"


Handling Exceptions

import sys
try:
f = open(myfile.txt)
s = f.readline()
i = int(s.strip())
except IOError as (errno, strerror):
print "I/O error({0}): {1}".format(errno, strerror)
except ValueError:
print "Could not convert data to an integer."
except:
print "Unexpected error:", sys.exc_info()[0]
raise


Questions ??


Where can I post questions?

Search in the net . If nothing found
Post in forums
ILUGCBE http://ilugcbe.techstud.org


References

A Byte of Python : Swaroop CH
Dive in to Python
Many wikibooks .............


Finally


Let’s Learn Python An introduction to Python

Related slideshows

More Related Content

Let’s Learn Python An introduction to Python