ஃபார்-லூப் என்பது ஒரு கட்டுப்பாட்டு அமைப்பாகும், இது ஒரு குறிப்பிட்ட எண்ணிக்கையிலான முறை அறிவுறுத்தல்களின் தொகுப்பை மீண்டும் செய்ய உதவுகிறது. R இல் மறு செய்கை செய்வதற்கு இது பொதுவாகப் பயன்படுத்தப்படும் முறையாகும், குறிப்பாக சில உறுப்புகளில் நாம் அதே செயல்பாட்டைச் செய்ய வேண்டியிருக்கும் போது அல்லது DataFrame இல் உள்ள தரவுக் கட்டமைப்பில் மீண்டும் மீண்டும் செய்ய வேண்டும். வரிசைகள் மற்றும் நெடுவரிசைகள் R இல் உள்ள டேட்டாஃப்ரேம்களை உருவாக்குகின்றன, அங்கு ஒவ்வொரு வரிசையும் ஒரு ஒற்றை அவதானிப்பைக் குறிக்கிறது மற்றும் ஒவ்வொரு நெடுவரிசையும் அந்த அவதானிப்பின் மாறி அல்லது அம்சத்தைக் குறிக்கிறது.
இந்தக் குறிப்பிட்ட கட்டுரையில், DataFrame ஐ வெவ்வேறு அணுகுமுறைகளில் மீண்டும் செய்ய ஃபார்-லூப்பைப் பயன்படுத்துகிறோம். வரிசைகள் மற்றும் நெடுவரிசைகள் முழுவதும் ஃபார்-லூப் மறு செய்கை பெரிய டேட்டாஃப்ரேம்களுக்கு மிகவும் கணக்கிடக்கூடியதாக இருக்கும் என்பதை நினைவில் கொள்ளவும்.
எடுத்துக்காட்டு 1: R இல் டேட்டாஃப்ரேம் வரிசைகளில் ஃபார்-லூப் பயன்படுத்துதல்
R இல் உள்ள for-loop ஒரு DataFrame இன் வரிசைகளை மீண்டும் செய்ய பயன்படுத்தப்படலாம். for-loop இன் உள்ளே, DataFrame இன் ஒவ்வொரு வரிசையையும் அணுக வரிசை குறியீட்டைப் பயன்படுத்தலாம். பின்வரும் R குறியீட்டைக் கருத்தில் கொள்வோம், இது குறிப்பிட்ட DataFrame இன் வரிசைகளுக்கு மேல் திரும்ப-லூப்பின் விளக்கமாகும்.
தரவு = data.frame(c1 = c(1:5),
c2 = c(6:10),
c3 = c(11:15))
க்கு (நான் 1:nrow(தரவு)) {
வரிசை <- தரவு[i, ]
அச்சு (வரிசை)
}
இங்கே, நாம் முதலில் data.frame() செயல்பாட்டை 'தரவு' க்குள் வரையறுக்கிறோம். இங்கே data.frame() செயல்பாடு மூன்று நெடுவரிசைகளைக் கொண்டுள்ளது. ஒவ்வொரு நெடுவரிசையும் முறையே 1 முதல் 5, 6 முதல் 10 மற்றும் 11 முதல் 15 வரையிலான எண்களின் வரிசையுடன் அமைக்கப்பட்டுள்ளது. அதன் பிறகு, ஃபார்-லூப் செயல்பாடு பயன்படுத்தப்படுகிறது, இது டேட்டாஃப்ரேம் 'தரவு' வரிசைகளில் nrow() செயல்பாட்டைப் பயன்படுத்தி மொத்த வரிசைகளின் எண்ணிக்கையைப் பெறுகிறது. லூப் மாறி, 'i', 'தரவு' இல் உள்ள முழு வரிசைகளின் மதிப்புகளை எடுக்கும்.
பின்னர், '[ ]' என்ற சதுர அடைப்புக்குறி குறியீட்டைப் பயன்படுத்தி DataFrame 'தரவின்' i-வது வரிசையைப் பிரித்தெடுக்கிறோம். பிரித்தெடுக்கப்பட்ட வரிசை 'வரிசை' மாறியில் சேமிக்கப்படுகிறது, இது அச்சு() செயல்பாட்டின் மூலம் அச்சிடப்படும்.
எனவே, லூப் டேட்டாஃப்ரேமில் உள்ள அனைத்து வரிசைகளிலும் மீண்டும் இயங்குகிறது மற்றும் நெடுவரிசையின் மதிப்புகளுடன் வரிசை எண்களை வெளியீட்டில் காண்பிக்கும்.
எடுத்துக்காட்டு 2: ஃபார்-லூப் ஓவர் டேட்டாஃப்ரேம் நெடுவரிசைகளைப் பயன்படுத்துதல்
இதேபோல், குறிப்பிட்ட டேட்டாஃப்ரேமின் நெடுவரிசைகளை லூப் செய்ய R இல் உள்ள for-லூப்பைப் பயன்படுத்தலாம். நெடுவரிசைகளில் லூப் செய்ய முந்தைய குறியீட்டைப் பயன்படுத்தலாம், ஆனால் for-லூப்பில் ncol() செயல்பாட்டைப் பயன்படுத்த வேண்டும். மாறாக, ஃபார்-லூப்பைப் பயன்படுத்தி 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))
(கோல் பெயர்களில் (df))
நெடுவரிசை <- df[[col]]
அச்சு (நெடுவரிசை)
}
இங்கே, நாம் முதலில் df மாறியை உருவாக்குகிறோம், அங்கு data.frame() பத்திகள் செருகலுடன் பயன்படுத்தப்படுகிறது. 'df' DataFrame ஆனது எண் மதிப்புகளைக் கொண்ட மூன்று நெடுவரிசைகளைக் கொண்டுள்ளது. அடுத்து, colnames() செயல்பாட்டைப் பயன்படுத்தி “data” DataFrame இன் நெடுவரிசைப் பெயர்களை மீண்டும் செய்ய ஃபார்-லூப்பைப் பயன்படுத்துகிறோம். ஒவ்வொரு மறு செய்கையிலும், லூப் மாறி “கோல்” தற்போதைய நெடுவரிசையின் பெயரைப் பெறுகிறது. பிரித்தெடுக்கப்பட்ட நெடுவரிசை 'நெடுவரிசை' என்ற புதிய மாறியில் சேமிக்கப்படுகிறது.
இவ்வாறு, 'நெடுவரிசை' மாறியின் தரவு பின்வரும் கன்சோலில் வெளியீட்டை அச்சிடுகிறது:
எடுத்துக்காட்டு 3: முழு டேட்டாஃப்ரேமிலும் ஃபார்-லூப்பைப் பயன்படுத்துதல்
முந்தைய எடுத்துக்காட்டுகளில், முறையே for-loop ஐப் பயன்படுத்தி நெடுவரிசைகள் மற்றும் வரிசைகளின் மீது லூப் செய்தோம். இப்போது, ஒரு டேட்டாஃப்ரேமின் வரிசைகள் மற்றும் நெடுவரிசைகள் இரண்டிலும் ஒரே நேரத்தில் மீண்டும் செயல்பட, நெஸ்டெட் ஃபார் லூப்களைப் பயன்படுத்துகிறோம். R இன் குறியீடு பின்வருவனவற்றில் வழங்கப்படுகிறது, நெடுவரிசைகள் மற்றும் வரிசைகளில் உள்ளமைக்கப்பட்ட for-லூப் பயன்படுத்தப்படுகிறது:
ஊழியர்கள் <- data.frame(id=1:4,பெயர்கள்=c('கிம்', 'ஜான்', 'இயன்', 'மார்க்'),
இடம்=c('ஆஸ்திரேலியா', 'அமெரிக்கா', 'கனடா', 'ஜோர்டான்'),
சம்பளம்=c(2000, 1800, 1500, 1000))
க்கு (வரிசை 1:nrow(ஊழியர்கள்)) {
க்கான (col in 1:ncol(ஊழியர்கள்)) {
அச்சு(ஒட்டு('வரிசை அட்டவணை', வரிசை, 'நெடுவரிசை பெயர்', கோல், 'செல் மதிப்பு', பணியாளர்கள்[வரிசை, கோல்]))
}
}
நெடுவரிசைகளை அமைக்க data.frame() அழைக்கப்படும் 'பணியாளர்கள்' மாறியை இங்கு அறிவிக்கிறோம். ஒவ்வொரு நெடுவரிசையிலும் உள்ள மதிப்புகள் திசையன்களைப் பயன்படுத்தி குறிப்பிடப்படுகின்றன. பின்னர், 'பணியாளர்கள்' DataFrame இன் வரிசை மற்றும் நெடுவரிசையில், தரவை மீண்டும் மீண்டும் செய்ய இரண்டு உள்ளமைக்கப்பட்ட for-லூப்களைப் பயன்படுத்துகிறோம். வெளிப்புற வளையமானது '1:nrow(ஊழியர்கள்)' ஐப் பயன்படுத்தி குறிப்பிடப்பட்ட DataFrame வரிசைகளின் மீது மீண்டும் செயல்படுகிறது. ஒவ்வொரு வரிசைக்கும், DataFrame இன் நெடுவரிசைகளில் மீண்டும் மீண்டும் மீண்டும் செய்ய உள் சுழற்சியில் “1:ncol(ஊழியர்கள்)” பயன்படுத்தப்படுகிறது.
அதன் பிறகு, உள்ளமைக்கப்பட்ட சுழல்களுக்குள் ஒரு அச்சு() செயல்பாடு உள்ளது, இது வரிசை அட்டவணை, நெடுவரிசை அட்டவணை மற்றும் செல் மதிப்பை ஒரு சரமாக இணைக்க பேஸ்ட்() செயல்பாட்டைப் பயன்படுத்துகிறது. இங்குள்ள பணியாளர் [வரிசை, கோல்] வெளிப்பாடு தற்போதைய கலத்தின் மதிப்பைப் பெறுகிறது, அங்கு வரிசையும் நெடுவரிசையும் முறையே இருக்கும் வரிசை மற்றும் நெடுவரிசை குறியீடுகளாகும்.
இவ்வாறு, கன்சோலில் உள்ள வெளியீடு, இணைக்கப்பட்ட வரிசை அட்டவணை, நெடுவரிசைக் குறியீடு மற்றும் செல் மதிப்பு ஆகியவற்றுடன் ஒரு சரத்தில் மீட்டெடுக்கப்படுகிறது.
எடுத்துக்காட்டு 4: R இல் லூப் மாற்று முறை
ஃபார் லூப் இப்போது ஆர் மொழியில் காலாவதியானது. இருப்பினும், இது ஃபார்-லூப்பைப் போலவே செயல்படும் மற்றும் ஃபார்-லூப்களை விட வேகமான சில மாற்று முறைகளை வழங்குகிறது. டேட்டாஃப்ரேம்களில் மீண்டும் மீண்டும் செய்ய பின்னணியில் இயங்கும் 'குடும்பத்தைப் பயன்படுத்து' செயல்பாடுகளிலிருந்து இந்த முறை உள்ளது. DataFrame மீது லூப் செய்ய sapply() செயல்பாடு பயன்படுத்தப்படும் பின்வரும் R குறியீட்டைக் கருத்தில் கொள்வோம்.
dfX <- data.frame(var1=c(1:5),var2=c(6:10),
var3=c(11:15),
var4=c(16:20))
dfX
sapply (dfX, தொகை)
இங்கே, நாம் முதலில் 'dfX' DataFrame ஐ, data.frame() செயல்பாட்டை இரண்டு நெடுவரிசைகளுடன் அழைப்பதன் மூலம் நிறுவுகிறோம், ஒவ்வொன்றும் எண் மதிப்புகளைக் கொண்டுள்ளது. நாங்கள் அசல் “dfX” DataFrame ஐ கன்சோலில் அச்சிடுகிறோம். அடுத்த கட்டத்தில், வழங்கப்பட்ட DataFrame ஐ மீண்டும் செய்யவும் மற்றும் ஒவ்வொரு நெடுவரிசையின் கூட்டுத்தொகையைப் பெறவும் sapply() செயல்பாட்டைப் பயன்படுத்துகிறோம். sapply() செயல்பாடு பொதுவாக 'x' மற்றும் 'FUN' வாதங்களை எடுக்கும். இந்த வழக்கில், X என்பது “dfX” DataFrame ஆகும், மேலும் “FUN” என்பது DataFrame இன் நெடுவரிசைகள் ஒவ்வொன்றிற்கும் பயன்படுத்தப்படும் தொகை() செயல்பாடாகும்.
sapply() செயல்பாட்டின் மூலம் அடையப்படும் மறு செய்கையின் முடிவு பின்வரும் திரையில் அடையப்படுகிறது. DataFrame இன் கூட்டுச் செயல்பாட்டின் முடிவுகள் ஒவ்வொரு நெடுவரிசைக்கும் காட்டப்படும். மேலும், R இல் உள்ள ஃபார்-லூப் செயல்பாட்டிற்கு 'குடும்பத்தைப் பயன்படுத்து' இன் வேறு சில செயல்பாடுகளையும் பயன்படுத்தலாம்:
முடிவுரை
ஒரு குறிப்பிட்ட செயல்பாட்டைச் செய்ய DataFrame இன் வரிசைகள் அல்லது நெடுவரிசைகளில் மீண்டும் மீண்டும் செய்ய ஃபார்-லூப்களுடன் நாங்கள் வேலை செய்கிறோம். நெடுவரிசைகள் மற்றும் வரிசைகளில் மீண்டும் மீண்டும் செய்ய ஃபார்-லூப் தனித்தனியாக பயன்படுத்தப்படுகிறது. மேலும், டேட்டாஃப்ரேமின் நெடுவரிசைகள் மற்றும் வரிசைகள் இரண்டிலும் ஒரே நேரத்தில் மீண்டும் மீண்டும் செய்ய இதைப் பயன்படுத்துகிறோம். பெரும்பாலான நேரங்களில், விரும்பிய முடிவைப் பெற செயல்பாடுகளைப் பயன்படுத்துவது மிகவும் பயனுள்ளதாக இருக்கும். விண்ணப்பிக்கும் செயல்பாட்டின் உதாரணம் ஃபார்-லூப் செயல்பாட்டின் கடைசி எடுத்துக்காட்டில் கொடுக்கப்பட்டுள்ளது.