AMcoder - javascript, python, java, html, php, sql

Մի քանի JSON գրառումների ընթերցում Pandas տվյալների շրջանակում

Ես կցանկանայի իմանալ, թե արդյոք կա հիշողության արդյունավետ միջոց՝ կարդալու բազմակի ձայնագրված JSON ֆայլը (յուրաքանչյուր տողը JSON դիկտ է) pandas տվյալների շրջանակում: Ստորև բերված է աշխատանքային լուծումով 2 տող օրինակ, ինձ այն անհրաժեշտ է պոտենցիալ շատ մեծ թվով գրառումների համար: Օգտագործման օրինակ կարող է լինել Hadoop Pig JSonStorage ֆունկցիայի արդյունքի մշակումը:

import json
import pandas as pd

test='''{"a":1,"b":2}
{"a":3,"b":4}'''
#df=pd.read_json(test,orient='records') doesn't work, expects []

l=[ json.loads(l) for l in test.splitlines()]
df=pd.DataFrame(l)
17.11.2013

  • Օգտագործեք pd.read_json-ի chunksize հատկանիշը՝ տվյալների շրջանակների ցանկը ստանալու համար և օգտագործեք քարտեզ կամ հանգույց՝ տվյալների շրջանակների վրա կրկնելու համար: 07.06.2018

Պատասխանները:


1

Նշում․ տողերով առանձնացված json-ն այժմ աջակցվում է read_json (0.19.0-ից):

In [31]: pd.read_json('{"a":1,"b":2}\n{"a":3,"b":4}', lines=True)
Out[31]:
   a  b
0  1  2
1  3  4

կամ ոչ թե json տողի, այլ ֆայլի/ֆայլուղու միջոցով.

pd.read_json(json_file, lines=True)

Դա կախված կլինի ձեր DataFrames-ի չափից, որն ավելի արագ է, բայց մեկ այլ տարբերակ է օգտագործել str.join-ը՝ ձեր «JSON» բազմակի տողը ջարդելու համար (Նշում. այն վավեր json չէ), վավեր json և օգտագործել read_json:

In [11]: '[%s]' % ','.join(test.splitlines())
Out[11]: '[{"a":1,"b":2},{"a":3,"b":4}]'

Այս փոքրիկ օրինակի համար սա ավելի դանդաղ է, եթե մոտ 100-ը նույնն է, զգալի շահույթը, եթե այն ավելի մեծ է...

In [21]: %timeit pd.read_json('[%s]' % ','.join(test.splitlines()))
1000 loops, best of 3: 977 µs per loop

In [22]: %timeit l=[ json.loads(l) for l in test.splitlines()]; df = pd.DataFrame(l)
1000 loops, best of 3: 282 µs per loop

In [23]: test_100 = '\n'.join([test] * 100)

In [24]: %timeit pd.read_json('[%s]' % ','.join(test_100.splitlines()))
1000 loops, best of 3: 1.25 ms per loop

In [25]: %timeit l = [json.loads(l) for l in test_100.splitlines()]; df = pd.DataFrame(l)
1000 loops, best of 3: 1.25 ms per loop

In [26]: test_1000 = '\n'.join([test] * 1000)

In [27]: %timeit l = [json.loads(l) for l in test_1000.splitlines()]; df = pd.DataFrame(l)
100 loops, best of 3: 9.78 ms per loop

In [28]: %timeit pd.read_json('[%s]' % ','.join(test_1000.splitlines()))
100 loops, best of 3: 3.36 ms per loop

Նշում. այդ ժամանակ միացումը զարմանալիորեն արագ է:

18.11.2013

2

Եթե ​​փորձում եք հիշողություն խնայել, ապա ֆայլը մեկ տողով կարդալը շատ ավելի արդյունավետ կլինի.

with open('test.json') as f:
    data = pd.DataFrame(json.loads(line) for line in f)

Բացի այդ, եթե դուք import simplejson as json եք, ապա simplejson-ի հետ ներառված C ընդլայնումները շատ ավելի արագ են, քան մաքուր Python json մոդուլը:

02.03.2014
  • Իրականում, կարծում եմ, որ առաջին բանը, որ անում է DataFrame կոնստրուկտորը, զանգերի ցուցակն է նման գեներատորի վրա, այնպես որ և՛ հիշողությունը, և՛ ժամանակաչափերը նույնը կլինեն: Simplejson-ի կատարումը գտնվում է պանդաների read_json-ի և json-ի միջև: 05.03.2014
  • Ահ, դա շատ վատ է; կարծես ճիշտ եք DataFrame կոնստրուկտորի հարցում: Իսկ Python-ի վերջին տարբերակները ներառում են C ընդլայնումներ՝ ներկառուցված json-ի համար: Բարեբախտաբար, Pandas 0.19-ի դրությամբ, դուք կարող եք օգտագործել read_json(lines=True): 19.09.2016
  • @AndyHayden. Սա դեռ կպահպանի հիշողությունը OP-ի l=[ json.loads(l) for l in test.splitlines()]-ի վրա, որը պետք է ունենա հիշողության մեջ, միանգամից. 3. Վերլուծված JSON օբյեկտները: Ծույլ կարդալը և տող առ տող բեռնելը նշանակում է, որ դուք ունեք վերը նշվածից միայն #3, գումարած ֆայլի միանգամից մեկ (տեխնիկապես երկու, բայց տրամաբանորեն մեկ) տող հիշողության մեջ: Իհարկե, բոլոր վերլուծված օբյեկտները հիշողության մեջ են, բայց ոչ ֆայլի տվյալների երկու հավելյալ պատճենը բեռնելու համար: 29.11.2017
  • @ShadowRanger ոչ, առաջին բանը, որ անում է DataFrame կոնստրուկտորը, list-ը կիրառում է կրկնողին: Դա լիովին համարժեք է: 29.11.2017
  • @AndyHayden. Դա համարժեք կլիներ, եթե կրկնվող կրկնվողը համարժեք լիներ, բայց OP-ի կրկնվողը test.splitlines() է (նշանակում է՝ test և ստացված տողերի list-ը բոլորը պահվում են հիշողության մեջ, մինչ list-ը կառուցված է), մինչդեռ Doctor J-ի կրկնվողը f է (a բաց ֆայլի օբյեկտ), որը քաշում է յուրաքանչյուր տող, երբ այն անցնում է, փոխարինելով այն անմիջապես յուրաքանչյուր json.loads-ից հետո: pd.DataFrame(json.loads(line) for line in f) և pd.DataFrame([json.loads(line) for line in f]) կլինեն համարժեք (նախկին listհաստատված DataFrame-ով, վերջինս ուղղակիորեն կազմում է list), բայց ֆայլը և str.split-ը տարբերվում են: 29.11.2017
  • Բանն այն է, որ Doctor J-ի լուծումը բարելավում է, քանի որ այն չի լցնում ֆայլը հիշողության մեջ առջևում. այն մշակում է այն կարդալու ընթացքում, ուստի հիշողության առավելագույն օգտագործումը վերլուծված JSON օբյեկտների listն է (գումարած ֆայլի երկու ամենամեծ տողերի չափը), ոչ թե JSON օբյեկտների list-ը, գումարած ֆայլի ամբողջական բովանդակությունը, գումարած ամբողջական ֆայլը: բովանդակությունը կրկին (բաժանված է տողերի): 29.11.2017
  • @ShadowRanger բացառությամբ, որ այն ստեղծում է python dict յուրաքանչյուր տողի համար, որը միշտ հիշողության մեջ շատ ավելի մեծ է լինելու, քան տողը (հետևաբար իմ պատասխանում 1000 տողերի ժամանակային արդյունքներից) 29.11.2017
  • @AndyHayden: Ճիշտ է: Ես երբեք չեմ պնդել, որ դա չի լինելու, պարզապես այն չի բարդացնի այդ խնդիրը՝ հիշողության մեջ պահելով ֆայլի ամբողջական բայթերի մի քանի պատճեններ: Այնուամենայնիվ, դուք կարող եք նվազեցնել dictlist-ի գերավճարը՝ համատեղելով այս մոտեցումը w/collections.namedtuple-ի հետ: Row = namedtuple('Row', ('a', 'b')), ապա data սահմանումը փոխարինել data = pd.DataFrame(Row(**json.loads(line)) for line in f)ով: Այժմ, #գծերի dicts-ի փոխարեն, դուք ունեք #գծեր Rows, որոնք աշխատում են (իմ համակարգում) յուրաքանչյուրը 64 բայթ, այլ ոչ թե 240, մոտավորապես 1/4-ի չափով: 29.11.2017
  • Նկատի ունեցեք, որ namedtuple մոտեցումը պահանջում է, որ բոլոր JSON օբյեկտներն ունենան ատրիբուտների նույն շարքը (կամ օգտագործվեն բարդ մոտեցումներ, որոնք ապահովում են կամընտիր արժեքների լռելյայն), այնպես որ այն հարմար չէ բոլոր հանգամանքներին, բայց ժամանակավորները շատ ավելի քիչ ծանրակշիռ են: այս կերպ. 29.11.2017

  • 3

    Pandas 0.19-ի դրությամբ read_json-ն ունի բնօրինակ աջակցություն line-delimited-ի համար: JSON:

    pd.read_json(jsonfile, lines=True)
    
    18.09.2016

    4

    ++++++++Թարմացում+++++++++++++++

    0.19-ի դրությամբ, Pandas-ն աջակցում է սա որպես բնօրինակ (տես https://github.com/pandas-dev/pandas/pull/13351): Պարզապես վազեք.

    df=pd.read_json('test.json', lines=True)
    

    ++++++++Հին պատասխան++++++++++

    Առկա պատասխանները լավն են, բայց մի փոքր բազմազանության համար ահա ձեր նպատակին հասնելու ևս մեկ միջոց, որը պահանջում է պարզ նախնական մշակման քայլ python-ից դուրս, որպեսզի pd.read_json()-ը կարողանա օգտագործել տվյալները:

    • Տեղադրեք jq https://stedolan.github.io/jq/:
    • Ստեղծեք վավեր json ֆայլ cat test.json | jq -c --slurp . > valid_test.json-ով
    • Ստեղծեք տվյալների շրջանակ df=pd.read_json('valid_test.json')-ով

    ipython notebook-ում դուք կարող եք գործարկել shell հրամանը անմիջապես բջջային միջերեսից

    !cat test.json | jq -c --slurp . > valid_test.json
    df=pd.read_json('valid_test.json')
    
    02.02.2016
    Նոր նյութեր

    Օգտագործելով Fetch Vs Axios.Js-ը՝ HTTP հարցումներ կատարելու համար
    JavaScript-ը կարող է ցանցային հարցումներ ուղարկել սերվեր և բեռնել նոր տեղեկատվություն, երբ դա անհրաժեշտ լինի: Օրինակ, մենք կարող ենք օգտագործել ցանցային հարցումը պատվեր ներկայացնելու,..

    Տիրապետել հանգստության արվեստին. մշակողի ուղեցույց՝ ճնշման տակ ծաղկելու համար
    Տիրապետել հանգստության արվեստին. մշակողի ուղեցույց՝ ճնշման տակ ծաղկելու համար Ինչպե՞ս հանգստացնել ձեր միտքը և աշխատեցնել ձեր պրոցեսորը: Ինչպես մնալ հանգիստ և զարգանալ ճնշման տակ...

    Մեքենայի ուսուցում բանկային և ֆինանսների ոլորտում
    Բարդ, խելացի անվտանգության համակարգերը և հաճախորդների սպասարկման պարզեցված ծառայությունները բիզնեսի հաջողության բանալին են: Ֆինանսական հաստատությունները, մասնավորապես, պետք է առաջ մնան կորի..

    Ես AI-ին հարցրի կյանքի իմաստը, այն ինչ ասում էր, ցնցող էր:
    Այն պահից ի վեր, երբ ես իմացա Արհեստական ​​ինտելեկտի մասին, ես հիացած էի այն բանով, թե ինչպես է այն կարողանում հասկանալ մարդկային նորմալ տեքստը, և այն կարող է առաջացնել իր սեփական արձագանքը դրա..

    Ինչպես սովորել կոդավորումը Python-ում վագրի պես:
    Սովորելու համար ծրագրավորման նոր լեզու ընտրելը բարդ է: Անկախ նրանից, թե դուք սկսնակ եք, թե առաջադեմ, դա օգնում է իմանալ, թե ինչ թեմաներ պետք է սովորել: Ծրագրավորման լեզվի հիմունքները, դրա..

    C++-ի օրական բիթ(ե) | Ամենաերկար պալինդրոմային ենթաշարը
    C++ #198-ի ամենօրյա բիթ(ե), Ընդհանուր հարցազրույցի խնդիր. Ամենաերկար պալինդրոմային ենթատող: Այսօր մենք կանդրադառնանք հարցազրույցի ընդհանուր խնդրին. Ամենաերկար palindromic substring...

    Kydavra ICAReducer՝ ձեր տվյալների ծավալայինությունը նվազեցնելու համար
    Ի՞նչ է ICAReducer-ը: ICAReducer-ն աշխատում է հետևյալ կերպ. այն նվազեցնում է նրանց միջև բարձր փոխկապակցված հատկանիշները մինչև մեկ սյունակ: Բավականին նման է PCAreducer-ին, չնայած այն..