Просто определите для этого свой собственный класс:

class Expando(object):
    pass

ex = Expando()
ex.foo = 17
ex.bar = "Hello"

Использование объекта только для хранения значений - не самый питонический стиль программирования. Это распространено в языках программирования, у которых нет хороших ассоциативных контейнеров, но в Python вы можете использовать словарь:

my_dict = {} # empty dict instance

my_dict["foo"] = "bar"
my_dict["num"] = 42

Вы также можете использовать «словарный литерал» для одновременного определения всего содержимого словаря:

my_dict = {"foo":"bar", "num":42}

Или, если все ваши ключи являются законными идентификаторами (и они будут такими, если вы планировали, что они будут именами атрибутов), вы можете использовать конструктор dict с аргументами ключевого слова как пары ключ-значение:

my_dict = dict(foo="bar", num=42) # note, no quotation marks needed around keys

Фактически, заполнение словаря - это то, что Python делает за кулисами, когда вы действительно используете объект, например, в ответе Неда Батчелдера. Атрибуты его ex объекта сохраняются в словаре ex.__dict__, который в конечном итоге должен быть равен эквивалентному dict, созданному напрямую.

Если синтаксис атрибута (например, ex.foo) не является абсолютно необходимым, вы также можете полностью пропустить объект и напрямую использовать словарь.

Если вы воспользуетесь подходом метаклассирования из ответа @Martijn, ответ @Ned можно переписать короче (хотя он, очевидно, менее читабелен, но делает то же самое).

obj = type('Expando', (object,), {})()
obj.foo = 71
obj.bar = 'World'

Или просто, что делает то же самое, что и выше, с использованием аргумента dict:

obj = type('Expando', (object,), {'foo': 71, 'bar': 'World'})()

Для Python 3 передача объекта в аргумент bases необязательна (см. type документация).

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

ns = type('Expando', (object,), {'foo': 71, 'bar': 'World'})

В то же время лично я предпочитаю простой класс (то есть без создания экземпляров) для случаев специальной тестовой конфигурации как наиболее простой и читаемый:

class ns:
    foo = 71
    bar = 'World'

Обновлять

В Python 3.3+ существует именно то, что запрашивает OP, types.SimpleNamespace. Это просто:

Простой подкласс object, который обеспечивает доступ по атрибутам к своему пространству имен, а также к содержательному представлению.

В отличие от object, с SimpleNamespace вы можете добавлять и удалять атрибуты. Если объект SimpleNamespace инициализируется аргументами ключевого слова, они напрямую добавляются в базовое пространство имен.

import types
obj = types.SimpleNamespace()
obj.a = 123
print(obj.a) # 123
print(repr(obj)) # namespace(a=123)

Однако в stdlib как Python 2, так и Python 3 есть argparse.Namespace , который имеет ту же цель:

Простой объект для хранения атрибутов.

Реализует равенство по именам и значениям атрибутов и предоставляет простое строковое представление.

import argparse
obj = argparse.Namespace()
obj.a = 123
print(obj.a) # 123 
print(repr(obj)) # Namespace(a=123)

Обратите внимание, что оба могут быть инициализированы с помощью аргументов ключевого слова:

types.SimpleNamespace(a = 'foo',b = 123)
argparse.Namespace(a = 'foo',b = 123)

Используйте collections.namedtuple() class factory, чтобы создать собственный класс для вашего возврата ценность:

from collections import namedtuple
return namedtuple('Expando', ('dynamic_property_a', 'dynamic_property_b'))('abc', 'abcdefg')

Возвращаемое значение может использоваться как в виде кортежа, так и для доступа к атрибутам:

print retval[0]                  # prints 'abc'
print retval.dynamic_property_b  # prints 'abcdefg'  

Один из способов, который я нашел, - это также создание лямбды. Он может иметь побочные эффекты и обладает некоторыми нежелательными свойствами. Просто публикуйте для интереса.

dynamic_object = lambda:expando
dynamic_object.dynamic_property_a = "abc"
dynamic_object.dynamic_property_b = "abcdefg"

Сначала я определяю словарь, потому что его легко определить. Затем я использую namedtuple, чтобы преобразовать его в объект:

from collections import namedtuple

def dict_to_obj(dict):
    return namedtuple("ObjectName", dict.keys())(*dict.values())

my_dict = {
    'name': 'The mighty object',
    'description': 'Yep! Thats me',
    'prop3': 1234
}
my_obj =  dict_to_obj(my_dict)