ఈ రోజు పరిశ్రమలో అందుబాటులో ఉన్న అత్యంత ప్రాచుర్యం పొందిన కోడింగ్ ప్లాట్‌ఫామ్‌లలో ఇది ఒకటి. Te త్సాహికుల నుండి నిపుణుల వరకు, ప్రతి ఒక్కరూ మొబైల్ మరియు వెబ్ కోసం కోడ్ చేయడానికి మరియు అనువర్తనాలు చేయడానికి పైథాన్‌ను ఉపయోగించారు. అటువంటి బహుముఖ వేదిక కావడంతో, వినియోగదారులలో అంతగా తెలియని కొన్ని అంశాలు ఉన్నాయి. వీటిలో ముఖ్యమైనది ఇనిట్ ఇన్ పైథాన్. ఈ భావన ఈ అంశాన్ని అన్వేషించడానికి మరియు పాయింటర్లను వివరంగా అనుసరించడానికి మీకు సహాయం చేస్తుంది,
కాబట్టి అప్పుడు ప్రారంభిద్దాం,
పైథాన్‌లో ప్రారంభించండి
ప్రారంభ ఫంక్షన్ పరిచయం
మీరు కొంతకాలంగా పైథాన్ ఉపయోగిస్తుంటే, పైథాన్ ఒక ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్ లాంగ్వేజ్ అనే విషయం మీకు బాగా తెలుసు. దీని ప్రాథమికంగా అర్థం ఏమిటంటే, పైథాన్ వాతావరణంలో మీరు సృష్టించిన ప్రతిదాన్ని వస్తువుగా పిలుస్తారు. ఇప్పుడు మేము పైథాన్‌లో __init__ ఫంక్షన్ గురించి మరింత అన్వేషించడానికి ముందు, ప్రాథమికాలను బయటకు తీద్దాం.
తరగతి
పైథాన్లోని ఒక తరగతి అనేది ఒకదానితో ఒకటి లేదా అంతకంటే ఎక్కువ సారూప్యతలను పంచుకునే ఒక సమూహం లేదా విభిన్న అంశాల సమితి, కానీ రకం, నాణ్యత మరియు రకం ద్వారా ఇతర తరగతుల నుండి భిన్నంగా ఉంటుంది. సాంకేతిక పరిభాషలో, పైథాన్ లోని ఒక తరగతిని ఒకే లేదా ఖచ్చితమైన ప్రవర్తన కలిగిన వ్యక్తిగత వస్తువులకు బ్లూప్రింట్ అని నిర్వచించవచ్చు.
వస్తువు
పైథాన్లోని ఒక వస్తువు ఒక తరగతి యొక్క ఒక ఉదాహరణ మరియు తరగతిలో నిర్వచించబడిన విధులను నిర్వహించడానికి దీనిని ప్రోగ్రామ్ చేయవచ్చు.
నేనే
పైథాన్లోని సెల్ఫ్ ఇన్ కీవర్డ్ ఒక తరగతిలోని అన్ని సందర్భాలకు ఉపయోగించబడుతుంది. స్వీయ కీవర్డ్‌ని ఉపయోగించడం ద్వారా, తరగతిలోని దాని పద్ధతులు మరియు లక్షణాలతో సహా నిర్వచించిన అన్ని సందర్భాలను సులభంగా యాక్సెస్ చేయవచ్చు.
అందులో
పైథాన్‌లో రిజర్వు చేయబడిన పద్ధతుల్లో __init__ ఒకటి. ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్‌లో, దీనిని కన్స్ట్రక్టర్ అంటారు. తరగతి నుండి ఒక వస్తువు సృష్టించబడినప్పుడు __init__ పద్ధతిని పిలుస్తారు మరియు తరగతి యొక్క లక్షణాలను ప్రారంభించడానికి యాక్సెస్ అవసరం.
ఇనిట్ ఇన్ పైథాన్ పై ఈ కథనంతో ముందుకు సాగుతోంది,
పైథాన్‌లో init వాడకం
పైన పంచుకున్న __init__ యొక్క నిర్వచనం నుండి, ఈ పద్ధతి సరిగ్గా ఏమి చేస్తుందనే దానిపై మీకు ఇప్పుడు కొంత ఆలోచన ఉంది. ఈ భావనను మరింత స్పష్టం చేయడానికి, ఒక ఉదాహరణను చూద్దాం.
# 1 ఉదాహరణ
లక్ష్యం: పైథాన్‌లో “NFS” పేరుతో రేసింగ్ గేమ్‌ను ప్రోగ్రామ్ చేయడానికి.
పరిష్కారం: మీరు పైథాన్‌లో “NFS” పేరుతో రేసింగ్ గేమ్‌ను సృష్టించాలనుకుంటే, మీరు సృష్టించాల్సిన ప్రాథమిక వస్తువులలో ఒకటి వ్యక్తిగత కార్లు. ఆటలో మీరు సృష్టించే ప్రతి కార్లన్నీ వేర్వేరు లక్షణాలను కలిగి ఉంటాయి, ఉదాహరణకు రంగు, వేగం మొదలైనవి అలాగే మార్పు గేర్, వేగవంతం, విచ్ఛిన్నం మొదలైన పద్ధతులు.
మీరు ఈ భావనను పైథాన్ ఇంటర్ప్రెటర్‌లోకి కోడ్ చేసినప్పుడు ఇది ఇలా ఉండాలి.
క్లాస్ కార్ (ఆబ్జెక్ట్): '' 'కారు కోసం బ్లూప్రింట్' '' డెఫ్ __ఇనిట్ __ (సెల్ఫ్, మోడల్, కలర్, కంపెనీ, స్పీడ్_లిమిట్): సెల్ఫ్.కలర్ = కలర్ సెల్ఫ్.కామ్పానీ = కంపెనీ సెల్ఫ్.స్పీడ్_లిమిట్ = స్పీడ్_లిమిట్ సెల్ఫ్ మోడల్ = మోడల్ డెఫ్ start (self): print ('start') def stop (self): print ('stop') def accelarate (self): print ('accelarating ...') 'accelarator functionality' def change_gear (self, గేర్_టైప్) : ప్రింట్ ('గేర్ మార్చబడింది') 'గేర్ సంబంధిత కార్యాచరణ ఇక్కడ' ఇప్పుడు మేము వస్తువులను సృష్టించాము, ఆటలో వ్యక్తిగత కార్లను సృష్టించడానికి ముందుకు వెళ్దాం. maruthi_suzuki = కారు ('ఎర్టిగా', 'బ్లాక్', 'సుజుకి', 60) ఆడి = కార్ ('A6', 'ఎరుపు', 'ఆడి', 80)పై ఉదాహరణలో, మేము రెండు వేర్వేరు కార్ మోడళ్లను సృష్టించాము, ఒకటి సుజుకి ఎర్టిగా మరియు రెండవ ఆడి A6. ఈ వస్తువులు విజయవంతంగా సృష్టించబడిన తర్వాత, ప్రారంభించడానికి __init__ పద్ధతిని ఉపయోగించుకోవచ్చు మరియు తదుపరి దశలకు సిద్ధం చేయవచ్చు.
ఈ ఉదాహరణలో, తరగతి యొక్క విభిన్న సందర్భాలను సూచించడానికి మేము స్వీయ పద్ధతిని కూడా ఉపయోగించుకోవచ్చు మరియు ఇచ్చిన వాదనలతో లక్షణాలను బంధించవచ్చు. స్వీయ పద్ధతిని ఉపయోగించడం వలన మేము తరగతిలో సృష్టించిన లక్షణాలను మరియు పద్ధతులను ప్రాథమికంగా యాక్సెస్ చేయడానికి అనుమతిస్తుంది.
స్టెప్ బై ఇన్ఫర్మేటికా నేర్చుకోవడం
ఇనిట్ ఇన్ పైథాన్ పై ఈ కథనంతో ముందుకు సాగుతోంది,
# 2 ఉదాహరణ
లక్ష్యం: కొలతలు, వెడల్పు (బి = 120), పొడవు (ఎల్ = 160) కలిగిన దీర్ఘచతురస్రాకార క్షేత్రం యొక్క అభివృద్ధి వ్యయాన్ని తెలుసుకోవడానికి. 1 చదరపు మీటర్ల ఖర్చు 2000 INR.
పరిష్కారం: మునుపటి ఉదాహరణలో పంచుకున్న దశలను దృష్టిలో ఉంచుకుని, ఈ ప్రత్యేక ఉదాహరణ కోసం కోడ్ క్రింది విధంగా కనిపిస్తుంది.
తరగతి దీర్ఘచతురస్రం: def __init __ (self, length, width, unit_cost = 0): self.length = length self.breadth = widthth self.unit_cost = unit_cost def get_perimeter (self): return 2 * (self.length + self.breadth) def get_area (self): return self.length * self.breadth def calclate_cost (self): area = self.get_area () రిటర్న్ ఏరియా * self.unit_cost # width = 120 cm, length = 160 cm, 1 cm ^ 2 = Rs 2000 r = దీర్ఘచతురస్రం (160, 120, 2000) ముద్రణ ('దీర్ఘచతురస్రం యొక్క ప్రాంతం:% s సెం.మీ ^ 2'% (r.get_area ())) ముద్రణ ('దీర్ఘచతురస్రాకార క్షేత్రం ఖర్చు: రూ.% S'% (r. లెక్కించు_కోస్ట్ ()))మునుపటి ఉదాహరణలో చర్చించినట్లుగా, స్వీయ పద్ధతి తరగతి యొక్క ఉదాహరణలు మరియు లక్షణాలను సూచిస్తుంది. మీరు నిశితంగా పరిశీలిస్తే, లక్షణం పొడవు యొక్క విలువను పొందటానికి మేము స్వీయ-పొడవు అనే పద్ధతులను ఉపయోగించామని మీరు గ్రహిస్తారు. లక్షణం పొడవు ఇప్పటికే తరగతిలోనే బంధించబడింది మరియు ఒకే తరగతిలో ఉన్న వస్తువును సూచించడానికి మేము స్వీయ పద్ధతిని ఉపయోగిస్తున్నాము.
పై కోడ్‌లోని పరామితిగా మేము డెఫ్ గెట్_రేయా (సెల్ఫ్) అనే పద్ధతిని కూడా ఉపయోగించాము. ఇది ఏమిటంటే, మేము పద్ధతిని పిలిచిన ప్రతిసారీ అది స్వయంచాలకంగా పద్ధతిలో ఇతర వాదనలతో పాటు మొదటి వాదనను దాటిపోతుంది. ఈ ఆటోమేషన్ మొదటి చూపులో చిన్నదిగా అనిపించినప్పటికీ, ఇది చాలా సమయాన్ని ఆదా చేస్తుంది మరియు దీర్ఘకాలంలో సామర్థ్యాన్ని పెంచుతుంది.
ఈ చర్చను మరింత స్పష్టం చేయడానికి, దిగువ ఉదాహరణను చూడండి.
r = దీర్ఘచతురస్రం (160, 120, 2000)
గమనిక: “r” అనేది తరగతి వెలుపల ఉన్న వస్తువు యొక్క ప్రాతినిధ్యం మరియు “స్వీయ” అనేది తరగతి లోపల ఉన్న వస్తువు యొక్క ప్రాతినిధ్యం.
ఇనిట్ ఇన్ పైథాన్ పై ఈ వ్యాసం చివరకి ఇది మనలను తీసుకువస్తుంది.
పైథాన్‌తో పాటు దాని వివిధ అనువర్తనాలతో లోతైన జ్ఞానం పొందడానికి, మీరు చేయవచ్చు 24/7 మద్దతు మరియు జీవితకాల ప్రాప్యతతో ప్రత్యక్ష ఆన్‌లైన్ శిక్షణ కోసం. మాకు ప్రశ్న ఉందా? “పైథాన్ ట్యుటోరియల్” యొక్క వ్యాఖ్యల విభాగంలో వాటిని పేర్కొనండి మరియు మేము మీ వద్దకు తిరిగి వస్తాము.