Introduction to XML

From Text to Usable Data

A JSON response begins as text, but working with that text directly would make data extraction inconvenient. The important boundary is json.loads(). It converts the JSON string into native Python data structures: dictionaries for JSON objects and lists for JSON arrays. After that conversion, the data can be accessed with ordinary Python indexing and iteration patterns rather than additional library calls for navigation.

Nested Python Structures

A JSON object becomes a Python dictionary, so its named data is reached through dictionary keys. A JSON array becomes a Python list, so its items are reached through list indexes. When objects and arrays are nested, the resulting Python structure is nested too. You follow the structure one level at a time: use a key when the current value is a dictionary and use an index when the current value is a list.

import json data_text = '{"profile": {"name": "Ada", "skills": ["Python", "XML"]}}' data = json.loads(data_text) name = data["profile"]["name"] second_skill = data["profile"]["skills"][1]

name: Ada
second_skill: XML

Following Keys and Indexes

JSON and XML Paths

Both JSON and XML can represent structured information, but reaching a value is not equally direct. Parsed JSON maps directly to Python dictionaries and lists, so extraction can use ordinary keys, indexes, and iteration patterns. XML has a self-descriptive structure and remains valuable when explicit semantic tagging or document-centric representation is important. However, the source material contrasts XML parsing with the simpler and more readable access made possible by JSON's direct Python mapping.

Why Web Services Prefer JSON

JSON became the industry standard for web services primarily because its structure maps directly to Python dictionaries and lists. That mapping lets a program parse the string and then use familiar indexing and iteration patterns immediately. The resulting extraction code is simpler and more readable than XML parsing code in the comparison described here.

This does not make XML useless. XML retains an advantage when a self-descriptive structure and explicit semantic tagging matter more than parsing simplicity, especially in document-centric applications. The practical choice depends on whether direct data consumption or richly explicit document structure is the stronger requirement.

Mistakes with Nested Access

• Treating the result of json.loads() as if it were still only raw text.

  json.loads() converts the JSON string into native Python lists and dictionaries.

  Fix: Inspect the structure conceptually and follow it with key access for dictionaries and index access for lists.

• Using a list index where a dictionary key is needed.

  The profile value is reached through a dictionary key, not a list position.

  Fix: Use the named key first, then use an index only after reaching a list.

• Using a dictionary key where a list index is needed.

  The skills value is represented as a Python list.

  Fix: Use a list index such as 1 to select an item from that list.

• Assuming XML and JSON offer the same extraction path.

  The source comparison identifies XML parsing and navigation as more involved and verbose.

  Fix: Choose the access approach that matches the representation and recognize JSON's direct Python mapping as its main convenience.

Practice the Access Path

Key Takeaways

1. json.loads() converts a JSON string into native Python dictionaries and lists.
2. Parsed JSON can be accessed directly with dictionary keys, list indexes, and iteration patterns.
3. Nested extraction is a sequence of accesses: use keys for dictionaries and indexes for lists.
4. JSON is widely used for web services because its direct Python mapping makes consumption simpler and more readable than XML parsing.
5. XML remains valuable when self-descriptive structure and explicit semantic tagging are more important than parsing simplicity.