python递归替换json

Ⅰ python中如何使用递归实现这个功能

简单说，解决以上问题的思路是，循环执行n*n-1,直到n=1时。

如何理解呢?第一点，函数中，调用自身函数的那部分句子，即return n *
recursion(n-1)，把recursion(n-1)想象成另一个独立的函数，该函数的功能返回n-1的值，如果n的值是1,则返回1，函数运行结束。第二点，直观的看，可以把return
n * recursion(n-1)看成return n*(n-1)*(n-2)...1。而递归函数无非是在指定的条件下做普通的循环而已。

Ⅱ 请教一个关于python处理json的问题

{
data : {
{
tg_i":" 1080723 ",
contest_i" : "1001",
sid : "1567515287"
},
{
tg_id : "1080723",
contest_id : "1001",
sid : "1567515287"
}
},
total : "2"
}

然后经过修改，变成：
?

1

{"data":{{"tg_i":"1080723","contest_i":"1001","sid":"1567515287"},{"tg_id":"1080723","contest_id":"1001","sid":"1567515287"}},"total":"2"}

格式化为：
?

1
2
3
4
5
6
7
8
9
10
11
12
13

{
"data" : { {
"tg_i" : "1080723",
"contest_i" : "1001",
"sid" : "1567515287"
}, {
"tg_id" : "1080723",
"contest_id" : "1001",
"sid" : "1567515287"
}
},
"total" : "2"
}

但是，去用json解析，但是出错：

Python 2.7.3 (default, Apr 10 2012, 23:24:47) [MSC v.1500 64 bit (AMD64)] on win32

Type "right", "credits" or "license()" for more information.
>>> import json
>>> json.loads(‘{"data":{{"tg_i":"1080723","contest_i":"1001","sid":"1567515287"},{"tg_id":"1080723","contest_id":"1001","sid":"1567515287"}},"total":"2"}’)
Traceback (most recent call last):

File "<pyshell#2>", line 1, in <mole>
json.loads(‘{"data":{{"tg_i":"1080723","contest_i":"1001","sid":"1567515287"},{"tg_id":"1080723","contest_id":"1001","sid":"1567515287"}},"total":"2"}’)
File "D:\tmp\dev_install_root\Python27_x64\lib\json\__init__.py", line 326, in loads
return _default_decoder.decode(s)
File "D:\tmp\dev_install_root\Python27_x64\lib\json\decoder.py", line 366, in decode
obj, end = self.raw_decode(s, idx=_w(s, 0).end())
File "D:\tmp\dev_install_root\Python27_x64\lib\json\decoder.py", line 382, in raw_decode
obj, end = self.scan_once(s, idx)
ValueError: Expecting property name: line 1 column 9 (char 9)

【折腾过程】
1.刚开始，看了看：
{"data":{{"tg_i":"1080723","contest_i":"1001","sid":"1567515287"},{"tg_id":"1080723","contest_id":"1001","sid":"1567515287"}},"total":"2"}
好像也都是正常的，没什么错误。
2.后来才发现，对应着错误的位置：
column 9
是大括号'{‘
对应着，格式化的结果中的：
"data" : { {
中的第一个大括号
然后才发现，原来是，data键的值，此处写成用大括号括起来的：
?

1
2
3
4
5
6
7
8
9
10

"data" : { {
"tg_i" : "1080723",
"contest_i" : "1001",
"sid" : "1567515287"
}, {
"tg_id" : "1080723",
"contest_id" : "1001",
"sid" : "1567515287"
}
},

但是，实际上，data的值，只是两个dict，所以，应该是：
要么改为list：
?

1
2
3
4
5
6
7
8
9
10

"data" : [{
"tg_i" : "1080723",
"contest_i" : "1001",
"sid" : "1567515287"
}, {
"tg_id" : "1080723",
"contest_id" : "1001",
"sid" : "1567515287"
}
],

要么改为dict：
?

1
2
3
4
5
6
7
8
9
10

"data1" : {
"tg_i" : "1080723",
"contest_i" : "1001",
"sid" : "1567515287"
},
"data2" : {
"tg_id" : "1080723",
"contest_id" : "1001",
"sid" : "1567515287"
},

对应着，非格式化的内容就是：
?

1

{"data":[{"tg_i":"1080723","contest_i":"1001","sid":"1567515287"},{"tg_id":"1080723","contest_id":"1001","sid":"1567515287"}],"total":"2"}

和：
?

1

{"data1":{"tg_i":"1080723","contest_i":"1001","sid":"1567515287"}, "data2":{"tg_id":"1080723","contest_id":"1001","sid":"1567515287"},"total":"2"}

这样才可以正常解析：

>>> json.loads(‘{"data":[{"tg_i":"1080723","contest_i":"1001","sid":"1567515287"},{"tg_id":"1080723","contest_id":"1001","sid":"1567515287"}],"total":"2"}’)

{u’total’: u’2′, u’data’: [{u’sid’: u’1567515287′, u’contest_i’: u’1001′, u’tg_i’: u’1080723′}, {u’tg_id’: u’1080723′, u’contest_id’: u’1001′, u’sid’: u’1567515287′}]}
>>> json.loads(‘{"data1":{"tg_i":"1080723","contest_i":"1001","sid":"1567515287"}, "data2":{"tg_id":"1080723","contest_id":"1001","sid":"1567515287"},"total":"2"}’)
{u’total’: u’2′, u’data1′: {u’sid’: u’1567515287′, u’contest_i’: u’1001′, u’tg_i’: u’1080723′}, u’data2′: {u’tg_id’: u’1080723′, u’contest_id’: u’1001′, u’sid’: u’1567515287′}}

【总结】
折腾json的话，前提要了解json的语法和规则。
其次才是用某种语言去处理json。

Ⅲ python 递归解析任意深度的json

可以，就是需要遍历所有的数据。

defprint_dict(k,v):
ifisinstance(v,dict):
printk,v
forkkinv.keys():
print_dict(kk,v[kk])
else:
printk,v

forkind.keys():
print_dict(k,d[k])

Ⅳ python3 对象 |字典|json|yaml|字符串 相互转化

在研究 k8s 的yaml 配置文件的时候，我总担心自己一不小心 会写错，所以我向往 使用将对象 序列化 yaml 的形式，

其实 python object 可以 直接 转 yaml ，甚至也可以 直接 转成yaml文件！！！

这里 会经常用到几个 函数 vars() ast.

我们先尝试用最笨的方法 实现 object到yaml 的转化
在python对象 convert to dict 的形式，使用 vars()函数

然后 dict convert to json 使用 json.mps(dict)函数

然后 json converte to yaml 使用 ya= yaml.load(json.mps(dict)) 然后
再 yaml.safe_mp(ya,default_flow_style=False)

至此我们看到 从 python Object ---> dict ----> json ---> yaml 的转化

其中 obj dict json yaml 转 string ，只要 str()函数即可,或者 str(vars())结合

yaml 格式 写入到文件 ,需要注意的是， open()函数 的渗昌mode 一定要是 'w' ,不能是’wb', b代表是二进制写入
yaml 写入的是dict str，使用 ‘wb' 会报错，[yaml TypeError: a bytes-like object is required, not 'str']
【出现该错误往往是通过open()函数打开文本文件时，使用了‘rb’属性，如：fileHandle=open(filename,'rb'),则此时是通过二进制方式打开文件的，所以在后面处理时如果使用了str()函数，就会出现该错误，该错误不会再python2中出现。

具体解决方法有以下两种：

第一种胡喊启，在open()函数中使用‘r’属性，即文本方式读取，而不是‘rb’,以二进制文件方式读取，可以直接解决问题。

第二种,在open()函数中使用‘rb’,可以在使用之前进行转换，有以下实例，来自： http://stackoverflow.com/questions/33054527/python-3-5-typeerror-a-bytes-like-object-is-required-not-str 】

其实 python object 可以 直接 转 yaml ，甚至也可以 直接 转成yaml文件！！！
比如我已经定义了一个 Dog python class,他有 好几裤如个属性 并已经赋值初始化了

另外生成 yaml 对象

生成yaml文件

结果是

反过来 yaml ----> json ---> 持久化 json 文件 indent=1属性是为了让 json 不以单行展示，而是展开
注意的是 python 的 dict 和set 很相似 ，都是 { }， set 里是list， dict 是键值对
【# set object is not JSON serializable [plicate]
】

打开 demo.json

yaml ---> dict

yaml ---> python object

json --> dict
json.loads()

dict--> json
json.jumps()

str ---> dict
newdict=dict(str)

json -- > python object

一个python object无法直接与json转化，只能先将对象转化成dictionary，再转化成json；对json，也只能先转换成dictionary，再转化成object，通过实践，源码如下：

yaml --> python object
对yaml，也只能先转换成json --->dictionary，再转化成object，通过实践，源码如下：

dict -- ->python object

python对象 默认都有一个 私有的属性 dict 取值 就是 object的 字典形式， 赋值就就可以给对象属性对应赋值

例如json 转 对象

对象 转 json

Python之dict(或对象)与json之间的互相转化
在Python语言中，json数据与dict字典以及对象之间的转化，是必不可少的操作。

dict字典转json数据

对象转json数据

json数据转成dict字典

json数据转成对象

json的load()与mp()方法的使用
mp()方法的使用

Ⅳ 如何用python把protobuf转化json

直接利用python提供的json包，在django model的定义中增加一个方法toJSON，利用django model 能访问 _meta.fields 得到相关属性而得到，例子如下：
class Category(models.Model):
autoid = models.AutoField(primary_key=True)
email=models.CharField(max_length=150,blank=False)
comtype=models.CharField(max_length=20,blank=False)
catname=models.CharField(max_length=150,blank=False)

def __unicode__(self):
return '%s' % (self.catname)

def toJSON(self):
import json
return json.mps(dict([(attr, getattr(self, attr)) for attr in [f.name for f in self._meta.fields]]))
然后用django查出数据，并转换成json，代码如下：
row=models.Category.objects.get(autoid=23)
print row.toJSON()

Ⅵ 【Python】浅谈python中的json

一 前言  

   最近一直在做开发相关的工作--基于Django的web 平台，其中需要从model层传输数据到view 层做数据展示或者做业务逻辑处理。我们采用通用的Json格式--Json(JavaScript Object Notation) 是一种轻量级的数据交换格式，易于阅读和程序解析。

二 认识Json

   2.1 Json 结构

   常见的Json格式为 “名称/值”对的集合,其中 值可以是对象，列表，字典，字符串等等。比如

backup_data = {"back_to_host": "dbbk0",

"ip_address": "10.10.20.3",

"host_name": "rac4",

"port": 3306}

  2.2 使用Json

  Python的Json模块序列化与反序列化的过程分别是 编码和解码。这两个过程涉及到两组不同的函数

  编码 把一个Python对象编码转换成Json字符串，json.mps(data)/json.mp(data,file_handler)

  解码 把Json格式字符串解码转换成Python对象，json.loads(data)/json.load(file_handler)

  在python中要使用Json模块做相关操作，必须先导入:

import Json

  2.3 主要函数

  编码函数主要有 json.mps(data)/json.mp(data,file_handler)

   json.mps()的参数是将python对象转换为字符串，如使用json.mps序列化的对象json_mps=json.mps({'a':1, 'b':2}) ，json_mps='{"b": 2, "a": 1}'

   json.mp 是将内置类型序列化为json对象后写入文件。

 解码函数主要由json.loads(data)/json.load(file_handler)  

    json.loads的参数是内存对象，把Json格式字符串解码转换成Python对象,json_loads=json.loads(d_json)  #{ b": 2, "a": 1}，使用load重新反序列化为dict

    json.load()的参数针对文件句柄，比如本地有一个文件/tmp/test.json  json_load=json.load(open('/tmp/test.json'))

具体案例参考如下:

In [3]: data={"back_to_host": "rac1",

...: "ip_address": "10.215.20.3",

...: "host_name": "rac3",

...: "port": 3306}

In [7]: json_str=json.mps(data)

In [8]: print json_str

{"ip_address": "10.215.20.3", "back_to_host": "rac1", "host_name": "rac3", "port": 3306}

In [9]: json_loads=json.load(json_str)

---------------------------------------------------------------------------

AttributeError Traceback (most recent call last)

<ipython-input-9-180506f16431> in <mole>()

----> 1 json_loads=json.load(json_str)

/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/json/__init__.pyc in load(fp, encoding, cls, object_hook, parse_float, parse_int, parse_constant, object_pairs_hook, **kw)

284

285 ""

注意 从上面的报错信息来看 json.loads 传参是字符串类型，并不是文件句柄，没有 read()属性。

In [10]: json_loads=json.loads(json_str)

In [11]: print json_loads

{u'back_to_host': u'rac1', u'ip_address': u'10.215.20.3', u'host_name': u'rac3', u'port': 3306}

In [12]: type(json_loads)

Out[12]: dict

In [13]: type(json_str)

Out[13]: str

利用mp 将数据写入 mp.json

In [17]: with open('/tmp/mp.json','w') as f:

...: json.mp(json_str,f)

...:

yangyiDBA:~ yangyi$ cat /tmp/mp.json

"{\"ip_address\": \"10.10.20.3\", \"back_to_host\": \"rac1\", \"host_name\": \"rac3\", \"port\": 3306}"

yangyiDBA:~ yangyi$

利用json.load 将mp.sjon的数据读出来并赋值给 data 

In [18]: with open('/tmp/mp.json','r') as f:

...: data=json.load(f)

...:

In [19]: print data

{"ip_address": "10.10.20.3", "back_to_host": "rac1", "host_name": "rac3", "port": 3306}

三 小结

  本文算是一篇学习笔记，主要对比了json.loads/json.load  , json.mps/ json.mp 的使用差异 ，方便以后更好的使用json 。

以上为本次分享内容，感谢观看。