链接列表类__str__函数

Question

I want to create this function

    >>> str(Link('Hello'))
    'Hello'

    >>> str(Link(1, Link(2)))
    '1 -> 2'

    >>> print(Link(1 / 2, Link(1 // 2)))
    0.5 -> 0

    >>> str(Link(Link(1, Link(2, Link(3))), Link(4, Link(5))))
    '(1 -> 2 -> 3) -> 4 -> 5'

    >>> print(Link(Link(Link(Link('Wow')))))
    (((Wow)))

    >>> print(Link(Link('a'), Link(Link('b'), Link(Link('c')))))
    (a) -> (b) -> (c)

Here is my code:

def __str__(self):
    result = ''
    while self.rest is not Link.empty:
        result += '{0} -> '.format(self.first)
        self = self.rest
    return result + '{0}'.format(self.first)

However, I do not know what to do in order to fulfill the last three doctests. Help!!!

class Link(object):
   empty = ()
   def __init__(self, first, rest=empty):
       self.first = first
       self.rest = rest

Answer 1

It looks like the rule is supposed to be that if the head of a list is itself a list, you format that list, and put it in parentheses. Something like this:

first = '({0})'.format(self.first) if isinstance(self.first, Link) else first
result += '{0} -> '.format(first)

Now, it's a bit strange to avoid using recursion on rest , but then indirectly use recursion on first . (That's what '{0}'.format(…) does—if you haven't defined a __format__ method, it calls your __str__ method.)

So, assuming this is an assignment, if the assignment tells you to not use recursion, you're going to need to turn that into a loop. If, on the other hand, the assignment doesn't say to avoid recursion, it would be a lot simpler to just recurse on both:

first = str(self.first)
if isinstance(self.first, Link):
    first = '({0})'.format(first)
if self.rest is Link.empty:
    return first
return '{0} -> {1}'.format(first, self.rest)

---

As a side note: This is a stock Scheme exercise ported badly to Python (which implies that your teacher either doesn't get or doesn't like Python, which isn't a great sign…), but it's missing a piece.

Normally, you're supposed to handle, eg, Link(1, 2) differently from Link(1, Link(2)) . (In Lisp terms, that's (1 . 2) vs. (1 2) .) But none of the examples you gave test for that, so it's not clear exactly what you're supposed to output for the former. Sp… be prepared to be marked off for not reading your teacher's mind, unless you want to do something like this:

first = str(self.first)
if isinstance(self.first, Link):
    first = '({0})'.format(first)
if self.rest is Link.empty:
    return first
rest = str(self.rest)
if isinstance(self.rest, Link):
    return '{0} -> {1}'.format(first, self.rest)
else:
    # surely (1 2 . 3) is not the same list as (1 2 3) but the spec left it out?
    return '{0} .. {1}'.format(first, self.rest)