Last updated: Apr 8, 2024
Reading timeยท6 min
The Python "TypeError: Object of type int64 is not JSON serializable" occurs when we try to convert a NumPy int64 object to a JSON string.
To solve the error, convert the NumPy int to a Python integer before
converting it to JSON, e.g. int(my_numpy_int)
.
Here is an example of how the error occurs.
import json import numpy as np salary = np.power(100, 4, dtype=np.int64) # โ๏ธ TypeError: Object of type int64 is not JSON serializable json_str = json.dumps({'salary': salary}) print(json_str)
We tried passing a numpy int64 object to
the json.dumps()
method but the method doesn't handle numpy
integers by
default.
int
or float
classes to solve the errorTo solve the error, use the built-in
int() (or float
)
constructor to convert the numpy
integer to a native Python integer before
serializing it.
import json import numpy as np salary = np.power(100, 4, dtype=np.int64) # ๐๏ธ convert to int json_str = json.dumps({'salary': int(salary)}) print(json_str) # ๐๏ธ '{"salary": 100000000}' print(type(json_str)) # ๐๏ธ <class 'str'>
The default JSON encoder handles int
and float
values, so we can use a
native Python int
instead of a numpy
int when serializing to JSON.
The json.dumps() method converts a Python object to a JSON formatted string.
JSONEncoder
class to solve the errorAlternatively, you can extend from the JSONEncoder
class and handle the
conversions in a default
method.
import json import numpy as np salary = np.power(100, 4, dtype=np.int64) class NpEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, np.integer): return int(obj) if isinstance(obj, np.floating): return float(obj) if isinstance(obj, np.ndarray): return obj.tolist() return json.JSONEncoder.default(self, obj) json_str = json.dumps({'salary': salary}, cls=NpEncoder) print(json_str) # ๐๏ธ '{"salary": 100000000}' print(type(json_str)) # ๐๏ธ <class 'str'>
We extended from the JSONEncoder class.
The JSONEncoder
class supports the following objects and types by default.
Python | JSON |
---|---|
dict | object |
list, tuple | array |
str | string |
int, float, int and float derived Enums | number |
True | true |
False | false |
None | null |
Notice that the JSONEncoder
class doesn't support numpy
int64 to JSON
conversion by default.
We can handle this by extending from the class and implementing a default()
method that returns a serializable object.
import json import numpy as np class NpEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, np.integer): return int(obj) if isinstance(obj, np.floating): return float(obj) if isinstance(obj, np.ndarray): return obj.tolist() return json.JSONEncoder.default(self, obj)
If the passed-in object is an instance of np.integer
, we convert the object to
a Python int
and return the result.
If the passed-in object is an instance of np.floating
, we convert it to a
Python float
and return the result.
If the object is an instance of np.ndarray
, we convert it to a Python list
and return the result.
To use a custom JSONEncoder
, specify it with the cls
keyword argument in
your call to the json.dumps()
method.
import json import numpy as np salary = np.power(100, 4, dtype=np.int64) class NpEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, np.integer): return int(obj) if isinstance(obj, np.floating): return float(obj) if isinstance(obj, np.ndarray): return obj.tolist() return json.JSONEncoder.default(self, obj) # โ pass cls kwarg json_str = json.dumps({'salary': salary}, cls=NpEncoder) print(json_str) # ๐๏ธ '{"salary": 100000000}' print(type(json_str)) # ๐๏ธ <class 'str'>
If you don't provide the cls
kwarg, the default JSONEncoder
is used.
default
keyword argument to solve the errorYou can also use the default
keyword argument in the call to the
json.dumps()
method.
import json import numpy as np salary = np.power(100, 4, dtype=np.int64) json_str = json.dumps({'salary': salary}, default=int) print(json_str) # ๐๏ธ '{"salary": 100000000}' print(type(json_str)) # ๐๏ธ <class 'str'>
The json.dumps() method converts a Python object to a JSON formatted string.
default
keyword argument can be set to a function that gets called for objects that can't otherwise be serialized.We simply convert the
numpy.int64
object to an integer by passing it to the int
class.
You can also define a custom JSON serializer function.
import json import numpy as np salary = np.power(100, 4, dtype=np.int64) def json_serializer(obj): if isinstance(obj, np.int64): return int(obj) return obj json_str = json.dumps({'salary': salary}, default=json_serializer) print(json_str) # ๐๏ธ '{"salary": 100000000}' print(type(json_str)) # ๐๏ธ <class 'str'>
We set the default
keyword argument to the custom json_serializer
function.
The function uses the isinstance()
function to check if the value is of type
numpy.int64
.
If the value is of type numpy.int64
, we convert it to an integer and return
the result.
Otherwise, the value is returned as is.
The Python "TypeError: Object of type float32 is not JSON serializable" occurs when we try to convert a numpy float32 object to a JSON string.
To solve the error, convert the numpy float to a Python float before
converting it to JSON, e.g. float(my_numpy_float)
.
Here is an example of how the error occurs.
import json import numpy as np salary = np.power(100, 2.75, dtype=np.float32) # โ๏ธ TypeError: Object of type float32 is not JSON serializable json_str = json.dumps({'salary': salary})
We tried passing a NumPy float32
object to the json.dumps()
method but the
method doesn't handle NumPy floats by default.
float
or str
constructor to convert the numpy floatTo solve the error, use the built-in float() (or str()) constructor to convert the numpy float to a native Python float before serializing it.
import json import numpy as np salary = np.power(100, 2.75, dtype=np.float32) print(salary) # ๐๏ธ 316227.78 # โ convert to float json_str = json.dumps({'salary': float(salary)}) print(json_str) # ๐๏ธ '{"salary": 316227.78125}' print(type(json_str)) # ๐๏ธ <class 'str'>
We used the built-in float()
constructor to convert the NumPy float32 value to
a native Python float.
str()
constructor to convert the value to a string instead.The default JSON encoder handles float
and str
values, so we can use a
native Python float
instead of a NumPy float32 when serializing to JSON.
The json.dumps() method converts a Python object to a JSON formatted string.
Alternatively, you can extend from the JSONEncoder
class and handle the
conversions in a default
method.
import json import numpy as np class NpEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, np.integer): return int(obj) if isinstance(obj, np.floating): # ๐๏ธ alternatively use str() return float(obj) if isinstance(obj, np.ndarray): return obj.tolist() return json.JSONEncoder.default(self, obj) salary = np.power(100, 2.75, dtype=np.float32) json_str = json.dumps({'salary': salary}, cls=NpEncoder) print(json_str) # ๐๏ธ {"salary": 316227} print(type(json_str)) # ๐๏ธ <class 'str'>
We extended from the JSONEncoder class.
The JSONEncoder
class supports the following objects and types by default.
Python | JSON |
---|---|
dict | object |
list, tuple | array |
str | string |
int, float, int and float derived Enums | number |
True | true |
False | false |
None | null |
Notice that the JSONEncoder
class doesn't support NumPy float32 to JSON
conversion by default.
We can handle this by extending from the class and implementing a default()
method that returns a serializable object.
import json import numpy as np class NpEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, np.integer): return int(obj) if isinstance(obj, np.floating): return float(obj) if isinstance(obj, np.ndarray): return obj.tolist() return json.JSONEncoder.default(self, obj)
If the passed-in object is an instance of np.integer
, we convert the object to
a Python int
and return the result.
If the passed-in object is an instance of np.floating
, we convert it to a
Python float
and return the result.
str()
constructor instead of float()
if you worry about losing precision.If the object is an instance of np.ndarray
, we convert it to a Python list
and return the result.
In all other cases, we let the base class's default method do the serialization.
To use a custom JSONEncoder
, specify it with the cls
keyword argument in
your call to the json.dumps()
method.
import json import numpy as np class NpEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, np.integer): return int(obj) if isinstance(obj, np.floating): return float(obj) if isinstance(obj, np.ndarray): return obj.tolist() return json.JSONEncoder.default(self, obj) salary = np.power(100, 2.75, dtype=np.float32) # โ pass cls kwarg json_str = json.dumps({'salary': salary}, cls=NpEncoder) print(json_str) # ๐๏ธ {"salary": 316227} print(type(json_str)) # ๐๏ธ <class 'str'>
If you don't provide the cls
kwarg, the default JSONEncoder
is used.