Chapter 16  Classes and functions 第 16 章 类与函数

本页译自 Think Python 2e（Allen B. Downey）· Chapter 16 Classes and functions。代码块保留英文原文不翻译；正文段段对照，中文块可用右下角按钮隐藏。

Code examples from this chapter are available from http://thinkpython.com/code/Time1.py.

16.1 Time 16.1 时间

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

We can create a new Time object and assign attributes for hours, minutes, and seconds:

The state diagram for the Time object looks like Figure 16.1.

Exercise 1

Write a function called Time00014 that takes a Time object and prints it in the form Time00015







. Hint: the format sequence Time00 prints an integer using at least two digits, including a leading zero if necessary.

Exercise 2

Write a boolean function called Time0002 that takes two Time objects, t1 and t1, and returns Time if t1 follows t1 chronologically and Time0 otherwise. Challenge: don’t use an t1 statement.

Figure 16.1: Object diagram.

16.2 Pure functions 16.2 纯函数

In the next few sections, we’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’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 Time0003:

The function creates a new Time 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’ll create two Time objects: Time0 contains the start time of a movie, like Monty Python and the Holy Grail, and Time0004 contains the run time of the movie, which is one hour 35 minutes.

Time0004 figures out when the movie will be done.

The result, Time0005 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 “carry” the extra seconds into the minute column or the extra minutes into the hour column.

Here’s an improved version:

Although this function is correct, it is starting to get big. We will see a shorter alternative later.

16.3 Modifiers 16.3 修改器

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.

Time00054, which adds a given number of seconds to a Time object, can be written naturally as a modifier. Here is a rough draft:

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 Time000 is much greater than sixty?

In that case, it is not enough to carry once; we have to keep doing it until Time00061
is less than sixty. One solution is to replace the t1 statements with Time0 statements. That would make the function correct, but not very efficient.

Exercise 3

Write a correct version of Time00067 that doesn’t contain any loops.

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.

Exercise 4

Write a “pure” version of Time00069 that creates and returns a new Time object rather than modifying the parameter.

16.4 Prototyping versus planning 16.4 原型开发与规划

The development plan I am demonstrating is called “prototype and patch.” 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’t yet have a deep understanding of the problem. But incremental corrections can generate code that is unnecessarily complicated—since it deals with many special cases—and unreliable—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 Time00072





























.)! The Time00 attribute is the “ones column,” the Time00 attribute is the “sixties column,” and the Time attribute is the “thirty-six hundreds column.”

When we wrote Time0008 and Time00082, 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—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:

And here is the function that converts integers to Times (recall that Time00 divides the first argument by the second and returns the quotient and remainder as a tuple).

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 Time00092





















for many values of x. This is an example of a consistency check.

Once you are convinced they are correct, you can use them to rewrite Time0009:

This version is shorter than the original, and easier to verify.

Exercise 5

Rewrite Time00099 using Time00100
and Time00101
.

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 (Time00105
and Time00106
), 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 naive 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 Debugging 16.5 调试

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

Requirements like these 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 Time00123 that takes a Time object and returns Time0 if it violates an invariant:

Then at the beginning of each function you could check the arguments to make sure they are valid:

Or you could use an Time00 statement, which checks a given invariant and raises an exception if it fails:

Time00 statements are useful because they distinguish code that deals with normal conditions from code that checks for errors.

16.6 Glossary 16.6 术语表

prototype and patch:

A development plan that involves writing a rough draft of a program, testing, and correcting errors as they are found.

planned development:

A development plan that involves high-level insight into the problem and more planning than incremental development or prototype development.

pure function:

A function that does not modify any of the objects it receives as arguments. Most pure functions are fruitful.

modifier:

A function that changes one or more of the objects it receives as arguments. Most modifiers are fruitless.

functional programming style:

A style of program design in which the majority of functions are pure.

invariant:

A condition that should always be true during the execution of a program.

prototype and patch 原型与打补丁：

一种开发方案：先写出程序的粗略草稿，进行测试，并在发现错误时逐一修正。

planned development 规划式开发：

一种开发方案：基于问题的高层洞察进行规划，比渐进式开发或原型开发更有计划性。

pure function 纯函数：

不修改任何作为实参传入的对象的t1。大多数纯函数都是有返回值的。

modifier 修改器：

会修改一个或多个作为实参传入的对象的t1。大多数修改器都没有返回值。

functional programming style 函数式编程风格：

一种程序设计风格，其中绝大多数t1都是纯函数。

invariant 不变量：

在程序执行过程中应当始终为真的条件。

16.7 Exercises 16.7 习题

Code examples from this chapter are available from Time00138

























; solutions to these exercises are available from Time00139






























.

Exercise 6

Write a function called Time0014 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 Time0014 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).

Exercise 7

The Time0015 module provides Time and Time 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 Time00154



































.

1. Use the Time0015 module to write a program that gets the current date and prints the day of the week.
2. Write a program that takes a birthday as input and prints the user’s age and the number of days, hours, minutes and seconds until their next birthday.
3. For two people born on different days, there is a day when one is twice as old as the other. That’s their Double Day. Write a program that takes two birthdays and computes their Double Day.
4. For a little more challenge, write the more general version that computes the day when one person is n times older than the other.

1. 使用 Time0016 模块写一个程序，获取当前日期并打印星期几。
2. 写一个程序，输入一个生日，打印用户的年龄，以及距离下一个生日还有多少天、小时、分钟和秒。
3. 对于两个不同日子出生的人，存在一天，其中一人的年龄恰好是另一人的两倍。那就是他们的「双日」（Double Day）。写一个程序，输入两个生日，算出他们的双日。
4. 再多一点挑战：写出更通用的版本，算出其中一人年龄是另一人 n 倍的那一天。