c# pdf to tiff : Create pdf signature field SDK Library service wpf asp.net html dnn Python%20How%20to%20Program%20200233-part1718

Chapter 9
Object-Oriented Programming: Inheritance
329
Method __getattribute__ (lines 13–19) executes every time the client attempts
to access an object’s attribute through the dot (.) access operator. The method prints a line
indicating that the method is executing and a line that displays the name of the attribute that
the client is attempting to access. Line 19 returns the result of calling base-class method
__getattribute__, passing the specified attribute name. Method
__getattribute__ in a derived class must call the base-class version of the method to
retrieve an attribute’s value, because attempting to access the attribute’s value through the
object’s __dict__ would result in another call to __getattribute__.
Common Programming Error 9.5
To  ensure  proper  attribute  access,  a  derived-class  version  of  method
__getattribute__ should call the base-class version of the method. Attempting to re-
turn the attribute’s value by accessing the object’s __dict__ causes infinite recursion.
9.5
Lines 21–29 define method __getattr__, which performs the same behavior as in
“classic” classes;  namely,  the method  executes  when  the  client attempts  to  access  an
attribute that the object’s __dict__ does not contain. The method displays output that
indicates the method is executing and provides the name of the attribute that the client
attempted to access (lines 24–26). Lines 28–29 raise an exception to preserve Python’s
default behavior of raising an exception when a client accesses a nonexistent attribute. 
1
# Fig. 9.15: fig09_15.py
2
# Class that defines method __getattribute__
3
4
class DemonstrateAccess( object ):
5
"""Class to demonstrate when method __getattribute__ executes"""
6
7
def __init__( self ):
8
"""DemonstrateAccess constructor, initializes attribute
9
value"""
10
11
self.value = 1
12
13
def __getattribute__( self, name ):
14
"""Executes for every attribute access"""
15
16
print "__getattribute__ executing..."
17
print "\tClient attempt to access attribute:", name
18
19
return object.__getattribute__( self, name )
20
21
def __getattr__( self, name ):
22
"""Executes when client access attribute not in __dict__"""
23
24
print "__getattr__ executing..."
25
print "\tClient attempt to access non-existent attribute:",\
26
name
27
28
raise AttributeError, "Object has no attribute %s" \
29
% name
F
ig
. 9.15
F
ig
. 9.15
F
ig
. 9.15
F
ig
. 9.15
__getattribute__
m
e
th
od
a
n
d
a
ttr
ib
ut
e
acce
ss. (P
a
rt 1 
o
f 2).
pythonhtp1_09.fm  Page 329  Friday, December 14, 2001  2:01 PM
Create pdf signature field - C# PDF File Permission Library: add, remove, update PDF file permission in C#.net, ASP.NET, MVC, WPF
Tell C# users how to set PDF file permissions, like printing, copying, modifying, extracting, annotating, form filling, etc
add signature to pdf reader; add signature pdf
Create pdf signature field - VB.NET PDF File Permission Library: add, remove, update PDF file permission in vb.net, ASP.NET, MVC, WPF
VB.NET Tutorial for How to Set PDF File Access Permissions Using XDoc.PDF for .NET
create signature field in pdf; adding signature to pdf files
330
Object-Oriented Programming: Inheritance
Chapter 9
The interactive session in the output box for Fig. 9.15 demonstrates when methods
__getattribute__ and __getattr__ execute. We first create an object of class
DemonstrateAccess, then access attribute value, using the dot access operator. The
output indicates that method __getattribute__ executes in response to the attribute
access; Python displays the return value (1) in the interactive session. Next, the program
accesses attribute novalue, a nonexistent attribute. Method __getattribute__ exe-
cutes  first,  because  the  method  executes  every  time  the  client  attempts  to  access  an
attribute. When the base-class version of the method determines that the object does not
contain a novalue attribute, method __getattr__ executes. The method raises an
exception to indicate that the client has accessed a nonexistent attribute.
9.12.4
__slots__
Cl
a
ss Attri
b
ut
e
Python’s dynamism enables programmers to write applications that can change as they ex-
ecute. Often, this is useful for software development purposes. For example, during the de-
velopment cycle, a graphical-application programmer might create software that enables
the programmer to change the application’s  appearance (i.e., some of the application’s
code) without terminating the application. This technique also is valuable for applications
like Web servers that must continue executing for long periods of time, but that may need
to change periodically to incorporate new features. Dynamism also has drawbacks—usual-
ly dynamic applications or applications programmed in a dynamic language exhibit poorer
performance than do their non-dynamic counterparts. 
One side-effect of Python’s dynamic nature is that a program can add attributes to an
object’s namespace after the object has been created. This practice sometimes can lead to
unexpected results. For example, the programmer could incorrectly type an attribute name
Python 2.2b2 (#26, Nov 16 2001, 11:44:11) [MSC 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> from fig09_15 import DemonstrateAccess
>>> access = DemonstrateAccess()
>>>
>>> access.value
__getattribute__ executing...
Client attempt to access attribute: value
1
>>>
>>> access.novalue
__getattribute__ executing...
Client attempt to access attribute: novalue
__getattr__ executing...
Client attempt to access non-existent attribute: novalue
Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "fig09_15.py", line 28, in __getattr__
raise AttributeError, "Object has no attribute %s" \
AttributeError: Object has no attribute novalue
F
ig
. 9.15
F
ig
. 9.15
F
ig
. 9.15
F
ig
. 9.15
__getattribute__
m
e
th
od
a
n
d
a
ttr
ib
ut
e
acce
ss. (P
a
rt 1 
o
f 2).
pythonhtp1_09.fm  Page 330  Friday, December 14, 2001  2:01 PM
C# PDF Digital Signature Library: add, remove, update PDF digital
Barcode Read. Barcode Create. OCR. Twain. Edit Digital Signatures. |. Home ›› XDoc.PDF ›› C# PDF: Edit PDF Digital Signature.
add jpg signature to pdf; pdf converter sign in
VB.NET PDF Digital Signature Library: add, remove, update PDF
PDF in C#, C#.NET PDF Reading, C#.NET Annotate PDF in WPF, C#.NET PDF Create, C#.NET PDF Document Viewer, C# Search unsigned signature field in PDF document.
add signature to pdf acrobat; copy and paste signature into pdf
Chapter 9
Object-Oriented Programming: Inheritance
331
in an assignment statement. Rather than printing an error, such an assignment statement
simply binds a new attribute name and value to the object, and the program continues exe-
cuting. Python 2.2 allows new classes to define a __slots__ attribute listing the only
attributes that objects of the class are allowed to have. Figure 9.16 presents two simplified
definitions of a point—classes PointWithoutSlots and PointWithSlots. A pro-
gram  can  add  attributes  to  objects  of  class PointWithoutSlots,  but  cannot  add
attributes to objects of class PointWithSlots.
1
# Fig. 9.16: Slots.py
2
# Simple class with slots
3
4
class PointWithoutSlots:
5
"""Programs can add attributes to objects of this class"""
6
7
def __init__( self, xValue = 0.0, yValue = 0.0 ):
8
"""Constructor for PointWithoutSlots, initializes x- and
9
y-coordinates"""
10
11
self.x = float( xValue )
12
self.y = float( yValue )
13
14
class PointWithSlots( object ):
15
"""Programs cannot add attributes to objects of this class"""
16
17
# PointWithSlots objects can contain only attributes x and y
18
__slots__ = [ "x", "y" ]
19
20
def __init__( self, xValue = 0.0, yValue = 0.0 ):
21
"""Constructor for PointWithoutSlots, initializes x- and
22
y-coordinates"""
23
24
self.x = float( xValue )
25
self.y = float( yValue )
26
27
# main program
28
def main():
29
noSlots = PointWithoutSlots() 
30
slots = PointWithSlots() 
31
32
for point in [ noSlots, slots ]:
33
print "\nProcessing an object of class", point.__class__
34
35
print "The current value of point.x is:", point.x
36
newValue = float( raw_input( "Enter new x coordinate: " ) )
37
print "Attempting to set new x-coordinate value..."
38
39
# Logic error: create new attribute called X, instead of
40
# changing the value of attribute X
41
point.X = newValue
42
43
# output unchanged attribute x
44
print "The new value of point.x is:", point.x
F
ig
. 9.16
F
ig
. 9.16
F
ig
. 9.16
F
ig
. 9.16
__slots__
a
ttr
ib
ut
e
—s
peci
fy
i
n
g
objec
t 
a
ttr
ib
ut
e
s.
pythonhtp1_09.fm  Page 331  Friday, December 14, 2001  2:01 PM
C# PDF insert image Library: insert images into PDF in C#.net, ASP
Create high resolution PDF file without image quality losing in ASP and add image, picture, digital photo, scanned signature or logo into PDF document page
add signature box to pdf; create pdf with signature field
How to C#: Basic SDK Concept of XDoc.PDF for .NET
create, load, combine, and split PDF file(s), and add, create, insert, delete, re To be specific, you can edit PDF password and digital signature, and set
export pdf to word sign in; click to sign pdf
332
Object-Oriented Programming: Inheritance
Chapter 9
The PointWithoutSlots  definition  (lines  4–12) simply defines  a  constructor
(lines 7–12) that initializes the point’s x- and y-coordinates. Class PointWithSlots
(lines 14–25) inherits from base-class object, and defines an attribute __slots__—a
list of attribute names that objects of the class may contain. When a new class defines the
__slots__ attribute, objects of the class can assign values only to attributes whose
names appear in the __slots__ list. If a client attempts to assign a value to an attribute
whose name does not appear in __slots__, Python raises an exception.
Software Engineering Observation 9.10
If a new class defines attribute __slots__, but the class’s constructor does not initialize
the attributes’ values, Python assigns None to each attribute in __slots__ when an object
of the class is created.
9.10
Software Engineering Observation 9.11
A derived class inherits its base-class __slots__ attribute. However, if programs should
not be allowed to add attributes to objects of the derived class, the derived class must define
its own __slots__ attribute. The derived-class __slots__ contains only the allowed
derived-class attribute names, but clients still can set values for attributes specified by the
derived class’s direct and indirect bases classes.
9.11
The driver program (lines 28–44) demonstrates the difference between an object of a
class that defines __slots__ and an object of a class that does not define __slots__.
Lines 29–30 assign create objects of classes PointWithoutSlots and PointsWith-
Slots, respectively. The for loop in lines 32–44 iterates over each object and attempts
to replace the value of the object’s x attribute with a user-supplied value, obtained in line
36. Line 41 contains a logic error—the program intends to modify the value of the object’s
x attribute, but mistakenly creates an attribute called X and assigns the user-entered value
45
46
if __name__ == "__main__":
47
main()
Processing an object of class __main__.PointWithoutSlots
The current value of point.x is: 0.0
Enter new x coordinate: 1.0
Attempting to set new x-coordinate value...
The new value of point.x is: 0.0
Processing an object of class <class '__main__.PointWithSlots'>
The current value of point.x is: 0.0
Enter new x coordinate: 1.0
Attempting to set new x-coordinate value...
Traceback (most recent call last):
File "Slots.py", line 47, in ?
main()
File "Slots.py", line 41, in main
point.X = newValue
AttributeError: 'PointWithSlots' object has no attribute 'X'
F
ig
. 9.16
F
ig
. 9.16
F
ig
. 9.16
F
ig
. 9.16
__slots__
a
ttr
ib
ut
e
—s
peci
fy
i
n
g
objec
t 
a
ttr
ib
ut
e
s.
pythonhtp1_09.fm  Page 332  Friday, December 14, 2001  2:01 PM
VB.NET PDF: Basic SDK Concept of XDoc.PDF
create, load, combine, and split PDF file(s), and add, create, insert, delete, re To be specific, you can edit PDF password and digital signature, and set
adding signature to pdf file; adding a signature to a pdf in preview
C# Create PDF Library SDK to convert PDF from other file formats
What's more, you can also protect created PDF file by adding digital signature (watermark) on PDF using C# code. Create PDF Document from Existing Files Using
add signature to pdf preview; pdf sign in
Chapter 9
Object-Oriented Programming: Inheritance
333
to the new attribute. For objects of class PointWithoutSlots (e.g., object noSlots),
line 41 executes without raising an exception, and line 44 prints the unchanged value of
attribute x. For objects of class PointWithSlots (e.g., slots), line 41 raises an excep-
tion, because the object’s __slots__ attribute does not contain the name "X".
The example in Fig. 9.16 demonstrates one benefit of defining the __slots__ attribute
for new  classes, namely preventing accidental  attribute creation.  Programs that use new
classes also gain performance benefits, because  Python  knows in advance that programs
cannot add new attributes to an object; therefore, Python can store and manipulate the objects
in a more efficient manner. A disadvantage of __slots__ is that experienced Python pro-
grammers  sometimes  expect  the  ability  to  add  object  attributes  dynamically.  Defining
__slots__ can inhibit programmers’ abilities to create dynamic applications quickly.
9.12.5 Pr
ope
rti
e
s
Python’s new classes can contain properties that describe object attributes. A program ac-
cesses an object’s properties using object-attribute syntax. However, a class definition cre-
ates a property by specifying up to four components—a get method that executes when a
program accesses the property’s value, a set method that executes when a program sets the
property’s value, a delete method that executes when a program deletes the value (e.g., with
keyword del) and a docstring that describes the property. The get, set and delete methods
can perform the tasks that maintain an object’s data in a consistent state. Thus, properties
provide an additional way for programmers to control access to an object’s data.
Figure 9.17 redefines class Time—the class previously used to demonstrate attribute
access—to contain attributes hour, minute and second as properties. The constructor
(lines 7–12) creates private attributes __hour, __minute and __second. Typically,
classes that use properties define their attributes to be private, to hide the data from clients
of the class. The clients of the class then access the public properties of that class, which
get and set the values of the private attributes.
Method deleteValue (lines 20–23) raises an exception to prevent a client from
deleting an attribute. We use this method to create properties that the client cannot delete.
Each property (hour, minute and second) defines corresponding get and set methods.
Each get method takes only the object reference as an argument and returns the property’s
value. Each set method takes two arguments—the object-reference argument and the new
value for the property. Lines 25–32 define the set method (setHour) for the hour prop-
erty. If the new value is within the appropriate range, the method assigns the new value to
the property; otherwise, the method raises an exception. Method getHour (lines 34–37)
is the hour property’s get method, which simply returns the value of the corresponding
private attribute (__hour).
1
# Fig. 9.17: TimeProperty.py
2
# Class Time with properties
3
4
class Time( object ):
5
"""Class Time with hour, minute and second properties"""
6
F
ig
. 9.17
F
ig
. 9.17
F
ig
. 9.17
F
ig
. 9.17
Pr
ope
rt
ie
s—
cla
ss 
Time
. (P
a
rt 1 
o
f 3).
pythonhtp1_09.fm  Page 333  Friday, December 14, 2001  2:01 PM
VB.NET PDF insert image library: insert images into PDF in vb.net
Create high resolution PDF file without image quality losing Import graphic picture, digital photo, signature and logo Insert images into PDF form field in VB
add signature to pdf file; add a signature to a pdf file
VB.NET PDF Library SDK to view, edit, convert, process PDF file
Password, digital signature and PDF text, image and page added to a specific location on PDF file page. In addition, you can easily create, modify, and delete
pdf signatures; adding a signature to a pdf form
334
Object-Oriented Programming: Inheritance
Chapter 9
7
def __init__( self, hourValue, minuteValue, secondValue ):
8
"""Time constructor, takes hour, minute and second"""
9
10
self.__hour = hourValue
11
self.__minute = minuteValue
12
self.__second = secondValue
13
14
def __str__( self ):
15
"""String representation of an object of class Time"""
16
17
return "%.2d:%.2d:%.2d" % \
18
( self.__hour, self.__minute, self.__second ) 
19
20
def deleteValue( self ):
21
"""Delete method for Time properties"""
22
23
raise TypeError, "Cannot delete attribute"
24
25
def setHour( self, value ):
26
"""Set method for hour attribute"""
27
28
if 0 <= value < 24:
29
self.__hour = value
30
else:
31
raise ValueError, \
32
"hour (%d) must be in range 0-23, inclusive" % value
33
34
def getHour( self ):
35
"""Get method for hour attribute"""
36
37
return self.__hour
38
39
# create hour property
40
hour = property( getHour, setHour, deleteValue, "hour" )   
41
42
def setMinute( self, value ):
43
"""Set method for minute attribute"""
44
45
if 0 <= value < 60:
46
self.__minute = value
47
else:
48
raise ValueError, \
49
"minute (%d) must be in range 0-59, inclusive" % value
50
51
def getMinute( self ):
52
"""Get method for minute attribute"""
53
54
return self.__minute       
55
56
# create minute property
57
minute = property( getMinute, setMinute, deleteValue, "minute" )
58
F
ig
. 9.17
F
ig
. 9.17
F
ig
. 9.17
F
ig
. 9.17
Pr
ope
rt
ie
s—
cla
ss 
Time
. (P
a
rt 1 
o
f 3).
pythonhtp1_09.fm  Page 334  Friday, December 14, 2001  2:01 PM
C# PDF remove image library: remove, delete images from PDF in C#.
Barcode Read. Barcode Create. OCR. Twain. Image: Remove Image graphic picture, digital photo, scanned signature, logo, etc. multiple or all images from PDF document
pdf secure signature; pdf signature field
C# PDF Convert to Images SDK: Convert PDF to png, gif images in C#
in C#.NET class. Create image files including all PDF contents, like watermark and signature in .NET. Turn multipage PDF file into
adding signature to pdf form; pdf will signature
Chapter 9
Object-Oriented Programming: Inheritance
335
59
def setSecond( self, value ):
60
"""Set method for second attribute"""
61
62
if 0 <= value < 60:
63
self.__second = value
64
else:
65
raise ValueError, \
66
"second (%d) must be in range 0-59, inclusive" % value
67
68
def getSecond( self ):
69
"""Get method for second attribute"""
70
71
return self.__second
72
73
# create second property
74
second = property( getSecond, setSecond, deleteValue, "second" )
Python 2.2b2 (#26, Nov 16 2001, 11:44:11) [MSC 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> from TimeProperty import Time
>>>
>>> time1 = Time( 5, 27, 19 )
>>> print time1
05:27:19
>>> print time1.hour, time1.minute, time1.second
5 27 19
>>>
>>> time1.hour, time1.minute, time1.second  = 16, 1, 59
>>> print time1
16:01:59
>>>
>>> time1.hour = 25
Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "TimeProperty.py", line 31, in setHour
raise ValueError, \
ValueError: hour (25) must be in range 0-23, inclusive
>>>
>>> time1.minute = -3
Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "TimeProperty.py", line 48, in setMinute
raise ValueError, \
ValueError: minute (-3) must be in range 0-59, inclusive
>>>
>>> time1.second = 99
Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "TimeProperty.py", line 65, in setSecond
raise ValueError, \
ValueError: second (99) must be in range 0-59, inclusive
F
ig
. 9.17
F
ig
. 9.17
F
ig
. 9.17
F
ig
. 9.17
Pr
ope
rt
ie
s—
cla
ss 
Time
. (P
a
rt 1 
o
f 3).
pythonhtp1_09.fm  Page 335  Friday, December 14, 2001  2:01 PM
336
Object-Oriented Programming: Inheritance
Chapter 9
Built-in function property (line 40) takes as arguments a get method, a set method,
a delete method and a docstring and returns a property for the class. Line 40 creates the
hour property by passing to function property methods getHour,  setHour and
deleteValue and the string "hour". Clients access properties, using the dot (.) access
operator. When the client uses a property as an rvalue, the property’s get method executes.
When the client uses the property as an lvalue, the property’s set method executes. When
the client deletes the property with keyword del, the property’s delete method executes.
The remainder of the class definition (lines 42–74) defines get and set methods for proper-
ties minute (created in line 57) and second (created in line 74).
Software Engineering Observation 9.12
Function property does not require that the caller pass all four arguments. Instead, the
caller can pass values for keyword arguments fget, fset, fdel and doc to specify the
property’s get, set and delete methods and the docstring, repsectively.
9.12
The interactive session in Fig. 9.17 highlights the benefits of properties. A client of the
class can access an object’s attributes, using the dot access operator, but the class author
also  can  ensure  data  integrity.  Properties  have  added  advantages  over  implementing
methods __setattr__, __getattr__  and __delattr__.  For  example,  class
authors can state explicitly the attributes for which the client may use the dot access nota-
tion. Additionally, the class author can write separate get, set and delete methods for each
attribute, rather than using if/else logic to determine which attribute to access.
In this chapter, we discussed the mechanics of inheritance and how inheritance pro-
motes software reuse and data abstraction. We discussed two examples of inheritance—one
example  of structural inheritance and one  example  of  a class  hierarchy  headed by an
abstract base class. We also introduced new object-oriented-programming features avail-
able in Python 2.2. We continued our discussion of data integrity by presenting proper-
ties—a feature that allows clients of the class to access data with the dot access operator
and allows classes to maintain private data in a consistent state. Data hiding and data integ-
rity are fundamental object-oriented software design principles. The topics discussed in this
and the previous two chapters provide a solid foundation for programmers who want to
build large, industrial-strength software systems in Python.
SUMMARY
• Inheritance is a form of software reusability in which new classes are created from existing classes
by absorbing their attributes and behaviors and then overriding or embellishing these with capa-
bilities the new classes require.
• When creating a new class, instead of writing completely new attributes and methods, the pro-
grammer can designate that the new class is to inherit the attributes and methods of a previously
defined base class.
• The class that inherits from a base class is referred to as a derived class. Each derived class itself
becomes a candidate to be a base class for some future derived class.
• With single inheritance, a class is derived from one base class.
• With multiple inheritance, a derived class inherits from multiple (possibly unrelated) base classes.
Multiple inheritance can be complex and error prone.
• The real strength of inheritance comes from the ability to define in the derived class additions, re-
placements or refinements for the features inherited from the base class. 
pythonhtp1_09.fm  Page 336  Friday, December 14, 2001  2:01 PM
Chapter 9
Object-Oriented Programming: Inheritance
337
• With inheritance, every object of a derived class also may be treated as an object of that derived
class’s base class. However, the converse is not true—base-class objects are not objects of that
base class’s derived classes.
• With polymorphism, it is possible to design and implement systems that are more easily extensi-
ble. Programs can be written to process generically—as base-class objects—objects of all existing
classes in a hierarchy.
• Polymorphism enables us to write programs in a general fashion to handle a wide variety of exist-
ing and yet-to-be-specified related classes.
• Object-oriented programming provides several ways of “seeing the forest through the trees”—a
process called abstraction.
• “Is a” is inheritance. In an “is-a” relationship, an object of a derived-class type may also be treated
as an object of the base-class type.
• “Has a” is composition. In a “has-a” relationship, an object 
has references to one or more objects
of other classes as members.
• A derived class can access the attributes and methods of its base class. When a base-class member
implementation is inappropriate for a derived class, that member can be overridden (i.e., replaced)
in the derived class with an appropriate implementation.
• Inheritance forms tree-like hierarchical structures. A base class exists in a hierarchical relationship
with its derived classes. 
• Function issubclass takes two arguments that are classes and returns true if the first argument
is a class that inherits from the second argument (or if the first argument is the same class as the
second argument)
• Python provides a built-in function— isinstance—that determines whether an object is an ob-
ject of a given class or of a subclass of that class. 
• Parentheses, (), in the first line of the class definition indicates inheritance. The name of the base
class (or base classes) is placed inside the parentheses. 
• A direct base class of a derived class is explicitly listed inside parentheses when the derived class
is defined. 
• An indirect base class is not explicitly listed when the derived class is defined; rather the indirect
base class is inherited from two or more levels up the class hierarchy.
• To initialize an object of a derived class, the derived-class constructor must call the base-class con-
structor.
• A bound method call is invoked by accessing the method name through an object. Python auto-
matically inserts the object reference argument for bound method calls.
• An unbound method call is invoked by accessing the method through its class name then specifi-
cally passing an object. 
• A class’s __bases__ attribute is a tuple that contains references to each of the class’s base classes. 
• A derived class can override a base-class method by supplying a new version of that method with
the same name. When that method is mentioned by name in the derived class, the derived-class
version is automatically selected.
• A base class specifies commonality. In the object-oriented design process, the designer looks for
commonality and “factors it out” to form base classes. Derived classes are then customized beyond
the capabilities inherited from the base class.
• A program uses an object if the program simply calls a method of that object through a reference.
• An object is said to have a knows a relationship with a second object if the first object is aware of
(i.e., has a reference to) the second object. This is sometimes called an association.
pythonhtp1_09.fm  Page 337  Friday, December 14, 2001  2:01 PM
338
Object-Oriented Programming: Inheritance
Chapter 9
• There are cases in which it is useful to define classes for which the programmer never intends to
create any objects. Such classes are called abstract classes.
• The sole purpose of an abstract class is to provide an appropriate base class from which classes
may inherit interface and possibly implementation. Classes from which objects can be created are
called concrete classes.
• Python does not provide a way to designate an abstract class. However, the programmer can im-
plement an abstract class by raising an exception in the class’s __init__ method.
• Python is inherently polymorphic because the language is dynamically typed. This means that Py-
thon determines at runtime whether an object defines a method or contains an attribute and, if so,
calls the appropriate method or accesses the appropriate attribute.
• Using polymorphism, one method call can cause different actions to occur depending on the class
of the object receiving the call. This gives the programmer tremendous expressive capability.
• Beginning with Python 2.2, the nature and behavior of classes will change. In all future 2.x releas-
es, a programmer can distinguish between two kinds of classes: “classic” classes and “new” class-
es. In Python 3.0, all classes will behave like “new” classes.
• Python 2.2 provides type object for defining “new” classes. Any class that inherits from ob-
ject exhibits the new-class behaviors.
• “New” classes can define static methods. A static method can be called by a client of the class,
even if no objects of the class exist.
• A class designates a method as static by passing the method’s name to built-in function static-
method and binding a name to the value returned from the function call.
• Static methods differ from regular methods in that when a program calls a static method, Python
does not pass the object reference argument to the method. Therefore, a static method does not
specify self as the first argument.
• The goal of the new class behavior is to remove the dichotomy that existed between Python types
and classes before version 2.2. The most practical use of this type-class unification is that program-
mers now can inherit from Python’s built-in types.
• Classes that inherit from base-class object also can define method __getattribute__,
which executes for every attribute access.
• Method __getattribute__ in a derived class must call the base-class version of the method
to retrieve an object’s attribute; otherwise, infinite recursion occurs.
• Python 2.2 allows “new” classes to define a __slots__ attribute listing the attributes that ob-
jects of the class are allowed to have.
• When a “new” class defines the __slots__ attribute, objects of the class can assign values only
to attributes whose names appear in the __slots__ list. If a client attempts to assign a value to
an attribute whose name does not appear in __slots__, Python raises an exception.
• ““New” classes can contain properties that describe object attributes. A program accesses an ob-
ject’s properties in the same manner as accessing the object’s attributes.
• A class definition creates a property by specifying four components—a get method, a set method,
a delete method and a docstring that describes the property. The get, set and delete methods can
perform any tasks necessary for maintaining data in a consistent state.
• Classes that use properties most often define their attributes to be private, to hide the data from
clients of the class. The clients of the class then access the public properties of that class, which
get and set the values of the private attributes.
• Built-in function property takes as arguments a get method, a set method, a delete method and
a docstring and returns a property for the class.
pythonhtp1_09.fm  Page 338  Friday, December 14, 2001  2:01 PM
Documents you may be interested
Documents you may be interested