আমার ফাংশন জটিল এবং প্রচুর ভেরিয়েবল থাকলে আমার একটি শ্রেণি তৈরি করা উচিত?

Question

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

অন্য কথায়, জাভার মতো ভাষায় অপ্রয়োজনীয় ক্লাস তৈরি করার জন্য আমি কম অপরাধী বোধ করি তবে আমার মনে হয় পাইথনের মতো কম বয়লারপ্লেট-y ভাষায় আরও ভাল উপায় থাকতে পারে।

আমার প্রোগ্রামটি বেশ কয়েকবার তুলনামূলকভাবে জটিল অপারেশন করা দরকার। এই অপারেশনের জন্য প্রচুর "বুককিপিং" দরকার, কিছু অস্থায়ী ফাইল ইত্যাদি তৈরি করতে এবং মুছতে হয় etc.

এজন্য এটিকে আরও অনেকগুলি "suboperation" কল করতে হবে - সবকিছুকে একটি বিশাল পদ্ধতিতে স্থাপন করা খুব সুন্দর, মডুলার, পঠনযোগ্য ইত্যাদি নয় isn't

এখন এগুলি আমার মনে আসে এমন পদ্ধতিগুলি:

১. এমন একটি শ্রেণি তৈরি করুন যার কেবলমাত্র একটি পাবলিক পদ্ধতি রয়েছে এবং সাবোপেশনগুলির জন্য প্রয়োজনীয় অভ্যন্তরীণ পরিস্থিতিকে তার ভেরিয়েবলগুলিতে রাখে।

এটি দেখতে এমন কিছু লাগবে:

class Thing:

    def __init__(self, var1, var2):
        self.var1 = var1
        self.var2 = var2
        self.var3 = []

    def the_public_method(self, param1, param2):
        self.var4 = param1
        self.var5 = param2
        self.var6 = param1 + param2 * self.var1
        self.__suboperation1()
        self.__suboperation2()
        self.__suboperation3()


    def __suboperation1(self):
        # Do something with self.var1, self.var2, self.var6
        # Do something with the result and self.var3
        # self.var7 = something
        # ...
        self.__suboperation4()
        self.__suboperation5()
        # ...

    def suboperation2(self):
        # Uses self.var1 and self.var3

#    ...
#    etc.

এই পদ্ধতির সাথে আমি যে সমস্যাটি দেখছি তা হ'ল এই শ্রেণীর অবস্থা কেবল অভ্যন্তরীণভাবেই বোধ করে এবং এটি তাদের একমাত্র সর্বজনীন পদ্ধতির কল ব্যতীত এর উদাহরণগুলির সাথে কিছুই করতে পারে না।

# Make a thing object
thing = Thing(1,2)

# Call the only method you can call
thing.the_public_method(3,4)

# You don't need thing anymore

২. একটি ক্লাস ছাড়াই একগুচ্ছ ফাংশন তৈরি করুন এবং তাদের মধ্যে অভ্যন্তরীণভাবে প্রয়োজনীয় বিভিন্ন পরিবর্তনশীল (তর্ক হিসাবে) পাস করুন।

আমি এটির সাথে যে সমস্যাটি দেখছি তা হ'ল আমাকে ফাংশনের মধ্যে প্রচুর ভেরিয়েবল পাস করতে হবে। এছাড়াও, ফাংশনগুলি একে অপরের সাথে ঘনিষ্ঠভাবে সম্পর্কিত হবে তবে সেগুলি একসাথে ভাগ করা হবে না।

৩. এর মতো ২. তবে রাষ্ট্রগুলি পরিবর্তন করার পরিবর্তে বৈশ্বিক পরিবর্তন করুন।

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

চতুর্থ, আরও ভাল, পদ্ধতির আছে? যদি তা না হয় তবে এর মধ্যে কোন একটি পদ্ধতির ভাল হবে এবং কেন? আমি কি অনুপস্থিত কিছু আছে?

Comments

"এই পদ্ধতির সাথে আমি যে সমস্যাটি দেখছি তা হ'ল এই শ্রেণীর অবস্থা কেবল অভ্যন্তরীণভাবেই বোধ করে এবং তাদের একমাত্র পাবলিক পদ্ধতি কল না করে এর উদাহরণগুলি দিয়ে কিছুই করতে পারে না।" আপনি এটিকে একটি সমস্যা হিসাবে প্রকাশ করেছেন তবে আপনি কেন এটি মনে করেন তা নয়।

— প্যাট্রিক মউপিন

@ পেট্রিক মউপিন - আপনি ঠিক বলেছেন। এবং আমি সত্যিই জানি না, এটাই সমস্যা। এটি কেবল মনে হয় যে আমি এমন কিছুর জন্য ক্লাস ব্যবহার করছি যার জন্য অন্য কিছু ব্যবহার করা উচিত, এবং পাইথনের অনেকগুলি বিষয় আমি এখনও অনুসন্ধান করতে পারি নি তাই আমি ভেবেছিলাম যে কেউ হয়তো আরও উপযুক্ত কিছু প্রস্তাব দেবেন।

— আইক্যানলার্ন

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

— আইক্যানলার্ন

সম্ভাব্য সদৃশ একটি শ্রেণীর আসল দায়িত্ব কি?

— gnat

যদি আপনি কেবলমাত্র বিদ্যমান কোডগুলি পদ্ধতি এবং উদাহরণের ভেরিয়েবলগুলিতে ছড়িয়ে দেন এবং এর কাঠামোর বিষয়ে কিছুই পরিবর্তন করেন না তবে আপনি স্পষ্টতা হারাতে ছাড়া কিছুই অর্জন করতে পারেন না। (1) একটি খারাপ ধারণা।

— usr ডিরেক্টরির

Answer 1

1. এমন একটি বর্গ তৈরি করুন যার কেবলমাত্র একটি পাবলিক পদ্ধতি রয়েছে এবং সাবওরেশনগুলির জন্য প্রয়োজনীয় অভ্যন্তরীণ পরিস্থিতিটিকে তার চলকগুলিতে রাখে।

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

বিকল্প 1 সঠিকভাবে ব্যবহৃত এনক্যাপসুলেশনের একটি ভাল উদাহরণ । আপনি চান অভ্যন্তরীণ অবস্থা বাইরের কোড থেকে গোপন করা হোক।

এর অর্থ যদি আপনার শ্রেণিতে কেবল একটি পাবলিক পদ্ধতি থাকে, তবে তা হ'ল। এটি বজায় রাখা এত সহজ হবে।

গলি আপনি একটি বর্গ যে ঠিক 1 জিনিস করে, একটি ছোট প্রকাশ্য পৃষ্ঠ আছে, এবং সব তার অভ্যন্তরীণ স্থিতি গোপন, তাহলে আপনি হয় (যেমন চার্লি শিন বলতে হবে) রাখে আছে যদি বিজয়ী ।

2. কোনও শ্রেণি ছাড়াই একগুচ্ছ ফাংশন তৈরি করুন এবং তাদের মধ্যে অভ্যন্তরীণভাবে প্রয়োজনীয় বিভিন্ন পরিবর্তনশীল (তর্ক হিসাবে) পাস করুন pass

আমি এটির সাথে যে সমস্যাটি দেখছি তা হ'ল আমাকে ফাংশনের মধ্যে প্রচুর ভেরিয়েবল পাস করতে হবে। এছাড়াও, ফাংশনগুলি একে অপরের সাথে ঘনিষ্ঠভাবে সম্পর্কিত হবে তবে তাদের একসাথে ভাগ করা হবে না।

বিকল্প 2 কম সংহতিতে ভুগছে । এটি রক্ষণাবেক্ষণকে আরও কঠিন করে তুলবে।

3. 2 টি পছন্দ করুন তবে রাষ্ট্রটি পরিবর্তন করার পরিবর্তে বৈশ্বিক পরিবর্তন করুন।

বিকল্প 3, বিকল্প 2 এর মতো, কম সংশ্লেষে ভুগছে, তবে আরও মারাত্মকভাবে!

ইতিহাস দেখিয়েছে যে বিশ্বব্যাপী ভেরিয়েবলের সুবিধাগুলি বর্ধিত বর্বর রক্ষণাবেক্ষণ ব্যয় দ্বারা ছাড়িয়ে গেছে। এ কারণেই আপনি শুনতে পান আমার মতো পুরানো খামারগুলি সারাক্ষণ এনক্যাপসুলেশন সম্পর্কে রেটিং করে।

---

বিজয়ী বিকল্পটি # 1 ।

Comments

# 1 যদিও একটি সুন্দর কুরুচিপূর্ণ এপিআই। আমি যদি এর জন্য একটি ক্লাস করার সিদ্ধান্ত নিয়েছি তবে আমি সম্ভবত একটি একক পাবলিক ফাংশন করব যা ক্লাসের প্রতিনিধি এবং পুরো ক্লাসটিকে ব্যক্তিগত করে তোলে। ThingDoer(var1, var2).do_it()বনাম do_thing(var1, var2)।

— ব্যবহারকারী 2357112

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

বিকল্প 1 এর এক্সটেনশনে আপনি আরও একটি জিনিস করতে পারেন: ফলস্বরূপ শ্রেণিটি সুরক্ষিত করুন (নামের সামনে আন্ডারস্কোর যুক্ত করুন) এবং তারপরে def do_thing(var1, var2): return _ThingDoer(var1, var2).run()বাহ্যিক এপিআইকে কিছুটা প্রিটিটিয়ার করার জন্য একটি মডিউল-স্তরের ফাংশন সংজ্ঞায়িত করুন ।

— সুজোরড জব পোস্টমাস

আমি আপনার যুক্তিটি 1 টি অনুসরণ করি না The অভ্যন্তরীণ অবস্থা ইতিমধ্যে লুকানো আছে। ক্লাস যুক্ত করা এতে পরিবর্তন হয় না। সুতরাং আপনি কেন প্রস্তাব দিন তা আমি দেখতে পাই না (1)। আসলে শ্রেণীর অস্তিত্বকে একেবারেই প্রকাশ করা প্রয়োজন হয় না।

— usr ডিরেক্টরির

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

— বেন

Answer 2

আমি মনে করি যে # 1 আসলে একটি খারাপ বিকল্প।

আসুন আপনার ফাংশন বিবেচনা করুন:

def the_public_method(self, param1, param2):
    self.var4 = param1
    self.var5 = param2 
    self.var6 = param1 + param2 * self.var1
    self.__suboperation1()
    self.__suboperation2()
    self.__suboperation3()

সাবোপরেশন 1 কোন টুকরো ডেটা ব্যবহার করে? এটি কি suboperation2 দ্বারা ব্যবহৃত ডেটা সংগ্রহ করে? আপনি যখন এটি নিজের উপর সঞ্চয় করে ডেটা চারপাশে পাস করেন তখন কার্যকারিতার টুকরো কীভাবে সম্পর্কিত তা আমি বলতে পারি না। আমি যখন নিজের দিকে তাকাই, তখন কিছু বৈশিষ্ট্য নির্মাতাদের থেকে হয়, কিছু কল থেকে__পাবলিক_সূত্রের, এবং কিছু এলোমেলোভাবে অন্য জায়গায় যুক্ত করা হয়। আমার মতে, এটি একটি জগাখিচুড়ি।

# 2 নাম্বার সম্পর্কে কী? ভাল, প্রথমত, এর সাথে দ্বিতীয় সমস্যাটি দেখুন:

এছাড়াও, ফাংশনগুলি একে অপরের সাথে ঘনিষ্ঠভাবে সম্পর্কিত হবে তবে তাদের একসাথে ভাগ করা হবে না।

তারা একসাথে একটি মডিউল হতে হবে, তাই তারা সম্পূর্ণ একসাথে গ্রুপ করা হবে।

আমি এটির সাথে যে সমস্যাটি দেখছি তা হ'ল আমাকে ফাংশনের মধ্যে প্রচুর ভেরিয়েবল পাস করতে হবে।

আমার মতে, এটি ভাল। এটি আপনার অ্যালগরিদমে ডেটা নির্ভরতা সুস্পষ্ট করে তোলে। গ্লোবাল ভেরিয়েবলে হোক বা স্বতে সেগুলি সঞ্চয় করে আপনি নির্ভরতাগুলি লুকিয়ে রাখেন এবং এগুলি কম খারাপ বলে মনে করেন, তবে তারা এখনও সেখানে রয়েছে।

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

অবশ্যই, আপনার প্রকৃত ফাংশনটি না দেখে অনুমান করা খুব ভাল যে কী ভাল পরামর্শ হবে। তবে আপনি এখানে কি আচরণ করছেন সে সম্পর্কে কিছুটা ইঙ্গিত দিয়েছেন:

আমার প্রোগ্রামটি বেশ কয়েকবার তুলনামূলকভাবে জটিল অপারেশন করা দরকার। এই অপারেশনের জন্য প্রচুর "বুককিপিং" দরকার, কিছু অস্থায়ী ফাইল তৈরি এবং মুছতে হবে ইত্যাদি

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

def install_program():
    copied_files = []
    try:
        for filename in FILES_TO_COPY:
           temporary_file = create_temporary_file()
           copy(target_filename(filename), temporary_file)
           copied_files = [target_filename(filename), temporary_file)
           copy(source_filename(filename), target_filename(filename))
     except CancelledException:
        for source_file, temp_file in copied_files:
            copy(temp_file, source_file)
     else:
        for source_file, temp_file in copied_files:
            delete(temp_file)

রেজিস্ট্রি সেটিংস, প্রোগ্রাম আইকন, ইত্যাদি করার জন্য এখন সেই যুক্তিকে গুণিত করুন এবং আপনি বেশ গোলমাল পেয়েছেন।

আমি মনে করি যে আপনার # 1 সমাধানটি দেখে মনে হচ্ছে:

class Installer:
    def install(self):
        try:
            self.copy_new_files()
        except CancellationError:
            self.restore_original_files()
        else:
            self.remove_temp_files()

এটি সামগ্রিক অ্যালগোরিদমকে আরও পরিষ্কার করে তোলে, তবে এটি বিভিন্ন টুকরোটি যোগাযোগ করার উপায়ে লুকায়।

পদ্ধতির # 2 এর মতো দেখতে:

def install_program():
    try:
       temp_files = copy_new_files()
    except CancellationError as error:
       restore_old_files(error.files_that_were_copied)
    else:
       remove_temp_files(temp_files)

এখন এটি স্পষ্টভাবে কীভাবে ডেটার টুকরো ফাংশনগুলির মধ্যে সরানো হয় তবে এটি খুব বিশ্রী।

তাহলে এই ফাংশনটি কীভাবে লেখা উচিত?

def install_program():
    with FileTransactionLog() as file_transaction_log:
         copy_new_files(file_transaction_log)

ফাইল ট্রান্সঅ্যাকশন লগ অবজেক্টটি একটি প্রসঙ্গ পরিচালক manager যখন copy_new_files কোনও ফাইল অনুলিপি করে তা ফাইলট্রান্সঅ্যাকশনলগের মাধ্যমে এটি করে যা অস্থায়ী অনুলিপি তৈরি করে এবং কোন ফাইল অনুলিপি করে তা ট্র্যাক করে। ব্যতিক্রমের ক্ষেত্রে এটি মূল ফাইলগুলি অনুলিপি করে এবং সাফল্যের ক্ষেত্রে এটি অস্থায়ী অনুলিপিগুলি মুছে দেয়।

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

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

Answer 3

যেহেতু পদ্ধতির 1 এর একমাত্র আপাত ত্রুটি এটির সাবটটিমাল ব্যবহারের ধরণ, তাই আমি মনে করি সর্বোত্তম সমাধান হ'ল আরও এক ধাপ আরও আগে এনক্যাপসুলেশন চালনা করা: একটি ক্লাস ব্যবহার করুন, তবে একটি নিখরচায় ফাংশন সরবরাহ করুন, যা কেবলমাত্র অবজেক্টটি তৈরি করে, পদ্ধতিটি কল করে এবং প্রত্যাবর্তন করে :

def publicFunction(var1, var2, param1, param2)
    thing = Thing(var1, var2)
    thing.theMethod(param1, param2)

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

Answer 4

একদিকে, প্রশ্নটি কোনওভাবে ভাষা অজ্ঞেয়; তবে অন্যদিকে, বাস্তবায়ন ভাষা এবং এর উদাহরণগুলির উপর নির্ভর করে। এই ক্ষেত্রে এটি পাইথন, যা একাধিক প্যারাডিজমগুলিকে সমর্থন করে।

আপনার সমাধানগুলি ছাড়াও আরও কার্যকরী উপায়ে অপারেশন সম্পূর্ণ স্টেটলেস সম্পূর্ণ করার একটি সম্ভাবনাও রয়েছে

def outer(param1, param2):
    def inner1(param1, param2, param3):
        pass
    def inner2(param1, param2):
        pass
    return inner2(inner1(param1),param2,param3)

এটি সব নেমে আসে

• সুপাঠ্যতা
• দৃঢ়তা
• maintainability

তবে -আপনার কোডবেস যদি ওওপি হয় তবে হঠাৎ কিছু অংশ যদি (আরও) কার্যকরী শৈলীতে লেখা হয় তবে এটি ধারাবাহিকতা লঙ্ঘন করে।

Answer 5

যখন আমি কোডিং করতে পারি তখন ডিজাইন কেন?

আমি যে উত্তরগুলি পড়েছি সেগুলিতে আমি একটি বিপরীত দৃষ্টিভঙ্গি সরবরাহ করি। সেই দৃষ্টিকোণ থেকে সমস্ত উত্তর এবং সত্যই এমনকি প্রশ্ন নিজেই কোডিং মেকানিক্সের উপর ফোকাস করে। তবে এটি একটি ডিজাইনের সমস্যা।

আমার ফাংশন জটিল এবং প্রচুর ভেরিয়েবল থাকলে আমার একটি শ্রেণি তৈরি করা উচিত?

হ্যাঁ, এটি যেমন আপনার ডিজাইনের জন্য অর্থবোধ করে। এটি নিজের কাছে একটি শ্রেণি বা অন্য কোনও শ্রেণির অংশ হতে পারে বা এর আচরণ ক্লাসগুলির মধ্যে বিতরণ করা যেতে পারে।

---

অবজেক্ট ওরিয়েন্টেড ডিজাইন জটিলতা সম্পর্কে

ওও এর বক্তব্যটি হ'ল সিস্টেমের নিজের ক্ষেত্রে শর্তাবলী কোডকে সাপ্লাই করে সাফল্যের সাথে বৃহত, জটিল সিস্টেমগুলি তৈরি এবং রক্ষণাবেক্ষণ করা। "যথাযথ" নকশা বলছে সবকিছু কিছু না কোনও শ্রেণিতে রয়েছে।

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

এটি প্রদত্ত, এটি প্রায়শই বলা হয় যে সিস্টেম সম্পর্কে ঝুঁকিপূর্ণ ফাংশনগুলি - সমস্ত খুব সর্বব্যাপী সাধারণ ইউটিলিটি শ্রেণি - এটি একটি গন্ধ যা অপর্যাপ্ত ডিজাইনের পরামর্শ দেয়। আমি একমত হয়।

Comments

ওও ডিজাইন প্রাকৃতিকভাবে জটিলতা পরিচালনা করে ওওপি প্রাকৃতিকভাবে অপ্রয়োজনীয় জটিলতার পরিচয় দেয়।

— মাইলস রাউট

"অপ্রয়োজনীয় জটিলতা" সহ-কর্মীদের কাছ থেকে অমূল্য মন্তব্যের কথা মনে করিয়ে দেয় যেমন "ওহ, এটি অনেকগুলি শ্রেণি।" অভিজ্ঞতা আমাকে বলে যে রসটি চেপে ধরার মূল্য। এটি সর্বোত্তম আমি দেখতে পাচ্ছি যে পদ্ধতিগুলি পুরোপুরি 1-3 লাইন দীর্ঘ এবং প্রতিটি ক্লাস করার সাথে এটি দেওয়া কোনও পদ্ধতির অংশ জটিলতা হ্রাস করা হয়েছে: একটি সংক্ষিপ্ত এলওসি দুটি সংগ্রহের সাথে তুলনা করে এবং সদৃশগুলি ফিরিয়ে দিচ্ছে - অবশ্যই এর পিছনে কোড রয়েছে। জটিল কোডে "প্রচুর কোড" বিভ্রান্ত করবেন না। যাই হোক না কেন, কিছুই বিনামূল্যে।

— রডারবব

জটিল পদ্ধতিতে ইন্টারঅ্যাক্ট করে প্রচুর "সাধারণ" কোডটি কম সংখ্যক জটিল কোডের চেয়ে খারাপ।

— মাইলস রাউট

অল্প পরিমাণে জটিল কোডটিতে জটিলতা রয়েছে । জটিলতা আছে, তবে কেবল সেখানে। এটি ফুটো হয় না। যখন আপনার কাছে আলাদা আলাদা সরল টুকরো রয়েছে যা সত্যিই জটিল এবং বোঝার জন্য একসাথে কাজ করে যা আরও জটিলতর হয় কারণ জটিলতার কোনও সীমানা বা দেয়াল নেই।

— মাইলস রাউট

Answer 6

আপনার প্রয়োজনগুলিকে স্ট্যান্ডার্ড পাইথন লাইব্রেরিতে বিদ্যমান এমন কিছু সাথে তুলনা করবেন না এবং তারপরে কীভাবে এটি প্রয়োগ করা হয় তা দেখুন?

দ্রষ্টব্য, যদি আপনার কোনও জিনিসের প্রয়োজন না হয় তবে আপনি এখনও ফাংশনগুলির মধ্যে ফাংশনগুলি সংজ্ঞায়িত করতে পারেন। পাইথন 3 এর সাথে একটি নতুন nonlocalঘোষণা রয়েছে যা আপনাকে আপনার পিতামাতার কার্যক্রমে ভেরিয়েবল পরিবর্তন করতে দেয়।

আপনি এখনও বিমূর্তি প্রয়োগ এবং অপারেশন আপ অপারেশন প্রয়োগ করার জন্য আপনার ফাংশনটির ভিতরে কিছু সাধারণ বেসরকারী ক্লাস রাখা দরকারী বলে মনে করতে পারেন।

Comments

ধন্যবাদ। এবং আপনি কি স্ট্যান্ডার্ড লাইব্রেরিতে এমন কিছু জানেন যা শোনায় যে প্রশ্নটিতে আমার কাছে যা আছে?

— আইক্যানলার্ন

নেস্টেড ফাংশনগুলি ব্যবহার করে কিছু উদ্ধৃত করা আমার পক্ষে কঠিন হয়ে পড়েছে, প্রকৃতপক্ষে আমি nonlocalআমার ইনস্টলড পাইথন লিবসের কোনও জায়গা পাই না । সম্ভবত আপনি হৃদয় গ্রহণ করতে পারেন textwrap.pyযা থেকে একটি TextWrapperক্লাস রয়েছে তবে এটি এমন একটি def wrap(text)ফাংশন যা কেবল একটি TextWrapper উদাহরণ তৈরি করে , এতে .wrap()পদ্ধতিটি কল করে ফিরে আসে। সুতরাং একটি ক্লাস ব্যবহার করুন, তবে কিছু সুবিধাজনক ফাংশন যুক্ত করুন।

— meuh