Python 2 Stack and LinkedList implementation I'm currently implementing data structures and algorithms I studed in my college course. This is my implementation of a singly linked list and a stack. I would appreciate some feedback in terms of the code quality.

My LinkedList:

from random import randint

class Node:

    def __init__(self, x):
        self.current = x
        self.next = None

class LinkedList:

    def __init__(self, x):
        self.head = Node(x)

    def insert(self, x):
        new_entry = Node(x)
        new_entry.next = self.head
        self.head = new_entry

    def search(self, x):
        node = self.head

        while node.current is not x:
            if node.next is None:
                break
            node = node.next

        if node.current is x:
            return x
        else:
            return None

    def contains(self, x):
        retrieved = self.search(x)
        return retrieved is x

    def delete(self, x):
        try:
            node = self.head

            while node.next.current is not x:
                node = node.next

            if node.next.current is x:
                node.next = node.next.next
        except AttributeError:
            print str(x) + " is not in the linked list"

    def traverse(self):
        node = self.head
        text = ""  # type: str

        while node is not None:
            text += str(node.current) + "-&gt;"
            node = node.next

        return text


My stack:

class Stack:

    def __init__(self):
        self.data = []

    def push(self, e):
        self.data.append(e)

    def pop(self):
        return self.data.pop()

    def prnt(self):
        print self.data

def is_integer(val):
    try:
        int(val)
        return True
    except ValueError:
        return False

def is_binary_operator(val):
    return val is '+' or val is '-' or val is '*' or val is '/'

def postfixEval(stack, expression):
    symbols = expression.split()

    for symbol in symbols:

        if is_integer(symbol):
            s = int(symbol)
            stack.push(s)
        elif is_binary_operator(symbol):
            s2 = stack.pop()
            s1 = stack.pop()

            if symbol is '+':
                a = s1 + s2
            elif symbol is '-':
                a = s1 - s2
            elif symbol is '*':
                a = s1 * s2
            elif symbol is '/':
                a = s1 / s2

            stack.push(a)

    return stack.pop()
Notes on LinkedList:


The import is unused.
It should allow creation of an empty list.
Normally a linked list inserts items after the last item. Maybe I'm confused by the way insert works, but it looks like in your case head is always the last inserted entry in the list, and the list is traversed from head backwards through history using .next.
delete should use search.


Notes on Stack:


self.data should be self.entries or something else descriptive.
prnt should be as_string or even __str__.
int(val) does not check whether something is an integer, it just tries to convert a value to an integer.
+, -, * and / are arithmetic, not binary, operators.
In Python 3 mathematical operators are modeled as functions.
is_integer, is_binary_operator and postfixEval should not be part of Stack - they are not fundamental to the stack in any way.