`json` — JSON-kodare och -avkodare¶

Källkod: Lib/json/__init__.py

JSON (JavaScript Object Notation), specificerat av RFC 7159 (som föråldrar RFC 4627) och av ECMA-404, är ett lättviktigt datautbytesformat inspirerat av JavaScript objektlitteral syntax (även om det inte är en strikt delmängd av JavaScript [1] ).

Anteckning

Termen ”objekt” i samband med JSON-bearbetning i Python kan vara tvetydig. Alla värden i Python är objekt. I JSON avser ett objekt alla data som är förpackade inom hakparenteser, på samma sätt som en Python-ordbok.

Varning

Var försiktig när du analyserar JSON-data från otillförlitliga källor. En skadlig JSON-sträng kan leda till att avkodaren förbrukar betydande CPU- och minnesresurser. Vi rekommenderar att du begränsar storleken på de data som ska analyseras.

Denna modul exponerar ett API som är bekant för användare av standardbibliotekets moduler marshal och pickle.

Kodning av grundläggande Python-objekthierarkier:

>>> import json
>>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
'["foo", {"bar": ["baz", null, 1.0, 2]}]'
>>> print(json.dumps("\"foo\bar"))
"\"foo\bar"
>>> print(json.dumps('\u1234'))
"\u1234"
>>> print(json.dumps('\\'))
"\\"
>>> print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True))
{"a": 0, "b": 0, "c": 0}
>>> from io import StringIO
>>> io = StringIO()
>>> json.dump(['streaming API'], io)
>>> io.getvalue()
'["streaming API"]'

Kompakt kodning:

>>> import json
>>> json.dumps([1, 2, 3, {'4': 5, '6': 7}], separators=(',', ':'))
'[1,2,3,{"4":5,"6":7}]'

Vacker utskrift:

>>> import json
>>> print(json.dumps({'6': 7, '4': 5}, sort_keys=True, indent=4))
{
    "4": 5,
    "6": 7
}

Anpassa kodning av JSON-objekt:

>>> import json
>>> def custom_json(obj):
...     if isinstance(obj, complex):
...         return {'__complex__': True, 'real': obj.real, 'imag': obj.imag}
...     raise TypeError(f'Cannot serialize object of {type(obj)}')
...
>>> json.dumps(1 + 2j, default=custom_json)
'{"__complex__": true, "real": 1.0, "imag": 2.0}'

Avkodning av JSON:

>>> import json
>>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]')
['foo', {'bar': ['baz', None, 1.0, 2]}]
>>> json.loads('"\\"foo\\bar"')
'"foo\x08ar'
>>> from io import StringIO
>>> io = StringIO('["streaming API"]')
>>> json.load(io)
['streaming API']

Anpassa avkodning av JSON-objekt:

>>> import json
>>> def as_complex(dct):
...     if '__complex__' in dct:
...         return complex(dct['real'], dct['imag'])
...     return dct
...
>>> json.loads('{"__complex__": true, "real": 1, "imag": 2}',
...     object_hook=as_complex)
(1+2j)
>>> import decimal
>>> json.loads('1.1', parse_float=decimal.Decimal)
Decimal('1.1')

Utökning av JSONEncoder:

>>> import json
>>> class ComplexEncoder(json.JSONEncoder):
...     def default(self, obj):
...         if isinstance(obj, complex):
...             return [obj.real, obj.imag]
...         # Let the base class default method raise the TypeError
...         return super().default(obj)
...
>>> json.dumps(2 + 1j, cls=ComplexEncoder)
'[2.0, 1.0]'
>>> ComplexEncoder().encode(2 + 1j)
'[2.0, 1.0]'
>>> list(ComplexEncoder().iterencode(2 + 1j))
['[2.0', ', 1.0', ']']

Använda json från skalet för att validera och skriva ut snyggt:

$ echo '{"json":"obj"}' | python -m json
{
    "json": "obj"
}
$ echo '{1.2:3.4}' | python -m json
Expecting property name enclosed in double quotes: line 1 column 2 (char 1)

Se Kommandoradsgränssnitt för detaljerad dokumentation.

Anteckning

JSON är en underdel av YAML 1.2. Den JSON som produceras av den här modulens standardinställningar (i synnerhet standardvärdet separators) är också en delmängd av YAML 1.0 och 1.1. Den här modulen kan därför också användas som en YAML-serialisator.

Anteckning

Den här modulens kodare och avkodare bevarar inmatnings- och utmatningsordning som standard. Ordningen går bara förlorad om de underliggande behållarna är oordnade.

Grundläggande användning¶

json.dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)¶

Serialisera obj som en JSON-formaterad ström till fp (ett .write()-stödjande filliknande objekt) med hjälp av denna Python-tillJSON-konverteringstabell.

Anteckning

Till skillnad från pickle och marshal är JSON inte ett inramat protokoll, så försök att serialisera flera objekt med upprepade anrop till dump() med samma fp kommer att resultera i en ogiltig JSON-fil.

Parametrar:

obj (object) – Python-objektet som ska serialiseras.
fp (file-like object) – Det filliknande objekt som obj ska serialiseras till. Modulen json producerar alltid str objekt, inte bytes objekt, därför måste fp.write() stödja str indata.
skipkeys (bool) – Om True, kommer nycklar som inte är av en grundläggande typ (str, int, float, bool, None) att hoppas över istället för att ge upphov till ett TypeError. Standard False.
ensure_ascii (bool) – Om True (standard) garanteras att alla inkommande icke-ASCII-tecken i utdata är escapade. Om False, kommer dessa tecken att matas ut som de är.
check_circular (bool) – Om False, hoppar man över kontrollen av cirkulära referenser för containertyper och en cirkulär referens resulterar i ett RecursionError (eller värre). Standard True.
allow_nan (bool) – Om False, serialisering av out-of-range float-värden (nan, inf, -inf) kommer att resultera i en ValueError, i strikt överensstämmelse med JSON-specifikationen. Om True (standard), används deras JavaScript-ekvivalenter (NaN, Infinity, -Infinity).
cls (a JSONEncoder subclass) – Om inställd, en anpassad JSON-kodare med default()-metoden åsidosatt, för serialisering till anpassade datatyper. Om None (standard) används JSONEncoder.
indent (int | str | None) – Om det är ett positivt heltal eller en sträng kommer JSON-arrayelement och objektmedlemmar att skrivas ut med den indragsnivån. Ett positivt heltal indenterar så många mellanslag per nivå; en sträng (t.ex. "\t") används för att indentera varje nivå. Om noll, negativt eller "" (den tomma strängen) infogas endast nya rader. Om None (standard) används den mest kompakta representationen.
separators (tuple | None) – En två-tupel: (item_separator, key_separator). Om None (standard), är separators standard (', ', ': ') om indent är None, och (',', ': ') annars. För den mest kompakta JSON, ange (',', ':') för att eliminera blanksteg.
default (callable | None) – En funktion som anropas för objekt som inte kan serialiseras på annat sätt. Den ska returnera en JSON-kodbar version av objektet eller ge upphov till ett TypeError. Om None (standard), kommer TypeError att returneras.
sort_keys (bool) – Om True, kommer ordböcker att matas ut sorterade efter nyckel. Standard False.

Ändrad i version 3.2: Tillåt strängar för indent i tillägg till heltal.

Ändrad i version 3.4: Använd (',', ': ') som standard om indent inte är None.

Ändrad i version 3.6: Alla valfria parametrar är nu keyword-only.

json.dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)¶: Serialiserar obj till en JSON-formaterad str med hjälp av denna konverteringstabell. Argumenten har samma betydelse som i dump().

Anteckning

Nycklar i nyckel/värde-par i JSON är alltid av typen str. När en ordbok konverteras till JSON omvandlas alla nycklar i ordboken till strängar. Om en ordbok konverteras till JSON och sedan tillbaka till en ordbok kan det därför hända att ordboken inte motsvarar den ursprungliga. Det vill säga, loads(dumps(x)) != x om x har nycklar som inte är strängar.

json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)¶

Deserialisera fp till ett Python-objekt med hjälp av JSON-till-Python-konverteringstabell.

Parametrar:

fp (file-like object) – En .read()-stödjande text file eller binary file som innehåller det JSON-dokument som ska deserialiseras.
cls (a JSONDecoder subclass) – Om inställd, en anpassad JSON-avkodare. Ytterligare nyckelordsargument till load() kommer att skickas till konstruktören av cls. Om None (standard), används JSONDecoder.
object_hook (callable | None) – Om inställd, en funktion som anropas med resultatet av en JSON-objektlitteral som avkodats (en dict). Returvärdet för denna funktion kommer att användas istället för dict. Denna funktion kan användas för att implementera anpassade avkodare, till exempel JSON-RPC class hinting. Standard None.
object_pairs_hook (callable | None) – Om inställd, en funktion som anropas med resultatet av en JSON-objektlitteral som avkodas med en ordnad lista av par. Returvärdet för denna funktion kommer att användas i stället för dict. Den här funktionen kan användas för att implementera anpassade avkodare. Om object_hook också är inställd, har object_pairs_hook prioritet. Standard None.
parse_float (callable | None) – Om den är inställd, en funktion som anropas med strängen för varje JSON-flat som ska avkodas. Om None (standard), är det likvärdigt med float(num_str). Detta kan användas för att analysera JSON-flottor till anpassade datatyper, t.ex. decimal.Decimal.
parse_int (callable | None) – Om den är inställd, en funktion som anropas med strängen för varje JSON int som ska avkodas. Om None (standard), är det likvärdigt med int(num_str). Detta kan användas för att analysera JSON heltal till anpassade datatyper, t.ex. float.
parse_constant (callable | None) – Om den är inställd, en funktion som anropas med en av följande strängar: '-Infinity', 'Infinity' eller 'NaN'. Detta kan användas för att skapa ett undantag om ogiltiga JSON-nummer påträffas. Standard None.

Höjer:

JSONDecodeError – När de data som deserialiseras inte är ett giltigt JSON-dokument.
UnicodeDecodeError – När de data som deserialiseras inte innehåller UTF-8-, UTF-16- eller UTF-32-kodade data.

Ändrad i version 3.1:

Lagt till den valfria parametern object_pairs_hook.
parse_constant anropas inte längre på ’null’, ’true’, ’false’.

Ändrad i version 3.6:

Alla valfria parametrar är nu keyword-only.
fp kan nu vara en binary file. Kodningen för indata bör vara UTF-8, UTF-16 eller UTF-32.

Ändrad i version 3.11: Standardvärdet parse_int för int() begränsar nu den maximala längden på heltalssträngen via tolkens Längdsbegränsning för konvertering av heltalssträngar för att undvika överbelastningsattacker.

json.loads(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)¶: Identiskt med load(), men istället för ett filliknande objekt, deserialisera s (en str, bytes eller bytearray-instans som innehåller ett JSON-dokument) till ett Python-objekt med hjälp av denna konverteringstabell.

Ändrad i version 3.6: s kan nu vara av typen bytes eller bytearray. Kodningen för indata bör vara UTF-8, UTF-16 eller UTF-32.

Ändrad i version 3.9: Nyckelordsargumentet encoding har tagits bort.

Kodare och avkodare¶

class json.JSONDecoder(*, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, strict=True, object_pairs_hook=None)¶

Enkel JSON-avkodare.

Utför följande översättningar vid avkodning som standard:

JSON	Python
object	dict
array	list
string	str
number (int)	int
number (real)	float
true	True
false	False
null	None

Den förstår också NaN, Infinity och -Infinity som deras motsvarande float-värden, vilket ligger utanför JSON-specifikationen.

object_hook är en valfri funktion som kommer att anropas med resultatet av varje JSON-objekt som avkodas och dess returvärde kommer att användas i stället för den angivna dict. Detta kan användas för att tillhandahålla anpassade deserialiseringar (t.ex. för att stödja JSON-RPC class hinting).

object_pairs_hook är en valfri funktion som anropas med resultatet av varje JSON-objekt som avkodats med en ordnad lista av par. Returvärdet för object_pairs_hook kommer att användas istället för dict. Den här funktionen kan användas för att implementera anpassade avkodare. Om object_hook också är definierad, har object_pairs_hook prioritet.

Ändrad i version 3.1: Lagt till stöd för object_pairs_hook.

parse_float är en valfri funktion som anropas med strängen för varje JSON-flat som ska avkodas. Som standard är detta likvärdigt med float(num_str). Detta kan användas för att använda en annan datatyp eller parser för JSON-flottor (t.ex. decimal.Decimal).

parse_int är en valfri funktion som anropas med strängen för varje JSON-int som ska avkodas. Som standard är detta likvärdigt med int(num_str). Detta kan användas för att använda en annan datatyp eller parser för JSON-integraler (t.ex. float).

parse_constant är en valfri funktion som kommer att anropas med en av följande strängar: '-Infinity', 'Infinity', 'NaN'. Detta kan användas för att skapa ett undantag om ogiltiga JSON-tal påträffas.

Om strict är false (True är standard) kommer kontrolltecken att tillåtas i strängar. Kontrolltecken i det här sammanhanget är de som har teckenkoder i intervallet 0-31, inklusive '\t' (tab), '\n', '\r' och '\0'.

Om data som deserialiseras inte är ett giltigt JSON-dokument, kommer ett JSONDecodeError att uppstå.

Ändrad i version 3.6: Alla parametrar är nu keyword-only.

decode(s)¶

Returnerar Python-representationen av s (en str-instans som innehåller ett JSON-dokument).

JSONDecodeError kommer att uppstå om det angivna JSON-dokumentet inte är giltigt.

raw_decode(s)¶

Avkodar ett JSON-dokument från s (en str som börjar med ett JSON-dokument) och returnerar en 2-tupel av Python-representationen och indexet i s där dokumentet slutade.

Detta kan användas för att avkoda ett JSON-dokument från en sträng som kan innehålla ovidkommande data i slutet.

class json.JSONEncoder(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)¶

Utökad JSON-kodare för Python-datastrukturer.

Stöder följande objekt och typer som standard:

Python	JSON
dict	object
list, tuple	array
str	string
int, float, int- & float-deriverade Enum	number
True	true
False	false
None	null

Ändrad i version 3.4: Stöd för int- och float-deriverade Enum-klasser har lagts till.

För att utöka detta till att känna igen andra objekt, subklassa och implementera en default()-metod med en annan metod som returnerar ett serialiserbart objekt för o om möjligt, annars bör den anropa superklassens implementering (för att höja TypeError).

Om skipkeys är false (standard), kommer ett TypeError att uppstå när man försöker koda nycklar som inte är str, int, float, bool eller None. Om skipkeys är true, hoppas sådana objekt helt enkelt över.

Om ensure_ascii är true (standard) garanteras att alla inkommande icke-ASCII-tecken i utdata är escapade. Om ensure_ascii är false kommer dessa tecken att matas ut som de är.

Om check_circular är true (standard) kommer listor, dicts och anpassade kodade objekt att kontrolleras för cirkulära referenser under kodningen för att förhindra en oändlig rekursion (vilket skulle orsaka ett RecursionError). I annat fall sker ingen sådan kontroll.

Om allow_nan är true (standard) kommer NaN, Infinity och -Infinity att kodas som sådana. Detta beteende är inte förenligt med JSON-specifikationen, men överensstämmer med de flesta JavaScript-baserade kodare och avkodare. Annars kommer det att vara ett ValueError att koda sådana floats.

Om sort_keys är true (standard: False) kommer utdata från ordböcker att sorteras efter nyckel; detta är användbart för regressionstester för att säkerställa att JSON-serialiseringar kan jämföras på daglig basis.

Om indent är ett icke-negativt heltal eller en sträng, kommer JSON-arrayelement och objektmedlemmar att skrivas ut med den indentnivån. En indragsnivå på 0, negativ eller "" infogar bara nya rader. None (standard) väljer den mest kompakta representationen. Om du använder ett positivt heltal indenteras så många mellanslag per nivå. Om indent är en sträng (t.ex. "\t") används den strängen för att indentera varje nivå.

Ändrad i version 3.2: Tillåt strängar för indent i tillägg till heltal.

Om det anges ska separatorer vara en tupel av (item_separator, key_separator). Standardvärdet är (', ', ': ') om indent är None och (',', ': ') annars. För att få den mest kompakta JSON-representationen bör du ange (',', ':') för att eliminera blanksteg.

Ändrad i version 3.4: Använd (',', ': ') som standard om indent inte är None.

Om det anges ska default vara en funktion som anropas för objekt som inte kan serialiseras på annat sätt. Den ska returnera en JSON-kodbar version av objektet eller ge upphov till ett TypeError. Om den inte specificeras, genereras TypeError.

Ändrad i version 3.6: Alla parametrar är nu keyword-only.

default(o)¶

Implementera denna metod i en subklass så att den returnerar ett serialiserbart objekt för o, eller anropar basimplementationen (för att skapa ett TypeError).

Till exempel, för att stödja godtyckliga iteratorer, kan du implementera default() så här:

def default(self, o):
   försök:
       iterable = iter(o)
   utom TypeError:
       passera
   else:
       return list(iterable)
   # Låt basklassens standardmetod höja TypeError
   return super().default(o)

encode(o)¶

Returnerar en JSON-strängrepresentation av en Python-datastruktur, o. Till exempel:

>>> json.JSONEncoder().encode({"foo": ["bar", "baz"]})
'{"foo": ["bar", "baz"]}'

iterencode(o)¶

Kodar det givna objektet, o, och ger varje strängrepresentation som är tillgänglig. Till exempel:

for chunk in json.JSONEncoder().iterencode(bigobject):
    mysocket.write(chunk)

Undantag¶

exception json.JSONDecodeError(msg, doc, pos)¶

Underklass till ValueError med följande ytterligare attribut:

msg¶: Det oformaterade felmeddelandet.

doc¶: Det JSON-dokument som analyseras.

pos¶: Startindex för doc där tolkningen misslyckades.

lineno¶: Den linje som motsvarar pos.

colno¶: Den kolumn som motsvarar pos.

Tillagd i version 3.5.

Standardöverensstämmelse och interoperabilitet¶

JSON-formatet specificeras av RFC 7159 och av ECMA-404. I det här avsnittet beskrivs modulens nivå av överensstämmelse med RFC. För enkelhetens skull beaktas inte underklasserna JSONEncoder och JSONDecoder, och andra parametrar än de som uttryckligen nämns.

Denna modul följer inte RFC strikt, utan implementerar vissa tillägg som är giltiga JavaScript men inte giltiga JSON. Detta gäller i synnerhet följande:

Oändliga och NaN-talvärden accepteras och matas ut;
Upprepade namn inom ett objekt accepteras, och endast värdet för det sista namn-värdeparet används.

Eftersom RFC tillåter RFC-kompatibla parsers att acceptera inmatningstexter som inte är RFC-kompatibla, är den här modulens deserializer tekniskt sett RFC-kompatibel med standardinställningarna.

Kodning av tecken¶

RFC kräver att JSON representeras med antingen UTF-8, UTF-16 eller UTF-32, där UTF-8 är den rekommenderade standardversionen för maximal interoperabilitet.

Som RFC tillåter, men inte kräver, ställer den här modulens serializer in ensure_ascii=True som standard, vilket innebär att utdata escapas så att de resulterande strängarna endast innehåller ASCII-tecken.

Förutom parametern ensure_ascii definieras den här modulen strikt i termer av konvertering mellan Python-objekt och Unicode-strängar, och tar därför inte direkt upp frågan om teckenkodning.

Enligt RFC är det förbjudet att lägga till en byteordermark (BOM) i början av en JSON-text, och den här modulens serialiserare lägger inte till någon BOM i utdata. RFC tillåter, men kräver inte, att JSON-deserialiserare ignorerar en initial BOM i sin indata. Den här modulens deserialiserare ger upphov till ett ValueError när en initial BOM finns.

RFC förbjuder inte uttryckligen JSON-strängar som innehåller byte-sekvenser som inte motsvarar giltiga Unicode-tecken (t.ex. oparade UTF-16-surrogat), men noterar att de kan orsaka problem med interoperabilitet. Som standard accepterar och matar den här modulen ut (när de finns i den ursprungliga str) kodpunkter för sådana sekvenser.

Oändliga och NaN-talvärden¶

RFC tillåter inte representation av oändliga eller NaN-talvärden. Trots detta accepterar och matar den här modulen som standard ut Infinity, -Infinity och NaN som om de vore giltiga JSON-numeriska bokstavliga värden:

>>> # Neither of these calls raises an exception, but the results are not valid JSON
>>> json.dumps(float('-inf'))
'-Infinity'
>>> json.dumps(float('nan'))
'NaN'
>>> # Same when deserializing
>>> json.loads('-Infinity')
-inf
>>> json.loads('NaN')
nan

I serializern kan parametern allow_nan användas för att ändra detta beteende. I deserializern kan parametern parse_constant användas för att ändra detta beteende.

Upprepade namn inom ett objekt¶

RFC anger att namnen i ett JSON-objekt ska vara unika, men anger inte hur upprepade namn i JSON-objekt ska hanteras. Som standard ger den här modulen inte upphov till något undantag, utan ignorerar alla utom det sista namn-värdeparet för ett givet namn:

>>> weird_json = '{"x": 1, "x": 2, "x": 3}'
>>> json.loads(weird_json)
{'x': 3}

Parametern object_pairs_hook kan användas för att ändra detta beteende.

Värden på högsta nivå som inte är objekt eller arrayer¶

Den gamla versionen av JSON som specificeras av den föråldrade RFC 4627 krävde att toppnivåvärdet för en JSON-text måste vara antingen ett JSON-objekt eller en array (Python dict eller list), och kunde inte vara ett JSON null-, boolean-, nummer- eller strängvärde. RFC 7159 tog bort den begränsningen, och den här modulen implementerar inte och har aldrig implementerat den begränsningen i varken dess serializer eller dess deserializer.

För att uppnå maximal interoperabilitet kan det dock vara bra om du själv frivilligt följer begränsningen.

Begränsningar i genomförandet¶

Vissa implementeringar av JSON-deserializer kan sätta gränser för:

storleken på accepterade JSON-texter
den maximala nivån för nestning av JSON-objekt och matriser
intervall och precision för JSON-tal
innehåll och maximal längd för JSON-strängar

Denna modul inför inte några sådana begränsningar utöver de som gäller för de relevanta Python-datatyperna själva eller Python-tolken själv.

När du serialiserar till JSON bör du vara uppmärksam på sådana begränsningar i applikationer som kan konsumera din JSON. I synnerhet är det vanligt att JSON-tal deserialiseras till IEEE 754-tal med dubbel precision och därmed omfattas av den representationens begränsningar för intervall och precision. Detta är särskilt relevant vid serialisering av Python int-värden av extremt stor magnitud, eller vid serialisering av instanser av ”exotiska” numeriska typer som decimal.Decimal.

Kommandoradsgränssnitt¶

Källkod: Lib/json/tool.py

Modulen json kan anropas som ett skript via python -m json för att validera och pretty-printa JSON-objekt. Undermodulen json.tool implementerar detta gränssnitt.

Om de valfria argumenten infile och outfile inte anges, används sys.stdin respektive sys.stdout:

$ echo '{"json": "obj"}' | python -m json
{
    "json": "obj"
}
$ echo '{1.2:3.4}' | python -m json
Expecting property name enclosed in double quotes: line 1 column 2 (char 1)

Ändrad i version 3.5: Utdata är nu i samma ordning som indata. Använd alternativet --sort-keys för att sortera utdata från ordböcker alfabetiskt efter nyckel.

Ändrad i version 3.14: Modulen json kan nu köras direkt som python -m json. För bakåtkompatibilitet stöds fortfarande att anropa CLI som python -m json.tool.

Alternativ för kommandoraden¶

infile¶

Den JSON-fil som ska valideras eller skrivas ut:

$ python -m json mp_films.json
[
    {
        "title": "And Now for Something Completely Different",
        "year": 1971
    },
    {
        "title": "Monty Python and the Holy Grail",
        "year": 1975
    }
]

Om infile inte anges, läs från sys.stdin.

outfile¶: Skriver utdata från infile till den angivna outfile. I annat fall skrivs den till sys.stdout.

--sort-keys¶: Sortera utdata från ordböcker alfabetiskt efter nyckel.

Tillagd i version 3.5.

--no-ensure-ascii¶: Inaktivera escaping av icke-ascii-tecken, se json.dumps() för mer information.

Tillagd i version 3.9.

--json-lines¶: Parsa varje inmatningsrad som ett separat JSON-objekt.

Tillagd i version 3.8.

--indent, --tab, --no-indent, --compact¶: Ömsesidigt uteslutande alternativ för kontroll av blanksteg.

Tillagd i version 3.9.

-h, --help¶: Visa hjälpmeddelandet.

Fotnoter

`json` — JSON-kodare och -avkodare¶

Grundläggande användning¶

Kodare och avkodare¶

Undantag¶

Standardöverensstämmelse och interoperabilitet¶

Kodning av tecken¶

Oändliga och NaN-talvärden¶

Upprepade namn inom ett objekt¶

Värden på högsta nivå som inte är objekt eller arrayer¶

Begränsningar i genomförandet¶

Kommandoradsgränssnitt¶

Alternativ för kommandoraden¶

Innehåll

Föregående ämne

Nästa ämne

Denna sidan

json — JSON-kodare och -avkodare¶

Grundläggande användning¶

Kodare och avkodare¶

Undantag¶

Standardöverensstämmelse och interoperabilitet¶

Kodning av tecken¶

Oändliga och NaN-talvärden¶

Upprepade namn inom ett objekt¶

Värden på högsta nivå som inte är objekt eller arrayer¶

Begränsningar i genomförandet¶

Kommandoradsgränssnitt¶

Alternativ för kommandoraden¶

`json` — JSON-kodare och -avkodare¶