programming with python
TRANSCRIPT
Programming with Python
Rasan SamarasingheESOFT Computer Studies (pvt) Ltd.No 68/1, Main Street, Pallegama, Embilipitiya.
Contents
1. Python Overview2. Python Environment3. First Python Program4. Python Basic Syntax5. Python Variables6. Standard Data Types7. Python Operators 8. Python Decision Making9. Python Loops10. Python Numbers
11. Python Strings12. Python Lists13. Python Tuples14. Python Dictionary15. Python Date & Time16. Python Functions17. Python Modules18. Python I/O19. Python Exceptions20. 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 Interpreter2. Run script from the Command line3. 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_files\test.py
Python Basic Syntax
Python IdentifiersReserved WordsLines and IndentationMulti Line StatementsQuotation in PythonComments in PythonUsing Blank LinesMultiple StatementsCommand 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.
Reserved Words
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 ismade 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_files\test.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 var1del var_a, var_b
Number Types in Python
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 ismade up of multiple lines and sentences."""
Python Strings
str = 'Hello World!' # Prints complete stringprint (str)
# Prints first character of the stringprint (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 ConversionFunction 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 ConversionFunction 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) tuplesfrozenset(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
Assignment Operators
Logical Operators
Bitwise Operators a = 60 b = 13
Membership Operators
Identity Operators
Operators Precedence
Python Decision Making
If statements
SYNTAX:
if expression: statement(s)
if...else statements
SYNTAX:
if expression: statement(s) else: statement(s)
The elif Statement
SYNTAX:
if expression1: statement(s) elif expression2: statement(s) elif expression3: statement(s) else: statement(s)
Nested if statementsSYNTAX:
if expression1: statement(s) if expression2: statement(s) elif expression3: statement(s) else statement(s) elif expression4: statement(s) else: statement(s)
Python Loops
While loop
SYNTAX:
while expression: statement(s)
The else 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)
The else Statement with For Loops
num = 7for 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)
Loop Control Statements
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 Examples
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')
Escape Characters
String Special Operators
String Formatting Operator
String formatting operator % is unique to strings
print ("My name is %s and weight is %d kg!" % ('Khan', 25))
String Formatting Operator
String Formatting Operator
Triple Quotes
Python's triple quotes allowing strings to span multiple lines.
paragraph = """This is a paragraph. It ismade 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!')
String Methods
String Methods
String Methods
String Methods
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] = 2001print ("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)
Basic List Operations
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 + tup2print (tup3)
Delete Tuple
tup = ('physics', 'chemistry', 1997, 2000) print (tup) del tupprint ("After deleting tup : ")print (tup)
Basic Tuples Operations
Indexing, Slicing and Matrixes
L = ('spam', 'Spam', 'SPAM!')
Built-in Tuple Functions
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
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)
The time Module
The time Module
The calendar Module
The calendar Module
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 reference2. 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 definitiondef 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 definitionsum = 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 definitiondef 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 definitiondef 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")
The from...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)
The globals() 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])
File open modes
The file object attributes
File Object Methods
File Object Methods
OS Object Methods
OS Object Methods
OS Object Methods
OS Object Methods
OS Object Methods
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.
Standard Exceptions in Python
Standard Exceptions in Python
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 Classes2. Creating Objects3. Accessing Attributes4. Destroying Objects5. Class Inheritance6. Overriding Methods7. Overloading Operators8. 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 classemp2 = 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 Inheritanceclass 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
Base Overloading Methods
Overloading Operatorsclass 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