Archive:Think Python/Classes and functions

2008-10-06T21:26:32Z

82.32.51.70: /* Chapter&#XA0;16&#XA0;&#XA0;Classes and functions */

{{Think Python/Page}}

== Chapter 16 Classes and functions ==

=== 16.1 Time ===

As another example of a user-defined type, we'll define a class called
<TT>Time</TT> that records the time of day. The class definition looks
like this:

<PRE CLASS="verbatim">class Time(object):
"""represents the time of day.
attributes: hour, minute, second"""
</PRE>
We can create a new <TT>Time</TT> object and assign
attributes for hours, minutes, and seconds:
<PRE CLASS="verbatim">time = Time()
time.hour = 11
time.minute = 59
time.second = 30
</PRE>
The state diagram for the <TT>Time</TT> object looks like this:

<DIV CLASS="center"><IMG SRC="book025.png"></DIV><DIV CLASS="theorem">'''Exercise&#XA0;1'''&#XA0;&#XA0;''
''''
Write a function called ''<CODE>''print_time''</CODE>'' that takes a
Time object and prints it in the form ''''<TT>hour:minute:second</TT>''''.
Hint: the format sequence ''<CODE>'''%.2d'''</CODE>'' prints an integer using
at least two digits, including a leading zero if necessary.
''</DIV><DIV CLASS="theorem">'''Exercise&#XA0;2'''&#XA0;&#XA0;''
''

''Write a boolean function called ''<CODE>''is_after''</CODE>'' that
takes two Time objects, ''''<TT>t1</TT>'''' and ''''<TT>t2</TT>'''', and
returns ''''<TT>True</TT>'''' if ''''<TT>t1</TT>'''' follows ''''<TT>t2</TT>'''' chronologically and
''''<TT>False</TT>'''' otherwise. Challenge: don&#X2019;t use an ''''<TT>if</TT>'''' statement.
''
</DIV>=== 16.2&#XA0;&#XA0;Pure functions ===

In the next few sections, we&#X2019;ll write two functions that add time
values. They demonstrate two kinds of functions: pure functions and
modifiers. They also demonstrate a development plan I&#X2019;ll call '''prototype and patch''', which is a way of tackling a complex problem
by starting with a simple prototype and incrementally dealing with the
complications.

Here is a simple prototype of <CODE>add_time</CODE>:
<PRE CLASS="verbatim">def add_time(t1, t2):
sum = Time()
sum.hour = t1.hour + t2.hour
sum.minute = t1.minute + t2.minute
sum.second = t1.second + t2.second
return sum
</PRE>
The function creates a new <TT>Time</TT> object, initializes its
attributes, and returns a reference to the new object. This is called
a '''pure function''' because it does not modify any of the objects
passed to it as arguments and it has no effect,
like displaying a value or getting user input,
other than returning a value.

To test this function, I&#X2019;ll create two Time objects: <TT>start</TT>
contains the start time of a movie, like ''Monty Python and the
Holy Grail'', and <TT>duration</TT> contains the run time of the movie,
which is one hour 35 minutes.

<CODE>add_time</CODE> figures out when the movie will be done.
<PRE CLASS="verbatim">>>> start = Time()
>>> start.hour = 9
>>> start.minute = 45
>>> start.second = 0

>>> duration = Time()
>>> duration.hour = 1
>>> duration.minute = 35
>>> duration.second = 0

>>> done = add_time(start, duration)
>>> print_time(done)
10:80:00
</PRE>
The result, <TT>10:80:00</TT> might not be what you were hoping
for. The problem is that this function does not deal with cases where the
number of seconds or minutes adds up to more than sixty. When that
happens, we have to &#X201C;carry&#X201D; the extra seconds into the minute column
or the extra minutes into the hour column.

Here&#X2019;s an improved version:
<PRE CLASS="verbatim">def add_time(t1, t2):
sum = Time()
sum.hour = t1.hour + t2.hour
sum.minute = t1.minute + t2.minute
sum.second = t1.second + t2.second

if sum.second >= 60:
sum.second -= 60
sum.minute += 1

if sum.minute >= 60:
sum.minute -= 60
sum.hour += 1

return sum
</PRE>
Although this function is correct, it is starting to get big.
We will see a shorter alternative later.
=== 16.3&#XA0;&#XA0;Modifiers ===

Sometimes it is useful for a function to modify the objects it gets as
parameters. In that case, the changes are visible to the caller.
Functions that work this way are called '''modifiers'''.

<TT>increment</TT>, which adds a given number of seconds to a <TT>Time</TT>
object, can be written naturally as a
modifier. Here is a rough draft:
<PRE CLASS="verbatim">def increment(time, seconds):
time.second += seconds

if time.second >= 60:
time.second -= 60
time.minute += 1

if time.minute >= 60:
time.minute -= 60
time.hour += 1
</PRE>
The first line performs the basic operation; the remainder deals
with the special cases we saw before.

Is this function correct? What happens if the parameter <TT>seconds</TT>
is much greater than sixty?

In that case, it is not enough to carry
once; we have to keep doing it until <TT>time.second</TT> is less than sixty.
One solution is to replace the <TT>if</TT> statements with <TT>while</TT>
statements. That would make the function correct, but not
very efficient.
<DIV CLASS="theorem">'''Exercise&#XA0;3'''&#XA0;&#XA0;''
Write a correct version of ''''<TT>increment</TT>'''' that
doesn&#X2019;t contain any loops.
''</DIV>
Anything that can be done with modifiers can also be done with pure
functions. In fact, some programming languages only allow pure
functions. There is some evidence that programs that use pure
functions are faster to develop and less error-prone than programs
that use modifiers. But modifiers are convenient at times,
and functional programs tend to be less efficient.

In general, I recommend that you write pure functions whenever it is
reasonable and resort to modifiers only if there is a compelling
advantage. This approach might be called a '''functional
programming style'''.

<DIV CLASS="theorem">'''Exercise&#XA0;4'''&#XA0;&#XA0;''
Write a &#X201C;pure&#X201D; version of ''''<TT>increment</TT>'''' that creates and returns
a new Time object rather than modifying the parameter.
''</DIV>=== 16.4&#XA0;&#XA0;Prototyping versus planning ===

The development plan I am demonstrating is called &#X201C;prototype and
patch.&#X201D; For each function, I wrote a prototype that performed the
basic calculation and then tested it, patching errors along the
way.

This approach can be effective, especially if you don&#X2019;t yet have a
deep understanding of the problem. But incremental corrections can
generate code that is unnecessarily complicated&#X2014;since it deals with
many special cases&#X2014;and unreliable&#X2014;since it is hard to know if you
have found all the errors.

An alternative is '''planned development''', in which high-level
insight into the problem can make the programming much easier. In
this case, the insight is that a Time object is really a three-digit
number in base 60 (see <TT>wikipedia.org/wiki/Sexagesimal</TT>)! The
<TT>second</TT> attribute is the &#X201C;ones column,&#X201D; the <TT>minute</TT>
attribute is the &#X201C;sixties column,&#X201D; and the <TT>hour</TT> attribute is
the &#X201C;thirty-six hundreds column.&#X201D;

When we wrote <CODE>add_time</CODE> and <TT>increment</TT>, we were effectively
doing addition in base 60, which is why we had to carry from one
column to the next.

This observation suggests another approach to the whole problem&#X2014;we
can convert Time objects to integers and take advantage of the fact
that the computer knows how to do integer arithmetic.

Here is a function that converts Times to integers:
<PRE CLASS="verbatim">def time_to_int(time):
minutes = time.hour * 60 + time.minute
seconds = minutes * 60 + time.second
return seconds
</PRE>
And here is the function that converts integers to Times
(recall that <TT>divmod</TT> divides the first argument by the second
and returns the quotient and remainder as a tuple).

<PRE CLASS="verbatim">def int_to_time(seconds):
time = Time()
minutes, time.second = divmod(seconds, 60)
time.hour, time.minute = divmod(minutes, 60)
return time
</PRE>
You might have to think a bit, and run some tests, to convince
yourself that these functions are correct. One way to test them is to
check that <CODE>time_to_int(int_to_time(x)) == x</CODE> for many values of
<TT>x</TT>. This is an example of a consistency check.

Once you are convinced they are correct, you can use them to
rewrite <CODE>add_time</CODE>:
<PRE CLASS="verbatim">def add_time(t1, t2):
seconds = time_to_int(t1) + time_to_int(t2)
return int_to_time(seconds)
</PRE>
This version is shorter than the original, and easier to verify.
<DIV CLASS="theorem">'''Exercise&#XA0;5'''&#XA0;&#XA0;''
Rewrite ''''<TT>increment</TT>'''' using ''<CODE>''time_to_int''</CODE>'' and ''<CODE>''int_to_time''</CODE>''.
''</DIV>
In some ways, converting from base 60 to base 10 and back is harder
than just dealing with times. Base conversion is more abstract; our
intuition for dealing with time values is better.

But if we have the insight to treat times as base 60 numbers and make
the investment of writing the conversion functions (<CODE>time_to_int</CODE>
and <CODE>int_to_time</CODE>), we get a program that is shorter, easier to
read and debug, and more reliable.

It is also easier to add features later. For example, imagine
subtracting two Times to find the duration between them. The
na&#XEF;ve approach would be to implement subtraction with borrowing.
Using the conversion functions would be easier and more likely to be
correct.

Ironically, sometimes making a problem harder (or more general) makes it
easier (because there are fewer special cases and fewer opportunities
for error).
=== 16.5&#XA0;&#XA0;Debugging ===

A Time object is well-formed if the values of <TT>minutes</TT> and <TT>seconds</TT> are between 0 and 60 (including 0 but not 60) and if
<TT>hours</TT> is positive. <TT>hours</TT> and <TT>minutes</TT> should be
integral values, but we might allow <TT>seconds</TT> to have a
fraction part.

These kind of requirements are called '''invariants''' because
they should always be true. To put it a different way, if they
are not true, then something has gone wrong.

Writing code to check your invariants can help you detect errors
and find their causes. For example, you might have a function
like <CODE>valid_time</CODE> that takes a Time object and returns
<TT>False</TT> if it violates an invariant:
<PRE CLASS="verbatim">def valid_time(time):
if time.hours < 0 or time.minutes < 0 or time.seconds < 0:
return False
if time.minutes >= 60 or time.seconds >= 60:
return False
return True
</PRE>
Then at the beginning of each function you could check the
arguments to make sure they are valid:

<PRE CLASS="verbatim">def add_time(t1, t2):
if not valid_time(t1) or not valid_time(t2):
raise ValueError, 'invalid Time object in add_time'
seconds = time_to_int(t1) + time_to_int(t2)
return int_to_time(seconds)
</PRE>
Or you could use an <TT>assert</TT> statement, which checks a given invariant
and raises an exception if it fails:

<PRE CLASS="verbatim">def add_time(t1, t2):
assert valid_time(t1) and valid_time(t2)
seconds = time_to_int(t1) + time_to_int(t2)
return int_to_time(seconds)
</PRE>
<TT>assert</TT> statements are useful because they distinguish
code that deals with normal conditions from code
that checks for errors.
=== 16.6&#XA0;&#XA0;Glossary ===

<DL CLASS="description"><DT CLASS="dt-description">'''prototype and patch:'''</DT><DD CLASS="dd-description"> A development plan that involves
writing a rough draft of a program, testing, and correcting errors as
they are found.
</DD><DT CLASS="dt-description">'''planned development:'''</DT><DD CLASS="dd-description"> A development plan that involves
high-level insight into the problem and more planning than incremental
development or prototype development.
</DD><DT CLASS="dt-description">'''pure function:'''</DT><DD CLASS="dd-description"> A function that does not modify any of the objects it
receives as arguments. Most pure functions are fruitful.
</DD><DT CLASS="dt-description">'''modifier:'''</DT><DD CLASS="dd-description"> A function that changes one or more of the objects it
receives as arguments. Most modifiers are fruitless.
</DD><DT CLASS="dt-description">'''functional programming style:'''</DT><DD CLASS="dd-description"> A style of program design in which the
majority of functions are pure.
</DD><DT CLASS="dt-description">'''invariant:'''</DT><DD CLASS="dd-description"> A condition that should always be true during the
execution of a program.
</DD></DL>=== 16.7&#XA0;&#XA0;Exercises ===

<DIV CLASS="theorem">'''Exercise&#XA0;6'''&#XA0;&#XA0;''
Write a function called ''<CODE>''mul_time''</CODE>'' that takes a Time object
and a number and returns a new Time object that contains
the product of the original Time and the number.''
''Then use ''<CODE>''mul_time''</CODE>'' to write a function that takes a Time
object that represents the finishing time in a race, and a number
that represents the distance, and returns a Time object that represents
the average pace (time per mile).''

</DIV><DIV CLASS="theorem">'''Exercise&#XA0;7'''&#XA0;&#XA0;
''
''

''Write a class definition for a Date object that has attributes ''''<TT>day</TT>'''', ''''<TT>month</TT>'''' and ''''<TT>year</TT>''''. Write a function called
''<CODE>''increment_date''</CODE>'' that takes a Date object, ''''<TT>date</TT>'''' and an
integer, ''''<TT>n</TT>'''', and returns a new Date object that
represents the day ''''<TT>n</TT>'''' days after ''''<TT>date</TT>''''. Hint:
&#X201C;Thirty days hath September...&#X201D; Challenge: does your function
deal with leap years correctly? See ''''<TT>wikipedia.org/wiki/Leap_year</TT>''
</DIV><DIV CLASS="theorem">'''Exercise&#XA0;8'''&#XA0;&#XA0;
''
''

''The ''''<TT>datetime</TT>'''' module provides ''''<TT>date</TT>'''' and ''''<TT>time</TT>'''' objects
that are similar to the Date and Time objects in this chapter, but
they provide a rich set of methods and operators. Read the
documentation at ''''<TT>docs.python.org/lib/datetime-date.html</TT>''''.''

*''Use the ''''<TT>datetime</TT>'''' module to write a program that
gets the current date and prints the day of the week.''

*''Write a program that takes a birthday as input
and prints the user&#X2019;s age and the number of days, hours,
minutes and seconds until their next birthday.
''

</DIV><HR>
<IMG SRC="previous_motif.gif" ALT="Previous">
<IMG SRC="contents_motif.gif" ALT="Up">
<IMG SRC="next_motif.gif" ALT="Next">

Template:OMIM

2006-12-05T01:45:09Z

82.32.38.45:

[[Mendelian Inheritance in Man]] (OMIM) [http://www.ncbi.nlm.nih.gov/entrez/dispomim.cgi?id={{{1}}} {{{1}}}]<noinclude>[[Category:External link templates|OMIM]]</noinclude>

[[Image:Stop hand.svg|left|3000x3000px]]

IdeaWazaWiki - User contributions [en]

Archive:Think Python/Classes and functions

Template:OMIM