orjson
3.10.12
orjson est une bibliothèque JSON rapide et correcte pour Python. Elle est considérée comme la bibliothèque Python la plus rapide pour JSON et est plus correcte que la bibliothèque json standard ou d'autres bibliothèques tierces. Il sérialise les instances dataclass, datetime, numpy et UUID de manière native.
orjson.dumps() est environ 10 fois plus rapide que json , sérialise les types et sous-types courants, possède un paramètre default permettant à l'appelant de spécifier comment sérialiser les types arbitraires et dispose d'un certain nombre d'indicateurs contrôlant la sortie.
orjson.loads() est environ 2 fois plus rapide que json et est strictement conforme à UTF-8 et RFC 8259 ("Le format d'échange de données JavaScript Object Notation (JSON)").
La lecture et l'écriture dans des fichiers, des fichiers JSON délimités par des lignes, etc. ne sont pas fournies par la bibliothèque.
orjson prend en charge CPython 3.8, 3.9, 3.10, 3.11, 3.12, 3.13 et 3.14.
Il distribue les roues amd64/x86_64, i686/x86, aarch64/armv8, arm7, POWER/ppc64le et s390x pour Linux, les roues amd64 et aarch64 pour macOS et les roues amd64 et i686/x86 pour Windows.
orjson ne prend pas en charge et ne prendra pas en charge PyPy, les versions Python intégrées pour Android/iOS ou les sous-interprètes PEP 554.
Les versions suivent le versionnement sémantique et la sérialisation d'un nouveau type d'objet sans indicateur d'adhésion est considérée comme une modification radicale.
orjson est sous licence Apache 2.0 et MIT. Le référentiel et le suivi des problèmes sont github.com/ijl/orjson, et les correctifs peuvent y être soumis. Il existe un CHANGELOG disponible dans le référentiel.
Pour installer une roue depuis PyPI, installez le package orjson .
Au format requirements.in ou requirements.txt , spécifiez :
orjson >= 3.10,<4 Au format pyproject.toml , précisez :
orjson = " ^3.10 "Pour construire une roue, voir emballage.
Voici un exemple de sérialisation, avec des options spécifiées, et de désérialisation :
> >> import orjson , datetime , numpy
> >> data = {
"type" : "job" ,
"created_at" : datetime . datetime ( 1970 , 1 , 1 ),
"status" : "?" ,
"payload" : numpy . array ([[ 1 , 2 ], [ 3 , 4 ]]),
}
> >> orjson . dumps ( data , option = orjson . OPT_NAIVE_UTC | orjson . OPT_SERIALIZE_NUMPY )
b'{"type":"job","created_at":"1970-01-01T00:00:00+00:00","status":" xf0 x9f x86 x97 ","payload":[[1,2],[3,4]]}'
> >> orjson . loads ( _ )
{ 'type' : 'job' , 'created_at' : '1970-01-01T00:00:00+00:00' , 'status' : '?' , 'payload' : [[ 1 , 2 ], [ 3 , 4 ]]} orjson version 3 sérialise plus de types que la version 2. Les sous-classes de str , int , dict et list sont désormais sérialisées. C'est plus rapide et plus similaire à la bibliothèque standard. Il peut être désactivé avec orjson.OPT_PASSTHROUGH_SUBCLASS . Les instances dataclasses.dataclass sont désormais sérialisées par défaut et ne peuvent pas être personnalisées dans une fonction default à moins que option=orjson.OPT_PASSTHROUGH_DATACLASS ne soit spécifié. Les instances uuid.UUID sont sérialisées par défaut. Pour tout type désormais sérialisé, les implémentations dans une fonction default et les options les activant peuvent être supprimées mais ce n'est pas obligatoire. Il n'y a eu aucun changement dans la désérialisation.
Pour migrer depuis la bibliothèque standard, la plus grande différence est que orjson.dumps renvoie bytes et json.dumps renvoie un str .
Les utilisateurs avec des objets dict utilisant des clés non str doivent spécifier option=orjson.OPT_NON_STR_KEYS .
sort_keys est remplacé par option=orjson.OPT_SORT_KEYS .
indent est remplacé par option=orjson.OPT_INDENT_2 et les autres niveaux d'indentation ne sont pas pris en charge.
ensure_ascii n'est probablement pas pertinent aujourd'hui et les caractères UTF-8 ne peuvent pas être échappés en ASCII.
def dumps (
__obj : Any ,
default : Optional [ Callable [[ Any ], Any ]] = ...,
option : Optional [ int ] = ...,
) -> bytes : ... dumps() sérialise les objets Python en JSON.
Il sérialise nativement str , dict , list , tuple , int , float , bool , None , dataclasses.dataclass , typing.TypedDict , datetime.datetime , datetime.date , datetime.time , uuid.UUID , numpy.ndarray et orjson.Fragment les instances. Il prend en charge les types arbitraires par default . Il sérialise les sous-classes de str , int , dict , list , dataclasses.dataclass et enum.Enum . Il ne sérialise pas les sous-classes de tuple pour éviter de sérialiser les objets namedtuple sous forme de tableaux. Pour éviter de sérialiser les sous-classes, spécifiez l'option orjson.OPT_PASSTHROUGH_SUBCLASS .
La sortie est un objet bytes contenant UTF-8.
Le verrouillage global de l'interprète (GIL) est maintenu pendant toute la durée de l'appel.
Il déclenche JSONEncodeError sur un type non pris en charge. Ce message d'exception décrit l'objet non valide avec le message d'erreur Type is not JSON serializable: ... . Pour résoudre ce problème, spécifiez default.
Il déclenche JSONEncodeError sur une str qui contient du UTF-8 non valide.
Il lève JSONEncodeError sur un entier qui dépasse 64 bits par défaut ou, avec OPT_STRICT_INTEGER , 53 bits.
Il déclenche JSONEncodeError si un dict a une clé d'un type autre que str , sauf si OPT_NON_STR_KEYS est spécifié.
Il déclenche JSONEncodeError si la sortie par default revient à la gestion par default de plus de 254 niveaux de profondeur.
Il déclenche JSONEncodeError sur les références circulaires.
Il génère JSONEncodeError si un tzinfo sur un objet datetime n'est pas pris en charge.
JSONEncodeError est une sous-classe de TypeError . Ceci est pour la compatibilité avec la bibliothèque standard.
Si l'échec a été provoqué par une exception par default , JSONEncodeError enchaîne l'exception d'origine sous la forme __cause__ .
Pour sérialiser une sous-classe ou des types arbitraires, spécifiez default comme appelable qui renvoie un type pris en charge. default peut être une instance de fonction, lambda ou de classe appelable. Pour spécifier qu'un type n'a pas été géré par default , déclenchez une exception telle que TypeError .
> >> import orjson , decimal
> >>
def default ( obj ):
if isinstance ( obj , decimal . Decimal ):
return str ( obj )
raise TypeError
> >> orjson . dumps ( decimal . Decimal ( "0.0842389659712649442845" ))
JSONEncodeError : Type is not JSON serializable : decimal . Decimal
> >> orjson . dumps ( decimal . Decimal ( "0.0842389659712649442845" ), default = default )
b'"0.0842389659712649442845"'
> >> orjson . dumps ({ 1 , 2 }, default = default )
orjson . JSONEncodeError : Type is not JSON serializable : set L'appelable default peut renvoyer un objet qui doit lui-même être géré par default jusqu'à 254 fois avant qu'une exception ne soit levée.
Il est important que default déclenche une exception si un type ne peut pas être géré. Sinon, Python renvoie implicitement None , qui apparaît à l'appelant comme une valeur légitime et est sérialisée :
> >> import orjson , json
> >>
def default ( obj ):
if isinstance ( obj , decimal . Decimal ):
return str ( obj )
> >> orjson . dumps ({ "set" :{ 1 , 2 }}, default = default )
b'{"set":null}'
> >> json . dumps ({ "set" :{ 1 , 2 }}, default = default )
'{"set":null}' Pour modifier la façon dont les données sont sérialisées, spécifiez option . Chaque option est une constante entière dans orjson . Pour spécifier plusieurs options, masquez-les ensemble, par exemple option=orjson.OPT_STRICT_INTEGER | orjson.OPT_NAIVE_UTC .
Ajoutez n à la sortie. Il s'agit d'une commodité et d'une optimisation pour le modèle de dumps(...) + "n" . Les objets bytes sont immuables et ce modèle copie le contenu original.
> >> import orjson
> >> orjson . dumps ([])
b"[]"
> >> orjson . dumps ([], option = orjson . OPT_APPEND_NEWLINE )
b"[] n " Sortie joliment imprimée avec un retrait de deux espaces. Cela équivaut à indent=2 dans la bibliothèque standard. L'impression jolie est plus lente et le résultat est plus grand. orjson est la bibliothèque comparée la plus rapide en matière d'impression jolie et présente beaucoup moins de ralentissement pour l'impression jolie que la bibliothèque standard. Cette option est compatible avec toutes les autres options.
> >> import orjson
> >> orjson . dumps ({ "a" : "b" , "c" : { "d" : True }, "e" : [ 1 , 2 ]})
b'{"a":"b","c":{"d":true},"e":[1,2]}'
> >> orjson . dumps (
{ "a" : "b" , "c" : { "d" : True }, "e" : [ 1 , 2 ]},
option = orjson . OPT_INDENT_2
)
b'{ n "a": "b", n "c": { n "d": true n }, n "e": [ n 1, n 2 n ] n }'S'ils sont affichés, l'indentation et les sauts de ligne apparaissent comme ceci :
{
"a" : " b " ,
"c" : {
"d" : true
},
"e" : [
1 ,
2
]
}Cela mesure la sérialisation du luminaire github.json comme compact (52 Ko) ou joli (64 Ko) :
| Bibliothèque | compact (ms) | jolie (mme) | contre orjson |
|---|---|---|---|
| orjson | 0,01 | 0,02 | 1 |
| json | 0,13 | 0,54 | 34 |
Cela mesure la sérialisation du luminaire citm_catalog.json, plutôt dans le pire des cas en raison de la quantité d'imbrication et de nouvelles lignes, aussi compact (489 Ko) ou joli (1,1 Mo) :
| Bibliothèque | compact (ms) | jolie (mme) | contre orjson |
|---|---|---|---|
| orjson | 0,25 | 0,45 | 1 |
| json | 3.01 | 24h42 | 54,4 |
Ceci peut être reproduit à l'aide du script pyindent .
Sérialisez les objets datetime.datetime sans tzinfo au format UTC. Cela n'a aucun effet sur les objets datetime.datetime pour lesquels tzinfo est défini.
> >> import orjson , datetime
> >> orjson . dumps (
datetime . datetime ( 1970 , 1 , 1 , 0 , 0 , 0 ),
)
b'"1970-01-01T00:00:00"'
> >> orjson . dumps (
datetime . datetime ( 1970 , 1 , 1 , 0 , 0 , 0 ),
option = orjson . OPT_NAIVE_UTC ,
)
b'"1970-01-01T00:00:00+00:00"' Sérialisez les clés dict d'un type autre que str . Cela permet aux clés dict d'être parmi str , int , float , bool , None , datetime.datetime , datetime.date , datetime.time , enum.Enum et uuid.UUID . À titre de comparaison, la bibliothèque standard sérialise str , int , float , bool ou None par défaut. orjson est considéré comme étant plus rapide à sérialiser les clés non str que les autres bibliothèques. Cette option est plus lente pour les clés str que la valeur par défaut.
> >> import orjson , datetime , uuid
> >> orjson . dumps (
{ uuid . UUID ( "7202d115-7ff3-4c81-a7c1-2a1f067b1ece" ): [ 1 , 2 , 3 ]},
option = orjson . OPT_NON_STR_KEYS ,
)
b'{"7202d115-7ff3-4c81-a7c1-2a1f067b1ece":[1,2,3]}'
> >> orjson . dumps (
{ datetime . datetime ( 1970 , 1 , 1 , 0 , 0 , 0 ): [ 1 , 2 , 3 ]},
option = orjson . OPT_NON_STR_KEYS | orjson . OPT_NAIVE_UTC ,
)
b'{"1970-01-01T00:00:00+00:00":[1,2,3]}' Ces types sont généralement sérialisés comme ils le seraient en tant que valeurs, par exemple, datetime.datetime est toujours une chaîne RFC 3339 et respecte les options qui l'affectent. L'exception est que la sérialisation int ne respecte pas OPT_STRICT_INTEGER .
Cette option présente le risque de créer des clés en double. En effet, les objets non str peuvent être sérialisés avec la même str qu'une clé existante, par exemple {"1": true, 1: false} . La dernière clé à insérer dans le dict sera sérialisée en dernier et un désérialiseur JSON prendra probablement la dernière occurrence d'une clé (dans ce qui précède, false ). La première valeur sera perdue.
Cette option est compatible avec orjson.OPT_SORT_KEYS . Si le tri est utilisé, notez que le tri est instable et sera imprévisible pour les clés en double.
> >> import orjson , datetime
> >> orjson . dumps (
{ "other" : 1 , datetime . date ( 1970 , 1 , 5 ): 2 , datetime . date ( 1970 , 1 , 3 ): 3 },
option = orjson . OPT_NON_STR_KEYS | orjson . OPT_SORT_KEYS
)
b'{"1970-01-03":3,"1970-01-05":2,"other":1}' Cela mesure la sérialisation de 589 Ko de JSON comprenant une list de 100 dict dans laquelle chaque dict a à la fois 365 clés int triées de manière aléatoire représentant les horodatages d'époque ainsi qu'une clé str et la valeur de chaque clé est un seul entier. Dans "str key", les clés ont été converties en str avant la sérialisation, et orjson spécifie toujours option=orjson.OPT_NON_STR_KEYS (ce qui est toujours un peu plus lent).
| Bibliothèque | touches str (ms) | clés int (ms) | clés int triées (ms) |
|---|---|---|---|
| orjson | 0,5 | 0,93 | 2.08 |
| json | 2,72 | 3,59 |
json est vide car il déclenche TypeError lors de la tentative de tri avant de convertir toutes les clés en str . Ceci peut être reproduit à l'aide du script pynonstr .
Ne sérialisez pas le champ microsecond sur les instances datetime.datetime et datetime.time .
> >> import orjson , datetime
> >> orjson . dumps (
datetime . datetime ( 1970 , 1 , 1 , 0 , 0 , 0 , 1 ),
)
b'"1970-01-01T00:00:00.000001"'
> >> orjson . dumps (
datetime . datetime ( 1970 , 1 , 1 , 0 , 0 , 0 , 1 ),
option = orjson . OPT_OMIT_MICROSECONDS ,
)
b'"1970-01-01T00:00:00"' Passthrough des instances dataclasses.dataclass vers default . Cela permet de personnaliser leur sortie mais est beaucoup plus lent.
> >> import orjson , dataclasses
> >>
@ dataclasses . dataclass
class User :
id : str
name : str
password : str
def default ( obj ):
if isinstance ( obj , User ):
return { "id" : obj . id , "name" : obj . name }
raise TypeError
> >> orjson . dumps ( User ( "3b1" , "asd" , "zxc" ))
b'{"id":"3b1","name":"asd","password":"zxc"}'
> >> orjson . dumps ( User ( "3b1" , "asd" , "zxc" ), option = orjson . OPT_PASSTHROUGH_DATACLASS )
TypeError : Type is not JSON serializable : User
> >> orjson . dumps (
User ( "3b1" , "asd" , "zxc" ),
option = orjson . OPT_PASSTHROUGH_DATACLASS ,
default = default ,
)
b'{"id":"3b1","name":"asd"}' Passthrough des instances datetime.datetime , datetime.date et datetime.time par default . Cela permet de sérialiser les dates et heures dans un format personnalisé, par exemple des dates HTTP :
> >> import orjson , datetime
> >>
def default ( obj ):
if isinstance ( obj , datetime . datetime ):
return obj . strftime ( "%a, %d %b %Y %H:%M:%S GMT" )
raise TypeError
> >> orjson . dumps ({ "created_at" : datetime . datetime ( 1970 , 1 , 1 )})
b'{"created_at":"1970-01-01T00:00:00"}'
> >> orjson . dumps ({ "created_at" : datetime . datetime ( 1970 , 1 , 1 )}, option = orjson . OPT_PASSTHROUGH_DATETIME )
TypeError : Type is not JSON serializable : datetime . datetime
> >> orjson . dumps (
{ "created_at" : datetime . datetime ( 1970 , 1 , 1 )},
option = orjson . OPT_PASSTHROUGH_DATETIME ,
default = default ,
)
b'{"created_at":"Thu, 01 Jan 1970 00:00:00 GMT"}' Cela n'affecte pas les dates et heures dans les clés dict si vous utilisez OPT_NON_STR_KEYS.
Passthrough des sous-classes des types intégrés par default .
> >> import orjson
> >>
class Secret ( str ):
pass
def default ( obj ):
if isinstance ( obj , Secret ):
return "******"
raise TypeError
> >> orjson . dumps ( Secret ( "zxc" ))
b'"zxc"'
> >> orjson . dumps ( Secret ( "zxc" ), option = orjson . OPT_PASSTHROUGH_SUBCLASS )
TypeError : Type is not JSON serializable : Secret
> >> orjson . dumps ( Secret ( "zxc" ), option = orjson . OPT_PASSTHROUGH_SUBCLASS , default = default )
b'"******"' Cela n'affecte pas la sérialisation des sous-classes en tant que clés dict si vous utilisez OPT_NON_STR_KEYS.
Ceci est obsolète et n’a aucun effet dans la version 3. Dans la version 2, cela était nécessaire pour sérialiser les instances dataclasses.dataclass . Pour en savoir plus, consultez dataclass.
Sérialisez les instances numpy.ndarray . Pour en savoir plus, consultez numpy.
Ceci est obsolète et n'a aucun effet dans la version 3. Dans la version 2, cela était nécessaire pour sérialiser les instances uuid.UUID . Pour en savoir plus, consultez UUID.
Sérialisez les clés dict dans l’ordre trié. La valeur par défaut est de sérialiser dans un ordre non spécifié. Ceci équivaut à sort_keys=True dans la bibliothèque standard.
Cela peut être utilisé pour garantir que l'ordre est déterministe pour le hachage ou les tests. Cela entraîne une perte de performances substantielle et n'est pas recommandé en général.
> >> import orjson
> >> orjson . dumps ({ "b" : 1 , "c" : 2 , "a" : 3 })
b'{"b":1,"c":2,"a":3}'
> >> orjson . dumps ({ "b" : 1 , "c" : 2 , "a" : 3 }, option = orjson . OPT_SORT_KEYS )
b'{"a":3,"b":1,"c":2}'Cela mesure la sérialisation du luminaire twitter.json non trié et trié :
| Bibliothèque | non trié (ms) | trié (ms) | contre orjson |
|---|---|---|---|
| orjson | 0,11 | 0,3 | 1 |
| json | 1,36 | 1,93 | 6.4 |
Le benchmark peut être reproduit à l'aide du script pysort .
Le tri n'est pas compatible avec le classement/les paramètres régionaux :
> >> import orjson
> >> orjson . dumps ({ "a" : 1 , "ä" : 2 , "A" : 3 }, option = orjson . OPT_SORT_KEYS )
b'{"A":3,"a":1," xc3 xa4 ":2}'C'est le même comportement de tri que la bibliothèque standard.
dataclass est également sérialisé sous forme de cartes mais cela n'a aucun effet sur elles.
Appliquez une limite de 53 bits aux nombres entiers. La limite est par ailleurs de 64 bits, identique à celle de la bibliothèque standard Python. Pour en savoir plus, voir int.
Sérialisez un fuseau horaire UTC sur les instances datetime.datetime en tant que Z au lieu de +00:00 .
> >> import orjson , datetime , zoneinfo
> >> orjson . dumps (
datetime . datetime ( 1970 , 1 , 1 , 0 , 0 , 0 , tzinfo = zoneinfo . ZoneInfo ( "UTC" )),
)
b'"1970-01-01T00:00:00+00:00"'
> >> orjson . dumps (
datetime . datetime ( 1970 , 1 , 1 , 0 , 0 , 0 , tzinfo = zoneinfo . ZoneInfo ( "UTC" )),
option = orjson . OPT_UTC_Z
)
b'"1970-01-01T00:00:00Z"' orjson.Fragment inclut du JSON déjà sérialisé dans un document. Il s'agit d'un moyen efficace d'inclure des blobs JSON à partir d'un cache, d'un champ JSONB ou d'un objet sérialisé séparément sans d'abord désérialiser en objets Python via loads() .
> >> import orjson
> >> orjson . dumps ({ "key" : "zxc" , "data" : orjson . Fragment ( b'{"a": "b", "c": 1}' )})
b'{"key":"zxc","data":{"a": "b", "c": 1}}' Il n'effectue aucun reformatage : orjson.OPT_INDENT_2 n'affectera pas un blob compact et un blob JSON joliment imprimé ne sera pas réécrit en tant que compact.
L'entrée doit être bytes ou str et donnée comme argument de position.
Cela déclenche orjson.JSONEncodeError si une str est donnée et que l'entrée n'est pas UTF-8 valide. Sinon, aucune validation n’est effectuée et il est possible d’écrire du JSON invalide. Cela n'échappe pas aux caractères. L'implémentation est testée pour ne pas planter en cas de chaînes non valides ou de JSON non valide.
def loads ( __obj : Union [ bytes , bytearray , memoryview , str ]) -> Any : ... loads() désérialise JSON en objets Python. Il se désérialise en objets dict , list , int , float , str , bool et None .
Les entrées bytes , bytearray , memoryview et str sont acceptées. Si l'entrée existe en tant qu'objet memoryview , bytearray ou bytes , il est recommandé de les transmettre directement plutôt que de créer un objet str inutile. Autrement dit, orjson.loads(b"{}") au lieu de orjson.loads(b"{}".decode("utf-8")) . Cela entraîne une utilisation de la mémoire et une latence inférieures.
L’entrée doit être UTF-8 valide.
orjson maintient un cache de clés de carte pendant toute la durée du processus. Cela entraîne une réduction nette de l'utilisation de la mémoire en évitant les chaînes en double. Les clés doivent faire au plus 64 octets pour être mises en cache et 2 048 entrées sont stockées.
Le verrouillage global de l'interprète (GIL) est maintenu pendant toute la durée de l'appel.
Il génère JSONDecodeError si un type non valide ou un JSON non valide lui sont attribués. Cela inclut si l'entrée contient NaN , Infinity ou -Infinity , ce que la bibliothèque standard autorise, mais n'est pas un JSON valide.
Il déclenche JSONDecodeError si une combinaison de tableau ou d'objet récure jusqu'à 1024 niveaux de profondeur.
JSONDecodeError est une sous-classe de json.JSONDecodeError et ValueError . Ceci est pour la compatibilité avec la bibliothèque standard.
orjson sérialise les instances de dataclasses.dataclass de manière native. Il sérialise les instances 40 à 50 fois plus rapidement que les autres bibliothèques et évite un ralentissement important observé dans d'autres bibliothèques par rapport à la sérialisation dict .
Il est pris en charge pour transmettre toutes les variantes de classes de données, y compris les classes de données utilisant __slots__ , les classes de données gelées, celles avec des attributs facultatifs ou par défaut et les sous-classes. Il y a un avantage en termes de performances à ne pas utiliser __slots__ .
| Bibliothèque | dict (ms) | classe de données (ms) | contre orjson |
|---|---|---|---|
| orjson | 0,43 | 0,95 | 1 |
| json | 5,81 | 38.32 | 40 |
Cela mesure la sérialisation de 555 Ko de JSON, orjson de manière native et d'autres bibliothèques en utilisant default pour sérialiser la sortie de dataclasses.asdict() . Cela peut être reproduit à l'aide du script pydataclass .
Les classes de données sont sérialisées sous forme de cartes, avec chaque attribut sérialisé et dans l'ordre indiqué lors de la définition de la classe :
> >> import dataclasses , orjson , typing
@ dataclasses . dataclass
class Member :
id : int
active : bool = dataclasses . field ( default = False )
@ dataclasses . dataclass
class Object :
id : int
name : str
members : typing . List [ Member ]
> >> orjson . dumps ( Object ( 1 , "a" , [ Member ( 1 , True ), Member ( 2 )]))
b'{"id":1,"name":"a","members":[{"id":1,"active":true},{"id":2,"active":false}]}' orjson sérialise les objets datetime.datetime au format RFC 3339, par exemple "1970-01-01T00:00:00+00:00". Il s'agit d'un sous-ensemble de la norme ISO 8601 et est compatible avec isoformat() dans la bibliothèque standard.
> >> import orjson , datetime , zoneinfo
> >> orjson . dumps (
datetime . datetime ( 2018 , 12 , 1 , 2 , 3 , 4 , 9 , tzinfo = zoneinfo . ZoneInfo ( "Australia/Adelaide" ))
)
b'"2018-12-01T02:03:04.000009+10:30"'
> >> orjson . dumps (
datetime . datetime ( 2100 , 9 , 1 , 21 , 55 , 2 ). replace ( tzinfo = zoneinfo . ZoneInfo ( "UTC" ))
)
b'"2100-09-01T21:55:02+00:00"'
> >> orjson . dumps (
datetime . datetime ( 2100 , 9 , 1 , 21 , 55 , 2 )
)
b'"2100-09-01T21:55:02"' datetime.datetime prend en charge les instances avec un tzinfo qui est None , datetime.timezone.utc , une instance de fuseau horaire du module python3.9+ zoneinfo ou une instance de fuseau horaire des bibliothèques tierces pendulum , pytz ou dateutil / arrow .
Il est plus rapide d’utiliser zoneinfo.ZoneInfo de la bibliothèque standard pour les fuseaux horaires.
Les objets datetime.time ne doivent pas avoir de tzinfo .
> >> import orjson , datetime
> >> orjson . dumps ( datetime . time ( 12 , 0 , 15 , 290 ))
b'"12:00:15.000290"' Les objets datetime.date seront toujours sérialisés.
> >> import orjson , datetime
> >> orjson . dumps ( datetime . date ( 1900 , 1 , 2 ))
b'"1900-01-02"' Les erreurs avec tzinfo entraînent l'apparition de JSONEncodeError .
Pour désactiver la sérialisation des objets datetime , spécifiez l'option orjson.
