It feels like you want to monkey patch a method onto this. If so, then welcome to the dark side young one. Let us begin the cursed ritual. In essence you want to monkey patch. All we need is a little monkey blood. Just kidding. We need type.MethodType. But note, that you cannot monkey patch stdlib types:

>>> from types import MethodType
>>> def palindrome(self): return self == self[::-1]
...
>>> str.palindrome = MethodType(palindrome, str)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: can't set attributes of built-in/extension type 'str'

But that won't stop you from causing havoc in other classes:

>>> class String(object):
...     def __init__(self, done):
...         self.done = done
...
...
...
>>> s = String("stanley yelnats")
>>> def palindrome(self): return self.done[::-1]
>>> s.palindrome = MethodType(palindrome, s)
>>> s.palindrome()
'stanley yelnats'

You see how easy that was? But we're just getting started. This is just a mere instance lets kill a class now shall we? The next part will get you laughing maniacally:

>>> from types import DynamicClassAttribute
>>> class String(object):
...     def __init__(self, done):
...         self.done = done
...
...
...
>>> s = String("cheese")
>>> def palindrome(self): return self.done[::-1];
...
>>> String.palindrome = DynamicClassAttribute(palindrome)
>>> s.palindrome
'eseehc'

After this, if you do not feel evil. Then you must come over to my evil lair, where I shall show you more evil tricks and share cookies.

Seems like you're missing a little part. I've noticed that you are calling a function improperly. Don't forget to type the opening and closing brackets while calling a function. The correct way would be;

class Dog():

def Bark(self):
    print("woof")

def Bark_lots(self):
    for I in range(3):       
        self.Bark()

Marley = Dog()

Marley.Bark_lots()

You can't do what you want when your function is defined, because it is unbound. Here's a way to achieve it in a generic fashion at runtime:

class CalcOrPass(object):
    def __init__(self, func):
        self.f = func

    def __get__(self, obj, type=None): # Cheat.
        return self.__class__(self.f.__get__(obj, type))

    #if the value is already in the instance dict from SimpleData,
    #don't recalculate the values, instead return the value from the dict
    def __call__(self, *args, **kwargs):
        # I'll concede that this doesn't look very pretty.
        # TODO handle KeyError here
        res = self.f.__self__.stats[self.f.__name__]
        if not res:
            res = self.f(*args, **kwargs)
            self.f.__self__.stats[self.f__name__] = res
        return res

A short explanation:

• Our decorator defines __get__ (and is hence said to be a descriptor). Whereas the default behaviour for an attribute access is to get it from the object's dictionary, if the descriptor method is defined, Python will call that instead.
• The case with objects is that object.__getattribute__ transforms an access like b.x into type(b).__dict__['x'].__get__(b, type(b))
• This way we can access the bound class and its type from the descriptor's parameters.
• Then we create a new CalcOrPass object which now decorates (wraps) a bound method instead of the old unbound function.
• Note the new style class definition. I'm not sure if this will work with old-style classes, as I haven't tried it; just don't use those. :) This will work for both functions and methods, however.
• What happens to the "old" decorated functions is left as an exercise.

One reason is to refer to the method of that particular class's instance within which the code is be executed.

This example might help:

def hello():
    print "global hello"

class bla:
    def hello(self):
        self.thing()
        hello()

    def thing(self):
        print "hello"

b = bla()
b.hello()
>>> hello
global hello

You can think of it, for now, to be namespace resolution.

Use self to refer to instance variables and methods from other instance methods. Also put self as the first parameter in the definition of instance methods.

An example:

class MyClass(object):

    my_var = None

    def my_method(self, my_var):
         self.my_var = my_var
         self.my_other_method()

    def my_other_method(self):
         # do something...

To use self, you have to share a list collection between instances of a Person-class. In that case this collection should be declared as a class attribute or global list variable (not an instance attribute).

These samples of code are working:

with global list variable:

class Person:

    def __init__(self, name):
        self.name = name

    def make_friends(self, list):
        list.remove(self)

    def __repr__(self):
        return self.name


p1 = Person("Joe")
p2 = Person("Barack")

the_list = []
the_list.append(p1)
the_list.append(p2)

p1.make_friends(the_list)

print(the_list)

With class attribute:

class Person2:
    class_list = []

    def __init__(self, name):
        self.name = name
        Person2.class_list.append(self)

    def make_friends(self):
        Person2.class_list.remove(self)

    def __repr__(self):
        return self.name


p1 = Person2("Joe")
p2 = Person2("Barack")
print(Person2.class_list)
p1.make_friends()
print(Person2.class_list)

EDIT: Variable 3 when a list of people is inside another class. For accessing a list inside another class you could use attribute name or public method to get it if implemented:

class ClassWithList:
    def __init__(self):
        self.list_collection = []

    def get_list(self):
        return self.list_collection


class_with_list = ClassWithList()


class Person:

    def __init__(self, name):
        self.name = name

    def make_friends(self, list):
        list.remove(self)

    def __repr__(self):
        return self.name


p1 = Person("Joe")
p2 = Person("Barack")
# using implemented get-method of instance list attribute
class_with_list.get_list().append(p1)
class_with_list.get_list().append(p2)
print(class_with_list.get_list())
p1.make_friends(class_with_list.get_list())

print(class_with_list.get_list())

# instance list attribute of class`ClassWithList
print(class_with_list.list_collection)
p2.make_friends(class_with_list.list_collection)
print(class_with_list.list_collection)