Introduction to Python

Introduction to Python
A dynamically typed programming language
allowing multiple paradigms – OO, functional

Narendran Thangarajan,
@naren_live
SSN College of Engg,
Chennai

Why Python?

 Productivity and readable code

 Dynamic Type system

 Automatic Memory Mangement

 No braces : "Life's better without braces"
(Bruce Eckel)

Tutorial Outline

 Interactive "shell"
 Basic types: numbers, strings
 Container types: lists, dictionaries, tuples
 Variables
 Control structures
 Functions & procedures
 Classes & instances
 Modules & packages
 Exceptions
 Files & standard library

Interactive “Shell”

 Great for learning the language
 Great for experimenting with the library
 Great for testing your own modules
 Two variations: IDLE (GUI),
python (command line)
 Type statements or expressions at prompt:
>>> print "Hello, world"
Hello, world
>>> x = 12**2
>>> x/2
72
>>> # this is a comment

Numbers

 The usual suspects
 12, 3.14, 0xFF, 0377, (-1+2)*3/4**5, abs(x), 0<x<=5

 C-style shifting & masking
 1<<16, x&0xff, x|1, ~x, x^y

 Integer division truncates :-(
 1/2 -> 0 # 1./2. -> 0.5, float(1)/2 -> 0.5
 Will be fixed in the future

 Long (arbitrary precision), complex
 2L**100 -> 1267650600228229401496703205376L
 In Python 2.2 and beyond, 2**100 does the same thing
 1j**2 -> (-1+0j)

Strings

 "hello"+"world" "helloworld" #
concatenation
 "hello"*3 "hellohellohello" # repetition
 "hello"[0] "h" # indexing
 "hello"[-1] "o" # (from end)
 "hello"[1:4] "ell" # slicing
 len("hello") 5 # size
 "hello" < "jello" 1 # comparison
 "e" in "hello" 1 # search
 "escapes: n etc, 033 etc, if etc"
 'single quotes' """triple quotes""" r"raw strings"

Lists

 Flexible arrays, not Lisp-like linked lists
 a = [99, "bottles of beer", ["on", "the", "wall"]]

 Same operators as for strings
 a+b, a*3, a[0], a[-1], a[1:], len(a)

 Item and slice assignment
 a[0] = 98
 a[1:2] = ["bottles", "of", "beer"]
-> [98, "bottles", "of", "beer", ["on", "the", "wall"]]
 del a[-1] # -> [98, "bottles", "of", "beer"]

More List Operations

>>> a = range(5) # [0,1,2,3,4]
>>> a.append(5) # [0,1,2,3,4,5]
>>> a.pop() # [0,1,2,3,4]
5
>>> a.insert(0, 42) # [42,0,1,2,3,4]
>>> a.pop(0) # [0,1,2,3,4]
5.5
>>> a.reverse() # [4,3,2,1,0]
>>> a.sort() # [0,1,2,3,4]

Dictionaries

 Hash tables, "associative arrays"
 d = {"duck": "eend", "water": "water"}

 Lookup:
 d["duck"] -> "eend"
 d["back"] # raises KeyError exception

 Delete, insert, overwrite:
 del d["water"] # {"duck": "eend", "back": "rug"}
 d["back"] = "rug" # {"duck": "eend", "back": "rug"}
 d["duck"] = "duik" # {"duck": "duik", "back": "rug"}

More Dictionary Ops

 Keys, values, items:
 d.keys() -> ["duck", "back"]
 d.values() -> ["duik", "rug"]
 d.items() -> [("duck","duik"), ("back","rug")]

 Presence check:
 d.has_key("duck") -> 1; d.has_key("spam") ->
0

 Values of any type; keys almost any
 {"name":"Guido", "age":43, ("hello","world"):1,
42:"yes", "flag": ["red","white","blue"]}

Dictionary Details

 Keys must be immutable:
 numbers, strings, tuples of immutables
 these cannot be changed after creation
 reason is hashing (fast lookup technique)
 not lists or other dictionaries
 these types of objects can be changed "in
place"
 no restrictions on values
 Keys will be listed in arbitrary order
 again, because of hashing

Tuples

 key = (lastname, firstname)
 point = x, y, z # parentheses optional
 x, y, z = point # unpack
 lastname = key[0]
 singleton = (1,) # trailing comma!!!
 empty = () # parentheses!
 tuples vs. lists; tuples immutable

Variables

 No need to declare
 Need to assign (initialize)
 use of uninitialized variable raises exception

 Not typed
if friendly: greeting = "hello world"
else: greeting = 12**2
print greeting

 Everything is a "variable":
 Even functions, classes, modules

Reference Semantics

 Assignment manipulates references
 x = y does not make a copy of y
 x = y makes x reference the object y references

 Very useful; but beware!
 Example:
>>> a = [1, 2, 3]
>>> b = a
>>> a.append(4)
>>> print b
[1, 2, 3, 4]

Changing a Shared List

a = [1, 2, 3] a 1 2 3

a
b=a 1 2 3
b

a
a.append(4) 1 2 3 4
b

Changing an Integer

a=1 a 1

a
b=a 1
b new int object created
by add operator (1+1)

a 2
a = a+1 old reference deleted
by assignment (a=...)
b 1

Control Structures

if condition: while condition:
statements
statements
[elif condition:
for var in sequence:
statements] ...
else: statements
statements break

continue

Grouping Indentation

In Python: In C:

for (i = 0; i < 20; i++)
for i in range(20):
if i%3 == 0: {

print i if (i%3 == 0) {
if i%5 == 0:
printf("%dn", i);
print "Bingo!"
print "---" if (i%5 == 0) {

printf("Bingo!n"); }

}

printf("---n");

}

Functions, Procedures

def name(arg1, arg2, ...):
"""documentation""" # optional doc string
statements

return # from procedure
return expression # from function

Example Function

def gcd(a, b):
"greatest common divisor"
while a != 0:
a, b = b%a, a # parallel assignment
return b

>>> gcd.__doc__
'greatest common divisor'
>>> gcd(12, 20)
4

Classes

class name:
"documentation"
statements
-or-
class name(base1, base2, ...):
...
Most, statements are method definitions:
def name(self, arg1, arg2, ...):
...
May also be class variable assignments

Example Class

class Stack:
"A well-known data structure…"
def __init__(self): # constructor
self.items = []
def push(self, x):
self.items.append(x) # the sky is the limit
def pop(self):
x = self.items[-1] # what happens if it’s empty?
del self.items[-1]
return x
def empty(self):
return len(self.items) == 0 # Boolean result

Using Classes

 To create an instance, simply call the class object:
x = Stack()# no 'new' operator!

 To use methods of the instance, call using dot notation:
x.empty() # -> 1
x.push(1) # [1]
x.empty() # -> 0
x.push("hello") # [1, "hello"]
x.pop() # -> "hello" # [1]

 To inspect instance variables, use dot notation:
x.items # -> [1]

Subclassing

class FancyStack(Stack):
"stack with added ability to inspect inferior stack items"

def peek(self, n):
"peek(0) returns top; peek(-1) returns item below that; etc."
size = len(self.items)
assert 0 <= n < size # test precondition
return self.items[size-1-n]

Subclassing (2)

class LimitedStack(FancyStack):
"fancy stack with limit on stack size"

def __init__(self, limit):
self.limit = limit
FancyStack.__init__(self) # base class constructor

def push(self, x):
assert len(self.items) < self.limit
FancyStack.push(self, x) # "super" method call

Class / Instance Variables

class Connection:
verbose = 0 # class variable
def __init__(self, host):
self.host = host # instance variable
def debug(self, v):
self.verbose = v # make instance variable!
def connect(self):
if self.verbose: # class or instance variable?
print "connecting to", self.host

Instance Variable Rules

 On use via instance (self.x), search order:
 (1) instance, (2) class, (3) base classes
 this also works for method lookup

 On assignment via instance (self.x = ...):
 always makes an instance variable
 Class variables "default" for instance variables
 But...!
 mutable class variable: one copy shared by all
 mutable instance variable: each instance its own

Modules

 Collection of stuff in foo.py file
 functions, classes, variables
 Importing modules:
 import re; print re.match("[a-z]+", s)
 from re import match; print match("[a-z]+", s)
 Import with rename:
 import re as regex
 from re import match as m
 Before Python 2.0:
 import re; regex = re; del re

Packages

 Collection of modules in directory
 Must have __init__.py file
 May contain subpackages
 Import syntax:
 from P.Q.M import foo; print foo()
 from P.Q import M; print M.foo()
 import P.Q.M; print P.Q.M.foo()
 import P.Q.M as M; print M.foo() # new

Catching Exceptions

def foo(x):
return 1/x

def bar(x):
try:
print foo(x)
except ZeroDivisionError, message:
print "Can’t divide by zero:", message

bar(0)

Try-finally: Cleanup

f = open(file)
try:
process_file(f)
finally:
f.close() # always executed
print "OK" # executed on success only

Raising Exceptions

 raise IndexError
 raise IndexError("k out of range")
 raise IndexError, "k out of range"
 try:
something
except: # catch everything
print "Oops"
raise # reraise

File Objects

 f = open(filename[, mode[, buffersize])
 mode can be "r", "w", "a" (like C stdio); default "r"
 append "b" for text translation mode
 append "+" for read/write open
 buffersize: 0=unbuffered; 1=line-buffered; buffered
 methods:
 read([nbytes]), readline(), readlines()
 write(string), writelines(list)
 seek(pos[, how]), tell()
 flush(), close()
 fileno()

Introduction to Python

More Related Content

What's hot (20)

Viewers also liked (7)

Similar to Introduction to Python (20)

More from UC San Diego (15)

Recently uploaded (20)

Introduction to Python