@ ডেকোটারেটর পাইথনে 2.4 যোগ করা হয়েছে যদি আপনি পাইথন <2.4 ব্যবহার করছেন তবে আপনি classmethod () এবং staticmethod () ফাংশন ব্যবহার করতে পারেন।

উদাহরণস্বরূপ, যদি আপনি একটি ফ্যাক্টরী পদ্ধতি তৈরি করতে চান (কোন ফাংশনটি কোন যুক্তিটির উপর নির্ভর করে একটি শ্রেণির একটি ভিন্ন বাস্তবায়নের একটি দৃষ্টান্ত ফেরত দিচ্ছে) আপনি এমন কিছু করতে পারেন:

class Cluster(object):

    def _is_cluster_for(cls, name):
        """
        see if this class is the cluster with this name
        this is a classmethod
        """ 
        return cls.__name__ == name
    _is_cluster_for = classmethod(_is_cluster_for)

    #static method
    def getCluster(name):
        """
        static factory method, should be in Cluster class
        returns a cluster object for the given name
        """
        for cls in Cluster.__subclasses__():
            if cls._is_cluster_for(name):
                return cls()
    getCluster = staticmethod(getCluster)

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

_is_cluster_for পদ্ধতিটি _is_cluster_for পদ্ধতিটি তৈরি করার আরেকটি সুবিধা তাই একটি উপশ্রেণীটি এটি বাস্তবায়নের সিদ্ধান্ত নিতে পারে, কারণ এটি বেশ জেনেরিক এবং একাধিক ধরনের ক্লাস্টার পরিচালনা করতে পারে, তাই কেবলমাত্র ক্লাসের নাম পরীক্ষা করা যথেষ্ট নয়।

Staticmethod vs classmethod সম্মান সঙ্গে আরেকটি বিবেচনা উত্তরাধিকার সঙ্গে আসে। বলুন আপনি নিম্নলিখিত ক্লাস আছে:

class Foo(object):
    @staticmethod
    def bar():
        return "In Foo"

এবং তারপর আপনি একটি শিশু বর্গ bar() ওভাররাইড করতে চান:

class Foo2(Foo):
    @staticmethod
    def bar():
        return "In Foo2"

এটি কাজ করে, কিন্তু মনে রাখবেন যে এখন Foo2 () শিশু বর্গ ( Foo2 ) বাস্তবায়ন আর সেই শ্রেণির নির্দিষ্ট কিছু সুবিধা গ্রহণ করতে পারবে না। উদাহরণস্বরূপ, Foo2 কে একটি magic() নামক একটি পদ্ধতি বলা হয়েছে যা আপনি bar() এর Foo2 বাস্তবায়নে ব্যবহার করতে চান:

class Foo2(Foo):
    @staticmethod
    def bar():
        return "In Foo2"
    @staticmethod
    def magic():
        return "Something useful you'd like to use in bar, but now can't" 

এখানে Foo2.magic() bar() Foo2.magic() এ কল করতে হবে, তবে তারপরে আপনি নিজের পুনরাবৃত্তি করছেন (যদি Foo2 নামটি পরিবর্তন করে তবে আপনাকে bar() পদ্ধতিটি আপডেট করতে মনে রাখা হবে।

আমার কাছে, এটি খোলা / বন্ধ নীতির সামান্য লঙ্ঘন, কারণ Foo করা সিদ্ধান্তটি একটি ডেরাইভেড শ্রেণিতে সাধারণ কোডটি পুনরায় প্রকাশ করার আপনার ক্ষমতাকে প্রভাবিত করে (অর্থাত এটি এক্সটেনশনটির জন্য কম খোলা থাকে)। যদি bar() একটি classmethod ছিল classmethod আমরা সূক্ষ্ম হব:

class Foo(object):
    @classmethod
    def bar(cls):
        return "In Foo"

class Foo2(Foo):
    @classmethod
    def bar(cls):
        return "In Foo2 " + cls.magic()
    @classmethod
    def magic(cls):
        return "MAGIC"

print Foo2().bar()

দেয়: In Foo2 MAGIC

আমার মনে হয় একটি ভাল প্রশ্ন "কখন আপনি @ ক্ল্যাসমিডেম বনাম @ স্ট্যাটিক মেথড ব্যবহার করবেন?"

@classmethod আপনাকে ক্লাসের সংজ্ঞাগুলির সাথে যুক্ত ব্যক্তিগত সদস্যদের সহজে অ্যাক্সেস দেয়। এটি একটি দুর্দান্ত উপায়, বা তৈরি করা বস্তুর দৃষ্টান্তের সংখ্যাগুলি নিয়ন্ত্রণ করতে এমন কারখানার ক্লাসগুলি করার একটি দুর্দান্ত উপায়।

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

আমি একটি উদাহরণ ব্যবহার করে মৌলিক পার্থক্য ব্যাখ্যা করার চেষ্টা করব।

class A(object):
    x = 0

    def say_hi(self):
        pass

    @staticmethod
    def say_hi_static():
        pass

    @classmethod
    def say_hi_class(cls):
        pass

    def run_self(self):
        self.x += 1
        print self.x # outputs 1
        self.say_hi()
        self.say_hi_static()
        self.say_hi_class()

    @staticmethod
    def run_static():
        print A.x  # outputs 0
        # A.say_hi() #  wrong
        A.say_hi_static()
        A.say_hi_class()

    @classmethod
    def run_class(cls):
        print cls.x # outputs 0
        # cls.say_hi() #  wrong
        cls.say_hi_static()
        cls.say_hi_class()

1 - আমরা সরাসরি স্ট্যাটিক এবং classmethods কল ছাড়া শুরু করতে পারেন

# A.run_self() #  wrong
A.run_static()
A.run_class()

2- স্ট্যাটিক পদ্ধতি স্ব পদ্ধতিতে কল করতে পারে না তবে অন্যান্য স্ট্যাটিক এবং ক্লাসম্যথিকে কল করতে পারে

3- স্ট্যাটিক পদ্ধতি ক্লাস অন্তর্গত এবং বস্তু ব্যবহার করবে না।

4- ক্লাস পদ্ধতি একটি বস্তু কিন্তু একটি বর্গ আবদ্ধ হয় না।

আমি সি ++ এবং তারপর জাভা এবং তারপর পাইথন সহ প্রোগ্রামিং ভাষা শিখতে শুরু করি এবং তাই এই প্রশ্নটি আমাকে অনেক বিরক্ত করে, যতক্ষণ না আমি প্রতিটি সহজ ব্যবহার বুঝতে পারি।

ক্লাস পদ্ধতি: জাভা এবং C ++ এর বিপরীতে পাইথন কনস্ট্রাকটর ওভারলোডিং নেই। এবং তাই এটি অর্জন করতে আপনি classmethod ব্যবহার করতে পারেন। নিম্নলিখিত উদাহরণ এই ব্যাখ্যা করবে

আসুন আমরা বিবেচনা করি যে আমাদের একটি Person শ্রেণীর আছে যা প্রথম আর্গুমেন্ট first_name এবং last_name নেয় এবং ব্যক্তিটির উদাহরণ তৈরি করে।

class Person(object):

    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

এখন, যদি এমন প্রয়োজন আসে যেখানে আপনি শুধুমাত্র একটি নাম ব্যবহার করে একটি শ্রেণি তৈরি করতে চান, শুধুমাত্র একটি first_name , আপনি পাইথন এ এমন কিছু করতে পারবেন না ।

যখন আপনি একটি বস্তু (উদাহরণ) তৈরি করার চেষ্টা করবেন তখন এটি আপনাকে একটি ত্রুটি দেবে।

class Person(object):

    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

    def __init__(self, first_name):
        self.first_name = first_name

তবে, আপনি নীচের উল্লিখিত @classmethod ব্যবহার করে একই জিনিস অর্জন করতে পারেন

class Person(object):

    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

    @classmethod
    def get_person(cls, first_name):
        return cls(first_name, "")

স্ট্যাটিক পদ্ধতি:: এটি বরং সহজ, এটি উদাহরণ বা শ্রেণির জন্য আবদ্ধ নয় এবং আপনি কেবল ক্লাস নাম ব্যবহার করে কল করতে পারেন।

তাই উপরের উদাহরণে বলা যাক আপনাকে একটি বৈধতা প্রয়োজন যা first_name ২0 অক্ষর অতিক্রম করবে না, আপনি কেবল এটি করতে পারেন।

@staticmethod  
def validate_name(name):
    return len(name) <= 20

এবং আপনি কেবল ক্লাস নাম ব্যবহার করে কল করতে পারে

Person.validate_name("Gaurang Shah")

মূলত @classmethod একটি পদ্ধতি তৈরি করে যার প্রথম যুক্তিটি ক্লাস (উদাহরণস্বরূপ ক্লাস ক্লাসের পরিবর্তে) থেকে বলা হয়, @staticmethod কোনও অন্তর্নিহিত আর্গুমেন্ট নেই।

হয়তো উদাহরণ কোডের একটি বিট সাহায্য করবে: foo , class_foo এবং static_foo এর কল স্বাক্ষরগুলির পার্থক্যটি লক্ষ্য করুন:

class A(object):
    def foo(self,x):
        print "executing foo(%s,%s)"%(self,x)

    @classmethod
    def class_foo(cls,x):
        print "executing class_foo(%s,%s)"%(cls,x)

    @staticmethod
    def static_foo(x):
        print "executing static_foo(%s)"%x    

a=A()

নীচে একটি বস্তু উদাহরণ একটি পদ্ধতি কল স্বাভাবিক উপায়। বস্তু উদাহরণ, a , নিখুঁত প্রথম যুক্তি হিসাবে পাস করা হয়।

a.foo(1)
# executing foo(<__main__.A object at 0xb7dbef0c>,1)

শ্রেণিবদ্ধ পদ্ধতিগুলির সাথে , বস্তুর দৃষ্টান্তের শ্রেণীটি স্বতঃস্ফূর্তভাবে আত্মের পরিবর্তে প্রথম যুক্তি হিসাবে গৃহীত হয়।

a.class_foo(1)
# executing class_foo(<class '__main__.A'>,1)

আপনি ক্লাস ব্যবহার করে class_foo কল করতে পারেন। প্রকৃতপক্ষে, যদি আপনি কোন শ্রেণীবিন্যাস হতে কিছু সংজ্ঞায়িত করেন তবে সম্ভবত এটির কারণ হল আপনি ক্লাসের দৃষ্টান্তের পরিবর্তে ক্লাস থেকে এটি কল করতে চান। A.foo(1) একটি A.class_foo(1) উত্থাপিত করেছে, তবে A.class_foo(1) ঠিক সূক্ষ্ম কাজ করে:

A.class_foo(1)
# executing class_foo(<class '__main__.A'>,1)

ক্লাস ব্যবহার করার জন্য পাওয়া যায় এমন এক ব্যবহার উত্তরাধিকারী বিকল্প কন্সট্রাক্টর তৈরি করা।

স্ট্যাটিক পদ্ধতির সাথে , self (বস্তু দৃষ্টান্ত) বা cls (বর্গ) সম্পূর্ণরূপে প্রথম যুক্তি হিসাবে পাস করা হয়। তারা প্লেইন ফাংশনগুলির মত আচরণ করে যা ব্যতীত আপনি তাদের একটি উদাহরণ বা শ্রেণী থেকে কল করতে পারেন:

a.static_foo(1)
# executing static_foo(1)

A.static_foo('hi')
# executing static_foo(hi)

Staticmethods ক্লাসে ক্লাসের সাথে কিছু লজিক্যাল সংযোগ আছে এমন গ্রুপ ক্রিয়াকলাপগুলিতে ব্যবহার করা হয়।

foo শুধু একটি ফাংশন, তবে যখন আপনি a.foo কল a.foo তখন ফাংশনটি পেতে না গেলে, ফাংশনের প্রথম যুক্তি হিসাবে আবদ্ধ বস্তুর উদাহরণটি সহ ফাংশনের একটি "আংশিকভাবে প্রয়োগ করা" সংস্করণ পাবেন। foo 2 আর্গুমেন্ট আশা করে, যখন a.foo শুধুমাত্র 1 টি যুক্তি আশা করে।

a foo আবদ্ধ হয়। যে শব্দটি "আবদ্ধ" শব্দটির দ্বারা বোঝানো হয়:

print(a.foo)
# <bound method A.foo of <__main__.A object at 0xb7d52f0c>>

a.class_foo দিয়ে, a.class_foo সাথে আবদ্ধ নয়, বরং ক্লাস A class_foo ।

print(a.class_foo)
# <bound method type.class_foo of <class '__main__.A'>>

এখানে, একটি স্ট্যাটিক পদ্ধতির সাথে এটি একটি পদ্ধতি হলেও, a.static_foo কেবল একটি ভাল 'Ole ফাংশন প্রদান করে যা কোন আর্গুমেন্ট আবদ্ধ নয়। static_foo 1 টি যুক্তি আশা করে এবং a.static_foo আশা করে 1 টি যুক্তিও।

print(a.static_foo)
# <function static_foo at 0xb7d479cc>

এবং অবশ্যই একই জিনিস ঘটে যখন আপনি ক্লাস A সাথে static_foo কল করুন।

print(A.static_foo)
# <function static_foo at 0xb7d479cc>

@staticmethod বা @classmethod ব্যবহার করতে হবে কিনা তা নির্ধারণ করার জন্য আপনাকে আপনার পদ্ধতির ভিতরে দেখতে হবে। আপনার পদ্ধতি আপনার ক্লাসে অন্যান্য ভেরিয়েবল / পদ্ধতি অ্যাক্সেস করে তাহলে @classmethod ব্যবহার করুন । অন্যদিকে, যদি আপনার পদ্ধতিটি ক্লাসের যে কোনও অংশকে স্পর্শ করে না তবে স্ট্যাটিকম পদ্ধতি ব্যবহার করুন।

class Apple:

    _counter = 0

    @staticmethod
    def about_apple():
        print('Apple is good for you.')

        # note you can still access other member of the class
        # but you have to use the class instance 
        # which is not very nice, because you have repeat yourself
        # 
        # For example:
        # @staticmethod
        #    print('Number of apples have been juiced: %s' % Apple._counter)
        #
        # @classmethod
        #    print('Number of apples have been juiced: %s' % cls._counter)
        #
        #    @classmethod is especially useful when you move your function to other class,
        #       you don't have to rename the class reference 

    @classmethod
    def make_apple_juice(cls, number_of_apples):
        print('Make juice:')
        for i in range(number_of_apples):
            cls._juice_this(i)

    @classmethod
    def _juice_this(cls, apple):
        print('Juicing %d...' % apple)
        cls._counter += 1

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

@staticmethod ফাংশন একটি বর্গের ভিতরে সংজ্ঞায়িত ফাংশন ছাড়া আর কিছুই নয়। এটা প্রথম ক্লাস তাত্ক্ষণিক ছাড়া callable হয়। এটা সংজ্ঞা উত্তরাধিকার মাধ্যমে অপরিবর্তনীয়।

• পাইথন বস্তুর জন্য একটি আবদ্ধ পদ্ধতি তাত্ক্ষণিক করতে হবে না।
• এটি কোডটির পঠনযোগ্যতা সহজ করে এবং এটি বস্তুর অবস্থার উপর নির্ভর করে না;

@classmethod ফাংশনটি ক্লাসটি তাত্ক্ষণিকভাবে কল করার @classmethod নয়, তবে তার সংজ্ঞা সাব ক্লাসের মাধ্যমে, সাবস্ক্রাসের মাধ্যমে, সাবস্ক্রাসের অনুসরণ করে, প্যারেন্ট ক্লাস নয়। যেহেতু @classmethod ফাংশনের প্রথম যুক্তি সর্বদা cls (বর্গ) হতে হবে।

• ফ্যাক্টরী পদ্ধতি , উদাহরণস্বরূপ ব্যবহার করার জন্য একটি ক্লাসের জন্য একটি উদাহরণ তৈরি করতে ব্যবহৃত হয় উদাহরণস্বরূপ প্রাক প্রক্রিয়াকরণ।
• স্ট্যাটিক পদ্ধতিগুলি স্ট্যাটিক পদ্ধতিগুলিকে কল করে : যদি আপনি বিভিন্ন স্ট্যাটিক পদ্ধতিতে স্ট্যাটিক পদ্ধতিগুলি বিভক্ত করেন তবে আপনাকে ক্লাসের নাম হার্ড-কোড করতে হবে না তবে ক্লাস পদ্ধতিগুলি ব্যবহার করতে হবে

অফিসিয়াল পাইথন ডক্স:

@classmethod

ক্লাস পদ্ধতিটি ক্লাসটিকে অন্তর্নিহিত প্রথম যুক্তি হিসেবে গ্রহণ করে, যেমন একটি ইনস্ট্যান্স পদ্ধতি উদাহরণটি গ্রহণ করে। একটি ক্লাস পদ্ধতি ঘোষণা করতে, এই idiom ব্যবহার করুন:

class C:
    @classmethod
    def f(cls, arg1, arg2, ...): ... 

@classmethod ফর্ম একটি ফাংশন decorator - বিস্তারিত জানার জন্য ফাংশন সংজ্ঞাগুলিতে ফাংশন সংজ্ঞাগুলির বর্ণনাটি দেখুন।

এটি ক্লাসে (যেমন Cf() ) বা একটি উদাহরণে (যেমন C().f() ) হিসাবে বলা যেতে পারে। উদাহরণ তার শ্রেণীর জন্য উপেক্ষা করা হয়। যদি একটি বর্গক্ষেত্রের পদ্ধতিটি কোনও প্রাপ্ত শ্রেণির জন্য বলা হয়, তবে অভিভূত শ্রেণিবদ্ধ বস্তুটিকে উদ্দিষ্ট প্রথম যুক্তি হিসাবে প্রেরণ করা হয়।

ক্লাস পদ্ধতিগুলি সি ++ বা জাভা স্ট্যাটিক পদ্ধতিগুলির থেকে আলাদা। আপনি যদি চান, এই বিভাগে staticmethod() দেখুন।

@staticmethod

একটি স্ট্যাটিক পদ্ধতি একটি অন্তর্নিহিত প্রথম যুক্তি পাবেন না। একটি স্ট্যাটিক পদ্ধতি ঘোষণা করার জন্য, এই idiom ব্যবহার করুন:

class C:
    @staticmethod
    def f(arg1, arg2, ...): ... 

@staticmethod ফর্মটি একটি ফাংশন decorator - বিস্তারিত জানার জন্য ফাংশন সংজ্ঞাগুলিতে ফাংশন সংজ্ঞাগুলির বর্ণনাটি দেখুন।

এটি ক্লাসে (যেমন Cf() ) বা একটি উদাহরণে (যেমন C().f() ) হিসাবে বলা যেতে পারে। উদাহরণ তার শ্রেণীর জন্য উপেক্ষা করা হয়।

পাইথন স্ট্যাটিক পদ্ধতিগুলি জাভা বা সি ++ এ পাওয়া যায়। আরো উন্নত ধারণাটির জন্য, এই বিভাগে classmethod() দেখুন।

পাইথন মধ্যে বর্গ পদ্ধতি বনাম স্ট্যাটিক পদ্ধতি

ক্লাস পদ্ধতি

@Classmethod সজ্জাকারী, একটি বিল্টিন ফাংশন সজ্জাকারী যা আপনার ক্রিয়াকলাপটিকে সংজ্ঞায়িত করার পরে মূল্যায়ন করে এমন একটি অভিব্যক্তি। যে মূল্যায়ন ফলাফল আপনার ফাংশন সংজ্ঞা ছায়া গো।

ক্লাস পদ্ধতিটি ক্লাসটিকে অন্তর্নিহিত প্রথম যুক্তি হিসেবে গ্রহণ করে, যেমন একটি ইনস্ট্যান্স পদ্ধতি উদাহরণটি গ্রহণ করে

বাক্য গঠন:

class C(object):
    @staticmethod
    def fun(arg1, arg2, ...):
        ...
returns: a static method for function fun.

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

স্ট্যাটিক পদ্ধতি

একটি স্ট্যাটিক পদ্ধতি একটি অন্তর্নিহিত প্রথম যুক্তি পাবেন না।

বাক্য গঠন:

# Python program to demonstrate 
# use of class method and static method.
from datetime import date

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # a class method to create a Person object by birth year.
    @classmethod
    def fromBirthYear(cls, name, year):
        return cls(name, date.today().year - year)

    # a static method to check if a Person is adult or not.
    @staticmethod
    def isAdult(age):
        return age > 18

person1 = Person('mayank', 21)
person2 = Person.fromBirthYear('mayank', 1996)

print person1.age
print person2.age

# print the result
print Person.isAdult(22)

• স্ট্যাটিক মেথড এমন একটি পদ্ধতি যা ক্লাসে আবদ্ধ এবং ক্লাসের বস্তু নয়।
• একটি স্ট্যাটিক পদ্ধতি প্রবেশাধিকার বা শ্রেণী রাষ্ট্র পরিবর্তন করতে পারবেন না।
• এটা ক্লাসে উপস্থিত কারণ এটি ক্লাসে উপস্থিত হওয়ার পদ্ধতির জন্য ইন্দ্রিয়গ্রাহী।

ক্লাস পদ্ধতি বনাম স্ট্যাটিক পদ্ধতি

• একটি স্ট্যাটিক পদ্ধতি কোন নির্দিষ্ট পরামিতি প্রয়োজন যখন একটি বর্গ পদ্ধতি প্রথম পরামিতি হিসাবে cls লাগে।
• একটি স্ট্যাটিক পদ্ধতি অ্যাক্সেস বা সংশোধন করতে পারে না যখন একটি বর্গ পদ্ধতি ক্লাস অবস্থা অ্যাক্সেস বা সংশোধন করতে পারেন।
• আমরা একটি ক্লাস পদ্ধতি তৈরি করতে পাইথনের @classmethod সজ্জা ব্যবহার করি এবং পাইথনে স্ট্যাটিক পদ্ধতি তৈরি করতে আমরা @ স্ট্যাটিকমিথ সজ্জাকারী ব্যবহার করি।

কখন ব্যবহার করবেন?

• আমরা সাধারণত কারখানা পদ্ধতি তৈরির জন্য ক্লাস পদ্ধতি ব্যবহার করি। ফ্যাক্টরি পদ্ধতি বিভিন্ন ব্যবহারের ক্ষেত্রে ক্লাস অবজেক্ট (একটি কন্সট্রাকটর অনুরূপ) ফেরত দেয়।
• আমরা সাধারণত ইউটিলিটি ফাংশন তৈরি করতে স্ট্যাটিক পদ্ধতি ব্যবহার করুন।

কিভাবে একটি ক্লাস পদ্ধতি এবং একটি স্ট্যাটিক পদ্ধতি সংজ্ঞায়িত?

পাইথনে একটি ক্লাস পদ্ধতি সংজ্ঞায়িত করার জন্য, আমরা @ ক্ল্যাসমিথ ডেক্সকোটার ব্যবহার করি এবং একটি স্ট্যাটিক পদ্ধতি সংজ্ঞায়িত করতে যা আমরা @ স্ট্যাটিক মেথড ডেক্সকোটার ব্যবহার করি।

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

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

বাস্তবায়ন

21
21
True

আউটপুট

>>> class Klaus:
        @classmethod
        def classmthd(*args):
            return args

        @staticmethod
        def staticmthd(*args):
            return args

# 1. Call classmethod without any arg
>>> Klaus.classmthd()  
(__main__.Klaus,)  # the class gets passed as the first argument

# 2. Call classmethod with 1 arg
>>> Klaus.classmthd('chumma')
(__main__.Klaus, 'chumma')

# 3. Call staticmethod without any arg
>>> Klaus.staticmthd()  
()

# 4. Call staticmethod with 1 arg
>>> Klaus.staticmthd('chumma')
('chumma',)

Reference

@ স্ট্যাটিকমিথটি আক্ষরিক অর্থে বিভিন্ন অন্তর্দৃষ্টি প্রদান করে বিশ্লেষণ করুন ।

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

একটি staticmethod প্রকৃতপক্ষে একটি স্বাভাবিক ফাংশন একটি বর্গ সংজ্ঞা বাইরে যারা হিসাবে একই।
এটি সৌভাগ্যক্রমে ক্লাসে গোষ্ঠীভুক্ত করা হয় যেখানে এটি প্রয়োগ করা হয় তার কাছাকাছি দাঁড়ানোর জন্য, অথবা আপনি এটি খুঁজে পেতে স্ক্রোল করতে পারেন।

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

কোড পঠনযোগ্যতা জন্য আমি @staticmethodআপনার লোড কাজ কাজের জন্য ব্যবহার করা হবে না, যেখানে nanoseconds গণনা না হওয়া পর্যন্ত আমি এড়াতে চাই ।

শ্রেণী পদ্ধতি, যেমন নাম প্রস্তাব করে, ক্লাসে পরিবর্তন করতে এবং বস্তুগুলির জন্য নয়। ক্লাসগুলিতে পরিবর্তনগুলি করতে, তারা শ্রেণির গুণাবলীগুলি (বস্তুর গুণাবলি নয়) সংশোধন করবে, যেহেতু আপনি ক্লাসগুলি কীভাবে আপডেট করবেন। এই কারণেই শ্রেণী পদ্ধতিগুলি প্রথম যুক্তি হিসাবে শ্রেণিকে (সাধারণভাবে 'cls' দ্বারা সংজ্ঞায়িত করে) গ্রহণ করে।

class A(object):
    m=54

    @classmethod
    def class_method(cls):
        print "m is %d" % cls.m

অন্যদিকে স্ট্যাটিক পদ্ধতিগুলি ক্লাসের সাথে আবদ্ধ নয় এমন কার্যকারিতা সম্পাদন করার জন্য ব্যবহৃত হয় অর্থাৎ তারা শ্রেণী ভেরিয়েবলগুলি পড়তে বা লিখতে পারবে না। অতএব, স্ট্যাটিক পদ্ধতি আর্গুমেন্ট হিসাবে ক্লাস নিতে না। তারা ব্যবহার করা হয় যাতে ক্লাস কার্যকারিতা সম্পাদন করতে পারে যা সরাসরি ক্লাসের উদ্দেশ্য সম্পর্কিত নয়।

class X(object):
    m=54 #will not be referenced

    @staticmethod
    def static_method():
        print "Referencing/calling a variable or function outside this class. E.g. Some global variable/function."

#!/usr/bin/python
#coding:utf-8

class Demo(object):
    def __init__(self,x):
        self.x = x

    @classmethod
    def addone(self, x):
        return x+1

    @staticmethod
    def addtwo(x):
        return x+2

    def addthree(self, x):
        return x+3

def main():
    print Demo.addone(2)
    print Demo.addtwo(2)

    #print Demo.addthree(2) #Error
    demo = Demo(2)
    print demo.addthree(2)


if __name__ == '__main__':
    main()