ఫర్-లూప్ అనేది నియంత్రణ నిర్మాణం, ఇది నిర్దేశించిన సంఖ్యలో సూచనల సమితిని పునరావృతం చేయడానికి మాకు వీలు కల్పిస్తుంది. R లో పునరావృతం చేయడానికి ఇది సాధారణంగా ఉపయోగించే పద్ధతి, ప్రత్యేకించి మనం కొన్ని మూలకాలపై అదే ఆపరేషన్‌ను నిర్వహించాల్సి వచ్చినప్పుడు లేదా డేటాఫ్రేమ్‌లో ఉన్న డేటా నిర్మాణంపై మళ్ళించాల్సిన అవసరం ఉన్నప్పుడు. అడ్డు వరుసలు మరియు నిలువు వరుసలు R లో డేటాఫ్రేమ్‌లను తయారు చేస్తాయి, ఇక్కడ ప్రతి అడ్డు వరుస ఒకే పరిశీలనను సూచిస్తుంది మరియు ప్రతి నిలువు వరుస ఆ పరిశీలన యొక్క వేరియబుల్ లేదా అంశాన్ని సూచిస్తుంది.
ఈ ప్రత్యేక కథనంతో, మేము వివిధ విధానాలలో డేటాఫ్రేమ్‌పై పునరావృతం చేయడానికి ఫర్-లూప్‌ని ఉపయోగిస్తాము. పెద్ద డేటాఫ్రేమ్‌ల కోసం అడ్డు వరుసలు మరియు నిలువు వరుసలలో ఫర్-లూప్ పునరావృతం చాలా గణనగా ఉంటుందని గుర్తుంచుకోండి.
ఉదాహరణ 1: R లో డేటాఫ్రేమ్ అడ్డు వరుసల కోసం లూప్‌ని ఉపయోగించడం
డేటాఫ్రేమ్ యొక్క వరుసలపై మళ్ళించడానికి R లోని ఫర్-లూప్ ఉపయోగించబడుతుంది. for-loop లోపల, మేము DataFrame యొక్క ప్రతి అడ్డు వరుసను యాక్సెస్ చేయడానికి అడ్డు వరుస సూచికను ఉపయోగించవచ్చు. పేర్కొన్న డేటాఫ్రేమ్ యొక్క అడ్డు వరుసలపై మళ్ళించడానికి ఫర్-లూప్ యొక్క ప్రదర్శన అయిన క్రింది R కోడ్‌ని పరిశీలిద్దాం.
డేటా = డేటా.ఫ్రేమ్(c1 = c(1:5),
c2 = c(6:10),
c3 = c(11:15))
కోసం (i in 1:nrow(data)) {
అడ్డు వరుస <- డేటా[i, ]
ప్రింట్ (వరుస)
}
ఇక్కడ, మేము మొదట 'డేటా' లోపల data.frame() ఫంక్షన్‌ని నిర్వచించాము. ఇక్కడ data.frame() ఫంక్షన్ మూడు నిలువు వరుసలను కలిగి ఉంది. ప్రతి నిలువు వరుస వరుసగా 1 నుండి 5, 6 నుండి 10 మరియు 11 నుండి 15 వరకు సంఖ్యల శ్రేణితో సెట్ చేయబడింది. ఆ తర్వాత, మొత్తం అడ్డు వరుసల సంఖ్యను పొందడానికి nrow() ఫంక్షన్‌ని ఉపయోగించి డేటాఫ్రేమ్ “డేటా” వరుసలపై మళ్ళించే for-loop ఫంక్షన్ అమలు చేయబడుతుంది. లూప్ వేరియబుల్, “i”, “డేటా”లోని మొత్తం వరుసల సంఖ్యకు విలువలను తీసుకుంటుంది.
అప్పుడు, మేము స్క్వేర్ బ్రాకెట్స్ సంజ్ఞామానం “[ ]”ని ఉపయోగించి డేటాఫ్రేమ్ “డేటా” యొక్క i-వ వరుసను సంగ్రహిస్తాము. సంగ్రహించిన అడ్డు వరుస 'వరుస' వేరియబుల్‌లో నిల్వ చేయబడుతుంది, ఇది ప్రింట్() ఫంక్షన్ ద్వారా ముద్రించబడుతుంది.
అందువల్ల, డేటాఫ్రేమ్‌లోని అన్ని అడ్డు వరుసలపై లూప్ పునరావృతమవుతుంది మరియు నిలువు వరుస విలువలతో పాటు అవుట్‌పుట్‌లోని అడ్డు వరుస సంఖ్యలను ప్రదర్శిస్తుంది.
ఉదాహరణ 2: డేటాఫ్రేమ్ నిలువు వరుసల కోసం లూప్‌ని ఉపయోగించడం
అదేవిధంగా, మేము పేర్కొన్న డేటాఫ్రేమ్ యొక్క నిలువు వరుసలపై లూప్ చేయడానికి R లో for-loopని ఉపయోగించవచ్చు. నిలువు వరుసలపై లూప్ చేయడానికి మనం మునుపటి కోడ్‌ని ఉపయోగించవచ్చు కానీ మనం తప్పనిసరిగా for-loopలో ncol() ఫంక్షన్‌ని ఉపయోగించాలి. దీనికి విరుద్ధంగా, for-loopని ఉపయోగించి DataFrame యొక్క నిలువు వరుసలపై లూప్ చేయడానికి మేము సరళమైన విధానాన్ని కలిగి ఉన్నాము. దీని కోసం క్రింది R కోడ్‌ను పరిగణించండి:
df = data.frame(col1 = c(10, 20, 30, 40, 50),col2 = c(11, 21, 31, 41, 51),
col3 = c(12, 22, 32, 42, 52))
కోసం (colnames (df)) {
నిలువు వరుస <- df[[col]]
ప్రింట్ (కాలమ్)
}
ఇక్కడ, మేము మొదట df వేరియబుల్‌ని సృష్టిస్తాము, ఇక్కడ data.frame() నిలువు వరుసల చొప్పించడంతో పని చేస్తుంది. 'df' డేటాఫ్రేమ్ సంఖ్యా విలువలను కలిగి ఉన్న మూడు నిలువు వరుసలను కలిగి ఉంది. తరువాత, మేము colnames() ఫంక్షన్‌ని ఉపయోగించి “డేటా” డేటాఫ్రేమ్ యొక్క నిలువు వరుస పేర్లపై మళ్ళించడానికి for-loopని ఉపయోగిస్తాము. ప్రతి పునరావృతంలో, లూప్ వేరియబుల్ “col” ప్రస్తుత కాలమ్ పేరును తీసుకుంటుంది. సంగ్రహించిన నిలువు వరుస కొత్త వేరియబుల్‌లో నిల్వ చేయబడుతుంది, అది “నిలువు”.
అందువలన, 'కాలమ్' వేరియబుల్ యొక్క డేటా క్రింది కన్సోల్‌లో అవుట్‌పుట్‌ను ప్రింట్ చేస్తుంది:
ఉదాహరణ 3: మొత్తం డేటాఫ్రేమ్‌లో ఫర్-లూప్‌ని ఉపయోగించడం
మునుపటి ఉదాహరణలలో, మేము వరుసగా for-loopని ఉపయోగించి నిలువు వరుసలు మరియు అడ్డు వరుసలపై లూప్ చేసాము. ఇప్పుడు, డేటాఫ్రేమ్‌లోని అడ్డు వరుసలు మరియు నిలువు వరుసలు రెండింటిపై ఏకకాలంలో పునరావృతం చేయడానికి మేము లూప్‌ల కోసం నెస్టెడ్‌ని ఉపయోగిస్తాము. R కోడ్ క్రింది వాటిలో అందించబడుతుంది, ఇక్కడ నిలువు వరుసలు మరియు అడ్డు వరుసలపై సమూహ లూప్ ఉపయోగించబడుతుంది:
ఉద్యోగులు <- data.frame(id=1:4,పేర్లు=c('కిమ్', 'జాన్', 'ఇయాన్', 'మార్క్'),
స్థానం=c('ఆస్ట్రేలియా', 'అమెరికా', 'కెనడా', 'జోర్డాన్'),
జీతం=c(2000, 1800, 1500, 1000))
కోసం (వరుస 1:nrow(ఉద్యోగులు)) {
కోసం (col in 1:ncol(ఉద్యోగులు)) {
ప్రింట్ (అతికించు('వరుస సూచిక', అడ్డు వరుస, 'కాలమ్ పేరు', col, 'సెల్ విలువ', ఉద్యోగులు[వరుస, col]))
}
}
ఇక్కడ, నిలువు వరుసలను సెట్ చేయడానికి data.frame()ని పిలిచే “ఉద్యోగులు” వేరియబుల్‌ని మేము ప్రకటిస్తాము. ప్రతి నిలువు వరుసలోని విలువలు వెక్టర్లను ఉపయోగించి పేర్కొనబడతాయి. ఆపై, “ఉద్యోగుల” డేటాఫ్రేమ్ యొక్క అడ్డు వరుస మరియు నిలువు వరుస కోసం, మేము డేటాపై మళ్లించడానికి రెండు సమూహ లూప్‌లను ఉపయోగిస్తాము. బయటి లూప్ '1:nrow(ఉద్యోగులు)'ని ఉపయోగించి పేర్కొన్న డేటాఫ్రేమ్ యొక్క అడ్డు వరుసలపై మళ్ళిస్తుంది. ప్రతి అడ్డు వరుస కోసం, డేటాఫ్రేమ్ యొక్క నిలువు వరుసలపై పదేపదే పునరావృతం చేయడానికి లోపలి లూప్‌లో “1:ncol(ఉద్యోగులు)” ఉపయోగించబడుతుంది.
ఆ తర్వాత, వరుస సూచిక, కాలమ్ ఇండెక్స్ మరియు సెల్ విలువను ఒకే స్ట్రింగ్‌గా కలపడానికి పేస్ట్() ఫంక్షన్‌ని అమలు చేసే నెస్టెడ్ లూప్‌ల లోపల మనకు ప్రింట్() ఫంక్షన్ ఉంటుంది. ఇక్కడ ఉద్యోగి [రో, కోల్] వ్యక్తీకరణ ప్రస్తుత సెల్‌లో విలువను పొందుతుంది, ఇక్కడ అడ్డు వరుస మరియు నిలువు వరుసలు వరుసగా ఉన్న అడ్డు వరుస మరియు నిలువు వరుస సూచికలు.
ఈ విధంగా, కన్సోల్‌లోని అవుట్‌పుట్ ఒకే స్ట్రింగ్‌లోకి సంగ్రహించబడిన అడ్డు వరుస సూచిక, నిలువు సూచిక మరియు సెల్ విలువతో తిరిగి పొందబడుతుంది.
ఉదాహరణ 4: ఫర్-లూప్ ఆల్టర్నేటివ్ మెథడ్‌లో R
ఫర్ లూప్ ఇప్పుడు R భాషలో పాతది. అయినప్పటికీ, ఇది కొన్ని ప్రత్యామ్నాయ పద్ధతులను అందిస్తుంది, ఇవి ఫర్-లూప్ వలె పని చేస్తాయి మరియు లూప్‌ల కంటే వేగంగా ఉంటాయి. డేటాఫ్రేమ్‌లలో పునరావృతం చేయడానికి బ్యాక్‌గ్రౌండ్‌లో లూప్ కోసం రన్ అయ్యే “ఫ్యామిలీని వర్తింపజేయి” ఫంక్షన్‌ల నుండి ఈ పద్ధతి రూపొందించబడింది. డేటాఫ్రేమ్‌పై లూప్ చేయడానికి sapply() ఫంక్షన్ ఉపయోగించబడే కింది R కోడ్‌ని పరిశీలిద్దాం.
dfX <- data.frame(var1=c(1:5),var2=c(6:10),
var3=c(11:15),
var4=c(16:20))
dfX
దరఖాస్తు (dfX, మొత్తం)
ఇక్కడ, మేము మొదట డేటా.ఫ్రేమ్() ఫంక్షన్‌ని రెండు నిలువు వరుసలతో కాల్ చేయడం ద్వారా “dfX” DataFrameని ఏర్పాటు చేస్తాము, ప్రతి ఒక్కటి సంఖ్యా విలువలను కలిగి ఉంటుంది. మేము అసలు “dfX” డేటాఫ్రేమ్‌ను కన్సోల్‌కు ప్రింట్ చేస్తాము. తదుపరి దశలో, అందించిన డేటాఫ్రేమ్‌పై మళ్లించడానికి మరియు ప్రతి నిలువు వరుస మొత్తాన్ని పొందడానికి మేము sapply() ఫంక్షన్‌ని ఉపయోగిస్తాము. sapply() ఫంక్షన్ సాధారణంగా “x” మరియు “FUN” ఆర్గ్యుమెంట్‌లను తీసుకుంటుంది. ఈ సందర్భంలో, X అనేది “dfX” డేటాఫ్రేమ్ మరియు “FUN” అనేది డేటాఫ్రేమ్ యొక్క ప్రతి నిలువు వరుసకు వర్తించే మొత్తం() ఫంక్షన్.
sapply() ఫంక్షన్ ద్వారా సాధించిన పునరావృత ఫలితం క్రింది స్క్రీన్‌లో సాధించబడుతుంది. DataFrame యొక్క సమ్ ఆపరేషన్ ఫలితాలు ప్రతి నిలువు వరుసకు చూపబడతాయి. అంతేకాకుండా, Rలో లూప్ ఆపరేషన్ కోసం మనం “అప్లై ఫ్యామిలీ” యొక్క కొన్ని ఇతర ఫంక్షన్లను కూడా ఉపయోగించవచ్చు:
ముగింపు
మేము నిర్దిష్ట ఆపరేషన్‌ని నిర్వహించడానికి DataFrame యొక్క అడ్డు వరుసలు లేదా నిలువు వరుసలపై మళ్ళించడానికి for-loopలతో పని చేస్తాము. నిలువు వరుసలు మరియు అడ్డు వరుసలపై మళ్ళించడానికి ఫర్-లూప్ వ్యక్తిగతంగా ఉపయోగించబడుతుంది. ఇంకా, డేటాఫ్రేమ్‌లోని నిలువు వరుసలు మరియు అడ్డు వరుసలు రెండింటిలో ఒకే సమయంలో పునరావృతం చేయడానికి మేము దీన్ని ఉపయోగిస్తాము. చాలా సమయం, ఆశించిన ఫలితాన్ని పొందడానికి ఫంక్షన్లను వర్తింపజేయడం మరింత ప్రభావవంతంగా ఉంటుంది. దరఖాస్తు ఫంక్షన్ యొక్క ఉదాహరణ ఫర్-లూప్ ఆపరేషన్‌లో చివరి ఉదాహరణలో ఇవ్వబడింది.