মাল্টিপ্রসেসিং পুল.ম্যাপ () ব্যবহার করার সময় <টাইপ 'উদাহরণস্বরূপ'> আচার তৈরি করতে পারবেন না

Question

আমি একই সাথে কাজ বিভক্ত করতে multiprocessingএর Pool.map()ফাংশনটি ব্যবহার করার চেষ্টা করছি । আমি যখন নিম্নলিখিত কোডটি ব্যবহার করি তখন এটি ঠিকঠাক কাজ করে:

import multiprocessing

def f(x):
    return x*x

def go():
    pool = multiprocessing.Pool(processes=4)        
    print pool.map(f, range(10))


if __name__== '__main__' :
    go()

যাইহোক, আমি যখন এটি আরও অবজেক্ট-ভিত্তিক পদ্ধতির ব্যবহার করি তখন এটি কার্যকর হয় না। এটি প্রদত্ত ত্রুটি বার্তাটি হ'ল:

PicklingError: Can't pickle <type 'instancemethod'>: attribute lookup
__builtin__.instancemethod failed

নিম্নলিখিতটি যখন আমার প্রধান প্রোগ্রাম হয় তখন এটি ঘটে:

import someClass

if __name__== '__main__' :
    sc = someClass.someClass()
    sc.go()

এবং নিম্নলিখিতটি আমার someClassক্লাস:

import multiprocessing

class someClass(object):
    def __init__(self):
        pass

    def f(self, x):
        return x*x

    def go(self):
        pool = multiprocessing.Pool(processes=4)       
        print pool.map(self.f, range(10))

সমস্যা কী হতে পারে বা এর চারপাশে সহজ উপায় যে কেউ জানেন?

Comments

যদি এফ কোনও নেস্টেড ফাংশন হয় তবে একই রকম ত্রুটি রয়েছেPicklingError: Can't pickle <class 'function'>: attribute lookup builtins.function failed

— ggg

Answer 1

সমস্যাটি হ'ল মাল্টিপ্রসেসিংগুলিকে অবশ্যই প্রক্রিয়াগুলির মধ্যে তাদের স্লিং করার জন্য জিনিসগুলি আচার করতে হবে, এবং আবদ্ধ পদ্ধতিগুলি বাছাইযোগ্য নয়। কার্যতালিকা (আপনি এটি "সহজ" বিবেচনা করুন বা নাও ;-) হ'ল আপনার প্রোগ্রামে অবকাঠামোগত যোগ করা যেমন এই পদ্ধতিগুলিকে বাছাই করা যায়, কপির_রেগের সাথে এটি নিবন্ধন করে স্ট্যান্ডার্ড লাইব্রেরি পদ্ধতিতে ।

উদাহরণস্বরূপ, স্টিভেন বেথার্ডের এই থ্রেডের ( থ্রেডের শেষের দিকে) অবদান পদ্ধতিটি বাছাই / আন-পিক্লিংয়ের মাধ্যমে পদ্ধতিটিকে বেছে নেওয়ার জন্য একদম কার্যকরী পদ্ধতি দেখায় copy_reg।

Comments

দুর্দান্ত - আপনাকে ধন্যবাদ দেখে মনে হচ্ছে যে কোনও উপায়ে অগ্রগতি হয়েছে: পেস্টবিন.সিএ / ১69৯৩৩৪৮ কোডটি ব্যবহার করে আমি এখন রানটাইম এরির পেয়েছি: সর্বাধিক পুনরাবৃত্তির গভীরতা অতিক্রম করেছে। আমি চারদিকে তাকালাম এবং একটি ফোরাম পোস্ট সর্বাধিক গভীরতা 1500 (ডিফল্ট 1000 থেকে) বাড়ানোর প্রস্তাব দিলেও সেখানে আমার কোনও আনন্দ নেই। সত্যি কথা বলতে, আমি দেখতে পাচ্ছি না (আমার কোডের কমপক্ষে) কোন অংশ নিয়ন্ত্রণের বাইরে চলে আসছিল, যদি না কোনও কারণে কোডটি একটি লুপে বাছাই করা হয় এবং আনুষাঙ্গিক না করা হয়, যাতে সামান্য পরিবর্তন করার কারণে আমি তৈরি করেছি স্টিভেনের কোড ওওড?

— ভেন্টোলিন

আপনার _pickle_methodরিটার্ন self._unpickle_method, একটি আবদ্ধ পদ্ধতি; সুতরাং অবশ্যই আচার চেষ্টা করে আচারটি - এবং এটি যেমনটি আপনি বলেছেন তেমনই ঘটে: কল করে _pickle_method, পুনরাবৃত্তি করে। অর্থাত OOএইভাবে কোডটি যুক্ত করে আপনি অনিবার্যভাবে অসীম পুনরাবৃত্তি প্রবর্তন করেছেন। আমি স্টিভেনের কোডটিতে ফিরে যাওয়ার পরামর্শ দিই (এবং উপযুক্ত না হলে ওওর বেদীটিতে উপাসনা করব না: পাইথনের অনেকগুলি কাজ আরও কার্যকরভাবে করা হয়, এবং এটি একটি)।

— অ্যালেক্স মার্টেলি

অলসতার জন্য

— জন

সুপার সুপার অলসতার জন্য , একমাত্র উত্তরটি দেখুন যা আসল নন-ম্যাঙ্গেলড কোড পোস্ট করতে বিরক্ত করেছিল ...

— সেরিন

ফিক্স আরেকটি উপায় / পাশকাটিয়ে pickling সমস্যা শুলফা ব্যবহার করছে, আমার উত্তর দেখুন stackoverflow.com/questions/8804830/...

— rocksportrocker

Answer 2

এই সমস্ত সমাধানগুলি কুরুচিপূর্ণ কারণ আপনি প্রমিত লাইব্রেরির বাইরে ঝাঁপ না দিয়ে মাল্টিপ্রসেসিং এবং পিকিং ভাঙ্গা এবং সীমাবদ্ধ।

যদি আপনি multiprocessingডাকা একটি কাঁটাচামচ ব্যবহার করেন pathos.multiprocesssing, আপনি মাল্টিপ্রসেসিংয়ের mapকার্যক্রমে সরাসরি ক্লাস এবং শ্রেণি পদ্ধতি ব্যবহার করতে পারেন । এ কারণে যে dillপরিবর্তে ব্যবহার করা হয় pickleবা cPickle, এবং dillপাইথন মধ্যে প্রায় কিছু ধারাবাহিকভাবে পারবেন না।

pathos.multiprocessingএছাড়াও একটি অ্যাসিনক্রোনাস মানচিত্র ফাংশন সরবরাহ করে ... এবং এটি mapএকাধিক যুক্তি (যেমন map(math.pow, [1,2,3], [4,5,6])) সহ ফাংশন করতে পারে

দেখুন: মাল্টিপ্রসেসিং এবং ডিল একসাথে কী করতে পারে?

এবং: http://matthewrocklin.com/blog/work/2013/12/05/ সমান্তরালতা- এবং- সমীক্ষা /

>>> import pathos.pools as pp
>>> p = pp.ProcessPool(4)
>>> 
>>> def add(x,y):
...   return x+y
... 
>>> x = [0,1,2,3]
>>> y = [4,5,6,7]
>>> 
>>> p.map(add, x, y)
[4, 6, 8, 10]
>>> 
>>> class Test(object):
...   def plus(self, x, y): 
...     return x+y
... 
>>> t = Test()
>>> 
>>> p.map(Test.plus, [t]*4, x, y)
[4, 6, 8, 10]
>>> 
>>> p.map(t.plus, x, y)
[4, 6, 8, 10]

এবং কেবল স্পষ্ট করে বলতে গেলে, আপনি ঠিক মতো করতে চান যে আপনি প্রথম স্থানে যা করতে চেয়েছিলেন, এবং আপনি চাইলে দোভাষী থেকে এটি করতে পারেন।

>>> import pathos.pools as pp
>>> class someClass(object):
...   def __init__(self):
...     pass
...   def f(self, x):
...     return x*x
...   def go(self):
...     pool = pp.ProcessPool(4)
...     print pool.map(self.f, range(10))
... 
>>> sc = someClass()
>>> sc.go()
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> 

কোডটি এখানে পান: https://github.com/uqfoundation/pathos

Comments

আপনি দয়া করে এই উত্তরটি pathos.pp এর উপর ভিত্তি করে আপডেট করতে পারেন কারণ প্যাথোস.মલ્ટিয়াপ্রসেসিংয়ের অস্তিত্ব নেই?

— সাহিল গোধন

আমি pathosলেখক। আপনি যে সংস্করণটির কথা উল্লেখ করছেন এটি বেশ কয়েক বছরের পুরনো। গিথুব এ সংস্করণ ব্যবহার করে দেখুন, আপনি ব্যবহার করতে পারেন pathos.ppবা github.com/uqfoundation/ppft ব্যবহার করতে পারেন ।

— মাইক ম্যাকার্নস 21

বা github.com/uqfoundation/pathos । @ সাহিলগোধনে: একটি নতুন প্রকাশ দীর্ঘ সময়ের জন্য বিলম্বিত, তবে শীঘ্রই এটি প্রকাশ করা উচিত।

— মাইক ম্যাকার্নস 21

প্রথমে pip install setuptools, তারপর pip install git+https://github.com/uqfoundation/pathos.git@master। এটি উপযুক্ত নির্ভরতা পাবে। একটি নতুন রিলিজ প্রায় প্রস্তুত ... এখন প্রায় সব pathosকিছু উইন্ডোতেও চলে এবং এটি 3.xসামঞ্জস্যপূর্ণ।

— মাইক ম্যাকার্নস 10

@ রিকা: হ্যাঁ। অবরুদ্ধকরণ, পুনরাবৃত্তি এবং অ্যাসিঙ্ক মানচিত্র উপলব্ধ।

— মাইক ম্যাকার্নস

Answer 3

আপনি নিজের __call__()অভ্যন্তরের কোনও পদ্ধতিও সংজ্ঞায়িত করতে পারেন someClass()যা কল করে someClass.go()এবং তারপরে একটি উদাহরণ someClass()পুলে যেতে পারে। এই বস্তুটি বাছাইযোগ্য এবং এটি কার্যকর (আমার জন্য) কাজ করে ...

Comments

এটি অ্যালেক্স মার্তেলির প্রস্তাবিত কৌশলটির চেয়ে অনেক সহজ, তবে আপনি আপনার মাল্টিপ্রসেসিং পুলটিতে প্রতি ক্লাসে কেবল একটি পদ্ধতি প্রেরণে সীমাবদ্ধ।

— অবচিত

অন্য একটি বিবরণ মনে রাখবেন তা হ'ল এটি কেবলমাত্র বস্তু (শ্রেণীর উদাহরণ) যা মশাল হয়ে যায়, শ্রেণী নিজেই নয়। অতএব, আপনি যদি তাদের ডিফল্ট মানগুলি থেকে কোনও শ্রেণীর বৈশিষ্ট্যগুলি পরিবর্তন করেন তবে এই পরিবর্তনগুলি বিভিন্ন প্রক্রিয়াতে প্রচার করবে না। কাজের ফাংশনটি হ'ল এটি নিশ্চিত করা যে আপনার ফাংশনটির যা যা প্রয়োজন তার সবগুলি উদাহরণের বৈশিষ্ট্য হিসাবে সঞ্চিত রয়েছে।

— অবচিত

@ দ্বারক আপনি কি এর সাথে একটি সাধারণ উদাহরণ দেখাতে পারেন __call__()? আমি মনে করি আপনার উত্তরটি ক্লিনারটি হতে পারে - আমি এই ত্রুটিটি বোঝার জন্য লড়াই করছি এবং প্রথমবার কলটি দেখতে এসেছি। যাইহোক, এই উত্তরটি মাল্টিপ্রসেসিং কী করে তা পরিষ্কার করতে সহায়তা করে: [

— স্ট্যাকওভারফ্লো.com

আপনি একটি উদাহরণ দিতে পারেন?

— frmsaul

এর জন্য উদাহরণ কোড সহ একটি নতুন উত্তর পোস্ট করা হয়েছে (বর্তমানে এটির নীচে)।

— অ্যারন

Answer 4

স্টিভেন বেথার্ডের সমাধানের ক্ষেত্রে কিছু সীমাবদ্ধতা:

আপনি যখন আপনার শ্রেণি পদ্ধতিটি একটি ফাংশন হিসাবে নিবন্ধন করেন, আপনার ক্লাসের ডেস্ট্রাক্টরকে প্রতিবার আপনার পদ্ধতি প্রক্রিয়া সমাপ্ত হওয়ার পরে অবাক করে বলা হয়। সুতরাং আপনার কাছে যদি আপনার ক্লাসের 1 টি উদাহরণ রয়েছে যা তার পদ্ধতিটিকে n বার বলছে, সদস্যরা 2 রানের মধ্যে অদৃশ্য হয়ে যেতে পারে এবং আপনি একটি বার্তা পেতে পারেন malloc: *** error for object 0x...: pointer being freed was not allocated(উদাঃ ওপেন মেম্বার ফাইল) বা pure virtual method called, terminate called without an active exception(যার অর্থ আমি যে সদস্যের অবজেক্টে ব্যবহৃত আজীবন তার চেয়ে কম ছিল) আমি যা ভেবেছিলাম). পুলের আকারের চেয়ে বৃহত্তর সাথে ডিল করার সময় আমি এটি পেয়েছি। এখানে একটি সংক্ষিপ্ত উদাহরণ:

from multiprocessing import Pool, cpu_count
from multiprocessing.pool import ApplyResult

# --------- see Stenven's solution above -------------
from copy_reg import pickle
from types import MethodType

def _pickle_method(method):
    func_name = method.im_func.__name__
    obj = method.im_self
    cls = method.im_class
    return _unpickle_method, (func_name, obj, cls)

def _unpickle_method(func_name, obj, cls):
    for cls in cls.mro():
        try:
            func = cls.__dict__[func_name]
        except KeyError:
            pass
        else:
            break
    return func.__get__(obj, cls)


class Myclass(object):

    def __init__(self, nobj, workers=cpu_count()):

        print "Constructor ..."
        # multi-processing
        pool = Pool(processes=workers)
        async_results = [ pool.apply_async(self.process_obj, (i,)) for i in range(nobj) ]
        pool.close()
        # waiting for all results
        map(ApplyResult.wait, async_results)
        lst_results=[r.get() for r in async_results]
        print lst_results

    def __del__(self):
        print "... Destructor"

    def process_obj(self, index):
        print "object %d" % index
        return "results"

pickle(MethodType, _pickle_method, _unpickle_method)
Myclass(nobj=8, workers=3)
# problem !!! the destructor is called nobj times (instead of once)

আউটপুট:

Constructor ...
object 0
object 1
object 2
... Destructor
object 3
... Destructor
object 4
... Destructor
object 5
... Destructor
object 6
... Destructor
object 7
... Destructor
... Destructor
... Destructor
['results', 'results', 'results', 'results', 'results', 'results', 'results', 'results']
... Destructor

__call__পদ্ধতি কারণ [কোনটি, ...] ফলাফল থেকে পড়া হয়, তাই সমতুল্য নয়:

from multiprocessing import Pool, cpu_count
from multiprocessing.pool import ApplyResult

class Myclass(object):

    def __init__(self, nobj, workers=cpu_count()):

        print "Constructor ..."
        # multiprocessing
        pool = Pool(processes=workers)
        async_results = [ pool.apply_async(self, (i,)) for i in range(nobj) ]
        pool.close()
        # waiting for all results
        map(ApplyResult.wait, async_results)
        lst_results=[r.get() for r in async_results]
        print lst_results

    def __call__(self, i):
        self.process_obj(i)

    def __del__(self):
        print "... Destructor"

    def process_obj(self, i):
        print "obj %d" % i
        return "result"

Myclass(nobj=8, workers=3)
# problem !!! the destructor is called nobj times (instead of once), 
# **and** results are empty !

সুতরাং উভয় পদ্ধতির কোনওটিই সন্তুষ্ট নয় ...

Comments

আপনি Noneফিরে পেয়েছেন কারণ আপনার সংজ্ঞাটি __call__অনুপস্থিত return: এটি হওয়া উচিত return self.process_obj(i)।

— torek

@ এরিক আমি একই ত্রুটি পাচ্ছিলাম এবং আমি এই সমাধানটি চেষ্টা করেছিলাম, তবে আমি "সিপিক্লিক.পিক্লিংএরারার: ​​নতুন ধরণের <ফাংশন"> আচার করতে পারছি না: ফাংশন বিল্ট ইন ফাংশন ব্যর্থ " হিসাবে নতুন ত্রুটি পাওয়া শুরু করে । এর পিছনে সম্ভাব্য কারণ কী হতে পারে জানেন?

— নামান

Answer 5

আপনি ব্যবহার করতে পারেন এমন আরও একটি শর্ট-কাট রয়েছে, যদিও এটি আপনার শ্রেণীর উদাহরণগুলির উপর নির্ভর করে অকার্যকর হতে পারে।

যেহেতু সবাই বলেছে যে সমস্যাটি হ'ল multiprocessingকোডটি সেগুলি শুরু করা উপ-প্রক্রিয়াগুলিতে প্রেরিত জিনিসগুলিকে আচার করতে হয়, এবং পিকেল উদাহরণ-পদ্ধতিগুলি করে না।

যাইহোক, উদাহরণ-পদ্ধতি প্রেরণের পরিবর্তে, আপনি প্রকৃত শ্রেণীর উদাহরণটি, কল করার জন্য ফাংশনের নামটি পাঠাতে পারেন একটি সাধারণ ফাংশনে যা পরে getattrউদাহরণ-পদ্ধতিটি কল করতে ব্যবহৃত হয়, ফলে Poolউপশক্তিতে আবদ্ধ পদ্ধতি তৈরি হয় । এটি একটি সংজ্ঞায়িত করার অনুরূপ__call__ পদ্ধতির যা আপনি একাধিক সদস্য ফাংশনটিতে কল করতে পারেন।

@ এরিকএইচ। এর কোডটি তার উত্তর থেকে চুরি করা এবং এটি কিছুটা বর্ণিত করা (সমস্ত কারণেই যাদুর উদাহরণের জন্য এটি কাট-পেস্ট :-) এর চেয়ে সহজ বলে মনে হয়েছিল) তাই নামটির সমস্ত নাম পরিবর্তন হয়েছে এবং এরকম: আমি এটি আবার লিখেছি:

import multiprocessing
import os

def call_it(instance, name, args=(), kwargs=None):
    "indirect caller for instance methods and multiprocessing"
    if kwargs is None:
        kwargs = {}
    return getattr(instance, name)(*args, **kwargs)

class Klass(object):
    def __init__(self, nobj, workers=multiprocessing.cpu_count()):
        print "Constructor (in pid=%d)..." % os.getpid()
        self.count = 1
        pool = multiprocessing.Pool(processes = workers)
        async_results = [pool.apply_async(call_it,
            args = (self, 'process_obj', (i,))) for i in range(nobj)]
        pool.close()
        map(multiprocessing.pool.ApplyResult.wait, async_results)
        lst_results = [r.get() for r in async_results]
        print lst_results

    def __del__(self):
        self.count -= 1
        print "... Destructor (in pid=%d) count=%d" % (os.getpid(), self.count)

    def process_obj(self, index):
        print "object %d" % index
        return "results"

Klass(nobj=8, workers=3)

আউটপুটটি দেখায় যে, প্রকৃতপক্ষে কনস্ট্রাক্টরকে একবার (মূল পিডে) বলা হয় এবং ডিস্ট্রাক্টরকে 9 বার বলা হয় (একবারে প্রতি কপির জন্য একবার পুল-কর্মী-প্রক্রিয়া অনুযায়ী প্রয়োজন অনুসারে = 2 বা 3 বার, মূল হিসাবে একবারে প্রক্রিয়ার মধ্যে)। এটি প্রায়শই ঠিক থাকে, যেমন এই ক্ষেত্রে, যেহেতু ডিফল্ট চয়নকারী পুরো দৃষ্টান্তের একটি অনুলিপি তৈরি করে এবং (আধা) গোপনে এটি পুনরায় জনসাধারণ করে this এক্ষেত্রে:

obj = object.__new__(Klass)
obj.__dict__.update({'count':1})

এই কারণেই যদিও তিনটি কর্মী প্রক্রিয়ায় ডেস্ট্রাক্টরকে আটবার ডাকা হলেও এটি প্রতিবার 1 থেকে 0 হয়ে যায় - তবে অবশ্যই আপনি এইভাবে সমস্যায় পড়তে পারেন। প্রয়োজনে আপনি নিজের সরবরাহ করতে পারেন __setstate__:

    def __setstate__(self, adict):
        self.count = adict['count']

উদাহরণস্বরূপ এই ক্ষেত্রে।

Comments

এটি এই সমস্যার পক্ষে এখন পর্যন্ত সর্বোত্তম উত্তর, কারণ অ-পিকেল-না-সক্ষম ডিফল্ট আচরণে প্রয়োগ করা সবচেয়ে সহজ

— ম্যাট টেলর

Answer 6

আপনি নিজের __call__()অভ্যন্তরের কোনও পদ্ধতিও সংজ্ঞায়িত করতে পারেন someClass()যা কল করে someClass.go()এবং তারপরে একটি উদাহরণ someClass()পুলে যেতে পারে। এই বস্তুটি বাছাইযোগ্য এবং এটি কার্যকর (আমার জন্য) কাজ করে ...

class someClass(object):
   def __init__(self):
       pass
   def f(self, x):
       return x*x

   def go(self):
      p = Pool(4)
      sc = p.map(self, range(4))
      print sc

   def __call__(self, x):   
     return self.f(x)

sc = someClass()
sc.go()

Answer 7

উপরের প্যারিসহোনের সমাধানটি আমার সাথে ভাল কাজ করে। এছাড়াও কোডটি পরিষ্কার এবং বোঝার জন্য সহজ দেখাচ্ছে। আমার ক্ষেত্রে পুল ব্যবহার করে কল করার জন্য কয়েকটি ফাংশন রয়েছে, তাই আমি কিছুটা নীচে প্যারিসহনের কোডটি সংশোধন করেছি। আমি তৈরী করেছি কল বিভিন্ন ফাংশান কল করার পাবে, এবং ফাংশন নাম থেকে যুক্তি অভি পাস হয় go():

from multiprocessing import Pool
class someClass(object):
    def __init__(self):
        pass

    def f(self, x):
        return x*x

    def g(self, x):
        return x*x+1    

    def go(self):
        p = Pool(4)
        sc = p.map(self, [{"func": "f", "v": 1}, {"func": "g", "v": 2}])
        print sc

    def __call__(self, x):
        if x["func"]=="f":
            return self.f(x["v"])
        if x["func"]=="g":
            return self.g(x["v"])        

sc = someClass()
sc.go()

Answer 8

এর সম্ভাব্য তুচ্ছ সমাধানটি হ'ল ব্যবহারে স্যুইচ করা multiprocessing.dummy । এটি মাল্টিপ্রসেসিং ইন্টারফেসের একটি থ্রেড ভিত্তিক বাস্তবায়ন যা পাইথন ২.7 এ এই সমস্যাটি বলে মনে হয় না। আমার এখানে খুব বেশি অভিজ্ঞতা নেই, তবে এই দ্রুত আমদানি পরিবর্তন আমাকে ক্লাস পদ্ধতিতে প্রয়োগ_াসিঙ্ক কল করতে দেয়।

কয়েকটি ভাল সংস্থান চালু আছে on multiprocessing.dummy :

https://docs.python.org/2/library/multiprocessing.html#module-multiprocessing.dummy

http://chriskiehl.com/article/parallelism-in-one-line/

Answer 9

এই সাধারণ ক্ষেত্রে, যেখানে someClass.fশ্রেণি থেকে কোনও তথ্য উত্তরাধিকার সূত্রে প্রাপ্ত নয় এবং শ্রেণিতে কোনও কিছু সংযুক্ত না করা, সেখানে একটি পৃথক পৃথক সমাধানের সম্ভাব্য সমাধান হতে পারে f, সুতরাং এটিকে বেছে নেওয়া যেতে পারে:

import multiprocessing


def f(x):
    return x*x


class someClass(object):
    def __init__(self):
        pass

    def go(self):
        pool = multiprocessing.Pool(processes=4)       
        print pool.map(f, range(10))

Answer 10

আলাদা ফানক ব্যবহার করবেন না কেন?

def func(*args, **kwargs):
    return inst.method(args, kwargs)

print pool.map(func, arr)

Answer 11

আমি এই একই সমস্যার মধ্যে দৌড়েছি কিন্তু জেনেছি যে একটি জেএসওএন এনকোডার রয়েছে যা এই বস্তুগুলিকে প্রক্রিয়াগুলির মধ্যে স্থানান্তরিত করতে ব্যবহার করা যেতে পারে।

from pyVmomi.VmomiSupport import VmomiJSONEncoder

আপনার তালিকা তৈরি করতে এটি ব্যবহার করুন:

jsonSerialized = json.dumps(pfVmomiObj, cls=VmomiJSONEncoder)

তারপরে ম্যাপ করা ফাংশনে, অবজেক্টটি পুনরুদ্ধার করতে এটি ব্যবহার করুন:

pfVmomiObj = json.loads(jsonSerialized)

Answer 12

আপডেট: এই লেখার দিন পর্যন্ত, নামকৃত টিপলগুলি বাছাইযোগ্য (অজগর ২.7 দিয়ে শুরু)

এখানে সমস্যাটি হচ্ছে শিশু প্রক্রিয়াগুলি বস্তুর শ্রেণিটি আমদানি করতে সক্ষম হয় না - এই ক্ষেত্রে, ক্লাস পি-, একটি বহু-মডেল প্রকল্পের ক্ষেত্রে ক্লাস পি যেখানেই শিশু প্রক্রিয়াটি ব্যবহার করা যায় সেখানে আমদানিযোগ্য হতে হবে

গ্লোবালগুলিতে () এর দ্বারা প্রভাবিত হয়ে এটিকে আমদানিযোগ্য করা দ্রুত কাজ

globals()["P"] = P