How to declare a dictionary with inline function

Question

Do I have to formally define a function before I can use it as an element of a dictionary?

def my_func():
  print 'my_func'

d = {
  'function': my_func
}

I would rather define the function inline. I just tried to type out what I want to do, but the whitespace policies of python syntax make it very hard to define an inline func within a dict. Is there any way to do this?

Answer 1

The answer seems to be that there is no way to declare a function inline a dictionary definition in python. Thanks to everyone who took the time to contribute.

Answer 2

Do you really need a dictionary, or just getitem access?

If the latter, then use a class:

>>> class Dispatch(object):
...     def funcA(self, *args):
...         print('funcA%r' % (args,))
...     def funcB(self, *args):
...         print('funcB%r' % (args,))
...     def __getitem__(self, name):
...         return getattr(self, name)
... 
>>> d = Dispatch()
>>> 
>>> d['funcA'](1, 2, 3)
funcA(1, 2, 3)

Answer 3

You could use a decorator:

func_dict = {}

def register(func):
    func_dict[func.__name__] = func
    return func

@register
def a_func():
    pass

@register
def b_func():
    pass

The func_dict will end up mapping using the entire name of the function:

>>> func_dict
{'a_func': <function a_func at 0x000001F6117BC950>, 'b_func': <function b_func at 0x000001F6117BC8C8>}

You can modify the key used by register as desired. The trick is that we use the __name__ attribute of the function to get the appropriate string.

Answer 4

Consider using lambdas, but note that lambdas can only consist of one expression and cannot contain statements (see http://docs.python.org/reference/expressions.html#lambda).

e.g.

d = { 'func': lambda x: x + 1 }
# call d['func'](2) will return 3

Also, note that in Python 2, print is not a function. So you have to do either:

from __future__ import print_function

d = {
    'function': print
}

or use sys.stdout.write instead

d = {
    'function': sys.stdout.write
}

Answer 5

The point of inlining functions is to blur the distinction between dictionaries and class instances. In javascript, for example, this techinque makes it very pleasant to write control classes that have little reusability. Also, and very helpfully the API then conforms to the well-known dictionary protocols, being self explanatory (pun intended).

You can do this in python - it just doesn't look like a dictionary! In fact, you can use the class keyword in ANY scope (i.e. a class def in a function, or a class def inside of a class def), and it's children can be the dictonary you are looking for; just inspect the attributes of a definition as if it was a javascript dictionary.

Example as if it was real:

somedict = {
    "foo":5,
    "one_function":your method here,
    "two_function":your method here,
}

Is actually accomplished as

class somedict:
    foo = 5
    @classmethod
    def one_method(self):
        print self.foo
        self.foo *= 2;

    @classmethod
    def two_method(self):
        print self.foo

So that you can then say:

somedict.foo          #(prints 5)
somedict.one_method() #(prints 5)
somedict.two_method() #(prints 10)

And in this way, you get the same logical groupings as you would with your "inlining".

Answer 6

Some functions can be easily 'inlined' anonymously with lambda expressions, e.g.:

>>> d={'function': lambda x : x**2}
>>> d['function'](5)
25

But for anything semi-complex (or using statements) you probably just should define them beforehand.

Answer 7

There is no good reason to want to write this using a dictionary in Python. It's strange and is not a common way to namespace functions.

The the Python philosophies that apply here are:

There should be one-- and preferably only one --obvious way to do it.

Combined with

Readability counts.

Doing it this way also makes things hard to understand and read for the typical Python user.

The good things the dictionary does in this case is map strings to functions and namespace them within a dictionary, but this functionality is already provided by both modules and classes and it's much easier to understand by those familiar with Python.

Examples:

Module method:

#cool.py

def cool():
    print 'cool'

Now use the module like you would be using your dict:

import cool
#cool.__dict__['cool']()
#update - to the more correct idiom vars
vars(cool)['cool']()

Class method:

class Cool():
    def cool():
        print 'cool'

#Cool.__dict__['cool']()
#update - to the more correct idiom vars
vars(Cool)['cool']()

Edit after comment below:

argparse seems like a good fit for this problem, so you don't have to reinvent the wheel. If you do decide to implement it completely yourself though argparse source should give you some good direction. Anyways the sections below seem to apply to this use case:

15.4.4.5. Beyond sys.argv

Sometimes it may be useful to have an ArgumentParser parse arguments other than those of sys.argv. This can be accomplished by passing a list of strings to parse_args(). This is useful for testing at the interactive prompt:

15.4.5.1. Sub-commands¶

ArgumentParser.add_subparsers()

Many programs split up their functionality into a number of sub-commands, for example, the svn program can invoke sub-commands like svn checkout, svn update, and svn commit.

15.4.4.6. The Namespace object

It may also be useful to have an ArgumentParser assign attributes to an already existing object, rather than a new Namespace object. This can be achieved by specifying the namespace= keyword argument:

Update, here's an example using argparse

strategizer = argparse.ArgumentParser()
strat_subs = strategizer.add_subparsers()
math = strat_subs.add_parser('math')
math_subs = math.add_subparsers()
math_max = math_subs.add_parser('max')
math_sum = math_subs.add_parser('sum')
math_max.set_defaults(strategy=max)
math_sum.set_defaults(strategy=sum)

strategizer.parse_args('math max'.split())
Out[46]: Namespace(strategy=<built-in function max>)

strategizer.parse_args('math sum'.split())
Out[47]: Namespace(strategy=<built-in function sum>)

I would like to note the reasons I would recommend argparse

1. Mainly the requirement to use strings that represent options and sub options to map to functions.
2. It's dead simple (after getting past the feature filled argparse module).
3. Uses a Python Standard Library Module. This let's others familiar with Python grok what your doing without getting into implementation details, and is very well documented for those who aren't.
4. Many extra features could be taken advantage of out of the box (not the best reason!).

Using argparse and Strategy Pattern together

For the plain and simple implementation of the Strategy Pattern, this has already been answered very well.

How to write Strategy Pattern in Python differently than example in Wikipedia?

#continuing from the above example
class MathStudent():
    def do_math(self, numbers):
        return self.strategy(numbers)


maximus = strategizer.parse_args('math max'.split(),
                                  namespace=MathStudent())

sumera = strategizer.parse_args('math sum'.split(),
                                 namespace=MathStudent())

maximus.do_math([1, 2, 3])
Out[71]: 3

sumera.do_math([1, 2, 3])
Out[72]: 6