Error when deleting a node in a Linked List <ListNode.ListNode object at 0x0000000267320>

Question

I am making a linkedlist, and I had to add in some different functions such as max, min , count and index for my list. I now have to add a remove function which is this snippet of code.

def removeItem(self, position):

        ''' removeItem removes a selected, because python has a built in "garbage remover",
        you don't have to physically delete the node, you only have to skip that node link and python will destroy it
        by it self.'''

        currentNode = self.head
        previousNode = None
        count = 0

        while count != position:
            #This is a quick check to make sure the next node isn't empty.
            if currentNode.link is None:
                print("Position Invalid")
                return None
            previousNode = currentNode
            currentNode = currentNode.link
            count += 1

        #Node.Link should link to the next node in the sequence.
        previousNode.link = currentNode.link
        return currentNode

I am basically just trying to link over the next node in the sequence, so that the built-in garbage remover will remove that node from the sequence. However, I am getting the following error message, which I know has to do something with my instance.

C:\Python33\python.exe "C:/Users/koopt_000/Desktop/College/Sophomore Semester 2/Computer Science 231/Chapter4/Test.py"
900
1
1
2
<ListNode.ListNode object at 0x0000000002679320>

Process finished with exit code 0

Why is it printing out this weird ListNode.ListNode object at the end? Here is my testing code:

from ListNode import ListNode
from LinkedList import LinkedList

node1 = ListNode(1)
node2 = ListNode(900)
node3 = ListNode(3)
node4 = ListNode(99)
node1.link = node2
node2.link = node3
node3.link = node4

linked_list = LinkedList((1, 900, 3, 99))
print(linked_list.__max__())
print(linked_list.__min__())
print(linked_list.getCount(900))
print(linked_list.getIndex(3))
print(linked_list.removeItem(3))

This is my code for my ListNode class:

# ListNode.py
class ListNode(object):

    def __init__(self, item = None, link = None):

        '''creates a ListNode with the specified data value and link
        post: creates a ListNode with the specified data value and link'''

        self.item = item
        self.link = link

This is my code for my LinkedList class:

from ListNode import ListNode

class LinkedList(object):

    #--------------------------------------------------------------

    def __init__(self, seq=()):

        """ Pre: Creates a Linked List
        Post: Creates a list containing the items in the seq=()"""

        if seq == ():

            # If there is no items to be put into the list, then it creates an empty one.
            self.head = None

        else:

            # Creates a node for the first item.
            self.head = ListNode(seq[0], None)

            # If there are remaining items, then they're added while keeping track of the last node.
            last = self.head
            for item in seq[1:]:
                last.link = ListNode(item, None)
                last = last.link

        self.size = len(seq)

    #-------------------------------------------------------------

    def __len__(self):

        '''Pre: Nothing.
           Post: Returns the number of items in the list.'''

        return self.size

    #-------------------------------------------------------------
    def __max__(self):

        ''' Goes through each node and compares what the max is for the linked list.
        Post: Finds the max of the linked list and returns that value.'''

        if self.head is None:
        return None
        max_value = self.head.item
        node = self.head.link

        while node is not None:
            if node.item > max_value:
                max_value = node.item
            node = node.link
        return max_value

    #--------------------------------------------------------------

    def __min__(self):

        ''' Goes through each node and compares what the min is for the linked list.
        Post: Finds the min of the linked list and returns that value.'''

        if self.head is None:
            return None
        min_value = self.head.item
        node = self.head.link

        while node is not None:
            if node.item < min_value:
                min_value = node.item
            node = node.link
        return min_value

    #--------------------------------------------------------------

    def getCount(self, yourData):

        ''' This function counts the amount of times a certain item is in the Linked List.'''

        count = 0
        node = self.head

        for i in range(self.size):
            data = node.item
            if data is yourData:
                count += 1
            node = node.link
        return count

    #--------------------------------------------------------------

    def getIndex(self, yourData):

        ''' getIndex finds the index of the selected item and returns that value. '''

        node = self.head

        if node is None:
            return None

        for i in range(self.size):
            data = node.item
            if data == yourData:
                return i
            node = node.link

        raise IndexError


    #--------------------------------------------------------------

    def removeItem(self, position):

        ''' removeItem removes a selected, because python has a built in "garbage remover",
        you don't have to physically delete the node, you only have to skip that node link and python will destroy it
        by it self.'''

        currentNode = self.head
        previousNode = None
        count = 0

        while count != position:
            #This is a quick check to make sure the next node isn't empty.
            if currentNode.link == None:
                print("Position Invalid")
                return None
            previousNode = currentNode
            currentNode = currentNode.link
            count += 1

        #Node.Link should link to the next node in the sequence.
        previousNode.link = currentNode.link
        return currentNode

    #--------------------------------------------------------------

If anyone could help me out to find out why my removeItem function isn't working that would be helpful!

On a side note, I'm also trying to make a doubly linked list of this list, I know I need to add a prev_node function into my ListNode function, but what else do I need to add? Thanks again!

Answer 1

If your method is returning a <LinkNode object at 0xmemoryaddr> string then it is working fine. You are printing the removed node, and Python is using the default repr() representation for that instance.

If you wanted to make it more readable, you could give the ListNode a object.__repr__ method:

def __repr__(self):
    next = 'None' if not self.link else '...'  # just to indicate
    return 'ListNode({!r}, {})'.format(self.item, next)

This then will print ListNode(99, None) instead of the <ListNode object at 0xmemoryaddr> string Python defaulted to:

>>> ll = LinkedList((1, 900, 3, 99))
>>> ll.head
ListNode(1, ...)
>>> ll.head.link
ListNode(900, ...)
>>> ll.head.link.link
ListNode(3, ...)
>>> ll.head.link.link.link
ListNode(99, None)

One thing you do have to take into account: you need to adjust the length of the list too; on successful removal, subtract 1 from self.size.