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

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.

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
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
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
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
def printme( str ):
"This prints a passed string into this function"
print (str)
return
# Call printme function
printme(); # will generate an error

Keyword arguments
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
def printinfo( name, age = 35 ):
"This prints a passed info into this function"
print ("Name: ", name)
print ("Age ", age)
return
printinfo( age=50, name="miki" )
printinfo( name="miki" )

Variable-length arguments
def printinfo( arg1, *vartuple ):
"This prints a variable passed arguments"
print ("Output is: ")
print (arg1)
for var in vartuple:
print (var)
return;
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
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
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
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()

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

# 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:
......................
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:
......................
Due to any exception, this may be skipped.
finally:
This would always be executed.
......................

Argument of an Exception
SYNTAX:
try:
......................
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

More Related Content

What's hot

Viewers also liked

Similar to Programming with Python

More from Rasan Samarasinghe

Recently uploaded

Programming with Python

Editor's Notes