在本文中，我们将带你了解无法导入名称simplejson-安装simplejson后在这篇文章中，我们将为您详细介绍无法导入名称simplejson-安装simplejson后的方方面面，并解答imp
在本文中，我们将带你了解无法导入名称simplejson-安装simplejson后在这篇文章中，我们将为您详细介绍无法导入名称simplejson-安装simplejson后的方方面面，并解答import无法导入常见的疑惑，同时我们还将给您一些技巧，以帮助您实现更有效的go-simplejson文档学习、Golang go-simplejson、golang simplejson 使用笔记、golang使用simplejson库解析复杂json。
本文目录一览：- 无法导入名称simplejson-安装simplejson后（import无法导入）
- go-simplejson文档学习
- Golang go-simplejson
- golang simplejson 使用笔记
- golang使用simplejson库解析复杂json
无法导入名称simplejson-安装simplejson后（import无法导入）
我有Django版本1.7和Python版本2.7.5-我使用pip install simplejson和apt-get install python-simplejson命令来解决此问题，但仍然显示此异常。Django和Python之间是否存在任何兼容性问题，或者解决该异常的解决方案是什么：
Traceback (most recent call last): File "manage.py", line 10, in <module> execute_from_command_line(sys.argv) File "/root/test_env/local/lib/python2.7/site-packages/django/core/management/__init__.py", line 385, in execute_from_command_line utility.execute() File "/root/test_env/local/lib/python2.7/site-packages/django/core/management/__init__.py", line 354, in execute django.setup() File "/root/test_env/local/lib/python2.7/site-packages/django/__init__.py", line 21, in setup apps.populate(settings.INSTALLED_APPS) File "/root/test_env/local/lib/python2.7/site-packages/django/apps/registry.py", line 85, in populate app_config = AppConfig.create(entry) File "/root/test_env/local/lib/python2.7/site-packages/django/apps/config.py", line 123, in create import_module(entry) File "/usr/lib/python2.7/importlib/__init__.py", line 37, in import_module __import__(name) File "/root/test_env/local/lib/python2.7/site-packages/extdirect.django-0.3-py2.7.egg/extdirect/django/__init__.py", line 3, in <module> from providers import ExtRemotingProvider, ExtPollingProvider File "/root/test_env/local/lib/python2.7/site-packages/extdirect.django-0.3-py2.7.egg/extdirect/django/providers.py", line 4, in <module> from django.utils import simplejsonImportError: cannot import name simplejson答案1
小编典典您的代码与您使用的Django版本不兼容。
Django以前附带simplejsonin django.utils，但在Django 1.5中已删除：
django.utils.simplejson
由于Django 1.5放弃了对Python 2.5的支持，因此我们现在可以依靠Python标准库中提供的json模块，因此我们删除了自己的simplejson副本。现在，您应该导入json而不是django.utils.simplejson。不幸的是，由于simplejson版本之间的不兼容，此更改可能会产生有害的副作用-请参阅“向后不兼容的更改”部分。如果您依赖于simplejson成为Python的json之后添加到其上的功能，则应显式导入simplejson。
您应该更新代码extdirect的providers.py来import json替代，或者用的Django版本，它的目的是要与工作。
go-simplejson文档学习
https://godoc.org/github.com/bitly/go-simplejson
导入方式：
import "github.com/bitly/go-simplejson"用来解析未知结构的JSON的包
首先要使用下面的语句先下载该包才能使用：
go get "github.com/bitly/go-simplejson"
func Version
func Version() string返回当前操作的go-simplejson版本
package main
import(
"fmt"
"github.com/bitly/go-simplejson"
)
func main() {
fmt.Println(simplejson.Version()) //0.5.0
}
type Json
type Json struct {
// 包含过滤和未支持字段
}func NewFromReader
func NewFromReader(r io.Reader) (*Json, error)NewFromReader通过从io.Reader取值，然后解码返回一个*Json
func (*Json) Array
func (j *Json) Array() ([]interface{}, error)Array类型断言成 `array`
func (*Json) MustArray
func (j *Json) MustArray(args ...[]interface{}) []interface{}for i, v := range js.Get("results").MustArray() {
fmt.Println(i, v)
}func (*Json) Get
func (j *Json) Get(key string) *Jsonjs.Get("top_level").Get("dict").Get("value").Int()func (*Json) GetIndex
func (j *Json) GetIndex(index int) *JsonGetIndex returns a pointer to a new `Json` object for `index` in its `array` representation
this is the analog to Get when accessing elements of a json array instead of a json object:
GetIndex在它的“数组array”表示法中为“index”返回一个指向新的“Json”对象的指针
这是在访问json数组而不是json对象的元素时得到的模拟:
js.Get("top_level").Get("array").GetIndex(1).Get("key").Int()其实就是得到数组中索引为index的值
func (*Json) Int
func (j *Json) Int() (int, error)Int()强制转换值为int类型
func (*Json) MustInt
func (j *Json) MustInt(args ...int) intmyFunc(js.Get("param1").MustInt(), js.Get("optional_param").MustInt(5150))即使不存在"optional_param"这个字段，也能够保证返回一个int类型的5150
func (*Json) Map
func (j *Json) Map() (map[string]interface{}, error)Map 类型断言为 `map`
func (*Json) MustMap
func (j *Json) MustMap(args ...map[string]interface{}) map[string]interface{}MustMap保证返回一个`map[string]interface{}` (默认为可选)
当你希望以简洁的方式对映射值进行交互时它很有用:
for k, v := range js.Get("dictionary").MustMap() {
fmt.Println(k, v)
}func (*Json) Int64
func (j *Json) Int64() (int64, error)强制转换为int64
func (*Json) MustInt64
func (j *Json) MustInt64(args ...int64) int64MustInt64 保证返回为`int64` (默认为可选)
当你明确想要在一个值返回上下文中有一个'' int64 ''时，它是非常有用的:
myFunc(js.Get("param1").MustInt64(), js.Get("optional_param").MustInt64(5150))即使不存在"optional_param"这个字段，也能够保证返回一个int64类型的5150
举例：
package main
import(
"fmt"
"github.com/bitly/go-simplejson"
"bytes"
"log"
)
func main() {
buf := bytes.NewBuffer([]byte(`{
"test": {
"array": [1, "2", 3],
"arraywithsubs": [
{"subkeyone": 1},
{"subkeytwo": 2, "subkeythree": 3}
],
"bignum": 8000000000
}
}`))
js, err := simplejson.NewFromReader(buf)
if err != nil || js == nil{
log.Fatal("something wrong when call NewFromReader")
}
fmt.Println(js) //&{map[test:map[array:[1 2 3] arraywithsubs:[map[subkeyone:1] map[subkeytwo:2 subkeythree:3]] bignum:8000000000]]}
arr, err := js.Get("test").Get("array").Array()
if err != nil || arr == nil{
log.Fatal("something wrong when call Get and Array")
}
fmt.Println(arr) //[1 2 3]
//使用下面的Must类方法就不用判断而err了
fmt.Println(js.Get("test").Get("array").MustArray()) //[1 2 3]
fmt.Println(js.Get("test").Get("arraywithsubs").GetIndex(0).MustMap()) //map[subkeyone:1]
fmt.Println(js.Get("test").Get("bignum").MustInt64()) //8000000000
}
func NewJson
func NewJson(body []byte) (*Json, error)NewJson在解封body后返回一个指向新`Json`对象的指针
如果上面的例子不使用NewFromReader，而是使用NewJson将写成：
package main
import(
"fmt"
"github.com/bitly/go-simplejson"
"log"
)
func main() {
js, err := simplejson.NewJson([]byte(`{
"test": {
"array": [1, "2", 3],
"arraywithsubs": [
{"subkeyone": 1},
{"subkeytwo": 2, "subkeythree": 3}
],
"bignum": 8000000000
}
}`))
if err != nil || js == nil{
log.Fatal("something wrong when call NewFromReader")
}
fmt.Println(js) //&{map[test:map[array:[1 2 3] arraywithsubs:[map[subkeyone:1] map[subkeytwo:2 subkeythree:3]] bignum:8000000000]]}
arr, err := js.Get("test").Get("array").Array()
if err != nil || arr == nil{
log.Fatal("something wrong when call Get and Array")
}
fmt.Println(arr) //[1 2 3]
//使用下面的Must类方法就不用判断而err了
fmt.Println(js.Get("test").Get("array").MustArray()) //[1 2 3]
fmt.Println(js.Get("test").Get("arraywithsubs").GetIndex(0).MustMap()) //map[subkeyone:1]
fmt.Println(js.Get("test").Get("bignum").MustInt64()) //8000000000
}
func (*Json) GetPath
func (j *Json) GetPath(branch ...string) *JsonGetPath搜索分支指定的项，而不需要使用Get()的深度搜索。
js.GetPath("top_level", "dict")直接指定先查找字段"top_level"，然后再在其子字段中查找"dict"，而不用深度搜索
func (*Json) CheckGet
func (j *Json) CheckGet(key string) (*Json, bool)当成功很重要时，链式操作非常有用:
if data, ok := js.Get("top_level").CheckGet("inner"); ok {
log.Println(data)
}其实就是用来查看该嵌套层中是否有key为"inner"的字段
func (*Json) Del
func (j *Json) Del(key string)Del modifies `Json` map by deleting `key` if it is present.
如果存在则通过删除key来修改Json映射
func (*Json) Set
func (j *Json) Set(key string, val interface{})Set通过“键”和“值”修改“Json”映射，这对于轻松更改“Json”对象中的单个键/值非常有用。
func (*Json) SetPath
func (j *Json) SetPath(branch []string, val interface{})SetPath修改Json对象，递归地检查/创建提供路径的映射键，最后写入值val
func (*Json) String
func (j *Json) String() (string, error)类型断言为`string`
func (*Json) MustString
func (j *Json) MustString(args ...string) string当你明确地想要一个“字符串”在一个值返回上下文中:
myFunc(js.Get("param1").MustString(), js.Get("optional_param").MustString("my_default"))func (*Json) StringArray
func (j *Json) StringArray() ([]string, error)StringArray类型断言为 `string`类型的数组
举例：
package main
import(
"fmt"
"github.com/bitly/go-simplejson"
"log"
)
func main() {
js, err := simplejson.NewJson([]byte(`{
"test": {
"string_array": ["asdf", "ghjk", "zxcv"],
"string_array_null": ["abc", null, "efg"],
"array": [1, "2", 3],
"arraywithsubs": [{"subkeyone": 1},
{"subkeytwo": 2, "subkeythree": 3}],
"int": 10,
"float": 5.150,
"string": "simplejson",
"bool": true,
"sub_obj": {"a": 1}
}
}`))
if err != nil {
log.Fatal(err)
}
_, ok := js.CheckGet("test") //true ,有该字段
fmt.Println(ok)
missJson, ok := js.CheckGet("missing_key")
fmt.Println(ok)//false，没有该字段
fmt.Println(missJson) //<nil>
fmt.Println(js.Get("test").Get("string").MustString()) //simplejson
fmt.Println(js.Get("test").Get("missing_array").MustArray([]interface{}{"1", 2, "3"})) //[1 2 3]
msa := js.Get("test").Get("string_array").MustStringArray()
for _,v := range msa{
fmt.Println(v)
}
//返回：
//asdf
//ghjk
//zxcv
gp, _ := js.GetPath("test", "string").String()
fmt.Println(gp) //simplejson
js.Set("test2", "setTest")
fmt.Println(js.Get("test2").MustString()) //setTest
js.Del("test2")
fmt.Println(js.Get("test2").MustString()) //为空
s := make([]string, 2)
s[0] = "test2"
s[1] = "name"
js.SetPath(s, "testSetPath")
gp, _ = js.GetPath("test2", "name").String()
fmt.Println(gp) //testSetPath
}
func (*Json) MarshalJSON
func (j *Json) MarshalJSON() ([]byte, error)实现json.Marshaler接口
作用其实就是将JSON类型的值转成[]byte
func (*Json) UnmarshalJSON
func (j *Json) UnmarshalJSON(p []byte) error实现json.Unmarshaler接口
作用其实就是将[]byte类型的值转成JSON类型
举例：
package main
import(
"fmt"
"github.com/bitly/go-simplejson"
"log"
)
func main() {
js, err := simplejson.NewJson([]byte(`{}`))
if err != nil {
log.Fatal(err)
}
fmt.Println(js) //&{map[]}
err = js.UnmarshalJSON([]byte(`{
"test": {
"string_array": ["asdf", "ghjk", "zxcv"],
"int": 10,
"float": 5.150,
"string": "simplejson",
"bool": true,
"sub_obj": {"a": 1}
}
}`))
if err != nil {
log.Fatal(err)
}
fmt.Println(js) //&{map[test:map[string:simplejson bool:true sub_obj:map[a:1] string_array:[asdf ghjk zxcv] int:10 float:5.150]]}
unjs, err := js.MarshalJSON()
if err != nil {
log.Fatal(err)
}
fmt.Printf("[]byte json is :%s\n", unjs)
//[]byte json is :{"test":{"bool":true,"float":5.150,"int":10,"string":"simplejson","string_array":["asdf","ghjk","zxcv"],"sub_obj":{"a":1}}}
}
其他函数还有：
func New
func New() *JsonNew返回一个新建的指针，是空的Json对象
func (*Json) Bool
func (j *Json) Bool() (bool, error)Bool类型断言为`bool`
func (*Json) MustBool
func (j *Json) MustBool(args ...bool) bool当你明确地想要一个“bool”在一个值返回上下文中:
myFunc(js.Get("param1").MustBool(), js.Get("optional_param").MustBool(true))func (*Json) Bytes
func (j *Json) Bytes() ([]byte, error)Bytes类型断言为`[]byte`
func (*Json) Encode
func (j *Json) Encode() ([]byte, error)Encode返回其编码数据为 `[]byte`
func (*Json) EncodePretty
func (j *Json) EncodePretty() ([]byte, error)EncodePretty返回其编码数据为带有缩进的 `[]byte`
func (*Json) Float64
func (j *Json) Float64() (float64, error)Float64强制转换为float64
func (*Json) MustFloat64
func (j *Json) MustFloat64(args ...float64) float64当您明确希望在一个值返回上下文中使用“float64”时，这将非常有用:
myFunc(js.Get("param1").MustFloat64(), js.Get("optional_param").MustFloat64(5.150))func (*Json) Interface
func (j *Json) Interface() interface{}Interface返回底层数据
func (*Json) Uint64
func (j *Json) Uint64() (uint64, error)Uint64强制转换为uint64
func (*Json) MustUint64
func (j *Json) MustUint64(args ...uint64) uint64当你明确想在一个值返回上下文中有一个'' uint64 ''
myFunc(js.Get("param1").MustUint64(), js.Get("optional_param").MustUint64(5150))
Golang go-simplejson
Source code
go-simplejson
a Go package to interact with arbitrary JSON.
Install
go get -u github.com/bitly/go-simplejson
Import
import "github.com/bitly/go-simplejson"
Demo
package main
import (
"fmt"
simplejson "github.com/bitly/go-simplejson"
)
func main() {
js,err := simplejson.NewJson([]byte(`
{
"test": {
"string_array": ["asdf","ghjk","zxcv"],"array": [1,"2",3],"arraywithsubs": [{"subkeyone": 1},{"subkeytwo": 2,"subkeythree": 3}],"int": 10,"float": 5.150,"bignum": 9223372036854775807,"string": "simplejson","bool": true
},"person": [
{
"name": "piao","age": 30,"email": "piaoyunsoft@163.com","phoneNum": ["13974999999","13984999999"]
},{
"name": "aaaaa","age": 20,"email": "aaaaaa@163.com","phoneNum": ["13974998888","13984998888"]
}
]
}
`))
if err != nil {
panic("json format error")
}
fmt.Println("\n")
// get some field
fmt.Println("---------------------get some field-----------------")
s,err := js.Get("test").Get("string").String()
if err != nil {
panic(err)
}
fmt.Println(s,"\n")
// check existence of some field
fmt.Println("---------------------check existence----------------")
_,ok := js.Get("test").CheckGet("string2")
if ok {
fmt.Println("exist!")
} else {
fmt.Println("not exist!")
}
fmt.Println("\n")
// array
fmt.Println("---------------------array--------------------------")
arr,err := js.Get("test").Get("string_array").StringArray()
fmt.Println("# array of string")
if err != nil {
panic(err)
}
for _,v := range arr {
fmt.Printf("%s\t",v)
}
fmt.Println("\n")
fmt.Println("# array of number and string")
arr2,err := js.Get("test").Get("array").Array()
if err != nil {
panic(err)
}
for _,v := range arr2 {
fmt.Printf("%T:%v\t",v,v)
}
fmt.Println("\n")
fmt.Println("# array of map")
arr3 := js.Get("test").Get("arraywithsubs").GetIndex(1).MustMap()
fmt.Printf("%v\t",arr3)
fmt.Printf("%v",arr3["subkeytwo"])
fmt.Println("\n")
//
fmt.Println("# array of json")
personArr,err := js.Get("person").Array()
fmt.Printf("Number of person: %d\n",len(personArr))
// Loop
fmt.Println("\t# Loop person")
for i,_ := range personArr {
person := js.Get("person").GetIndex(i)
name := person.Get("name").MustString()
age := person.Get("age").MustInt()
email := person.Get("email").MustString()
fmt.Printf("\tname=%s,age=%d,email=%s\n",name,age,email)
// get Phone number
fmt.Println("\t# Loop phone number")
phoneNumArr,_ := person.Get("phoneNum").Array()
for ii,vv := range phoneNumArr {
fmt.Println("\t",ii,vv)
}
}
}
Output:
---------------------get some field----------------- simplejson ---------------------check existence---------------- not exist! ---------------------array-------------------------- # array of string asdf ghjk zxcv # array of number and string json.Number:1 string:2 json.Number:3 # array of map map[subkeytwo:2 subkeythree:3] 2 # array of json Number of person: 2 # Loop person name=piao,age=30,email=piaoyunsoft@163.com # Loop phone number 0 13974999999 1 13984999999 name=aaaaa,age=20,email=aaaaaa@163.com # Loop phone number 0 13974998888 1 13984998888
Reference
- go-simplejson|解析json字符串测试
- Golang–Simplejson简单实例
- go-simplejson
golang simplejson 使用笔记
第一步，得到json的内容
contents,_ := IoUtil.ReadAll(res.Body)
js,js_err := simplejson.NewJson(contents)
第二部，根据json的格式，选择使用array或者map储存数据
var nodes = make(map[string]interface{})
nodes,_ = js.Map()
第三步，将nodes当作map处理即可，如果map的value仍是一个json机构，回到第二步。
for key,_ := range nodes {
...
}
golang使用simplejson库解析复杂json
cnblogs原创
golang自带的json解析库encoding/json提供了json字符串到json对象的相互转换，在json字符串比较简单的情况下还是挺好用的，但是当json字符串比较复杂或者嵌套比较多的时候，就显得力不从心了，不可能用encoding/json那种为每个嵌套字段定义一个struct类型的方式，这时候使用simplejson库能够很方便的解析。例如，有这样一个嵌套很深的json字符串，例子如下：
{
"rc": 0,
"error": "Success",
"type": "stats",
"progress": 100,
"job_status": "COMPLETED",
"result": {
"total_hits": 803254,
"starttime": 1528434707000,
"endtime": 1528434767000,
"fields": [],
"timeline": {
"interval": 1000,
"start_ts": 1528434707000,
"end_ts": 1528434767000,
"rows": [{
"start_ts": 1528434707000,
"end_ts": 1528434708000,
"number": "x12887"
}, {
"start_ts": 1528434720000,
"end_ts": 1528434721000,
"number": "x13028"
}, {
"start_ts": 1528434721000,
"end_ts": 1528434722000,
"number": "x12975"
}, {
"start_ts": 1528434722000,
"end_ts": 1528434723000,
"number": "x12879"
}, {
"start_ts": 1528434723000,
"end_ts": 1528434724000,
"number": "x13989"
}],
"total": 803254
},
"total": 8
}
}
对于上面的这个json字符串，其嵌套很深，如果要一个一个去定义对应的struct结构，无疑是一件比较费力的事情，如果使用simplejson库那就简单多了，实例代码如下：
package main
import (
"encoding/json"
"fmt"
"reflect"
"strconv"
simplejson "github.com/bitly/go-simplejson"
)
var json_str string = `{"rc" : 0,
"error" : "Success",
"type" : "stats",
"progress" : 100,
"job_status" : "COMPLETED",
"result" : {
"total_hits" : 803254,
"starttime" : 1528434707000,
"endtime" : 1528434767000,
"fields" : [ ],
"timeline" : {
"interval" : 1000,
"start_ts" : 1528434707000,
"end_ts" : 1528434767000,
"rows" : [ {
"start_ts" : 1528434707000,
"end_ts" : 1528434708000,
"number" : "x12887"
}, {
"start_ts" : 1528434720000,
"end_ts" : 1528434721000,
"number" : "x13028"
}, {
"start_ts" : 1528434721000,
"end_ts" : 1528434722000,
"number" : "x12975"
}, {
"start_ts" : 1528434722000,
"end_ts" : 1528434723000,
"number" : "x12879"
}, {
"start_ts" : 1528434723000,
"end_ts" : 1528434724000,
"number" : "x13989"
} ],
"total" : 803254
},
"total" : 8
}
}`
func main() {
res, err := simplejson.NewJson([]byte(json_str))
if err != nil {
fmt.Printf("%v\n", err)
return
}
//获取json字符串中的 result 下的 timeline 下的 rows 数组
rows, err := res.Get("result").Get("timeline").Get("rows").Array()
//遍历rows数组
for _, row := range rows {
//对每个row获取其类型，每个row相当于 C++/Golang 中的map、Python中的dict
//每个row对应一个map，该map类型为map[string]interface{}，也即key为string类型，value是interface{}类型
if each_map, ok := row.(map[string]interface{}); ok {
//可以看到each_map["start_ts"]类型是json.Number
//而json.Number是golang自带json库中decode.go文件中定义的: type Number string
//因此json.Number实际上是个string类型
fmt.Println(reflect.TypeOf(each_map["start_ts"]))
if start_ts, ok := each_map["start_ts"].(json.Number); ok {
start_ts_int, err := strconv.ParseInt(string(start_ts), 10, 0)
if err == nil {
fmt.Println(start_ts_int)
}
}
if number, ok := each_map["number"].(string); ok {
fmt.Println(number)
}
}
}
}
关于无法导入名称simplejson-安装simplejson后和import无法导入的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于go-simplejson文档学习、Golang go-simplejson、golang simplejson 使用笔记、golang使用simplejson库解析复杂json等相关内容，可以在本站寻找。
本文标签：
