There are something i copied from :
http://www.greenteapress.com/thinkpython/thinkCSpy/html/chap14.html
这本书叫thinkpython
These would be very helpful :D
14.7 Points revisited
Let's rewrite the Point class fromSection 12.1 in a more object-oriented style:
class Point:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
def __str__(self):
return '(' + str(self.x) + ', ' + str(self.y) + ')'
The initialization methodtakes x and y values as optional parameters;the default for either parameter is 0.
The next method, __str__, returns a string representationof a Point object.If a class provides a method named __str__, itoverrides the default behavior of the Python built-in str function.
>>> p = Point(3, 4)
>>> str(p)
'(3, 4)'
Printing a Point object implicitly invokes __str__ onthe object, so defining __str__ also changes the behavior ofprint:
>>> p = Point(3, 4)
>>> print p
(3, 4)
When we write a new class, we almost always start by writing __init__, which makes it easier to instantiate objects, and __str__, which is almost always useful for debugging.
下面还有!很精彩的介绍
14.8 Operator overloading
Some languages make it possible to change the definition of thebuilt-in operators when they are applied to user-defined types. Thisfeature is called operator overloading. It is especially useful whendefining new mathematical types.
For example, to override the addition operator +, weprovide a method named __add__:
class Point:
# previously defined methods here...
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
As usual, the first parameter is the object on which the method isinvoked. The second parameter is conveniently named otherto distinguish it from self. To add two Points, we createand return a new Point that contains the sum of thex coordinates and the sum of the y coordinates.
Now, when we apply the + operator to Point objects, Pythoninvokes __add__:
>>> p1 = Point(3, 4)
>>> p2 = Point(5, 7)
>>> p3 = p1 + p2
>>> print p3
(8, 11)
The expression p1 + p2 is equivalent top1.__add__(p2), but obviously more elegant.
As an exercise, add a method __sub__(self, other) thatoverloads the subtraction operator, and try it out.
There are several ways to override the behavior of themultiplication operator: by defining a method named__mul__, or __rmul__, or both.
If the left operand of * is a Point, Python invokes__mul__, which assumes that the other operand is alsoa Point. It computes the dot product of the twopoints, defined according to the rules of linear algebra:
def __mul__(self, other):
return self.x * other.x + self.y * other.y
If the left operand of * is a primitive type and the rightoperand is a Point, Python invokes __rmul__, whichperforms scalar multiplication:
def __rmul__(self, other):
return Point(other * self.x, other * self.y)
The result is a new Point whose coordinates are a multipleof the original coordinates. If other is a type that cannotbe multiplied by a floating-point number, then__rmul__ will yield an error.
This example demonstrates both kinds of multiplication:
>>> p1 = Point(3, 4)
>>> p2 = Point(5, 7)
>>> print p1 * p2
43
>>> print 2 * p2
(10, 14)
What happens if we try to evaluate p2 * 2? Sincethe first operand is a Point, Python invokes__mul__ with 2 as the second argument.Inside __mul__, the program tries to access the xcoordinate of other, which fails becausean integer has no attributes:
>>> print p2 * 2
AttributeError: 'int' object has no attribute 'x'
Unfortunately, the error message is a bit opaque. This exampledemonstrates some of the difficulties of object-oriented programming.Sometimes it is hard enough just to figure out what code is running.
For a more complete example of operator overloading, seeAppendix B.