字典的多层嵌套怎么用递归取值

可以使用递归来取得多层嵌套字典的值。以下是一个示例代码：

def get_value(data, keys):
    if len(keys) == 1:
        return data[keys[0]]
    else:
        return get_value(data[keys[0]], keys[1:])

# 示例字典
data = {
    "a": {
        "b": {
            "c": 1,
            "d": 2
        }
    }
}

# 获取值
keys = ["a", "b", "c"]
value = get_value(data, keys)
print(value) # 输出: 1

在这个示例中，`get_value` 函数接收两个参数：`data` 和 `keys`。`data` 表示要取值的字典，`keys` 表示要取的键的列表。如果 `keys` 列表只有一个键，表示已经找到了最里层的值，直接返回该值。如果 `keys` 列表有多个键，表示还需要继续查找，递归调用 `get_value` 函数，传入 `data[keys[0]]` 作为下一层字典，同时将 `keys` 列表的剩余部分传入递归函数。最终返回找到的值。

相关问题

字典的多层嵌套怎么用递归取键

同样地，我们可以使用递归来取得多层嵌套字典的键。以下是一个示例代码：

def get_keys(data, target_value, current_keys=None):
    if current_keys is None:
        current_keys = []
    for key, value in data.items():
        if isinstance(value, dict):
            keys = get_keys(value, target_value, current_keys + [key])
            if keys:
                return keys
        elif value == target_value:
            return current_keys + [key]
    return None

# 示例字典
data = {
    "a": {
        "b": {
            "c": 1,
            "d": 2
        }
    },
    "e": {
        "f": 3,
        "g": {
            "h": 4,
            "i": 1
        }
    }
}

# 获取键
keys = get_keys(data, 1)
print(keys) # 输出: ['a', 'b', 'c']，因为 data['a']['b']['c'] 的值为 1

在这个示例中，`get_keys` 函数接收三个参数：`data` 表示要取键的字典，`target_value` 表示要查找的值，`current_keys` 表示当前已经找到的键的列表。如果 `current_keys` 为 `None`，则表示当前还没有找到任何键，将其设为一个空列表。函数通过循环遍历字典的各个键值对，如果值是字典，则递归调用 `get_keys` 函数，传入该字典、目标值和当前键列表的拷贝。如果返回的键列表不为空，则说明已经找到目标值，直接返回当前键列表和找到的键列表。如果值不是字典，且等于目标值，则说明已经找到目标值，直接返回当前键列表和该键。如果循环结束仍未找到目标值，则返回 `None`。

多层嵌套json递归解析工具类

下面是一个简单的工具类，可以递归解析多层嵌套的 JSON 数据：

import org.json.JSONArray;
import org.json.JSONObject;

public class JsonParser {
    public static void parse(JSONObject json) {
        for (String key : json.keySet()) {
            Object value = json.get(key);
            if (value instanceof JSONObject) {
                System.out.println("Object: " + key);
                parse((JSONObject) value);
            } else if (value instanceof JSONArray) {
                System.out.println("Array: " + key);
                parseArray((JSONArray) value);
            } else {
                System.out.println(key + ": " + value.toString());
            }
        }
    }

    private static void parseArray(JSONArray array) {
        for (int i = 0; i < array.length(); i++) {
            Object value = array.get(i);
            if (value instanceof JSONObject) {
                System.out.println("Object: " + i);
                parse((JSONObject) value);
            } else if (value instanceof JSONArray) {
                System.out.println("Array: " + i);
                parseArray((JSONArray) value);
            } else {
                System.out.println(i + ": " + value.toString());
            }
        }
    }
}

使用示例：

public class TestJsonParser {
    public static void main(String[] args) {
        String jsonStr = "{\"name\":\"John\",\"age\":30,\"cars\":[{\"name\":\"Ford\",\"models\":[\"Fiesta\",\"Focus\",\"Mustang\"]},{\"name\":\"BMW\",\"models\":[\"320\",\"X3\",\"X5\"]}],\"address\":{\"street\":\"Downing Street 10\",\"city\":\"London\"}}";
        JSONObject json = new JSONObject(jsonStr);
        JsonParser.parse(json);
    }
}

输出结果：

name: John
age: 30
Array: cars
Object: 0
name: Ford
Array: models
0: Fiesta
1: Focus
2: Mustang
Object: 1
name: BMW
Array: models
0: 320
1: X3
2: X5
Object: address
street: Downing Street 10
city: London