在 Python 中如何对嵌套列表进行 JSON 解组

对于一个Golang开发者来说，牢固扎实的基础是十分重要的，golang学习网就来带大家一点点的掌握基础知识点。今天本篇文章带大家了解《在 Python 中如何对嵌套列表进行 JSON 解组》，主要介绍了，希望对大家的知识积累有所帮助，快点收藏起来吧，否则需要时就找不到了！

我正在尝试解组一些相当难看的 json，但不知道如何解组。我有：

package main

import "fmt"
import "encoding/json"

type publickey struct {
    id     int    `json:"id"`
    key    string `json:"key"`
    mydata []struct {
        id    string `json:"id"`
        value int    `json:"value"`
    }
}

func main() {
    b := `[
  {
    "id": 1,
    "key": "my_key"
  },
  [
    {
      "id": "some_id",
      "value": 12
    },
    {
      "id": "anorther_id",
      "value": 13
    }
  ]
]`

    var pk []publickey
    err := json.unmarshal([]byte(b), &pk)
    if err != nil {
        fmt.println(err)
    }
    fmt.println(pk)

}

对于我得到的结果：

[{1 my_key []} {0  []}]

第二个切片不应该是空的。

编辑： 我得到的错误是：

json: cannot unmarshal array into Go struct field PublicKey.key of type main.PublicKey

https://play.golang.org/p/cztxochiis5

解决方案

那是一些真正可怕的 json！我有两种方法来处理混合数组元素，我更喜欢第二种方法。这是使用 interface 和类型开关的第一种方法：

package main

import (
    "encoding/json"
    "errors"
    "fmt"
)

type publickey struct {
    id  int    `json:"id"`
    key string `json:"key"`
}

type mydata struct {
    id    string `json:"id"`
    value int    `json:"value"`
}

type mixeddata struct {
    key    []publickey
    mydata [][]mydata
}

func (md *mixeddata) unmarshaljson(b []byte) error {
    md.key = []publickey{}
    md.mydata = [][]mydata{}
    var obj []interface{}
    err := json.unmarshal([]byte(b), &obj)
    if err != nil {
        return err
    }
    for _, o := range obj {
        switch o.(type) {
        case map[string]interface{}:
            m := o.(map[string]interface{})
            id, ok := m["id"].(float64)
            if !ok {
                return errors.new("public key id must be an int")
            }
            pk := publickey{}
            pk.id = int(id)
            pk.key, ok = m["key"].(string)
            if !ok {
                return errors.new("public key key must be a string")
            }
            md.key = append(md.key, pk)
        case []interface{}:
            a := o.([]interface{})
            mydata := make([]mydata, len(a))
            for i, x := range a {
                m, ok := x.(map[string]interface{})
                if !ok {
                    return errors.new("data array contains unexpected object")
                }
                val, ok := m["value"].(float64)
                if !ok {
                    return errors.new("data value must be an int")
                }
                mydata[i].value = int(val)
                mydata[i].id, ok = m["id"].(string)
                if !ok {
                    return errors.new("data id must be a string")
                }
                md.mydata = append(md.mydata, mydata)
            }
        default:
            // got something unexpected, handle somehow
        }
    }
    return nil
}

func main() {
    b := `[
  {
    "id": 1,
    "key": "my_key"
  },
  [
    {
      "id": "some_id",
      "value": 12
    },
    {
      "id": "another_id",
      "value": 13
    }
  ]
]`

    m := mixeddata{}
    err := json.unmarshal([]byte(b), &m)
    if err != nil {
        fmt.println(err)
    }
    fmt.println(m)

}

https://play.golang.org/p/g8d_AsH-pYY

希望没有任何意外的其他元素，但它们可以类似地处理。

这是第二个，它更多地依赖于 go 的内部 json 解析，并借助 json.rawmessage。它对数组的内容做出相同的假设。它假设任何对象都将解组为 publickey 实例，并且任何数组仅包含 mydata 实例。我还添加了如何编组回目标 json 以实现对称：

package main

import (
    "encoding/json"
    "fmt"
    "os"
)

type publickey struct {
    id  int    `json:"id"`
    key string `json:"key"`
}

type mydata struct {
    id    string `json:"id"`
    value int    `json:"value"`
}

type mixeddata struct {
    keys   []publickey
    mydata [][]mydata
}

func (md *mixeddata) unmarshaljson(b []byte) error {
    md.keys = []publickey{}
    md.mydata = [][]mydata{}
    obj := []json.rawmessage{}
    err := json.unmarshal([]byte(b), &obj)
    if err != nil {
        return err
    }
    for _, o := range obj {
        switch o[0] {
        case '{':
            pk := publickey{}
            err := json.unmarshal(o, &pk)
            if err != nil {
                return err
            }
            md.keys = append(md.keys, pk)
        case '[':
            mydata := []mydata{}
            err := json.unmarshal(o, &mydata)
            if err != nil {
                return err
            }
            md.mydata = append(md.mydata, mydata)
        default:
            // got something unexpected, handle somehow
        }
    }
    return nil
}

func (md *mixeddata) marshaljson() ([]byte, error) {
    out := make([]interface{}, len(md.keys)+len(md.mydata))
    i := 0
    for _, x := range md.keys {
        out[i] = x
        i++
    }
    for _, x := range md.mydata {
        out[i] = x
        i++
    }
    return json.marshal(out)
}

func main() {
    b := `[
  {
    "id": 1,
    "key": "my_key"
  },
  [
    {
      "id": "some_id",
      "value": 12
    },
    {
      "id": "another_id",
      "value": 13
    }
  ]
]`

    m := mixeddata{}
    err := json.unmarshal([]byte(b), &m)
    if err != nil {
        fmt.println(err)
        os.exit(1)
    }
    fmt.println(m)

    enc := json.newencoder(os.stdout)
    enc.setindent("", "    ")
    if err := enc.encode(m); err != nil {
        fmt.println(err)
        os.exit(1)
    }
}

https://play.golang.org/p/ryZzaWKNcN0

这是一种将 json.RawMessage 与通过创建一个为目标类型别名的新临时类型来实现 json.Unmarshaler 的类型中使用默认解组器的技巧相结合的方法。

我们的想法是，我们将传入的数组解组为原始消息，并确保数组长度符合我们的预期。然后，我们使用 json 标记注释将各个数组元素解组为自定义结构类型。最终结果是，我们可以按照通常的方式解组 publickey 类型，并且一旦理解了其中的技巧，unmarshaljson 代码就不会很难理解。

例如（Go Playground）：

type PublicKey struct {
  ID   int    `json:"id"`
  Key  string `json:"key"`
  Data []MyData
}

type MyData struct {
  ID    string `json:"id"`
  Value int    `json:"value"`
}

func (pk *PublicKey) UnmarshalJSON(bs []byte) error {
  // Unmarshal into a RawMessage so we can inspect the array length.
  var rawMessage []json.RawMessage
  err := json.Unmarshal(bs, &rawMessage)
  if err != nil {
    return err
  }
  if len(rawMessage) != 2 {
    return fmt.Errorf("expected array of length 2, got %d", len(rawMessage))
  }

  // Parse the first object as PublicKey using the default unmarshaler
  // using a temporary type that is an alias for the target type.
  type PublicKey2 PublicKey
  var pk2 PublicKey2
  err = json.Unmarshal(rawMessage[0], &pk2)
  if err != nil {
    return err
  }

  // Parse the second object as []MyData in the usual way.
  err = json.Unmarshal(rawMessage[1], &pk2.Data)
  if err != nil {
    return err
  }

  // Finally, assign the aliased object to the target object.
  *pk = PublicKey(pk2)
  return nil
}

func main() {
  var pk PublicKey
  err := json.Unmarshal([]byte(jsonstr), &pk)
  if err != nil {
    panic(err)
  }
  fmt.Printf("%#v\n", pk)
  // main.PublicKey{ID:1, Key:"my_key", Data:[]main.MyData{main.MyData{ID:"some_id", Value:12}, main.MyData{ID:"anorther_id", Value:13}}}

}

今天关于《在 Python 中如何对嵌套列表进行 JSON 解组》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！