Author Dusty Phillips Reviewers

[
 151 
]
This class allows us to create characters and prefix them with a special character 
when the 
str()
function is applied to them. Nothing too exciting there. We only 
have to make a few minor modifications to the 
Document
and 
Cursor
classes to
work with this class. In the 
Document
class, we add these two lines at the
beginning of the 
insert
method:
def insert(self, character):
if not hasattr(character, 'character'):
character = Character(character)
This is a rather strange bit of code. Its basic purpose is to check whether the character 
being passed in is a 
Character
or a 
str
. If it is a string, it is wrapped in a 
Character
class so all objects in the list are 
Character
objects. However, it is entirely possible 
that someone using our code would want to use a class that is neither 
Character
nor string, using duck typing. If the object has a character attribute, we assume it is 
a "
Character
-like" object. But if it does not, we assume it is a "
str
-like" object and 
wrap it in 
Character
. This helps the program take advantage of duck typing as well 
as polymorphism; as long as an object has a character attribute, it can be used in the 
Document
class.
This generic check could be very useful, for example, if we wanted to make a 
programmer's editor with syntax highlighting: we'd need extra data on the character, 
such as what type of syntax token the character belongs to. Note that if we are doing 
a lot of this kind of comparison, it's probably better to implement 
Character
as an 
abstract base class with an appropriate 
__subclasshook__
, as discussed in 
Chapter 3
, 
When Objects Are Alike
.
In addition, we need to modify the string property on 
Document
to accept the new 
Character
values. All we need to do is call 
str()
on each character before we join it:
@property
def string(self):