Exercise 41 学会讲“面对对象”

单词解释

class(类)：告诉python去创建一个新类型。

object(对象)：有两种意思，事物的基本类型，或者事物的实例化。

instance(实例)：你通过python创建一个类所获得的。

def：用来在类中定义一个函数。

self：在一个类包含的函数中，self是一个用来访问实例或对象的变量。

inheritance：概念，表示一个类可以继承另一个类的特征,就像你和你的父母。

composition：概念，表示一个类可以包含其他类,就像汽车轮子。

attribute：类所拥有的特性，通常是变量。

is-a：惯用语，表示一个东西继承自另一个东西(a),像在“鲑鱼”是“鱼”。

has-a：惯用语，表示由其他事情或有一个特征(a),如“鲑鱼有嘴。”

短语解释

class X(Y)     创建一个叫X的类，并继承Y 
class X(object): def __init__(self, J)    类X有一个__init__方法，该方法有self和J两个参数 
class X(object): def M(self, J)         类X有一个叫M的函数，该函数有self和J两个参数
foo = X()      给foo赋值为类X的一个实例
foo.M(J)       从foo里调用M函数，传递的参数为self和J
foo.K = Q      从foo里调用K属性，并将其设置为Q

无尽模式练习

import random
from urllib import urlopen
import sys

WORD_URL = "http://learncodethehardway.org/words.txt"
WORDS = []

PHRASES = {
    "class %%%(%%%):":
      "Make a class named %%% that is-a %%%.",
    "class %%%(object):\n\tdef __init__(self, ***)" :
      "class %%% has-a __init__ that takes self and *** parameters.",
    "class %%%(object):\n\tdef ***(self, @@@)":
      "class %%% has-a function named *** that takes self and @@@ parameters.",
    "*** = %%%()":
      "Set *** to an instance of class %%%.",
    "***.***(@@@)":
      "From *** get the *** function, and call it with parameters self, @@@.",
    "***.*** = '***'":
      "From *** get the *** attribute and set it to '***'."
}

#do they want to drill phrases first
PHRASE_FIRST = False 
if len(sys.argv) == 2 and sys.argv[1] == "english":
    PHRASE_FIRST = True
    
#load up the words from the website
for word in urlopen(WORD_URL).readlines():
    WORDS.append(word.strip().decode("utf-8"))
    
    
def convert(snippet, phrase):
    class_names = [w.capitalize() for w in
                   random.sample(WORDS, snippet.count("%%%"))]
    other_names = random.sample(WORDS, snippet.count("***"))
    results = []
    param_names = []
    
    for i in range(0, snippet.count("@@@")):
        param_count = random.randint(1,3)
        param_names.append(', '.join(random.sample(WORDS, param_count)))
        
    for sentence in snippet, phrase:
        result = sentence[:]
        
        # fake class name
        for word in class_names:
            result = result.replace("%%%", word, 1)
        
        # fake other names
        for word in other_names:
            result = result.replace("***", word, 1)
            
        # fake parameter lists
        for word in param_names:
            result = result.replace("@@@", word, 1)
            
        results.append(result)
        
    return results 
    
    
# keep going until they hit CTRL-D 
try:
    while True:
        snippets = PHRASES.keys()
        random.shuffle(snippets)
        
        for snippet in snippets:
            phrase = PHRASES[snippet]
            question, answer = convert(snippet, phrase)
            if PHRASE_FIRST:
                question, answer = answer, question
                
            print question 
            
            raw_input("> ")
            print "ANSWER: %s\n\n" % answer 
except EOFError:
    print "\nBye"    

一开始总是执行错误（python2.7，第29行出错），百度之，发现知乎上有类似的问题
链接在此：https://www.zhihu.com/question/53126295

zhihu.png

这样修改了之后，代码运行正常，结果如下：

output41.png

这个程序的作用就是练习一下刚才的短语解释，随机地分配网页上的单词到类名、函数名、变量名或是参数名。

Exercise 42 is-a，has-a，对象，类

'a Salmon is a kind of fish':三文鱼（类）is-a 鱼（类）
'Mary is a kind of Salmon':玛丽（对象）is-a 三文鱼（类）
has-a : class has-a 在class内定义的变量

## Animal is-a object (yes, sort of confusing) look at the extra credit
class Animal(object):
    pass
    
##  class Dog is-a class Animal 
class Dog(Animal):
    
    def __init__(self, name):
        ## Dog has-a name
        self.name = name
        
##  class Cat is-a class Animal 
class Cat(Animal):

    def __init__(self, name):
        ##Cat has-a name 
        self.name = name
        
##  class person is-a object
class Person(object):

    def __init__(self, name):
        ##class Person has-a name 
        self.name = name
        
        ## Person has-a pet of some kind
        self.pet = None
        
##  class Employee is-a class Person 
class Employee(Person):
    
    def __init__(self, name, salary):
        ## ?? hmm what is this strange magic?
        super(Employee, self).__init__(name)
        ## class Employee has-a salary 
        self.salary = salary 
        
## class Fish is-a object 
class Fish(object):
    pass

## class Salmon is-a class Fish 
class Salmon(Fish):
    pass
    
## class Halibut is-a class Fish 
class Halibut(Fish):
    pass 
    
    
## rover is-a dog  ##?#but, what is Dog("Rover")?? 
rover = Dog("Rover")

## satan is-a cat 
satan = Cat("Satan")

## mary is-a person 
mary = Person("Mary")

## class mary has-a pet 
mary.pet = satan 

##?#why there are parameters after a class??
frank = Employee("Frank", 120000)

## class frank has-a pet 
frank.pet = rover 

## object flipper is an instance of class Fish 
flipper = Fish()

## object crouse is an instance of class Salmon 
crouse = Salmon()

## object harry is an instance of class Halibut 
harry = Halibut()        

Exercise 43 基础的面对对象的分析和设计

使用python进行“面对对象”编程的过程：

1.写出或画出你的问题
2.从1中提炼关键问题并搜索相关资料
3.为2中的问题创建一个有层次结构的类和对象映射
4.编写类和测试代码，并保证他们运行
5.重复并精炼

一个例子：分析一个简单的游戏引擎

1.考虑这个游戏的大致背景和游戏流程，列出它的场景。
2.提取出这个游戏的关键定义，列出它们，对每个关键概念进行扩展。
3.通过思考“哪些是类似于其他东西的”和“哪些单词是其他东西的基础呢？”，把名词列表转换成一个有层次结构的类树；然后，找出这些名词都需要什么行动，再把这些动词加到类树里。
4.有了这个类树和一些功能之后，在编辑器中尝试编写代码。
5.做一个循环，测试和完善代码。

from sys import exit
from random import randint

class Scene(object):

    def enter(self):
        print "This scene is not yet configured. Subclass it and implement enter()."
        exit(1)
#------------------------------------------
class Engine(object):

    def __init__(self, scene_map):
        self.scene_map = scene_map

    def play(self):
        current_scene = self.scene_map.opening_scene()
        last_scene = self.scene_map.next_scene('finished')

        while current_scene != last_scene:
            next_scene_name = current_scene.enter()
            current_scene = self.scene_map.next_scene(next_scene_name)

        # be sure to print out the last scene
        current_scene.enter()  
#-----------------------------------------------------------
class Death(Scene):

    quips = [
        "You died.  You kinda suck at this.",
         "Your mom would be proud...if she were smarter.",
         "Such a luser.",
         "I have a small puppy that's better at this."
    ]

    def enter(self):
        print Death.quips[randint(0, len(self.quips)-1)]
        exit(1)
#-----------------------------------------------------------
class CentralCorridor(Scene):

    def enter(self):
        print "The Gothons of Planet Percal #25 have invaded your ship and destroyed"
        print "your entire crew.  You are the last surviving member and your last"
        print "mission is to get the neutron destruct bomb from the Weapons Armory,"
        print "put it in the bridge, and blow the ship up after getting into an "
        print "escape pod."
        print "\n"
        print "You're running down the central corridor to the Weapons Armory when"
        print "a Gothon jumps out, red scaly skin, dark grimy teeth, and evil clown costume"
        print "flowing around his hate filled body.  He's blocking the door to the"
        print "Armory and about to pull a weapon to blast you."

        action = raw_input("> ")

        if action == "shoot!":
            print "Quick on the draw you yank out your blaster and fire it at the Gothon."
            print "His clown costume is flowing and moving around his body, which throws"
            print "off your aim.  Your laser hits his costume but misses him entirely.  This"
            print "completely ruins his brand new costume his mother bought him, which"
            print "makes him fly into an insane rage and blast you repeatedly in the face until"
            print "you are dead.  Then he eats you."
            return 'death'

        elif action == "dodge!":
            print "Like a world class boxer you dodge, weave, slip and slide right"
            print "as the Gothon's blaster cranks a laser past your head."
            print "In the middle of your artful dodge your foot slips and you"
            print "bang your head on the metal wall and pass out."
            print "You wake up shortly after only to die as the Gothon stomps on"
            print "your head and eats you."
            return 'death'

        elif action == "tell a joke":
            print "Lucky for you they made you learn Gothon insults in the academy."
            print "You tell the one Gothon joke you know:"
            print "Lbhe zbgure vf fb sng, jura fur fvgf nebhaq gur ubhfr, fur fvgf nebhaq gur ubhfr."
            print "The Gothon stops, tries not to laugh, then busts out laughing and can't move."
            print "While he's laughing you run up and shoot him square in the head"
            print "putting him down, then jump through the Weapon Armory door."
            return 'laser_weapon_armory'

        else:
            print "DOES NOT COMPUTE!"
            return 'central_corridor'
#-----------------------------------------------------------------------------
class LaserWeaponArmory(Scene):

    def enter(self):
        print "You do a dive roll into the Weapon Armory, crouch and scan the room"
        print "for more Gothons that might be hiding.  It's dead quiet, too quiet."
        print "You stand up and run to the far side of the room and find the"
        print "neutron bomb in its container.  There's a keypad lock on the box"
        print "and you need the code to get the bomb out.  If you get the code"
        print "wrong 10 times then the lock closes forever and you can't"
        print "get the bomb.  The code is 3 digits."
        code = "%d%d%d" % (randint(1,9), randint(1,9), randint(1,9))
        guess = raw_input("[keypad]> ")
        guesses = 0

        while guess != code and guesses < 10:
            print "BZZZZEDDD!"
            guesses += 1
            guess = raw_input("[keypad]> ")

        if guess == code:
            print "The container clicks open and the seal breaks, letting gas out."
            print "You grab the neutron bomb and run as fast as you can to the"
            print "bridge where you must place it in the right spot."
            return 'the_bridge'
        else:
            print "The lock buzzes one last time and then you hear a sickening"
            print "melting sound as the mechanism is fused together."
            print "You decide to sit there, and finally the Gothons blow up the"
            print "ship from their ship and you die."
            return 'death'
#-------------------------------------------------
class TheBridge(Scene):

    def enter(self):
        print "You burst onto the Bridge with the netron destruct bomb"
        print "under your arm and surprise 5 Gothons who are trying to"
        print "take control of the ship.  Each of them has an even uglier"
        print "clown costume than the last.  They haven't pulled their"
        print "weapons out yet, as they see the active bomb under your"
        print "arm and don't want to set it off."

        action = raw_input("> ")

        if action == "throw the bomb":
            print "In a panic you throw the bomb at the group of Gothons"
            print "and make a leap for the door.  Right as you drop it a"
            print "Gothon shoots you right in the back killing you."
            print "As you die you see another Gothon frantically try to disarm"
            print "the bomb. You die knowing they will probably blow up when"
            print "it goes off."
            return 'death'

        elif action == "slowly place the bomb":
            print "You point your blaster at the bomb under your arm"
            print "and the Gothons put their hands up and start to sweat."
            print "You inch backward to the door, open it, and then carefully"
            print "place the bomb on the floor, pointing your blaster at it."
            print "You then jump back through the door, punch the close button"
            print "and blast the lock so the Gothons can't get out."
            print "Now that the bomb is placed you run to the escape pod to"
            print "get off this tin can."
            return 'escape_pod'
        else:
            print "DOES NOT COMPUTE!"
            return "the_bridge"
#------------------------------------------------
class EscapePod(Scene):

    def enter(self):
        print "You rush through the ship desperately trying to make it to"
        print "the escape pod before the whole ship explodes.  It seems like"
        print "hardly any Gothons are on the ship, so your run is clear of"
        print "interference.  You get to the chamber with the escape pods, and"
        print "now need to pick one to take.  Some of them could be damaged"
        print "but you don't have time to look.  There's 5 pods, which one"
        print "do you take?"

        good_pod = randint(1,5)
        guess = raw_input("[pod #]> ")


        if int(guess) != good_pod:
            print "You jump into pod %s and hit the eject button." % guess
            print "The pod escapes out into the void of space, then"
            print "implodes as the hull ruptures, crushing your body"
            print "into jam jelly."
            return 'death'
        else:
            print "You jump into pod %s and hit the eject button." % guess
            print "The pod easily slides out into space heading to"
            print "the planet below.  As it flies to the planet, you look"
            print "back and see your ship implode then explode like a"
            print "bright star, taking out the Gothon ship at the same"
            print "time.  You won!"

            return 'finished'
#----------------------------------------
class Finished(Scene):

    def enter(self):
        print "You won! Good job."
        return 'finished'
#-------------------------------------------
class Map(object):

    scenes = {
        'central_corridor': CentralCorridor(),
        'laser_weapon_armory': LaserWeaponArmory(),
        'the_bridge': TheBridge(),
        'escape_pod': EscapePod(),
        'death': Death(),
        'finished': Finished(),
    }

    def __init__(self, start_scene):
        self.start_scene = start_scene

    def next_scene(self, scene_name):
        val = Map.scenes.get(scene_name)
        return val

    def opening_scene(self):
        return self.next_scene(self.start_scene)
#----------------------------------------------
a_map = Map('central_corridor')
a_game = Engine(a_map)
a_game.play()        

运行后结果如下：

output43.png

作者构思的类的结构树如下：

• Map
  next_scene
  opening_scene
• Engine
  play
• Scene
  enter

Death
Central Corridor
Laser Weapon Armory
The Bridge
Escape Pod

作者定义了三个大的类（class）：Map，Engine，Scene。
1.Map类中有两个函数next_scene和opening_scene；
2.Engine类中有一个函数play；
3.Scene类中有一个函数enter，而且它是下列类的父类：Death类，CentralCorridor类，LaserWeaponArmory类，TheBridge类，EscapePod类。(后面几个类需要继承Scene类，因为需要用到Scene类中的enter函数）

遗留问题：
后三行代码很迷惑我

a_map = Map('central_corridor')
a_game = Engine(a_map)
a_game.play()

a_map = Map() 是创建一个Map类的instance到a_map，为什么它的括号内有个参数？第二行同样的问题，class括号内的参数干嘛用的？

已解决：括号内的参数是对该类的init()的参数进行赋值的，为空的话代表为初始值。