SoFunction
Updated on 2025-03-03

Python reads JSON files and some common pitfalls and improvements

Preface

In Python programming, JSON (JavaScript Object Notation) is a commonly used lightweight data exchange format. We often need to read JSON data from local files and process it. This article will start with a simple code example for reading JSON files and gradually optimize it, while delving into some common pitfalls and improvements.

1. Initial code: Simple JSON file reading

Here is the most basic code example for reading local JSON files:

import json

global data;

if __name__ == '__main__':
    with open('', 'r', encoding='utf-8') as file:
        data = (file)

    print(data)

This code can read the local name normally asJSON file and print out its contents. However, there are some places in the code that can be optimized, especially in terms of variable scope and code scalability.

2. Analysis and optimization direction

  • Use of global: in the codeglobalKeywords are used to declare global variables, and are usually used to modify the value of global variables within a function. But in this code,dataVariables are defined and used in the main scope.globalActually it is redundant. RemoveglobalIt will not affect the normal operation of the code and make the code more concise.

  • Exception handling: The current code assumes that the file always exists and is formatted correctly, but in a real environment, there may be cases where the file path is wrong, the file does not exist, or the JSON format is incorrect. If these cases are not processed, the program will crash directly and throw an error. Therefore, introducing an exception handling mechanism is a very important improvement.

  • Function encapsulation: In order to make the code better maintainability and reusability, it is recommended to encapsulate the logic that reads JSON files into a function. This not only improves the clarity of the code, but also facilitates future calls.

3. Code optimization steps

We've removed the excessglobalStart the keyword, and then gradually optimize the code.

Remove global keywords

In Python,globalUsually used to modify global variables inside functions. In the current scenario,datais defined in the main function, so it is a global variable and does not need to be explicitly used at all.global. RemoveglobalAfter that, the code is clearer:

import json

if __name__ == '__main__':
    with open('', 'r', encoding='utf-8') as file:
        data = (file)

    print(data)

Add exception handling

In order to make the code more robust, we need to consider the following scenarios:

  • The file does not exist.
  • The JSON file format is incorrect.

Can be passedtry-exceptStatements to catch these exceptions and give user-friendly prompts when an error occurs:

import json

if __name__ == '__main__':
    try:
        with open('', 'r', encoding='utf-8') as file:
            data = (file)
        print(data)
    except FileNotFoundError:
        print("The file is not found, please check the file path")
    except :
        print("File format is wrong, please check if it is a valid JSON format")

Function encapsulation

To improve the modularity and reusability of the code, we encapsulate the logic of file reading into a function. In this way, when you need to read a JSON file elsewhere, just call this function directly to avoid duplication of code:

import json

def load_json_file(file_path):
    """Read the JSON file and return the parsed data"""
    try:
        with open(file_path, 'r', encoding='utf-8') as file:
            return (file)
    except FileNotFoundError:
        print(f"document '{file_path}' not found")
    except :
        print(f"document '{file_path}' Error in format")
    return None

if __name__ == '__main__':
    data = load_json_file('')
    
    if data:
        print(data)

4. Code explanation

  • Function load_json_file(): This function accepts a file path as a parameter and is responsible for reading and parsing JSON files. It not only improves the readability and scalability of the code, but also facilitates error handling.

  • Exception handling:We useFileNotFoundErrorTo handle the situation where the file does not exist, useHandle the situation where the file content is incorrect. These exception handling helps improve the robustness of the code and avoids program crashes caused by file problems.

  • if data:: When reading a file, the returneddatamay beNone(In case of file reading failure). Therefore, we need to check whether the data is read successfully and only output the content when it is successful.

5. Summary

Through a series of optimization steps, we make the code more fault-tolerant and scalable from the initial simple reading of JSON files. These improvements include removing unnecessaryglobalKeywords, add exception handling, and improve code maintainability through function encapsulation.

The final optimized code is more versatile and can handle various potential exceptions, while the structure is clearer and more concise. Whether beginners or experienced developers, you can learn from this article how to write more robust Python code.

Extended reading：

  • Python documentation: json module
  • Python exception handling: try-except mechanism

This is the article about reading JSON files in Python and some common pitfalls and improvement methods. For more related contents of reading JSON files in Python, please search for my previous articles or continue browsing the following related articles. I hope everyone will support me in the future!