Chapter 18  Inheritance 第 18 章 继承

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

In this chapter I present classes to represent playing cards, decks of cards, and poker hands. If you don't play poker, you can read about it at http://en.wikipedia.org/wiki/Poker, but you don't have to; I'll tell you what you need to know for the exercises. Code examples from this chapter are available from http://thinkpython.com/code/Card.py.

If you are not familiar with Anglo-American playing cards, you can read about them at http://en.wikipedia.org/wiki/Playing_cards.

18.1 Card objects 18.1 卡片对象

There are fifty-two cards in a deck, each of which belongs to one of four suits and one of thirteen ranks. The suits are Spades, Hearts, Diamonds, and Clubs (in descending order in bridge). The ranks are Ace, 2, 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen, and King. Depending on the game that you are playing, an Ace may be higher than King or lower than 2.

If we want to define a new object to represent a playing card, it is obvious what the attributes should be: rank and rank. It is not as obvious what type the attributes should be. One possibility is to use strings containing words like rank000 for suits and rank000 for ranks. One problem with this implementation is that it would not be easy to compare cards to see which had a higher rank or suit.

An alternative is to use integers to encode the ranks and suits. In this context, "encode" means that we are going to define a mapping between numbers and suits, or between numbers and ranks. This kind of encoding is not meant to be a secret (that would be "encryption").

For example, this table shows the suits and the corresponding integer codes:

This code makes it easy to compare cards; because higher suits map to higher numbers, we can compare suits by comparing their codes.

The mapping for ranks is fairly obvious; each of the numerical ranks maps to the corresponding integer, and for face cards:

I am using the ↦ symbol to make it clear that these mappings are not part of the Python program. They are part of the program design, but they don't appear explicitly in the code.

The class definition for rank looks like this:

As usual, the init method takes an optional parameter for each attribute. The default card is the 2 of Clubs.

To create a Card, you call rank with the suit and rank of the card you want.

18.2 Class attributes 18.2 类属性

In order to print Card objects in a way that people can easily read, we need a mapping from the integer codes to the corresponding ranks and suits. A natural way to do that is with lists of strings. We assign these lists to class attributes:

Variables like rank00026 and rank00027, which are defined inside a class but outside of any method, are called class attributes because they are associated with the class object rank.

This term distinguishes them from variables like rank and rank, which are called instance attributes because they are associated with a particular instance.

Both kinds of attribute are accessed using dot notation. For example, in rank000, rank is a Card object, and rank00038 is its rank. Similarly, rank is a class object, and rank00040




is a list of strings associated with the class.

Every card has its own rank and rank, but there is only one copy of rank00049 and rank00050.

Putting it all together, the expression rank00055















means "use the attribute rank from the object rank as an index into the list rank00058 from the class rank, and select the appropriate string."

The first element of rank00065 is rank because there is no card with rank zero. By including rank as a place-keeper, we get a mapping with the nice property that the index 2 maps to the string '2', and so on. To avoid this tweak, we could have used a dictionary instead of a list.

With the methods we have so far, we can create and print cards:

Figure 18.1: Object diagram.

Figure 18.1 is a diagram of the rank class object and one Card instance. rank is a class object, so it has type rank. rank0 has type rank. (To save space, I didn't draw the contents of rank00079 and rank00080).

18.3 Comparing cards 18.3 比较牌

For built-in types, there are relational operators (rank, rank, ==, etc.) that compare values and determine when one is greater than, less than, or equal to another. For user-defined types, we can override the behavior of the built-in operators by providing a method named rank000.

rank000 takes two parameters, rank and rank0, and returns a positive number if the first object is greater, a negative number if the second object is greater, and 0 if they are equal to each other.

The correct ordering for cards is not obvious. For example, which is better, the 3 of Clubs or the 2 of Diamonds? One has a higher rank, but the other has a higher suit. In order to compare cards, you have to decide whether rank or suit is more important.

The answer might depend on what game you are playing, but to keep things simple, we'll make the arbitrary choice that suit is more important, so all of the Spades outrank all of the Diamonds, and so on.

With that decided, we can write rank001:

You can write this more concisely using tuple comparison:

The built-in function '2' has the same interface as the method rank001: it takes two values and returns a positive number if the first is larger, a negative number if the second is larger, and 0 if they are equal.

In Python 3, '2' no longer exists, and the rank001 method is not supported. Instead you should provide rank00, which returns rank if rank is less than rank0. You can implement rank00 using tuples and the rank operator.

Exercise 1

Write a rank001 method for Time objects. Hint: you can use tuple comparison, but you also might consider using integer subtraction.

18.4 Decks 18.4 牌组

Now that we have Cards, the next step is to define Decks. Since a deck is made up of cards, it is natural for each Deck to contain a list of cards as an attribute.

The following is a class definition for rank. The init method creates the attribute rank0 and generates the standard set of fifty-two cards:

The easiest way to populate the deck is with a nested loop. The outer loop enumerates the suits from 0 to 3. The inner loop enumerates the ranks from 1 to 13. Each iteration creates a new Card with the current suit and rank, and appends it to rank00134.

18.5 Printing the deck 18.5 打印牌组

Here is a rank001 method for rank:

This method demonstrates an efficient way to accumulate a large string: building a list of strings and then using rank. The built-in function '2' invokes the rank001 method on each card and returns the string representation.

Since we invoke rank on a newline character, the cards are separated by newlines. Here's what the result looks like:

Even though the result appears on 52 lines, it is one long string that contains newlines.

18.6 Add, remove, shuffle and sort 18.6 加牌、删牌、洗牌与排序

To deal cards, we would like a method that removes a card from the deck and returns it. The list method '2' provides a convenient way to do that:

Since '2' removes the last card in the list, we are dealing from the bottom of the deck. In real life "bottom dealing" is frowned upon, but in this context it's ok.

To add a card, we can use the list method rank00:

A method like this that uses another function without doing much real work is sometimes called a veneer. The metaphor comes from woodworking, where it is common to glue a thin layer of good quality wood to the surface of a cheaper piece of wood.

In this case we are defining a "thin" method that expresses a list operation in terms that are appropriate for decks.

As another example, we can write a Deck method named rank001 using the function rank001 from the rank00 module:

Don't forget to import rank00.

Exercise 2

Write a Deck method named rank that uses the list method rank to sort the cards in a rank. rank uses the rank001 method we defined to determine sort order.

18.7 Inheritance 18.7 继承

The language feature most often associated with object-oriented programming is inheritance. Inheritance is the ability to define a new class that is a modified version of an existing class.

It is called "inheritance" because the new class inherits the methods of the existing class. Extending this metaphor, the existing class is called the parent and the new class is called the child.

As an example, let's say we want a class to represent a "hand," that is, the set of cards held by one player. A hand is similar to a deck: both are made up of a set of cards, and both require operations like adding and removing cards.

A hand is also different from a deck; there are operations we want for hands that don't make sense for a deck. For example, in poker we might compare two hands to see which one wins. In bridge, we might compute a score for a hand in order to make a bid.

This relationship between classes—similar, but different—lends itself to inheritance.

The definition of a child class is like other class definitions, but the name of the parent class appears in parentheses:

This definition indicates that rank inherits from rank; that means we can use methods like rank0018 and rank0018 for Hands as well as Decks.

rank also inherits rank0018 from rank, but it doesn't really do what we want: instead of populating the hand with 52 new cards, the init method for Hands should initialize rank0 with an empty list.

If we provide an init method in the rank class, it overrides the one in the rank class:

So when you create a Hand, Python invokes this init method:

But the other methods are inherited from rank, so we can use rank0020 and rank0020 to deal a card:

A natural next step is to encapsulate this code in a method called rank00207:

rank00210 takes two arguments, a Hand object and the number of cards to deal. It modifies both rank and rank, and returns rank.

In some games, cards are moved from one hand to another, or from a hand back to the deck. You can use rank00218 for any of these operations: rank can be either a Deck or a Hand, and rank, despite the name, can also be a rank.

Exercise 3

Write a Deck method called rank00226 that takes two parameters, the number of hands and the number of cards per hand, and that creates new Hand objects, deals the appropriate number of cards per hand, and returns a list of Hand objects.

Inheritance is a useful feature. Some programs that would be repetitive without inheritance can be written more elegantly with it. Inheritance can facilitate code reuse, since you can customize the behavior of parent classes without having to modify them. In some cases, the inheritance structure reflects the natural structure of the problem, which makes the program easier to understand.

On the other hand, inheritance can make programs difficult to read. When a method is invoked, it is sometimes not clear where to find its definition. The relevant code may be scattered among several modules. Also, many of the things that can be done using inheritance can be done as well or better without it.

18.8 Class diagrams 18.8 类图

So far we have seen stack diagrams, which show the state of a program, and object diagrams, which show the attributes of an object and their values. These diagrams represent a snapshot in the execution of a program, so they change as the program runs.

They are also highly detailed; for some purposes, too detailed. A class diagram is a more abstract representation of the structure of a program. Instead of showing individual objects, it shows classes and the relationships between them.

There are several kinds of relationship between classes:

• Objects in one class might contain references to objects in another class. For example, each Rectangle contains a reference to a Point, and each Deck contains references to many Cards. This kind of relationship is called HAS-A, as in, "a Rectangle has a Point."
• One class might inherit from another. This relationship is called IS-A, as in, "a Hand is a kind of a Deck."
• One class might depend on another in the sense that changes in one class would require changes in the other.

• 一个类里的对象可能持有对另一个类里对象的引用。例如，每个 Rectangle 都持有一个对 Point 的引用，每个 Deck 都持有对许多 Card 的引用。这种关系叫做「有一个」关系（HAS-A），即「一个 Rectangle 有一个 Point」。
• 一个类可能继承自另一个类。这种关系叫做「是一个」关系（IS-A），即「一手牌是一种牌组」。
• 一个类可能依赖（dependency）另一个类，意思是其中一个类的改动会要求改动另一个类。

A class diagram is a graphical representation of these relationships. For example, Figure 18.2 shows the relationships between rank, rank and rank.

Figure 18.2: Class diagram.

The arrow with a hollow triangle head represents an IS-A relationship; in this case it indicates that Hand inherits from Deck.

The standard arrow head represents a HAS-A relationship; in this case a Deck has references to Card objects.

The star (*) near the arrow head is a multiplicity; it indicates how many Cards a Deck has. A multiplicity can be a simple number, like ==, a range, like rank or a star, which indicates that a Deck can have any number of Cards.

A more detailed diagram might show that a Deck actually contains a list of Cards, but built-in types like list and dict are usually not included in class diagrams.

Exercise 4

Read rank00240



, rank0024 and rank00 and draw a class diagram that shows the relationships among the classes defined there.

18.9 Debugging 18.9 调试

Inheritance can make debugging a challenge because when you invoke a method on an object, you might not know which method will be invoked.

Suppose you are writing a function that works with Hand objects. You would like it to work with all kinds of Hands, like PokerHands, BridgeHands, etc. If you invoke a method like rank002, you might get the one defined in rank, but if any of the subclasses override this method, you'll get that version instead.

Any time you are unsure about the flow of execution through your program, the simplest solution is to add print statements at the beginning of the relevant methods. If rank00250

prints a message that says something like rank00251









, then as the program runs it traces the flow of execution.

As an alternative, you could use this function, which takes an object and a method name (as a string) and returns the class that provides the definition of the method:

Here's an example:

So the rank002 method for this Hand is the one in rank.

rank00260








uses the '2' method to get the list of class objects (types) that will be searched for methods. "MRO" stands for "method resolution order."

Here's a program design suggestion: whenever you override a method, the interface of the new method should be the same as the old. It should take the same parameters, return the same type, and obey the same preconditions and postconditions. If you obey this rule, you will find that any function designed to work with an instance of a superclass, like a Deck, will also work with instances of subclasses like a Hand or PokerHand.

If you violate this rule, your code will collapse like (sorry) a house of cards.

18.10 Data encapsulation 18.10 数据封装

Chapter 16 demonstrates a development plan we might call "object-oriented design." We identified objects we needed—rank, rank0 and rank00266—and defined classes to represent them. In each case there is an obvious correspondence between the object and some entity in the real world (or at least a mathematical world).

But sometimes it is less obvious what objects you need and how they should interact. In that case you need a different development plan. In the same way that we discovered function interfaces by encapsulation and generalization, we can discover class interfaces by data encapsulation.

Markov analysis, from Section 13.8, provides a good example. If you download my code from rank00270


























, you'll see that it uses two global variables—rank00271 and rank00—that are read and written from several functions.

Because these variables are global we can only run one analysis at a time. If we read two texts, their prefixes and suffixes would be added to the same data structures (which makes for some interesting generated text).

To run multiple analyses, and keep them separate, we can encapsulate the state of each analysis in an object. Here's what that looks like:

Next, we transform the functions into methods. For example, here's rank00278

:

Transforming a program like this—changing the design without changing the function—is another example of refactoring (see Section 4.7).

This example suggests a development plan for designing objects and methods:

1. Start by writing functions that read and write global variables (when necessary).
2. Once you get the program working, look for associations between global variables and the functions that use them.
3. Encapsulate related variables as attributes of an object.
4. Transform the associated functions into methods of the new class.

1. 先写一些读写全局变量的函数（必要时）。
2. 等程序跑通后，寻找全局变量和用到它们的函数之间的关联。
3. 把相关的变量封装为对象的属性。
4. 把相关的函数改造成新类的方法。

Exercise 5

Download my code from Section 13.8 (rank00281


























), and follow the steps described above to encapsulate the global variables as attributes of a new class called rank00. Solution: rank00283


























(note the capital M).

18.11 Glossary 18.11 术语表

encode:

To represent one set of values using another set of values by constructing a mapping between them.

class attribute:

An attribute associated with a class object. Class attributes are defined inside a class definition but outside any method.

instance attribute:

An attribute associated with an instance of a class.

veneer:

A method or function that provides a different interface to another function without doing much computation.

inheritance:

The ability to define a new class that is a modified version of a previously defined class.

parent class:

The class from which a child class inherits.

child class:

A new class created by inheriting from an existing class; also called a "subclass."

IS-A relationship:

The relationship between a child class and its parent class.

HAS-A relationship:

The relationship between two classes where instances of one class contain references to instances of the other.

class diagram:

A diagram that shows the classes in a program and the relationships between them.

multiplicity:

A notation in a class diagram that shows, for a HAS-A relationship, how many references there are to instances of another class.

encode 编码：

通过构造两套值之间的映射，用一组值来表示另一组值。

class attribute 类属性：

与类对象关联的属性。类属性定义在类定义内部、但任何方法之外。

instance attribute 实例属性：

与类的某个实例关联的属性。

veneer 薄封装（转接层）：

为另一个函数提供不同接口、而本身不做什么计算的方法或函数。

inheritance 继承：

能够定义一个新类，它是先前某类的一个修改版。

parent class 父类：

子类所继承的那个类。

child class 子类：

通过继承已有类而创建的新类；也叫「subclass」。

IS-A relationship 「是一个」关系：

子类与其父类之间的关系。

HAS-A relationship 「有一个」关系：

两个类之间的关系，其中一个类的实例持有对另一个类实例的引用。

class diagram 类图：

展示程序中各个类以及它们之间关系的图。

multiplicity 多重性：

类图中的一种记号，用于「有一个」关系，表示对另一个类的实例有多少个引用。

18.12 Exercises 18.12 习题

Exercise 6

The following are the possible hands in poker, in increasing order of value (and decreasing order of probability):

pair:

two cards with the same rank

two pair:

two pairs of cards with the same rank

three of a kind:

three cards with the same rank

straight:

five cards with ranks in sequence (aces can be high or low, so rank00287
is a straight and so is rank00288











, but rank00289







is not.)

flush:

five cards with the same suit

full house:

three cards with one rank, two cards with another

four of a kind:

four cards with the same rank

straight flush:

five cards in sequence (as defined above) and with the same suit

pair 一对：

两张点数相同的牌

two pair 两对：

两组点数相同的对子

three of a kind 三条：

三张点数相同的牌

straight 顺子：

五张点数连续的牌（A 可大可小，所以 Ace-2-3-4-5 是顺子，10-Jack-Queen-King-Ace 也是，但 Queen-King-Ace-2-3 不是）

flush 同花：

五张花色相同的牌

full house 葫芦：

三张同点、两张另点

four of a kind 四条：

四张点数相同的牌

straight flush 同花顺：

五张点数连续且花色相同的牌

The goal of these exercises is to estimate the probability of drawing these various hands.

1. Download the following files from rank00290
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   :

   rank002

   : A complete version of the rank, rank and rank classes in this chapter.

   rank00295
   
   

   : An incomplete implementation of a class that represents a poker hand, and some code that tests it.

2. If you run rank00296
   
   , it deals seven 7-card poker hands and checks to see if any of them contains a flush. Read this code carefully before you go on.
3. Add methods to rank00297
   
   named rank0029, rank00299
   , etc. that return True or False according to whether or not the hand meets the relevant criteria. Your code should work correctly for "hands" that contain any number of cards (although 5 and 7 are the most common sizes).
4. Write a method named rank0030 that figures out the highest-value classification for a hand and sets the rank0 attribute accordingly. For example, a 7-card hand might contain a flush and a pair; it should be labeled "flush".
5. When you are convinced that your classification methods are working, the next step is to estimate the probabilities of the various hands. Write a function in rank00302
   
   that shuffles a deck of cards, divides it into hands, classifies the hands, and counts the number of times various classifications appear.
6. Print a table of the classifications and their probabilities. Run your program with larger and larger numbers of hands until the output values converge to a reasonable degree of accuracy. Compare your results to the values at rank00303
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   .

1. 从 rank00304
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   下载以下文件：

   rank003

   ：本章 rank、rank、rank 三个类的完整版本。

   rank00309
   
   

   ：一个表示扑克牌型的不完整类实现，以及一段测试它的代码。

2. 运行 rank00310
   
   ，它会发七手 7 张的扑克牌，并检查其中是否有同花。继续之前请仔细阅读这段代码。
3. 给 rank00311
   
   添加名为 rank0031、rank00313
   等方法，根据手牌是否符合相应条件返回 True 或 False。你的代码应能对包含任意张数的「手牌」正确工作（尽管 5 张和 7 张最常见）。
4. 写一个名为 rank0031 的方法，找出一手牌价值最高的牌型，并相应地设置 rank0 属性。例如，一手 7 张牌可能同时有同花和一对，此时应标记为「flush」。
5. 当你确信分类方法已经正确后，下一步是估计各种牌型的概率。在 rank00316
   
   里写一个函数：洗一副牌、把它分成若干手、对每手分类，并统计各种牌型出现的次数。
6. 打印一张表格，列出各牌型及其概率。用越来越大的手牌数量运行程序，直到输出值收敛到合理精度。把你得到的结果与 rank00317
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   上的数值做对比。

Solution: rank00318

































.

Exercise 7

This exercise uses TurtleWorld from Chapter 4. You will write code that makes Turtles play tag. If you are not familiar with the rules of tag, see rank00320




























.

1. Download rank00322
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   and run it. You should see a TurtleWorld with three Turtles. If you press the Run button, the Turtles wander at random.
2. Read the code and make sure you understand how it works. The rank003 class inherits from rank00, which means that the rank00 methods ==, ==, == and == work on Wobblers. The rank method gets invoked by TurtleWorld. It invokes rank0, which turns the Turtle in the desired direction, rank00, which makes a random turn in proportion to the Turtle's clumsiness, and rank, which moves forward a few pixels, depending on the Turtle's speed.
3. Create a file named rank00334. Import everything from rank003, then define a class named rank00 that inherits from rank003. Call rank00338 passing the rank00 class object as an argument.
4. Add a rank0 method to rank00 to override the one in rank003. As a starting place, write a version that always points the Turtle toward the origin. Hint: use the math function rank0 and the Turtle attributes *, * and rank003.
5. Modify rank0 so that the Turtles stay in bounds. For debugging, you might want to use the Step button, which invokes rank once on each Turtle.
6. Modify rank0 so that each Turtle points toward its nearest neighbor. Hint: Turtles have an attribute, rank0, that is a reference to the TurtleWorld they live in, and the TurtleWorld has an attribute, rank003, that is a list of all Turtles in the world.
7. Modify rank0 so the Turtles play tag. You can add methods to rank00 and you can override rank0 and rank0035, but you may not modify or override rank, rank00 or rank. Also, rank0 is allowed to change the heading of the Turtle but not the position. Adjust the rules and your rank0 method for good quality play; for example, it should be possible for the slow Turtle to tag the faster Turtles eventually.

1. 下载 rank00361
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   并运行。你会看到一个有三个 Turtle 的 TurtleWorld。按下 Run 按钮，Turtle 会随机游走。
2. 阅读代码，确保你理解它的工作原理。rank003 类继承自 rank00，这意味着 rank00 的 ==、==、==、== 方法在 Wobbler 上同样可用。 rank 方法由 TurtleWorld 调用。它会调用 rank0（让 Turtle 转向期望方向）、rank00（根据 Turtle 的笨拙程度做一个随机转向），以及 rank（根据 Turtle 的速度前进几个像素）。
3. 创建一个名为 rank00373 的文件。从 rank003 导入所有内容，然后定义一个继承自 rank003 的类 rank00。调用 rank00377，把 rank00 类对象作为参数传入。
4. 给 rank00 添加一个 rank0 方法，覆盖 rank003 里的那个。作为起点，先写一个总是让 Turtle 朝向原点的版本。提示：用数学函数 rank0 以及 Turtle 的属性 *、* 和 rank003。
5. 修改 rank0，让 Turtle 保持在边界内。调试时你可以用 Step 按钮，它会让每个 Turtle 调用一次 rank。
6. 修改 rank0，让每个 Turtle 朝向离它最近的邻居。提示：Turtle 有一个属性 rank0，指向它所在的 TurtleWorld；而 TurtleWorld 有一个属性 rank003，是世界里所有 Turtle 的列表。
7. 修改 rank0，让 Turtle 玩抓人游戏。你可以给 rank00 添加方法，也可以重写 rank0 和 rank0039，但不得修改或重写 rank、rank00 或 rank。此外，rank0 可以改 Turtle 的朝向，但不能改它的位置。 调整规则和你的 rank0 方法，让游戏玩起来有质量；例如，慢的 Turtle 最终应当能抓到快的 Turtle。

Solution: rank00400


























.