<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:

def difference(self, second_iterable, selector=identity):
        '''Returns those elements which are in the source sequence which are not
        in the second_iterable.

        This method is equivalent to the Except() LINQ operator, renamed to a
        valid Python identifier.

        Note: This method uses deferred execution, but as soon as execution
            commences the entirety of the second_iterable is consumed;
            therefore, although the source sequence may be infinite the
            second_iterable must be finite.

        Args:
            second_iterable: Elements from this sequence are excluded from the
                returned sequence. This sequence will be consumed in its
                entirety, so must be finite.

            selector: A optional single argument function with selects from the
                elements of both sequences the values which will be
                compared for equality. If omitted the identity function will
                be used.

        Returns:
            A sequence containing all elements in the source sequence except
            those which are also members of the second sequence.

        Raises:
            ValueError: If the Queryable has been closed.
            TypeError: If the second_iterable is not in fact iterable.
            TypeError: If the selector is not callable.
        '''
        if self.closed():
            raise ValueError("Attempt to call difference() on a "
                             "closed Queryable.")

        if not is_iterable(second_iterable):
            raise TypeError("Cannot compute difference() with second_iterable"
               "of non-iterable {0}".format(str(type(second_iterable))[7: -2]))

        if not is_callable(selector):
            raise TypeError("difference() parameter selector={0} is "
                "not callable".format(repr(selector)))

        return self._create(self._generate_difference_result(second_iterable,
                                                            selector))