of JSON data is almost identical to a Python dictionary. It is shorter than XML,

and can be quickly parsed by browsers since it uses JavaScript syntax. This makes

JSON an ideal format for transporting data between a client and a server. If

your client is not a browser, don't worry. Android and other mobile operating

systems all come equipped with tools for parsing and working with JSON. Today, I

will show you how to use Python's JSON library to send and receive JSON data

packets. We'll have a ton of fun with JSON sent from my Rayguns. Pew Pew!

Here is a typical JSON data packet. Notice how it looks just like a Python dictionary with

a few exceptions. True and false are not capitalized in JSON, while in Python

they are. And instead of none you use JavaScript value null. This JSON object

contains examples of all possible data types. All the keys are strings, but the

values can be strings, numbers, booleans, a list, null, or even another JSON object. Now

compare this with the XML version. The increased size of XML data is largely

due to the end tags repeating the text of the opening tags. A popular sport is

debating the merits of JSON versus XML. But instead of arguing, I recommend you

learn the pros and cons of both formats, then choose the one which is best for your project.

Let's now learn how to use the JSON module in Python.

First, let's save the sample JSON data to a txt file.

Notice the Cinematographer's name

contains a non ASCII character. For this reason, we will save this text file using

utf-8 encoding. Begin by importing the JSON module. Next, let's look at the

methods in this module. Today, we will focus on the load and dump methods.

The load method allows you to load JSON data from a file, while the load s method

enables you to load JSON data from a string. That's why there's an S at the

end of the method name: s for string. The dump method will

write JSON data to a file, and the dump s method will output a string in proper

JSON format. Let's see some examples. First, we will load the JSON data from

the file we created earlier. Using the open function, the first argument is the

path to the file. For the second argument, let's pass R, since we are only reading

the data. Next, specify the encoding is utf-8, since this data contains non ASCII

characters. Now that we have opened the file, we can load the JSON data using the

load method. After loading the JSON data, close the file. If you display the object,

you will see a dictionary containing all the data. If you look at the type, you

will see it is, in fact, a dictionary. Also notice how the true/false and null

values from the file were correctly parsed into Python true/false and none

values. And the non ASCII character was correctly parsed. If you look up the 142

Unicode character, it is a lowercase L with the stroke. Because this is a

dictionary, you can access the data by key. We can see the title, the list of

actors, and so on.

You use the load s function if your JSON data arrives in

the form of a string. This is common in client-server applications where data is

sent over the net. As an illustration, let's create a string with a JSON

formatted value. To parse this JSON data, call the load s function. Since all

characters are ASCII, there is no need to worry about encoding. If you look at the

result, we have a valid Python dictionary with all data properly converted. False

is the Python boolean and null was converted to none.

Suppose you want to store the data about Gattaca in a database, or send it to a remote user.

To convert this dictionary into a valid JSON string you use the dump s method

When you call the method simply pass in the dictionary. The result is a string in

proper JSON format. Notice that true and false are both lowercase, and none was

converted to null. There is an unusual double stroke for the non ASCII

character, however. This is because the JSON library assumes you want the output

to be ASCII, and will escape all non-ASCII

characters. To avoid this, and allow Unicode characters in your string, call

dump s, and set ensure ASCII to false. The non ASCII character is now preserved and

the backslash is not escaped.

Let's now create a new object, convert it to JSON,

and write it to a file. we start by creating a dictionary. For this example,

we will use data for the movie Minority Report. Directed by Steven Spielberg, with

a soundtrack by John Williams... this is a must-see movie for any Python programmer.

The cinematographer is Janusz Kaminsky. The N in his last name has an accent

with a Unicode values of 144. To write this to a file in JSON format, we must

first open a file in write mode with utf-8 encoding. Next call the dump

method. The first argument is the dictionary. Now pass in the file.

Remember to set ensure ASCII to false, since our data contains non ASCII characters.

Finally, close the file. If we open the file, we see all the data is there.

Everything is properly formatted, and the Unicode characters are all accounted for

Please wait for an incoming message from Socratica...

This JSON says Patreon helps Python to carry on...

and since rhyming sentences are twice as likely to be true

as ordinary ones, this message must be as good as gold...

which is what we are asking for, if you have some to spare.