python正在努力设计这个

Question

今天我在课堂上做了一个小测验，结果很惨，测验如下。 有人能帮我解释一下吗。在

1. 向Link添加一个方法open()，该方法将断开链接与“仅在其左侧”的链接，从而打开项链，同时保持右侧链的完整性。例如，如果抓取link1处的项链，那么调用link1.open()会断开link3与{}的连接，但仍保持link1到{}之间的链。在

这是我目前拥有的：

class Diamond(object):
    def __str__(self):
        return "Diamond"

class Ruby(object):
    def __str__(self):
        return "Ruby"

class Visitor:
    def __str__(self):
        return self.__class__.__name__

class Link(object):
    def __init__(self, index, jewel = None):
        self.jewel = jewel
        self.index = index

    def connectTo(self, link):
        self.nextLink = link

    def __next__(self):
        return self.nextLink or None

    def attach(self, jewel):
        if not self.jewel:
            self.jewel = jewel

    def detatch(self):
        stone = self.jewel
        self.jewel = None
        return stone

    def open(self):
        pass

    def __str__(self):
        return "link%d" % (self.index)

class Necklace(object):
    def __init__(self, base):
        self.base = base

    def describe(self):
        link = self.base
        while True:
            print link, "with", link.jewel, "attatched to", link.nextLink, "with", link.nextLink.jewel
            link = link.nextLink
            if link == self.base:
                break

    def getJewel(self):
        link = self.base
        while True:
            link = link
            if isinstance(link.jewel, Diamond):
                print "a", link.detatch()
                break
            link = link.nextLink
            if link == self.base:
                print "nothing..."
                break

    def acceptVisitor(self, visitor):
        visitor.visit(self)

class DiamondThief(object, Visitor):
    def __init__(self, base):
        self.base = base
        self.jewel = self.base.jewel

    def visit(self, necklace):
        necklace.getJewel()

    def searchForDiamond(self):
        self.visit(myNecklace)

link1 = Link(1, Ruby())
link2 = Link(2, Diamond())
link3 = Link(3, Ruby())
link1.connectTo(link2)
link2.connectTo(link3)
link3.connectTo(link1)
myNecklace = Necklace(link1)
myNecklace.describe()

print "Uh on here comes a thief..."
thief = DiamondThief(link1)
print "Oh no he took "
thief.searchForDiamond()
myNecklace.describe()

Answer 1

让我们看看每个类需要什么函数？

1. Link
   • 变数
     • name（可能）
     • linked_to或^{cd4>}
     • jewel
   • 方法
     • connectTo(self,link)
     • attach(self,jewel)
     • ^{cd8>}
     • open(self)
     • get_next(self)
2. Necklace（不在下面的代码中，请自行制作）
   • 变数
     • ^{cd12>}
   • 方法
     • __next__(self)或^{cd14>}
3. DiamondThief
   • 变数
     • link
     • diamond
   • 方法
     • getDiamond(self)
     • ^{cd19>}
4. Jewels类似^{cd21>}或^{cd22>}
   • 无变量或方法

看到这个代码，我还添加了Diamond盗贼类。。。

class Necklace:
    '''My version of necklace'''
    def __init__(self, link):
        self.first = link
        self.current_link = link
    def next(self):
        self.current_link = self.current_link.get_next()
        if self.current_link == self.first:
            raise StopIteration
        return self.current_link
    def __iter__(self):
        return self

class Link(object):
    """A link of a necklace"""
    def __init__(self, name, jewel=None):
        self.name = name
        self.linkedTo = None
        self.jewel = None
        if jewel != None:
            self.attach(jewel)

    def connectTo(self, link):
        '''Connect to link'''
        if isinstance(link,Link):
            self.linkedTo = link
        else:
            raise TypeError

    def attach(self, jewel):
        '''Attach jewel'''
        if self.jewel == None:
            self.jewel = jewel
        else:
            msg = 'There is already a %s attached' % jewel.__class__.__name__
            raise AttributeError(msg)

    def detach(self):
        '''Detach jewel'''
        if self.jewel != None: # 
            je = self.jewel
            self.jewel = None
            return j
        else:
            msg = 'There is nothing to detach'
            raise AttributeError(msg)

    def __str__(self):
        if self.linkedTo != None:
            return "%s(%s) => %s" % \
                   (self.name,self.jewel.__class__.__name__, self.linkedTo.name)
        else:
            return "%s(%s) => %s" % \
                   (self.name,self.jewel.__class__.__name__,None)

    def get_next(self):
        '''Get the next chain'''
        return self.linkedTo

class Diamond(object):
    pass

class Ruby(object):
    pass

class DiamondThief:
    def __init__(self, necklace):
        self.necklace = necklace
        self.diamond = None

    def search(self):
        '''Go link by link to find the Diamond'''
        if self.diamond != None:
            print 'Have a diamond already'
            return 
        first = self.necklace.first
        link = first
        for link in self.necklace: # loop till
            if isinstance(link.jewel, Diamond): # diamond is found
                self.diamond = link.jewel
                link.jewel = None
                print 'Found Diamond'
                break

    def getDiamond(self):
        if self.diamond != None:
            return self.diamond
        else:
            return None

def main():
    # create
    l1 = Link('1',Diamond())
    l2 = Link('2',Ruby())
    l3 = Link('3', Ruby())
    l1.connectTo(l2)
    l2.connectTo(l3)
    l3.connectTo(l1)
    i = DiamondThief()
    try:
        l2.attach(Ruby())
    except AttributeError,e:
        print e
    print l1
    print l2
    print l3
    print '-'*16
    i.search()
    print l1
    print l2
    print l3
main()

Answer 2

第1部分简单地要求您使用Link类中描述的方法来构建一个指定的项链：

link1 = Link()
link1.attach(Ruby())
link2 = Link()
link2.attach(Diamond())
link3 = Link()
link3.attach(Ruby())

link1.connectTo(link2)
link2.connectTo(link3)
link3.connectTo(link1)

myNecklace = link1

第2部分需要一个Link和diamond小偷类的实现。在

下面是我如何实现Link，作为一个双链接列表。您实际上并不需要第二个链接来实现我们在本部分中需要做的基本方法，但是如果我们同时引用了左边和右边的相邻链接，那么在第3部分中添加open将更加容易。在

^{pr2}$

这是我的DiamondThief访问者的实现。它的主要方法是visit，它递归地访问后续的Link实例，直到找到钻石或者它循环（或者从打开的项链的末端跑出来）。您可以用while循环而不是递归来做同样的事情，但这似乎更简单。注意，递归调用中的or表达式意味着如果first为None（默认情况下为None），那么link将作为first传递。在

^{3}$

第3部分要求您向open类添加一个open方法。由于Link是双重链接的，所以很容易将列表拆分到当前位置的左侧。如果你把它实现为一个单链链表，你必须扫描整个项链（从每个链环到它的右邻居），直到找到链接到第一个实例的那条。如果项链没有形成一个环，那就完全不起作用了。在

总之，下面是一个简单的实现：

def open(self):
    """Disconnect this link from it's left neighbor."""
    if self.left is None:
        raise ValueError("Link is not connected on the left")
    self.left.right = None
    self.left = None