如何声明带内联函数的字典

Question

在我可以使用它作为字典的元素之前，我必须正式定义一个函数吗？

def my_func(): 
    print 'my_func' 

d = { 
    'function': my_func 
} 

我宁愿定义函数内联。我只是试图输入我想要做的事情，但python语法的空白策略使得在dict内定义一个内联func非常困难。有没有办法做到这一点？

Answer 1

答案似乎是没有办法在Python内联函数声明为一个字典的定义。感谢所有花时间参与贡献的人。

Answer 2

一些功能可以很容易地“内联”匿名与lambda表达式，例如：

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

但对于任何半复杂（或using语句），你可能只是应事先定义它们。

Answer 3

考虑使用lambda表达式，但请注意，lambda表达式必须是功能，不能包含语句（见http://docs.python.org/reference/expressions.html#lambda）

例如

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

另请注意，在python2中，print不是函数。所以，你需要做的要么：

from __future__ import print_function 

d = { 
    'function': print 
} 

或使用sys.stdout.write代替

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

Answer 4

你真的需要一本字典，或者只是getitem访问？

如果是后者，那么使用类：

>>> 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 5

没有充分的理由要使用Python中的字典来写这个。这很奇怪，并不是命名空间函数的常用方法。

的是，这里采用Python的哲学是：

应该有one--和最好只有一个--obvious办法做到这一点。

结合

可读性计数。

这样做也会使得一些Python用户很难理解和阅读。

字典在这种情况下所做的好处是将字符串映射到函数并在字典中将它们命名空间，但是这个功能已经由模块和类提供，熟悉Python的人更容易理解。

例子：

模块方法：

#cool.py 

def cool(): 
    print 'cool' 

现在使用的模块，就像您使用您的字典：

​​

类方法：

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

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

编辑后评论如下：

argparse似乎很适合这个问题，所以你不必重新发明轮子。如果你决定完全自己实现它，尽管源头应该给你一些好的方向。无论如何，以下部分似乎适用于此用例：

15.4.4.5。超越sys.argv

有时，除了sys.argv的ArgumentParser解析参数 以外可能会有用。这可以通过将 字符串列表传递给parse_args（）来完成。这对于在 交互式提示下进行测试很有用：

15.4.5.1。子commands¶

ArgumentParser.add_subparsers（）

许多程序拆分它们的功能分成若干子命令，例如，使用svn程序可以调用子命令 像svn签，SVN更新，和svn提交。

15.4.4.6。名称空间对象

将ArgumentParser的属性分配给 已存在的对象而非新的命名空间对象也可能有用。这 可以通过指定的命名空间=关键字参数来实现：

更新，这是一个使用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>) 

我想指出的原因一个例子，我会建议argparse

1. 主要需要使用表示选项和子选项的字符串映射到函数。
2. 它很简单（在通过功能填充的argparse模块之后）。
3. 使用Python标准库模块。这让让其他熟悉Python的人不需要深入了解实现细节就可以了解自己的工作，并且对于那些不了解实际情况的人来说，它们的记录非常详尽
4. 许多额外的功能可以利用开箱即用（不是最好的理由！）。

使用argparse和策略模式一起

对于普通和简单的实现策略模式，这已经回答得非常好。

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 

Answer 6

内联函数的要点是模糊词典和类实例之间的区别。例如，在JavaScript中，这种技术使得编写几乎没有重用性的控件类变得非常令人愉快。此外，API非常有用，因此符合众所周知的字典协议，是自解释的（双关意图）。

你可以在python中做到这一点 - 它看起来不像字典！实际上，您可以在任何范围内使用class关键字（即函数中的类def或类def中的类def），并且它的子代可以是您正在寻找的代码;只要检查一个定义的属性就好像它是一个javascript字典。

例子，如果它是真实的：

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

是实际完成的

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

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

这样你就可以说：

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

并以这种方式，你会得到与“内联”相同的逻辑分组。