Explication détaillée des exemples d'opérations liées à Python sur json

Cet article analyse les opérations associées de python sur json à travers des exemples. Partagez-le avec tout le monde pour votre référence, les détails sont les suivants :

Qu'est-ce que json :

JSON (JavaScript Object Notation) est un format d'échange de données léger. Facile à lire et à écrire pour les humains. Il est également facile à analyser et à générer pour les machines. Il est basé sur le langage de programmation JavaScript, un sous-ensemble de la norme ECMA-262 3e édition – décembre 1999. JSON utilise un format de texte totalement indépendant du langage, mais utilise également des conventions similaires à la famille des langages C (notamment C, C, C#, Java, JavaScript, Perl, Python, etc.). Ces propriétés font de JSON un langage d'échange de données idéal.

JSON est construit à partir de deux structures :

Une collection de paires nom/valeur. Dans différentes langues, il est compris comme un objet, un enregistrement, une structure, un dictionnaire, une table de hachage, une liste à clés ou un tableau associatif).

Une liste ordonnée de valeurs. Dans la plupart des langues, il s’agit d’un tableau.

Ce sont des structures de données courantes. En fait, la plupart des langages informatiques modernes les prennent en charge sous une forme ou une autre. Cela permet d'échanger un format de données entre des langages de programmation également basés sur ces structures.

Pour la description officielle de json, voir : http://json.org/

La référence de la bibliothèque API standard pour que Python fasse fonctionner json : http://docs.python.org/ library/json.html

Encodage et décodage de types de données simples :

Utilisez la méthode simple json.dumps pour encoder des types de données simples, par exemple :

import json
obj = [[1,2,3],123,123.123,'abc',{'key1':(1,2,3),'key2':(4,5,6)}]
encodedjson = json.dumps(obj)
print repr(obj)
print encodedjson

Sortie :

[[1, 2, 3], 123, 123.123, 'abc', {'key2': (4, 5, 6), 'key1': (1, 2, 3)}]
[[1, 2, 3], 123, 123.123, "abc", {"key2": [4, 5, 6], "key1": [1, 2, 3]}]

Comme le montrent les résultats de sortie, le type simple après encodage est très similaire à sa sortie repr() d'origine, mais certains types de données ont été modifiés, par exemple, le tuple dans. l'exemple ci-dessus est converti en liste. Pendant le processus d'encodage de json, il y aura un processus de conversion du type original python en type json. La comparaison de conversion spécifique est la suivante :

Le json.dumps(). La méthode renvoie un objet str encodedjson, nous décoderons ensuite encodedjson pour obtenir les données originales. La fonction json.loads() qui doit être utilisée :

decodejson = json.loads(encodedjson)
print type(decodejson)
print decodejson[4]['key1']
print decodejson

<. 🎜> Sortie :

<type &#39;list&#39;>
[1, 2, 3]
[[1, 2, 3], 123, 123.123, u&#39;abc&#39;, {u&#39;key2&#39;: [4, 5, 6], u&#39;key1&#39;: [1, 2, 3]}]

La méthodeloads renvoie l'objet d'origine, mais certaines conversions de types de données se produisent toujours. Par exemple, dans l'exemple ci-dessus, « abc » est converti en type Unicode. La comparaison de la conversion de type de json en python est la suivante :

La méthode json.dumps fournit de nombreux paramètres utiles parmi lesquels choisir. Les plus couramment utilisés sont sort_keys (pour. objets dict) Tri, nous savons que le dict par défaut est stocké de manière non ordonnée), les séparateurs, l'indentation et d'autres paramètres.

La fonction de tri rend les données stockées plus propices à l'observation et permet également de comparer les objets de sortie json, par exemple :

data1 = {'b':789,'c':456,'a':123}
data2 = {'a':123,'b':789,'c':456}
d1 = json.dumps(data1,sort_keys=True)
d2 = json.dumps(data2)
d3 = json.dumps(data2,sort_keys=True)
print d1
print d2
print d3
print d1==d2
print d1==d3

Sortie :

{"a": 123, "b": 789, "c": 456}
{"a": 123, "c": 456, "b": 789}
{"a": 123, "b": 789, "c": 456}
False
True

Dans l'exemple ci-dessus, à l'origine les données data1 et data2 devraient être les mêmes, mais en raison de la nature désordonnée du stockage dict, le deux ne peuvent pas comparer. Par conséquent, les deux peuvent être stockés via les résultats triés pour éviter l'incohérence des données. Cependant, si les données sont stockées après le tri, le système doit faire plus de choses, ce qui entraînera certainement une certaine consommation de performances, un tri approprié est donc très important. .

Le paramètre indent signifie indentation, ce qui peut rendre le format de stockage des données plus élégant.

data1 = {'b':789,'c':456,'a':123}
d1 = json.dumps(data1,sort_keys=True,indent=4)
print d1

Sortie :

{
 "a": 123,
 "b": 789,
 "c": 456
}

Les données de sortie sont formatées après cela, il devient plus lisible, mais il est rempli en ajoutant quelques espaces blancs redondants. JSON existe principalement comme format de communication de données, et la communication réseau est très préoccupée par la taille des données. Les espaces inutiles occuperont une grande partie de la bande passante de communication, les données doivent donc être compressées le cas échéant. Le paramètre separator peut jouer ce rôle. Le paramètre passé est un tuple contenant la chaîne de l'objet fractionné.

print 'DATA:', repr(data)
print 'repr(data)  :', len(repr(data))
print 'dumps(data)  :', len(json.dumps(data))
print 'dumps(data, indent=2) :', len(json.dumps(data, indent=4))
print 'dumps(data, separators):', len(json.dumps(data, separators=(',',':')))

Sortie :

DATA: {'a': 123, 'c': 456, 'b': 789}
repr(data)  : 30
dumps(data)  : 30
dumps(data, indent=2) : 46
dumps(data, separators): 25

en supprimant le symbole d'espace supplémentaire, atteindre l'objectif de compresser les données, et l'effet est assez évident.

Un autre paramètre de dumps utile est skipkeys, qui est par défaut False. Lorsque la méthode dumps stocke un objet dict, la clé doit être de type str. Si d'autres types apparaissent, une exception TypeError sera générée. Si ce paramètre est activé et défini sur True, il sera plus gracieux.

data = {'b':789,'c':456,(1,2):123}
print json.dumps(data,skipkeys=True)

Sortie :

{"c": 456, "b": 789}

Gérez vos propres types de données

Le module json peut non seulement gérer les types intégrés Python ordinaires, mais également nos types de données personnalisés, et il est souvent courant de gérer des objets personnalisés.

Tout d’abord, nous définissons une classe Person.

class Person(object):
 def __init__(self,name,age):
 self.name = name
 self.age = age
 def __repr__(self):
 return 'Person Object name : %s , age : %d' % (self.name,self.age)
if __name__ == '__main__':
 p = Person('Peter',22)
 print p

如果直接通过json.dumps方法对Person的实例进行处理的话，会报错，因为json无法支持这样的自动转化。通过上面所提到的json和python的类型转化对照表，可以发现，object类型是和dict相关联的，所以我们需要把我们自定义的类型转化为dict，然后再进行处理。这里，有两种方法可以使用。

方法一：自己写转化函数

'''
Created on 2011-12-14
@author: Peter
'''
import Person
import json
p = Person.Person('Peter',22)
def object2dict(obj):
 #convert object to a dict
 d = {}
 d['__class__'] = obj.__class__.__name__
 d['__module__'] = obj.__module__
 d.update(obj.__dict__)
 return d
def dict2object(d):
 #convert dict to object
 if'__class__' in d:
 class_name = d.pop('__class__')
 module_name = d.pop('__module__')
 module = __import__(module_name)
 class_ = getattr(module,class_name)
 args = dict((key.encode('ascii'), value) for key, value in d.items()) #get args
 inst = class_(**args) #create new instance
 else:
 inst = d
 return inst
d = object2dict(p)
print d
#{'age': 22, '__module__': 'Person', '__class__': 'Person', 'name': 'Peter'}
o = dict2object(d)
print type(o),o
#<class &#39;Person.Person&#39;> Person Object name : Peter , age : 22
dump = json.dumps(p,default=object2dict)
print dump
#{"age": 22, "__module__": "Person", "__class__": "Person", "name": "Peter"}
load = json.loads(dump,object_hook = dict2object)
print load
#Person Object name : Peter , age : 22

上面代码已经写的很清楚了，实质就是自定义object类型和dict类型进行转化。object2dict函数将对象模块名、类名以及__dict__存储在dict对象里，并返回。dict2object函数则是反解出模块名、类名、参数，创建新的对象并返回。在json.dumps 方法中增加default参数，该参数表示在转化过程中调用指定的函数，同样在decode过程中json.loads方法增加object_hook,指定转化函数。

方法二：继承JSONEncoder和JSONDecoder类，覆写相关方法

JSONEncoder类负责编码，主要是通过其default函数进行转化，我们可以override该方法。同理对于JSONDecoder。

'''
Created on 2011-12-14
@author: Peter
'''
import Person
import json
p = Person.Person('Peter',22)
class MyEncoder(json.JSONEncoder):
 def default(self,obj):
 #convert object to a dict
 d = {}
 d['__class__'] = obj.__class__.__name__
 d['__module__'] = obj.__module__
 d.update(obj.__dict__)
 return d
class MyDecoder(json.JSONDecoder):
 def __init__(self):
 json.JSONDecoder.__init__(self,object_hook=self.dict2object)
 def dict2object(self,d):
 #convert dict to object
 if'__class__' in d:
  class_name = d.pop('__class__')
  module_name = d.pop('__module__')
  module = __import__(module_name)
  class_ = getattr(module,class_name)
  args = dict((key.encode('ascii'), value) for key, value in d.items()) #get args
  inst = class_(**args) #create new instance
 else:
  inst = d
 return inst
d = MyEncoder().encode(p)
o = MyDecoder().decode(d)
print d
print type(o), o

   

对于JSONDecoder类方法，稍微有点不同，但是改写起来也不是很麻烦。看代码应该就比较清楚了。

希望本文所述对大家Python程序设计有所帮助。

更多Explication détaillée des exemples dopérations liées à Python sur json相关文章请关注PHP中文网！