On Tue, Apr 08, 2014 at 11:10:57AM +0530, Santosh Kumar wrote:
> 1 #!/usr/bin/python
> 2
> 3 class shape:
> 4 def __init__(self,x,y):
> 5 self.x = x
> 6 self.y = y
> 7 description = "This shape has not been described yet"
> 8 author = "Nobody has claimed to make this shape yet"
Notice that the body of the __init__ method is indented (by two spaces
-- four is recommended) from the method header. The body ends once the
indentation returns to the previous level. So this piece of code has
three levels of indentation:
Level 0: "class shape" is not indented;
Level 1: "def __init__" is 1 indent in;
Level 2: the body of the method is 2 indents in;
Level 1: the "description" and "author" lines are outdented
from 2 back to 1.
Because "description" and "author" are indented level with the __init__
definition (NOT the body of the method, the def header) that makes them
*class attributes*. They are bound to the class itself, not the
instance, and are shared by all instances. In Java terms they would be
called "static variables".
> 9
> 10 def __init__(self,x,y,z):
> 11 self.x = x
> 12 self.y = y
> 13 self.z = z
This now overwrites the existing __init__ method with a new method, also
called __init__, that takes three arguments instead of two. Because
methods are values exactly the same as strings, floats, bools and so
forth, you can only have one method with the same name. If you wrote:
x = 1
x = 2
of course you would expect that the second assignment to x overwrites
the first assignment -- x cannot have two different values at the same
time. The same applies to methods: you cannot have __init__ set to a
method taking arguments x, y, z and a method taking arguments x, y at
the same time. The newest assignment wins.
Java methods are fixed at compile-time, so it is easy for the compiler
to decide which constructor method to call at compile-time: if there are
two arguments, call the first method, if there are three, call the
second. But Python methods are values, and can be replaced on the fly at
run-time. Python can do run-time polymorphism, but not in the same way
that you do it with Java. Instead, you should define the method with
default arguments:
def __init__(self, x, y, z=None):
self.x = x
self.y = y
if z is not None:
self.z = z
> 14 print "The values are %d,%d,%d" %(self.x,self.y,self.z)
This line is outdented relative to the body of the __init__
method, so it too is at the class scope. That means that the print
statement will be executed at class definition time. The problem is, at
class definition time, there is no instance yet, even the class doesn't
exist yet, so the reference to "self" will fail with NameError.
I think what you want is for the print to be indented one more level,
so it is inside the method:
def __init__(self,x,y,z):
self.x = x
self.y = y
self.z = z
print "The values are %d,%d,%d" % (self.x, self.y, self.z)
--
Steven
_______________________________________________
Tutor maillist - Tutor@python.org
To unsubscribe or change subscription options:
https://mail.python.org/mailman/listinfo/tutor
