Apakah ada cara untuk dengan mudah mendefinisikan struktur mirip-C dalam Python? Saya lelah menulis hal-hal seperti:

class MyStruct():
    def __init__(self, field1, field2, field3):
        self.field1 = field1
        self.field2 = field2
        self.field3 = field3

Gunakan tuple bernama , yang ditambahkan ke modul koleksi di perpustakaan standar di Python 2.6. Anda juga dapat menggunakan resep tuple bernama Raymond Hettinger jika Anda perlu mendukung Python 2.4.

Ini bagus untuk contoh dasar Anda, tetapi juga mencakup banyak kasus tepi yang mungkin Anda temui nanti. Fragmen Anda di atas akan ditulis sebagai:

from collections import namedtuple
MyStruct = namedtuple("MyStruct", "field1 field2 field3")

Jenis yang baru dibuat dapat digunakan seperti ini:

m = MyStruct("foo", "bar", "baz")

Anda juga dapat menggunakan argumen bernama:

m = MyStruct(field1="foo", field2="bar", field3="baz")

Pembaruan : Kelas Data

Dengan diperkenalkannya Kelas Data di Python 3.7 kami menjadi sangat dekat.

Contoh berikut mirip dengan contoh NamedTuple di bawah ini, tetapi objek yang dihasilkan bisa berubah dan memungkinkan untuk nilai-nilai default.

from dataclasses import dataclass


@dataclass
class Point:
    x: float
    y: float
    z: float = 0.0


p = Point(1.5, 2.5)

print(p)  # Point(x=1.5, y=2.5, z=0.0)

Ini berfungsi baik dengan modul pengetikan baru jika Anda ingin menggunakan anotasi jenis yang lebih spesifik.

Saya sudah menunggu dengan putus asa untuk ini! Jika Anda bertanya kepada saya, Kelas Data dan deklarasi NamedTuple baru , dikombinasikan dengan modul pengetikan adalah anugerah!

Deklarasi NamedTuple yang ditingkatkan

Sejak Python 3.6 itu menjadi sangat sederhana dan indah (IMHO), selama Anda dapat hidup dengan kekekalan .

Cara baru untuk mendeklarasikan NamedTuples diperkenalkan, yang memungkinkan anotasi jenis juga:

from typing import NamedTuple


class User(NamedTuple):
    name: str


class MyStruct(NamedTuple):
    foo: str
    bar: int
    baz: list
    qux: User


my_item = MyStruct('foo', 0, ['baz'], User('peter'))

print(my_item) # MyStruct(foo='foo', bar=0, baz=['baz'], qux=User(name='peter'))

Anda dapat menggunakan tuple untuk banyak hal di mana Anda akan menggunakan struct di C (misalnya x, y koordinat atau warna RGB misalnya).

Untuk yang lainnya, Anda dapat menggunakan kamus, atau kelas utilitas seperti ini :

>>> class Bunch:
...     def __init__(self, **kwds):
...         self.__dict__.update(kwds)
...
>>> mystruct = Bunch(field1=value1, field2=value2)

Saya pikir diskusi "pasti" ada di sini , dalam versi yang diterbitkan dari Python Cookbook.

Mungkin Anda mencari Structs tanpa konstruktor:

class Sample:
  name = ''
  average = 0.0
  values = None # list cannot be initialized here!


s1 = Sample()
s1.name = "sample 1"
s1.values = []
s1.values.append(1)
s1.values.append(2)
s1.values.append(3)

s2 = Sample()
s2.name = "sample 2"
s2.values = []
s2.values.append(4)

for v in s1.values:   # prints 1,2,3 --> OK.
  print v
print "***"
for v in s2.values:   # prints 4 --> OK.
  print v

Bagaimana dengan kamus?

Sesuatu seperti ini:

myStruct = {'field1': 'some val', 'field2': 'some val'}

Kemudian Anda bisa menggunakan ini untuk memanipulasi nilai:

print myStruct['field1']
myStruct['field2'] = 'some other values'

Dan nilainya tidak harus berupa string. Mereka bisa menjadi hampir semua objek lain.

dF: itu sangat keren ... Saya tidak tahu bahwa saya bisa mengakses bidang dalam kelas menggunakan dict.

Mark: situasi yang kuharap aku punya ini tepatnya ketika aku menginginkan sebuah tuple tetapi tidak ada yang seberat kamus.

Anda dapat mengakses bidang kelas menggunakan kamus karena bidang kelas, metode, dan semua propertinya disimpan secara internal menggunakan dicts (setidaknya dalam CPython).

... Yang mengarahkan kami ke komentar kedua Anda. Percaya bahwa perintah Python "berat" adalah konsep yang sangat non-pythonistik. Dan membaca komentar seperti itu membunuh Python Zen saya. Itu tidak baik.

Anda tahu, ketika Anda mendeklarasikan kelas Anda sebenarnya membuat pembungkus yang cukup rumit di sekitar kamus - jadi, jika ada, Anda menambahkan lebih banyak overhead daripada menggunakan kamus sederhana. Bagaimanapun juga, overhead yang tidak ada artinya. Jika Anda bekerja pada aplikasi kritis kinerja, gunakan C atau sesuatu.

Anda bisa subkelas struktur C yang tersedia di perpustakaan standar. The ctypes modul menyediakan kelas Struktur . Contoh dari dokumen:

>>> from ctypes import *
>>> class POINT(Structure):
...     _fields_ = [("x", c_int),
...                 ("y", c_int)]
...
>>> point = POINT(10, 20)
>>> print point.x, point.y
10 20
>>> point = POINT(y=5)
>>> print point.x, point.y
0 5
>>> POINT(1, 2, 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: too many initializers
>>>
>>> class RECT(Structure):
...     _fields_ = [("upperleft", POINT),
...                 ("lowerright", POINT)]
...
>>> rc = RECT(point)
>>> print rc.upperleft.x, rc.upperleft.y
0 5
>>> print rc.lowerright.x, rc.lowerright.y
0 0
>>>

Saya juga ingin menambahkan solusi yang menggunakan slot :

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

Jelas memeriksa dokumentasi untuk slot tetapi penjelasan cepat slot adalah bahwa itu adalah cara python mengatakan: "Jika Anda dapat mengunci atribut ini dan hanya atribut ini ke dalam kelas sehingga Anda berkomitmen bahwa Anda tidak akan menambahkan atribut baru setelah kelas instantiated (ya Anda dapat menambahkan atribut baru ke instance kelas, lihat contoh di bawah) maka saya akan menghapus alokasi memori besar yang memungkinkan untuk menambahkan atribut baru ke instance kelas dan menggunakan apa yang saya butuhkan untuk atribut slotted ini ".

Contoh menambahkan atribut ke instance kelas (sehingga tidak menggunakan slot):

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p1 = Point(3,5)
p1.z = 8
print(p1.z)

Output: 8

Contoh mencoba menambahkan atribut ke instance kelas di mana slot digunakan:

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

p1 = Point(3,5)
p1.z = 8

Output: AttributeError: objek 'Point' tidak memiliki atribut 'z'

Ini secara efektif dapat berfungsi sebagai struct dan menggunakan memori lebih sedikit daripada kelas (seperti struct akan, meskipun saya belum meneliti persis berapa banyak). Disarankan untuk menggunakan slot jika Anda akan membuat banyak instance objek dan tidak perlu menambahkan atribut. Objek titik adalah contoh yang baik dari ini karena ada kemungkinan bahwa orang dapat instantiate banyak poin untuk menggambarkan dataset.

Anda juga dapat meneruskan parameter init ke variabel instan dengan posisi

# Abstract struct class       
class Struct:
    def __init__ (self, *argv, **argd):
        if len(argd):
            # Update by dictionary
            self.__dict__.update (argd)
        else:
            # Update by position
            attrs = filter (lambda x: x[0:2] != "__", dir(self))
            for n in range(len(argv)):
                setattr(self, attrs[n], argv[n])

# Specific class
class Point3dStruct (Struct):
    x = 0
    y = 0
    z = 0

pt1 = Point3dStruct()
pt1.x = 10

print pt1.x
print "-"*10

pt2 = Point3dStruct(5, 6)

print pt2.x, pt2.y
print "-"*10

pt3 = Point3dStruct (x=1, y=2, z=3)
print pt3.x, pt3.y, pt3.z
print "-"*10

Setiap kali saya membutuhkan "objek data instan yang juga berperilaku seperti kamus" (Saya tidak memikirkan C struct!), Saya memikirkan hack lucu ini:

class Map(dict):
    def __init__(self, **kwargs):
        super(Map, self).__init__(**kwargs)
        self.__dict__ = self

Sekarang Anda bisa mengatakan:

struct = Map(field1='foo', field2='bar', field3=42)

self.assertEquals('bar', struct.field2)
self.assertEquals(42, struct['field3'])

Sangat berguna untuk saat-saat ketika Anda membutuhkan "tas data yang BUKAN kelas", dan untuk saat namatuple tidak dapat dipahami ...

Anda mengakses struct C-Style dalam python dengan cara berikut.

class cstruct:
    var_i = 0
    var_f = 0.0
    var_str = ""

jika Anda hanya ingin menggunakan objek cuct

obj = cstruct()
obj.var_i = 50
obj.var_f = 50.00
obj.var_str = "fifty"
print "cstruct: obj i=%d f=%f s=%s" %(obj.var_i, obj.var_f, obj.var_str)

jika Anda ingin membuat array objek cstruct

obj_array = [cstruct() for i in range(10)]
obj_array[0].var_i = 10
obj_array[0].var_f = 10.00
obj_array[0].var_str = "ten"

#go ahead and fill rest of array instaces of struct

#print all the value
for i in range(10):
    print "cstruct: obj_array i=%d f=%f s=%s" %(obj_array[i].var_i, obj_array[i].var_f, obj_array[i].var_str)

Catatan: alih-alih nama 'cstruct', harap gunakan nama struct Anda alih-alih var_i, var_f, var_str, harap tentukan variabel anggota struktur Anda.

Beberapa jawaban di sini sangat rumit. Opsi paling sederhana yang saya temukan adalah (dari: http://norvig.com/python-iaq.html ):

class Struct:
    "A structure that can have any fields defined."
    def __init__(self, **entries): self.__dict__.update(entries)

Inisialisasi:

>>> options = Struct(answer=42, linelen=80, font='courier')
>>> options.answer
42

menambahkan lebih banyak:

>>> options.cat = "dog"
>>> options.cat
dog

sunting: Maaf tidak melihat contoh ini lebih jauh ke bawah.

Ini mungkin agak terlambat tapi saya membuat solusi menggunakan Python Meta-Classes (versi dekorator di bawah ini juga).

Ketika __init__dipanggil pada saat run time, ia mengambil setiap argumen dan nilainya dan menetapkannya sebagai variabel instan ke kelas Anda. Dengan cara ini Anda bisa membuat kelas struct-like tanpa harus menetapkan setiap nilai secara manual.

Contoh saya tidak memiliki pengecekan kesalahan sehingga lebih mudah diikuti.

class MyStruct(type):
    def __call__(cls, *args, **kwargs):
        names = cls.__init__.func_code.co_varnames[1:]

        self = type.__call__(cls, *args, **kwargs)

        for name, value in zip(names, args):
            setattr(self , name, value)

        for name, value in kwargs.iteritems():
            setattr(self , name, value)
        return self 

Ini dia beraksi.

>>> class MyClass(object):
    __metaclass__ = MyStruct
    def __init__(self, a, b, c):
        pass


>>> my_instance = MyClass(1, 2, 3)
>>> my_instance.a
1
>>> 

Saya diposting di reddit dan / u / matchu memposting versi dekorator yang lebih bersih. Saya mendorong Anda untuk menggunakannya kecuali jika Anda ingin memperluas versi metaclass.

>>> def init_all_args(fn):
    @wraps(fn)
    def wrapped_init(self, *args, **kwargs):
        names = fn.func_code.co_varnames[1:]

        for name, value in zip(names, args):
            setattr(self, name, value)

        for name, value in kwargs.iteritems():
            setattr(self, name, value)

    return wrapped_init

>>> class Test(object):
    @init_all_args
    def __init__(self, a, b):
        pass


>>> a = Test(1, 2)
>>> a.a
1
>>> 

Saya menulis dekorator yang dapat Anda gunakan pada metode apa saja untuk membuatnya sehingga semua argumen yang diteruskan, atau default apa pun, ditetapkan ke instance.

def argumentsToAttributes(method):
    argumentNames = method.func_code.co_varnames[1:]

    # Generate a dictionary of default values:
    defaultsDict = {}
    defaults = method.func_defaults if method.func_defaults else ()
    for i, default in enumerate(defaults, start = len(argumentNames) - len(defaults)):
        defaultsDict[argumentNames[i]] = default

    def newMethod(self, *args, **kwargs):
        # Use the positional arguments.
        for name, value in zip(argumentNames, args):
            setattr(self, name, value)

        # Add the key word arguments. If anything is missing, use the default.
        for name in argumentNames[len(args):]:
            setattr(self, name, kwargs.get(name, defaultsDict[name]))

        # Run whatever else the method needs to do.
        method(self, *args, **kwargs)

    return newMethod

Peragaan cepat. Perhatikan bahwa saya menggunakan argumen posisi a, gunakan nilai default untuk b, dan argumen bernama c. Saya kemudian mencetak semua 3 referensi self, untuk menunjukkan bahwa mereka telah ditugaskan dengan benar sebelum metode dimasukkan.

class A(object):
    @argumentsToAttributes
    def __init__(self, a, b = 'Invisible', c = 'Hello'):
        print(self.a)
        print(self.b)
        print(self.c)

A('Why', c = 'Nothing')

Perhatikan bahwa dekorator saya harus bekerja dengan metode apa pun, bukan hanya __init__.

Saya tidak melihat jawaban ini di sini, jadi saya pikir saya akan menambahkannya karena saya condong ke Python sekarang dan baru saja menemukannya. The Python tutorial (Python 2 dalam hal ini) memberikan sederhana berikut dan contoh yang efektif:

class Employee:
    pass

john = Employee()  # Create an empty employee record

# Fill the fields of the record
john.name = 'John Doe'
john.dept = 'computer lab'
john.salary = 1000

Yaitu, objek kelas kosong dibuat, kemudian dipakai, dan bidang ditambahkan secara dinamis.

Sisi baiknya adalah ini sangat sederhana. Kelemahannya adalah tidak mendokumentasikan diri sendiri (anggota yang dituju tidak terdaftar di manapun di "definisi" kelas), dan bidang yang tidak disetel dapat menyebabkan masalah saat diakses. Kedua masalah tersebut dapat diselesaikan dengan:

class Employee:
    def __init__ (self):
        self.name = None # or whatever
        self.dept = None
        self.salary = None

Sekarang sekilas Anda setidaknya bisa melihat bidang apa yang akan Anda harapkan dari program ini.

Keduanya rentan terhadap kesalahan ketik, john.slarly = 1000akan berhasil. Tetap saja berhasil.

Berikut ini adalah solusi yang menggunakan kelas (tidak pernah dipakai) untuk menyimpan data. Saya suka bahwa cara ini melibatkan sangat sedikit pengetikan dan tidak memerlukan paket tambahan dll.

class myStruct:
    field1 = "one"
    field2 = "2"

Anda dapat menambahkan lebih banyak bidang nanti, sesuai kebutuhan:

myStruct.field3 = 3

Untuk mendapatkan nilai, bidang diakses seperti biasa:

>>> myStruct.field1
'one'

Secara pribadi, saya suka varian ini juga. Itu memperluas jawaban @ dF .

class struct:
    def __init__(self, *sequential, **named):
        fields = dict(zip(sequential, [None]*len(sequential)), **named)
        self.__dict__.update(fields)
    def __repr__(self):
        return str(self.__dict__)

Ini mendukung dua mode inisialisasi (yang dapat dicampur):

# Struct with field1, field2, field3 that are initialized to None.
mystruct1 = struct("field1", "field2", "field3") 
# Struct with field1, field2, field3 that are initialized according to arguments.
mystruct2 = struct(field1=1, field2=2, field3=3)

Juga, ini mencetak lebih baik:

print(mystruct2)
# Prints: {'field3': 3, 'field1': 1, 'field2': 2}

Solusi untuk struct berikut ini diilhami oleh implementasi namesuple dan beberapa jawaban sebelumnya. Namun, tidak seperti nametuple itu bisa berubah, dalam nilai-nilai itu, tetapi seperti struct c-style yang tidak dapat diubah dalam nama / atribut, yang bukan kelas atau dikt normal.

_class_template = """\
class {typename}:
def __init__(self, *args, **kwargs):
    fields = {field_names!r}

    for x in fields:
        setattr(self, x, None)            

    for name, value in zip(fields, args):
        setattr(self, name, value)

    for name, value in kwargs.items():
        setattr(self, name, value)            

def __repr__(self):
    return str(vars(self))

def __setattr__(self, name, value):
    if name not in {field_names!r}:
        raise KeyError("invalid name: %s" % name)
    object.__setattr__(self, name, value)            
"""

def struct(typename, field_names):

    class_definition = _class_template.format(
        typename = typename,
        field_names = field_names)

    namespace = dict(__name__='struct_%s' % typename)
    exec(class_definition, namespace)
    result = namespace[typename]
    result._source = class_definition

    return result

Pemakaian:

Person = struct('Person', ['firstname','lastname'])
generic = Person()
michael = Person('Michael')
jones = Person(lastname = 'Jones')


In [168]: michael.middlename = 'ben'
Traceback (most recent call last):

  File "<ipython-input-168-b31c393c0d67>", line 1, in <module>
michael.middlename = 'ben'

  File "<string>", line 19, in __setattr__

KeyError: 'invalid name: middlename'

Ada paket python persis untuk tujuan ini. lihat cstruct2py

cstruct2pyadalah pustaka python murni untuk menghasilkan kelas python dari kode C dan menggunakannya untuk mengemas dan membongkar data. Perpustakaan dapat mengurai C headres (struct, unions, enums, dan deklarasi array) dan meniru mereka dengan python. Kelas pythonic yang dihasilkan dapat menguraikan dan mengemas data.

Sebagai contoh:

typedef struct {
  int x;
  int y;
} Point;

after generating pythonic class...
p = Point(x=0x1234, y=0x5678)
p.packed == "\x34\x12\x00\x00\x78\x56\x00\x00"

Cara Penggunaan

Pertama kita perlu membuat struct pythonic:

import cstruct2py
parser = cstruct2py.c2py.Parser()
parser.parse_file('examples/example.h')

Sekarang kita dapat mengimpor semua nama dari kode C:

parser.update_globals(globals())

Kami juga dapat melakukannya secara langsung:

A = parser.parse_string('struct A { int x; int y;};')

Menggunakan tipe dan definisi dari kode C.

a = A()
a.x = 45
print a
buf = a.packed
b = A(buf)
print b
c = A('aaaa11112222', 2)
print c
print repr(c)

Outputnya adalah:

{'x':0x2d, 'y':0x0}
{'x':0x2d, 'y':0x0}
{'x':0x31316161, 'y':0x32323131}
A('aa111122', x=0x31316161, y=0x32323131)

Klon

Untuk cstruct2pymenjalankan klon :

git clone https://github.com/st0ky/cstruct2py.git --recursive

Saya pikir kamus struktur Python cocok untuk persyaratan ini.

d = dict{}
d[field1] = field1
d[field2] = field2
d[field2] = field3

https://stackoverflow.com/a/32448434/159695 tidak berfungsi di Python3.

https://stackoverflow.com/a/35993/159695 berfungsi di Python3.

Dan saya memperluasnya untuk menambahkan nilai default.

class myStruct:
    def __init__(self, **kwds):
        self.x=0
        self.__dict__.update(kwds) # Must be last to accept assigned member variable.
    def __repr__(self):
        args = ['%s=%s' % (k, repr(v)) for (k,v) in vars(self).items()]
        return '%s(%s)' % ( self.__class__.__qualname__, ', '.join(args) )

a=myStruct()
b=myStruct(x=3,y='test')
c=myStruct(x='str')

>>> a
myStruct(x=0)
>>> b
myStruct(x=3, y='test')
>>> c
myStruct(x='str')

Jika Anda tidak memiliki 3,7 untuk @dataclass dan perlu mutabilitas, kode berikut ini mungkin cocok untuk Anda. Ini cukup mendokumentasikan diri sendiri dan ramah-IDE (auto-complete), mencegah penulisan dua kali, mudah diperpanjang dan sangat mudah untuk menguji bahwa semua variabel instan sepenuhnya diinisialisasi:

class Params():
    def __init__(self):
        self.var1 : int = None
        self.var2 : str = None

    def are_all_defined(self):
        for key, value in self.__dict__.items():
            assert (value is not None), "instance variable {} is still None".format(key)
        return True


params = Params()
params.var1 = 2
params.var2 = 'hello'
assert(params.are_all_defined)

Ini trik cepat dan kotor:

>>> ms = Warning()
>>> ms.foo = 123
>>> ms.bar = 'akafrit'

Bagaimana cara kerjanya? Itu hanya menggunakan kembali kelas builtin Warning(berasal dari Exception) dan menggunakannya karena Anda sendiri kelas yang ditentukan.

Poin baiknya adalah Anda tidak perlu mengimpor atau mendefinisikan apa pun terlebih dahulu, bahwa "Peringatan" adalah nama pendek, dan itu juga menjelaskan bahwa Anda melakukan sesuatu yang kotor yang tidak boleh digunakan di tempat lain selain naskah kecil Anda.

Ngomong-ngomong, saya mencoba menemukan sesuatu yang lebih sederhana seperti ms = object()tetapi tidak bisa (contoh terakhir ini tidak berfungsi). Jika Anda memilikinya, saya tertarik.

Cara terbaik yang saya temukan untuk melakukan ini adalah dengan menggunakan kelas kamus khusus seperti yang dijelaskan dalam posting ini: https://stackoverflow.com/a/14620633/8484485

Jika dukungan pelengkapan otomatis iPython diperlukan, cukup tentukan fungsi dir () seperti ini:

class AttrDict(dict):
    def __init__(self, *args, **kwargs):
        super(AttrDict, self).__init__(*args, **kwargs)
        self.__dict__ = self
    def __dir__(self):
        return self.keys()

Anda kemudian mendefinisikan struct semu Anda seperti: (ini bersarang)

my_struct=AttrDict ({
    'com1':AttrDict ({
        'inst':[0x05],
        'numbytes':2,
        'canpayload':False,
        'payload':None
    })
})

Anda kemudian dapat mengakses nilai-nilai di dalam my_struct seperti ini:

print(my_struct.com1.inst)

=>[5]

NamedTuple nyaman. tetapi tidak ada yang berbagi kinerja dan penyimpanan.

from typing import NamedTuple
import guppy  # pip install guppy
import timeit


class User:
    def __init__(self, name: str, uid: int):
        self.name = name
        self.uid = uid


class UserSlot:
    __slots__ = ('name', 'uid')

    def __init__(self, name: str, uid: int):
        self.name = name
        self.uid = uid


class UserTuple(NamedTuple):
    # __slots__ = ()  # AttributeError: Cannot overwrite NamedTuple attribute __slots__
    name: str
    uid: int


def get_fn(obj, attr_name: str):
    def get():
        getattr(obj, attr_name)
    return get

if 'memory test':
    obj = [User('Carson', 1) for _ in range(1000000)]      # Cumulative: 189138883
    obj_slot = [UserSlot('Carson', 1) for _ in range(1000000)]          # 77718299  <-- winner
    obj_namedtuple = [UserTuple('Carson', 1) for _ in range(1000000)]   # 85718297
    print(guppy.hpy().heap())  # Run this function individually. 
    """
    Index  Count   %     Size   % Cumulative  % Kind (class / dict of class)
     0 1000000    24 112000000 34 112000000  34 dict of __main__.User
     1 1000000    24 64000000  19 176000000  53 __main__.UserTuple
     2 1000000    24 56000000  17 232000000  70 __main__.User
     3 1000000    24 56000000  17 288000000  87 __main__.UserSlot
     ...
    """

if 'performance test':
    obj = User('Carson', 1)
    obj_slot = UserSlot('Carson', 1)
    obj_tuple = UserTuple('Carson', 1)

    time_normal = min(timeit.repeat(get_fn(obj, 'name'), repeat=20))
    print(time_normal)  # 0.12550550000000005

    time_slot = min(timeit.repeat(get_fn(obj_slot, 'name'), repeat=20))
    print(time_slot)  # 0.1368690000000008

    time_tuple = min(timeit.repeat(get_fn(obj_tuple, 'name'), repeat=20))
    print(time_tuple)  # 0.16006120000000124

    print(time_tuple/time_slot)  # 1.1694481584580898  # The slot is almost 17% faster than NamedTuple on Windows. (Python 3.7.7)

Jika Anda __dict__tidak menggunakan, silakan pilih antara __slots__(kinerja dan penyimpanan lebih tinggi) dan NamedTuple(jelas untuk membaca dan menggunakan)

Anda dapat meninjau tautan ini ( Penggunaan slot ) untuk mendapatkan __slots__informasi lebih lanjut.