JSON

JSON er et tekst-basert filformat. Teksten i en JSON-fil følger en bestemt struktur som gjør det ekstra lett for et Python-program å jobbe med innholdet.

Ren JSON

• Eksempel
• Gyldig JSON

JSON og Python

• Objekter i Python
• Oppslag
• Indeksering
• Dype oppslag og indekseringer
• Endre, legge til og fjerne verdier
• Lese en JSON-fil med Python
• Skrive en JSON-fil med Python

PS: På denne siden benytter vi Python-samfunnet sin «ordbok» for å beskrive datastrukturene; vokabularet kan derfor være litt forskjellig fra hva som brukes om JSON i andre kontekster.

Eksempel

Den letteste strategien for å bli kjent med JSON er å se på et eksempel. Last ned: kontakter.json eller bare kikk på innholdet ved å se under:

{
  "contacts": [
    {
      "name": "Martin",
      "number": "+47 12345678",
      "address": {
        "street": "Gateveien",
        "number": 24,
        "country": "Norway"
      }
    },
    {
      "name": "Ada",
      "number": "+47 87654321",
      "address": {
        "street": "Veitraséen",
        "number": 42,
        "country": "Norway"
      }
    }
  ],
  "last missed call": {
    "timestamp": {
      "year": 2025,
      "month": 8,
      "day": 19,
      "hour": 14,
      "minute": 15,
      "second": 0
    },
    "number": "+47 12345678"
  }
}

Gyldig JSON

Strukturen i en JSON-fil er basert på at innholdet i filen beskriver ett objekt. Det finnes flere ulike typer objekter, som vi beskriver her

Atomiske typer

Vi beskriver først noen atomiske typer. At typen er «atomisk» betyr bare at den ikke er bygget opp av andre objekter.

De atomiske typene er de minste byggeklossene i en JSON-fil. For å representere større mengder data, trenger vi også minst én av de to sammensatte objekttypene: lister (list) og oppslagsverk (dict).

Lister

En liste er et objekt som inneholder 0, 1, 2 eller flere objekter. En liste er omsluttet av firkantklammer ([ og ]) og objektene i listen skilles fra hverandre med komma (,). Det er valgfritt med mellomrom og linjeskift for å skille objektene i tillegg. Lister følger mønsteret

[ ⏶ , ⏶ , … , ⏶ ]

hvor ⏶ er andre gyldige JSON -objekter. For eksempel:

[42, 45, 40, 88, 45]

["hello",42]

[
  "Martin",
  "Ada",
  "Erling"
]

[]

Oppslagsverk

Oppslagsverk (dict) er objekter bygget opp av nøkkel-verdi –par. En nøkkel er en streng, mens en verdi kan være hvilket som helst objekt. Nøkkel-verdi –par skilles med komma (,), og oppslagsverket er omgitt av krøllparenteser ({ og }). Oppslagsverk følger mønsteret

{ ▮: ⏶, ▮: ⏶, …, ▮: ⏶ }

Hvor ▮ er unike strenger, og ⏶ er gyldige JSON-objekter. For eksempel:

{ "my_key": "my_value", "other_key": 42, "third_one": 0.0 }

{
  "id": 42,
  "values": [24, 25, 26]
}

Objekter i Python

Datastrukturene i JSON er i mange tilfeller identiske med datastrukturene vi benytter i et Python-program; men i et Python-program vil vi ofte ha variabler som peker på et objekt slik at vi kan referere til det flere ganger. For eksempel:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

data = {
    "name": "Martin",
    "number": "+47 12345678"
}

print(data)
print(data["name"])
print(data["number"])

# Skriver ut:
# {'name': 'Martin', 'number': '+47 12345678'}
# Martin
# +47 12345678

I eksempelet over er data en variabel som refererer til et objekt { "name": "Martin", "number": "+47 12345678"}.

På linje 6, 7 og 8 gir programmet instrukser om å skrive ut informasjon fra objektet til skjermen. Legg merke til at firkantklammene som følger umiddelbart etter variabelnavnet på linje 7 og 8 indikerer at vi henter ut en verdi fra oppslagsverket knyttet til den oppgitte nøkkelen. For eksempel vil data["name"] evaluere til "Martin"

Oppslag

Hvis man i Python har en variabel som peker på et oppslagsverk, er det vanlig at man ønsker å hente ut et av de «indre» verdiene i objektet og at man allerede vet hvilken nøkkel verdien er knyttet til. Dette gjøres ved oppslag. Eksempel:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

my_object = {
    "name": "Ada",
    "number": "+47 87654321"
}

my_name = my_object["name"]
my_number = my_object["number"]

print(my_name)    # Ada
print(my_number)  # +47 87654321

Oppslaget er altså det som foregår på linje 6-7 i eksempelet. Vi ser det benyttes firkantklammer som plasseres like bak objektet man skal slå opp i. Mellom firkantklammene oppgis nøkkelen. Det hele evaluerer til den tilhørende verdien.

Indeksering

Hvis man i Python har en variabel som peker på en liste, er det vanlig at man ønsker å hente ut et av de «indre» verdiene fra listen. Dette gjøres ved indeksering. Eksempel:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

my_list = [42, 43, 94, 95]

x = my_list[0]  # Indeks 0 viser til det første posisjonen i listen (42)
y = my_list[1]  # Indeks 1 viser til den andre posisjonen i listen (43)
z = my_list[3]  # Indeks 3 viser til den fjerde posisjonen i listen (95)

total = x + y + z

print(x)      # 42
print(y)      # 43
print(z)      # 95
print(total)  # 180

Indekseringen er altså det som foregår på linje 3-5. Legg merke til at i Python er lister null-indeksert. Det vil si at det første elementet er på posisjon 0 i listen, det andre elementet er på posisjon 1, det tredje elementet er på posisjon 2 og så videre.

Ved både indeksering og oppslag brukes det firkantklammer som plasseres like bak objektet man skal slå opp i. I eksempelet over er my_list en variabel som viser til listen vi skal slå opp i.

Dype oppslag og indekseringer

Noen ganger befinner objektet seg nokså «dypt» omsluttet av sammensatte objekter. For å få tak i slike objekter, må vi gjøre flere oppslag og indekseringer for å kommer frem. Dette kan gjøres på samme linje ved å legge oppslagene etter hverandre. For eksempel, se linje 30 her:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

data = {
  "contacts": [
    {
      "name": "Martin",
      "number": "+47 12345678",
      "address": {
        "street": "Gateveien",
        "number": 24
      }
    },
    {
      "name": "Ada",
      "number": "+47 87654321",
      "address": {
        "street": "Veitraséen",
        "number": 42
      }
    }
  ],
  "last missed call": {
    "timestamp": {
      "year": 2025,
      "month": 8,
      "day": 19
    },
    "number": "+47 12345678"
  }
}

martins_street = data["contacts"][0]["address"]["street"]
print(f"Martin's gate er {martins_street}")  # Martin's gate er Gateveien

I det selve det dype oppslaget data["contacts"][0]["address"]["street"] legger vi merke til at oppslagene bli mer og mer spesifikk jo lengre mot høyre vi kommer.

Endre verdier

I både oppslagsverk og lister er det mulig å endre på verdier.

# Endring av verdi i liste
my_list = ["one", "two", "three"]
my_list[0] = 42 

print(my_list)  # [42, 'two', 'three']

# Endring av verdi i oppslagsverk
my_dict = {
  "key1": "value1",
  "key2": "value2"
}

my_dict["key1"] = "new value"

print(my_dict)  # {'key1': 'new value', 'key2': 'value2'}

Legge til verdier

I både oppslagsverk og lister er det mulig å legge til nye verdier.

# Legge til ny verdi i liste
my_list = ["one", "two", "three"]
x = "four"
my_list.append(x)

print(my_list)  # ['one', 'two', 'three', 'four']

# Legge til nytt nøkkel-verdi par i oppslagsverk
my_dict = {
  "key1": "value1",
  "key2": "value2"
}
x = 'new value'
my_dict['new key'] = x

print(my_dict)  # {'key1': 'value1', 'key2': 'value2', 'new key': 'new value'}

Fjerne verdier

I både oppslagsverk og lister er det mulig å fjerne verdier.

# Fjerne verdi på en gitt indeks i listen
my_list = ["one", "two", "three"]
my_list.pop(1)

print(my_list)  # ['one', 'three']

# Fjerne nøkkel-verdi par med gitt nøkkel
my_dict = {
  "key1": "value1",
  "key2": "value2"
}
my_dict.pop("key1")

print(my_dict)  # {'key2': 'value2'}

Lese en JSON-fil med Python

Når et Python-program skal lese en JSON-fil, er innebærer det to steg:

1. Man leser filen til en streng som om det var en vanlig tekst-fil (på linje 4 under).
2. Man benytter json -modulen for å oversette fra strenger til riktig objekttype (på linje 5 under).

1
2
3
4
5

from pathlib import Path
import json

content = Path("name_of_file.json").read_text(encoding="utf-8")
data = json.loads(content)

1
2
3
4
5
6
7

from pathlib import Path
import json

content = Path("kontakter.json").read_text(encoding="utf-8")
data = json.loads(content)

print(data["contacts"])

[{'name': 'Martin', 'number': '+47 12345678', 'address': {'street': 'Gateveien', 'number': 24, 'country': 'Norway'}}, {'name': 'Ada', 'number': '+47 87654321', 'address': {'street': 'Allégaten', 'number': 42, 'country': 'Norway'}}]

Skrive en JSON-fil med Python

Dersom du har et objekt i Python som kun er bygget opp av de vanlig objekttypene støttet av JSON, kan vi med hjelp av dumps-funksjonen i json -modulen lagre objektet som en JSON-fil.

Det hele foregår i to steg:

1. Man konverterer objektet til en streng med dumps-funksjonen fra json-modulen (linje 9).
2. Man skriver strengen til en fil som en vanlig tekst (linje 10).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from pathlib import Path
import json

example_data = {
  "user_id": "foo8247",
  "password": "HinabeaRDOnt"
}

content = json.dumps(example_data, indent=2)
Path("sample.json").write_text(content, encoding="utf-8")