පයිතන් සහ උසස් ක්‍රම, වඩා හොඳ ක්‍රමලේඛනය සඳහා ඩන්ඩර් ක්‍රියා කරයි

Python යනු අතිවිශිෂ්ට ක්‍රමලේඛන භාෂාවක් වන අතර එයට සාක්ෂි දරයි GitHub, 2022 දී දෙවන වඩාත් ජනප්‍රිය භාෂාව ද වේ.

Python හි වඩාත් සිත්ගන්නාසුලු වාසි වන්නේ වැඩසටහන්කරුවන්ගේ විශාල ප්රජාවයි.

ඕනෑම භාවිතයක් සඳහා Python සතුව පැකේජයක් ඇති බව පෙනේ.

Python ක්‍රමලේඛනයේ විශාල ලෝකයේ, බොහෝ විට ආරම්භකයින් විසින් අවධානයට ලක් නොවන විශේෂාංග සමූහයක් ඇත, නමුත් භාෂාවේ පරිසර පද්ධතිය තුළ සැලකිය යුතු වැදගත්කමක් ඇත.

ඉන්ද්‍රජාලික ක්‍රම යනු පූර්ව ක්‍රම සමූහයකිdefiවිශේෂ වාක්‍ය ක්‍රියාකාරීත්වයක් සපයන පයිතන් හි nited. ආරම්භයේ සහ අවසානයේ ඇති ද්විත්ව ඉරි මගින් ඒවා පහසුවෙන් හඳුනාගත හැකිය __init__, __call__, __len__ … ආදිය

මැජික් ක්රම

මැජික් ක්‍රම මගින් අභිරුචි වස්තු වලට බිල්ට්-ඉන් පයිතන් වර්ග වලට සමානව හැසිරීමට ඉඩ සලසයි.

මෙම ලිපියෙන් අපි බලගතු ඩන්ඩර් කාර්යයන් කෙරෙහි අවධානය යොමු කරමු. අපි ඔවුන්ගේ අරමුණ ගවේෂණය කර ඒවායේ භාවිතය ගැන සාකච්ඡා කරන්නෙමු.

ඔබ Python ආධුනිකයෙක් හෝ පළපුරුදු ක්‍රමලේඛකයෙක් වුවද, මෙම ලිපියේ අරමුණ වන්නේ ඔබට Dunder ක්‍රියාකාරකම් පිළිබඳ සවිස්තරාත්මක අවබෝධයක් ලබා දීම, ඔබේ Python කේතීකරණ අත්දැකීම වඩාත් කාර්යක්‍ෂම සහ විනෝදජනක කරවීමයි.

මතක තබා ගන්න, Python හි මැජික් එහි සරල බව සහ බහුකාර්යතාව තුළ පමණක් නොව, Dunder ශ්රිතයන් වැනි එහි ප්රබල අංගයන් තුළද පවතී.

__init__

සමහර විට සියල්ලටම වඩා මූලික dunder කාර්යය. අපි නව වස්තුවක් නිර්මාණය කරන විට (හෝ නම යෝජනා කරන පරිදි, ආරම්භ කරන විට) පයිතන් ස්වයංක්‍රීයව හඳුන්වන මැජික් ක්‍රමය මෙයයි.__init__

පන්තියේ පීසා:
    def __init__(ස්වයං, ප්‍රමාණය, මුදුන්):
        self.size = විශාලත්වය
        ස්වයං.ටොපිංස් = ටොපිංස්

# දැන් අපි පීසා එකක් හදමු
my_pizza = පීසා ('විශාල', ['පෙපෙරෝනි', 'හතු'])

මුද්‍රණය (my_pizza.size) # මෙය මුද්‍රණය කරනු ඇත: විශාල
මුද්‍රණය (my_pizza.toppings) # මෙය මුද්‍රණය කරනු ඇත: ['pepperoni', 'hushrooms']

මෙම උදාහරණයේදී Pizza නමින් පන්තියක් නිර්මාණය වේ. අපි අපගේ __init__ ශ්‍රිතය සකසන්නේ ආරම්භක අවස්ථාවේ නියම කිරීමට පරාමිති ඇතුළත් කිරීමට සහ ඒවා අපගේ අභිරුචි වස්තුව සඳහා ගුණාංග ලෙස සකසන්න.

මෙහිදී, එය පන්තියේ උදාහරණය නියෝජනය කිරීමට භාවිතා කරයි. ඉතින් අපි self.size = size ලියන විට, අපි කියනවා, "Hey, මේ pizza object එකට attribute size එකක් තියෙනවා. size, සහ මම වස්තුව නිර්මාණය කරන විට එය මා ලබා දුන් ඕනෑම ප්‍රමාණයක වීමට මට අවශ්‍යය.

__str__ සහ __repr__

__Str__

මෙය අපට ඉඩ සලසන Python ගේ මැජික් ක්‍රමයයි defiඅපගේ අභිරුචි අයිතමය සඳහා විස්තරයක් ලබා දෙන්න.

ඔබ වස්තුවක් මුද්‍රණය කරන විට හෝ එය භාවිතා කරමින් තන්තුවකට පරිවර්තනය කරන විට str(), Python ඔබ සතුව තිබේදැයි පරීක්ෂා කරන්න defiක්රමයක් නිෂ්ප්රභ කළා __str__ එම වස්තුවේ පන්තිය සඳහා.

එසේ නම්, වස්තුව තන්තුවකට පරිවර්තනය කිරීමට එම ක්‍රමය භාවිතා කරන්න.

ශ්‍රිතයක් ඇතුළත් කිරීමට අපට අපගේ පීසා උදාහරණය දිගු කළ හැක __str__ පහත පරිදි:

පන්තියේ Pizza: def __init__(self, size, toppings): self.size = size self.toppings = toppings def __str__(self): ආපසු f"A {self.size} pizza with {', '.join(self.toppings) )}" my_pizza = Pizza('විශාල', ['pepperoni', 'hishrooms']) print(my_pizza) # මෙය මුද්‍රණය කරනු ඇත: පෙපෙරෝනි, හතු සහිත විශාල පීසා

__repr__

__str__ ශ්‍රිතය වස්තුවක ගුණ විස්තර කිරීමේ අවිධිමත් ක්‍රමයකි. අනෙක් අතට, අභිරුචි වස්තුව පිළිබඳ වඩාත් විධිමත්, සවිස්තරාත්මක සහ පැහැදිලි විස්තරයක් සැපයීමට __repr__ භාවිතා වේ.

ඔබ ඇමතුවොත් repr() වස්තුවක් මත හෝ ඔබ කොන්සෝලයට වස්තුවේ නම ටයිප් කරන්න, පයිතන් ක්‍රමයක් සොයනු ඇත __repr__.

Se __str__ එහෙම නෙවෙයි definite, Python භාවිතා කරනු ඇත __repr__ වස්තුව මුද්‍රණය කිරීමට හෝ තන්තුවකට පරිවර්තනය කිරීමට උත්සාහ කරන විට උපස්ථයක් ලෙස. එබැවින් එය බොහෝ විට හොඳ අදහසකි defiඅවම වශයෙන් අවසන් කරන්න __repr__, ඔබ එසේ නොකළත් defiනියමයි __str__.

මෙන්න අපට හැකි ආකාරය defiඅවසන් කරන්න __repr__ අපගේ පීසා උදාහරණය සඳහා:

පන්තියේ පීසා:
    def __init__(ස්වයං, ප්‍රමාණය, මුදුන්):
        self.size = විශාලත්වය
        ස්වයං.ටොපිංස් = ටොපිංස්

    def __repr__(ස්වයං):
        f"Pizza('{self.size}', {self.toppings})" ආපසු එවන්න

my_pizza = පීසා ('විශාල', ['පෙපෙරෝනි', 'හතු'])
මුද්‍රණය (repr(my_pizza)) # මෙය මුද්‍රණය කරනු ඇත: Pizza ('විශාල', ['pepperoni', 'hushrooms'])

__repr__ ඔබට පීසා වස්තුව ප්‍රතිනිර්මාණය කිරීම සඳහා පයිතන් විධානයක් ලෙස ක්‍රියාත්මක කළ හැකි තන්තුවක් ලබා දෙයි. __str__ ඔබට වඩාත් මානව විස්තරයක් ලබා දෙයි. මෙම dunder ක්‍රම ටිකක් හොඳින් හපන්නට එය ඔබට උපකාරී වනු ඇතැයි මම බලාපොරොත්තු වෙමි!

__එකතු කරන්න__

Python වලදී, operator භාවිතා කර අංක එකතු කළ හැකි බව අපි කවුරුත් දනිමු +වගේ 3 + 5.

නමුත් අපට යම් අභිරුචි වස්තුවක අවස්ථා එකතු කිරීමට අවශ්‍ය නම් කුමක් කළ යුතුද?

ඩන්ඩර් කාර්යය __add__ එය අපට එය කිරීමට ඉඩ සලසයි. එය අපට අවස්ථාව ලබා දෙයි defiක්රියාකරුගේ හැසිරීම පිරිපහදු කරන්න + අපගේ පුද්ගලාරෝපිත අයිතම මත.

අනුකූලතාව සඳහා, අපට අවශ්‍ය යැයි උපකල්පනය කරමු definite හැසිරීම + අපේ පීසා උදාහරණය මත. අපි කියමු අපි පීසා දෙකක් හෝ වැඩි ගණනක් එකට එකතු කරන විට, එය ස්වයංක්‍රීයව ඒවායේ සියලුම ටොපිංස් ඒකාබද්ධ කරයි. එය කෙබඳු විය හැකිද යන්න මෙන්න:

පන්තියේ පීසා:
    def __init__(ස්වයං, ප්‍රමාණය, මුදුන්):
        self.size = විශාලත්වය
        ස්වයං.ටොපිංස් = ටොපිංස්

    def __add__(ස්වයං, වෙනත්):
        එසේ නොවේ නම් (වෙනත්, පීසා):
            TypeError නැංවීම ("ඔබට එකතු කළ හැක්කේ තවත් Pizza පමණි!")
        new_toppings = self.toppings + other.toppings
        ආපසු Pizza (self.size, new_toppings)

# අපි පීසා දෙකක් නිර්මාණය කරමු
pizza1 = Pizza('විශාල', ['pepperoni', 'Hhuths'])
pizza2 = Pizza('විශාල', ['ඔලිව්', 'අන්නාසි'])

# දැන් අපි ඒවා "එකතු කරමු"
combined_pizza = pizza1 + pizza2

මුද්‍රණය (combined_pizza.toppings) # මෙය මුද්‍රණය කරනු ඇත: ['pepperoni', 'hushrooms', 'olives', 'pineapple']

ඩැන්ඩර් වලට සමානයි __add__, අපිටත් පුළුවන් definite වැනි අනෙකුත් අංක ගණිත ශ්‍රිත __sub__ (ක්‍රියාකරු භාවිතයෙන් අඩු කිරීමෙන් -) සහ __mul__ (ක්‍රියාකරු භාවිතයෙන් ගුණ කිරීම සඳහා *).

__len__

මෙම ඩන්ඩර් ක්රමය අපට ඉඩ සලසයි definish මොකක්ද කාර්යය len() අපගේ අභිරුචි කළ අයිතම සඳහා ආපසු යා යුතුය.

පයිතන් භාවිතා කරයි len() ලැයිස්තුවක් හෝ තන්තුවක් වැනි දත්ත ව්‍යුහයක දිග හෝ ප්‍රමාණය ලබා ගැනීමට.

අපගේ උදාහරණයේ සන්දර්භය තුළ, පීසා එකක "දිග" යනු එහි ඇති ටොපිං ගණන බව අපට පැවසිය හැකිය. අපට එය ක්‍රියාත්මක කළ හැකි ආකාරය මෙන්න:

පන්තියේ පීසා:
    def __init__(ස්වයං, ප්‍රමාණය, මුදුන්):
        self.size = විශාලත්වය
        ස්වයං.ටොපිංස් = ටොපිංස්

    def __len__(ස්වයං):
        ආපසු len (self.toppings)

# අපි පීසා එකක් හදමු
my_pizza = පීසා ('විශාල', ['පෙපෙරෝනි', 'හතු', 'ඔලිව්'])

print(len(my_pizza)) # මෙය මුද්‍රණය කරයි: 3

__len__ ක්‍රමයේදී, අපි ලැයිස්තුවේ දිග පමණක් ආපසු ලබා දෙමු toppings. දැන්, len(my_pizza) එහි ඇති ටොපිං කීයක් එය අපට කියනු ඇත my_pizza.

__ ක්රියාවලිය __

මෙම dunder ක්‍රමය මඟින් වස්තූන් පුනරාවර්තනය කිරීමට ඉඩ සලසයි, එනම් එය ලූපයක් තුළ භාවිතා කළ හැකිය.

මෙය සිදු කිරීම සඳහා, අප ද කළ යුතුය defiකාර්යය අවසන් කරන්න __next__, මෙය භාවිතා වේ defiපුනරාවර්තනයේ ඊළඟ අගය ලබා දිය යුතු හැසිරීම අවසන් කරන්න. තවද, එය අනුපිළිවෙලෙහි තවත් මූලද්‍රව්‍ය නොමැති බවට සිදුවීම මත පුනරාවර්තනයට සංඥා කළ යුතුය. අපි සාමාන්‍යයෙන් මෙය සාක්ෂාත් කර ගන්නේ ව්‍යතිරේකයක් මතු කිරීමෙනි StopIteration.

අපගේ පීසා උදාහරණය සඳහා, අපට ටොපිංස් නැවත කිරීමට අවශ්‍ය යැයි කියමු. අපට අපගේ පීසා පන්තිය නැවත නැවතත් කළ හැකි බවට පත් කළ හැකිය defiක්‍රමයක් දෙනවා __iter__:

පන්තියේ පීසා:
    def __init__(ස්වයං, ප්‍රමාණය, මුදුන්):
        self.size = විශාලත්වය
        ස්වයං.ටොපිංස් = ටොපිංස්

    def __iter__(ස්වයං):
        self.n = 0
        ස්වයං ආපසු

    def __next__(self):
        self.n < len(self.toppings):
            ප්‍රතිඵලය = self.toppings[self.n]
            self.n += 1
            ආපසු ප්රතිඵලය
        වෙනත්:
            StopIteration ඉහල දමන්න

# අපි පීසා එකක් හදමු
my_pizza = පීසා ('විශාල', ['පෙපෙරෝනි', 'හතු', 'ඔලිව්'])

# දැන් අපි එය නැවත කියමු
my_pizza හි ඉහළට ගැනීම සඳහා:
    මුද්‍රණය (ඉහළට)

මෙම අවස්ථාවේදී, for loop ඇමතුම් __iter__, කවුන්ටරයක් ​​ආරම්භ කරන (self.n) සහ පීසා වස්තුවම ආපසු ලබා දෙයි (self).

පසුව, for loop ඇමතුම් __next__ එක් එක් මුදුන් හැරීම ලබා ගැනීමට.

විට __next__ සියලු කුළුබඩු ආපසු, StopIteration එය ව්‍යතිරේකයක් විසි කරන අතර for loop දැන් ටොපිංස් නොමැති බව දන්නා අතර එම නිසා පුනරාවර්තන ක්‍රියාවලිය නවත්වනු ඇත.

Ercole Palmeri