Embed json in yaml

Python Object Serialization : yaml & json

What is yaml?

Let’s see how it looks like (from wiki):

– receipt: Oz-Ware Purchase Invoice date: 2012-08-06 customer: given: Dorothy family: Gale items: – part_no: A4786 descrip: Water Bucket (Filled) price: 1.47 quantity: 4 – part_no: E1628 descrip: High Heeled “Ruby” Slippers size: 8 price: 100.27 quantity: 1 bill-to: &id001 street: | 123 Tornado Alley Suite 16 city: East Centerville state: KS ship-to: *id001 specialDelivery: > Follow the Yellow Brick Road to the Emerald City. Pay no attention to the man behind the curtain. …

  1. strings do not require quotations.
  2. The specific number of spaces in the indentation is unimportant as long as parallel elements have the same left justification and the hierarchically nested elements are indented further.
  3. The sample above defines:
    1. An associative array with 7 top level keys
    2. The “items” key contains a 2-element array (or “list”)
    3. Each element of which is itself an associative array with differing keys.
    4. Relational data and redundancy removal are displayed:
      1. The “ship-to” associative array content is copied from the “bill-to” associative array’s content as indicated by the anchor (&) and reference (*) labels.
  4. Optional blank lines can be added for readability.
  5. Multiple documents can exist in a single file/stream and are separated by “-“.
  6. An optional “…” can be used at the end of a file (useful for signaling an end in streamed communications without closing the pipe).

This answer is an abstracts from What is the difference between YAML and JSON?

Technically YAML is a superset of JSON. This means that, in theory at least, a YAML parser can understand JSON, but not necessarily the other way around.

Read more: Ts node is not recognized as an internal or external command

See the official specs, in the section entitled “YAML: Relation to JSON”.

In general, there are certain things available from YAML that are not available from JSON.

YAML is visually easier to look at. In fact the YAML homepage is itself valid YAML, yet it is easy for a human to read. YAML has the ability to reference other items within a YAML file using “anchors.” Thus it can handle relational information as one might find in a MySQL database. YAML is more robust about embedding other serialization formats such as JSON or XML within a YAML file. In practice neither of these last two points will likely matter for things that we do, but in the long term, YAML may be a more robust and viable data serialization format.

We can use YAML Lint to validate *.yml file.

Read more: Talking cuck

But it doesn’t like the “…” in the last line. Otherwise the sample document passes the validation test.

Let’s convert the following json to yaml:

{ “foo”: “bar”, “baz”: [ “qux”, “quxx” ], “corge”: null, “grault”: 1, “garply”: true, “waldo”: “false”, “fred”: “undefined”, “emptyArray”: [], “emptyObject”: {}, “emptyString”: “” }

Python code:

import json import yaml sample = { “foo”: “bar”, “baz”: [ “qux”, “quxx” ], “corge”: None, “grault”: 1, “garply”: True, “waldo”: “false”, “fred”: “undefined”, “emptyArray”: [], “emptyObject”: {}, “emptyString”: “” } json_obj = json.dumps(sample) print ‘json_obj =’, json_obj ff = open(‘data.yml’, ‘wb’) yaml.dump(sample, ff, default_flow_style=False) ydump = yaml.dump(sample, default_flow_style=False) print ‘ydump=’,ydump


json_obj = {“emptyObject”: {}, “emptyString”: “”, “emptyArray”: [], “corge”: null, “waldo”: “false”, “grault”: 1, “garply”: true, “foo”: “bar”, “baz”: [“qux”, “quxx”], “fred”: “undefined”} ydump= baz: – qux – quxx corge: null emptyArray: [] emptyObject: {} emptyString: ” foo: bar fred: undefined garply: true grault: 1 waldo: ‘false’

Read more: Messi tattoo design

If we open the data.yml :

baz: – qux – quxx corge: null emptyArray: [] emptyObject: {} emptyString: ” foo: bar fred: undefined garply: true grault: 1 waldo: ‘false’

We can check our conversion is correct via yamllint:


We can reads in the yaml and write it to json:

stream = file(‘data.yml’, ‘r’) yml_loaded = yaml.load(stream) with open(‘data.json’,’wb’) as f: json.dump(yml_loaded, f)

The data.json looks like this:

{“emptyObject”: {}, “emptyArray”: [], “waldo”: “false”, “baz”: [“qux”, “quxx”], “emptyString”: “”, “corge”: null, “grault”: 1, “garply”: true, “foo”: “bar”, “fred”: “undefined”}

We can check the conversion using one of the online conversion tools:

Related Posts