Python Working with JSON Exercises

JSON (JavaScript Object Notation) is a lightweight, widely used format for storing and exchanging structured data between applications. In Python, the built-in `json` module makes it easy to parse (load) JSON strings into Python objects and convert (dump) Python objects into JSON strings.

JSON is commonly used in web development, APIs, configuration files, and data interchange between systems. Understanding how to handle JSON in Python is crucial when building real-world applications.

Consider the following Python code:

import json

data = '{"name": "Alice", "age": 30, "city": "New York"}'
parsed = json.loads(data)
print(parsed["name"])

What does this code demonstrate about Python’s handling of JSON?

JSON strings must be manually split and parsed in Python.

The json.loads() function parses a JSON string into a Python dictionary.

The code throws an error because JSON cannot be used in Python without third-party libraries.

The json module only works with files, not strings.

This code snippet uses the json.loads() function to parse a JSON-formatted string into a Python dictionary.

data is a valid JSON string that contains key-value pairs.
json.loads(data) converts the string into a Python dictionary:

{'name': 'Alice', 'age': 30, 'city': 'New York'}

You can then access values using dictionary syntax like parsed["name"].

The json module also includes:

json.dumps() to convert Python objects (like dicts or lists) into JSON strings.
json.load() and json.dump() to read from and write to files.

This is useful when working with web APIs, config files, and data exchange formats — making JSON an essential skill in every Python developer’s toolkit.

How can you convert a Python dictionary into a JSON string?

import json
json.dump(my_dict)

import json
json.dumps(my_dict)

import json
json.stringify(my_dict)

import json
json.to_json(my_dict)

The correct method to convert a Python dictionary into a JSON string is json.dumps(). The dumps method stands for "dump string," and it serializes a Python object into a JSON-formatted string. The other options are either incorrect method names or functions that don't exist in the json module.

Which of the following is the correct way to load a JSON string into a Python dictionary?

import json
my_dict = json.loads('{"name": "John", "age": 30}')

import json
my_dict = json.dump('{"name": "John", "age": 30}')

import json
my_dict = json.load('{"name": "John", "age": 30}')

import json
my_dict = json.parse('{"name": "John", "age": 30}')

The correct method to load a JSON string into a Python dictionary is json.loads(), where loads stands for "load string." This method parses the JSON string and returns a Python dictionary. The other options use incorrect methods or function names.

What is the output of the following code?

import json

data = {"name": "Alice", "age": 25}
json_string = json.dumps(data)
print(json_string)

{"name": Alice, age: 25}

{"name": "Alice", "age": 25}

{'name': 'Alice', 'age': 25}

["name": "Alice", "age": 25]

When using json.dumps(), the Python dictionary is serialized into a JSON-formatted string. The correct format for JSON keys and string values includes double quotes, so the output will be {"name": "Alice", "age": 25}. Option 3 uses single quotes, which is not valid for JSON, and option 4 uses square brackets, which represent lists in JSON.

Which method in the `json` module is used to write JSON data to a file?

json.to_file()

json.write()

json.dump()

json.save()

The correct method to write JSON data to a file is json.dump(). This method serializes a Python object and writes it to a file in JSON format. The other options are not valid methods in the json module.

You have a JSON file `data.json` containing the following data:

{
  "students": [
    {"name": "Alice", "age": 23},
    {"name": "Bob", "age": 25},
    {"name": "Charlie", "age": 22}
  ]
}

Which of the following code snippets correctly loads the file and retrieves the names of all students?

import json
with open("data.json") as f:
    data = json.load(f)
names = [student["name"] for student in data["students"]]

import json
with open("data.json") as f:
    data = json.dumps(f)
names = [student["name"] for student in data["students"]]

import json
with open("data.json") as f:
    data = json.loads(f)
names = [student["name"] for student in data["students"]]

import json
with open("data.json") as f:
    data = json.load(f)
names = [student["name"] for student in f["students"]]

In this question, we need to load the contents of the data.json file into a Python object using json.load(f) and then access the list of students to extract their names. Option 1 is the correct one because it uses the json.load() function to parse the file, and the list comprehension correctly accesses the "students" key to retrieve each student's name. The other options either use incorrect methods or try to access the file object instead of the data.

Consider the following JSON data:

{
  "products": [
    {"id": 1, "name": "Laptop", "price": 999},
    {"id": 2, "name": "Smartphone", "price": 499},
    {"id": 3, "name": "Tablet", "price": 299}
  ]
}

You need to increase the price of all products by 10%. Which code snippet will correctly perform this task?

import json
with open("products.json") as f:
    data = json.loads(f)
for product in data["products"]:
    product["price"] *= 1.10

import json
with open("products.json") as f:
    data = json.loads(f)
for product in data["products"]:
    product["price"] *= 1.10

import json
with open("products.json") as f:
    data = json.load(f)
for product in data["products"]:
    product["price"] += 0.10

import json
with open("products.json") as f:
    data = json.load(f)
for product in data["products"]:
    product["price"] *= 1.10

To increase the price of all products by 10%, the correct approach is to load the JSON data using json.load(f), iterate through the list of products, and multiply each product's price by 1.10 to get a 10% increase. Option 1 is correct because it uses json.load() to parse the file and correctly updates the prices. The other options either use incorrect methods (json.loads() for file input or json.dumps() for dumping) or incorrectly update the price.

You have a JSON object that contains nested data, and you want to extract a specific field from it. Given the following JSON data:

{
  "user": {
    "name": "John",
    "address": {
      "city": "New York",
      "zipcode": "10001"
    }
  }
}

Which of the following code snippets correctly extracts the `"city"` value?

import json
data = json.loads('{"user": {"name": "John", "address": {"city": "New York", "zipcode": "10001"}}}')
city = data["address"]["city"]

import json
data = json.loads('{"user": {"name": "John", "address": {"city": "New York", "zipcode": "10001"}}}')
city = data["user"]["address"]["city"]

import json
data = json.loads('{"user": {"name": "John", "address": {"city": "New York", "zipcode": "10001"}}}')
city = data["user"]["city"]

import json
data = json.loads('{"user": {"name": "John", "address": {"city": "New York", "zipcode": "10001"}}}')
city = data["address"]["city"]

In this case, the correct way to access the "city" value is by navigating through the nested structure: data["user"]["address"]["city"]. Option 1 correctly accesses the "user" dictionary, then the "address" dictionary, and finally the "city" key. The other options either omit the "address" key or attempt to access "city" incorrectly.

What will be the result of the following code snippet?

import json

data = '{"name": "John", "age": 30}'
parsed_data = json.loads(data)
parsed_data["age"] = 35
json_string = json.dumps(parsed_data)
print(json_string)

{"name": "John", "age": 30}

{"name": "John", "age": 35}

{"name": "John", "age": "35"}

{"name": "John", "age": 30, "age": 35}

In the code, the json.loads() method is used to parse the JSON string into a Python dictionary. The value of "age" is then updated to 35. The dictionary is then converted back into a JSON string using json.dumps(), and the output will reflect the updated "age" value. Therefore, the correct output is {"name": "John", "age": 35}.

Given the following JSON data, you want to retrieve all names of employees who have an age greater than 30. How would you accomplish this?

{
  "employees": [
    {"name": "Alice", "age": 25},
    {"name": "Bob", "age": 35},
    {"name": "Charlie", "age": 40}
  ]
}

import json
with open("employees.json") as f:
    data = json.load(f)
names = [emp["name"] for emp in data["employees"] if emp["age"] == 30]

import json
with open("employees.json") as f:
    data = json.load(f)
names = [emp["name"] for emp in data["employees"] if emp["age"] <= 30]

import json
with open("employees.json") as f:
    data = json.load(f)
names = [emp["name"] for emp in data["employees"] if emp["age"] > 30]

import json
with open("employees.json") as f:
    data = json.load(f)
names = [emp["name"] for emp in data["employees"]]

The correct approach is to load the JSON data using json.load(f) and then filter the employees whose age is greater than 30 using a list comprehension. Option 1 correctly implements this logic by checking emp["age"] > 30. Option 2 and Option 3 are incorrect because they either filter by age less than or equal to 30 or exactly equal to 30, which doesn’t match the requirement. Option 4 retrieves all employee names, regardless of age.

You have a nested JSON object with user data. You want to calculate the average age of all users whose `"status"` is `"active"`. Given the following JSON data:

{
  "users": [
    {"id": 1, "name": "Alice", "age": 25, "status": "active"},
    {"id": 2, "name": "Bob", "age": 30, "status": "inactive"},
    {"id": 3, "name": "Charlie", "age": 35, "status": "active"},
    {"id": 4, "name": "David", "age": 40, "status": "inactive"}
  ]
}

Which of the following code snippets will correctly compute the average age of all active users?

import json
with open("users.json") as f:
    data = json.load(f)
active_users = [user["age"] for user in data["users"] if user["status"] == "active"]
average_age = sum(active_users) / len(active_users)

import json
with open("users.json") as f:
    data = json.load(f)
active_users = [user["age"] for user in data["users"] if user["status"] == "active"]
average_age = sum(active_users)

import json
with open("users.json") as f:
    data = json.load(f)
active_users = [user["age"] for user in data["users"] if user["status"] == "active"]
average_age = active_users / len(active_users)

import json
with open("users.json") as f:
    data = json.load(f)
active_users = [user["age"] for user in data["users"] if user["status"] == "inactive"]
average_age = sum(active_users) / len(active_users)

To calculate the average age of active users, we first filter out users with the "status" of "active". Then we compute the sum of their ages and divide it by the number of active users to get the average. Option 1 correctly implements this approach. Option 2 omits dividing by the number of users, and Option 3 incorrectly attempts to divide the list by its length. Option 4 filters inactive users, which is not the correct condition.

You have a large JSON object containing data about various products, and you need to sort the products by their price in descending order. Given the following JSON data:

{
  "products": [
    {"id": 1, "name": "Laptop", "price": 1000},
    {"id": 2, "name": "Smartphone", "price": 600},
    {"id": 3, "name": "Tablet", "price": 300},
    {"id": 4, "name": "Headphones", "price": 150}
  ]
}

Which of the following code snippets will correctly sort the products by price in descending order?

import json
with open("products.json") as f:
    data = json.load(f)
sorted_products = sorted(data["products"], key=lambda x: x["price"], reverse=False)

import json
with open("products.json") as f:
    data = json.load(f)
sorted_products = sorted(data["products"], key=lambda x: x["price"])

import json
with open("products.json") as f:
    data = json.load(f)
sorted_products = sorted(data["products"], key=lambda x: x["name"], reverse=True)

import json
with open("products.json") as f:
    data = json.load(f)
sorted_products = sorted(data["products"], key=lambda x: x["price"], reverse=True)

To sort the products by price in descending order, we use sorted() with the key argument set to a lambda function that accesses the "price" key, and reverse=True to ensure descending order. Option 4 is correct. Option 1 sorts in ascending order (reverse=False), while Option 2 sorts in ascending order without specifying the reverse flag. Option 3 incorrectly sorts by product name instead of price.

You have a JSON file containing employee data, and you need to update the salary of all employees by adding a 5% bonus. Given the following JSON data:

{
  "employees": [
    {"id": 1, "name": "Alice", "salary": 50000},
    {"id": 2, "name": "Bob", "salary": 60000},
    {"id": 3, "name": "Charlie", "salary": 70000}
  ]
}

Which of the following code snippets will correctly add a 5% bonus to all employee salaries?

import json
with open("employees.json") as f:
    data = json.load(f)
for employee in data["employees"]:
    employee["salary"] *= 1.05

import json
with open("employees.json") as f:
    data = json.load(f)
for employee in data["employees"]:
    employee["salary"] += 0.05

import json
with open("employees.json") as f:
    data = json.load(f)
for employee in data["employees"]:
    employee["salary"] += employee["salary"] * 0.05

import json
with open("employees.json") as f:
    data = json.load(f)
for employee in data["employees"]:
    employee["salary"] += 5

To add a 5% bonus, the salary should be increased by multiplying the current salary by 0.05 and adding that to the original salary. Option 3 correctly implements this approach. Option 1 is incorrect because it multiplies the salary by 1.05 directly, which would still work but is less clear. Option 2 adds a fixed value 0.05 rather than a percentage, which is incorrect. Option 4 adds a fixed bonus of 5, which doesn’t account for percentages.

You have the following JSON object with transaction data. You need to calculate the total amount of transactions for each user, where the transaction type is `"credit"`. Given the following JSON data:

{
  "transactions": [
    {"user_id": 1, "amount": 100, "type": "credit"},
    {"user_id": 2, "amount": 200, "type": "debit"},
    {"user_id": 1, "amount": 150, "type": "credit"},
    {"user_id": 3, "amount": 50, "type": "credit"},
    {"user_id": 2, "amount": 300, "type": "credit"}
  ]
}

Which of the following code snippets will correctly calculate the total amount for each user where the transaction type is `"credit"`?

import json
with open("transactions.json") as f:
    data = json.load(f)
totals = {}
for transaction in data["transactions"]:
    if transaction["type"] == "credit":
        if transaction["user_id"] not in totals:
            totals[transaction["user_id"]] = 0
        totals[transaction["user_id"]] += transaction["amount"]

import json
with open("transactions.json") as f:
    data = json.load(f)
totals = {}
for transaction in data["transactions"]:
    if transaction["type"] == "debit":
        if transaction["user_id"] not in totals:
            totals[transaction["user_id"]] = 0
        totals[transaction["user_id"]] += transaction["amount"]

import json
with open("transactions.json") as f:
    data = json.load(f)
totals = {}
for transaction in data["transactions"]:
    if transaction["type"] == "credit":
        totals[transaction["user_id"]] = totals.get(transaction["user_id"], 0) + transaction["amount"]

import json
with open("transactions.json") as f:
    data = json.load(f)
totals = {}
for transaction in data["transactions"]:
    if transaction["type"] == "credit":
        totals[transaction["user_id"]] = transaction["amount"]

Option 3 correctly calculates the total credit amount per user by using totals.get(transaction["user_id"], 0) to ensure that if the user does not yet exist in the dictionary, their initial amount is set to 0 before adding the transaction amount. Option 1 correctly calculates the total but uses a manual check for existing users, while Option 2 incorrectly filters by "debit" transactions. Option 4 only stores the last "credit" transaction amount for each user, rather than summing them.

You are given a JSON file containing information about a series of orders. Each order contains product details and their respective prices. You need to calculate the total cost of each order, including tax, where the tax rate is 10%. Given the following JSON data:

{
  "orders": [
    {
      "order_id": 1,
      "products": [
        {"product_id": 1, "name": "Laptop", "price": 1000},
        {"product_id": 2, "name": "Mouse", "price": 50}
      ]
    },
    {
      "order_id": 2,
      "products": [
        {"product_id": 3, "name": "Keyboard", "price": 100},
        {"product_id": 4, "name": "Monitor", "price": 300}
      ]
    }
  ]
}

Which of the following code snippets will correctly calculate the total cost for each order, including a 10% tax?

import json
with open("orders.json") as f:
    data = json.load(f)
tax_rate = 0.05
for order in data["orders"]:
    total_cost = sum([product["price"] for product in order["products"]])
    total_cost_with_tax = total_cost * (1 + tax_rate)
    print(f"Order {order['order_id']} total cost with tax: {total_cost_with_tax}")

import json
with open("orders.json") as f:
    data = json.load(f)
tax_rate = 0.10
for order in data["orders"]:
    total_cost = sum([product["price"] for product in order["products"]])
    total_cost_with_tax = total_cost + total_cost * tax_rate
    print(f"Order {order['order_id']} total cost with tax: {total_cost_with_tax}")

import json
with open("orders.json") as f:
    data = json.load(f)
tax_rate = 0.10
for order in data["orders"]:
    total_cost = sum([product["price"] for product in order["products"]])
    total_cost_with_tax = total_cost / (1 - tax_rate)
    print(f"Order {order['order_id']} total cost with tax: {total_cost_with_tax}")

import json
with open("orders.json") as f:
    data = json.load(f)
tax_rate = 0.10
for order in data["orders"]:
    total_cost = sum([product["price"] for product in order["products"]])
    total_cost_with_tax = total_cost * tax_rate
    print(f"Order {order['order_id']} total cost with tax: {total_cost_with_tax}")

In Option 2, the code correctly calculates the total cost of all products in an order using sum(), then applies a 10% tax (total_cost * 0.10) and adds it to the original total. Option 1 uses an incorrect tax rate of 5%. Option 3 incorrectly divides by (1 - tax_rate) instead of multiplying by (1 + tax_rate) to calculate the tax. Option 4 calculates only the tax, not the total cost with tax.