మల్టీలైన్ వ్యాఖ్యలను ఎలా వ్రాయాలో మాకు ఇప్పటికే తెలుసు కాబట్టి, మేము ట్రిపుల్ సింగిల్ కోట్‌లను లేదా ట్రిపుల్ డబుల్ కోట్‌లను ఉపయోగించవచ్చు. మేము మా ఫంక్షన్‌లను వివరించాలనుకున్నప్పుడు డాక్యుమెంటేషన్ స్ట్రింగ్‌ని ఉపయోగిస్తాము, తద్వారా మనకు అవసరమైనప్పుడు డాక్యుమెంటేషన్ పొందవచ్చు. కొన్ని IDEలు పేరుపై హోవర్ చేయడం ద్వారా మీకు డాక్యుమెంటేషన్‌ను అందిస్తాయి మరియు కొన్ని నిర్దిష్ట కీలకపదాలను హైలైట్ చేస్తాయి. కానీ నిజానికి NumPyలోని డాక్‌స్ట్రింగ్‌లు ఇతర భాషల కంటే చాలా సరళంగా ఉంటాయి. డాక్‌స్ట్రింగ్ అనేది ఫంక్షన్ డెఫినిషన్ ప్రారంభంలో జరిగే స్ట్రింగ్ లిటరల్. ఫంక్షన్‌లు, తరగతులు మొదలైన సందర్భాల్లో డాక్‌స్ట్రింగ్‌లను ఉపయోగిస్తున్నప్పుడు మేము నిర్దిష్ట విలువలను అందించాలి.
ఫంక్షన్‌లతో డాక్‌స్ట్రింగ్‌లను ఉపయోగిస్తున్నప్పుడు, మేము ఆర్గ్యుమెంట్‌లను పాస్ చేయాలి. వాటిని తరగతులతో ఉపయోగిస్తున్నప్పుడు, మేము లక్షణాలను మరియు పద్ధతులను పాస్ చేస్తాము. మాడ్యూల్స్ విషయంలో, మేము తరగతులు మరియు ఫంక్షన్ల జాబితాను అందించాలి. ప్యాకేజీ విషయంలో, మేము కార్యాచరణతో మాడ్యూళ్ల జాబితాను పాస్ చేస్తాము. కాబట్టి ప్రాథమికంగా, డాక్‌స్ట్రింగ్ యొక్క ఉద్దేశ్యం, పేరు వివరించినట్లుగా, ఇది మా కోడ్ యొక్క డాక్యుమెంటేషన్‌తో సహాయపడుతుంది. మేము డాక్యుమెంటేషన్ చేస్తాము, తద్వారా భవిష్యత్తులో ఎవరైనా మన కోడ్‌ని ఉపయోగిస్తే, అతను డాక్‌స్ట్రింగ్ సహాయంతో మన కోడ్ మరియు మన కోడ్ వెనుక ఉన్న లాజిక్‌ను అర్థం చేసుకోగలుగుతాడు. అంతర్నిర్మిత విధులు డాక్‌స్ట్రింగ్‌లను కూడా కలిగి ఉంటాయి; అంతర్నిర్మిత ఫంక్షన్ల డాక్‌స్ట్రింగ్‌ని చూడటానికి మనం help() ఫంక్షన్‌ని ఉపయోగించవచ్చు.
వ్యాఖ్యలు మరియు డాక్‌స్ట్రింగ్‌ల మధ్య కొన్ని తేడాలు ఉన్నాయి. వ్యాఖ్యానాలు వ్యాఖ్యాతలచే విస్మరించబడతాయి కానీ వ్యాఖ్యాతలచే డాక్‌స్ట్రింగ్‌లు విస్మరించబడవు. డాక్‌స్ట్రింగ్‌ల కోసం మెమరీ కేటాయించబడింది. వ్యాఖ్య అనేది కోడ్ యొక్క వివరణ అయితే మరోవైపు, డాక్‌స్ట్రింగ్‌లు కోడ్ యొక్క ప్రయోజనాన్ని మాకు తెలియజేస్తాయి.
సింటాక్స్:
NumPyలో డాక్‌స్ట్రింగ్‌లను వ్రాయడానికి వాక్యనిర్మాణం:
'''డాక్‌స్ట్రింగ్ సందేశం'''
లేదా
'''డాక్‌స్ట్రింగ్ సందేశం'''
దయచేసి docstring ఒక ఫంక్షన్ లేదా పద్ధతి కాదని గమనించండి, కనుక దీనికి సరైన సింటాక్స్ లేదు. ఇక్కడ గమనించవలసిన ఏకైక విషయం ఏమిటంటే, మేము డాక్‌స్ట్రింగ్‌ను మూడు సింగిల్ కోట్‌లు లేదా మూడు డబుల్ కోట్‌లతో ప్రారంభిస్తాము. మేము కోడ్ యొక్క మా వివరణను వ్రాసి, చివరిలో మూడు సింగిల్ కోట్‌లు లేదా మూడు డబుల్ కోట్‌లతో దాన్ని మళ్లీ ముగించాము. డాక్‌స్ట్రింగ్‌ల కోసం వ్రాయడానికి తప్పనిసరి విషయం లేదు. మీరు మీ స్ట్రింగ్ వివరణకు ముందు మరియు తర్వాత మూడు సింగిల్ లేదా డబుల్ కోట్‌లను ఉంచాలి.
ఉదాహరణ 1:
డాక్‌స్ట్రింగ్‌లను మరింత మెరుగ్గా అర్థం చేసుకోవడానికి, ఒక ఉదాహరణ చూద్దాం. ఈ ఉదాహరణలో, NumPy లైబ్రరీని చేర్చిన తర్వాత, మేము కేవలం వేరియబుల్ “a” మరియు మరొక వేరియబుల్ “b”ని ప్రకటిస్తాము. ఆ తర్వాత, మేము 'a' మరియు 'b' వేరియబుల్స్‌ని యాడ్ చేద్దాం' అని చెప్పే మా డాక్‌స్ట్రింగ్‌ని సృష్టిస్తాము. మా విషయంలో, ఇది సులభమైన ఉదాహరణ, అయితే మా కోడ్ సంక్లిష్టంగా ఉంటే, కోడ్ను అర్థం చేసుకోవడంలో ఇది కోడర్‌కు చాలా సహాయపడుతుంది. ఆ తర్వాత, మేము వేరియబుల్స్ “a” మరియు “b”లను సంగ్రహించి, వాటి అవుట్‌పుట్ ఫలితాన్ని “c” అనే వేరియబుల్‌లో నిల్వ చేస్తాము. చివరగా, మేము వేరియబుల్ 'c' విలువను ముద్రిస్తాము. ఇప్పుడు, మేము మా కోడ్ను అమలు చేస్తాము.
దిగుమతి మొద్దుబారిన వంటి ఉదాa = 1
బి = రెండు
'''a మరియు b వేరియబుల్స్‌ని యాడ్ చేద్దాం'''
సి = a+b
ముద్రణ ( సి )
ఇచ్చిన కోడ్ ముక్క నుండి ఇది మా అవుట్‌పుట్. సిస్టమ్ తప్పు సింటాక్స్ గురించి లేదా మన కోడ్ యొక్క line7 కోసం ఏదైనా లోపం ఇవ్వలేదని మనం చూడవచ్చు. అలాగే, సిస్టమ్ మా డాక్‌స్ట్రింగ్‌ను ముద్రించలేదు. బదులుగా, ఇది మా వేరియబుల్ “c” యొక్క అవుట్‌పుట్‌ను మాత్రమే ముద్రిస్తుంది, దీనిలో మేము మా సిస్టమ్‌ను ప్రింట్ చేయమని చెప్పాము. ఇది డాక్‌స్ట్రింగ్‌లు ఎలా పని చేస్తుందో చూపిస్తుంది. తదుపరిసారి, కొత్త కోడర్ మా కోడ్‌పై పని చేయడానికి ప్రయత్నించినప్పుడు, అతను మా డాక్‌స్ట్రింగ్ సహాయంతో మనం ఏమి చేస్తున్నామో అర్థం చేసుకుంటాడు. కానీ అది అవుట్‌పుట్‌గా ముద్రించబడదు కాబట్టి కోడ్‌ని ఉపయోగించే వినియోగదారు దానితో కలవరపడరు.
ఉదాహరణ 2:
ఇప్పుడు, డాక్‌స్ట్రింగ్ పనిని అర్థం చేసుకోవడానికి మేము సంక్లిష్టమైన ఉదాహరణను ప్రదర్శిస్తాము. ముందుగా, మేము NumPy లైబ్రరీని చేర్చి, ఆపై ఒక డాక్ స్ట్రింగ్‌ను వ్రాస్తాము, దీనిలో మేము శ్రేణి యొక్క ప్రారంభాన్ని వివరించే కోడ్ యొక్క తదుపరి లైన్‌ను వివరిస్తాము. మేము కోడ్‌లోని ఇతర భాగంలో డాక్‌స్ట్రింగ్‌లను కూడా జోడిస్తాము. ఇప్పుడు, డాక్‌స్ట్రింగ్‌లను జోడించకుండా ఏదైనా కొత్త పైథాన్ డెవలపర్‌తో మనం ఈ కోడ్ను షేర్ చేస్తే, ఈ కోడ్ యొక్క పనిని మరియు ఉద్దేశ్యాన్ని తెలుసుకోవడం అతనికి కొంత కష్టమవుతుంది. మేము ఉపయోగించిన ఫంక్షన్ల గురించి అతను మొదట శోధించాలి. కానీ మేము మా కోడ్‌కి డాక్‌స్ట్రింగ్‌ని జోడిస్తే, ఇతర డెవలపర్‌లు ఫంక్షన్ల గురించి మరింత అధ్యయనం చేయకుండా కోడ్‌ని అర్థం చేసుకోవడం సులభం అవుతుంది. మేము కొన్ని పరిమితులకు వ్యాఖ్యలను జోడించడానికి పరిమితం కాదు; వ్యాఖ్యలు ఒకటి లేదా ఒకటి కంటే ఎక్కువ లైన్లలో ఉండవచ్చు. ఇది కోడ్‌లో ఒకటి కంటే ఎక్కువసార్లు కూడా జోడించబడుతుంది. తర్వాత, NumPyని npగా దిగుమతి చేయండి.
'''మేము 1x6 పరిమాణం గల శ్రేణిని పాస్ చేసే వేరియబుల్‌ను సృష్టించడం'''అమరిక = ఉదా అమరిక ( [ పదకొండు , 22 , 33 , 44 , 55 , 66 ] )
'''arr అనే ఫైల్‌లో సేవ్ చేయడానికి టోఫైల్() ఫంక్షన్‌కు శ్రేణిని కేటాయించడం'''
అమరిక . టోఫైల్ ( 'arr.bin' )
'''ffile ఫంక్షన్‌ని ఉపయోగించి ఫైల్‌ని ప్రదర్శించు'''
ముద్రణ ( ఉదా ఫైల్ నుండి ( 'arr.bin' , dtype = int ) )
కింది స్నిప్పెట్‌లో చూపినట్లుగా, అవుట్‌పుట్‌లో డాక్‌స్ట్రింగ్‌లు ప్రదర్శించబడవు అంటే ఇది కోడ్ యొక్క అవుట్‌పుట్ లేదా కంపైలేషన్‌పై ప్రభావం చూపదు. సంకలన ప్రక్రియలో డాక్‌స్ట్రింగ్‌లు విస్మరించబడతాయి.
ముగింపు
ఈ గైడ్‌లో, మేము NumPyలో డాక్‌స్ట్రింగ్‌ల గురించి తెలుసుకున్నాము. మేము డాక్‌స్ట్రింగ్‌లను వ్యాఖ్యలతో పోల్చాము మరియు వాటి మధ్య వ్యత్యాసాన్ని వివరించాము. మేము డాక్‌స్ట్రింగ్‌ల సింటాక్స్ మరియు మా కోడ్‌లో డాక్‌స్ట్రింగ్‌లను ఎలా వ్రాయాలో నేర్చుకున్నాము. ఇంకా, మేము NumPyలోని డాక్‌స్ట్రింగ్‌లు ఏమిటో మరియు అవి ఎలా పని చేస్తాయో ఉదాహరణల సహాయంతో వివరించడానికి కూడా ప్రయత్నించాము. చివరగా, కోడర్‌లకు అవి చాలా అవసరం అని మేము వ్యాఖ్యానించాము. మేము NumPyలో డాక్‌స్ట్రింగ్‌ల ప్రాముఖ్యతను పునరావృతం చేయము. మీరు మీ కోడ్‌లోని డాక్‌స్ట్రింగ్‌లను ఉపయోగించాలని మేము చెబుతాము. NumPyలో, డాక్‌స్ట్రింగ్‌ల రచనా శైలి అత్యంత ప్రజాదరణ పొందినది. ప్రోగ్రామింగ్ కమ్యూనిటీలో వారి కోడ్‌ల పని మరియు కార్యాచరణ గురించి ఒకరికొకరు తెలియజేయడానికి ఇది విస్తృతంగా ఉపయోగించబడుతుంది. NumPy డాక్‌స్ట్రింగ్‌లతో ప్రారంభించడానికి ఈ గైడ్ మీకు సహాయం చేస్తుంది. NumPyలోని డాక్‌స్ట్రింగ్‌లను ఉపయోగించి మీకు కావాల్సిన వాటిలో చాలా వరకు కవర్ చేయడానికి మేము ప్రయత్నించాము.