පටුන[සඟවන්න][පෙන්වන්න]
මෙම දේශනයේදී අපි python හි පන්ති, ඉදිකිරීම්කරුවන් සහ උරුමය පිළිබඳව ඉගෙන ගනිමු.
විවිධ වර්ගයන් අර්ථ දැක්වීමට අවශ්ය වන විශාල වැඩසටහනක දී මෙම සංකල්ප සැබවින්ම වැදගත් වේ.
පංතිවල
ක්රමලේඛනයේදී පන්ති අත්යවශ්ය වන අතර ඒවා python සඳහා විශේෂිත නොවේ. වෙනත් බොහෝ ක්රමලේඛන භාෂා පන්ති සංකල්පයට සහාය වීම. අපි නව දත්ත වර්ග නිර්වචනය කිරීමට පන්ති භාවිතා කරමු.
මේ වන විට අපි පයිතන් හි අංක, නූල් සහ බූලියන් වැනි මූලික දත්ත වර්ග ගැන ඉගෙන ගෙන ඇත්තෙමු. මේවා පයිතන් හි ඇති මූලික හෝ සරල දත්ත වර්ග වේ. ලැයිස්තු සහ ශබ්දකෝෂ වැනි සංකීර්ණ දත්ත වර්ග කිහිපයක් ද අපි දැක ඇත්තෙමු.
මෙම වර්ග අතිශයින්ම ප්රයෝජනවත් වන අතර, ඒවා සංකීර්ණ සංකල්ප ආදර්ශනය කිරීමට සෑම විටම භාවිතා කළ නොහැකිය. නිදසුනක් වශයෙන්, ලක්ෂ්යයක් හෝ සාප්පු කරත්තයක් පිළිබඳ අදහස ගැන සිතන්න. සාප්පු කරත්තයක් යනු බූලියන් හෝ ලැයිස්තුවක් නොවේ. එය වෙනස් ආකාරයක දත්තයකි. එබැවින් සැබෑ සංකල්ප ආදර්ශන කිරීමට නව වර්ග නිර්වචනය කිරීමට අපට පන්ති භාවිතා කළ හැකිය.
දැන්, අපි point ලෙස හඳුන්වන නව දත්ත වර්ගයක් නිර්වචනය කරමු. මේ අලුත් වර්ගයට අපි කලින් බලපු විදියට ක්රම තියෙනවා.
ඔබ එය කරන ආකාරය මෙයයි:
අපි "class" මූල පදය භාවිතා කර පන්තියක් නිර්වචනය කිරීමෙන් ආරම්භ කරන අතර ඉන් පසුව අපි අපගේ පන්තියට නමක් ලබා දෙමු.
class Point
දැන්, මම මෙහි භාවිතා කර ඇති නාමකරණ සම්මුතිය දෙස බලන්න. මම මෙහි පළමු අකුර කැපිටල් කර ඇත, මෙය අපි පැස්කල් නම් කිරීමේ සම්මුතියක් ලෙස හඳුන්වමු. මෙම සම්මුතිය අපගේ විචල්යයන් සහ ශ්රිත නම් කිරීම සඳහා අප භාවිතා කරන සම්මුතියට වඩා වෙනස් වන අතර ඒ සඳහා අපි සෑම විටම කුඩා අකුරු භාවිතා කරන අතර යටි ඉරි භාවිතයෙන් වචන කිහිපයක් වෙන් කරමු. නමුත් පන්ති නම් කිරීමේදී, අපි වචන කිහිපයක් වෙන් කිරීමට යටි ඉරි භාවිතා නොකර, සෑම වචනයකම පළමු අකුර අපි විශාල කරමු.
අපේ class එක define කලාට පස්සේ colon එකක් දානවා ඒ කියන්නේ දැන් block එකක් define කරලා.
class Point:
def move (self):
මෙම බ්ලොක් එකේදී, අපට ලක්ෂ්යවලට අයත් සියලුම කාර්යයන් හෝ ක්රම නිර්වචනය කළ හැකිය. උදාහරණයක් ලෙස, අපට ලක්ෂ්යයක් චලනය කිරීම සඳහා "චලනය" නම් ශ්රිතයක් අර්ථ දැක්විය හැක. අපි විවෘත වරහන් ටයිප් කළ වහාම PyCharm ස්වයංක්රීයව මෙහි "self" එකතු කරන බව සලකන්න. මෙය විශේෂ මූල පදයක් වන අතර මට ඉක්මනින් මෙය වෙත ආපසු යාමට ඉඩ දෙන්න. අපි ටර්මිනලයේ "චලනය" මුද්රණය කරමු.
print("move")
“Dra” වැනි වෙනත් ක්රමයක් නිර්වචනය කර එය ටර්මිනලයේ මුද්රණය කරමු.
def draw(self):
print("draw")
අපි අපගේ "ලක්ෂ්ය" පන්තියේ නිර්වචනය අවසන් කර ඇත. මෙම නව වර්ගය සමඟ, අපට නව වස්තූන් නිර්මාණය කළ හැකිය. පන්තියක් සරලව එම සැලැස්ම මත පදනම් වූ සත්ය අවස්ථාවන් වන වස්තු නිර්මාණය කිරීම සඳහා වන සැලැස්ම හෝ අච්චුව නිර්වචනය කරයි. වස්තුවක් නිර්මාණය කිරීම සඳහා, අපි අපගේ පන්තියේ නම ටයිප් කර එය ශ්රිතයක් ලෙස හඳුන්වමු. මෙය නව වස්තුවක් නිර්මාණය කර එය ආපසු ලබා දෙයි. එවිට අපට එම වස්තුව විචල්යයක ගබඩා කළ හැක. මම ඔබට පෙන්වන්නම්:
මෙහිදී අපි ත්රිමාණ ලක්ෂ්යයක් වන "ලක්ෂ්යය1" නිර්වචනය කර ඇත. ඔබට එය දැක ගත හැකිය, අපට ටර්මිනලයේ තනි ඛණ්ඩාංක මුද්රණය කළ හැකිය.
මෙම ලක්ෂ්යය සමඟ අපට "ඇඳීම" සහ "චලනය" යන ක්රම දෙක භාවිතා කළ හැකිය.
එබැවින් නැවත කියවීමට, අපි නව වර්ග නිර්වචනය කිරීමට පන්ති භාවිතා කරන අතර මෙම වර්ග වලට අපි පන්තියේ ශරීරය තුළ නිර්වචනය කරන ක්රම තිබිය හැක. අපගේ වැඩසටහන්වල ඕනෑම තැනක අපට සැකසිය හැකි ගුණාංග පන්තිවලට තිබිය හැක.
ඉදිකිරීම්කරුවන්
අපි මෙතෙක් ඉගෙන ගෙන ඇත්තේ පන්ති භාවිතා කර නව වර්ග නිර්මාණය කරන ආකාරයයි. දැන් මේක ක්රියාත්මක කිරීමේදී පොඩි ප්රශ්නයක් තියෙනවා. අපට පන්ති භාවිතයෙන් x හෝ y ඛණ්ඩාංකයක් නොමැතිව ලක්ෂ්ය වස්තුවක් නිර්මාණය කළ හැකි අතර එය සුදුසු නොවේ. මම ඔබට පෙන්වන්නම්.
අපි x ඛණ්ඩාංකය සැකසීමට පෙර ලක්ෂ්යයක් සාදා එය මුද්රණය කරමු. අපගේ වැඩසටහන ක්රියාත්මක කිරීමෙන් මෙවැනි ගුණාංග දෝෂයක් ඇති වේ:
ඒ කියන්නේ ලක්ෂ්ය වස්තුවට x කියලා ගුණාංගයක් නැහැ. දැන් ගැටලුව වන්නේ x හෝ y ඛණ්ඩාංක නොමැතිව ලක්ෂ්ය වස්තුවක් තිබිය හැකි වීමයි. අපි යම් කරුණක් ගැන කතා කරන විට, එම ලක්ෂ්යය පිහිටා ඇත්තේ කොතැනද යන්න දැන ගැනීමට අවශ්ය බැවින් මෙය තේරුමක් නැත. මෙම ගැටළුව විසඳීම සඳහා, අපි ඉදිකිරීම්කරුවෙකු භාවිතා කරමු. Constructor යනු වස්තුවක් නිර්මාණය කරන අවස්ථාවේ දී කැඳවනු ලබන ශ්රිතයකි.
මෙන්න අපි Constructor එකක් භාවිතා කරන ආකාරය. පළමුව, ඉහත වැඩසටහනේ x සහ y ඛණ්ඩාංක අගයන් සම්මත කරමු.
point = Point(10, 20)
print(point.x)
දැන් මේ class එකට constructor කියලා විශේෂ ක්රමයක් එකතු කරන්න ඕන. එහි වාක්ය ඛණ්ඩය මේ වගේ ය:
def __init__(self, x, y):
init
ආරම්භ කිරීම සඳහා කෙටි වන අතර, මෙය නව ලක්ෂ්ය වස්තුවක් සාදන විට කැඳවනු ලබන ශ්රිතය හෝ ක්රමය වේ. x සහ y පසුව එකතු වේ self
අමතර පරාමිතීන් දෙකක් එකතු කිරීමට.
ඊට පසු, අපි සම්මත කළ අගයන් එනම් 10 සහ 20 වෙත x සහ y සිතියම්ගත කළ යුතුය
self.x = x
self.y = y
අපි භාවිතා කරනවා self
වත්මන් වස්තුව වෙත යොමු කිරීමට සහ පසුව අපි "x" ශ්රිතයට ලබා දුන් x තර්කයට x ගුණාංගය සකසන්නෙමු. මේ ආකාරයෙන්, භාවිතා කිරීම init
ක්රමය, අපට අපගේ වස්තූන් ආරම්භ කළ හැක. මෙම ක්රමය ඉදිකිරීම්කරුවෙකු ලෙස හැඳින්වේ. අපි අපේ වැඩසටහන ක්රියාත්මක කරමු.
දැන්, අපට x සහ y ඛණ්ඩාංක පසුව වෙනස් කළ හැක. අපි x සම්බන්ධීකරණය යාවත්කාලීන කරමු:
point = Point(10, 20)
point.x = 11
print(point.x)
දැන්, x ඛණ්ඩාංකය 11 අගයට යාවත්කාලීන කර ඇත.
ව්යායාම
මෙන්න ඔබට රසවත් අභ්යාසයක්.
මට අවශ්ය ඔබ පුද්ගලයෙකු ලෙස හඳුන්වන නව වර්ගයක් නිර්වචනය කිරීමටයි. මෙම "පුද්ගල" වස්තූන්ට "" තිබිය යුතුයname
"ගුණාංගය මෙන්ම"talk()
”ක්රමය.
එය සරල කාර්යයක් වන අතර මිනිත්තු දෙකකට වඩා ගත නොවිය යුතුය.
විසඳුමක්
"පුද්ගලයා" පන්තිය නිර්වචනය කිරීමෙන් ආරම්භ කරන්න:
class Person:
self.name = name
අපි පසුව ඉදිකිරීම්කරු නිර්වචනය කරමු. දැන්, අපට "පුද්ගලයා" වස්තුව සෑදිය හැක. අපි ඒකට ජෝන් කියමු
john = Person("John Smith")
print(john.name)
john.talk()
දැන්, කේතයේ පළමු කොටස වෙත ගොස් ඉදිකිරීම්කරුවෙකු සාදන්න.
def __init__(self, name):
අවසාන කේතය මේ ආකාරයෙන් පෙනෙනු ඇත:
ඔබට පන්ති සහ ඉදිකිරීම්කරුවන් සමඟ ඒකාබද්ධව ආකෘතිගත නූල් සහ වෙනත් සංකල්ප භාවිතා කළ හැකිය.
උරුමය
උරුමය යනු ඔබට කේතයක් නැවත භාවිතා කිරීමට ඉඩ දෙන පන්ති හා සම්බන්ධ තවත් සංකල්පයකි.
මෙම කේත කොටස සලකා බලන්න.
class Dog:
def walk(self):
print("walk")
අපි "ඇවිදීම" ක්රමයක් සමඟ "බල්ලා" පන්තියක් නිර්මාණය කර ඇත. මෙම ක්රමයේදී, අපි හුදෙක් පර්යන්තයේ ඇවිදීමේ පණිවිඩය මුද්රණය කරමු. අපි හිතමු, නියම වැඩසටහනක මෙහි එක පේළියක් වෙනුවට කේත පේළි 10ක් තියෙනවා කියලා. අනාගතයේදී, "ඇවිදින" ක්රමය ඇති කිරීමට වෙනත් පන්තියක් අවශ්ය නම්, අපට එම සියලුම කේතය නැවත කිරීමට සිදුවනු ඇත. මෙය පරමාදර්ශී නොවේ.
ක්රමලේඛනයේදී, අපට DRY නම් ප්රතිපත්තියක් ඇත, එය නැවත නැවත නොකරන්න යන්නට කෙටි වේ. අනාගතයේදී අපි කියමු, අපි අපගේ “ඇවිදීම” ක්රමයේ ගැටලුවක් සොයා ගන්නා අතර, අපි මෙම ක්රමය වෙනත් බොහෝ ස්ථානවල නැවත නැවත හෝ අනුපිටපත් කර ඇත්නම්, අපට නැවත පැමිණ අප මෙය අනුපිටපත් කළ සෑම තැනකම එම ගැටලුව විසඳා ගත යුතුය. කේතය. ඉතින් ඒක නිසා programming වලදි අපි දෙයක් දෙපාරක් define කරන්න එපා.
මෙම ගැටළුව විසඳීම සඳහා විවිධ ප්රවේශයන් ඇත, නමුත් මෙහිදී අපි ඉගෙන ගැනීමට යන්නේ ආරම්භකයින් සඳහා පහසු වන අතර එය උරුමය ලෙස හැඳින්වේ. මෙම අවස්ථාවේදී, අපි තවත් පන්තියක් "ක්ෂීරපායී" නිර්මාණය කර එම පන්තියේ අපගේ "ඇවිදීම" ගුණාංගය නිර්වචනය කරමු.
class Mammal:
def walk(self):
print("walk")
අපගේ "ක්ෂීරපායින්" පන්තිය නිර්වචනය කිරීමෙන් පසු අපට මෙවැනි ගුණාංග සම්මත කිරීමට උරුමය භාවිතා කළ හැකිය:
බල්ලා සහ බළලුන් පන්ති දෙකම ඔවුන්ගේ මාපිය පන්තියේ නිර්වචනය කර ඇති සියලුම පන්ති ක්රම උරුම කරයි. දැන්, අපට මෙවැනි සුනඛයන් සඳහා විශේෂිත ක්රම එකතු කළ හැකිය:
class Dog:
def bark(self):
print("bark")
අවසන් කරන්න!
මේ සියල්ල පන්ති, නිර්මාපකයින් සහ උරුම සංකල්ප සහිත පන්තිවල කේතය නැවත භාවිතා කිරීම ගැන විය. දැන් අපි අපේ ලිපි මාලාවේ අවසානයට ළඟා වෙමින් සිටිමු. මෙම අවස්ථාව වන විට, ඔබට පයිතන් තුළ හොඳ, කියවිය හැකි සහ සංක්ෂිප්ත කේත නිපදවීමට හැකි විය යුතුය.
මොඩියුල සහ පැකේජ සංකල්පය මීළඟ දේශනයේදී බලමු.
ඔබමයි