Singly Linked List implementation in Python

Question

I'm new to Python and thus learning it by implementing a set of commonly used data structures. Here's my implementation of a LinkedList. First the Node class.

class Node:

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

Here's the LinkedList,

from node import Node

class LinkedList:

    def __init__(self):
        self.head = None;
        self.size = 0;

    def insert(self, item):
        curr = Node();
        curr.value = item
        self.size += 1
        if(self.head == None):
            self.head = curr
        else:
            curr.next = self.head
            self.head = curr

    def remove(self, item):
        if(self.head == None):
             raise Exception('Removing from an empty list')
        curr = self.head
        if(curr.value == item):
            self.head = curr.next
            return
        while(curr.next.value != item):
            curr = curr.next
        if(curr.next == None):
            raise Exception('Item not present in list')
        else:
            curr.next = curr.next.next



    def print_list(self):
        curr = self.head;
        while(curr):
            print(curr.value, end=' ')
            curr = curr.next

And finally the calling client,

from linked_list import LinkedList

list = LinkedList()
list.insert(2)
list.insert(5)
list.insert(7)
list.insert(12)
list.insert(13)
list.remove(13)
list.print_list()

My primary language is Java, so I'd invite comments on how pythonic is my implementation and best practices. TIA.

Answer 1

For the most part it looks good, I haven't tested performance, but nothing stands out as bad. You should probably rewrite remove, so that it takes an index rather than a value. Imagine

list = LinkedList()
list.insert(2)
list.insert(2)
list.remove(2)

Your current code works great as long as there aren't duplicate values, but once there are everything gets kind of messed up.

With regards to pythonicness, the only comment I have is that if(x): is harder to type and harder to parse than if x:.

Answer 2

You should not name variables and parameters the same as Python built-in names, such as next (see this).

The reason is because you are redefining what Python already defined. Now anyone, including you, relying on that Python builtin by importing your code might see unexpected side effects. See this simple illustration; once you modify Python builtin list to be an instance of list, one cannot call list() again:

>>> x = list()
>>> x
[]
>>> list = [5]
>>> y = list()
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: 'int' object is not callable