Существование изменяемого именованного кортежа в Python?

похоже, что ответа на этот вопрос нет.

ниже довольно близко, но это технически не изменчиво. Это создание нового namedtuple() экземпляр с обновленным значением x:

Point = namedtuple('Point', ['x', 'y'])
p = Point(0, 0)
p = p._replace(x=10) 

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

class Point:
    __slots__ = ['x', 'y']
    def __init__(self, x, y):
        self.x = x
        self.y = y

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

вот один соответствующий поток, который иллюстрирует эффективность памяти - словарь против объекта-что более эффективно и почему?

цитируемое содержание в ответе этой темы является очень кратким объяснением, почему __slots__ - это более эффективный для памяти Python слоты

последние namedlist 1.7 проходит все ваши тесты с Python 2.7 и Python 3.5 по состоянию на 11 января 2016 года. это чистая реализация python а recordclass это c расширением. Конечно, это зависит от ваших требований, является ли расширение C предпочтительным или нет.

тесты (а также см. Примечание ниже):

from __future__ import print_function
import pickle
import sys
from namedlist import namedlist

Point = namedlist('Point', 'x y')
p = Point(x=1, y=2)

print('1. Mutation of field values')
p.x *= 10
p.y += 10
print('p: {}, {}\n'.format(p.x, p.y))

print('2. String')
print('p: {}\n'.format(p))

print('3. Representation')
print(repr(p), '\n')

print('4. Sizeof')
print('size of p:', sys.getsizeof(p), '\n')

print('5. Access by name of field')
print('p: {}, {}\n'.format(p.x, p.y))

print('6. Access by index')
print('p: {}, {}\n'.format(p[0], p[1]))

print('7. Iterative unpacking')
x, y = p
print('p: {}, {}\n'.format(x, y))

print('8. Iteration')
print('p: {}\n'.format([v for v in p]))

print('9. Ordered Dict')
print('p: {}\n'.format(p._asdict()))

print('10. Inplace replacement (update?)')
p._update(x=100, y=200)
print('p: {}\n'.format(p))

print('11. Pickle and Unpickle')
pickled = pickle.dumps(p)
unpickled = pickle.loads(pickled)
assert p == unpickled
print('Pickled successfully\n')

print('12. Fields\n')
print('p: {}\n'.format(p._fields))

print('13. Slots')
print('p: {}\n'.format(p.__slots__))

вывод на Python 2.7

1. Mutation of field values  
p: 10, 12

2. String  
p: Point(x=10, y=12)

3. Representation  
Point(x=10, y=12) 

4. Sizeof  
size of p: 64 

5. Access by name of field  
p: 10, 12

6. Access by index  
p: 10, 12

7. Iterative unpacking  
p: 10, 12

8. Iteration  
p: [10, 12]

9. Ordered Dict  
p: OrderedDict([('x', 10), ('y', 12)])

10. Inplace replacement (update?)  
p: Point(x=100, y=200)

11. Pickle and Unpickle  
Pickled successfully

12. Fields  
p: ('x', 'y')

13. Slots  
p: ('x', 'y')

единственная разница с Python 3.5 состоит в том, что namedlist стал меньше, размер 56 (Python 2.7 сообщает 64).

обратите внимание, что я изменил ваш тест 10 для замены на месте. The namedlist есть _replace() метод, который делает мелкую копию, и что имеет смысл для меня, потому что namedtuple в стандартной библиотеке ведет себя так же. Изменение семантики _replace() метод будет запутанным. По-моему _update() метод должен использоваться для обновления на месте. Или, может быть, я не понимаю цель вашего теста 10?

типы.SimpleNamespace был введен в Python 3.3 и поддерживает выдвинутые требования.

from types import SimpleNamespace
t = SimpleNamespace(foo='bar')
t.ham = 'spam'
print(t)
namespace(foo='bar', ham='spam')
print(t.foo)
'bar'
import pickle
with open('/tmp/pickle', 'wb') as f:
    pickle.dump(t, f)

следующее хорошее решение для Python 3: Минимальный класс с использованием __slots__ и Sequence абстрактный базовый класс; не делает необычное обнаружение ошибок или такое, но он работает и ведет себя в основном как изменяемый кортеж (за исключением проверки типа).

from collections import Sequence

class NamedMutableSequence(Sequence):
    __slots__ = ()

    def __init__(self, *a, **kw):
        slots = self.__slots__
        for k in slots:
            setattr(self, k, kw.get(k))

        if a:
            for k, v in zip(slots, a):
                setattr(self, k, v)

    def __str__(self):
        clsname = self.__class__.__name__
        values = ', '.join('%s=%r' % (k, getattr(self, k))
                           for k in self.__slots__)
        return '%s(%s)' % (clsname, values)

    __repr__ = __str__

    def __getitem__(self, item):
        return getattr(self, self.__slots__[item])

    def __setitem__(self, item, value):
        return setattr(self, self.__slots__[item], value)

    def __len__(self):
        return len(self.__slots__)

class Point(NamedMutableSequence):
    __slots__ = ('x', 'y')

пример:

>>> p = Point(0, 0)
>>> p.x = 10
>>> p
Point(x=10, y=0)
>>> p.x *= 10
>>> p
Point(x=100, y=0)

если вы хотите, вы можете иметь метод для создания класса тоже (хотя с помощью явного класса больше прозрачный):

def namedgroup(name, members):
    if isinstance(members, str):
        members = members.split()
    members = tuple(members)
    return type(name, (NamedMutableSequence,), {'__slots__': members})

пример:

>>> Point = namedgroup('Point', ['x', 'y'])
>>> Point(6, 42)
Point(x=6, y=42)

---

в Python 2 вам нужно немного настроить его-если вы наследовать от Sequence класс будет __dict__ и __slots__ перестанет работать.

решение в Python 2 не должно наследовать от Sequence, а object. Если isinstance(Point, Sequence) == True желательно, вам нужно зарегистрировать NamedMutableSequence в качестве базового класса для Sequence:

Sequence.register(NamedMutableSequence)

как очень подходящие для Python вариантом для этой задачи, начиная с версии Python-3.7, вы можете использовать dataclasses модуль, который не только ведет себя как Мутабельный NamedTuple поскольку они используют обычные определения классов, они также поддерживают другие функции классов.

от PEP-0557:

хотя они используют совсем другой механизм, классы данных можно рассматривать как"изменяемые namedtuples с настройками по умолчанию". Поскольку классы данных используют обычный синтаксис определения класса, вы можете использовать его бесплатно наследование, метаклассы, docstrings, пользовательские методы, фабрики классов и другие функции класса Python.

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

эта функция введена в PEP-0557 что вы можете узнать об этом более подробно в документации ссылка на сайт.

пример:

In [20]: from dataclasses import dataclass

In [21]: @dataclass
    ...: class InventoryItem:
    ...:     '''Class for keeping track of an item in inventory.'''
    ...:     name: str
    ...:     unit_price: float
    ...:     quantity_on_hand: int = 0
    ...: 
    ...:     def total_cost(self) -> float:
    ...:         return self.unit_price * self.quantity_on_hand
    ...:    

демо:

In [23]: II = InventoryItem('bisc', 2000)

In [24]: II
Out[24]: InventoryItem(name='bisc', unit_price=2000, quantity_on_hand=0)

In [25]: II.name = 'choco'

In [26]: II.name
Out[26]: 'choco'

In [27]: 

In [27]: II.unit_price *= 3

In [28]: II.unit_price
Out[28]: 6000

In [29]: II
Out[29]: InventoryItem(name='choco', unit_price=6000, quantity_on_hand=0)

давайте реализуем это с помощью динамического создания типа:

import copy
def namedgroup(typename, fieldnames):

    def init(self, **kwargs): 
        attrs = {k: None for k in self._attrs_}
        for k in kwargs:
            if k in self._attrs_:
                attrs[k] = kwargs[k]
            else:
                raise AttributeError('Invalid Field')
        self.__dict__.update(attrs)

    def getattribute(self, attr):
        if attr.startswith("_") or attr in self._attrs_:
            return object.__getattribute__(self, attr)
        else:
            raise AttributeError('Invalid Field')

    def setattr(self, attr, value):
        if attr in self._attrs_:
            object.__setattr__(self, attr, value)
        else:
            raise AttributeError('Invalid Field')

    def rep(self):
         d = ["{}={}".format(v,self.__dict__[v]) for v in self._attrs_]
         return self._typename_ + '(' + ', '.join(d) + ')'

    def iterate(self):
        for x in self._attrs_:
            yield self.__dict__[x]
        raise StopIteration()

    def setitem(self, *args, **kwargs):
        return self.__dict__.__setitem__(*args, **kwargs)

    def getitem(self, *args, **kwargs):
        return self.__dict__.__getitem__(*args, **kwargs)

    attrs = {"__init__": init,
                "__setattr__": setattr,
                "__getattribute__": getattribute,
                "_attrs_": copy.deepcopy(fieldnames),
                "_typename_": str(typename),
                "__str__": rep,
                "__repr__": rep,
                "__len__": lambda self: len(fieldnames),
                "__iter__": iterate,
                "__setitem__": setitem,
                "__getitem__": getitem,
                }

    return type(typename, (object,), attrs)

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

так это рассол? Да, если (и только если) вы делаете следующее:

>>> import pickle
>>> Point = namedgroup("Point", ["x", "y"])
>>> p = Point(x=100, y=200)
>>> p2 = pickle.loads(pickle.dumps(p))
>>> p2.x
100
>>> p2.y
200
>>> id(p) != id(p2)
True

определение должно быть в вашем пространстве имен и должно существовать достаточно долго, чтобы рассол его нашел. Поэтому, если вы определяете это, чтобы быть в вашем пакете, он должен работать.

Point = namedgroup("Point", ["x", "y"])

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

some_point = namedgroup("Point", ["x", "y"])

и да, он сохраняет порядок полей, перечисленных в создании типа.

Кортежи по определению неизменяемы.

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

In [1]: %cpaste
Pasting code; enter '--' alone on the line to stop or use Ctrl-D.
:class AttrDict(dict):
:
:    def __getattr__(self, name):
:        return self[name]
:
:    def __setattr__(self, name, value):
:        self[name] = value
:--

In [2]: test = AttrDict()

In [3]: test.a = 1

In [4]: test.b = True

In [5]: test
Out[5]: {'a': 1, 'b': True}

Если вы хотите, чтобы подобное поведение как namedtuples но Мутабельный попробовать namedlist

обратите внимание, что для того, чтобы быть изменяемы это не может кортежа.

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

from collection import namedtuple

Point = namedtuple('Point', 'x y z')
mutable_z = Point(1,2,[3])