Programming with Python

Programming with Python Rasan Samarasinghe ESOFT Computer Studies (pvt) Ltd. No 68/1, Main Street, Pallegama, Embilipitiya.

Contents 1. Python Overview 2. Python Environment 3. First Python Program 4. Python Basic Syntax 5. Python Variables 6. Standard Data Types 7. Python Operators 8. Python Decision Making 9. Python Loops 10. Python Numbers 11. Python Strings 12. Python Lists 13. Python Tuples 14. Python Dictionary 15. Python Date & Time 16. Python Functions 17. Python Modules 18. Python I/O 19. Python Exceptions 20. Python OOP

Python Overview • A high-level, interpreted, interactive and object-oriented scripting language. • Designed to be highly readable which uses English keywords. • Fewer syntactical constructions than other languages.

Features • Readability • Support Structured / OOP Styles • Easy to learn • Easy to maintain • A broad standard library • Interactive Mode

Features • Portable • Extendable • Support Databases • GUI Programming • Scalable • Easy integration with other languages

Application of Python • Systems Programming • GUIs • Internet Scripting • Component Integration • Database Programming • Numeric and Scientific Programming • More: Gaming, Images, Data Mining, Robots, Excel..

Python Environment Python is available on a wide variety of platforms (Windows / Linux / Mac OS) Python Official Website: http://www.python.org Install Python Setting up PATH

Running Python 1. Interactive Interpreter 2. Run script from the Command line 3. Integrated Development Environment

First Python Program In interactive mode programming Type and enter in Python prompt: print ("Hello, World!") Or just type and enter "Hello, World!"

First Python Program In script mode programming Make a Python script file test.py and include code: print ("Hello, World!") In command shell run test.py file C:>python_filestest.py

Python Basic Syntax Python Identifiers Reserved Words Lines and Indentation Multi Line Statements Quotation in Python Comments in Python Using Blank Lines Multiple Statements Command Line Arguments

Python Identifiers • Identifiers are case sensitive. • Class names start with an uppercase letter • Other identifiers start with a lowercase letter. • Starting with a single leading underscore indicates private. • Starting with two leading underscores indicates strongly private. • Ends with two underscores means a language defined special name.

Lines and Indentation Blocks of code are denoted by line indentation if True: print("Good") print("Cat") else: print("Bad") print("Cat")

Multi Line Statements Use of the line continuation character total = item_one + item_two + item_three

Multi Line Statements Statements contained within the [], {} or () brackets do not need to use the line continuation character. days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

Quotation in Python Python uses quotes to denote string literals word = 'word' sentence = "This is a sentence." paragraph = """This is a paragraph. It is made up of multiple lines and sentences."""

Comments in Python A hash sign # that is not inside a string literal begins a comment. # first comment print ("Hello, Rasan!") # second comment

Using Blank Lines • A line containing only whitespace / or comment is known as a blank line and Python totally ignores it. • In an interactive interpreter session an empty physical line used to terminate a multiline statement.

Multiple Statements The semicolon ; allows multiple statements on the single line. print ("hello"); print ("Rasan!");

Command Line Arguments test.py script to access command line arguments import sys print ('Number of arguments:', len(sys.argv)) print ('Argument List:', str(sys.argv)) Run script in with arguments passed into it. C:>python_filestest.py rasan indunil samarasinghe

Python Variables • Variables do not have to be explicitly declared to reserve memory space. • The declaration happens automatically when you assign a value to a variable.

Assigning Values to Variables counter = 100 # An integer assignment miles = 1000.0 # A floating point name = "Nuwan" # A string print (counter) print (miles) print (name)

Multiple Assignment Python allows you to assign a single value to several variables simultaneously. a = b = c = 1 a, b, c = 1, 2, "nuwan"

Standard Data Types • Numbers • String • List • Tuple • Dictionary

Python Numbers Number objects are created when you assign a value to them. var1 = 1 var2 = 10

Python Numbers You can delete a single object or multiple objects by using the del statement. del var1 del var_a, var_b

Python Strings String created with either pairs of single or double quotes. word = 'word' sentence = "This is a sentence." paragraph = """This is a paragraph. It is made up of multiple lines and sentences."""

Python Strings str = 'Hello World!' # Prints complete string print (str) # Prints first character of the string print (str[0]) # Prints characters starting from 3rd to 5th print (str[2:5])

Python Strings str = 'Hello World!' # Prints string starting from 3rd character print (str[2:]) # Prints string two times print (str * 2) # Prints concatenated string print (str + "TEST")

Python Lists • A list contains items separated by commas and enclosed within square brackets []. • Lists are similar to arrays in C. • Items belonging to a list can be of different data type.

Creating Python Lists mylist = [ 'abcd', 786 , 2.23, 'rasan', 70.2 ] tinylist = [123, 'rasan']

Printing Python Lists # Prints complete list print (mylist) # Prints first element print (mylist[0]) # Prints elements from 2nd till 3rd print (mylist[1:3])

Printing Python Lists # Prints elements starting from 3rd print (mylist[2:]) # Prints list two times print (tinylist * 2) # Prints concatenated lists print (mylist + tinylist)

Python Tuples • Consists of a number of values separated by commas enclosed within brackets ( ). • Tuples cannot be updated.

Crating Python Tuples mytuple = ( 'abcd', 786 , 2.23, 'rasan', 70.2 ) tinytuple = (123, 'rasan')

Printing Python Tuples # Prints complete list print (mytuple) # Prints first element of the list print (mytuple[0]) # Prints elements starting from 2nd till 3rd print (mytuple[1:3])

Printing Python Tuples # Prints elements starting from 3rd element print (mytuple[2:]) # Prints list two times print (tinytuple * 2) # Prints concatenated lists print (mytuple + tinytuple)

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.

Creating Python Dictionary dic = {} dic['one'] = "This is one" dic[2] = "This is two"

Crating Python Dictionary tinydic = {'name': 'neil','code':6734, 'dept': 'sales'}

Print Python Dictionary Values # Prints value for 'one' key print (dic['one']) # Prints complete dictionary print (tinydic) # Prints all the keys print (tinydic.keys()) # Prints all the values print (tinydic.values())

Data Type Conversion Function Description int(x [,base]) Converts x to an integer. base specifies the base if x is a string. long(x [,base] ) Converts x to a long integer. base specifies the base if x is a string. float(x) Converts x to a floating-point number. complex(real [,imag]) Creates a complex number. str(x) Converts object x to a string representation. repr(x) Converts object x to an expression string. eval(str) Evaluates a string and returns an object. tuple(s) Converts s to a tuple.

Data Type Conversion Function Description list(s) Converts s to a list. set(s) Converts s to a set. dict(d) Creates a dictionary. d must be a sequence of (key,value) tuples frozenset(s) Converts s to a frozen set. chr(x) Converts an integer to a character. unichr(x) Converts an integer to a Unicode character. ord(x) Converts a single character to its integer value. hex(x) Converts an integer to a hexadecimal string. oct(x) Converts an integer to an octal string.

Python Operators 1. Arithmetic Operators 2. Comparison Operators 3. Assignment Operators 4. Logical Operators 5. Bitwise Operators 6. Membership Operators 7. Identity Operators

Arithmetic Operators a = 10 b = 20

Comparison Operators a = True b = False

Bitwise Operators a = 60 b = 13

If statements SYNTAX: if expression: statement(s)

if...else statements SYNTAX: if expression: statement(s) else: statement(s)

Theelif Statement SYNTAX: if expression1: statement(s) elif expression2: statement(s) elif expression3: statement(s) else: statement(s)

Nested if statements SYNTAX: if expression1: statement(s) if expression2: statement(s) elif expression3: statement(s) else statement(s) elif expression4: statement(s) else: statement(s)

While loop SYNTAX: while expression: statement(s)

Theelse Statement with While Loops count = 0 while count < 5: print (count, " is less than 5") count = count + 1 else: print (count, " is not less than 5")

For loop SYNTAX: for var in sequence: statements(s)

Theelse Statement with For Loops num = 7 for i in range(2,num): if num%i == 0: print ('%d is not a prime number' % (num)) break else: print (num, 'is a prime number')

Nested for loops SYNTAX: for iterating_var in sequence: for iterating_var in sequence: statements(s) statements(s)

Nested while loops SYNTAX: while expression: while expression: statement(s) statement(s)

Python Numbers • Number data types store numeric values. • They are immutable data types. • Changing the value of a number data type results in a newly allocated object.

Number Type Conversion • int(x) - convert x to a plain integer. • long(x) - convert x to a long integer. • float(x) - convert x to a floating-point number.

Number Type Conversion • complex(x) - convert x to a complex number with real part x and imaginary part zero. • complex(x, y) - convert x and y to a complex number with real part x and imaginary part y.

Mathematical Functions (math header)

Trigonometric Functions (math module)

Random Number Functions (random module)

Python Strings • Strings Created by enclosing characters in quotes. • Treats single quotes the same as double quotes. var1 = 'Hello World!' var2 = "Python Programming"

Accessing Values in Strings var1 = 'Hello World!' var2 = "Python Programming" print ("var1[0]: ", var1[0]) print ("var2[1:5]: ", var2[1:5])

Updating Strings var1 = ( 'Hello World!' ) print ("Updated String :- ", var1[:6] + 'Python')

String Formatting Operator String formatting operator % is unique to strings print ("My name is %s and weight is %d kg!" % ('Khan', 25))

Triple Quotes Python's triple quotes allowing strings to span multiple lines. paragraph = """This is a paragraph. It is made up of multiple lines and sentences."""

Raw String Raw strings don't treat the backslash as a special character at all. print (r'C:nowhere')

Unicode String Normal strings in Python are stored internally as 8-bit ASCII Unicode strings are stored as 16-bit Unicode. print (u'Hello, world!')

Python Lists • Lists be written as a list of comma separated values between square brackets. • Items in a list need not all have the same type.

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

Accessing Values in Lists list1 = ['physics', 'chemistry', 1997, 2000] list2 = [1, 2, 3, 4, 5 ] list3 = ["a", "b", "c", "d"] print ("list1[0]: ", list1[0]) print ("list2[1:5]: ", list2[1:5])

Updating Lists 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])

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

Indexing, Slicing and Matrixes L = ['spam', 'Spam', 'SPAM!']

Built-in List Functions & Methods

Python Tuples • A tuple is a sequence of immutable Python objects. • Tuples are read only. • Tuples use parentheses ()

Crating Python Tuples tup1 = ('physics', 'chemistry', 1997, 2000) tup2 = (1, 2, 3, 4, 5 ) tup3 = "a", "b", "c", "d"

Creating Python Tuples Creating an empty tuple: tup1 = () Tuple with one value: tup1 = (50,)

Accessing Values in Tuples 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])

Updating Tuples 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)

Delete Tuple tup = ('physics', 'chemistry', 1997, 2000) print (tup) del tup print ("After deleting tup : ") print (tup)

Indexing, Slicing and Matrixes L = ('spam', 'Spam', 'SPAM!')

Python Dictionary • A dictionary can store any number of Python objects. • Dictionaries consist of pairs of keys and their corresponding values. • A dictionary is mutable.

Creating Python Dictionary dict1 = { 'abc': 456 } dict2 = { 'abc': 123, 98.6: 37 }

Accessing Values in Dictionary dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'} print ("dict['Name']: ", dict['Name']) print ("dict['Age']: ", dict['Age'])

Updating Dictionary dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'} # update existing entry dict['Age'] = 8 # Add new entry dict['School'] = "DPS School"

Delete Dictionary Elements dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}; # remove entry with key 'Name' del dict['Name']; # remove all entries in dict dict.clear(); # delete entire dictionary del dict ;

Built-in Dictionary Functions and Methods

Python Date & Time • A python program can handle date & time in several ways. • Python's time and calendar modules help track dates and times.

What is Tick? The function time.time() returns the current system time in ticks since 12:00am, January 1, 1970 (epoch)

What is Tick? import time; ticks = time.time() print ("Number of ticks since 12:00am, January 1, 1970:", ticks)

TimeTuple Python's time functions handle time as a tuple of 9 numbers

struct_time structure time tuple is equivalent to struct_time structure. This structure has following attributes

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

Python Functions A function is a block of organized, reusable code that is used to perform a single, related action.

Defining a Function SYNTAX: def functionname( parameters ): "function_docstring" function_suite return [expression]

Calling a Function # Function definition def printme( str ): "This prints a passed string into this function" print (str) return # Call to printme function printme("I'm first call to user defined function!") printme("Again second call to the same function")

Calling a Function 1. Pass by reference 2. Pass by value

Pass by reference # Function definition is here def changeme( mylist ): "This changes a passed list into this function" mylist.append([1,2,3,4]) print ("Values inside the function: ", mylist) return # Now you can call changeme function mylist = [10,20,30] changeme( mylist ) print ("Values outside the function: ", mylist)

Pass by value # Function definition def changeme( mylist ): "This changes a passed list into this function" mylist = [1,2,3,4]; # assign new reference in mylist print ("Values inside the function: ", mylist) return # Call to changeme function mylist = [10,20,30] changeme( mylist ) print ("Values outside the function: ", mylist)

Function Arguments • Required arguments • Keyword arguments • Default arguments • Variable-length arguments

Required arguments # Function definition def printme( str ): "This prints a passed string into this function" print (str) return # Call printme function printme(); # will generate an error

Keyword arguments # Function definition def printinfo( name, age ): "This prints a passed info into this function" print ("Name: ", name) print ("Age ", age) return # Call printinfo function printinfo( age=50, name="miki" )

Default arguments # Function definition def printinfo( name, age = 35 ): "This prints a passed info into this function" print ("Name: ", name) print ("Age ", age) return # Call printinfo function printinfo( age=50, name="miki" ) printinfo( name="miki" )

Variable-length arguments # Function definition def printinfo( arg1, *vartuple ): "This prints a variable passed arguments" print ("Output is: ") print (arg1) for var in vartuple: print (var) return; # Call printinfo function printinfo( 10 ); printinfo( 70, 60, 50 );

Anonymous Functions • lambda keyword used to create small anonymous functions. • Lambda forms can take any number of arguments but return just one value as an expression.

Anonymous Functions SYNTAX: lambda [arg1 [,arg2,.....argn]]:expression

Anonymous Functions # Function definition sum = lambda arg1, arg2 : arg1 + arg2; # Call sum as a function print ("Value of total : ", sum( 10, 20 )) print ("Value of total : ", sum( 20, 20 ))

The return Statement • The statement return exits a function. • Optionally passing back an expression to the caller.

The return Statement # Function definition def sum( arg1, arg2 ): # Add both the parameters and return them." total = arg1 + arg2 print ("Inside the function : ", total) return total; # Call sum function total = sum( 10, 20 ); print ("Outside the function : ", total)

Scope of Variables • Global variables • Local variables

Scope of Variables total = 0; # This is global variable # Function definition def sum( arg1, arg2 ): total = arg1 + arg2; # Here total is local variable. print ("Inside the function local total : ", total) return total; # Call sum function sum( 10, 20 ); print ("Outside the function global total : ", total)

Python 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.

Creating Python Modules Code for a module named hello normally resides in a file named hello.py hello.py file def print_func( par ): print ("Hello : ", par) return

The import Statement Using a Python file as a module by executing an import statement. SYNTAX: import module1[, module2[,... moduleN]

The import Statement # Import module hello import hello # Call defined function of module as follows hello.print_func("Rasan")

Thefrom...import Statement Import specific attributes from a module into the current namespace. SYNTAX: from modname import func1[, func2[, ... funcN]]

The from...import * Statement Import all names from a module into the current namespace SYNTAX: from modname import *

Locating Modules Sequence 1. The current directory. 2. If the module isn't found, Python then searches each directory in the shell variable PYTHONPATH. 3. If all else fails, Python checks the default path. (UNIX: /usr/local/lib/python/)

Namespaces and Scoping • Each function and class method has its own local namespace. • If a local and a global variable have the same name, the local variable shadows the global variable. • Therefore global statement is used to assign a value to a global variable within a function.

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

The dir( ) Function The dir() function returns a sorted list of strings containing the names defined by a module. # Import built-in module math import math content = dir(math) print (content)

Theglobals() and locals() Functions • A call to locals() within a function return all the names that can be accessed locally from that function. • A call to globals() within a function return all the names that can be accessed globally from that function.

The reload() Function • To re-execute the top-level code in a module, you can use the reload(module_name) function. • The reload() function imports a previously imported module again.

Packages in Python • A package is a hierarchical file directory structure. • It defines a single Python application environment that consists of modules and sub packages and so on.

Packages in Python Example Create 1. File Pots.py available in Phone directory having function Pots(). 2. Phone/Isdn.py file having function Isdn() 3. Phone/G3.py file having function G3()

Packages in Python Example Now, create one more file __init__.py in Phone directory __init__.py from Pots import Pots from Isdn import Isdn from G3 import G3

Packages in Python Example # Now import your Phone Package. import Phone Phone.Pots() Phone.Isdn() Phone.G3()

Python I/O • Printing to the Screen • Reading Keyboard Input

Printing to the Screen print ("Hi there!", "How are you?")

Reading Keyboard Input • raw_input() (Works only with python 2.x) • input()

The raw_input Function The raw_input() function reads one line from standard input and returns it as a string. str = raw_input("Enter your input: ") print ("Received input is : ", str) (Works only with python 2.x)

The input Function input() function assumes the input is a valid Python expression and returns the evaluated result. str = input("Enter your input: "); print ("Received input is : ", str) (In Python 3.x, input() replaces raw_input())

Opening and Closing Files • The open() Function • The close() Function

The open Function SYNTAX: file object = open(file_name [, access_mode][, buffering])

Python Exceptions • An exception is an event, which occurs during the execution of a program. • When a Python script encounters a situation that it can't cope with, it raises an exception.

Handling an exception SYNTAX: try: You do your operations here; ...................... except Exception1: If there is ExceptionI, then execute this block. except Exception2: If there is ExceptionII, then execute this block. ...................... else: If there is no exception then execute this block.

Except clause with no exceptions SYNTAX: try: You do your operations here; ...................... except: If there is any exception, then execute this block. ...................... else: If there is no exception then execute this block.

The try-finally clause SYNTAX: try: You do your operations here; ...................... Due to any exception, this may be skipped. finally: This would always be executed. ......................

Argument of an Exception SYNTAX: try: You do your operations here; ...................... except ExceptionType, Argument: You can print value of Argument here...

Raising an exception SYNTAX: raise [Exception [, args [, traceback]]]

User Defined Exceptions # create exception by deriving standard exception class Networkerror(RuntimeError): def __init__(self, arg): self.args = arg # raise exception try: raise Networkerror("Bad hostname") except Networkerror,e: print (e.args)

Python OOP 1. Creating Classes 2. Creating Objects 3. Accessing Attributes 4. Destroying Objects 5. Class Inheritance 6. Overriding Methods 7. Overloading Operators 8. Data Hiding

Creating Classes class ClassName: 'Optional class documentation string' defining class members… data attributes… functions…

Creating Classes class Employee: 'Common base class for all employees' empCount = 0 def __init__(self, name, salary): self.name = name self.salary = salary Employee.empCount += 1 def displayCount(self): print ("Total Employee %d" % Employee.empCount) def displayEmployee(self): print ("Name : ", self.name, ", Salary: ", self.salary)

Creating Objects # Create first object of Employee class emp1 = Employee("Zara", 2000) # Create second object of Employee class emp2 = Employee("Manni", 5000)

Accessing Attributes emp1.displayEmployee() emp2.displayEmployee() print ("Total Employee %d" % Employee.empCount)

Accessing Attributes • getattr(obj, name[, default]) : access the attribute of object. • hasattr(obj,name) : check if an attribute exists or not. • setattr(obj,name,value) : set an attribute. If attribute does not exist, then it would be created. • delattr(obj, name) : delete an attribute.

Built-In Class Attributes • __dict__ : Dictionary containing the class's namespace. • __doc__ : Class documentation string or None if undefined. • __name__: Class name. • __module__: Module name in which the class is defined. This attribute is "__main__" in interactive mode. • __bases__ : A possibly empty tuple containing the base classes, in the order of their occurrence in the base class list.

Destroying Objects (Garbage Collection) class Point: def __init__( self, x=0, y=0): self.x = x self.y = y def __del__(self): class_name = self.__class__.__name__ print (class_name, "destroyed")

Destroying Objects (Garbage Collection) pt1 = Point() pt2 = pt1 pt3 = pt1 # prints the ids of the objects print (id(pt1), id(pt2), id(pt3)) del pt1 del pt2 del pt3

Class Inheritance SYNTAX: class SubClassName (ParentClass1[, ParentClass2, ...]): 'Optional class documentation string' defining class members… data attributes… functions…

Class Inheritance class Parent: # define parent class parentAttr = 100 def __init__(self): print ("Calling parent constructor") def parentMethod(self): print ('Calling parent method') def setAttr(self, attr): Parent.parentAttr = attr def getAttr(self): print ("Parent attribute :", Parent.parentAttr) class Child(Parent): # define child class def __init__(self): print ("Calling child constructor") def childMethod(self):

Class Inheritance c = Child() # instance of child c.childMethod() # child calls its method c.parentMethod() # calls parent's method c.setAttr(200) # again call parent's method c.getAttr() # again call parent's method

Class Inheritance issubclass(sub, sup) : Returns true if the given subclass sub is a subclass of the superclass sup. isinstance(obj, Class) : Returns true if obj is an instance of class Class or is an instance of a subclass of Class

Overriding Methods class Parent: # define parent class def myMethod(self): print ('Calling parent method') class Child(Parent): # define child class def myMethod(self): print ('Calling child method') c = Child() # instance of child c.myMethod() # child calls overridden method

Overloading Operators class Vector: def __init__(self, a, b): self.a = a self.b = b def __str__(self): return 'Vector (%d, %d)' % (self.a, self.b) def __add__(self,other): return Vector(self.a + other.a, self.b + other.b) v1 = Vector(2,10) v2 = Vector(5,-2) print (v1 + v2)

Data Hiding class JustCounter: __secretCount = 0 def count(self): self.__secretCount += 1 print (self.__secretCount) counter = JustCounter() counter.count() counter.count() print (counter.__secretCount) print (counter._JustCounter__secretCount)

The End http://twitter.com/rasansmn

Programming with Python

In this document