workshop on python

S. Mahbub - Uz - Zaman (09301004)BRAC UNIVERSITY

Department of Computer Science and Engineering

Workshop On

Python

● Python is a dynamic object-oriented programming language that can be used for many kinds of software development.

● It offers strong support for integration with other languages and tools, comes with extensive standard libraries

● Python runs on Windows, Linux/Unix, Mac OS X, OS/2, Amiga, Palm Handhelds, and Nokia mobile phones. Python has also been ported to the Java and .NET virtual machines.

● Python is distributed under an OSI-approved open source license that makes it free to use, even for commercial products.

● It appeared in 1991 and influenced by languages like ABC, ALGOL 68, C, C++, Dylan, Haskell, Icon, Java, Lisp, Modula-3, and Perl. Python has a large and comprehensive standard library.

● Libraries like NumPy, SciPy and Matplotlib allow Python to be used effectively in scientific computing.1

Current Version is 3.3.0We will be using 2.7

Introduction

[1] https://www.facebook.com/groups/274240126027143/doc/285833394867816/

Where can I use Python ?

– Web and Internet Development– Database Access– Desktop GUIs– Scientific and Numeric Computing– Education– Network Programming– Software Development – Game and 3D Graphics2

Google is powered by python3

[2] https://www.facebook.com/groups/274240126027143/doc/285870364864119/[3] http://techreport.com/blog/16713/google-python-world-domination

Installations1. http://www.enthought.com/products/epd_free.php2. http://www.python.org/

StartingYou will start programming in IDLE which comes with Python. IDLE is a special text editors Integrated Development Environment (IDE) which is a bit like Microsoft Word, except it understands Python and helps you get your code right. IDLE is itself, a Python application4

http://docs.python.org/ This web site is the definitive Python reference. The “Library Reference” is probably the most useful as you start to learn more Python (and need to look up details about functions that you have forgotten)5

[4] https://www.facebook.com/groups/274240126027143/doc/285863108198178/[5] https://www.facebook.com/groups/274240126027143/doc/285859274865228/

Python programs

• Program (or script) is a sequence of definitions and commands

– Definitions evaluated and commands executed byPython interpreter in a shell– Can be typed directly into a shell, or stored in afile that is read into the shell and evaluated

• Command (or statement) instructs interpreter to do something

Slides are taken from Professor Eric Grimsonhttps://www.edx.org/courses/MITx/6.00x/2012_Fall/courseware/Week_1/Lecture_2/

Objects

• At heart, programs will manipulate data objects

• Each object has a type that defines the kinds of things programs can do to it

• Objects are:

– Scalar (i.e. cannot be subdivided), or– Non-scalar (i.e. have internal structure that can be accessed)


Scalar objects

• int – used to represent integers, e.g., 5 or 10082!• float – used to represent real numbers, e.g., 3.14 or 27.0• bool – used to represent Boolean values True and False

• The built in Python function type returns the type of an object

>>> type(3)<type ‘int’>>>> type(3.0)<type ‘float’>


Expressions

• Objects and operators can be combined to form expressions, each of which denotes an object of some type

• The syntax for most simple expressions is: – <object> <operator> <object>


Operators on ints and floats

• i + j – sum – if both are ints, result is int,if either is float, result is float• i - j – difference• i * j –product• i / j – division – if both are ints, result is int, representing quotient without remainder• i % j – remainder• i ** j – i raised to the power of j


Some simple examples

>>> 3 + 58

>>> 3.14 * 2062.8

>>> (2 + 3)*420

>>> 2 + 3*414


Performing simple operations

• Parentheses define sub-computations – complete these to get values before evaluating larger expression

– (2+3)*4 – 5*4– 20

• Operator precedence:

– In the absence of parentheses (within which expressions are first reduced), operators are executed le[ to right, first using **, then * and /, and then + and -


Comparison operators on ints and floats

• i > j – returns True if strictly greater than• i >= j – returns True if greater than or equal• i < j• i <= j• i == j – returns True if equal• i != j – returns True if not equal


Operators on bools

• a and b is True if both are True

• a or b is True if at least one isTrue

• not a is True if a is False; it is False if a is True


Type conversions (type casting)

• We can o[en convert an object of one type to another, by using the name of the type as a function

– float(3) has the value of 3.0– int(3.9) truncates to 3


Non-scalar objects

• We will see many different kinds of compound objects• The simplest of these are strings, objects of type str• Literals of type string can be written using single or double quotes

– ‘abc’– “abc”– ‘123’ – this is a string of characters, not the number


Operators on strings

>>> 3 * ‘a’ ‘aaa’

>>> ‘a’ + ‘a’ ‘aa’

>>> ‘a’ + str(3) ‘a3’

>>> len(‘abc’) 3


Extracting parts of strings

• Indexing:– ‘abc’[0] returns the string ‘a’– ‘abc’[2] returns the string ‘c’– ‘abc’[3] is an error (as we cannot go beyond the boundaries of the string)– ‘abc’[-1] returns the string ‘c’ (essentially counting backwards from the start of the string)• Slicing:– If s is a string, the expression s[start:end] denotes the substring that starts at start, and ends at end-1• ‘abc’[1:3] has the value ‘bc’


Providing input

• If we are going to write programs or scripts, we will need a way to incorporate input from a user.

• We use the Python function raw_input, as in:

>>> name = raw_input(‘Enter your name: ‘)Enter your name: Eric Grimson>>> print(‘Are you ‘ + name + ‘?’)Are you Eric Grimson?

Slides are taken from Professor Eric Grimson

https://www.edx.org/courses/MITx/6.00x/2012_Fall/courseware/Week_1/Lecture_2/

Branching programs

• The simplest branching

statement is a conditional

– A test (expression that evaluates to True or False)– A block of code to execute if the test is True– An optional block of code to execute if the test is False



A simple example

x = int(raw_input('Enter an integer: '))

if x%2 == 0:print(‘’)print('Even')

else: print(‘’)

print('Odd')print(’Done with conditional')


Some observations

• The expression x%2 == 0 evaluates to Truewhen the remainder of x divided by 2 is 0!• Note that == is used for comparison, since = isreserved for assignment• The indentation is important – each indented set of expressions denotes a block of instructions– For example, if the last statement were indented, it would be executed as part of the else block of code• Note how this indentation provides a visual structure that reflects the semantic structure of the program


We can have nested conditionals

if x%2 == 0:

if x%3 == 0: print('Divisible by 2 and 3’) else: print('Divisible by 2 and not by 3’)

elif x%3 == 0: print('Divisible by 3 and not by 2’)



And we can use compound Booleans

if x < y and x < z: print('x is least’)

elif y < z: print('y is least’)

else: print('z is least’)


NASA Open Source Software written in Python

The SunPy project is an effort to create an open-source software library for solar physics using the Python programming language. More information at http://www.sunpy.org.6

[6] http://code.nasa.gov/language/python/

Capturing computation as a function

• Idea is to encapsulate this computation within a scope such that can treat as primi%ve– Use by simply calling name, and providing input – Internal details hidden from users

• Syntaxdef <function name> (<formal parameters>):

<function body>• def is a keyword• Name is any legal Python name• Within parenthesis are zero or more formal parameters – each is a variable name to be used inside function body


A simple exampledef max(x, y): if x > y: return x else:

return y

• We can then invoke by z = max(3, 4)

• When we call or invoke max(3, 4), x is bound to 3, y is bound to 4, and then body expression(s) are evaluated


Function returns• Body can consist of any number of legal Python expressions

• Expressions are evaluated unit

– Run out of expressions, in which case special valueNone is returned– Or until special keyword return is reached, in which case subsequent expression is evaluated and that value is returned as value of function call


Summary of function call1.

1. Expressions for each parameter are evaluated, bound to formal parameter names of function2. Control transfers to first expression in body of function3. Body expressions executed until return keyword reached (returning value of next expression) or run out of expressions (returning None)4. Invocation is bound to the returned value5. Control transfers to next piece of code

2.


Objects

Tuples• Ordered sequence of t1 = (1, ‘two’, 3)print(t1) #(1, 'two', 3)

elements (similar to strings)

• Elements can be more than just characters

t2 = (t1, ‘four’)print(t2)# ((1, 'two', 3), 'four')


Operations on tuplest1 = (1, ‘two’, 3)t2 = (t1, ‘four’)

• Concatenation print(t1+t2) • Indexing print((t1+t2)[3])• Slicing print((t1+t2)[2:5])• Singletons t3 = (‘five’,) print(t1+t2+t3)

(1, 'two', 3, (1, 'two', 3), 'four')(1, 'two', 3)(3, (1, 'two', 3), 'four')(1, 'two', 3, (1, 'two', 3), 'four', 'five')


Tuples (Example)

num = (2, 3, 5, 7)total = 0for i in num:

total += iprint(total) #17

num = (2, 3, 5, 7)emp = ()for i in num:

emp += (i, ) # why not emp += iprint(emp) #(2, 3, 5, 7)

Lists• Look a lot like tuples

– Ordered sequence of values, each identified by an index

– Use [1, 2, 3] rather than (1, 2, 3)– Singletons are now just [4] rather than (4, )

• BIG DIFFERENCE– Lists are mutable– While tuple, int, float, str are immutable– So lists can be modified aMer they are created



Why should this matter?• Some data objects we want to treat as fixed – Can create new versions of them– Can bind variable names to them– But don’t want to change them

– Generally valuable when these data objects will be referenced frequently but elements don’t change

• Some data objects may want to support modifications to elements, either for efficiency or because elements are prone to change• Mutable structures are more prone to bugs in use, but provide great flexibility


Visualizing lists Techs = [‘MIT’,‘Cal Tech’]

Ivys = [‘Harvard’,‘Yale’, ‘Brown’] >>>Ivys[1] ‘Yale’


Structures of lists

• Consider

Univs = [Techs, Ivys]!Univs1 = [[‘MIT’, ‘Cal Tech’], [‘Harvard’, ‘Yale’, ‘Brown’]]

• Are these the same thing?– They print the same thing– But let’s try adding something to one of these

[['MIT', 'Cal Tech'], ['Harvard', 'Yale', 'Brown']][['MIT', 'Cal Tech'], ['Harvard', 'Yale', 'Brown']]


Mutability of listsLet’s evaluate

Techs.append(‘RPI’)

• Append is a method (hence the .) that has a side effect

– It doesn’t create a new list, it mutates the existing one to add a new element to the end

• So if we print Univs and Univs1 we get different things


print(Univs)

[[‘MIT’,‘Cal Tech’,‘RPI’],[‘Harvard’, ‘Yale’, ‘Brown’]]

Print(Univs1)

[[‘MIT’, ‘Cal Tech’],[‘Harvard’, ‘Yale’, ‘Brown’]]


Why?• Bindings before append • Bindings aMer append


ObservationElements of Univs are not copies of the lists to which Techs and Ivys are bound, but are the lists themselves

• This effect is called aliasing:

– There are two distinct paths to a data object

• One through the variable Techs

• A second through the first element of list object to which Univs is bound

– Can mutate object through either path, but effect will be visible through both

– Convenient but treacherous


We can directly change elements

>>> Techs['MIT', 'Cal Tech', 'RPI']>>> Techs[2] = 'WPI’!

>>> Techs['MIT', 'Cal Tech', 'WPI']

Cannot do this with tuples!


Dictionaries

• Dict is generalization of lists, but now indices don’t have to be integers – can be values of any immutable type

• Refer to indices as keys, since arbitrary in form

• A dict is then a collec$on of <key, value> pairs

• Syntax

– monthNumbers = { ‘Jan’:1, ‘Feb’:2, ‘Mar’:3, 1:’Jan’,

2:’Feb’, 3:’Mar’}

We access by using a keymonthNumbers = {‘Jan’:1, ‘Feb’:2, ‘Mar’:3, 1:’Jan’, 2:’Feb’, 3:’Mar’}

monthNumbers[‘Jan’]returns 1

monthNumbers[1]

returns ‘Jan’

Entries in a dict are unordered, and can only be accessed by a key, not an index


Operations on dicts • Insersion monthNumbers[‘Apr’] = 4#{1: 'Jan', 2: 'Feb', 'Mar': 3, 'Feb': 2, 'Apr': 4, 'Jan': 1, 3: 'Mar'}

• Iterationcollect = []

for e in monthNumbers:collect.append(e)

collect is now[1, 2, 'Mar', 'Feb', 'Apr', 'Jan', 3]

Compare tomonthNumbers.keys() #[1, 2, 'Mar', 'Feb', 'Apr', 'Jan', 3]


Keys can be complex myDict = {(1,2): 'twelve', (1,3): 'thirteen'}

myDict[(1,2)]

returns ‘twelve’

Note that keys must be immutable, so have to use a tuple, not a list


SymPy

SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python and does not require any external libraries.

solve([x + 5*y - 2, -3*x + 6*y - 15], [x, y]){x: -3, y: 1}

http://sympy.org/en/index.html

Object Oriented Programming

Exceptions

● What to do when procedure execution is stymied by an error condition?

– Fail silently: substitute default values, continue execution • Bad idea! User gets no indication results may be suspect

– Return an “error” value

• What value to chose? None?• Callers must include code to check for this special value and deal with

consequences ⇒ cascade of error values up the call tree

– Stop execution, signal error condition • In Python: raise an exception

raise Exception(“descriptive string”)

Slides are taken from Professor CHRIS TERMANhttps://www.edx.org/courses/MITx/6.00x/2012_Fall/courseware/Week_6/Lecture_10/

Dealing with Exceptions

• Python code can provide handlers for exceptions

try: f = open(‘grades.txt’) # ...code to read and process grades

except: raise Exception(“Can’t open grades file”)

• Exceptions raised by statements in body of try are handled by the except statement and execution continues with the body of the except statement.


Handling Specific Exceptions

• Usually the handler is only meant to deal with a particular type of exception. And sometimes we need to clean-up before continuing.

try: f = open(‘grades.txt’) # ...code to read and process grades

except IOError,e: print “Can’t open grades file: ” + str(e) sys.exit(0)

except ArithmeticError,e: raise ValueError(“Oops, bug in grade calculation! "

+ str(e))


Types of Exceptions

● We’ve seen the common errors:

SyntaxError: Python can’t parse programNameError: local or global name not found AttributeError: attribute reference failsTypeError: operand doesn’t have correct typeValueError: operand type okay, but value is illegal IOError: IO system reports malfunction (eg, file not found)

Slides are taken from Professor CHRIS TERMAN


Other extensions to try

• else:

– Body of this clause is executed when execution of the associated try body completes with no exceptions

• finally:

– Body of this clause is always executed after try, else and except clauses, even they’ve raised another error or executed a break, continue or return.

– Useful for clean-up code that should be run (e.g., closing files) no matter what else happened.


Code Exampledef thisRaisesAZeroDivisionError():

x = 1/0

def thisDoesNotRaiseAnyErrors():

z = 'just a string'

def thisRaisesAValueError():

y = int('Five')

def tryExercise():

print 'A',

try:

# Line Of Code Is Inserted Here # # thisDoesNotRaiseAnyErrors()

# thisRaisesAZeroDivisionError() # thisRaisesAValueError() # return

print 'B',

except ZeroDivisionError as e:

print 'C',

else:

print 'D',

finally:

print 'E',

print 'F'

# A B D E F # A C E F # A E # A E


Cython

Cython is a language that makes writing C extensions for the Python language as easy as Python itself. It is based on the well-known Pyrex, but supports more cutting edge functionality

and optimizations.7

[7] http://www.cython.org/

Objects! Python supports many different kinds of data:

1234 int 3.14159 float “Hi there!” str [1, 2, 3, 5, 7, 11] list

{“MA”: “Massachusetts”, “ME”: “Maine”} dict

Each of the above is an object.

Objects have• a type (a particular object is said to be an instance of a type) • an internal data representation• a set of procedures for interacting with the object


Defining New Types

In Python, the class statement is used to define a new type

class Coordinate(object):

... define attributes here...

Like with def, indentation is used to indicate which statements are part of the definition.

Classes can inherit attributes from other classes, in this case Coordinate inherits from the object class. Coordinate is said to be a subclass of object, object is a superclass of Coordinate. One can override an inherited attribute with a new definition in the class statement.

Slides are taken from Professor CHRIS TERMANhttps://www.edx.org/courses/MITx

Creating an Instance Usually when creating an instance of a type, we’ll want to provide some initial

values for the internal data. To do this, define an __init__ method:

class Coordinate(object): def __init__(self,x,y): self.x = x self.y = y

When calling a method of an object, Python always passes the object as the first argument. By convention Python programmers use self as the name for the first argument of methods.The “.” operator is used to access an attribute of an object. So the __init__ method above is defining two attributes for the new Coordinate object: x and y.

Data attributes of an instance are often called instance variables.


Creating an Instance

class Coordinate(object): def __init__(self,x,y): self.x = x self.y = y

c = Coordinate(3,4)origin = Coordinate(0,0)print c.x, origin.x


matplotlib is a python 2D plotting library which produces publication quality figures in a variety of hardcopy formats and interactive environments across

platforms. matplotlib can be used in python scripts, the python and ipython shell (ala MATLAB®* or Mathematica®†), web application servers, and six graphical

user interface toolkits.

http://matplotlib.org/

NumPy is the fundamental package for scientific computing with Python. http://www.numpy.org/

SciPy (pronounced "Sigh Pie") is open-source software for mathematics, science, and engineering

http://www.scipy.org/

http://www.scipy.org/PyLab

Other Libraries

http://ipython.org

http://ipython.org

http://matplotlib.org/#ftn.matlab

http://matplotlib.org/#ftn.mathematica



http://www.numpy.org/

http://www.numpy.org/





http://www.secdev.org/projects/scapy/https://www.djangoproject.com/

http://newcenturycomputers.net/projects/gdmodule.htmlhttp://gmplib.org/

http://jabberpy.sourceforge.net/http://python-irclib.sourceforge.net/

http://xael.org/norman/python/pyclamav/http://www.pythonware.com/library/http://www.pythonware.com/library/

Other tools

http://www.secdev.org/projects/scapy/












http://xael.org/norman/python/pyclamav/




http://www.pythonware.com/library/

http://www.pythonware.com/library/

Further Studies

1. https://www.edx.org/courses/MITx/6.00x/2013_Spring/about2. http://scipy-lectures.github.com/3. http://www.udacity.com/overview/Course/cs101/CourseRev/apr20124. http://pythoncentral.org/5. http://en.wikipedia.org/wiki/List_of_Python_software6. http://www.learnpython.org/7. http://getpython3.com/diveintopython3/8. http://www.swaroopch.com/notes/Python/9. http://www.learningpython.com/

https://www.edx.org/courses/MITx/6.00x/2013_Spring/about

http://scipy-lectures.github.com/

http://www.udacity.com/overview/Course/cs101/CourseRev/apr2012

http://pythoncentral.org/

http://en.wikipedia.org/wiki/List_of_Python_software

http://www.learnpython.org/

http://getpython3.com/diveintopython3/

http://www.swaroopch.com/notes/Python/

http://www.learningpython.com/

Special Thanks

1. Professor Eric Grimson2. Professor Chris Terman

3. Tanjina Islam4. Engineer Yousuf Ibrahim

5. https://www.facebook.com/groups/274240126027143/6. https://www.edx.org/

https://www.facebook.com/Yousuf.Ibrahim.Khan

workshop on python

Documents