పైథాన్ ఫైల్ రీడబుల్() పద్ధతి

సంబంధిత డేటాను ఉంచడానికి, ఫైల్‌లు ఉపయోగించబడతాయి, ఇవి డిస్క్‌లోని స్థానాలను లేబుల్ చేస్తాయి. అవి అస్థిరత లేని మెమరీలో శాశ్వత డేటా నిల్వ పరికరాలుగా పనిచేస్తాయి.

పైథాన్‌లోని “రీడబుల్()” ఫంక్షన్ ఇచ్చిన ఫైల్ చదవదగినదో కాదో నిర్ణయించడానికి ఉపయోగించబడుతుంది. పేర్కొన్న ఫైల్‌ని చదవగలిగితే అది నిజమని తిరిగి వస్తుంది; లేకపోతే, అది తప్పుగా తిరిగి వస్తుంది. ఫైల్‌ని రీడ్ “r” మోడ్‌లో మాత్రమే ఓపెన్ చేస్తే అది చదవబడుతుంది.

పైథాన్ ప్రోగ్రామ్‌లో ఈ పద్ధతిని ఉపయోగించడం కోసం సింటాక్స్ క్రింద ఇవ్వబడింది:

ఈ కథనంలో, మీరు స్పైడర్ టూల్‌లోని పైథాన్ ప్రోగ్రామ్‌ల ఆచరణాత్మక అమలుతో ఫైల్‌ను తెరవడం మరియు అది చదవగలిగేలా ఉందో లేదో ధృవీకరించడం గురించి నేర్చుకుంటారు.

ఉదాహరణ # 1: అందించిన ఫైల్ చదవగలదో లేదో తనిఖీ చేయడానికి చదవగలిగే() పద్ధతిని ఉపయోగించడం

మొదటి ఉదాహరణగా, మేము ఈ పద్ధతిని అమలు చేయడానికి ఒక సాధారణ పైథాన్ ప్రోగ్రామ్‌ను సృష్టిస్తాము.

టెక్స్ట్ ఫైల్‌ను చదవడానికి, ముందుగా మన ప్రోగ్రామ్ యొక్క ప్రస్తుత వర్కింగ్ డైరెక్టరీలో ఫైల్ ఉండాలి. పైథాన్‌లో ప్రస్తుత వర్కింగ్ డైరెక్టరీని కనుగొనడానికి, మేము క్రింది కోడ్ బ్లాక్‌ను అమలు చేయాలి:

ఇది మాకు ప్రస్తుత వర్కింగ్ డైరెక్టరీని పొందుతుంది. కింది చిత్రంలో, మనం ప్రస్తుతం ఈ డైరెక్టరీలో నడుస్తున్నట్లు చూడవచ్చు.

మనం తప్పనిసరిగా టెక్స్ట్ ఫైల్‌ని సృష్టించి, పైన పేర్కొన్న డైరెక్టరీలో సేవ్ చేయాలి.

టెక్స్ట్ ఫైల్‌ను రూపొందించడానికి, మేము 'నోట్‌ప్యాడ్'ని ప్రారంభించాము మరియు దానిలో 'ఇది డెమో ఫైల్' అని కొన్ని టెక్స్ట్ స్ట్రింగ్‌ను వ్రాసాము.

అప్పుడు మేము ఈ ఫైల్‌ను అదే డైరెక్టరీలో “sample.txt” శీర్షికతో సేవ్ చేసాము.

మీరు అదే డైరెక్టరీలో అవసరమైన ఫైల్‌ను ఉంచకపోతే, ప్రోగ్రామ్ 'FileNotFoundError'ని చూపుతుంది.

ఇప్పుడు మేము ఈ ప్రోగ్రామ్‌ను అమలు చేయడానికి అన్ని ముందస్తు అవసరాలను సెట్ చేసాము, ప్రధాన పైథాన్ కోడ్‌కి వెళ్దాం.

ప్రోగ్రామ్ యొక్క ప్రారంభ లైన్‌లో, మేము పైథాన్ “ఓపెన్()” పద్ధతిని పిలిచాము. ఈ పద్ధతి ఫైల్‌ను తెరుస్తుంది. దీనికి ఫైల్ పేరు మరియు ఫైల్‌ని రెండు ఇన్‌పుట్‌లుగా తెరవాల్సిన మోడ్ అవసరం. ఈ పద్ధతిలో ఈ రీతులు ఉన్నాయి; చదవడానికి “r”, వ్రాయడానికి “w” మరియు అనుబంధం కోసం “a”. ఇక్కడ, మేము ఫైల్ పేరుని “sample.txt”గా అందించాము, ఇది ఇప్పటికే మా ప్రస్తుత వర్కింగ్ డైరెక్టరీలో రీలొకేట్ చేయబడింది, ఆపై మేము రీడ్ మోడ్‌లో ఫైల్‌ను తెరవడాన్ని సూచించే మోడ్‌ను “r”గా పేర్కొన్నాము.

తిరిగి పొందిన అవుట్‌పుట్ ఫైల్‌ను నిల్వ చేయడానికి, మేము “డాక్” అనే ఫైల్ ఆబ్జెక్ట్‌ను సృష్టించాము. సంగ్రహించిన ఫైల్ రీడ్ మోడ్‌లో ఉంది మరియు 'డాక్' వేరియబుల్‌లో ఉంచబడుతుంది. ఈ ఫైల్ చదవగలిగేలా ఉందో లేదో తనిఖీ చేయడానికి, పైథాన్ మాకు అంతర్నిర్మిత “రీడబుల్()” పద్ధతిని అందిస్తుంది. సరఫరా చేయబడిన ఫైల్ చదవగలిగేలా ఉంటే, అది అవుట్‌పుట్ విండోలో స్ట్రింగ్ విలువ 'ట్రూ'ని ఉత్పత్తి చేస్తుంది; లేకపోతే, అది 'తప్పు' అని ముద్రిస్తుంది. 'doc.readable()' ఫంక్షన్ నుండి ఉత్పత్తి చేయబడిన టెర్మినల్‌లో ఫలితాన్ని 'చెకింగ్' అనే స్ట్రింగ్ స్టేట్‌మెంట్‌తో పాటుగా ప్రదర్శించడానికి 'print()' పద్ధతిలో ఫైల్ ఆబ్జెక్ట్ “doc”తో “రీడబుల్()” పద్ధతిని మేము ప్రారంభించాము. ఫైల్ చదవగలిగేలా ఉందా:”.

ఫైల్ రీడ్ మోడ్‌లో తెరవబడినందున, “రీడబుల్()” పద్ధతిని అమలు చేయడం వలన మనకు “TRUE” స్ట్రింగ్ విలువ వస్తుంది, అంటే ఫైల్ చదవగలిగేది.

ఫైల్‌ను “w” మరియు “a” మోడ్‌లలో తెరిచేటప్పుడు “రీడబుల్()” పద్ధతిని తనిఖీ చేద్దాం.

ఫైల్‌ని తెరవడానికి మోడ్ ఇక్కడ మార్చబడింది తప్ప, మేము గతంలో సృష్టించిన స్క్రిప్ట్‌ని ఉపయోగించాము. మేము మోడ్‌ను “w”గా పేర్కొన్నాము, అంటే ఫైల్‌ను “వ్రాయడం” మోడ్‌లో తెరవడం.

మేము దీన్ని అమలు చేసినప్పుడు, అది అవుట్‌పుట్ విండోలో “తప్పుడు” స్ట్రింగ్ విలువను ఉత్పత్తి చేస్తుంది, ఇది ఫైల్ చదవదగినది కాదని సూచిస్తుంది.

ఇప్పుడు, మేము దానిని 'a' మోడ్ కోసం తనిఖీ చేస్తాము.

అదే కోడ్ మళ్లీ ఉపయోగించబడుతుంది, కానీ ఈసారి ప్రారంభ మోడ్ మార్చబడింది. ఈసారి మేము మోడ్‌ను 'a' 'అనుబంధం'ని సూచిస్తున్నట్లు పేర్కొన్నాము. అప్పుడు 'రీడబుల్ ()' పద్ధతి కేవలం ఫైల్ ఆబ్జెక్ట్ 'డాక్'తో ప్రారంభించబడుతుంది. ఇప్పుడు, అవుట్‌పుట్‌ని చూడటానికి మేము ప్రోగ్రామ్‌ను అమలు చేస్తాము.

పొందిన ఫలితం ఫైల్ ఈ మోడ్‌లో చదవబడదని కూడా సూచిస్తుంది.

అందువలన, 'r' మోడ్‌లో తెరిచినప్పుడు మాత్రమే ఫైల్‌లు చదవగలవని మేము నిర్ధారించాము; అన్ని ఇతర మోడ్‌ల కోసం, ఇది చదవదగినది కాదు.

ఉదాహరణ # 3: ఫైల్ ఇన్‌పుట్‌ని పొందడం ద్వారా ఇది చదవదగినది కాదా అని ధృవీకరించడానికి if/else తో రీడబుల్() పద్ధతిని ఉపయోగించి

ఈ ప్రదర్శన కోసం, మేము ప్రోగ్రామ్ యొక్క ప్రస్తుత వర్కింగ్ డైరెక్టరీలో తప్పనిసరిగా ఉండే ఇన్‌పుట్ ఫైల్‌ని వినియోగదారు నుండి తీసుకుంటాము. ఇన్‌పుట్ ఫైల్ పేరును తీసుకున్న తర్వాత, ఫైల్ తెరవబడుతుంది మరియు ప్రోగ్రామ్ చదవగలదా అని తనిఖీ చేస్తుంది. మేము ఈ సాంకేతికత అమలు చేయబడిన ఉదాహరణ పైథాన్ ప్రోగ్రామ్‌ను సృష్టించాము. కోడ్ స్నిప్పెట్ యొక్క స్నాప్‌షాట్ క్రింద అందించబడింది:

పైథాన్ యొక్క “ప్రింట్()” పద్ధతిని ఉపయోగించడం ద్వారా టెర్మినల్‌లో “దయచేసి ఫైల్ పేరు రాయండి:” అనే స్టేట్‌మెంట్‌ను మొదట ప్రదర్శించడం ద్వారా ఈ ప్రోగ్రామ్ ప్రారంభమవుతుంది. వినియోగదారు నుండి ఇన్‌పుట్ తీసుకోవడానికి, పైథాన్ యొక్క అంతర్నిర్మిత పద్ధతి “ఇన్‌పుట్()” ప్రారంభించబడింది మరియు వేరియబుల్ “pro_file” “ఇన్‌పుట్()” ఫంక్షన్ నుండి ఉత్పత్తి చేయబడిన ఫలితాన్ని నిల్వ చేస్తుంది. '\nయూజర్ అందించిన ఫైల్ పేరు:' మరియు 'pro_file' వేరియబుల్‌లో నిల్వ చేయబడిన విలువ వలె స్ట్రింగ్ టెక్స్ట్‌ను ప్రదర్శించడానికి కోడ్ యొక్క క్రింది లైన్‌లో “print()” పద్ధతి ఉపయోగించబడింది. ఇక్కడ, “\n” తదుపరి పంక్తికి వెళ్లడాన్ని సూచిస్తుంది. కాబట్టి, ఈ ప్రకటన టెర్మినల్‌లో ఖాళీ లైన్‌ను దాటేసిన తర్వాత ముద్రించబడుతుంది.

కోడ్‌తో మరింత కొనసాగుతూ, వినియోగదారు పేర్కొన్న ఫైల్‌ను తెరవడానికి “ఓపెన్()” పద్ధతిని పిలుస్తారు. “open()” ఫంక్షన్ యొక్క కుండలీకరణాల మధ్య, మేము ఫైల్‌ను కలిగి ఉన్న వేరియబుల్‌ను అందించాము మరియు ఫైల్‌ను తెరవడానికి మోడ్ “r”గా పేర్కొనబడింది. కాబట్టి, ఫైల్ రీడ్ మోడ్‌లో తెరవబడుతుంది. తిరిగి పొందిన ఫైల్‌ను నిల్వ చేయడానికి ఫైల్ ఆబ్జెక్ట్ “డేటా” సృష్టించబడింది.

ఇప్పుడు ఫైల్ చదవగలిగేలా ఉందో లేదో తనిఖీ చేయడానికి, 'if-Statement' కోసం షరతుగా ఫైల్ ఆబ్జెక్ట్ 'డేటా'తో మేము 'రీడబుల్()' పద్ధతిని ఉపయోగించాము. కాబట్టి, ఫైల్ చదవగలిగేదిగా మారినట్లయితే, నియంత్రణ 'ప్రింట్()' ఫంక్షన్ '\nఅందించిన ఫైల్ చదవదగినది' అనే స్టేట్‌మెంట్‌ను కలిగి ఉన్న తదుపరి పంక్తికి తరలించబడుతుంది. మరియు దానిని టెర్మినల్‌లో ప్రదర్శించండి. ఫైల్ రీడబుల్ కాకపోతే, 'వేరే' భాగం అమలు చేయబడుతుంది. ఈ విభాగం “ప్రింట్()” ఫంక్షన్‌ను కూడా కలిగి ఉంది, ఇది “\nఅందించిన ఫైల్ చదవదగినది కాదు”గా ప్రదర్శించబడే టెక్స్ట్ స్ట్రింగ్‌ను కలిగి ఉంది.

ప్రోగ్రామ్ ఎగ్జిక్యూట్ అయినప్పుడు, ఫైల్ పేరును నమోదు చేయమని వినియోగదారుని అడుగుతున్న స్టేట్‌మెంట్ ప్రదర్శించబడుతుంది మరియు కర్సర్ తదుపరి లైన్‌కు వెళుతుంది, ఇక్కడ వినియోగదారు నిర్దిష్ట ఫైల్ పేరును “.txt” పొడిగింపుతో వ్రాయాలి.

ఈ స్నాప్‌షాట్‌లో, వినియోగదారు “sample.txt” అనే ఫైల్‌ను నమోదు చేసినట్లు మనం చూడవచ్చు. “Enter” కీ ఇన్ చేసిన తర్వాత, ప్రోగ్రామ్ అన్ని ఇతర కార్యకలాపాలను అమలు చేస్తుంది. ఇక్కడ, ఫైల్ పేరు వినియోగదారు ఇన్‌పుట్‌లో ప్రదర్శించబడుతుంది. ఆపై, “అందించిన ఫైల్ చదవదగినది” అని చెప్పే ప్రకటన ముద్రించబడుతుంది.

ముగింపు

పైథాన్ యొక్క అంతర్నిర్మిత పద్ధతి, “రీడబుల్(),” ఫైల్ చదవగలిగేలా ఉందో లేదో తనిఖీ చేయడానికి మమ్మల్ని అనుమతిస్తుంది. ఈ గైడ్ ఈ నిర్దిష్ట పద్ధతి యొక్క అమలును నేర్చుకోవడంలో పనిచేసింది. అమలు ప్రక్రియను అర్థం చేసుకోవడానికి మేము రెండు ఉదాహరణలను నిర్వహించాము. మొదటి ఉదాహరణ కోసం, ప్రోగ్రామ్ మొదట 'ఓపెన్()' పద్ధతిని ఉపయోగించి వేర్వేరు ప్రారంభ మోడ్‌లతో ఫైల్‌ను తెరిచింది మరియు ఫైల్ చదవగలదా లేదా అని తనిఖీ చేస్తుంది. రెండవ ఉదాహరణ ఫైల్ పేరును వినియోగదారు నుండి ఇన్‌పుట్‌గా తీసుకుంటుంది మరియు దానిని “r” మోడ్‌లో తెరిచిన తర్వాత, “రీడబుల్()” పద్ధతిని అమలు చేయడానికి if/else స్టేట్‌మెంట్ ఉపయోగించబడుతుంది. ఈ రెండు పద్ధతులు విధి అవసరాలను బట్టి పూర్తిగా ఆచరణాత్మకంగా అమలు చేయబడతాయి.