Python JSON-faili lugemine - kuidas failist JSON-i laadida ja parsida prügimäed

Tere tulemast! Kui soovite õppida JSON-failidega töötamist Pythonis, siis see artikkel on mõeldud teile.

Sa õpid:

  • Miks on JSON-vorming nii oluline?
  • Selle põhistruktuur ja andmetüübid.
  • Kuidas JSON ja Pythoni sõnastikud Pythonis koos töötavad.
  • Kuidas töötada Pythoni sisseehitatud   jsonmooduliga.
  • Kuidas teisendada JSON-i stringid Pythoni objektideks ja vastupidi.
  • Kuidas kasutada loads()jadumps()
  • Kuidas JSON-stringe automaatselt taandada.
  • Kuidas lugeda JSON-faile Pythonis kasutades load()
  • Kuidas Pythonis JSON-failidesse kirjutada dump()
  • Ja veel!

Oled sa valmis? Alustagem! ✨

? Sissejuhatus: mis on JSON?

JSON-vorming oli algselt inspireeritud JavaScripti (veebiarenduses kasutatava programmeerimiskeele) süntaksist. Kuid sellest ajast alates on see muutunud keelest sõltumatuks andmevorminguks ja enamik programmeerimiskeeli, mida me täna kasutame, suudab JSON-i luua ja lugeda.

JSONi olulisuse ja kasutamise juhtumid

JSON on põhimõtteliselt andmete salvestamiseks või esitamiseks kasutatav vorming. Selle üldkasutatavad juhtumid hõlmavad veebiarendus- ja konfiguratsioonifaile.

Vaatame, miks:

  • Veebiarendus: JSON-i kasutatakse tavaliselt serverist andmete saatmiseks kliendile ja vastupidi veebirakendustes.
  • Konfiguratsioonifailid: JSON-i kasutatakse ka konfiguratsioonide ja sätete salvestamiseks. Näiteks Google Chrome'i rakenduse loomiseks peate lisama JSON-faili, mida nimetatakse manifest.jsonrakenduse nime, selle kirjelduse, praeguse versiooni ning muude atribuutide ja sätete määramiseks.  

? JSONi struktuur ja vorming

Nüüd, kui teate, milleks JSON-vormingut kasutatakse, vaatame selle põhistruktuuri koos näitega, mis esindab pitsa tellimuse andmeid:

{ "size": "medium", "price": 15.67, "toppings": ["mushrooms", "pepperoni", "basil"], "extra_cheese": false, "delivery": true, "client": { "name": "Jane Doe", "phone": null, "email": "[email protected]" } }

Need on JSON-vormingu peamised omadused:

  • Seal on jada võtmeväärtuste paare, mis on ümbritsetud lokkis sulgudega {}.
  • Iga võti kaardistatakse konkreetse väärtusega, kasutades seda vormingut:
"key":  

? Nõuanne: jutumärke vajavad väärtused peavad olema ümbritsetud topelt jutumärkidega.

  • Võtme-väärtuse paarid eraldatakse komaga. Ainult viimasele paarile ei järgne koma.
{ "size": "medium", # Comma! "price": 15.67 }

? Nõuanne. Tavaliselt vormindame JSON-i erineva taande tasemega, et andmeid oleks hõlpsam lugeda. Selles artiklis saate teada, kuidas taande Pythoni abil automaatselt lisada.

JSON-i andmetüübid: võtmed ja väärtused

JSON-failidel on konkreetsed reeglid, mis määravad, millised andmetüübid võtmete ja väärtuste jaoks kehtivad.

  • Võtmed peavad olema stringid.
  • Väärtused võivad olla kas string, arv, massiiv, tõeväärtus ( true/ false) nullvõi JSON-objekt.

Vastavalt Pythoni dokumentatsioonile:

JSON-i võtme- ja väärtuspaaride võtmed on alati seda tüüpi str. Kui sõnastik muudetakse JSON-iks, sunnitakse kõik sõnastiku klahvid stringideks.

Stiilijuht

Google JSON-i stiilijuhendi järgi:

  • Valige alati sisukad nimed.
  • Massiivitüüpidel peaksid olema mitmuse võtmenimed. Kõik muud võtmenimed peaksid olema ainsad. Näiteks: kasutage "orders"selle asemel, "order"kui vastav väärtus on massiiv.
  • JSON-i objektides ei tohiks olla kommentaare.

? JSON vs Pythoni sõnastikud

JSON ja sõnaraamatud võivad esmalt (visuaalselt) tunduda väga sarnased, kuid need on üsna erinevad. Vaatame, kuidas nad on "ühendatud" ja kuidas nad üksteist täiendavad, et Python oleks võimas tööriist JSON-failidega töötamiseks.

JSON on failivorming, mida kasutatakse andmete esitamiseks ja salvestamiseks, samas kui Pythoni sõnaraamat on tegelik andmestruktuur (objekt), mida Pythoni programmi töötamise ajal mälus hoitakse.

Kuidas JSONi ja Pythoni sõnastikud koos töötavad

Kui töötame JSON-failidega Pythonis, ei saa me neid lihtsalt lugeda ja oma programmis olevaid andmeid otse kasutada. Seda seetõttu, et kogu fail oleks kujutatud ühe stringina ja me ei saaks võtmeväärtuste paaridele eraldi juurde pääseda.

Kui ei...

Kasutame JSON-faili võtmeväärtuste paare Pythoni sõnaraamatu loomiseks, mida saame oma programmis kasutada andmete lugemiseks, kasutamiseks ja muutmiseks (vajadusel).

See on peamine seos JSONi ja Pythoni sõnastike vahel. JSON on andmete stringiline esitus ja sõnastikud on tegelikud mälu andmestruktuurid, mis luuakse programmi käivitamisel.

Suurepärane. Nüüd, kui teate JSONist rohkem, alustame sukeldumist JSONiga Pythonis töötamise praktilistesse aspektidesse.

? JSON-moodul

Meie õnneks on Pythonil sisseehitatud moodul nimega json. See installitakse Pythoni installimisel automaatselt ja see sisaldab funktsioone, mis aitavad teil töötada JSON-failide ja -stringidega.

Kasutame seda moodulit järgmistes näidetes.

Kuidas importida JSON-moodulit

jsonMeie programmis kasutamiseks peame lihtsalt faili ülaossa kirjutama impordi avalduse.

Nagu nii:

Selle reaga on teil juurdepääs moodulis määratletud funktsioonidele. Näidetes kasutame neist mitut.

? Nõuanne: kui kirjutate selle impordilause, peate seda süntaksit kasutamajsonmoodulis määratletud funktsiooni kutsumiseks :

? Pythoni ja JSONi stringid

jsonMooduli kõige olulisemate funktsioonide toimimise illustreerimiseks kasutame JSON-vormingus mitmerealist stringi.

JSON String

Eelkõige kasutame seda stringi näidetes. See on lihtsalt tavaline mitmerealine Pythoni string, mis järgib JSON-vormingut.

data_JSON = """ { "size": "Medium", "price": 15.67, "toppings": ["Mushrooms", "Extra Cheese", "Pepperoni", "Basil"], "client": { "name": "Jane Doe", "phone": "455-344-234", "email": "[email protected]" } } """
  • Mitmerealise stringi defineerimiseks Pythonis kasutame kolmikjutumärke.  
  • Seejärel määrame muutujale stringi data_JSON.

? Nõuanne: Pythoni stiilijuhendis soovitatakse kolmekordse jutumärgiga stringide jaoks kasutada topelttsiteeritud märke.  

JSON Stringi Pythoni sõnaraamatusse

JSON-vormingus stringi abil luuakse Pythoni sõnastik, millele pääseme juurde, millega saame töötada ja mida muuta.

Selleks kasutame mooduli loads()funktsiooni json, edastades argumendina stringi.

See on põhiline süntaks:

Siin on kood:

# Import the module import json # String with JSON format data_JSON = """ { "size": "Medium", "price": 15.67, "toppings": ["Mushrooms", "Extra Cheese", "Pepperoni", "Basil"], "client": { "name": "Jane Doe", "phone": "455-344-234", "email": "[email protected]" } } """ # Convert JSON string to dictionary data_dict = json.loads(data_JSON) 

Keskendume sellele reale:

data_dict = json.loads(data_JSON)
  • json.loads(data_JSON) loob uue sõnastiku JSON-stringi võtmeväärtuste paaridega ja tagastab selle uue sõnastiku.
  • Seejärel määratakse muutujale tagastatud sõnastik data_dict.

Vinge! Selle sõnastiku printimisel näeme seda väljundit:

{'size': 'Medium', 'price': 15.67, 'toppings': ['Mushrooms', 'Extra Cheese', 'Pepperoni', 'Basil'], 'client': {'name': 'Jane Doe', 'phone': '455-344-234', 'email': '[email protected]'}}

Sõnastik on asustatud JSON-stringi andmetega. Iga võtme-väärtuse paar lisati edukalt.

Vaatame nüüd, mis juhtub, kui proovime pääseda juurde võtme-väärtuspaaride väärtustele sama süntaksiga, mida kasutaksime tavalise Pythoni sõnaraamatu väärtustele juurde pääsemiseks:

print(data_dict["size"]) print(data_dict["price"]) print(data_dict["toppings"]) print(data_dict["client"])

Väljund on:

Medium 15.67 ['Mushrooms', 'Extra Cheese', 'Pepperoni', 'Basil'] {'name': 'Jane Doe', 'phone': '455-344-234', 'email': '[email protected]'}

Täpselt see, mida me ootasime. Iga võtit saab kasutada vastava väärtuse saamiseks.

? Nõuanne. Saame seda sõnastikku kasutada nagu iga teist Pythoni sõnastikku. Näiteks võime kutsuda sõnastike meetodeid, lisada, värskendada ja eemaldada võtmeväärtuste paare ja palju muud. Me võime seda isegi kasutada loopi jaoks.

JSON - Python: Tüübi teisendamine

Kui kasutate loads()JSON-i stringist Pythoni sõnaraamatu loomist, märkate, et mõned väärtused teisendatakse vastavateks Pythoni väärtusteks ja andmetüüpideks.

See jsonmooduli Pythoni dokumentatsioonis esitatud tabel võtab kokku JSON-i andmetüüpide ja -väärtuste vastavuse Pythoni andmetüüpidele ja -väärtustele.

? Nõuanne: JSON-failidega töötamisel kehtib sama teisendustabel.

Pythoni sõnastik JSONi stringile

Nüüd teate, kuidas luua Pythoni sõnastik JSON-vormingus stringist.

Kuid mõnikord peame võib-olla tegema vastupidi, luues objektist (näiteks sõnastikust) JSON-vormingus stringi selle printimiseks, kuvamiseks, salvestamiseks või stringina töötamiseks.

Selleks saame kasutada mooduli dumpsfunktsiooni json, edastades argumendina objekti:

? Nõuanne: see funktsioon tagastab stringi.

See on näide, kus teisendame Pythoni sõnaraamatu clientJSON-vormingus stringiks ja salvestame selle muutujasse:

# Python Dictionary client = { "name": "Nora", "age": 56, "id": "45355", "eye_color": "green", "wears_glasses": False } # Get a JSON formatted string client_JSON = json.dumps(client)

Keskendume sellele reale:

client_JSON = json.dumps(client)
  • json.dumps(client) loob ja tagastab JSON-vormingus stringi koos kõigi sõnastiku võtmeväärtuste paaridega.
  • Seejärel määratakse see string client_JSONmuutujale.

Selle stringi printimisel näeme seda väljundit:

{"name": "Nora", "age": 56, "id": "45355", "eye_color": "green", "wears_glasses": false}

? Tip: Notice that the last value (false) was changed. In the Python dictionary, this value was False but in JSON, the equivalent value is false. This helps us confirm that, indeed, the original dictionary is now represented as a string with JSON format.

If we check the data type of this variable, we see:

So the return value of this function was definitely a string.

Python to JSON: Type Conversion

A process of type conversion occurs as well when we convert a dictionary into a JSON string. This table from the Python Documentation illustrates the corresponding values:

How to Print JSON With Indentation

If we use the dumps function and we print the string that we got in the previous example, we see:

{"name": "Nora", "age": 56, "id": "45355", "eye_color": "green", "wears_glasses": false}

But this is not very readable, right?

We can improve the readability of the JSON string by adding indentation.

To do this automatically, we just need to pass a second argument to specify the number of spaces that we want to use to indent the JSON string:

? Tip: the second argument has to be a non-negative integer (number of spaces) or a string. If indent is a string (such as "\t"), that string is used to indent each level (source).

Now, if we call dumps with this second argument:

client_JSON = json.dumps(client, indent=4)

The result of printing client_JSON is:

{ "name": "Nora", "age": 56, "id": "45355", "eye_color": "green", "wears_glasses": false }

That's great, right? Now our string is nicely formatted. This will be very helpful when we start working with files to store the data in a human-readable format.

How to Sort the Keys

You can also sort the keys in alphabetical order if you need to. To do this, you just need to write the name of the parameter sort_keys and pass the value True:

? Tip: The value of sort_keys is False by default if you don't pass a value.

For example:

client_JSON = json.dumps(client, sort_keys=True)

Returns this string with the keys sorted in alphabetical order:

{"age": 56, "eye_color": "green", "id": "45355", "name": "Nora", "wears_glasses": false}

How to Sort Alphabetically and Indent (at the same time)

To generate a JSON string that is sorted alphabetically and indented, you just need to pass the two arguments:

In this case, the output is:

{ "age": 56, "eye_color": "green", "id": "45355", "name": "Nora", "wears_glasses": false }

? Tip: You can pass these arguments in any order (relative to each other), but the object has to be the first argument in the list.

Great. Now you know how to work with JSON strings, so let's see how you can work with JSON files in your Python programs.

? JSON and Files

Typically, JSON is used to store data in files, so Python gives us the tools we need to read these types of file in our program, work with their data, and write new data.

? Tip: a JSON file has a .json extension:

Let's see how we can work with .json files in Python.

How to Read a JSON File in Python

Let's say that we created an orders.json file with this data that represents two orders in a pizza shop:

{ "orders": [ { "size": "medium", "price": 15.67, "toppings": ["mushrooms", "pepperoni", "basil"], "extra_cheese": false, "delivery": true, "client": { "name": "Jane Doe", "phone": null, "email": "[email protected]" } }, { "size": "small", "price": 6.54, "toppings": null, "extra_cheese": true, "delivery": false, "client": { "name": "Foo Jones", "phone": "556-342-452", "email": null } } ] }

Please take a moment to analyze the structure of this JSON file.

Here are some quick tips:

  • Notice the data types of the values, the indentation, and the overall structure of the file.
  • The value of the main key "orders" is an array of JSON objects (this array will be represented as list in Python). Each JSON object holds the data of a pizza order.

If we want to read this file in Python, we just need to use a with statement:

? Tip: In the syntax above, we can assign any name to file (green box). This is a variable that we can use within the with statement to refer to the file object.

The key line of code in this syntax is:

data = json.load(file)
  • json.load(file) creates and returns a new Python dictionary with the key-value pairs in the JSON file.
  • Then, this dictionary is assigned to the data variable.

? Tip: Notice that we are using load() instead of loads(). This is a different function in the json module. You will learn more about their differences at the end of this article.

Once we have the content of the JSON file stored in the data variable as a dictionary, we can use it to do basically anything we want.

Examples

For example, if we write:

print(len(data["orders"]))

The output is 2 because the value of the main key "orders" is a list with two elements.

We can also use the keys to access their corresponding values. This is what we typically do when we work with JSON files.

For example, to access the toppings of the first order, we would write:

data["orders"][0]["toppings"]
  • First, we select the main key "orders"
  • Then, we select the first element in the list (index 0).
  • Finally, we select the value that corresponds to the key "toppings"

You can see this "path" graphically in the diagram:

If we print this value, the output is:

['mushrooms', 'pepperoni', 'basil']

Exactly what we expected. You just need to "dive deeper" into the structure of the dictionary by using the necessary keys and indices. You can use the original JSON file/string as a visual reference. This way, you can access, modify, or delete any value.

? Tip: Remember that we are working with the new dictionary. The changes made to this dictionary will not affect the JSON file. To update the content of the file, we need to write to the file.

How to Write to a JSON File

Let's see how you can write to a JSON file.

The first line of the with statement is very similar. The only change is that you need to open the file in 'w' (write) mode to be able to modify the file.

? Tip: If the file doesn't exist already in the current working directory (folder), it will be created automatically. By using the 'w' mode, we will be replacing the entire content of the file if it already exists.

There are two alternative ways to write to a JSON file in the body of the with statement:

  • dump
  • dumps

Let's see them in detail.

First Approach: dump

This is a function that takes two arguments:

  • The object that will be stored in JSON format (for example, a dictionary).
  • The file where it will be stored (a file object).

Let's say that the pizza shop wants to remove the clients' data from the JSON file and create a new JSON file called orders_new.json with this new version.

We can do this with this code:

# Open the orders.json file with open("orders.json") as file: # Load its content and make a new dictionary data = json.load(file) # Delete the "client" key-value pair from each order for order in data["orders"]: del order["client"] # Open (or create) an orders_new.json file # and store the new version of the data. with open("orders_new.json", 'w') as file: json.dump(data, file)

This was the original version of the data in the orders.json file. Notice that the "client" key-value pair exists.

{ "orders": [ { "size": "medium", "price": 15.67, "toppings": ["mushrooms", "pepperoni", "basil"], "extra_cheese": false, "delivery": true, "client": { "name": "Jane Doe", "phone": null, "email": "[email protected]" } }, { "size": "small", "price": 6.54, "toppings": null, "extra_cheese": true, "delivery": false, "client": { "name": "Foo Jones", "phone": "556-342-452", "email": null } } ] } 

This is the new version in the orders_new.json file:

{"orders": [{"size": "medium", "price": 15.67, "toppings": ["mushrooms", "pepperoni", "basil"], "extra_cheese": false, "delivery": true}, {"size": "small", "price": 6.54, "toppings": null, "extra_cheese": true, "delivery": false}]}

If you analyze this carefully, you will see that the "clients" key-value pair was removed from all the orders.

However, there is something missing in this file, right?

Please take a moment to think about this... What could it be?

Indentation, of course!

The file doesn't really look like a JSON file, but we can easily fix this by passing the argument indentation=4 to dump().

Now the content of the file looks like this:

{ "orders": [ { "size": "medium", "price": 15.67, "toppings": [ "mushrooms", "pepperoni", "basil" ], "extra_cheese": false, "delivery": true }, { "size": "small", "price": 6.54, "toppings": null, "extra_cheese": true, "delivery": false } ] }

What a difference! This is exactly what we would expect a JSON file to look like.

Now you know how to read and write to JSON files using load() and dump(). Let's see the differences between these functions and the functions that we used to work with JSON strings.  

? load() vs. loads()

This table summarizes the key differences between these two functions:

? Tip: Think of loads() as "load string" and that will help you remember which function is used for which purpose.

? dump() vs. dumps()

Here we have a table that summarizes the key differences between these two functions:

? Tip: Think of dumps() as a "dump string" and that will help you remember which function is used for which purpose.

? Important Terminology in JSON

Finally, there are two important terms that you need to know to work with JSON:

  • Serialiseerimine: objekti teisendamine JSON-stringiks.
  • Deserialiseerimine: JSON-stringi teisendamine objektiks.

? Kokkuvõttes

  • JSON (JavaScripti objektide märge) on andmete esitamiseks ja salvestamiseks kasutatav vorming.
  • Seda kasutatakse tavaliselt andmete edastamiseks veebis ja konfiguratsiooniseadete salvestamiseks.
  • JSON-failidel on .jsonlaiend.
  • Võite teisendada JSON-stringid Pythoni objektideks ja vastupidi.
  • Saate lugeda JSON-faile ja luua Pythoni objekte nende võtmeväärtuste paaridest.
  • Pythoni objektide sisu JSON-vormingus salvestamiseks võite kirjutada JSON-failidesse.

Loodan väga, et teile meeldis minu artikkel ja see oli teile kasulik. Nüüd teate, kuidas JSON-iga Pythonis töötada. Jälgige mind Twitteris @ EstefaniaCassN ja vaadake minu veebikursusi.