linkedlist.py

class Node:

    __slots__ = ('val', 'next')

    def __init__(self, value=None, next=None):
        self.val = value
        self.next = next

    def __str__(self):
        return str(self.val)


class Linkedlist:

    def __init__(self):
        self.head = None

    def __getitem__(self, index):
        return self.node_at(index).val

    def __setitem__(self, index, value):
        node = self.__getitem__(index)
        if isinstance(value, Node):
            value = value.value
        node.value = value

    def __delitem__(self, index):
        to_del = self.node_at(index)
        self.remove(to_del)

    def __len__(self):
        return self.length

    def __iter__(self):
        p = self.head
        while p:
            yield p.val
            p = p.next

    def node_at(self, index):
        if self.is_empty():
            raise IndexError('Linked list is empty')
        elif index < 0:
            index = index + self.length
        elif index < 0 or index >= self.length:
            raise IndexError('index out of range')

        p = self.head
        i = 0
        while p and i < index:
            p = p.next
            i += 1
        return p

    def init_by_list(self, data):
        self.head = Node(data[0])

        p = self.head
        for v in data[1:]:
            node = Node(v)
            p.next = node
            p = p.next

    def insert_before(self, index, value):
        cur = self.node_at(index)
        pre = self._get_prev(index)
        new = Node(value)

        if pre:
            pre.next = new
        else:
            self.haed = new
        new.next = cur

        return new
    insert = insert_before

    def insert_after(self, index, value):
        cur = self.node_at(index)
        new = Node(value)
        if cur.next is None:
            cur.next = new
        else:
            new.next = cur.next
            cur.next = new
        return new

    def append(self, value):
        self.insert_after(self.length - 1, value)

    def index_of(self, value):
        if self.is_empty():
            raise ValueError('List is empty')

        p = self.head
        i = 0
        for i in range(self.length):
            if p.val == value:
                return i
            p = p.next
        raise ValueError("Node doesn't exit")

    @property
    def length(self):

        p = self.head
        length = 0
        while p:
            length += 1
            p = p.next
        return length

    def is_empty(self):
        return self.length == 0

    def _get_prev(self, index):
        if self.is_empty():
            raise IndexError('List is empty')
        elif index == 0:
            None
        p = self.head
        i = 0
        while p and i < index:
            p = p.next
            i += 1
        return self.node_at(i - 1)

    def __str__(self):
        return "{}".format(' '.join(map(str, self)))