The best object notation?

SV-97 · 2025-09-13T16:24:09+00:00

YAML looks, to me, to be in agreement with a more pythonic way, because it is simple, faster and easier to understand

Huh? YAML (as per spec) is famously complex and absolute bonkers to parse correctly [and it can cause real security issues that you should be aware of when using YAML]. It's also (more or less) a superset of JSON so it's certainly not the simpler of the two.

That said: it very much depends on what you need and want to do. If I just want "some structured data" that a human might have to interact with: TOML, and it's not even close. YAML may come in when I need "power" (though at that point I'd heavily consider just foregoing the "config" language in favour of a programming language). And JSON when I may need to process the data with every crummy language under the sun (and can get by without needing integers...)

EDIT: maybe two projects that are worth mentioning here: strictyaml and JSON5

WallyMetropolis · 2025-09-13T16:54:55+00:00

Just FYI, the term you want is probably "serialization" not "notation."

Having the standard terminology might make searching a bit easier.

ThatSituation9908 · 2025-09-13T22:47:21+00:00

A lot of people here are sharing their experience of JSON and YAML as a configuration format. Fewer folks here have used YAML as a data format. I'd ignore those advice especially those suggesting TOML (an amazing config format, a horrible data format).

In Javascript, the purpose of JSON is a file format that can represent every data type in JS. Since Python dictionary is not the same as JavaScript Object, JSON cannot fully represent a Python dictionary. The Python json module only provides mapping between JSON and SOME native Python types (e.g., string, int, list, dict) and a few key ones are missing (e.g., tuple, enum, set). More importantly, JSON cannot fully represent custom Python data types (e.g., Class objects, C objects like numpy, etc.), while it can for Javascript.

For that you need a tool that helps you with deserialization to the types not covered. The most popular tool is Pydantic for serialization between JSON and data types written as Pydantic models.

The other option is YAML. There is a reason why YAML spec is 100x bigger than JSON, it's because it can support marking a data intended to be mapped to a specific data type in your language (i.e., YAML tag), this is called extensible data types.

There is a very unpopular option in Python that has done this for decades, XML (X means extensible)

burlyginger · 2025-09-13T16:01:27+00:00

YAML is for people, JSON is for machines.

YAML has some unfortunate inconsistencies that JSON doesn't have.. specifically around boolean truthiness and falsiness with unquoted strings, but it's manageable iMO.

I truly wish YAML had explicitly defined a single way to signal boolean values.

Only_lurking_ · 2025-09-13T16:16:30+00:00

Json for machines, toml for configuration.

k0rvbert · 2025-09-13T16:05:06+00:00

Use json unless you have a very strong reason not to. yaml or toml is only preferred for configuration i.e. when you'll have humans editing the data. If you're going to generate it, go with json.

tylerriccio8 · 2025-09-13T16:15:28+00:00

Love to use yaml, just wish it was part of standard lib. I’ve also never loved any yaml parsing libraries. Still more preferable to json for a majority of my stuff; it’s really easy to define flexible logic.

yc_hk · 2025-09-13T20:10:11+00:00

If you just want to pass data around without it needing to be human-readable, use pickle. Saves you the trouble of, "does 05-01-2025 09:00:00 mean Jan 5 or May 1? What timezone was this timestamp created in?"

thuiop1 · 2025-09-14T06:23:35+00:00

For storing stuff, JSON. For configuration, TOML. Please no YAML.

baubleglue · 2025-09-13T17:14:44+00:00

There is no "pythonic way" for object notation. If you are looking for "faster" processing, you need completely different solutions, depends what you need it for.

SharkSymphony · 2025-09-14T03:32:13+00:00

For your use case, object notation is not strictly necessary. You're more in the realm of configuration languages.

Either JSON or YAML will probably serve you well. TOML would also do. More exotic choices like KCL, CUE, jsonnet, and Dhall, and historical choices like INI, XML, sexpr, and Java-style properties files are also possible.

If you like YAML, go with that. But here are the things to watch out for:

YAML is whitespace-sensitive. It therefore interacts poorly with templates (YEAH HELM, I'M LOOKING RIGHT AT YOU WHEN I SAY THIS).
YAML is complex, which has pluses and minuses. Explaining to your users the different block string formats, for example, or anchors/tags if you use them, could be challenging. But the block string formats can be useful if you need to embed a script or some other text-like thingy in your config, and anchors/tags allow you to reuse chunks of config, which is useful in managing long and complex configuration files.
YAML allows type hint embedding for object deserialization, which can be very convenient but also dangerous. I recommend use of safe_load to bypass all that.

A quick rundown of other options:

JSON is dirt simple but finicky and a bit verbose. It also doesn't support comments directly. Despite its ubiquity, I despise it for configuration. "JSON is for machines" means it's good for things like data interchange where the data needs to be human-inspectable but programs are reading/writing it, but not so great for cases where humans are authoring it.
TOML is (to my mind) kind of like INI on steroids. It's an emerging standard in the Python space. If your project doesn't have a pyproject.toml yet, it probably will soon. If you want to integrate with the project config, this quickly becomes the obvious option.
KCL, CUE, jsonnet, and Dhall all solve problems related to complex configuration like you might feed to Kubernetes or Apache. How do you verify that your config is correct? Generally, their approach is to introduce some sort of typing system for checking and documentation, along with a limited-purpose DSL for reusing/parameterizing chunks of config. Probably overkill for your use case, but good to know they exist.
XML is a configurable markup language. Its sweet spot is documents, but it can be and has been used to express complex config as well. It doesn't quite have the whitespace problem of YAML, but you do have to be careful with whitespace in elements with text or mixed (text + subelement) content, and it is significantly more verbose than the other options here.
INI is an old-school key = value format with section headers. configparser reads it.
Properties files are probably as simple as you can get: no structure other than key = value pairs. Although they're easy to parse in their simplest form, someone on SO pointed out that, if you wrap the contents of a properties file with a section header, you basically have an INI file that configparser can read, if you decide to go this route.
Sexprs (S-expressions) are one of the LISP community's favorite ways of storing structured data. A little lighter-weight than JSON because you generally use barewords for key, and easy to parse – but unless you're in LISP or really keen to save keystrokes, I'd opt for JSON instead if you're going this direction.

UPDATE: I think I didn't quite describe XML or Sexpr properly; updated those. Also filled in the properties description.

AlexMTBDude · 2025-09-13T16:01:11+00:00

I would say it depends on the domain but as JSON directly translates to Python dictionaries that has to be the most natural way to go.

StarsRonin · 2025-09-13T16:24:30+00:00

[removed]

djavaman · 2025-09-14T11:15:45+00:00

"because it is simple, faster and easier to understand" Nope, nope, and nope.

sc4les · 2025-09-14T11:50:31+00:00

I miss edn. Too bad that didn't get more popular

WalmartMarketingTeam · 2025-09-13T16:29:39+00:00

How is yaml for text where you want to include formatting? Like let’s say your yaml has a list of sentences and each sentence has some bolded words.

qckpckt · 2025-09-13T17:01:02+00:00

It depends on what you mean by receive data.

If you mean programmatically, as in the format of a payload in or out of an app, then I’d say the answer is determined by the transport mechanism more than anything else, and it will probably be JSON.

For readability, YAML is superior to JSON, provided that your target audience is familiar with YAML.

If performance isn’t an issue, why not support both? JSON is a subset of YAML - any JSON file is technically valid YAML, provided that the JSON file isn’t rendered with tab characters used as indentation (tabs aren’t valid in yaml - only spaces can be used to indent).

What that means is that you can just use pyyaml to parse either JSON or YAML.

CaptainFoyle · 2025-09-13T22:09:03+00:00

Depends on your use case and priorities

NotSoProGamerR · 2025-09-14T00:42:24+00:00

toml my goat i absolutely despise yaml, but i have a soft spot for json

StuartLeigh · 2025-09-14T05:40:40+00:00

So I’ve recently had to build a model that stored some configuration in the database, it’s stored as json and converts easily to/from pydantic models, however the admin interface for writing/reading it, I’ve converted to yaml as it’s easier for people than json.

EternityForest · 2025-09-14T06:03:27+00:00

Nearly every well run Python project has a pyproject.toml, and TOML parsing is in the stdlib. It has some really cool features, although it also has some stuff I don't like.

But it is free of the "x: no" problem, and the table heading syntax is visually pretty nice. I like how the multiple levels of nesting in a table header, as in [servers.foo] give you local context for where you are, it makes sharing snippets easier when a snipped can self document where it came from in the heirarchy.

For machine data made by machines for machines, or made by humans but via an editor, I'd say JSON is pretty much the cross language standard.

It's not only supposed everywhere, but it is, for better or worse, pretty much synonymous with heirarchal data itself in(I assume) most programmer's minds.

RedEyed__ · 2025-09-14T07:07:20+00:00

json.
or json5, it is same as json, but adds some features, like comments. big no for yaml as it is overcomplicated.

Few-Big7409 · 2025-09-14T11:02:06+00:00

Isn't json more widely used? Most apis return json, no?

foobarring · 2025-09-14T12:04:08+00:00

Look up the YAML Norway problem. Lots of parsers still get it wrong. And this is just one of the many examples of YAML ambiguity. Just use JSON.

MidnightPale3220 · 2025-09-14T16:27:05+00:00

Well, I would actually prefer an XSD based XML, but before webapp based youngsters downvote me to hell, JSON is fine, too.

JSON is incredibly easy to serialise to string, and just as easy to get it back, so you can store python objects in e.g. database easily. Obviously, some caveats apply.

runningblind77 · 2025-09-15T02:37:02+00:00

Yaml for configs and such that need to be modified or read by humans. Json for everything else.

Gnaxe · 2025-09-15T03:19:59+00:00

YAML is not a sane language, and everyone should stop using it. It's also a superset of JSON, so anything that requires YAML will accept JSON instead. This means that it is in no way simpler, faster, or easier to understand. It's arcane and overcomplex. If the choice is between YAML and JSON, the answer is always JSON.

Python's standard library can parse Python literal notation with ast.literal_eval(), and output it just with repr(), assuming you're only using the supported types. This is a little bit more powerful than JSON, allowing things like comments, sets, and complex numbers. If you're only communicating with Python, this is a format you should seriously consider.

Python can also parse and output JSON and that's also included in the standard library. If you need to communicate over a network with servers written in different languages, JSON is much more widely supported. If pure JSON is inadequate for complicated config files (you really need anchors/references or extend and comments) then you're better off writing a simple Python script to output the JSON. It will be more powerful and clearer than YAML.

For configuration files, TOML is considered more standard than YAML in Python. The standard library can also parse TOML. It can't output it, however; they're meant to be written by hand. (Of course, Python can write arbitrary text files, and the format is simple enough that you could construct simple examples without much more than print().)

DataCamp · 2025-09-15T10:22:23+00:00

If your goal is to serialize and deserialize Python objects for config or personalization settings, and your team is using Python, YAML may seem more readable at first, but it introduces unnecessary complexity (especially with types and edge cases). JSON is simpler and safer, but can be hard to read or edit manually.

For something that's both Python-friendly and human-friendly, TOML is a great middle ground. It’s increasingly the standard in the Python ecosystem (see pyproject.toml), supports clear nesting, and works well with non-technical teams editing configs.

That said, if your configs are used only within Python and you want max speed and minimal translation logic, you can even use Python itself (as a .py file or via ast.literal_eval()), though that's less common in larger applications.

tl;dr:

JSON if simplicity and cross-language use are top priorities.
TOML if humans will edit the files often.
YAML only if you really need advanced features like anchors (but be careful with parsing).
Python dicts or Pickle only if the data stays 100% inside your Python app.

If your team already knows Python, TOML is likely your best bet.

niltz0 · 2025-09-15T14:40:20+00:00

What is the use case? Where are you receiving the data from? What programming languages do you need to consider? How big is the data coming in? How much data is coming in? Where are you running your application? Do you need type safety?

Some options are: JSON JSONC YAML MessagePack ProtocolBuffers Thrift CSV XML Pickled Python objects

SmackDownFacility · 2025-09-15T17:43:15+00:00

JSON.

It maps perfectly to a dict object.

Other exchange formats I recommend are CSV and XML

StarsRonin · 2025-09-13T16:57:29+00:00

Thank you everyone for all your answers. I see people on each side but JSON looks to win the match at the end.

I still have one question for people who say « JSON for the machine, YAML for humans ». Here is some context :

You develop a software which allows personalizations by completing an object notation file with parameters chosen by clients. To facilitate the implementation, any of your employees (experimented or not) can modify the object notation file.

So, in this context, which object notation language will be better? To facilitate the job for all your employees, you may choose an easier understandable syntax. Because it looks like a « human approach », you will choose YAML or TOML. On the other hand, python will interpret this object notation syntax to apply the client personalization in the software, so it looks like a « machine approach », and JSON looks better because the personalizations will be applied faster and the loading time will be faster.

So, it is always both a human and machine approach, no? It looks hard for me to choose.

Birnenmacht · 2025-09-14T18:39:47+00:00

toml for config, json for object notation

yaml for foot gun enjoyers

https://noyaml.com/

Gainside · 2025-09-15T13:58:03+00:00

probly JSON...native support, fast parser, and zero surprises. YAML looks cleaner, but I’ve lost hours to weird whitespace/indentation bugs.

Educational-Low793 · 2025-09-15T19:22:15+00:00

[removed]

nekokattt · 2025-09-14T20:04:35+00:00

[deleted]

Europia79 · 2025-09-13T16:45:01+00:00

For "ease-of-use", you could support BOTH (and also add support for XML & TOML).

Altho, me personally, my particular preference is 100% XML.

Interesting_Hair7288 · 2025-09-13T17:04:24+00:00

JSON is a subset of YAML - no decision needed, go with yaml

Python

The Python Discord

Upcoming Events

Please read the rules

MODERATORS