PYTHON JSON

MODULE2.X

Moon Yong Joon

JSON기본Moon Yong Joon

JSON 기본 문장 { } 문장 : Key 와 값이 쌍으로 구성된 문장[ ] 문장 : 값에 들어갈 수 있는 구조로 {} 문장 , 다양한 데이터타입이 들어감

{“ 키” : 값 , “ 키 1”: 값 …… }

[ 요소 1, 요소 2 ,……]

{ } 문장

[ ] 문장

JSON 값 : data type

파이썬 데이터 타입과 JSON 타입 매핑JSON 설명 Python

object 순서가 없는 키와 값의 쌍 dictarray 순서가있는 sequece 들의 값 liststring 문자열 unicode

number (int) double- precision in JavaScript int, longnumber (real) floating-point format in JavaScript float

true Boolean Truefalse Boolean Falsenull empty None

DECODING 처리

Moon Yong Joon

decoding

부호화 (encoding) 된 것을 다시 원래의 기준으로 전환하는 것

JSON Pythonobject dictarray liststring unicode

number (int) int, longnumber (real) float

true Truefalse Falsenull None

json module : load()

json.load() 파라미터 json.load(fp[, encoding[, cls[, object_hook[, parse_float[, parse_int[, parse_constant[, object_pairs_hook[, **kw]]]]]]]])

parameter 설명fp 파일명encoding utf-8, ascii 인코딩 타입cls 별도의 사용자 오류시 사용object_hook

object_hook 는 객체 리터럴 디코딩 (DICT) 의 결과로 호출되는 선택적 기능입니다 . object_hook 의 리턴 값 대신 딕셔너리로 사용된다 . 이 기능은 사용자의 디코더 ( 를 구현하는데 사용될 수있다 .

parse_float Float 처리parse_int Int 처리parse_constant '-Infinity', 'Infinity', 'NaN’ 처리

object_pairs_hook

object_pairs_hook 쌍의 정렬 된 목록으로 디코딩 문자 그대로 모든 개체의 결과로 호출되는 선택적 기능입니다 . object_pairs_hook 의 리턴 값 대신 딕셔너리로 사용된다 . 이 기능 키 및 값 쌍 ( 예를 들어 , collections.OrderedDict () 는 삽입의 순서를 기억한다 ) 복호화되는 순서에 의존 맞춤 디코더를 구현하기 위해 사용될 수있다 . object_hook 도 정의되어있는 경우 , object_pairs_hook 은 우선합니다 .

**kw 별도의 사용자 오류시 사용

기본스트림을 파일에 저장하고 다시 파이썬 처리를 위한 변환처리

f = open("file_txt1",'w+')f.write('[{"a": "A", "c": 3.0, "b": [2, 4]}]')f.flush()f.seek(0)

print json.load(f)f.close()

# 결과값[{u'a': u'A', u'c': 3.0, u'b': [2, 4]}]

json module : loads()

json Module : json.loads json.loads(s[, encoding[, cls[, object_hook[, parse_float[, parse_int[, parse_constant[, object_pairs_hook[, **kw]]]]]]]])

parameter 설명s string

encoding utf-8, ascii 인코딩 타입cls 별도의 사용자 오류시 사용object_hook

object_hook 는 객체 리터럴 디코딩 (DICT) 의 결과로 호출되는 선택적 기능입니다 . object_hook 의 리턴 값 대신 딕셔너리로 사용된다 . 이 기능은 사용자의 디코더 ( 를 구현하는데 사용될 수있다 .

parse_float Float 처리parse_int Int 처리parse_constant '-Infinity', 'Infinity', 'NaN’ 처리object_pairs_hook 객체 변환을 위한 함수 변환 연결**kw 별도의 사용자 오류시 사용

기본Json 형태의 스트링을 파이썬 타입으로 변환

#json --> python decodingobj_jl = u'{"answer": [42.2], "abs": 42}'obj_pl = json.loads(obj_jl)print("decoding",obj_pl)

# 결과값('decoding', {u'answer': [42.2], u'abs': 42})

obejct_hook 처리 방식 obejct_hook 파라미터에 변환함수를 지정하고 변환하는 객체의 값을 처리

# obejct_hook 에 처리할 함수 정의 def obejct_hook _processing(obj) : #obj 를 전환 convert_obj = 처리로직 return convert_obj

json.loads(encoded_object, object_hook= obejct_hook _process-ing)

#json_myobj.pyclass MyObj(object): def __init__(self, s): self.s = s def __repr__(self): return '<MyObj(%s)>' % self.s

encoded_object = '[{"s": "instance value goes here", "__module__": "json_myobj", "__class__": "My-Obj"}]'

obejct_hook : 클래스 생성JSON 에 넘겨진 클래스 객체에 대해 생성

#json_myobj.pyclass MyObj(object): def __init__(self, s): self.s = s def __repr__(self): return '<MyObj(%s)>' % self.s

obejct_hook : 함수 생성Object_hook 에 클래스 객체와 연결될 함수를 생성

#json.obj.pyimport json

def dict_to_object(d): if '__class__' in d: class_name = d.pop('__class__') module_name = d.pop('__module__') module = __import__(module_name) # 클래스 타입을 넣고 class_ = getattr(module, class_name) print 'CLASS:', class_ # 클래스 아키먼트를 가져오고 kargs = dict( (key, value) for key, value in d.items()) print 'INSTANCE ARGS:', args #instance 생성 inst = class_(**kargs) else: inst = d return inst

1. 변수 = 클래스타입을 할당2. 변수 ( 파라미터 ) 에 키와 값을 가지는 파라미터를 전달시 변수명 앞예 ** 를 붙이고 실행

함수 파리미터 d 에 전단됨{"s": "instance value goes here", "__module__": "json_myobj", "__-class__": "MyObj"}

obejct_hook : 실행실행해서 인스턴스를 변수에 할당

#json.obj.py# json 데이터encoded_object = '[{"s": "instance value goes here", "__module__": "json_myobj", "__class__": "My-Obj"}]‘

#json 데이터를 변환해서 인스턴스로 전환myobj_instance = json.loads(encoded_object, object_hook=dict_to_object)

print type(myobj_instance), myobj_instance[0].__dict__

# 결과값 CLASS: <class 'json_myobj.MyObj'>INSTANCE ARGS: {u's': u'instance value goes here'}<type 'list'> {'s': u'instance value goes here'}

obejct_hook 이용한 encoding

Unicode 처리를 함수를 이용하여 ascii 처리로 전환

#object_hook 용 함수 처리def ascii_encode_dict(data): ascii_encode = lambda x: x.encode('ascii') return dict(map(ascii_encode, pair) for pair in data.items())

#json datajson_data = '{"foo": "bar", "bar": "baz"}‘#python 스타일로 변환 unicodeprint json.loads(json_data)

#python 스타일로 변환 Asciiprint json.loads(json_data, object_hook=ascii_encode_dict)

# 결과값 {u'foo': u'bar', u'bar': u'baz'}{'foo': 'bar', 'bar': 'baz'}

json module : JSONDecorder

JSONDecoder 클래스 사용Json. JSONDecoder 를 이용해서 JSON 형태의 스트링을 파이썬 타입으로 변환

from json import JSONDecoder# 인스턴스 객체 생성jd = JSONDecoder()# 메소드에 JSON 타입 전달jd_p = jd.decode("""{ "a":"b" }""")

print(type(jd_p),jd.decode("""{ "a":"b" }"""))#dumps() 함수를 사용해서 decodingprint(type(json.loads("""{ "a":"b" }""")), json.loads("""{ "a":"b" }"""))

# 결과값(<type 'dict'>, {u'a': u'b'})(<type 'dict'>, {u'a': u'b'})

ENCODING 처리

Moon Yong Joon

encoding

부호화 (encoding) 되지 않을 것을 특정 기준에 따라 전환하는 것

Python JSONdict object

list, tuple arraystr, unicode string

int, long, float numberTrue trueFalse falseNone null

json module : dump()

json.dump 파라미터 json.dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, encoding="utf-8", default=None, sort_keys=False, **kw)

parameter 설명obj Python 스타일 객체fp 파일명skipkeys=False basic type (str, unicode, int, long, float, bool, None) 이 아닐 경우 오류처리ensure_ascii=True Ascii /unicode 처리 방식check_circular=True 거짓 인 경우 , 컨테이너 유형에 대한 순환 참조 검사가 생략되며 순환 참조는 오버플로 오류처리allow_nan=True (nan, inf, -inf) 처리를 위해 사용cls=None 별도의 사용자 오류시 사용indent=None 출력하는 것에 대한 인텐트 처리separators=None, (item_separator, dict_separator) tuple default (', ', ': ') separators 이며 공백을

제거할 경우 (',', ':')  사용encoding="utf-8 인코딩 타입default=None 변환함수 입력 sort_keys=False True 일 경우 sort 처리**kw 별도의 사용자 오류시 사용

기본스트림처리를 위해 file 을 사용해서 처리하고 저장해서 처리

import json

data = [ { 'a':'A', 'b':(2, 4), 'c':3.0 } ]

f = open("file_txt",'w')json.dump(data, f)f.flush()

print open(f.name, 'r').read()

# 결과값[{"a": "A", "c": 3.0, "b": [2, 4]}]

json module : dumps()

json.dumps json.dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, encoding="utf-8", default=None, sort_keys=False, **kw)

parameter 설명obj Python 스타일 객체skipkeys=False basic type (str, unicode, int, long, float, bool, None) 이 아닐 경우 오류처리ensure_ascii=True Ascii 처리 방식check_circular=True 거짓 인 경우 , 컨테이너 유형에 대한 순환 참조 검사가 생략되며 순환 참조는 오버플로 오류처리allow_nan=True (nan, inf, -inf) 처리를 위해 사용cls=None 별도의 사용자 오류시 사용indent=None 출력하는 것에 대한 인텐트 처리separators=None, (item_separator, dict_separator) tuple default (', ', ': ') separators 이며 공백을

제거할 경우 (',', ':')  사용encoding="utf-8” 인코딩 타입default=None 변환함수 입력 sort_keys=False True 일 경우 sort 처리**kw 별도의 사용자 오류시 사용

기본파이썬 타입을 json 스트링으로 변환

#python --> json encodingobj_pd = {u"answer": [42.2], u"abs": 42}obj_jd = json.dumps(obj_pd)print("encoding ",type(obj_jd), obj_jd)

# 결과값('encoding ', <type 'str'>, '{"answer": [42.2], "abs": 42}')

tuple ->list

Tuple 타입은 JSON 에 존재하지 않아서 list 타입으로 전환되어 버림

# 원소중에 dict 을 가지는 리스트 생성data = [ { 'a':'A', 'b':(2, 4), 'c':3.0 } ]

print 'DATA:', type(data), dataprint 'DATA repr:', type(repr(data)), repr(data)#json 으로 전환data_string = json.dumps(data)print 'JSON:', data_string#decoding 해도 리스트로 남는다print "Data ",json.loads(data_string)

# 결과값DATA: <type 'list'> [{'a': 'A', 'c': 3.0, 'b': (2, 4)}]DATA repr: <type 'str'> [{'a': 'A', 'c': 3.0, 'b': (2, 4)}]JSON: [{"a": "A", "c": 3.0, "b": [2, 4]}]Data [{u'a': u'A', u'c': 3.0, u'b': [2, 4]}]

ensure_ascii 처리Ensure_ascii=False 일 경우 Unicode 타입는 unicode 데이터 타입으로 전환

print type(json.dumps({'a':u'b'}, ensure_ascii=True)) # <type 'str'>print json.dumps({'a':u'b'}, ensure_ascii=True)print type(json.dumps({'a':'b'}, ensure_ascii=False)) # <type 'str'>print json.dumps({'a':'b'}, ensure_ascii=False)print type(json.dumps({'a':u'b'}, ensure_ascii=False)) #<type 'unicode'>print json.dumps({'a':u'b'}, ensure_ascii=False)

# 결과값<type 'str'>{"a": "b"}<type 'str'>{"a": "b"}<type 'unicode'>{"a": "b"}

sort_keys 처리파이썬 타입을 sort_keys 에 맞춰 json 스트링으로 변환

data = [ { 'a':'A', 'b':(2, 4), 'c':3.0 } ]print 'DATA:', repr(data)

unsorted = json.dumps(data)print 'JSON:', json.dumps(data)print 'SORT:', json.dumps(data, sort_keys=True)

first = json.dumps(data, sort_keys=True)second = json.dumps(data, sort_keys=True)

print 'UNSORTED MATCH:', unsorted == firstprint 'SORTED MATCH :', first == second

# 결과값DATA: [{'a': 'A', 'c': 3.0, 'b': (2, 4)}]JSON: [{"a": "A", "c": 3.0, "b": [2, 4]}]SORT: [{"a": "A", "b": [2, 4], "c": 3.0}]UNSORTED MATCH: FalseSORTED MATCH : True

intent 처리파이썬 타입을 intent 에 맞춰 json 스트링으로 변환

#intent 를 주어 보기좋게 하기obj = {u"answer": [42.2], u"abs": 42}print(repr(json.dumps(obj, indent=4)))print(json.dumps(obj, indent=4)))

# 결과값'{\n "answer": [\n 42.2\n ], \n "abs": 42\n}'{ "answer": [ 42.2 ], "abs": 42}

separators 처리파이썬 타입을 separators 에 맞춰 json 스트링으로 변환 separatros 에 blank 가 없으므로 blank 가 제거됨data = [ { 'a':'A', 'b':(2, 4), 'c':3.0 } ]print 'DATA:', repr(data)print 'repr(data) :', repr(data)print 'dumps(data) :', json.dumps(data), len(json.dumps(data))print 'dumps(data, separators):', json.dumps(data, separators=(',',':')),len(json.dumps(data, separators=(',',':')))

# 결과값repr(data) : [{'a': 'A', 'c': 3.0, 'b': (2, 4)}]dumps(data) : [{"a": "A", "c": 3.0, "b": [2, 4]}] 35dumps(data, separators): [{"a":"A","c":3.0,"b":[2,4]}] 29

default 처리 흐름Default 파라미터에는 변환함수를 지정하여 파이썬에서 Json 으로 전환될 수 있는 형태 처리 한 후에 dumps함수가 실행

# default 에 처리할 함수 정의 def default_processing(obj) : #obj 를 전환 convert_obj = 처리로직 return convert_obj

Json.dumps(obj, default=default_processing)

# 부호화 대상 파이썬 객체obj = 파이썬 객체

default : 사용자정의 객체 1

파이썬 타입 중 인스턴스를 default 에 변환 함수를 지정해서 json 스트링으로 변환

# 파이썬 클래스 생성class User(object): def __init__(self, name, password): self.name = name self.password = password# 파이썬 인스턴스 생성alice = User('Alice A. Adams', 'secret')

# 인스턴스 내의 속성만 전환 매소드def jdefault(o): return o.__dict__

# Json 으로 변환print(json.dumps(alice, default=jdefault))

# 결과값{"password": "secret", "name": "Alice A. Adams"}

default : 사용자정의 객체 2

파이썬 타입 중 인스턴스를 default 에 변환 함수를 지정해서 json 스트링으로 변환

import json

class MyObj(object): def __init__(self, s): self.s = s def __repr__(self): return '<MyObj(%s)>' % self.s obj = MyObj('instance value goes here')

def convert_to_builtin_type(obj): print 'default(', repr(obj), ')' # Convert objects to a dictionary of their representa-tion d = { '__class__':obj.__class__.__name__, '__module__':obj.__module__, } d.update(obj.__dict__) return d

# 결과값{"s": "instance value goes here", "__-module__": "__main__", "__class__": "MyObj"}

print json.dumps(obj, default=convert_to_builtin_type)

default : set type 변환파이썬 타입 중 set 을 default 에 변환 함수를 지정해서 json 스트링으로 변환

# set 타입을 리스트로 전환def jdefault_set(o): if isinstance(o, set): return list(o) return o.__dict__

pets = set([u'Tiger', u'Panther', u'Toad'])pets_js = json.dumps(pets, default=jdefault_set)print( type(pets_js),json.dumps(pets, default=jdefault_set))) # 결과값

(<type 'str'>, '["Tiger", "Toad", "Panther"]')

json module : JSONEecorder

Encode/iterencode

파이썬에서 JSON 으로 부호화 , iterable 처리가 필요할 경우 iterencode 를 사용

import json

encoder = json.JSONEncoder()data = [ { 'a':'A', 'b':(2, 4), 'c':3.0 } ]

print encoder.encode(data)for part in encoder.iterencode(data): print 'PART:', part

# 결과값[{"a": "A", "c": 3.0, "b": [2, 4]}]PART: [PART: {PART: "a"PART: : PART: "A"PART: , PART: "c"PART: : PART: 3.0PART: , PART: "b"PART: : PART: [2PART: , 4PART: ]PART: }PART: ]