JSON에 대한 기본사항 정리

1. PYTHON
JSON
MODULE
2.X
Moon Yong Joon

2. JSON
기본
Moon Yong Joon

3. JSON 기본 문장
{ } 문장 : Key와 값이 쌍으로 구성된 문장
[ ] 문장 : 값에 들어갈 수 있는 구조로 {}문장, 다양한 데
이터타입이 들어감
{“키” : 값, “키1”: 값 ……}
[요소1,요소2 ,……]
{ } 문장
[ ] 문장

4. JSON 값 : data type
파이썬 데이터 타입과 JSON 타입 매핑
JSON 설명 Python
object 순서가 없는 키와 값의 쌍 dict
array 순서가있는 sequece들의 값 list
string 문자열 unicode
number (int) double- precision in JavaScript int, long
number (real) floating-point format in JavaScript float
true Boolean True
false Boolean False
null empty None

5. DECODING
처리
Moon Yong Joon

6. decoding
부호화(encoding) 된 것을 다시 원래의 기준으로
전환하는 것
JSON Python
object dict
array list
string unicode
number (int) int, long
number (real) float
true True
false False
null None

7. json module : load()

8. 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 별도의 사용자 오류시 사용

9. 기본
스트림을 파일에 저장하고 다시 파이썬 처리를
위한 변환처리
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]}]

10. json module : loads()

11. 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 별도의 사용자 오류시 사용

12. 기본
Json 형태의 스트링을 파이썬 타입으로 변환
#json --> python decoding
obj_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})

13. 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 _processing)
#json_myobj.py
class 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__": "MyObj"}]'

14. obejct_hook : 클래스 생성
JSON에 넘겨진 클래스 객체에 대해 생성
#json_myobj.py
class MyObj(object):
def __init__(self, s):
self.s = s
def __repr__(self):
return '<MyObj(%s)>' % self.s

15. obejct_hook : 함수 생성
Object_hook에 클래스 객체와 연결될 함수를 생
성
#json.obj.py
import 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"}

16. obejct_hook : 실행
실행해서 인스턴스를 변수에 할당
#json.obj.py
# json 데이터
encoded_object = '[{"s": "instance value goes here", "__module__": "json_myobj", "__class__": "MyObj"}]‘
#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'}

17. 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 data
json_data = '{"foo": "bar", "bar": "baz"}‘
#python 스타일로 변환  unicode
print json.loads(json_data)
#python 스타일로 변환  Ascii
print json.loads(json_data, object_hook=ascii_encode_dict)
#결과값
{u'foo': u'bar', u'bar': u'baz'}
{'foo': 'bar', 'bar': 'baz'}

18. json module : JSONDecorder

19. 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()함수를 사용해서 decoding
print(type(json.loads("""{ "a":"b" }""")), json.loads("""{ "a":"b" }"""))
#결과값
(<type 'dict'>, {u'a': u'b'})
(<type 'dict'>, {u'a': u'b'})

20. ENCODING
처리
Moon Yong Joon

21. encoding
부호화(encoding)되지 않을 것을 특정 기준에 따
라 전환하는 것
Python JSON
dict object
list, tuple array
str, unicode string
int, long, float number
True true
False false
None null

22. json module : dump()

23. 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 별도의 사용자 오류시 사용

24. 기본
스트림처리를 위해 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]}]

25. json module : dumps()

26. 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 별도의 사용자 오류시 사용

27. 기본
파이썬 타입을 json 스트링으로 변환
#python --> json encoding
obj_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}')

28. tuple ->list
Tuple 타입은 JSON에 존재하지 않아서 list 타입
으로 전환되어 버림
#원소중에 dict 을 가지는 리스트 생성
data = [ { 'a':'A', 'b':(2, 4), 'c':3.0 } ]
print 'DATA:', type(data), data
print '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]}]

29. 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"}

30. 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 == first
print '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: False
SORTED MATCH : True

31. 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.2n ], n
"abs": 42n}'
{
"answer": [
42.2
],
"abs": 42
}

32. 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]}] 35
dumps(data, separators): [{"a":"A","c":3.0,"b":[2,4]}] 29

33. default 처리 흐름
Default 파라미터에는 변환함수를 지정하여 파이
썬에서 Json으로 전환될 수 있는 형태 처리 한 후
에 dumps함수가 실행
# default에 처리할 함수 정의
def default_processing(obj) :
#obj를 전환
convert_obj = 처리로직
return convert_obj
Json.dumps(obj, default=default_processing)
# 부호화 대상 파이썬 객체
obj = 파이썬 객체

34. 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"}

35. 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 representation
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)

36. 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"]')

37. json module : JSONEecorder

38. 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.0
PART: ,
PART: "b"
PART: :
PART: [2
PART: , 4
PART: ]
PART: }
PART: ]