在 python 中实现自定义可迭代对象

Question

这是我在Python中实现的自定义单向链表。

 class SList:
        def __init__(self):
            self.root = None
            self.size = 0

        def insert(self, item):
            if not item:
                raise ValueError('Cannot add None item to a list')
            self.size += 1
            if self.root is None:
                self.root = Node(item)
            else:
                p = Node(item)
                p.next = self.root
                self.root = p

        """Remove the element at the specific index"""
        def remove(self, index):
            if index < 0 or index >= self.size:
                raise ValueError('Index cannot be negative or greater than the size of the list')

            current = self.root
            if index == 0:
                self.root = self.root.next
            else:
                for _ in range(index -1):
                    current = current.next
                p = current.next.next
                if p is not None:
                    current.next = p
                else:
                    current.next = None

            self.size -= 1

        def __len__(self):
            return self.size

        def __repr__(self):
            res = '[ '
            current = self.root
            while current is not None:
                res += str(current.data)
                res += ' '
                current = current.next
            res += ']'
            return res

        def __iter__(self):
            return self

        def next(self):
            ........

这是节点对象

class Node:
    def __init__(self, data):
        try:
            if not data:
                raise ValueError
            self.data = data
            self.next = None
        except ValueError:
            raise ValueError('Node cannot be instantiated without an item')

我在实现 iter 方法时有点不知所措。我看到有多种方法可以实现它，而 yield 似乎是常见的前进方式。希望能在 yield

中提供一些帮助

Answer 1

尝试遵循以下解释： pythontips.com/2013/09/29/the-python-yield-keyword-explained

简而言之，为了创建生成器，您应该创建一个包含一次或多次 yield 关键字的函数。任何时候在函数执行中达到 yield 时，它都会被搁置，并将关键字后的值传递给调用者。

def my_gen(arg):
    yield arg * 10
    for i in xrange(5):
            if i / 2 == 0:
                 yield i

for x in my_gen(3):
     print(x)

将打印： 30 0 2个 4

节点class的构造函数也有问题，除了捕获你自己的异常，你的if条件也有错误 not data will be True not only if data is False或 None，但如果数据为 0、空列表、空字符串等等。请改用 data is None。

Answer 2

您可以通过将其 __iter__ 方法作为生成器来使您的 class 可迭代。

这是一些在 Python 2 或 Python 3 上正确运行的代码。

from __future__ import print_function

class Node(object):
    def __init__(self, data):
        if data is None:
            raise ValueError('Node cannot be instantiated without an item')
        self.data = data
        self.nextnode = None

    def __repr__(self):
        return 'Node({})'.format(self.data)

class SList(object):
    def __init__(self):
        self.root = None
        self.size = 0

    def insert(self, item):
        if item is None:
            raise ValueError('Cannot add None item to a list')
        self.size += 1
        if self.root is None:
            self.root = Node(item)
        else:
            p = Node(item)
            p.nextnode = self.root
            self.root = p

    def remove(self, index):
        """ Remove the element at the specific index """
        if index < 0 or index >= self.size:
            raise ValueError('Index cannot be negative or greater than the size of the list')

        current = self.root
        if index == 0:
            self.root = self.root.nextnode
        else:
            for _ in range(index - 1):
                current = current.nextnode
            current.nextnode = current.nextnode.nextnode

        self.size -= 1

    def __len__(self):
        return self.size

    def __repr__(self):
        res = []
        current = self.root
        while current is not None:
            res.append(current.data)
            current = current.nextnode
        return str(res)

    def __iter__(self):
        current = self.root
        while current is not None:
            yield current
            current = current.nextnode

# test 

a = SList()
for c in 'ABCDE':
    a.insert(c)

print(a)

gen = iter(a)
print('root', next(gen))
for node in gen:
    print(node)

a.remove(2)

print(list(a))

for node in a:
    print(node)

输出

['E', 'D', 'C', 'B', 'A']
root Node(E)
Node(D)
Node(C)
Node(B)
Node(A)
[Node(E), Node(D), Node(B), Node(A)]
Node(E)
Node(D)
Node(B)
Node(A)

在 python 中实现自定义可迭代对象

Implemeting custom iterable object in python

python

iterable