Chapter 17  Classes and methods 第 17 章 类与方法

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

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

17.1 Object-oriented features 17.1 面向对象的特性

Python is an object-oriented programming language, which means that it provides features that support object-oriented programming. It is not easy to define object-oriented programming, but we have already seen some of its characteristics:

• Programs are made up of object definitions and function definitions, and most of the computation is expressed in terms of operations on objects.
• Each object definition corresponds to some object or concept in the real world, and the functions that operate on that object correspond to the ways real-world objects interact.

• 程序由对象定义和函数定义组成，大部分计算都表达为对对象的操作。
• 每个对象定义都对应现实世界中的某个对象或概念，而作用于该对象的函数，对应现实对象之间交互的方式。

For example, the Time class defined in Chapter 16 corresponds to the way people record the time of day, and the functions we defined correspond to the kinds of things people do with times. Similarly, the Time0 and Time00008 classes correspond to the mathematical concepts of a point and a rectangle.

So far, we have not taken advantage of the features Python provides to support object-oriented programming. These features are not strictly necessary; most of them provide alternative syntax for things we have already done. But in many cases, the alternative is more concise and more accurately conveys the structure of the program.

For example, in the Time program, there is no obvious connection between the class definition and the function definitions that follow. With some examination, it is apparent that every function takes at least one Time object as an argument.

This observation is the motivation for methods; a method is a function that is associated with a particular class. We have seen methods for strings, lists, dictionaries and tuples. In this chapter, we will define methods for user-defined types.

Methods are semantically the same as functions, but there are two syntactic differences:

• Methods are defined inside a class definition in order to make the relationship between the class and the method explicit.
• The syntax for invoking a method is different from the syntax for calling a function.

• 方法定义在类定义的内部，以明确类与方法之间的关系。
• 调用方法的语法，与调用函数的语法不同。

In the next few sections, we will take the functions from the previous two chapters and transform them into methods. This transformation is purely mechanical; you can do it simply by following a sequence of steps. If you are comfortable converting from one form to another, you will be able to choose the best form for whatever you are doing.

17.2 Printing objects 17.2 打印对象

In Chapter 16, we defined a class named Time and in Exercise 1, you wrote a function named Time00017:

To call this function, you have to pass a Time object as an argument:

To make Time00024 a method, all we have to do is move the function definition inside the class definition. Notice the change in indentation.

Now there are two ways to call Time00027. The first (and less common) way is to use function syntax:

In this use of dot notation, Time is the name of the class, and Time00031 is the name of the method. Time0 is passed as a parameter.

The second (and more concise) way is to use method syntax:

In this use of dot notation, Time00037 is the name of the method (again), and Time0 is the object the method is invoked on, which is called the subject. Just as the subject of a sentence is what the sentence is about, the subject of a method invocation is what the method is about.

Inside the method, the subject is assigned to the first parameter, so in this case Time0 is assigned to Time.

By convention, the first parameter of a method is called Time, so it would be more common to write Time00046 like this:

The reason for this convention is an implicit metaphor:

• The syntax for a function call, Time00050
  
  
  
  
  
  
  , suggests that the function is the active agent. It says something like, “Hey Time00051! Here's an object for you to print.”
• In object-oriented programming, the objects are the active agents. A method invocation like Time00052
  
  
  
  
  
  
  
  says “Hey Time0! Please print yourself.”

• 函数调用的语法 Time00054
  
  
  
  
  
  
  ，暗示函数是主动方。它像是说：“喂 Time00055！这有个对象交给你打印。”
• 在面向对象编程里，对象才是主动方。像 Time00056
  
  
  
  
  
  
  
  这样的方法调用，意思是“喂 Time0！请你打印自己。”

This change in perspective might be more polite, but it is not obvious that it is useful. In the examples we have seen so far, it may not be. But sometimes shifting responsibility from the functions onto the objects makes it possible to write more versatile functions, and makes it easier to maintain and reuse code.

Exercise 1

Rewrite Time00058
(from Section 16.4) as a method. It is probably not appropriate to rewrite Time00059
as a method; what object you would invoke it on?

17.3 Another example 17.3 另一个例子

Here's a version of Time00062 (from Section 16.3) rewritten as a method:

This version assumes that Time00065
is written as a method, as in Exercise 1. Also, note that it is a pure function, not a modifier.

Here's how you would invoke Time00067:

The subject, Time0, gets assigned to the first parameter, Time. The argument, Time, gets assigned to the second parameter, Time000.

This mechanism can be confusing, especially if you make an error. For example, if you invoke Time00078 with two arguments, you get:

The error message is initially confusing, because there are only two arguments in parentheses. But the subject is also considered an argument, so all together that's three.

17.4 A more complicated example 17.4 一个更复杂的例子

Time0008 (from Exercise 2) is slightly more complicated because it takes two Time objects as parameters. In this case it is conventional to name the first parameter Time and the second parameter Time0:

To use this method, you have to invoke it on one object and pass the other as an argument:

One nice thing about this syntax is that it almost reads like English: “end is after start?”

17.5 The init method 17.5 Time0008 方法

The init method (short for “initialization”) is a special method that gets invoked when an object is instantiated. Its full name is Time0009 (two underscore characters, followed by Time, and then two more underscores). An init method for the Time class might look like this:

It is common for the parameters of Time0009 to have the same names as the attributes. The statement

stores the value of the parameter Time as an attribute of Time.

The parameters are optional, so if you call Time with no arguments, you get the default values.

If you provide one argument, it overrides Time:

If you provide two arguments, they override Time and Time00.

And if you provide three arguments, they override all three default values.

Exercise 2

Write an init method for the Time0 class that takes x and x as optional parameters and assigns them to the corresponding attributes.

17.6 The Time001 method 17.6 Time001 方法

Time001 is a special method, like Time0012, that is supposed to return a string representation of an object.

For example, here is a x00 method for Time objects:

When you Time0 an object, Python invokes the x00 method:

When I write a new class, I almost always start by writing Time0013, which makes it easier to instantiate objects, and Time001, which is useful for debugging.

Exercise 3

Write a x00 method for the Time0 class. Create a Point object and print it.

17.7 Operator overloading 17.7 运算符重载

By defining other special methods, you can specify the behavior of operators on user-defined types. For example, if you define a method named Time001 for the Time class, you can use the x operator on Time objects.

Here is what the definition might look like:

And here is how you could use it:

When you apply the x operator to Time objects, Python invokes Time001. When you print the result, Python invokes Time001. So there is quite a lot happening behind the scenes!

Changing the behavior of an operator so that it works with user-defined types is called operator overloading. For every operator in Python there is a corresponding special method, like Time001. For more details, see Time00158



















































.

Exercise 4

Write an x00 method for the Point class.

17.8 Type-based dispatch 17.8 按类型分派

In the previous section we added two Time objects, but you also might want to add an integer to a Time object. The following is a version of Time001 that checks the type of Time0 and invokes either Time0016 or Time00166:

The built-in function Time00172 takes a value and a class object, and returns Time if the value is an instance of the class.

If Time0 is a Time object, Time001 invokes Time0017. Otherwise it assumes that the parameter is a number and invokes Time00179. This operation is called a type-based dispatch because it dispatches the computation to different methods based on the type of the arguments.

Here are examples that use the x operator with different types:

Unfortunately, this implementation of addition is not commutative. If the integer is the first operand, you get

The problem is, instead of asking the Time object to add an integer, Python is asking an integer to add a Time object, and it doesn't know how to do that. But there is a clever solution for this problem: the special method Time0018, which stands for “right-side add.” This method is invoked when a Time object appears on the right side of the x operator. Here's the definition:

And here's how it's used:

Exercise 5

Write an x00 method for Points that works with either a Point object or a tuple:

• If the second operand is a Point, the method should return a new Point whose x coordinate is the sum of the x coordinates of the operands, and likewise for the y coordinates.
• If the second operand is a tuple, the method should add the first element of the tuple to the x coordinate and the second element to the y coordinate, and return a new Point with the result.

• 如果第二个操作数是 Point，方法应返回一个新 Point，其 x 坐标等于两个操作数 x 坐标之和，y 坐标同理。
• 如果第二个操作数是元组，方法应把元组第一个元素加到 x 坐标、第二个元素加到 y 坐标，并返回结果构成的新 Point。

17.9 Polymorphism 17.9 多态

Type-based dispatch is useful when it is necessary, but (fortunately) it is not always necessary. Often you can avoid it by writing functions that work correctly for arguments with different types.

Many of the functions we wrote for strings will actually work for any kind of sequence. For example, in Section 11.1 we used Time00196 to count the number of times each letter appears in a word.

This function also works for lists, tuples, and even dictionaries, as long as the elements of x are hashable, so they can be used as keys in x.

Functions that can work with several types are called polymorphic. Polymorphism can facilitate code reuse. For example, the built-in function x00, which adds the elements of a sequence, works as long as the elements of the sequence support addition.

Since Time objects provide an x00 method, they work with x00:

In general, if all of the operations inside a function work with a given type, then the function works with that type.

The best kind of polymorphism is the unintentional kind, where you discover that a function you already wrote can be applied to a type you never planned for.

17.10 Debugging 17.10 调试

It is legal to add attributes to objects at any point in the execution of a program, but if you are a stickler for type theory, it is a dubious practice to have objects of the same type with different attribute sets. It is usually a good idea to initialize all of an object's attributes in the init method.

If you are not sure whether an object has a particular attribute, you can use the built-in function Time002 (see Section 15.7).

Another way to access the attributes of an object is through the special attribute Time0021, which is a dictionary that maps attribute names (as strings) and values:

For purposes of debugging, you might find it useful to keep this function handy:

Time00217





traverses the items in the object's dictionary and prints each attribute name and its corresponding value.

The built-in function Time002 takes an object and an attribute name (as a string) and returns the attribute's value.

17.11 Interface and implementation 17.11 接口与实现

One of the goals of object-oriented design is to make software more maintainable, which means that you can keep the program working when other parts of the system change, and modify the program to meet new requirements.

A design principle that helps achieve that goal is to keep interfaces separate from implementations. For objects, that means that the methods a class provides should not depend on how the attributes are represented.

For example, in this chapter we developed a class that represents a time of day. Methods provided by this class include Time00221
, Time0022, and Time0022.

We could implement those methods in several ways. The details of the implementation depend on how we represent time. In this chapter, the attributes of a Time object are Time, Time00, and Time00.

As an alternative, we could replace these attributes with a single integer representing the number of seconds since midnight. This implementation would make some methods, like Time0023, easier to write, but it makes some methods harder.

After you deploy a new class, you might discover a better implementation. If other parts of the program are using your class, it might be time-consuming and error-prone to change the interface.

But if you designed the interface carefully, you can change the implementation without changing the interface, which means that other parts of the program don't have to change.

Keeping the interface separate from the implementation means that you have to hide the attributes. Code in other parts of the program (outside the class definition) should use methods to read and modify the state of the object. They should not access the attributes directly. This principle is called information hiding; see Time00237




































.

Exercise 6

Download the code from this chapter (Time00239

























). Change the attributes of Time to be a single integer representing seconds since midnight. Then modify the methods (and the function Time00241
) to work with the new implementation. You should not have to modify the test code in Time. When you are done, the output should be the same as before. Solution: Time00243

17.12 Glossary 17.12 术语表

object-oriented language:

A language that provides features, such as user-defined classes and method syntax, that facilitate object-oriented programming.

object-oriented programming:

A style of programming in which data and the operations that manipulate it are organized into classes and methods.

method:

A function that is defined inside a class definition and is invoked on instances of that class.

subject:

The object a method is invoked on.

operator overloading:

Changing the behavior of an operator like x so it works with a user-defined type.

type-based dispatch:

A programming pattern that checks the type of an operand and invokes different functions for different types.

polymorphic:

Pertaining to a function that can work with more than one type.

information hiding:

The principle that the interface provided by an object should not depend on its implementation, in particular the representation of its attributes.

面向对象语言（object-oriented language）：

提供某些特性（如用户自定义类和方法语法）来支撑面向对象编程的语言。

面向对象编程（object-oriented programming）：

一种编程风格，把数据以及操作数据的动作组织成类和方法。

方法（method）：

定义在类定义内部、并在该类实例上被调用的函数。

主语（subject）：

方法被调用时所作用的那个对象。

运算符重载（operator overloading）：

改变像 x 这样的运算符的行为，让它适用于用户自定义类型。

按类型分派（type-based dispatch）：

一种编程模式：检查操作数的类型，对不同类型的操作数调用不同的函数。

多态的（polymorphic）：

形容一个能适用于多种类型的函数。

信息隐藏（information hiding）：

一个原则：对象所提供的接口不应依赖于它的实现，尤其是属性的表示方式。

17.13 Exercises 17.13 习题

Exercise 7

This exercise is a cautionary tale about one of the most common, and difficult to find, errors in Python. Write a definition for a class named Time0025 with the following methods:

1. An Time0025 method that initializes an attribute named Time00254
   
   
   
   to an empty list.
2. A method named Time00255
   
   that takes an object of any type and adds it to Time00256
   
   
   
   .
3. A Time002 method that returns a string representation of the Kangaroo object and the contents of the pouch.

1. 一个 Time0025 方法，把名为 Time00259
   
   
   
   的属性初始化为空列表。
2. 一个名为 Time00260
   
   的方法，接受一个任意类型的对象，把它加进 Time00261
   
   
   
   。
3. 一个 Time002 方法，返回 Kangaroo 对象及其育儿袋内容的字符串表示。

Test your code by creating two Time0026 objects, assigning them to variables named Time0 and x00, and then adding x00 to the contents of Time0's pouch.

Download Time00273































. It contains a solution to the previous problem with one big, nasty bug. Find and fix the bug.

If you get stuck, you can download Time00275
































, which explains the problem and demonstrates a solution.

Exercise 8

Visual is a Python module that provides 3-D graphics. It is not always included in a Python installation, so you might have to install it from your software repository or, if it's not there, from Time00277







.

The following example creates a 3-D space that is 256 units wide, long and high, and sets the “center” to be the point (128,128,128). Then it draws a blue sphere.

Time0 is an RGB tuple; that is, the elements are Red-Green-Blue levels between 0.0 and 1.0 (see Time00281

































).

If you run this code, you should see a window with a black background and a blue sphere. If you drag the middle button up and down, you can zoom in and out. You can also rotate the scene by dragging the right button, but with only one sphere in the world, it is hard to tell the difference.

The following loop creates a cube of spheres:

1. Put this code in a script and make sure it works for you.
2. Modify the program so that each sphere in the cube has the color that corresponds to its position in RGB space. Notice that the coordinates are in the range 0–255, but the RGB tuples are in the range 0.0–1.0.
3. Download Time00285
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   and use the function Time00286
   to generate a list of the available colors on your system, their names and RGB values. For each named color draw a sphere in the position that corresponds to its RGB values.

1. 把这段代码放进一个脚本，确保它能在你机器上运行。
2. 修改程序，让立方体里每个球体的颜色对应它在 RGB 空间中的位置。注意坐标是 0–255 的范围，而 RGB 元组是 0.0–1.0 的范围。
3. 下载 Time00287
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   ，用其中的 Time00288
   函数生成你系统上可用颜色（名字与 RGB 值）的列表。为每个具名颜色画一个球体，位置对应它的 RGB 值。

You can see my solution at Time00289































.