Continue with the Basics by Example; today's version of the post written in IronPython Enjoy!
You can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you the basics of the Programming Language.
There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2010/08/new-series-languages-basics-by-example.html
Greetings Program - Verbose
# IronPython Basics
import System
from System import Console, DateTime
class Greet(object):
# Fields of Attributes
__message = ''
__name = ''
__loopMessage = 0
# Properties
def getMessage(self):
return self.__message
def setMessage(self, value):
self.__message = self.__capitalize(value)
Message = property(getMessage, setMessage)
def getName(self):
return self.__name
def setName(self, value):
self.__name = self.__capitalize(value)
Name = property(getName, setName)
def getLoopMessage(self):
return self.__loopMessage
def setLoopMessage(self, value):
self.__loopMessage = value
LoopMessage = property(getLoopMessage, setLoopMessage)
# Constructor or Initializer Method
def __init__(self):
self.__message = ''
self.__name = ''
self.__loopMessage = 0
# Overloaded Constructor
# No Overloaded Constructors Support in Python
# Method 1
def __capitalize(self, val):
# "if-then-else" statement
if len(val) >= 1:
return val.capitalize()
else:
return ""
# Method 2
def salute(self):
# "for" statement
for i in range(0, self.__loopMessage):
print self.__message, self.__name + '!'
# Overloaded Method
# No Overloaded Methods Support in Python. New methods instead.
# Method 2.1
def salute21(self, message, name, loopMessage):
# "while" statement
i = 0
while i < loopMessage:
print self.__capitalize(message), self.__capitalize(name) + '!'
i = i + 1
# Method 2.2
def salute22(self, name):
# "switch/case" statement is not supported
# so I'm using if then else if...
dtNow = DateTime.Now
hh = dtNow.Hour
if hh in range(6,12):
self.__message = "good morning,"
elif hh in range(12,18):
self.__message = "good evening,"
elif hh in range(18,23):
self.__message = "good afternoon,"
elif hh == 23 or hh in range(0,6):
self.__message = "good night,"
else:
self.__message = "huh?"
print self.__capitalize(self.__message), self.__capitalize(name) + '!'
# Console Program
def main():
# Define variable object of type Greet
# Instantiate Greet. Call Constructor
g = Greet()
# Call Set Properties
g.Message = "hello"
g.Name = "world"
g.LoopMessage = 5
# Call Method 2
g.salute()
# Call Method 2.1 and Get Properties
g.salute21(g.Message, "ironPython", g.LoopMessage)
# Call Method 2.2
g.salute22("carlos")
# Stop and exit
print "Press any key to exit..."
Console.Read()
main()
Greetings Program - Minimal
# IronPython Basics
from System import Console, DateTime
class Greet(object):
# Fields of Attributes
__message = ''
__name = ''
__loopMessage = 0
# Properties
def getMessage(self):
return self.__message
def setMessage(self, value):
self.__message = self.__capitalize(value)
Message = property(getMessage, setMessage)
def getName(self):
return self.__name
def setName(self, value):
self.__name = self.__capitalize(value)
Name = property(getName, setName)
def getLoopMessage(self):
return self.__loopMessage
def setLoopMessage(self, value):
self.__loopMessage = value
LoopMessage = property(getLoopMessage, setLoopMessage)
# Constructor or Initializer Method
def __init__(self):
self.__message = ''
self.__name = ''
self.__loopMessage = 0
# Overloaded Constructor
# No Overloaded Constructors Support in Python
# Method 1
def __capitalize(self, val):
# "if-then-else" statement
if len(val) >= 1:
return val.capitalize()
else:
return ""
# Method 2
def salute(self):
# "for" statement
for i in range(0, self.__loopMessage):
print self.__message, self.__name + '!'
# Overloaded Method
# No Overloaded Methods Support in Python. New methods instead.
# Method 2.1
def salute21(self, message, name, loopMessage):
# "while" statement
i = 0
while i < loopMessage:
print self.__capitalize(message), self.__capitalize(name) + '!'
i = i + 1
# Method 2.2
def salute22(self, name):
# "switch/case" statement is not supported
# so I'm using if then else if...
dtNow = DateTime.Now
hh = dtNow.Hour
if hh in range(6,12):
self.__message = "good morning,"
elif hh in range(12,18):
self.__message = "good evening,"
elif hh in range(18,23):
self.__message = "good afternoon,"
elif hh == 23 or hh in range(0,6):
self.__message = "good night,"
else:
self.__message = "huh?"
print self.__capitalize(self.__message), self.__capitalize(name) + '!'
# Console Program
# Define variable object of type Greet
# Instantiate Greet. Call Constructor
g = Greet()
# Call Set Properties
g.Message = "hello"
g.Name = "world"
g.LoopMessage = 5
# Call Method 2
g.salute()
# Call Method 2.1 and Get Properties
g.salute21(g.Message, "ironPython", g.LoopMessage)
# Call Method 2.2
g.salute22("carlos")
# Stop and exit
print "Press any key to exit..."
Console.Read()
And the Output is:
Private Fields and Methods in (Iron)Python
"There is limited support for class-private identifiers. Any identifier of the form __spam (at least two leading underscores, at most one trailing underscore) is textually replaced with _classname__spam, where classname is the current class name with leading underscore(s) stripped. This mangling is done without regard to the syntactic position of the identifier, so it can be used to define class-private instance and class variables, methods, variables stored in globals, and even variables stored in instances. private to this class on instances of other classes.
Name mangling is intended to give classes an easy way to define 'private' instance variables and methods, without having to worry about instance variables defined by derived classes, or mucking with instance variables by code outside the class. Note that the mangling rules are designed mostly to avoid accidents; it still is possible for a determined soul to access or modify a variable that is considered private. This can even be useful in special circumstances, such as in the debugger, and that's one reason why this loophole is not closed. (Buglet: derivation of a class with the same name as the base class makes use of private variables of the base class possible.)". Taken from: "http://docs.python.org/release/2.5.2/tut/node11.html#SECTION0011600000000000000000"
print 'Private Access Modifier Example:'
class Greet(object):
# Fields of Attributes
__message = ''
__name = ''
__loopMessage = 0
# Constructor or Initializer Method
def __init__(self):
self.__message = ''
self.__name = ''
self.__loopMessage = 0
# Private Method
def __capitalize(self, val):
if len(val) >= 1:
return val.capitalize()
else:
return ""
# Public Method
def Salute(self):
for i in range(0, self.__loopMessage):
print self.__message, self.__name + '!'
g = Greet()
# publicly accessing private fields (_classname__fieldname)
g._Greet__message = "hello"
g._Greet__name = "world"
g._Greet__loopMessage = 5
# Call Public Method
g.Salute()
# Call Private Method (_classname__methodname)
print g._Greet__capitalize('capitalized!')
Where to define Class Fields/Attributes in (Iron)Python
print ''
print 'Class Attributes Example:'
class ClassAttributes(object):
# You do not need to explicitly add the Fields/Attributes as shown below within the class:
# message = ''
# name = ''
# loopMessage = 0
# because they are added to the class as Fields/Attributes the first time they appear in
# your code. For example, here below, in the Initialize method,
# we have 2 fields (name and message)
def __init__(self):
self.message = '' # class field
self.name = '' # class field
# and one more within a public method (loopMessage)
def Salute(self):
self.loopMessage = 0 # class field
localtest = 0 # local variable
# Then, you can access each of them as you normally do:
f = ClassAttributes()
f.message = 'Hello'
f.name = 'World'
f.loopMessage = 5
print f.message, f.name, f.loopMessage
Overloading Constructor and Methods in (Iron)Python
Python does not support Overloading Methods nor Constructors, instead, you can define one method with variable arguments and code the if-elif code to handle both(or multiple) cases yourself.
print ''
print 'Overloaded-like Constructor and Method Example:'
class Overloading(object):
# Constructor with variable arguments
def __init__(self, *args):
# if args list/sequence is not empty we use the arguments,
# otherwise we use the class fields
if args:
self.message = args[0]
self.name = args[1]
self.loopMessage = args[2]
else:
self.message = 'empty_message'
self.name = 'empty_name'
self.loopMessage = 2
# Method with variable arguments
def Salute(self, *args):
# if args list/sequence is not empty we use the arguments,
# otherwise we use the class fields
if args:
for i in range(0, args[2]):
print args[0], args[1] + '!'
else:
for i in range(0, self.loopMessage):
print self.message, self.name + '!'
# and now we use the "overloaded-like" constructor and method
# calling constructor without parameters
o1 = Overloading()
# calling method without parameters
o1.Salute()
# calling method with parameters
o1.Salute('Hello', 'IronPython', 3)
# calling constructor with with parameters
o2 = Overloading('Hello', 'Carlos', 2)
# calling method without parameters
o2.Salute()
And the Output is:
No comments:
Post a Comment