පයිතන්හි atstaticmethod සහ lassClassmethod අතර වෙනස කුමක්ද?
මෙම ව්‍යාජ කේතය වැනි පයිතන් කේතය ඔබ දැක ඇති අතර, එය විවිධ ක්රම වර්ගවල අත්සන් නිරූපණය කරන අතර ඒවා පැහැදිලි කිරීමට ලේඛනයක් සපයයි:
class Foo(object):
def a_normal_instance_method(self, arg_1, kwarg_2=None):
'''
Return a value that is a function of the instance with its
attributes, and other arguments such as arg_1 and kwarg2
'''
@staticmethod
def a_static_method(arg_0):
'''
Return a value that is a function of arg_0. It does not know the
instance or class it is called from.
'''
@classmethod
def a_class_method(cls, arg1):
'''
Return a value that is a function of the class and other arguments.
respects subclassing, it is called with the class it is called from.
'''
සාමාන්‍ය උදාහරණ ක්රමය
මුලින්ම මම පැහැදිලි කරන්නම් a_normal_instance_method. මෙය හරියටම " නිදර්ශන ක්‍රමයක් " ලෙස හැඳින්වේ " හැඳින්වේ. නිදර්ශන ක්‍රමයක් භාවිතා කරන විට, එය අර්ධ ශ්රිතයක් ලෙස භාවිතා කරයි (සම්පූර්ණ ශ්‍රිතයට ප්‍රතිවිරුද්ධව, ප්‍රභව කේතයෙන් බලන විට සියලු අගයන් සඳහා අර්ථ දක්වා ඇත), එනම් භාවිතා කරන විට, පළමු තර්කයේ උදාහරණය ලෙස පූර්ව නිශ්චිත වේ. වස්තුව, එහි දී ඇති සියලු ගුණාංග සමඟ. එයට වස්තුව බැඳී ඇති අවස්ථාව ඇති අතර එය වස්තුවක උදාහරණයකින් හැඳින්විය යුතුය. සාමාන්‍යයෙන්, එය උදාහරණයේ විවිධ ගුණාංග වලට ප්‍රවේශ වේ.
උදාහරණයක් ලෙස, මෙය නූලක උදාහරණයකි:
', '
අපි, උදාහරණයක් ක්රමය භාවිතා කරන්නේ නම් joinතවත් iterable එක්වන මෙම නූලක් මත, එය ඉතා පැහැදිලිව ම උදාහරණයක් ශ්රිතයක් එම iterable ලැයිස්තුව ශ්රිතයක් වීමට අමතරව, ය ['a', 'b', 'c']:
>>> ', '.join(['a', 'b', 'c'])
'a, b, c'
මායිම් ක්රම
පසුකාලීන භාවිතය සඳහා තිත් බැලීමක් හරහා නිදසුන් ක්රම බැඳිය හැකිය.
උදාහරණයක් ලෙස, මෙය str.joinක්‍රමයට උදාහරණයකට බැඳ තබයි ':':
>>> join_with_colons = ':'.join
පසුව අපට මෙය පළමු තර්කය හා බැඳී ඇති ශ්රිතයක් ලෙස භාවිතා කළ හැකිය. මේ ආකාරයට, එය නිදසුනක් ලෙස අර්ධ ශ්රිතයක් ලෙස ක්‍රියා කරයි:
>>> join_with_colons('abcde')
'a:b:c:d:e'
>>> join_with_colons(['FF', 'FF', 'FF', 'FF', 'FF', 'FF'])
'FF:FF:FF:FF:FF:FF'
ස්ථිතික ක්රමය
ස්ථිතික ක්රමය වන්නේ නැහැ තර්කයක් ලෙස උදාහරණයක් ගන්න.
එය මොඩියුල මට්ටමේ ශ්‍රිතයකට බෙහෙවින් සමාන ය.
කෙසේ වෙතත්, මොඩියුල මට්ටමේ ශ්රිතයක් මොඩියුලයේ ජීවත් විය යුතු අතර එය භාවිතා කරන වෙනත් ස්ථානවලට විශේෂයෙන් ආනයනය කළ යුතුය.
කෙසේ වෙතත්, එය වස්තුවට අනුයුක්ත කර ඇත්නම්, එය ආනයනය හා උරුමය තුළින් පහසුවෙන් වස්තුව අනුගමනය කරනු ඇත.
ස්ථිතික ක්‍රමයකට උදාහරණයක් පයිතන් 3 හි මොඩියුලයෙන් str.maketransගෙන යනු ලැබේ string. එය පරිභෝජනයට සුදුසු පරිවර්තන වගුවක් කරයි str.translate. පහත දැක්වෙන පරිදි, නූලක උදාහරණයකින් භාවිතා කරන විට එය මෝඩකමක් සේ පෙනේ, නමුත් stringමොඩියුලයෙන් ශ්‍රිතය ආනයනය කිරීම තරමක් අවුල් සහගත වන අතර පන්තියේ සිට එය ඇමතීමට හැකිවීම සතුටක්.str.maketrans
# demonstrate same function whether called from instance or not:
>>> ', '.maketrans('ABC', 'abc')
{65: 97, 66: 98, 67: 99}
>>> str.maketrans('ABC', 'abc')
{65: 97, 66: 98, 67: 99}
පයිතන් 2 හි, වැඩි වැඩියෙන් ප්‍රයෝජනවත් නොවන නූල් මොඩියුලයෙන් ඔබට මෙම ශ්‍රිතය ආනයනය කළ යුතුය:
>>> import string
>>> 'ABCDEFG'.translate(string.maketrans('ABC', 'abc'))
'abcDEFG'
පන්ති ක්රමය
පංති ක්‍රමයක් යනු නිදර්ශන ක්‍රමයකට සමාන වන අතර එය ව්‍යංගයෙන් පළමු තර්කය ගනී, නමුත් උදාහරණය ගැනීම වෙනුවට එය පන්තිය ගනී. බොහෝ විට මේවා වඩා හොඳ අර්ථකථන භාවිතය සඳහා විකල්ප ඉදිකිරීම්කරුවන් ලෙස භාවිතා කරන අතර එය උරුමයට සහාය වනු ඇත.
බිල්ඩින් පංති ක්‍රමයක් සඳහා වඩාත්ම කැනොනිකල් උදාහරණය නම් dict.fromkeys. එය විකල්පයේ ඉදිකිරීම්කරුවෙකු ලෙස භාවිතා කරයි, (ඔබේ යතුරු මොනවාදැයි ඔබ දන්නා විට සහ ඒවා සඳහා පෙරනිමි අගයක් අවශ්‍ය විට එය හොඳින් ගැලපේ.)
>>> dict.fromkeys(['a', 'b', 'c'])
{'c': None, 'b': None, 'a': None}
අපි උප පංතියේ විධානය කරන විට, අපට උප කාණ්ඩයේ නිදසුනක් නිර්මාණය කරන එකම ඉදිකිරීම්කරු භාවිතා කළ හැකිය.
>>> class MyDict(dict): 'A dict subclass, use to demo classmethods'
>>> md = MyDict.fromkeys(['a', 'b', 'c'])
>>> md
{'a': None, 'c': None, 'b': None}
>>> type(md)
<class '__main__.MyDict'>
බලන්න pandas මූල කේතය විකල්ප ඉදිකරන්නන් වෙනත් සමාන උදාහරණ සඳහා, සහ මත ද නිල Python ප්රලේඛනය බලන්න classmethodසහ staticmethod.