การมีอยู่ของทูเปิลที่ไม่เปลี่ยนชื่อใน Python?

ใครสามารถแก้ไขnametupleหรือจัดเตรียมคลาสทางเลือกเพื่อให้ทำงานกับวัตถุที่เปลี่ยนแปลงได้?

เพื่อความสามารถในการอ่านเป็นหลักฉันต้องการสิ่งที่คล้ายกับ namedtuple ที่ทำสิ่งนี้:

from Camelot import namedgroup

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

>>> p
Point(x=10, y=0)

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

ต้องเป็นไปได้ที่จะดองวัตถุที่เป็นผลลัพธ์ และตามลักษณะของชื่อทูเปิลลำดับของเอาต์พุตเมื่อแสดงจะต้องตรงกับลำดับของรายการพารามิเตอร์เมื่อสร้างวัตถุ

มีทางเลือกที่ไม่แน่นอนคือการcollections.namedtuple- recordclass

มี API และหน่วยความจำเหมือนกันnamedtupleและรองรับการมอบหมายงาน (ควรเร็วกว่าด้วย) ตัวอย่างเช่น:

from recordclass import recordclass

Point = recordclass('Point', 'x y')

>>> p = Point(1, 2)
>>> p
Point(x=1, y=2)
>>> print(p.x, p.y)
1 2
>>> p.x += 2; p.y += 3; print(p)
Point(x=3, y=5)

สำหรับ python 3.6 และสูงกว่าrecordclass(ตั้งแต่ 0.5) การสนับสนุน typehints:

from recordclass import recordclass, RecordClass

class Point(RecordClass):
   x: int
   y: int

>>> Point.__annotations__
{'x':int, 'y':int}
>>> p = Point(1, 2)
>>> p
Point(x=1, y=2)
>>> print(p.x, p.y)
1 2
>>> p.x += 2; p.y += 3; print(p)
Point(x=3, y=5)

มีตัวอย่างที่สมบูรณ์มากขึ้น(รวมถึงการเปรียบเทียบประสิทธิภาพด้วย)

เนื่องจากrecordclassไลบรารี0.9 มีตัวแปรอื่น - recordclass.structclassฟังก์ชันโรงงาน สามารถสร้างคลาสซึ่งอินสแตนซ์ใช้หน่วยความจำน้อยกว่า__slots__อินสแตนซ์พื้นฐาน สิ่งนี้มีความสำคัญสำหรับอินสแตนซ์ที่มีค่าแอตทริบิวต์ซึ่งไม่ได้ตั้งใจให้มีรอบการอ้างอิง อาจช่วยลดการใช้หน่วยความจำหากคุณต้องการสร้างอินสแตนซ์หลายล้านอินสแตนซ์ นี่คือตัวอย่างเช่น

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

ในฐานะที่เป็นทางเลือก Pythonic สำหรับงานนี้เนื่องจาก Python-3.7 คุณสามารถใช้ dataclassesโมดูลที่ไม่เพียง แต่มีพฤติกรรมไม่แน่นอนNamedTupleเนื่องจากใช้นิยามคลาสปกติ แต่ยังรองรับคุณสมบัติคลาสอื่น ๆ

จาก PEP-0557:

แม้ว่าจะใช้กลไกที่แตกต่างกันมาก แต่ Data Classes อาจถูกคิดว่าเป็น "ชื่อที่เปลี่ยนแปลงได้โดยมีค่าเริ่มต้น" เนื่องจากคลาสข้อมูลใช้ไวยากรณ์นิยามคลาสปกติคุณจึงมีอิสระที่จะใช้การสืบทอด metaclasses 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)

ล่าสุดnamedlist 1.7 ผ่านการทดสอบทั้งหมดของคุณกับทั้งงูหลาม 2.7 และ Python 3.5ณ วันที่ 11 ม.ค. 2016 มันเป็นการนำงูหลามบริสุทธิ์ในขณะที่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. การกลายพันธุ์ของค่าฟิลด์  
p: 10, 12

2. สตริง  
p: จุด (x = 10, y = 12)

3. การเป็นตัวแทน  
จุด (x = 10, y = 12) 

4. ขนาดของ  
ขนาด p: 64 

5. เข้าถึงตามชื่อเขตข้อมูล  
p: 10, 12

6. เข้าถึงโดยดัชนี  
p: 10, 12

7. แกะกล่องซ้ำ  
p: 10, 12

8. การทำซ้ำ  
p: [10, 12]

9. สั่ง Dict  
p: OrderDict ([('x', 10), ('y', 12)])

10. การเปลี่ยนแทนที่ (อัพเดต?)  
p: จุด (x = 100, y = 200)

11. ดองและแกะ  
ดองสำเร็จ

12. ทุ่งนา  
p: ('x', 'y')

13. สล็อต  
p: ('x', 'y')

ข้อแตกต่างเพียงอย่างเดียวกับ Python 3.5 คือnamedlistมีขนาดเล็กลงคือ 56 (Python 2.7 รายงาน 64)

โปรดทราบว่าฉันได้เปลี่ยนการทดสอบ 10 ของคุณสำหรับการแทนที่แบบแทนที่ namedlistมี_replace()วิธีการที่ไม่สำเนาตื้นและที่ทำให้รู้สึกดีกับผมเพราะnamedtupleในห้องสมุดมาตรฐานพฤติกรรมในลักษณะเดียวกัน การเปลี่ยนความหมายของ_replace()วิธีการจะทำให้เกิดความสับสน ในความคิดของฉัน_update()ควรใช้วิธีการสำหรับการอัปเดตแบบแทนที่ หรือบางทีฉันอาจไม่เข้าใจเจตนาของการทดสอบ 10 ของคุณ?

ดูเหมือนว่าคำตอบสำหรับคำถามนี้คือไม่

ด้านล่างค่อนข้างใกล้ แต่ก็ไม่เปลี่ยนแปลงในทางเทคนิค นี่คือการสร้าง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__ใช้ที่นี่ได้ดีเพราะหน่วยความจำมีประสิทธิภาพเมื่อคุณสร้างอินสแตนซ์คลาสจำนวนมาก ข้อเสียเพียงอย่างเดียวคือคุณไม่สามารถสร้างแอตทริบิวต์คลาสใหม่ได้

นี่คือหัวข้อที่เกี่ยวข้องซึ่งแสดงให้เห็นถึงประสิทธิภาพของหน่วยความจำ - Dictionary vs Object - ซึ่งมีประสิทธิภาพมากกว่าและทำไม

เนื้อหาที่ยกมาในคำตอบของเธรดนี้เป็นคำอธิบายที่รวบรัดมากว่าทำไม__slots__หน่วยความจำจึงมีประสิทธิภาพมากกว่า - สล็อต Python

ต่อไปนี้เป็นทางออกที่ดีสำหรับ 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คลาสจะมี a__dict__และ__slots__จะหยุดทำงาน

วิธีแก้ปัญหาใน Python 2 คือการไม่สืบทอดจากSequenceแต่object. หากisinstance(Point, Sequence) == Trueต้องการคุณต้องลงทะเบียน NamedMutableSequenceเป็นคลาสพื้นฐานเพื่อSequence:

Sequence.register(NamedMutableSequence)

มาใช้สิ่งนี้กับการสร้างประเภทไดนามิก:

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

Pickle จะล้มเหลวหากคุณทำสิ่งต่อไปนี้หรือกำหนดนิยามชั่วคราว (ออกไปนอกขอบเขตเมื่อฟังก์ชันสิ้นสุดลงพูด):

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

และใช่มันจะรักษาลำดับของฟิลด์ที่แสดงรายการในการสร้างชนิด

Tuples เป็นไปตามความหมายที่ไม่เปลี่ยนรูป

อย่างไรก็ตามคุณสามารถสร้างคลาสย่อยของพจนานุกรมที่คุณสามารถเข้าถึงแอตทริบิวต์ด้วยเครื่องหมายจุด

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}

หากคุณต้องการลักษณะการทำงานที่คล้ายกับชื่อรายการ แต่ไม่สามารถเปลี่ยนแปลงได้ให้ลองชื่อรายการ

โปรดทราบว่าเพื่อให้สามารถเปลี่ยนแปลงได้จะต้องไม่เป็นทูเพิล

ประสิทธิภาพที่ให้มานั้นมีความสำคัญเพียงเล็กน้อยเราสามารถใช้แฮ็คโง่ ๆ เช่น:

from collection import namedtuple

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