Working program but review required to make it better

import os
import pickle
"""
Caches and pickles factorial of a number.
Upon instantiation, sarches for the file 'fact.cache'
in the current directory or in the path passed during
construction. If not found then creates the file there.
If found then unpickles it and creates the dictionary
with pre-calculated factorial values.
"""
class FactCache:
    c = {}
    def __init__(self,path="./fact.cache"):
        self.path=path
        try:
            if(os.path.isfile(self.path)):
                print("Cache file found. Reading it now...")
                with open(self.path,'rb') as readCache:
                    self.c = pickle.load(readCache)
            else:
                print("File not found. Creating it now...")
                with open(self.path,'wb') as writeCache:
                    pickle.dump(self.c,writeCache)
        except IOError as err:
            print("Oops! Factorial cache not loaded!",str(err))
            pass
        finally:
            print(self.c)

    """
    Stores the value (f) of the factorial for a number (n) in the file.
    """
    def add(self,n,f):
        self.c[n]=f
        with open(self.path,'wb') as writeCache:
            pickle.dump(self.c,writeCache)    

    """
    Returns the value of the factorial for a number (n) from the dictionary.
    """
    def get(self,n):
        if n in self.c:
            return self.c[n]
        else:
            return -1

"""
Computes factorial of a given number and
reuses all previous results to reduce recursion.
"""
def factorial(n,c):
    f = c.get(n)
    if(f == -1):
        if(n==0):
            return 1
        else:
            v = n*factorial(n-1,c)
            c.add(n,v)
            return v
    else:
        print("Value served from cache for ",n)
        return f

def spam(eggs):
    '''Add spam to my eggs.

    A more detailed explanation follows here.
    '''

''' DocumentationString1.py
documentation strings must be added right below the function definition,
triple quotes are recommended as a standard
can be accessed via function_name.__doc__
'''

def get_distance(x1, y1, x2, y2):
    """
    get_distance(x1, y1, x2, y2)
    returns distance between two points using the pythagorean theorem
    the function parameters are the coordinates of the two points
    """
    dx = x2 - x1
    dy = y2 - y1
    return (dx**2 + dy**2)**0.5

#
# since the indentation rules relax between triple quotes
# you can also use this to avoid adding spaces in front of 
# the doc string
#

def get_distance2(x1, y1, x2, y2):
    """
get_distance(x1, y1, x2, y2)
returns distance between two points using the pythagorean theorem
the function parameters are the coordinates of the two points
    """
    dx = x2 - x1
    dy = y2 - y1
    return (dx**2 + dy**2)**0.5

print( "The function's documentation string:" )
# shows text between the triple quotes
print(get_distance.__doc__)
print("\nWithout leading spaces:")
print(get_distance2.__doc__)

''' my result >>>
The function's documentation string:

    get_distance(x1, y1, x2, y2)
    returns distance between two points using the pythagorean theorem
    the function parameters are the coordinates of the two points
    

Without leading spaces:

get_distance(x1, y1, x2, y2)
returns distance between two points using the pythagorean theorem
the function parameters are the coordinates of the two points
'''