दिलचस्प पोस्ट
मोबाइल सफारी (आईफ़ोन) पर फ़ॉन्ट आकार का मुद्दा तय करें जहां टेक्स्ट असंगत रूप से प्रदान किया गया है और कुछ फोंट दूसरों की तुलना में बड़ा है? सी – "चार var " और "चार * var" के बीच का अंतर? स्किकिट में प्रीप्रोसिंग सीखना – एकल नमूना – मूल्यह्रास चेतावनी डीबीसीपी – विभिन्न डेटाबेस के लिए सत्यापन जीएसएन्स टाइप टूनेशन कैसे काम करता है? कौन प्राथमिकता, maxRequestLength या maxAllowedContentLength? रीजेक्स में रिकर्सिव पैटर्न एसवीजी गोल कोने एक चुनिंदा ड्रॉप डाउन से jQuery शो / छुपा विकल्प, जब अन्य चुनिंदा ड्रॉपडाउन पर विकल्प चुना जाता है एंड्रॉइड एप्लिकेशन में एक SQLite क्वेरी कैसे करें? Win32 के तहत भ्रष्टाचार भ्रष्टाचार; कैसे पता लगाने के लिए? IE11 में "ब्राउज़र मोड" को कैसे वापस लाया जाए? "Java.net.MalformedURLException: प्रोटोकॉल नहीं मिला" html फ़ाइल को पढ़ा जावास्क्रिप्ट में क्या मतलब है? आईओएस 8 टैब बार मद पृष्ठभूमि रंग

कैसे vlookup करने के लिए और आर में (जैसे Excel में) भरें?

मेरे पास एक डाटासेट है जिसके बारे में 105000 पंक्तियाँ और 30 कॉलम हैं I मेरे पास एक निश्चित वैरिएबल है जो मुझे इसे एक संख्या में असाइन करना है। Excel में, मैं शायद कुछ VLOOKUP और भरने के साथ कुछ करना होगा।

मैं R में एक ही काम करने के बारे में कैसे जाना होगा?

मूलतः, मेरे पास एक HouseType वैरिएबल है, और मुझे HouseTypeNo गणना करने की आवश्यकता है यहां कुछ नमूना डेटा दिए गए हैं:

 HouseType HouseTypeNo Semi 1 Single 2 Row 3 Single 2 Apartment 4 Apartment 4 Row 3 

Solutions Collecting From Web of "कैसे vlookup करने के लिए और आर में (जैसे Excel में) भरें?"

अगर मैं आपके प्रश्न को सही ढंग से समझता हूं, तो एक्सेल के VLOOKUP के समतुल्य करने के लिए चार तरीके हैं और R का उपयोग करके भरें:

 # load sample data from Q hous <- read.table(header = TRUE, stringsAsFactors = FALSE, text="HouseType HouseTypeNo Semi 1 Single 2 Row 3 Single 2 Apartment 4 Apartment 4 Row 3") # create a toy large table with a 'HouseType' column # but no 'HouseTypeNo' column (yet) largetable <- data.frame(HouseType = as.character(sample(unique(hous$HouseType), 1000, replace = TRUE)), stringsAsFactors = FALSE) # create a lookup table to get the numbers to fill # the large table lookup <- unique(hous) HouseType HouseTypeNo 1 Semi 1 2 Single 2 3 Row 3 5 Apartment 4 

lookup तालिका में मूल्यों का उपयोग करके HouseTypeNo में HouseTypeNo को भरने के लिए यहां चार तरीके हैं:

पहले आधार में merge साथ:

 # 1. using base base1 <- (merge(lookup, largetable, by = 'HouseType')) 

बेस में नामित वैक्टर के साथ एक दूसरी विधि:

 # 2. using base and a named vector housenames <- as.numeric(1:length(unique(hous$HouseType))) names(housenames) <- unique(hous$HouseType) base2 <- data.frame(HouseType = largetable$HouseType, HouseTypeNo = (housenames[largetable$HouseType])) 

तीसरा, plyr पैकेज का उपयोग कर:

 # 3. using the plyr package library(plyr) plyr1 <- join(largetable, lookup, by = "HouseType") 

चौथा, sqldf पैकेज का उपयोग कर

 # 4. using the sqldf package library(sqldf) sqldf1 <- sqldf("SELECT largetable.HouseType, lookup.HouseTypeNo FROM largetable INNER JOIN lookup ON largetable.HouseType = lookup.HouseType") 

यदि यह संभव है कि largetable में कुछ घर प्रकार मौजूद नहीं हैं तो एक बाएं जुड़ने का उपयोग किया जाएगा:

 sqldf("select * from largetable left join lookup using (HouseType)") 

अन्य समाधानों के अनुरूप बदलावों की भी आवश्यकता होगी।

क्या आप जो करना चाहते थे? मुझे बताएं कि आपको कौन सी विधि पसंद है और मैं कमेंटरी जोड़ूंगा

मुझे लगता है कि आप match() का भी उपयोग कर सकते हैं:

 largetable$HouseTypeNo <- with(lookup, HouseTypeNo[match(largetable$HouseType, HouseType)]) 

यह अभी भी काम करता है अगर मैं lookup के आदेश को lookup

मैं qdapTools::lookup या शॉर्टहैंड बायनरी ऑपरेटर %l% का उपयोग qdapTools::lookup पसंद करता हूं। यह एक एक्सेल vlookup के समान रूप से कार्य करता है, लेकिन यह स्तंभ संख्याओं के विरोध में नाम तर्क को स्वीकार करता है

 ## Replicate Ben's data: hous <- structure(list(HouseType = c("Semi", "Single", "Row", "Single", "Apartment", "Apartment", "Row"), HouseTypeNo = c(1L, 2L, 3L, 2L, 4L, 4L, 3L)), .Names = c("HouseType", "HouseTypeNo"), class = "data.frame", row.names = c(NA, -7L)) largetable <- data.frame(HouseType = as.character(sample(unique(hous$HouseType), 1000, replace = TRUE)), stringsAsFactors = FALSE) ## It's this simple: library(qdapTools) largetable[, 1] %l% hous 

@ बेन के उत्तर # 2 का समाधान अन्य सामान्य उदाहरणों में प्रतिलिपि प्रस्तुत करने योग्य नहीं है। यह उदाहरण में सही लुकअप देना होता है क्योंकि houses में अद्वितीय HouseType बढ़ती क्रम में दिखाई देते हैं। इसे इस्तेमाल करे:

 hous <- read.table(header = TRUE, stringsAsFactors = FALSE, text="HouseType HouseTypeNo Semi 1 ECIIsHome 17 Single 2 Row 3 Single 2 Apartment 4 Apartment 4 Row 3") largetable <- data.frame(HouseType = as.character(sample(unique(hous$HouseType), 1000, replace = TRUE)), stringsAsFactors = FALSE) lookup <- unique(hous) 

बेन्स समाधान # 2 देता है

 housenames <- as.numeric(1:length(unique(hous$HouseType))) names(housenames) <- unique(hous$HouseType) base2 <- data.frame(HouseType = largetable$HouseType, HouseTypeNo = (housenames[largetable$HouseType])) 

जो जब

 unique(base2$HouseTypeNo[ base2$HouseType=="ECIIsHome" ]) [1] 2 

जब लुकअप तालिका से सही उत्तर 17 है

ऐसा करने का सही तरीका है

  hous <- read.table(header = TRUE, stringsAsFactors = FALSE, text="HouseType HouseTypeNo Semi 1 ECIIsHome 17 Single 2 Row 3 Single 2 Apartment 4 Apartment 4 Row 3") largetable <- data.frame(HouseType = as.character(sample(unique(hous$HouseType), 1000, replace = TRUE)), stringsAsFactors = FALSE) housenames <- tapply(hous$HouseTypeNo, hous$HouseType, unique) base2 <- data.frame(HouseType = largetable$HouseType, HouseTypeNo = (housenames[largetable$HouseType])) 

अब लुकअप सही ढंग से किया जाता है

 unique(base2$HouseTypeNo[ base2$HouseType=="ECIIsHome" ]) ECIIsHome 17 

मैंने बीन्स के जवाब को संपादित करने की कोशिश की लेकिन मुझे समझ में नहीं आ रही वजहों के कारण इसे अस्वीकार कर दिया गया।

के साथ शुरू:

 houses <- read.table(text="Semi 1 Single 2 Row 3 Single 2 Apartment 4 Apartment 4 Row 3",col.names=c("HouseType","HouseTypeNo")) 

… आप उपयोग कर सकते हैं

 as.numeric(factor(houses$HouseType)) 

… प्रत्येक घर के प्रकार के लिए एक अद्वितीय संख्या देने के लिए। आप यहां परिणाम देख सकते हैं:

 > houses2 <- data.frame(houses,as.numeric(factor(houses$HouseType))) > houses2 HouseType HouseTypeNo as.numeric.factor.houses.HouseType.. 1 Semi 1 3 2 Single 2 4 3 Row 3 2 4 Single 2 4 5 Apartment 4 1 6 Apartment 4 1 7 Row 3 2 

… ताकि आप पंक्तियों पर अलग-अलग संख्याओं के साथ समाप्त हो जाएं (क्योंकि कारकों को वर्णानुक्रम के अनुसार क्रमबद्ध किया गया है), लेकिन समान पैटर्न

(संपादित करें: इस उत्तर में शेष पाठ वास्तव में अनावश्यक है। यह जांचने के लिए मेरे पास आया और यह पता चला कि read.table() पहले से ही घर को एक घर में बना दिया था जब इसे पहली जगह में डेटाफ्रेम में पढ़ा गया था) ।

हालांकि, आप केवल हाउसटाइप को एक कारक में परिवर्तित करने के लिए बेहतर हो सकते हैं, जो आपको हाउसटिप्नो के रूप में सभी लाभ दे सकते हैं, लेकिन व्याख्या करना आसान होगा क्योंकि घर के प्रकारों को नामित किए जाने के बजाय नाम दिया गया है, जैसे:

 > houses3 <- houses > houses3$HouseType <- factor(houses3$HouseType) > houses3 HouseType HouseTypeNo 1 Semi 1 2 Single 2 3 Row 3 4 Single 2 5 Apartment 4 6 Apartment 4 7 Row 3 > levels(houses3$HouseType) [1] "Apartment" "Row" "Semi" "Single" 

पोस्टर ने exact=FALSE मूल्यों को देखने के बारे में नहीं पूछा, लेकिन मैं इसे अपने संदर्भ के लिए एक उत्तर के रूप में जोड़ रहा हूं और संभवतः अन्य

यदि आप स्पष्ट मूल्यों को देख रहे हैं, तो अन्य उत्तरों का उपयोग करें।

एक्सेल के vlookup आपको लगभग 4 वां तर्क (1) match=TRUE साथ संख्यात्मक मानों के लिए मिलान मैच की अनुमति देता है। मैं match=TRUE बारे में सोचता हूं match=TRUE जैसे थर्मामीटर पर मूल्यों की तलाश करना डिफ़ॉल्ट मान गलत है, जो स्पष्ट मानों के लिए एकदम सही है।

यदि आप लगभग (एक लुकअप प्रदर्शन) मैच करना चाहते हैं, तो आर में एक फ़ंक्शन है जिसे findInterval कहा जाता है, जो (जैसा कि नाम से है) अंतराल / बिन मिलेगा जिसमें आपके निरंतर संख्यात्मक मूल्य होगा।

हालांकि, मान लें कि आप कई मानों के लिए findInterval चाहते हैं। आप एक लूप लिख सकते हैं या फ़ंक्शन को लागू कर सकते हैं। हालांकि, मैंने इसे एक DIY vectorized दृष्टिकोण लेना अधिक कुशल पाया है

मान लें कि आपके पास x और y द्वारा अनुक्रमित मानों का ग्रिड है:

 grid <- list(x = c(-87.727, -87.723, -87.719, -87.715, -87.711), y = c(41.836, 41.839, 41.843, 41.847, 41.851), z = (matrix(data = c(-3.428, -3.722, -3.061, -2.554, -2.362, -3.034, -3.925, -3.639, -3.357, -3.283, -0.152, -1.688, -2.765, -3.084, -2.742, 1.973, 1.193, -0.354, -1.682, -1.803, 0.998, 2.863, 3.224, 1.541, -0.044), nrow = 5, ncol = 5))) 

और आपके पास कुछ मान हैं जिन्हें आप एक्स और वाई द्वारा देखना चाहते हैं:

 df <- data.frame(x = c(-87.723, -87.712, -87.726, -87.719, -87.722, -87.722), y = c(41.84, 41.842, 41.844, 41.849, 41.838, 41.842), id = c("a", "b", "c", "d", "e", "f") 

दृश्यमान उदाहरण यहां दिया गया है:

 contour(grid) points(df$x, df$y, pch=df$id, col="blue", cex=1.2) 

समोच्च साजिश

आप इस प्रकार के सूत्र के साथ एक्स अंतराल और वाई अंतराल पा सकते हैं:

 xrng <- range(grid$x) xbins <- length(grid$x) -1 yrng <- range(grid$y) ybins <- length(grid$y) -1 df$ix <- trunc( (df$x - min(xrng)) / diff(xrng) * (xbins)) + 1 df$iy <- trunc( (df$y - min(yrng)) / diff(yrng) * (ybins)) + 1 

आप इसे एक कदम आगे ले सकते हैं और इस तरह grid में z मानों पर एक (सरलीकृत) प्रक्षेपण कर सकते हैं:

 df$z <- with(df, (grid$z[cbind(ix, iy)] + grid$z[cbind(ix + 1, iy)] + grid$z[cbind(ix, iy + 1)] + grid$z[cbind(ix + 1, iy + 1)]) / 4) 

जो आपको इन मूल्यों को देता है:

 contour(grid, xlim = range(c(grid$x, df$x)), ylim = range(c(grid$y, df$y))) points(df$x, df$y, pch=df$id, col="blue", cex=1.2) text(df$x + .001, df$y, lab=round(df$z, 2), col="blue", cex=1) 

मूल्यों के साथ कंटूर प्लॉट

 df # xy id ix iy z # 1 -87.723 41.840 a 2 2 -3.00425 # 2 -87.712 41.842 b 4 2 -3.11650 # 3 -87.726 41.844 c 1 3 0.33150 # 4 -87.719 41.849 d 3 4 0.68225 # 6 -87.722 41.838 e 2 1 -3.58675 # 7 -87.722 41.842 f 2 2 -3.00425 

ध्यान दें कि ix, और i findInterval का उपयोग करके एक लूप के साथ भी मिल सकता था, उदाहरण के लिए दूसरी पंक्ति के लिए यह एक उदाहरण है

 findInterval(df$x[2], grid$x) # 4 findInterval(df$y[2], grid$y) # 2 

जो df[2] में ix और आई से मेल खाता है

फुटनोट: (1) vlookup का चौथा तर्क पहले से "मैच" कहा जाता था, लेकिन रिबन को पेश करने के बाद इसका नाम बदलकर "[range_lookup]" कर दिया गया था

आप प्लाईर पैकेज से mapvalues() इस्तेमाल कर सकते हैं

प्रारंभिक आंकड़े:

 dat <- data.frame(HouseType = c("Semi", "Single", "Row", "Single", "Apartment", "Apartment", "Row")) > dat HouseType 1 Semi 2 Single 3 Row 4 Single 5 Apartment 6 Apartment 7 Row 

लुकअप / क्रॉसवाक तालिका:

 lookup <- data.frame(type_text = c("Semi", "Single", "Row", "Apartment"), type_num = c(1, 2, 3, 4)) > lookup type_text type_num 1 Semi 1 2 Single 2 3 Row 3 4 Apartment 4 

नया चर बनाएँ:

 dat$house_type_num <- plyr::mapvalues(dat$HouseType, from = lookup$type_text, to = lookup$type_num) 

या साधारण प्रतिस्थापन के लिए आप एक लंबी लुकअप तालिका बना सकते हैं और इसे सीधे एक चरण में कर सकते हैं:

 dat$house_type_num <- plyr::mapvalues(dat$HouseType, from = c("Semi", "Single", "Row", "Apartment"), to = c(1, 2, 3, 4)) 

परिणाम:

 > dat HouseType house_type_num 1 Semi 1 2 Single 2 3 Row 3 4 Single 2 5 Apartment 4 6 Apartment 4 7 Row 3 

merge का उपयोग Excel में देखने से भिन्न होता है क्योंकि प्राथमिक डेटा की नकल करने के लिए आपके डेटा को डुप्लिकेट (गुणा) करने की क्षमता है या यदि आप all.x = T का उपयोग नहीं कर रहे हैं तो लुकअप तालिका में लागू नहीं की गई है या रिकॉर्ड की संख्या कम कर all.x = T

यह सुनिश्चित करने के लिए कि आप उस के साथ मुसीबत में नहीं आते हैं और सुरक्षित रूप से देखने के लिए, मैं दो रणनीतियों का सुझाव देता हूं।

सबसे पहले एक लुकअप कुंजी में कई दोहराई गई पंक्तियों पर एक जांच करना है:

 safeLookup <- function(data, lookup, by, select = setdiff(colnames(lookup), by)) { # Merges data to lookup making sure that the number of rows does not change. stopifnot(sum(duplicated(lookup[, by])) == 0) res <- merge(data, lookup[, c(by, select)], by = by, all.x = T) return (res) } 

यह आपको उपयोग करने से पहले डी-डुप्ले लुकअप डाटासेट पर लागू होगा:

 baseSafe <- safeLookup(largetable, house.ids, by = "HouseType") # Error: sum(duplicated(lookup[, by])) == 0 is not TRUE baseSafe<- safeLookup(largetable, unique(house.ids), by = "HouseType") head(baseSafe) # HouseType HouseTypeNo # 1 Apartment 4 # 2 Apartment 4 # ... 

दूसरा विकल्प लुकअप डाटासेट से प्रथम मिलान मूल्य ले कर Excel व्यवहार को पुन: उत्पन्न करना है:

 firstLookup <- function(data, lookup, by, select = setdiff(colnames(lookup), by)) { # Merges data to lookup using first row per unique combination in by. unique.lookup <- lookup[!duplicated(lookup[, by]), ] res <- merge(data, unique.lookup[, c(by, select)], by = by, all.x = T) return (res) } baseFirst <- firstLookup(largetable, house.ids, by = "HouseType") 

ये फ़ंक्शन lookup से थोड़ी भिन्न हैं क्योंकि वे एकाधिक कॉलम जोड़ते हैं।