Conversion d'une chaîne avec un entier de début zéro en json

Premièrement, utiliser une expression régulière sur JSON est un mal, presque aussi mauvais que de tuer un chaton.

Si vous voulez représenter 01 comme une valeur JSON valide, envisagez d'utiliser cette structure: p>

a = '{"index" : "01"}'
import json
json.loads(a)

Si vous avez besoin que la chaîne littérale 01 se comporte comme un nombre, envisagez de la convertir simplement en un entier dans votre script Python.

Comment convertir une chaîne int JSON en véritable int avec json.loads S'il vous plaît voir le post ci-dessus Vous devez utiliser votre propre version de Decoder.

Plus d'informations peuvent être trouvées ici, dans le github https://github.com/simplejson/simplejson/blob/master/index. rst

>>> c = '{"value": 02}'
>>> import demjson
>>> demjson.decode(c)
{'value': 2}

Cela semble fonctionner .. C'est étrange

> >>> c = '{"value": 02}'
> >>> import json
> >>> value= json.loads(json.dumps(c))
> >>> print(value) {"value": 02}
> >>> c = '{"value": 0002}'
> >>> value= json.loads(json.dumps(c))
> >>> print(value) {"value": 0002}

Comme @Dunes, l'a souligné les charges produisent une chaîne comme résultat qui n'est pas une solution valide. Cependant,

DEMJSON semble le décoder correctement. https://pypi.org/project/demjson/ - méthode alternative

XXX

Un 0 au début d'un littéral de nombre dans JSON n'est pas valide sauf si le littéral de nombre est uniquement le caractère 0 ou commence par 0. . Le module Python json est assez strict en ce sens qu'il n'acceptera pas ces littéraux numériques. En partie parce qu'un 0 non significatif est parfois utilisé pour désigner la notation octale plutôt que la notation décimale. La désérialisation de ces numéros peut entraîner des erreurs de programmation involontaires. Autrement dit, doit 010 être analysé comme le nombre 8 (en notation octale) ou comme 10 (en notation décimale).

Vous peut créer un décodeur qui fera ce que vous voulez, mais vous devrez fortement pirater le module json ou réécrire une grande partie de ses composants internes. Quoi qu'il en soit, vous verrez un ralentissement des performances car vous n'utiliserez plus l'implémentation C du module.

Voici une implémentation qui peut décoder JSON qui contient des nombres avec n'importe quel nombre de zéros non significatifs. / p>

import json
import re
import threading

# a more lenient number regex (modified from json.scanner.NUMBER_RE)
NUMBER_RE = re.compile(
    r'(-?(?:\d*))(\.\d+)?([eE][-+]?\d+)?',
    (re.VERBOSE | re.MULTILINE | re.DOTALL))


# we are going to be messing with the internals of `json.scanner`. As such we
# want to return it to its initial state when we're done with it, but we need to
# do so in a thread safe way.
_LOCK = threading.Lock()
def thread_safe_py_make_scanner(context, *, number_re=json.scanner.NUMBER_RE):
    with _LOCK:
        original_number_re = json.scanner.NUMBER_RE
        try:
            json.scanner.NUMBER_RE = number_re
            return json.scanner._original_py_make_scanner(context)
        finally:
            json.scanner.NUMBER_RE = original_number_re

json.scanner._original_py_make_scanner = json.scanner.py_make_scanner
json.scanner.py_make_scanner = thread_safe_py_make_scanner


class MyJsonDecoder(json.JSONDecoder):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # overwrite the stricter scan_once implementation
        self.scan_once = json.scanner.py_make_scanner(self, number_re=NUMBER_RE)


d = MyJsonDecoder()
n = d.decode('010')
assert n == 10

json.loads('010') # check the normal route still raise an error

Je tiens à souligner que vous ne devriez pas vous fier à cela comme une solution appropriée. Il s'agit plutôt d'un hack rapide pour vous aider à décoder un JSON malformé qui est presque, mais pas tout à fait valide. C'est utile si la recréation du JSON sous une forme valide n'est pas possible pour une raison quelconque.