Fixed point iteration and cobweb plot
Your questions


Functions can be function arguments, too.
You can add a parameter for that.
See additional comments. I think it's fine that you use a class.
That is usually not in the range of codereview. That should be asked in StackOverflow (but I think I know what you want - just look at the code).


Additional comments


Add a shebang. If you do, you can directly execute the script. See What does #!/usr/bin/python mean?
Read PEP8 or at least use pep8online.com to make your coding style standard conform and hence easier to read. It's mostly about setting whitespaces correct.
Use docstrings and eventually doctest. That makes your code again easier to read and you can easily verify if it works as you expect.
If you don't use a variable, you should remove it at all. If that is not possible (e.g. in the case of unzipping values) you should name the variable _.


The code

#!/usr/bin/env python

import numpy as np
import matplotlib.pyplot as plt


def f(x):
    """An (arbitrary) quadratic mathematical function.
       It has fixpoints 0 and 0.5.

    &gt;&gt;&gt; f(0)
    0
    &gt;&gt;&gt; f(0.5)
    0.5
    """
    return 2*x*(1-x)


def g(x):
    """An (arbitrary) quadratic mathematical function.
       It has fixpoints 0 and (+/-) 1/sqrt(2)

    &gt;&gt;&gt; g(0)
    0
    &gt;&gt;&gt; "%0.4f" % g(-0.7071)
    '-0.7071'
    """
    return 2*x*(1-x)*(1+x)


class fixpt(object):
    """Find fixed points of a given function f."""
    def __init__(self, x, f, xmin=0, xmax=1, epsilon=1.0E-100):
        """Constructor
        @param x float - where to start search
        @param f function - function that should get evaluated
        @param xmin float - Interval that gets examined
        @param xmax float - Interval that gets examined
        @param epsilon float - comparison when floats are considered to be
                               the same
        """
        self.x = x
        self.f = f
        self.xmin = xmin
        self.xmax = xmax
        self.epsilon = epsilon

    def search(self, N=1000, store=False):
        """Search fixed points.
        @param N int - number of iterations
        @param store - bool - if set, return ????
        @return I did not understand that. It seems to depend on 'store'

        &gt;&gt;&gt; fixpointiter = fixpt(0, f)
        &gt;&gt;&gt; fixpointiter.search()
        (0, 0, 0)
        """
        # Set initial values
        x = self.x
        y = self.f(x)
        n = 0
        if store:
            values = [(x, y)]  # Why?
        while abs(y-x) &gt;= self.epsilon and n &lt; N:
            x = f(x)
            n += 1
            y = f(x)
            if store:
                values.append((x, y))
        if store:
            return y, values
        else:
            if n &gt;= N or x == -float('inf') or x == float('inf'):
                # No fixed point for given initial condition
                return None
            else:
                return x, n, y

    def plot(self):
        """Draw a cobweb plot."""
        _, points = self.search(store=True)
        xaxis = np.linspace(self.xmin, self.xmax, 1000)
        plt.plot(xaxis, f(xaxis), 'b')
        plt.plot(xaxis, xaxis, 'r')

        for x, y in points:
            plt.plot([x, x], [x, y], 'g')
            plt.plot([x, y], [y, y], 'g')

        plt.show()

    def scan(self):
        """Scan for all fix points in xmin / xmax."""
        x_range = np.linspace(self.xmin, self.xmax, 1000)
        fixpoints = []
        for x in x_range:
            self.x = x
            ret = self.search()
            if ret is not None:
                fixpoints.append(ret[0])
        # Get rid of duplicates
        fixpoints = sorted(fixpoints)
        final = []
        for x in fixpoints:
            # It's not the same as the last fixpoint
            if len(final) == 0 or abs(final[-1]-x) &gt;= self.epsilon:
                final.append(x)
        return final

if __name__ == '__main__':
    # Automatic doctest
    import doctest
    doctest.testmod()
    # Usage example
    fixpointiter = fixpt(0, g, -2, 2)
    print(fixpointiter.search())
    print(fixpointiter.search(store=True))
    print(fixpointiter.scan())