Можно ли создавать анонимные объекты в Python?

Мне нравится решение Tetha, но оно излишне сложное.

Вот что-то проще:

>>> class MicroMock(object):
...     def __init__(self, **kwargs):
...         self.__dict__.update(kwargs)
...
>>> def print_foo(x):
...     print x.foo
...
>>> print_foo(MicroMock(foo=3))
3

Я нашел это: http://www.hydrogen18.com/blog/python-anonymous-objects.html, и в моем ограниченном тестировании кажется, что это работает:

>>> obj = type('',(object,),{"foo": 1})()
>>> obj.foo
1

Такой краткий, такой Питон! о.о

>>> Object = lambda **kwargs: type("Object", (), kwargs)

Затем вы можете использовать Object в качестве универсального конструктора объектов:

>>> person = Object(name = "Bernhard", gender = "male", age = 42)
>>> person.name
'Bernhard'
>>>

РЕДАКТИРОВАТЬ: Хорошо, технически это создает объект класса, а не объект объекта. Но вы можете рассматривать его как анонимный объект или изменить первую строку, добавив пару круглых скобок, чтобы немедленно создать экземпляр:

>>> Object = lambda **kwargs: type("Object", (), kwargs)()

Посмотри на это:

class MiniMock(object):
    def __new__(cls, **attrs):
        result = object.__new__(cls)
        result.__dict__ = attrs
        return result

def print_foo(x):
    print x.foo

print_foo(MiniMock(foo=3))

Возможно, вы можете использовать namedtuple, чтобы решить эту проблему следующим образом:

from collections import namedtuple
Mock = namedtuple('Mock', ['foo'])

mock = Mock(foo=1)
mock.foo  // 1

Еще один очевидный взлом:

class foo1: x=3; y='y'
class foo2: y=5; x=6

print(foo1.x, foo2.y)

Но для вашего точного варианта использования, вызывая функцию с анонимными объектами напрямую, я не знаю ни одной строчки, менее подробной, чем

myfunc(type('', (object,), {'foo': 3},), type('', (object,), {'foo': 4}))

Некрасиво, работает, но не совсем.

Начиная с Python 3.3 существует types.SimpleNamespace, который делает именно то, что ты хочешь:

myfunc([types.SimpleNamespace(foo=1), types.SimpleNamespace(foo=2), types.SimpleNamespace(foo=3), types.SimpleNamespace(foo=4)])

Это немного многословно, но вы можете убрать это с помощью псевдонима:

_ = types.SimpleNamespace
myfunc([_(foo=1), _(foo=2), _(foo=3), _(foo=4)])

И теперь это на самом деле довольно близко к вымышленному синтаксису в вашем вопросе.

anonymous_object = type('',(),{'name':'woody', 'age':'25'})()
anonymous_object.name
> 'woody'

Есть крутой способ, но сложный для понимания. Он использует type() для создания безымянного класса с параметрами инициализации по умолчанию, затем инициализирует его без каких-либо параметров и получает анонимный объект.

Не классный:

def mock(**attrs):
    r = lambda:0
    r.__dict__ = attrs
    return r 

def test(a, b, c, d):
    print a.foo, b.foo, c.foo, d.foo

test(*[mock(foo=i) for i in xrange(1,5)])
# or
test(mock(foo=1), mock(foo=2), mock(foo=3), mock(foo=4))

буду использовать лямбду

obj = lambda: None
obj.s = 'abb'
obj.i = 122

Вот как я это сделал:

from mock import patch
import requests

class MockResponse:

    def __init__(self, text, status_code):
        self.text = text
        self.status_code = status_code


class TestSomething(unittest.TestCase):

    @patch('requests.get',return_value=MockResponse('the result',200))
    def test_some_request(self, *args, **kwargs):
        response = requests.get('some.url.com')
        assert response.text=='the result'
        assert response.status_code=='200'

Если вы используете Python 3.7 или выше, вы можете использовать именованные кортежи, чтобы улучшить созданный объект с помощью неизменяемости, строки документации и удобных методов кортежа:

from collections import namedtuple

PyObj = lambda **kwargs: namedtuple('PyObj', kwargs.keys())._make(kwargs.values())

o = PyObj(foo = 1)
print(o)
# prints: PyObj(foo=1)
o.foo
# returns: 1
o.foo = 0
# exception:
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# AttributeError: can't set attribute

print(PyObj(foo = 1, bar = 'baz'))
# prints: PyObj(foo=1, bar='baz')

Требуется Python 3.7+, чтобы ключи и значения находились в одном порядке.

Однако, если список атрибутов предопределен, вы можете использовать namedtuple напрямую, как было предложено Huachao, нет необходимости определять PyObj, и вы можете использовать ее в версии 2.7.

from collections import namedtuple
foo = namedtuple('Foo', 'foo')

myfunc = lambda l: [x.foo * 10 for x in l]
myfunc([foo(1), foo(2), foo(3), foo(4)])
# returns [10, 20, 30, 40]

Кроме того, это больше похоже на синтаксис, который вы ищете.

Да, мне очень не хватало простых анонимных объектов в JavaScript, особенно в возвращаемых значениях функций, где можно просто сказать

function george() { 
    return {fred:6, jim:9}; 
}
x = george();
y = x.fred;

Вы можете использовать словарь, чтобы получить тот же эффект, но все эти квадратные скобки и одинарные кавычки выглядят грязно. Итак, теперь я делаю следующее, что работает:

def fred():
    class rv:
        x=0
    rv.y = 6
    return rv

def jim():
    class rv:
        x=0
    rv.y = 9
    return rv
a = fred()
b = jim()
print(a.y, b.y, id(a.y), id(b.y))

Было бы лучше иметь глобальный класс RV и создавать его экземпляры для получения того же эффекта, но таким образом функция не имеет внешних зависимостей.