విషయ సూచిక[దాచు][చూపండి]
ఈ ఉపన్యాసంలో, పైథాన్లోని తరగతులు, కన్స్ట్రక్టర్లు మరియు వారసత్వం గురించి మనం నేర్చుకుంటాము.
విభిన్న రకాలను నిర్వచించాల్సిన పెద్ద ప్రోగ్రామ్లో ఈ భావనలు నిజంగా ముఖ్యమైనవి.
క్లాసులు
ప్రోగ్రామింగ్లో తరగతులు చాలా అవసరం మరియు అవి పైథాన్కి ప్రత్యేకమైనవి కావు. అనేక ఇతర ప్రోగ్రామింగ్ భాషలు తరగతుల భావనకు మద్దతు ఇవ్వండి. కొత్త డేటా రకాలను నిర్వచించడానికి మేము తరగతులను ఉపయోగిస్తాము.
ఇప్పటివరకు, మేము పైథాన్లోని సంఖ్యలు, స్ట్రింగ్లు మరియు బూలియన్ల వంటి ప్రాథమిక డేటా రకాల గురించి తెలుసుకున్నాము. ఇవి పైథాన్లోని ప్రాథమిక లేదా సాధారణ డేటా రకాలు. మేము జాబితాలు మరియు నిఘంటువుల వంటి సంక్లిష్ట డేటా రకాలను కూడా చూశాము.
ఈ రకాలు చాలా ఉపయోగకరంగా ఉన్నప్పటికీ, సంక్లిష్ట భావనలను రూపొందించడానికి వాటిని ఎల్లప్పుడూ ఉపయోగించలేరు. ఉదాహరణకు, ఒక పాయింట్ లేదా షాపింగ్ కార్ట్ ఆలోచన గురించి ఆలోచించండి. షాపింగ్ కార్ట్ బూలియన్ లేదా జాబితా కాదు. ఇది వేరే రకమైన డేటా. కాబట్టి మేము నిజమైన భావనలను మోడల్ చేయడానికి కొత్త రకాలను నిర్వచించడానికి తరగతులను ఉపయోగించవచ్చు.
ఇప్పుడు, పాయింట్ అనే కొత్త డేటా రకాన్ని నిర్వచిద్దాం. ఈ కొత్త రకం మేము ముందు తనిఖీ చేసిన పద్ధతులను కలిగి ఉంటుంది.
మీరు దీన్ని ఎలా చేస్తారు:
మేము “తరగతి” కీవర్డ్ని ఉపయోగించడం ద్వారా తరగతిని నిర్వచించడం ద్వారా ప్రారంభిస్తాము మరియు ఆ తర్వాత మేము మా తరగతికి పేరు ఇస్తాము.
class Point
ఇప్పుడు, నేను ఇక్కడ ఉపయోగించిన పేరు పెట్టే విధానాన్ని చూడండి. నేను ఇక్కడ మొదటి అక్షరాన్ని క్యాపిటలైజ్ చేసాను, దీనినే మనం పాస్కల్ నేమింగ్ కన్వెన్షన్ అని పిలుస్తాము. ఈ కన్వెన్షన్ మన వేరియబుల్స్ మరియు ఫంక్షన్లకు పేరు పెట్టడానికి ఉపయోగించే దానికి భిన్నంగా ఉంటుంది, దీని కోసం మేము ఎల్లప్పుడూ చిన్న అక్షరాలను ఉపయోగిస్తాము మరియు అండర్ స్కోర్ ఉపయోగించి బహుళ పదాలను వేరు చేస్తాము. కానీ తరగతులకు పేరు పెట్టేటప్పుడు, మేము బహుళ పదాలను వేరు చేయడానికి అండర్స్కోర్ని ఉపయోగించము, ప్రతి పదంలోని మొదటి అక్షరాన్ని పెద్ద అక్షరం చేస్తాము.
మా తరగతిని నిర్వచించిన తర్వాత, కోలన్ ఉపయోగించబడుతుంది అంటే ఇప్పుడు ఒక బ్లాక్ నిర్వచించబడింది.
class Point:
def move (self):
ఈ బ్లాక్లో, మేము పాయింట్లకు చెందిన అన్ని విధులు లేదా పద్ధతులను నిర్వచించవచ్చు. ఉదాహరణకు, ఒక పాయింట్ను తరలించడానికి “తరలించు” అనే ఫంక్షన్ను మనం నిర్వచించవచ్చు. మేము ఓపెన్ కుండలీకరణాలను టైప్ చేసిన వెంటనే, PyCharm స్వయంచాలకంగా ఇక్కడ "సెల్ఫ్" జోడిస్తుంది. ఇది ఒక ప్రత్యేక కీవర్డ్ మరియు నేను త్వరలో దీనికి తిరిగి వస్తాను. టెర్మినల్లో “తరలించు” అని ప్రింట్ చేద్దాం.
print("move")
"డ్రా" వంటి మరొక పద్ధతిని నిర్వచించండి మరియు దానిని టెర్మినల్లో ముద్రించండి.
def draw(self):
print("draw")
మేము మా “పాయింట్” క్లాస్ నిర్వచనాన్ని పూర్తి చేసాము. ఈ కొత్త రకంతో, మనం కొత్త వస్తువులను సృష్టించవచ్చు. ఒక తరగతి బ్లూప్రింట్ లేదా వస్తువులను సృష్టించడానికి టెంప్లేట్ను నిర్వచిస్తుంది, అవి ఆ బ్లూప్రింట్ ఆధారంగా వాస్తవ సందర్భాలు. ఆబ్జెక్ట్ను సృష్టించడానికి, మేము మా తరగతి పేరును టైప్ చేసి, దానిని ఫంక్షన్ లాగా పిలుస్తాము. ఇది కొత్త వస్తువును సృష్టించి, ఆపై దాన్ని తిరిగి ఇస్తుంది. అప్పుడు మనం ఆ వస్తువును వేరియబుల్లో నిల్వ చేయవచ్చు. నన్ను చూపించనివ్వు:
ఇక్కడ మనం "పాయింట్1"ని నిర్వచించాము, ఇది త్రిమితీయ బిందువు. మీరు దానిని చూడవచ్చు, మేము టెర్మినల్లో వ్యక్తిగత కోఆర్డినేట్లను ముద్రించగలము.
మేము ఈ పాయింట్తో “డ్రా” మరియు “తరలించు” అనే రెండు పద్ధతులను ఉపయోగించవచ్చు.
కాబట్టి రీక్యాప్ చేయడానికి, మేము కొత్త రకాలను నిర్వచించడానికి తరగతులను ఉపయోగిస్తాము మరియు ఈ రకాలు క్లాస్ బాడీలో మనం నిర్వచించే పద్ధతులను కలిగి ఉంటాయి. తరగతులు మా ప్రోగ్రామ్లలో ఎక్కడైనా సెట్ చేయగల లక్షణాలను కలిగి ఉంటాయి.
కన్స్ట్రక్టర్లు
ఇప్పటివరకు, మేము తరగతులను ఉపయోగించి కొత్త రకాలను ఎలా సృష్టించాలో నేర్చుకున్నాము. ఇప్పుడు ఈ అమలులో చిన్న సమస్య ఉంది. మేము తరగతులను ఉపయోగించి x లేదా y కోఆర్డినేట్ లేకుండా పాయింట్ ఆబ్జెక్ట్ను సృష్టించవచ్చు మరియు అది సరైనది కాదు. నన్ను చూపించనివ్వు.
మనం x కోఆర్డినేట్ని సెట్ చేసే ముందు ఒక పాయింట్ని క్రియేట్ చేసి ప్రింట్ చేద్దాం. మా ప్రోగ్రామ్ని అమలు చేయడం వలన ఇలాంటి లక్షణం లోపం ఏర్పడుతుంది:
పాయింట్ ఆబ్జెక్ట్కు x అనే లక్షణం లేదని అర్థం. ఇప్పుడు సమస్య ఏమిటంటే x లేదా y కోఆర్డినేట్లు లేకుండా పాయింట్ ఆబ్జెక్ట్ను కలిగి ఉండటం సాధ్యమవుతుంది. మనం ఒక పాయింట్ గురించి మాట్లాడినప్పుడల్లా, ఆ పాయింట్ ఎక్కడ ఉందో తెలుసుకోవాలి కాబట్టి ఇది అర్ధవంతం కాదు. ఈ సమస్యను పరిష్కరించడానికి, మేము కన్స్ట్రక్టర్ని ఉపయోగిస్తాము. కన్స్ట్రక్టర్ అనేది ఒక వస్తువును సృష్టించే సమయంలో పిలువబడే ఒక ఫంక్షన్.
ఇక్కడ మనం కన్స్ట్రక్టర్ని ఎలా ఉపయోగిస్తాము. ముందుగా, పై ప్రోగ్రామ్లో x మరియు y కోఆర్డినేట్ల విలువలను పాస్ చేద్దాం.
point = Point(10, 20)
print(point.x)
ఇప్పుడు, మనం ఈ క్లాస్లో కన్స్ట్రక్టర్ అని పిలువబడే ప్రత్యేక పద్ధతిని జోడించాలి. దీని వాక్యనిర్మాణం ఇలా ఉంటుంది:
def __init__(self, x, y):
init
ప్రారంభించడం కోసం చిన్నది, మరియు ఇది కొత్త పాయింట్ ఆబ్జెక్ట్ సృష్టించబడినప్పుడు పిలువబడే ఫంక్షన్ లేదా పద్ధతి. x మరియు y లు వెంటనే జోడించబడతాయి self
రెండు అదనపు పారామితులను జోడించడానికి.
ఆ తర్వాత, మనం x మరియు y లను పాస్ చేసిన విలువలకు అంటే 10 మరియు 20కి మ్యాప్ చేయాలి
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 అనే సూత్రాన్ని కలిగి ఉన్నాము, ఇది మిమ్మల్ని మీరు పునరావృతం చేయవద్దు అనే దానికి సంక్షిప్తంగా ఉంటుంది. భవిష్యత్తులో ఎప్పుడైనా చెప్పుకుందాం, మేము మా “నడక” పద్ధతిలో సమస్యను కనుగొన్నాము మరియు మేము ఈ పద్ధతిని అనేక ఇతర ప్రదేశాలలో పునరావృతం చేసినట్లయితే లేదా నకిలీ చేసినట్లయితే, మేము తిరిగి వచ్చి, మేము దీన్ని నకిలీ చేసిన ప్రతి స్థలంలో ఆ సమస్యను పరిష్కరించాలి కోడ్. అందుకే ప్రోగ్రామింగ్లో మనం ఏదో ఒకటి రెండుసార్లు నిర్వచించకూడదు.
ఈ సమస్యను పరిష్కరించడానికి వివిధ విధానాలు ఉన్నాయి, కానీ ఇక్కడ మేము ప్రారంభకులకు సులభమైనది మరియు దానిని వారసత్వం అని నేర్చుకోబోతున్నాము. ఈ సందర్భంలో, మేము మరొక తరగతి "క్షీరదం"ని సృష్టిస్తాము మరియు ఆ తరగతిలో మా "నడక" లక్షణాన్ని నిర్వచించాము.
class Mammal:
def walk(self):
print("walk")
మా "క్షీరదం" తరగతిని నిర్వచించిన తర్వాత మేము ఈ క్రింది లక్షణాలను పాస్ చేయడానికి వారసత్వాన్ని ఉపయోగించవచ్చు:
కుక్క మరియు పిల్లి తరగతులు రెండూ వారి పేరెంట్ క్లాస్లో నిర్వచించిన అన్ని తరగతి పద్ధతులను వారసత్వంగా పొందుతున్నాయి. ఇప్పుడు, మేము ఇలాంటి కుక్కలకు ప్రత్యేకమైన పద్ధతులను జోడించవచ్చు:
class Dog:
def bark(self):
print("bark")
ముగించు!
ఇదంతా క్లాస్లు, కన్స్ట్రక్టర్లు మరియు వారసత్వ భావనలతో తరగతుల్లో కోడ్ని మళ్లీ ఉపయోగించడం. ఇప్పుడు మేము మా సిరీస్ ముగింపు దశకు చేరుకున్నాము. ఈ సమయానికి, మీరు పైథాన్లో మంచి, చదవగలిగే మరియు సంక్షిప్త కోడ్లను ఉత్పత్తి చేయగలరు.
మేము తదుపరి ఉపన్యాసంలో మాడ్యూల్స్ మరియు ప్యాకేజీల భావనను చూస్తాము.
సమాధానం ఇవ్వూ