对象字面量是 Pythonic 的吗？

Question

JavaScript 有对象文字，例如

var p = {
  name: "John Smith",
  age:  23
}

，.NET 有匿名类型，例如，

var p = new { Name = "John Smith", Age = 23}; // C#

可以通过（ab）使用命名参数在 Python 中模拟类似的东西：

class literal(object):
    def __init__(self, **kwargs):
        for (k,v) in kwargs.iteritems():
            self.__setattr__(k, v)
    def __repr__(self):
        return 'literal(%s)' % ', '.join('%s = %r' % i for i in sorted(self.__dict__.iteritems()))
    def __str__(self):
        return repr(self)

用法：

p = literal(name = "John Smith", age = 23)
print p       # prints: literal(age = 23, name = 'John Smith')
print p.name  # prints: John Smith

但是这种代码被认为是 Pythonic 吗？

Answer 1

为什么不直接使用字典呢？

p = {'name': 'John Smith', 'age': 23}

print p
print p['name']
print p['age']

Answer 2

您是否考虑过使用 命名元组？

使用你的字典表示法

>>> from collections import namedtuple
>>> L = namedtuple('literal', 'name age')(**{'name': 'John Smith', 'age': 23})

或关键字参数

>>> L = namedtuple('literal', 'name age')(name='John Smith', age=23)
>>> L
literal(name='John Smith', age=23)
>>> L.name
'John Smith'
>>> L.age
23

可以很容易地将这种行为包装到一个函数中，

def literal(**kw):
    return namedtuple('literal', kw)(**kw)

就像 lambda 等价物一样，

literal = lambda **kw: namedtuple('literal', kw)(**kw)

但我个人认为给“匿名”函数命名是愚蠢的

Answer 3

来自 ActiveState：

class Bunch:
    def __init__(self, **kwds):
        self.__dict__.update(kwds)

# that's it!  Now, you can create a Bunch
# whenever you want to group a few variables:

point = Bunch(datum=y, squared=y*y, coord=x)

# and of course you can read/write the named
# attributes you just created, add others, del
# some of them, etc, etc:
if point.squared > threshold:
    point.isok = 1

Answer 4

我想说你实现的解决方案看起来很Pythonic；话虽如此，types.SimpleNamespace（记录在此处) 已经封装了这个功能：

from types import SimpleNamespace
p = SimpleNamespace(name = "John Smith", age = 23)
print(p)

Answer 5

我不认为创建“匿名”类/实例有什么问题。在一行代码中通过简单的函数调用来创建一个通常非常方便。我个人使用这样的东西：

def make_class( *args, **attributes ):
    """With fixed inability of using 'name' and 'bases' attributes ;)"""
    if len(args) == 2:
        name, bases = args
    elif len(args) == 1:
        name, bases = args[0], (object, )
    elif not args:
        name, bases = "AnonymousClass", (object, )
    return type( name, bases, attributes )

obj = make_class( something = "some value" )()
print obj.something

对于创建虚拟对象，它工作得很好。 Namedtuple 还可以，但是它是不可变的，这有时会很不方便。字典是......好吧，字典，但在某些情况下，您必须传递定义了 __getattr__ 的内容，而不是 __getitem__ 。

我不知道它是否是Pythonic，但它有时会加快速度，对我来说，这是使用它的充分理由（有时）。

Answer 6

来自 Python IAQ：

从 Python 2.3 开始，您可以使用以下语法

dict(a=1, b=2, c=3, dee=4)

就我而言，这已经足够好了。在Python 2.3之前我使用单行函数

def Dict(**dict): 返回字典

Answer 7

我认为对象字面量在 JavaScript 中有意义有两个原因：

1. 在 JavaScript 中，对象是创建具有字符串索引属性的“事物”的唯一方法。在 Python 中，正如另一个答案中所述，字典类型可以做到这一点。

2. JavaScript 的对象系统是基于原型的。 JavaScript 中没有类这样的东西（尽管它会在未来的版本中出现）——对象具有原型对象而不是类。因此，通过文字“从无到有”创建一个对象是很自然的，因为所有对象只需要内置的根对象作为原型。在Python 中，每个对象都有一个类——您应该将对象用于具有多个实例的事物，而不仅仅是一次性的。

因此，对象字面量不是 Pythonic，但它们是 JavaScripthonic。

Answer 8

对于大多数情况来说，一个简单的字典就足够了。

如果您正在寻找与您为字面情况指定的 API 类似的 API，您仍然可以使用字典并简单地覆盖特殊的 __getattr__ 函数：

class CustomDict(dict):
    def __getattr__(self, name):
        return self[name]

p = CustomDict(user='James', location='Earth')
print p.user
print p.location

注意：请记住，与命名元组相反，字段是未经验证，你有责任确保你的论点是合理的。字典中允许使用诸如 p['def'] = 'something' 之类的参数，但您无法通过 p.def 访问它们。