জিসসনে পাইথন নামের এক পাইথন সিরিয়ালিয়াল করা

Question 1

namedtupleক্ষেত্রের নামগুলি বজায় রেখে জ টু জসনকে সিরিয়ালকরণের প্রস্তাবিত উপায় কী ?

একটিতে জসনকে সিরিয়ালকরণ করা namedtupleহলে ফলাফলগুলি কেবল সিরিয়ালাইজড হয়ে যায় এবং ক্ষেত্রের নামগুলি অনুবাদে হারিয়ে যায়। আমি চাই ক্ষেত্রগুলিও যখন জসন-আইাইজড হয়ে থাকে এবং তাই নিম্নলিখিতটি করা হয়:

class foobar(namedtuple('f', 'foo, bar')):
    __slots__ = ()
    def __iter__(self):
        yield self._asdict()

উপরের সিরিয়ালগুলি জসনকে যেমন প্রত্যাশা করা হয়েছে এবং আমি namedtupleঅন্যান্য জায়গাগুলির মতো আচরণ করি (অ্যাট্রিবিউট অ্যাক্সেস ইত্যাদি), যেমন এটির পুনরুক্তি করার সময় ফলাফলগুলি (যেমন আমার ব্যবহারের ক্ষেত্রে জরিমানা) বাদ দেয় non

ক্ষেত্রের নামগুলি বজায় রেখে জসনে রূপান্তরিত করার "সঠিক উপায়" কী?

Question 2

এটি বেশ জটিল, যেহেতু namedtuple()একটি কারখানা যা থেকে প্রাপ্ত নতুন ধরণের ফিরে আসে tuple। একটি পদ্ধতির ক্ষেত্রে আপনার শ্রেণিটি উত্তরাধিকার সূত্রে প্রাপ্ত হওয়াও হবে UserDict.DictMixinতবে tuple.__getitem__এটি ইতিমধ্যে সংজ্ঞায়িত হয়েছে এবং এটির বৈশিষ্ট্যের নাম নয় বরং কোনও সংখ্যার উপাদানটির অবস্থান নির্দেশ করে বলে প্রত্যাশা করে:

>>> f = foobar('a', 1)
>>> f[0]
'a'

এর হৃদয়ে নেডটুপলটি জেএসএনের জন্য একটি স্বতন্ত্র ফিট, যেহেতু এটি সত্যিই একটি কাস্টম-বিল্ট টাইপ যার মূল নামগুলি টাইপ সংজ্ঞার অংশ হিসাবে স্থির করা হয়েছে , যেখানে অভিধানের মধ্যে মূল নামগুলি সংরক্ষণ করা হয় এমন একটি অভিধানের মত নয়। এটি আপনাকে একটি নেমডটুপলকে "রাউন্ড-ট্রিপিং" বাধা দেয়, যেমন আপনি ডিকের মধ্যে অ্যাপ্লিকেশন নির্দিষ্ট ধরণের মার্কার মতো কোনও ডিকশনারিকে কোনও নামটুপলে আবার ডিকোড করতে পারবেন না {'a': 1, '#_type': 'foobar'}যা কিছুটা হ্যাকি।

এটি আদর্শ নয়, তবে আপনার যদি কেবল অভিধানগুলিতে নেমটুপলগুলি এনকোড করা দরকার , তবে অন্য পদ্ধতিটি হল আপনার জেএসএন এনকোডারকে এই ধরণের বিশেষ ক্ষেত্রে প্রসারিত বা সংশোধন করতে। পাইথন সাবক্লাসিংয়ের উদাহরণ এখানে json.JSONEncoder। নেস্টেড নেমেডটুপলসকে অভিধানে যথাযথ রূপান্তর করা হয়েছে তা নিশ্চিত করার সমস্যাটি এটি সমাধান করে:

from collections import namedtuple
from json import JSONEncoder

class MyEncoder(JSONEncoder):

    def _iterencode(self, obj, markers=None):
        if isinstance(obj, tuple) and hasattr(obj, '_asdict'):
            gen = self._iterencode_dict(obj._asdict(), markers)
        else:
            gen = JSONEncoder._iterencode(self, obj, markers)
        for chunk in gen:
            yield chunk

class foobar(namedtuple('f', 'foo, bar')):
    pass

enc = MyEncoder()
for obj in (foobar('a', 1), ('a', 1), {'outer': foobar('x', 'y')}):
    print enc.encode(obj)

{"foo": "a", "bar": 1}
["a", 1]
{"outer": {"foo": "x", "bar": "y"}}

Question 3

যদি namedtupleআপনি কেবলমাত্র সিরিয়ালাইজ করতে চান তবে এর _asdict()পদ্ধতিটি ব্যবহার করে (পাইথন> = 2.7 সহ) কাজ করবে

>>> from collections import namedtuple
>>> import json
>>> FB = namedtuple("FB", ("foo", "bar"))
>>> fb = FB(123, 456)
>>> json.dumps(fb._asdict())
'{"foo": 123, "bar": 456}'

Question 4

দেখে মনে হচ্ছে আপনি সাবক্লাস করতে সক্ষম হয়েছিলেন simplejson.JSONEncoder এই কাজটি করতে তবে সর্বশেষ সিম্পলসন কোড সহ, এটি আর নেই: আপনাকে প্রকৃতপক্ষে প্রকল্পের কোডটি সংশোধন করতে হবে। আমি সিম্পজসন কেন নামটুপলসকে সমর্থন না করা উচিত তার কোন কারণ দেখছি না, তাই আমি প্রকল্পটি কাঁটাচামচ করেছিলাম, নামচতুষ্পিক সমর্থনটি যুক্ত করেছি, এবং আমি বর্তমানে আমার শাখাটি মূল প্রকল্পে ফিরে টানার জন্য অপেক্ষা করছি । যদি এখনই ঠিক করতে হয় তবে আমার কাঁটাচামচ থেকে টানুন।

সম্পাদনা : এর সর্বশেষ সংস্করণ মত দেখায় simplejsonএখন স্থানীয়ভাবে এই সঙ্গে সমর্থন namedtuple_as_objectবিকল্প, যা ডিফল্ট True।

Question 5

এটি করার জন্য আমি একটি লাইব্রেরি লিখেছি: https://github.com/ltworf/typedload

এটি থেকে নামকরণ-টিপল এবং ফিরে যেতে পারে।

এটি তালিকা, সেট, এনাম, ইউনিয়ন, ডিফল্ট মান সহ বেশ জটিল নেস্টেড স্ট্রাকচার সমর্থন করে। এটি সর্বাধিক সাধারণ ক্ষেত্রে আবশ্যক।

সম্পাদনা: গ্রন্থাগারটি ডেটাগ্লাস এবং অ্যাটার ক্লাসগুলিও সমর্থন করে

Question 6

এটি পুনরাবৃত্তভাবে নামকৃত টিপল ডেটাটিকে জসন-এ রূপান্তর করে।

print(m1)
## Message(id=2, agent=Agent(id=1, first_name='asd', last_name='asd', mail='2@mai.com'), customer=Customer(id=1, first_name='asd', last_name='asd', mail='2@mai.com', phone_number=123123), type='image', content='text', media_url='h.com', la=123123, ls=4512313)

def reqursive_to_json(obj):
    _json = {}

    if isinstance(obj, tuple):
        datas = obj._asdict()
        for data in datas:
            if isinstance(datas[data], tuple):
                _json[data] = (reqursive_to_json(datas[data]))
            else:
                 print(datas[data])
                _json[data] = (datas[data])
    return _json

data = reqursive_to_json(m1)
print(data)
{'agent': {'first_name': 'asd',
'last_name': 'asd',
'mail': '2@mai.com',
'id': 1},
'content': 'text',
'customer': {'first_name': 'asd',
'last_name': 'asd',
'mail': '2@mai.com',
'phone_number': 123123,
'id': 1},
'id': 2,
'la': 123123,
'ls': 4512313,
'media_url': 'h.com',
'type': 'image'}

Question 7

আরও বেশি সুবিধাজনক সমাধান হ'ল সাজসজ্জার ব্যবহার করা (এটি সুরক্ষিত ক্ষেত্র ব্যবহার করে _fields)।

পাইথন ২.7++:

import json
from collections import namedtuple, OrderedDict

def json_serializable(cls):
    def as_dict(self):
        yield OrderedDict(
            (name, value) for name, value in zip(
                self._fields,
                iter(super(cls, self).__iter__())))
    cls.__iter__ = as_dict
    return cls

#Usage:

C = json_serializable(namedtuple('C', 'a b c'))
print json.dumps(C('abc', True, 3.14))

# or

@json_serializable
class D(namedtuple('D', 'a b c')):
    pass

print json.dumps(D('abc', True, 3.14))

পাইথন ৩.6..6++:

import json
from typing import TupleName

def json_serializable(cls):
    def as_dict(self):
        yield {name: value for name, value in zip(
            self._fields,
            iter(super(cls, self).__iter__()))}
    cls.__iter__ = as_dict
    return cls

# Usage:

@json_serializable
class C(NamedTuple):
    a: str
    b: bool
    c: float

print(json.dumps(C('abc', True, 3.14))

Question 8

Jsonplus গ্রন্থাগার NamedTuple দৃষ্টান্ত একটি serializer প্রদান করে। প্রয়োজনে সাধারণ অবজেক্টগুলি আউটপুট করতে তার সামঞ্জস্যতা মোডটি ব্যবহার করুন, তবে ডিফল্টটিকে পছন্দ করুন কারণ এটি পিছনে ডিকোডিংয়ের জন্য সহায়ক।

Question 9

নেটিভটপলসকে দেশীয় পাইথন জেসন লাইব্রেরির মাধ্যমে সঠিকভাবে সিরিয়ালাইজ করা অসম্ভব। এটি সর্বদা তালিকাগুলি হিসাবে টিপলস দেখতে পাবেন এবং এই আচরণটি পরিবর্তন করতে ডিফল্ট সিরিয়ালটিকে ওভাররাইড করা অসম্ভব। যদি জিনিসগুলি বাসা বাঁধে তবে এটি আরও খারাপ।

অর্জসনের মতো আরও দৃust় লাইব্রেরি ব্যবহার করা আরও ভাল :

import orjson
from typing import NamedTuple

class Rectangle(NamedTuple):
    width: int
    height: int

def default(obj):
    if hasattr(obj, '_asdict'):
        return obj._asdict()

rectangle = Rectangle(width=10, height=20)
print(orjson.dumps(rectangle, default=default))

=>

{
    "width":10,
    "height":20
}

Question 10

এটি একটি পুরানো প্রশ্ন। যাহোক:

একই প্রশ্নযুক্ত সকলের জন্য একটি পরামর্শ, ব্যক্তিগত এবং অভ্যন্তরীণ বৈশিষ্ট্যগুলির যে NamedTupleকোনওটির আগে ব্যবহার করার বিষয়ে সাবধানতার সাথে ভাবুন কারণ তাদের আগে রয়েছে এবং সময়ের সাথে সাথে আবার পরিবর্তন হবে।

উদাহরণস্বরূপ, যদি আপনার NamedTuple ফ্ল্যাট ভ্যালু অবজেক্ট হয় এবং আপনি কেবল এটির ক্রমিকায়িত করতে আগ্রহী হন এবং এটি অন্য কোনও বস্তুর মধ্যে বাসা বাঁধার ক্ষেত্রে নয় তবে আপনি যে __dict__সমস্যাগুলি সরিয়ে বা _as_dict()পরিবর্তনের সাথে সাথে আসে এবং এজাতীয় কিছু করতে পারেন তা এড়াতে পারেন (এবং হ্যাঁ এটি পাইথন 3 কারণ এই উত্তরটি বর্তমানের জন্য):

from typing import NamedTuple

class ApiListRequest(NamedTuple):
  group: str="default"
  filter: str="*"

  def to_dict(self):
    return {
      'group': self.group,
      'filter': self.filter,
    }

  def to_json(self):
    return json.dumps(self.to_dict())

কল পাওয়া যায় তবে কলটি করার জন্য defaultকাওয়ার্গ ব্যবহার করার চেষ্টা করেছি , তবে এটি তালিকায় রূপান্তরযোগ্য হিসাবে কল হয় নি ।dumpsto_dict()NamedTuple

Question 11

সমস্যাটি আমার এখানে দেওয়া। এটি নেমডটপলকে সিরিয়ালাইজ করে, ভাঁজ করা নামডটপলস এবং তাদের ভিতরে তালিকাগুলির যত্ন নেয়

def recursive_to_dict(obj: Any) -> dict:
_dict = {}

if isinstance(obj, tuple):
    node = obj._asdict()
    for item in node:
        if isinstance(node[item], list): # Process as a list
            _dict[item] = [recursive_to_dict(x) for x in (node[item])]
        elif getattr(node[item], "_asdict", False): # Process as a NamedTuple
            _dict[item] = recursive_to_dict(node[item])
        else: # Process as a regular element
            _dict[item] = (node[item])
return _dict

Question 12

simplejson.dump()পরিবর্তে json.dumpকাজ করে। যদিও এটি ধীর হতে পারে।