एक पैटर्न के अनुसार एक विकल्प निकालें

Question

मान लीजिए कि मेरे पास स्ट्रिंग की सूची है:

string = c("G1:E001", "G2:E002", "G3:E003")

अब मैं एक वेक्टर के स्ट्रिंग प्राप्त करने की उम्मीद करता हूं जिसमें बृहदान्त्र ":", यानी के बाद केवल भाग शामिल हैं substring = c(E001,E002,E003)।

क्या ऐसा करने के लिए R में एक सुविधाजनक तरीका है? का उपयोग कर substr?

Answer 1

यहाँ कुछ तरीके हैं:

1) उप

sub(".*:", "", string)
## [1] "E001" "E002" "E003"

2) strsplit

sapply(strsplit(string, ":"), "[", 2)
## [1] "E001" "E002" "E003"

3) read.table

read.table(text = string, sep = ":", as.is = TRUE)$V2
## [1] "E001" "E002" "E003"

4) विकल्प

यह दूसरा भाग हमेशा 4 वें वर्ण पर शुरू होता है (जो प्रश्न में उदाहरण में मामला है):

substring(string, 4)
## [1] "E001" "E002" "E003"

4a) सबस्ट्रिंग / रेगेक्स

यदि बृहदान्त्र हमेशा ज्ञात स्थिति में नहीं होता है तो हम उसे खोज कर (4) संशोधित कर सकते हैं:

substring(string, regexpr(":", string) + 1)

5) स्ट्रैप्लीक

strapplyc कोष्ठक भाग देता है:

library(gsubfn)
strapplyc(string, ":(.*)", simplify = TRUE)
## [1] "E001" "E002" "E003"

6) read.dcf

यह केवल तभी काम करता है जब बृहदान्त्र से पहले सबस्ट्रिंग अद्वितीय होते हैं (जो वे प्रश्न में उदाहरण में हैं)। इसके अलावा यह आवश्यक है कि विभाजक बृहदान्त्र हो (जो कि प्रश्न में है)। यदि एक अलग विभाजक का उपयोग किया गया था, तो हम subइसे पहले एक बृहदान्त्र के साथ बदलने के लिए उपयोग कर सकते हैं । उदाहरण के लिए, यदि विभाजक _तब थेstring <- sub("_", ":", string)

c(read.dcf(textConnection(string)))
## [1] "E001" "E002" "E003"

7) अलग

7a)tidyr::separate हम दो स्तंभों के साथ एक डेटा फ्रेम का उपयोग करते हैं, एक बृहदान्त्र से पहले के भाग के लिए और एक बाद के लिए, और फिर बाद वाले को निकालते हैं।

library(dplyr)
library(tidyr)
library(purrr)

DF <- data.frame(string)
DF %>% 
  separate(string, into = c("pre", "post")) %>% 
  pull("post")
## [1] "E001" "E002" "E003"

7 बी) वैकल्पिक रूप separateसे postस्तंभ और उसके बाद unlistऔर unnameइसके परिणामस्वरूप डेटा फ्रेम बनाने के लिए उपयोग किया जा सकता है :

library(dplyr)
library(tidyr)

DF %>% 
  separate(string, into = c(NA, "post")) %>% 
  unlist %>%
  unname
## [1] "E001" "E002" "E003"

8) ट्रिम्स हम trimwsबाईं ओर से शब्द वर्णों को ट्रिम करने के लिए उपयोग कर सकते हैं और फिर इसे बृहदान्त्र ट्रिम करने के लिए फिर से उपयोग कर सकते हैं।

trimws(trimws(string, "left", "\\w"), "left", ":")
## [1] "E001" "E002" "E003"

ध्यान दें

इनपुट stringमाना जाता है:

string <- c("G1:E001", "G2:E002", "G3:E003")

Comments

मेरे पास एक पिघले हुए टेबल में एक चर था _जो एक विभाजक के रूप में था और @Grothendieck उत्तर के आधार पर उपसर्ग और प्रत्यय के लिए दो अलग-अलग चर बनाए: prefix <- sub("_.*", "", variable)और suffix <- sub(".*_", "", variable)

— swihart

इस अद्भुत उत्तर के एक माइक्रोबेनमार्किंग को देखना अच्छा होगा!

— patL

Answer 2

उदाहरण के लिए gsubया का उपयोग करsub

    gsub('.*:(.*)','\\1',string)
    [1] "E001" "E002" "E003"

Comments

क्या आप ये पता लगा सकते हैं कि ये क्या हैं '। * (* और इसी तरह वहाँ पर ठीक है! मैं एक कठिन समय यह केवल थोड़ा अलग सेटिंग में फिर से कर रहा हूँ ...

— पीटर पैन

@PeterPan यह बृहदान्त्र के बाद दिखने वाले वर्णों के समूह को पकड़ता है और लौटाता है। यदि मैच के लिए तार अधिक जटिल हैं और आप बेस आर में रहना चाहते हैं तो यह अच्छी तरह से काम करता है।

— क्लार्क फिजराल्ड़

Answer 3

यहाँ एक और सरल उत्तर है

gsub("^.*:","", string)

Answer 4

पार्टी के लिए देर हो गई, लेकिन बाद के लिए, स्ट्रिंग पैकेज (पैकेज के लोकप्रिय "tidyverse" सूट का हिस्सा) अब स्ट्रिंग हैंडलिंग के लिए सामंजस्यपूर्ण हस्ताक्षर के साथ कार्य प्रदान करता है:

string <- c("G1:E001", "G2:E002", "G3:E003")
# match string to keep
stringr::str_extract(string = string, pattern = "E[0-9]+")
# [1] "E001" "E002" "E003"

# replace leading string with ""
stringr::str_remove(string = string, pattern = "^.*:")
# [1] "E001" "E002" "E003"

Comments

क्या यह पहला नंबर नहीं है जो कि बृहदान्त्र के बाद सब कुछ के बजाय ई के साथ शुरू होता है?

— मार्क नील

Answer 5

यह करना चाहिए:

gsub("[A-Z][1-9]:", "", string)

देता है

[1] "E001" "E002" "E003"

Answer 6

यदि आप उपयोग कर रहे हैं data.tableतो tstrsplit()एक प्राकृतिक विकल्प है:

tstrsplit(string, ":")[[2]]
[1] "E001" "E002" "E003"

Answer 7

Unglue पैकेज के लिए एक विकल्प प्रदान करता है, रेगुलर एक्सप्रेशन के बारे में कोई जानकारी नहीं साधारण मामलों के लिए आवश्यक है, यहाँ हम कर चाहते हैं:

# install.packages("unglue")
library(unglue)
string = c("G1:E001", "G2:E002", "G3:E003")
unglue_vec(string,"{x}:{y}", var = "y")
#> [1] "E001" "E002" "E003"

^{2019-11-06 को रेप्रेक्स पैकेज (v0.3.0) द्वारा बनाया गया}

अधिक जानकारी: https://github.com/moodymudskipper/unglue/blob/master/README.md