barcode generator in c# windows application codeproject MAGIC METHODS, PROPERTIES, AND ITERATORS in Font

Drawing PDF 417 in Font MAGIC METHODS, PROPERTIES, AND ITERATORS

As you can see from this example, once the bird has eaten, it is no longer hungry. Now consider the subclass SongBird, which adds singing to the repertoire of behaviors: class SongBird(Bird): def __init__(self): self.sound = 'Squawk!' def sing(self): print self.sound The SongBird class is just as easy to use as Bird: >>> sb = SongBird() >>> sb.sing() Squawk! Because SongBird is a subclass of Bird, it inherits the eat method, but if you try to call it, you ll discover a problem: >>> sb.eat() Traceback (most recent call last): File "<stdin>", line 1, in File "birds.py", line 6, in eat if self.hungry: AttributeError: SongBird instance has no attribute 'hungry' The exception is quite clear about what s wrong: the SongBird has no attribute called 'hungry'. Why should it In SongBird the constructor is overridden, and the new constructor doesn t contain any initialization code dealing with the hungry attribute. To rectify the situation, the SongBird constructor must call the constructor of its superclass, Bird, to make sure that the basic initialization takes place. There are basically two ways of doing this: calling the unbound version of the superclass s constructor, and using the super function. In the next two sections I explain both.

Note Although this discussion centers around overriding constructors, the techniques apply to all methods.

If you find the title of this section a bit intimidating, relax. Calling the constructor of a superclass is, in fact, very easy (and useful). I ll start by giving you the solution to the problem posed at the end of the previous section: class SongBird(Bird): def __init__(self): Bird.__init__(self) self.sound = 'Squawk!' def sing(self): print self.sound

Only one line has been added to the SongBird class, containing the code Bird._ _init_ _(self). Before I explain what this really means, let me just show you that this really works: >>> sb = SongBird() >>> sb.sing() Squawk! >>> sb.eat() Aaaah... >>> sb.eat() No, thanks! But why does this work When you retrieve a method from an instance, the self argument of the method is automatically bound to the instance (a so-called bound method). You ve seen several examples of that. However, if you retrieve the method directly from the class (such as in Bird.__init__), there is no instance to bind to. Therefore, you are free to supply any self you want to. Such a method is called unbound, which explains the title of this section. By supplying the current instance as the self argument to the unbound method, the songbird gets the full treatment from its superclass s constructor (which means that it has its hungry attribute set). This technique works well in most situations, and knowing how to use unbound methods like this is important. However, if you are using new-style classes, you should use the other alternative: the super function.

The super function only works in new-style classes. It is called with the current class and instance as its arguments, and any method you call on the returned object will be fetched from the superclass rather than the current class. So, instead of using Bird in the SongBird constructor, you can use super(SongBird, self). Also, the __init__ method can be called in a normal (bound) fashion. The following is an updated version of the bird example. Note that Bird now subclasses object to make the classes new-style: class Bird(object): def __init__(self): self.hungry = 1 def eat(self): if self.hungry: print 'Aaaah...' self.hungry = 0 else: print 'No, thanks!' class SongBird(Bird): def __init__(self): super(SongBird, self).__init__() self.sound = 'Squawk!' def sing(self): print self.sound

This new-style version works just like the old-style one: >>> sb = SongBird() >>> sb.sing() Squawk! >>> sb.eat() Aaaah... >>> sb.eat() No, thanks!