Cara membuat JSON kelas menjadi serial

Bagaimana cara membuat kelas Python serializable?

Kelas sederhana:

class FileItem:
    def __init__(self, fname):
        self.fname = fname

Apa yang harus saya lakukan untuk bisa mendapatkan output:

>>> import json

>>> my_file = FileItem('/foo/bar')
>>> json.dumps(my_file)
TypeError: Object of type 'FileItem' is not JSON serializable

Tanpa kesalahan

Apakah Anda memiliki gagasan tentang output yang diharapkan? Untuk misalnya apakah ini akan dilakukan?

>>> f  = FileItem("/foo/bar")
>>> magic(f)
'{"fname": "/foo/bar"}'

Dalam hal ini Anda hanya dapat menelepon json.dumps(f.__dict__).

Jika Anda ingin lebih banyak output yang disesuaikan, Anda harus subclass JSONEncoderdan mengimplementasikan serialisasi kustom Anda sendiri.

Untuk contoh sepele, lihat di bawah.

>>> from json import JSONEncoder
>>> class MyEncoder(JSONEncoder):
        def default(self, o):
            return o.__dict__    

>>> MyEncoder().encode(f)
'{"fname": "/foo/bar"}'

Kemudian Anda meneruskan kelas ini ke json.dumps()metode sebagai clskwarg:

json.dumps(cls=MyEncoder)

Jika Anda juga ingin memecahkan kode maka Anda harus menyediakan custom object_hookke JSONDecoderkelas. Untuk misalnya

>>> def from_json(json_object):
        if 'fname' in json_object:
            return FileItem(json_object['fname'])
>>> f = JSONDecoder(object_hook = from_json).decode('{"fname": "/foo/bar"}')
>>> f
<__main__.FileItem object at 0x9337fac>
>>> 

Berikut ini adalah solusi sederhana untuk fitur sederhana:

.toJSON() metode

Alih-alih kelas JSON serializable, terapkan metode serializer:

import json

class Object:
    def toJSON(self):
        return json.dumps(self, default=lambda o: o.__dict__, 
            sort_keys=True, indent=4)

Jadi Anda cukup menyebutnya untuk membuat serial:

me = Object()
me.name = "Onur"
me.age = 35
me.dog = Object()
me.dog.name = "Apollo"

print(me.toJSON())

akan menampilkan:

{
    "age": 35,
    "dog": {
        "name": "Apollo"
    },
    "name": "Onur"
}

Untuk kelas yang lebih kompleks, Anda dapat mempertimbangkan alat jsonpickle :

jsonpickle adalah pustaka Python untuk serialisasi dan deserialisasi objek Python kompleks ke dan dari JSON.

Pustaka Python standar untuk penyandian Python ke JSON, seperti stdlib's json, simplejson, dan demjson, hanya dapat menangani primitif Python yang memiliki setara JSON langsung (misalnya dikt, daftar, string, int, dll.). jsonpickle dibangun di atas perpustakaan ini dan memungkinkan struktur data yang lebih kompleks untuk diserialisasi ke JSON. jsonpickle sangat dapat dikonfigurasi dan dapat diperpanjang - memungkinkan pengguna untuk memilih backend JSON dan menambahkan backend tambahan.

(tautan ke jsonpickle di PyPi)

Sebagian besar jawabannya melibatkan mengubah panggilan ke json.dumps () , yang tidak selalu mungkin atau diinginkan (mungkin terjadi di dalam komponen kerangka kerja misalnya).

Jika Anda ingin dapat memanggil json.dumps (obj) apa adanya, maka solusi sederhana diwarisi dari dict :

class FileItem(dict):
    def __init__(self, fname):
        dict.__init__(self, fname=fname)

f = FileItem('tasks.txt')
json.dumps(f)  #No need to change anything here

Ini berfungsi jika kelas Anda hanya representasi data dasar, untuk hal-hal rumit Anda selalu dapat mengatur kunci secara eksplisit.

Saya suka jawaban Onur tetapi akan diperluas untuk memasukkan toJSON()metode opsional untuk objek untuk membuat cerita bersambung sendiri:

def dumper(obj):
    try:
        return obj.toJSON()
    except:
        return obj.__dict__
print json.dumps(some_big_object, default=dumper, indent=2)

Pilihan lain adalah untuk membungkus dumping JSON di kelasnya sendiri:

import json

class FileItem:
    def __init__(self, fname):
        self.fname = fname

    def __repr__(self):
        return json.dumps(self.__dict__)

Atau, bahkan lebih baik lagi, mensubclass kelas FileItem dari suatu JsonSerializablekelas:

import json

class JsonSerializable(object):
    def toJson(self):
        return json.dumps(self.__dict__)

    def __repr__(self):
        return self.toJson()


class FileItem(JsonSerializable):
    def __init__(self, fname):
        self.fname = fname

Pengujian:

>>> f = FileItem('/foo/bar')
>>> f.toJson()
'{"fname": "/foo/bar"}'
>>> f
'{"fname": "/foo/bar"}'
>>> str(f) # string coercion
'{"fname": "/foo/bar"}'

Cukup tambahkan to_jsonmetode ke kelas Anda seperti ini:

def to_json(self):
  return self.message # or how you want it to be serialized

Dan tambahkan kode ini (dari jawaban ini ) , ke suatu tempat di atas segalanya:

from json import JSONEncoder

def _default(self, obj):
    return getattr(obj.__class__, "to_json", _default.default)(obj)

_default.default = JSONEncoder().default
JSONEncoder.default = _default

Ini akan me-monkey-patch modul json ketika diimpor sehingga JSONEncoder.default () secara otomatis memeriksa metode "to_json ()" khusus dan menggunakannya untuk menyandikan objek jika ditemukan.

Seperti yang dikatakan Onur, tetapi kali ini Anda tidak perlu memperbarui setiap json.dumps()proyek Anda.

Saya menemukan masalah ini tempo hari dan menerapkan versi yang lebih umum dari Encoder untuk objek Python yang dapat menangani objek bersarang dan bidang yang diwarisi :

import json
import inspect

class ObjectEncoder(json.JSONEncoder):
    def default(self, obj):
        if hasattr(obj, "to_json"):
            return self.default(obj.to_json())
        elif hasattr(obj, "__dict__"):
            d = dict(
                (key, value)
                for key, value in inspect.getmembers(obj)
                if not key.startswith("__")
                and not inspect.isabstract(value)
                and not inspect.isbuiltin(value)
                and not inspect.isfunction(value)
                and not inspect.isgenerator(value)
                and not inspect.isgeneratorfunction(value)
                and not inspect.ismethod(value)
                and not inspect.ismethoddescriptor(value)
                and not inspect.isroutine(value)
            )
            return self.default(d)
        return obj

Contoh:

class C(object):
    c = "NO"
    def to_json(self):
        return {"c": "YES"}

class B(object):
    b = "B"
    i = "I"
    def __init__(self, y):
        self.y = y

    def f(self):
        print "f"

class A(B):
    a = "A"
    def __init__(self):
        self.b = [{"ab": B("y")}]
        self.c = C()

print json.dumps(A(), cls=ObjectEncoder, indent=2, sort_keys=True)

Hasil:

{
  "a": "A", 
  "b": [
    {
      "ab": {
        "b": "B", 
        "i": "I", 
        "y": "y"
      }
    }
  ], 
  "c": {
    "c": "YES"
  }, 
  "i": "I"
}

Jika Anda menggunakan Python3.5 +, Anda bisa menggunakan jsons. Ini akan mengubah objek Anda (dan semua atributnya secara rekursif) menjadi dict.

import jsons

a_dict = jsons.dump(your_object)

Atau jika Anda menginginkan string:

a_str = jsons.dumps(your_object)

Atau jika kelas Anda diimplementasikan jsons.JsonSerializable:

a_dict = your_object.json

import simplejson

class User(object):
    def __init__(self, name, mail):
        self.name = name
        self.mail = mail

    def _asdict(self):
        return self.__dict__

print(simplejson.dumps(User('alice', '[email protected]')))

jika menggunakan standar json, Anda perlu mendefinisikan suatu defaultfungsi

import json
def default(o):
    return o._asdict()

print(json.dumps(User('alice', '[email protected]'), default=default))

jsonterbatas dalam hal objek yang dapat dicetak, dan jsonpickle(Anda mungkin perlu pip install jsonpickle) terbatas dalam hal tidak dapat membuat teks. Jika Anda ingin memeriksa konten objek yang kelasnya tidak dapat Anda ubah, saya masih tidak bisa menemukan cara yang lebih lurus daripada:

 import json
 import jsonpickle
 ...
 print  json.dumps(json.loads(jsonpickle.encode(object)), indent=2)

Catatan: mereka tetap tidak dapat mencetak metode objek.

Kelas ini dapat melakukan triknya, mengubah objek menjadi standar json.

import json


class Serializer(object):
    @staticmethod
    def serialize(object):
        return json.dumps(object, default=lambda o: o.__dict__.values()[0])

pemakaian:

Serializer.serialize(my_object)

bekerja di python2.7dan python3.

import json

class Foo(object):
    def __init__(self):
        self.bar = 'baz'
        self._qux = 'flub'

    def somemethod(self):
        pass

def default(instance):
    return {k: v
            for k, v in vars(instance).items()
            if not str(k).startswith('_')}

json_foo = json.dumps(Foo(), default=default)
assert '{"bar": "baz"}' == json_foo

print(json_foo)

jaraco memberikan jawaban yang cukup rapi. Saya perlu memperbaiki beberapa hal kecil, tetapi ini berfungsi:

Kode

# Your custom class
class MyCustom(object):
    def __json__(self):
        return {
            'a': self.a,
            'b': self.b,
            '__python__': 'mymodule.submodule:MyCustom.from_json',
        }

    to_json = __json__  # supported by simplejson

    @classmethod
    def from_json(cls, json):
        obj = cls()
        obj.a = json['a']
        obj.b = json['b']
        return obj

# Dumping and loading
import simplejson

obj = MyCustom()
obj.a = 3
obj.b = 4

json = simplejson.dumps(obj, for_json=True)

# Two-step loading
obj2_dict = simplejson.loads(json)
obj2 = MyCustom.from_json(obj2_dict)

# Make sure we have the correct thing
assert isinstance(obj2, MyCustom)
assert obj2.__dict__ == obj.__dict__

Perhatikan bahwa kita perlu dua langkah untuk memuat. Untuk saat ini, __python__properti tidak digunakan.

Seberapa umum ini?

Dengan menggunakan metode AlJohri , saya memeriksa popularitas pendekatan:

Serialisasi (Python -> JSON):

• to_json: 266.595 pada 2018-06-27
• toJSON: 96.307 pada 2018-06-27
• __json__: 8.504 pada 2018-06-27
• for_json: 6,937 pada 2018-06-27

Deserialisasi (JSON -> Python):

• from_json: 226.101 pada 2018-06-27

Ini telah bekerja dengan baik untuk saya:

class JsonSerializable(object):

    def serialize(self):
        return json.dumps(self.__dict__)

    def __repr__(self):
        return self.serialize()

    @staticmethod
    def dumper(obj):
        if "serialize" in dir(obj):
            return obj.serialize()

        return obj.__dict__

lalu

class FileItem(JsonSerializable):
    ...

dan

log.debug(json.dumps(<my object>, default=JsonSerializable.dumper, indent=2))

Jika Anda tidak keberatan menginstal paket untuk itu, Anda dapat menggunakan json-trik :

pip install json-tricks

Setelah itu Anda hanya perlu mengimpor dump(s)dari json_tricksbukan json, dan biasanya akan berfungsi:

from json_tricks import dumps
json_str = dumps(cls_instance, indent=4)

yang akan memberi

{
        "__instance_type__": [
                "module_name.test_class",
                "MyTestCls"
        ],
        "attributes": {
                "attr": "val",
                "dct_attr": {
                        "hello": 42
                }
        }
}

Dan pada dasarnya itu!

Ini akan bekerja dengan baik pada umumnya. Ada beberapa pengecualian, misalnya jika terjadi hal-hal khusus __new__, atau lebih banyak keajaiban metaclass terjadi.

Jelas memuat juga berfungsi (jika tidak apa gunanya):

from json_tricks import loads
json_str = loads(json_str)

Ini mengasumsikan yang module_name.test_class.MyTestClsdapat diimpor dan tidak berubah dengan cara yang tidak kompatibel. Anda akan mendapatkan kembali sebuah instance , bukan kamus atau sejenisnya, dan itu harus merupakan salinan yang identik dengan yang Anda buang.

Jika Anda ingin mengkustomisasi bagaimana sesuatu mendapat (de) serial, Anda dapat menambahkan metode khusus ke kelas Anda, seperti:

class CustomEncodeCls:
        def __init__(self):
                self.relevant = 42
                self.irrelevant = 37

        def __json_encode__(self):
                # should return primitive, serializable types like dict, list, int, string, float...
                return {'relevant': self.relevant}

        def __json_decode__(self, **attrs):
                # should initialize all properties; note that __init__ is not called implicitly
                self.relevant = attrs['relevant']
                self.irrelevant = 12

yang membuat cerita bersambung hanya sebagian dari parameter atribut, sebagai contoh.

Dan sebagai bonus gratis, Anda mendapatkan (de) serialisasi array numpy, tanggal & waktu, peta yang dipesan, serta kemampuan untuk memasukkan komentar di json.

Penafian: Saya membuat json_tricks , karena saya memiliki masalah yang sama dengan Anda.

jsonweb tampaknya menjadi solusi terbaik untuk saya. Lihat http://www.jsonweb.info/en/latest/

from jsonweb.encode import to_object, dumper

@to_object()
class DataModel(object):
  def __init__(self, id, value):
   self.id = id
   self.value = value

>>> data = DataModel(5, "foo")
>>> dumper(data)
'{"__type__": "DataModel", "id": 5, "value": "foo"}'

Ini adalah 3 sen saya ...
Ini menunjukkan serialisasi json eksplisit untuk objek python seperti pohon.
Catatan: Jika Anda benar-benar menginginkan beberapa kode seperti ini, Anda bisa menggunakan kelas FilePath bengkok .

import json, sys, os

class File:
    def __init__(self, path):
        self.path = path

    def isdir(self):
        return os.path.isdir(self.path)

    def isfile(self):
        return os.path.isfile(self.path)

    def children(self):        
        return [File(os.path.join(self.path, f)) 
                for f in os.listdir(self.path)]

    def getsize(self):        
        return os.path.getsize(self.path)

    def getModificationTime(self):
        return os.path.getmtime(self.path)

def _default(o):
    d = {}
    d['path'] = o.path
    d['isFile'] = o.isfile()
    d['isDir'] = o.isdir()
    d['mtime'] = int(o.getModificationTime())
    d['size'] = o.getsize() if o.isfile() else 0
    if o.isdir(): d['children'] = o.children()
    return d

folder = os.path.abspath('.')
json.dump(File(folder), sys.stdout, default=_default)

Saya mengalami masalah ini ketika saya mencoba menyimpan model Peewee ke dalam PostgreSQL JSONField.

Setelah berjuang sebentar, inilah solusi umum.

Kunci untuk solusi saya adalah melalui kode sumber Python dan menyadari bahwa dokumentasi kode (dijelaskan di sini ) sudah menjelaskan cara memperluas yang ada json.dumpsuntuk mendukung tipe data lainnya.

Misalkan Anda saat ini memiliki model yang berisi beberapa bidang yang tidak dapat serial ke JSON dan model yang berisi bidang JSON awalnya terlihat seperti ini:

class SomeClass(Model):
    json_field = JSONField()

Cukup tentukan kustom JSONEncoderseperti ini:

class CustomJsonEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, SomeTypeUnsupportedByJsonDumps):
            return < whatever value you want >
        return json.JSONEncoder.default(self, obj)

    @staticmethod
    def json_dumper(obj):
        return json.dumps(obj, cls=CustomJsonEncoder)

Dan kemudian gunakan saja JSONFieldseperti di bawah ini:

class SomeClass(Model):
    json_field = JSONField(dumps=CustomJsonEncoder.json_dumper)

Kuncinya adalah default(self, obj)metode di atas. Untuk setiap satu ... is not JSON serializablekeluhan yang Anda terima dari Python, cukup tambahkan kode untuk menangani tipe JSON yang tidak dapat digunakan (seperti Enumataudatetime )

Misalnya, inilah cara saya mendukung kelas yang diturunkan dari Enum:

class TransactionType(Enum):
   CURRENT = 1
   STACKED = 2

   def default(self, obj):
       if isinstance(obj, TransactionType):
           return obj.value
       return json.JSONEncoder.default(self, obj)

Akhirnya, dengan kode yang diimplementasikan seperti di atas, Anda bisa mengonversi model Peewee apa saja menjadi objek JSON-seriazable seperti di bawah ini:

peewee_model = WhateverPeeweeModel()
new_model = SomeClass()
new_model.json_field = model_to_dict(peewee_model)

Meskipun kode di atas (agak) khusus untuk Peewee, tapi saya pikir:

1. Ini berlaku untuk ORM lain (Django, dll) secara umum
2. Juga, jika Anda mengerti cara json.dumpskerjanya, solusi ini juga bekerja dengan Python (sans ORM) secara umum juga

Ada pertanyaan, silakan posting di bagian komentar. Terima kasih!

Fungsi ini menggunakan rekursi untuk mengulangi setiap bagian kamus dan memanggil metode repr () dari kelas yang bukan tipe bawaan .

def sterilize(obj):
    object_type = type(obj)
    if isinstance(obj, dict):
        return {k: sterilize(v) for k, v in obj.items()}
    elif object_type in (list, tuple):
        return [sterilize(v) for v in obj]
    elif object_type in (str, int, bool):
        return obj
    else:
        return obj.__repr__()

Ini adalah perpustakaan kecil yang membuat serialisasi objek dengan semua anaknya ke JSON dan juga menguraikannya kembali:

https://github.com/Toubs/PyJSONSerialization/

Saya datang dengan solusi saya sendiri. Gunakan metode ini, berikan dokumen apa saja ( dict , daftar , ObjectId dll) untuk membuat cerita bersambung.

def getSerializable(doc):
    # check if it's a list
    if isinstance(doc, list):
        for i, val in enumerate(doc):
            doc[i] = getSerializable(doc[i])
        return doc

    # check if it's a dict
    if isinstance(doc, dict):
        for key in doc.keys():
            doc[key] = getSerializable(doc[key])
        return doc

    # Process ObjectId
    if isinstance(doc, ObjectId):
        doc = str(doc)
        return doc

    # Use any other custom serializting stuff here...

    # For the rest of stuff
    return doc

Saya memilih untuk menggunakan dekorator untuk memecahkan masalah serialisasi objek datetime. Ini kode saya:

#myjson.py
#Author: jmooremcc 7/16/2017

import json
from datetime import datetime, date, time, timedelta
"""
This module uses decorators to serialize date objects using json
The filename is myjson.py
In another module you simply add the following import statement:
    from myjson import json

json.dumps and json.dump will then correctly serialize datetime and date 
objects
"""

def json_serial(obj):
    """JSON serializer for objects not serializable by default json code"""

    if isinstance(obj, (datetime, date)):
        serial = str(obj)
        return serial
    raise TypeError ("Type %s not serializable" % type(obj))


def FixDumps(fn):
    def hook(obj):
        return fn(obj, default=json_serial)

    return hook

def FixDump(fn):
    def hook(obj, fp):
        return fn(obj,fp, default=json_serial)

    return hook


json.dumps=FixDumps(json.dumps)
json.dump=FixDump(json.dump)


if __name__=="__main__":
    today=datetime.now()
    data={'atime':today, 'greet':'Hello'}
    str=json.dumps(data)
    print str

Dengan mengimpor modul di atas, modul saya yang lain menggunakan json dengan cara normal (tanpa menentukan kata kunci default) untuk membuat serialisasi data yang berisi objek waktu tanggal. Kode serializer datetime secara otomatis dipanggil untuk json.dumps dan json.dump.

Saya paling suka metode Lost Koder. Saya mengalami masalah ketika mencoba untuk meng-serialisasi objek yang lebih kompleks yang anggota / metode tidak dapat serial. Inilah implementasi saya yang bekerja pada lebih banyak objek:

class Serializer(object):
    @staticmethod
    def serialize(obj):
        def check(o):
            for k, v in o.__dict__.items():
                try:
                    _ = json.dumps(v)
                    o.__dict__[k] = v
                except TypeError:
                    o.__dict__[k] = str(v)
            return o
        return json.dumps(check(obj).__dict__, indent=2)

Jika Anda dapat menginstal paket, saya sarankan mencoba dill , yang berfungsi dengan baik untuk proyek saya. Yang menyenangkan tentang paket ini adalah ia memiliki antarmuka yang sama pickle, jadi jika Anda sudah pernah menggunakanpickle dalam proyek Anda, Anda dapat dengan mudah menggantinya dengandill dan melihat apakah skrip berjalan, tanpa mengubah kode apa pun. Jadi ini adalah solusi yang sangat murah untuk dicoba!

(Anti-pengungkapan penuh: Saya sama sekali tidak berafiliasi dengan dan tidak pernah berkontribusi pada proyek dill.)

Instal paket:

pip install dill

Kemudian edit kode Anda untuk mengimpor dillalih-alih pickle:

# import pickle
import dill as pickle

Jalankan skrip Anda dan lihat apakah itu berfungsi. (Jika ya, Anda mungkin ingin membersihkan kode Anda sehingga Anda tidak lagi membayangipickle nama modul!)

Beberapa spesifik pada tipe data yang dilldapat dan tidak bisa membuat serial, dari halaman proyek :

dill dapat memilih jenis standar berikut:

tidak ada, ketik, bool, int, panjang, float, complex, str, unicode, tuple, list, dict, file, buffer, builtin, baik kelas gaya lama dan baru, contoh kelas gaya lama dan baru, set, frozenset, array , fungsi, pengecualian

dill juga dapat menggunakan jenis standar yang lebih 'eksotis':

fungsi dengan hasil, fungsi bersarang, lambdas, sel, metode, metode tidak terikat, modul, kode, pembungkus metode, dictproxy, deskriptor metode, getsetdescriptor, memberdescription, wrapperdescriptor, xrange, slice, notimplemented, ellipsis, berhenti

dill belum dapat memilih jenis standar ini:

bingkai, generator, traceback

Saya melihat tidak disebutkan di sini tentang versi serial atau backcompat, jadi saya akan memposting solusi saya yang telah saya gunakan sebentar. Saya mungkin harus belajar lebih banyak, khususnya Java dan Javascript mungkin lebih matang daripada saya di sini, tetapi begini

https://gist.github.com/andy-d/b7878d0044a4242c0498ed6d67fd50fe

Untuk menambahkan opsi lain: Anda dapat menggunakan attrspaket dan asdictmetode.

class ObjectEncoder(JSONEncoder):
    def default(self, o):
        return attr.asdict(o)

json.dumps(objects, cls=ObjectEncoder)

dan untuk mengkonversi kembali

def from_json(o):
    if '_obj_name' in o:
        type_ = o['_obj_name']
        del o['_obj_name']
        return globals()[type_](**o)
    else:
        return o

data = JSONDecoder(object_hook=from_json).decode(data)

kelas terlihat seperti ini

@attr.s
class Foo(object):
    x = attr.ib()
    _obj_name = attr.ib(init=False, default='Foo')

Selain jawaban Onur , Anda mungkin ingin berurusan dengan tipe datetime seperti di bawah ini.
(untuk menangani: objek 'datetime.datetime' tidak memiliki pengecualian atribut ' dict '.)

def datetime_option(value):
    if isinstance(value, datetime.date):
        return value.timestamp()
    else:
        return value.__dict__

Pemakaian:

def toJSON(self):
    return json.dumps(self, default=datetime_option, sort_keys=True, indent=4)

Pertama, kita perlu membuat objek kita kompatibel dengan JSON, jadi kita bisa membuangnya menggunakan modul JSON standar. Saya melakukannya dengan cara ini:

def serialize(o):
    if isinstance(o, dict):
        return {k:serialize(v) for k,v in o.items()}
    if isinstance(o, list):
        return [serialize(e) for e in o]
    if isinstance(o, bytes):
        return o.decode("utf-8")
    return o

Membangun Quinten Cabo 's jawabannya :

def sterilize(obj):
    if type(obj) in (str, float, int, bool, type(None)):
        return obj
    elif isinstance(obj, dict):
        return {k: sterilize(v) for k, v in obj.items()}
    elif hasattr(obj, '__iter__') and callable(obj.__iter__):
        return [sterilize(v) for v in obj]
    elif hasattr(obj, '__dict__'):
        return {k: sterilize(v) for k, v in obj.__dict__.items() if k not in ['__module__', '__dict__', '__weakref__', '__doc__']}
    else:
        return repr(obj)

Perbedaannya adalah

1. Berfungsi untuk semua iterable, bukan adil listdantuple (berfungsi untuk array NumPy, dll.)
2. Bekerja untuk tipe dinamis (yang berisi a __dict__ ).
3. Termasuk tipe asli floatdan Nonesehingga mereka tidak dapat dikonversi ke string.

Kiri sebagai latihan untuk pembaca adalah untuk menangani __slots__, kelas-kelas yang baik iterable dan memiliki anggota, kelas-kelas yang kamus dan juga memiliki anggota, dll.