Co jest szybsze - ładowanie wytrawionego obiektu słownika lub ładowanie pliku JSON - do słownika?

Question

Co jest szybsze:

(A) 'Unpickling' (Ładowanie) piklowanych słownika obiektu, za pomocą pickle.load()

lub

(B) Ładowanie pliku JSON do słownika za pomocą simplejson.load()

Założenie: plik piklowany istnieje już w przypadku A, , a plik JSON istnieje już w przypadku B.

Answer 1

Prędkość zależy od danych, zawartości i rozmiaru.

Ale, tak czy owak, rzućmy Przykładem danych JSON i zobaczyć, co jest szybsze (Ubuntu 12.04, Python 2.7.3):

• pickle
• cPickle
• json
• simplejson
• ujson
• yajl

Podając tę ​​strukturę json dumpingowych na test.json i test.pickle plików:

{ 
    "glossary": { 
     "title": "example glossary", 
     "GlossDiv": { 
      "title": "S", 
      "GlossList": { 
       "GlossEntry": { 
        "ID": "SGML", 
        "SortAs": "SGML", 
        "GlossTerm": "Standard Generalized Markup Language", 
        "Acronym": "SGML", 
        "Abbrev": "ISO 8879:1986", 
        "GlossDef": { 
         "para": "A meta-markup language, used to create markup languages such as DocBook.", 
         "GlossSeeAlso": ["GML", "XML"] 
        }, 
        "GlossSee": "markup" 
       } 
      } 
     } 
    } 
} 

Testowanie skryptu:

import timeit 

import pickle 
import cPickle 

import json 
import simplejson 
import ujson 
import yajl 


def load_pickle(f): 
    return pickle.load(f) 


def load_cpickle(f): 
    return cPickle.load(f) 


def load_json(f): 
    return json.load(f) 


def load_simplejson(f): 
    return simplejson.load(f) 


def load_ujson(f): 
    return ujson.load(f) 


def load_yajl(f): 
    return yajl.load(f) 


print "pickle:" 
print timeit.Timer('load_pickle(open("test.pickle"))', 'from __main__ import load_pickle').timeit() 

print "cpickle:" 
print timeit.Timer('load_cpickle(open("test.pickle"))', 'from __main__ import load_cpickle').timeit() 

print "json:" 
print timeit.Timer('load_json(open("test.json"))', 'from __main__ import load_json').timeit() 

print "simplejson:" 
print timeit.Timer('load_simplejson(open("test.json"))', 'from __main__ import load_simplejson').timeit() 

print "ujson:" 
print timeit.Timer('load_ujson(open("test.json"))', 'from __main__ import load_ujson').timeit() 

print "yajl:" 
print timeit.Timer('load_yajl(open("test.json"))', 'from __main__ import load_yajl').timeit() 

wyjściowa:

pickle: 
107.936687946 

cpickle: 
28.4231381416 

json: 
31.6450419426 

simplejson: 
20.5853149891 

ujson: 
16.9352178574 

yajl: 
18.9763481617 

Jak widać, unpickling poprzez pickle wcale nie jest tak szybki - cPickle jest zdecydowanie najlepszym rozwiązaniem, jeśli wybierzesz opcję wytrawiania/rozpylania. ujson wygląda obiecująco wśród tych parserów json na tych konkretnych danych.

Ponadto, biblioteki json i simplejson ładują się znacznie szybciej przy pypy (patrz Python JSON Performance).

Zobacz także:

• Python JSON decoding performance
• Pickle or json?
• Pickle vs JSON — Which is Faster?

Ważne jest, aby pamiętać, że wyniki mogą się różnić od danego systemu, na inny typ i rozmiar danych.