conflict in using dictionary with an object instance

Question

class class_name:
    def foo1(self):
        print "foo1"

    def foo2(self):
        print "foo2"

    def foo(self, key):
        self.dictionary[key]()

dictionary = {
'key1' : class_name.foo1,
'key2' : class_name.foo2
}

>>>class_name().foo('key1')

Error: AttributeError: class_name instance has no attribute 'dictionary'

Although I understand the error, I do not know how to rectify it.

Even if I define the dictionary inside the class "by indenting it to be inside the class definition, it then generates the error that NameError: name 'class_name' is not defined"*

Any advice on how to fix this is appreciated.

EDIT: I need a single dictionary for the class, not one dictionary per object instance

A little insight into the real problem: I am making a chess game. So while defining the game logic, each piece has its own style of moving. I wished to call a single function to give me the legal moves as per the current state of the chess board. This single function (in the example foo()) has to call other functions based on the type of the piece and also provide those functions with the object instance (and other parameters), so that they can compute the moves. The problem I face is to pass the object instance to the piece specific functions (foo1() and foo2()).

Maybe this will help. This is what I want to achieve in the function foo():

switch(key){
    case 'key1':
        self.foo1();
        break;
    case 'key2':
        self.foo2();
        break;
}

_{* added from comment}

Answer 1

The problem you have when defining dictionary outside of the class is that the class doesn't have dictionary as attribute. You could fix this doing:

class_name.dictionary = {'foo1': class_name.foo1, 'foo2': class_name.foo2}

after the class definition.

The error you see when defining dictionary inside the class is due to the fact that you cannot reference the class inside the class definition, since when that code is executed the class doesn't exist.

Something you have to rememeber is that python doesn't have any kind of "declaration" statement. All statement execute code. Hence, the body of the class is run by the interpreter inside a new scope and afterwards it sets the created scope as the __dict__ of the class object.

Since the class definition is executed you can reference the foo1 and foo2 functions directly from that scope:

In [9]: class A(object):
   ...:     def foo1(self):
   ...:         print('foo1')
   ...:     def foo2(self):
   ...:         print('foo2')
   ...:     def foo(self, key):
   ...:         self.dictionary[key](self)
   ...:     dictionary = {'foo1': foo1, 'foo2': foo2}  # NOTE: do NOT use cls_name.method

In [10]: a = A()

In [11]: a.foo('foo1')
foo1

In [12]: a.foo('foo2')
foo2

However note that inside the foo method(even with the first solution) you must also manually pass the self parameter.

This happens because when creating the dictionary you are assigning the functions(or unbound-methods in python2) foo1 and foo2, not the instance methods, hence those values do not have information on the instance they are called on.

---

I agree with the other answer, that this kind of pattern isn't really useful since you could use getattr to achieve the same functionality without having to use dicts at all. Simply do getattr(instance, method_name)().

Answer 2

Instead of storing functions in the dictionary, you can store function names and use getattr to access them.

class class_name:
    dictionary = {
    'key1' : 'foo1',
    'key2' : 'foo2'
    }

    def foo1(self):
        print "foo1"

    def foo2(self):
        print "foo2"

    def foo(self, key):
        getattr(self, self.dictionary[key])()

You can now do this

>>> class_name().foo('key1')
foo1

The dictionary is the same for all instances.

>>> c1 = class_name()
>>> c2 = class_name()
>>> c2.dictionary['key3'] = 'foo1'
>>> c1.foo('key3')
foo1

That said, I'm not quite sure what you want to achieve and if that is the right approach.

Why are the piece specific function not part of a piece base class and overwritten in the different specific piece classes? Something like this

class class_name:
    def foo(self, piece):
        print piece.get_valid_moves()

class BasePiece:
    def get_valid_moves():
        raise NotImplementedError

class Queen:
    def get_valid_moves():
        return ['diagonal', 'vertical', 'horizontal']

class Tower:
    def get_valid_moves():
        return ['vertical', 'horizontal']

Answer 3

You have defined dictionary outside your class, so self.dictionary makes no sense.
If you want to have a dictionary in each class instance, set it in __init__ See here for details

Try this

class class_name:
    def foo1(self):
        print "foo1"

    def foo2(self):
        print "foo2"

    def foo(self, key):
        self.dictionary[key]()

    def __init__(self):
        self.dictionary = {
        'key1' : self.foo1,
        'key2' : self.foo2
        }

Edit If you want all instances of class_name to use the same foo1 and foo2 in the same dictionary, and the methods are instance methods, from which instance do you intend to use? Or should the foo1 and foo2 not be instance methods? Why are you even using a class in that case?

Answer 4

You either need to create one object, and pass in this object to the dictionary such as:

my_object = class_name()
dictionary = {
    'key1' : my_object.foo1,
    'key2' : my_object.foo2
}

Or create static methods:

class class_name:
    @staticmethod
    def foo1():
        print "foo1"

    @staticmethod
    def foo2():
        print "foo2"

    def foo(self, key):
        self.dictionary[key]()  # This doesn't make sense, your class doesn't have an attribute called dictionnary

dictionary = {
    'key1' : class_name.foo1,
    'key2' : class_name.foo2
}

EDIT: You do not need a dictionnary for this kind of stuff. Use getattr

Something like:

method = gettatr(my_current_object, 'method_name')
method()