Являются ли объектные литералы Pythonic?

JavaScript имеет объектные литералы, например

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

и .NET имеет анонимные типы, например

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

Нечто подобное может быть эмулировано в Python по (ab) с использованием именованных аргументов:

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?

Ответ 1

Считаете ли вы использование named tuple?

Использование вашей записи dict

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

лямбда-эквивалент был бы

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

но лично я думаю, что это глупо давать имена "анонимным" функциям

Ответ 2

Почему бы просто не использовать словарь?

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

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

Ответ 3

От ActiveState:

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

# that 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

Ответ 4

Из Python IAQ:

С Python 2.3 вы можете использовать синтаксис
dict(a=1, b=2, c=3, dee=4)
который достаточно хорош, насколько мне известно. Перед Python 2.3 я использовал однострочную функцию
def Dict(**dict): return dict

Ответ 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__.

Я не знаю, является ли это питоническим или нет, но иногда это ускоряет, и для меня это достаточно разумно использовать его (иногда).

Ответ 6

Я думаю, что объектные литералы имеют смысл в JavaScript по двум причинам:

В JavaScript объекты - это только способ создания "вещи" со строковыми индексами. В Python, как указано в другом ответе, тип словаря делает это.
Объектная система JavaScript основана на прототипе. В JavaScript нет такой вещи, как класс (хотя это и происходит в будущей версии) - объекты имеют объекты-прототипы вместо классов. Таким образом, естественно создать объект "из ничего" через литерал, потому что все объекты требуют только встроенного корневого объекта в качестве прототипа. В Python каждый объект имеет класс - вы ожидаете использовать объекты для вещей, где у вас есть несколько экземпляров, а не только для одноразовых.

Таким образом, нет, литералы объектов arent Pythonic, но они являются JavaScripthonic.

Ответ 7

В большинстве случаев достаточно простого словаря.

Если вы ищете аналогичный API для того, который вы указали для буквального случая, вы все равно можете использовать словари и просто переопределить специальный __getattr__:

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

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

Примечание. Имейте в виду, что в отличие от namedtuples, поля не проверяются, и вы отвечаете за то, чтобы ваши аргументы были разумными. Аргументы, такие как p['def'] = 'something' допускаются внутри словаря, но вы не сможете получить к ним доступ через p.def.