दो तारों को कैसे समेटा जा सकता है?

Question

मैं दो मूल्यों को कैसे समेट (मर्ज, कंबाइन) कर सकता हूं? उदाहरण के लिए मेरे पास:

tmp = cbind("GAD", "AB")
tmp
#      [,1]  [,2]
# [1,] "GAD" "AB"

मेरा लक्ष्य "tmp" में दो मानों को एक स्ट्रिंग में बदलना है:

tmp_new = "GAD,AB"

कौन सा कार्य मेरे लिए यह कर सकता है?

Comments

यहाँ ज्यादातर उत्तर टूटते हैं अगर तार वैक्टर हैं, जैसा कि @ रिचर्डसवेन के उत्तर नोट हैं।

— एसएमसीआई

@smci मेरे द्वारा पोस्ट किए गए छोटे उत्तर के बारे में क्या है? इसे बेहतर बनाने के लिए कोई सुझाव?

— joel.wilson

Answer 1

paste()

जाने का रास्ता है। जैसा कि पिछले पोस्टर ने बताया, पेस्ट दो काम कर सकता है:

एक "स्ट्रिंग" में मानों को अलग करें, जैसे

> paste("Hello", "world", sep=" ")
[1] "Hello world"

जहाँ तर्क sepवर्णों को संक्षिप्त करने, या संक्षिप्त करने के लिए वर्ण वैक्टर के बीच उपयोग किए जाने वाले वर्ण को निर्दिष्ट करता है

> x <- c("Hello", "World")
> x
[1] "Hello" "World"
> paste(x, collapse="--")
[1] "Hello--World"

जहां तर्क collapseवेक्टर के तत्वों के बीच उपयोग किए जाने वाले वर्णों को ध्वस्त करने के लिए निर्दिष्ट करता है।

आप दोनों को जोड़ भी सकते हैं:

> paste(x, "and some more", sep="|-|", collapse="--")
[1] "Hello|-|and some more--World|-|and some more"

उम्मीद है की यह मदद करेगा।

Comments

स्ट्रिंग्स और वैक्टर या वैक्टर को अलग-अलग लंबाई में paste()मिलाना मेरी पसंद के हिसाब से थोड़ा लचीला है । उदाहरण के लिए, में paste(c('a','b'),'blah', c(1,2,3))परिणाम "a blah 1" "b blah 2" "a blah 3"। मूल रूप से, यह सबसे लंबी वेक्टर के रूप में उसी लंबाई के तार का एक सदिश बनाता है जो पास हो जाता है और उसी लंबाई के अन्य वैक्टर / तार को ढीला करता है। आकस्मिक व्यवहार के लिए बहुत जगह है।

— n

सच - लेकिन क्या आप एक वैकल्पिक दृष्टिकोण प्रदान कर सकते हैं जो प्रश्न को संबोधित करता है?

— रेनर

नहीं - आपका उत्तर सही है (जैसा कि अन्य उत्तरों में से अधिकांश वही बात कहते हैं)। मैं सिर्फ यह ध्यान दे रहा था कि पेस्ट का व्यवहार उसके लचीलेपन में असामान्य है।

— n

@ n-0101 मैं इसे R के मानकों से असामान्य नहीं मानूंगा। वेक्टर पुनर्चक्रण आर कार्यों की एक सामान्य संपत्ति है। ध्यान रखें कि 'ब्ला' लंबाई का एक सदिश है। रिसाइकलिंग प्रॉपर्टी से कुछ ऐसा करना आसान हो जाता है जिसे paste0("blah", 1:3)प्राप्त करना पसंद है "blah1" "blah2" "blah3"।

— दासन

हां, मुझे आर के बारे में शिकायत करनी चाहिए, न कि केवल पेस्ट: पी। यह वास्तव में आर भर में असंगत है - data.frame()यदि आप वैक्टर एक दूसरे के कई नहीं हैं, तो आपको ऐसा करने नहीं देता है। matrix()चेतावनी देता है, लेकिन array()नहीं करता है। कष्टप्रद प्रकार का। वास्तव में, उन्हें सभी चेतावनियों को तब तक थूकना चाहिए जब तक कि कोई विकल्प निर्धारित न हो ...

— n

Answer 2

help.search() एक आसान कार्य है, जैसे

> help.search("concatenate")

आपको ले जाएगा paste()।

Answer 3

पहले गैर- paste()उत्तर के लिए, हम stringr::str_c()(और फिर toString()नीचे) देख सकते हैं । जब तक यह प्रश्न है, तब तक ऐसा नहीं हुआ, इसलिए मुझे लगता है कि यह उल्लेख करना उपयोगी है कि यह भी मौजूद है।

उपयोग करने के लिए बहुत सरल, जैसा कि आप देख सकते हैं।

tmp <- cbind("GAD", "AB")
library(stringr)
str_c(tmp, collapse = ",")
# [1] "GAD,AB"

अपने प्रलेखन फ़ाइल विवरण से, यह इस समस्या को अच्छी तरह से फिट बैठता है।

यह समझने के लिए कि str_c कैसे काम करता है, आपको यह कल्पना करने की आवश्यकता है कि आप स्ट्रिंग्स का एक मैट्रिक्स बना रहे हैं। प्रत्येक इनपुट तर्क एक कॉलम बनाता है, और सामान्य पुनरावर्ती नियमों का उपयोग करते हुए, सबसे लंबे तर्क की लंबाई तक विस्तारित होता है। प्रत्येक स्तंभ के बीच सेप स्ट्रिंग डाली जाती है। यदि पतन NULL है तो प्रत्येक पंक्ति एक स्ट्रिंग में ढह जाती है। यदि गैर-पूर्ण उस स्ट्रिंग को प्रत्येक पंक्ति के अंत में डाला जाता है, और पूरा मैट्रिक्स एकल स्ट्रिंग में ढह जाता है।

जोड़ा गया 4/13/2016 : यह आपके वांछित आउटपुट (अतिरिक्त स्थान) के समान नहीं है, लेकिन किसी ने भी इसका उल्लेख नहीं किया है। toString()मूल रूप paste()से collapse = ", "हार्ड-कोडित का एक संस्करण है , इसलिए आप कर सकते हैं

toString(tmp)
# [1] "GAD, AB"

Comments

हे, यह एकमात्र उत्तर है जो इस तथ्य को संबोधित करता है कि tmp एक सदिश है, और न केवल मूल्यों का एक गुच्छा - pasteवैक्टर नहीं करता है। दूसरा विकल्प है do.call(paste, as.list(tmp))।

— naught101

Answer 4

जैसा कि दूसरों ने बताया है, paste()जाने का रास्ता है। लेकिन यह paste(str1, str2, str3, sep='')गैर-डिफ़ॉल्ट विभाजक के लिए हर बार टाइप करने के लिए कष्टप्रद हो सकता है ।

आप बहुत आसानी से रैपर फ़ंक्शंस बना सकते हैं जो जीवन को बहुत सरल बनाते हैं। उदाहरण के लिए, यदि आप वास्तव में अक्सर कोई विभाजक नहीं है, तो आप कर सकते हैं

p <- function(..., sep='') {
    paste(..., sep=sep, collapse=sep)
}

या यदि आप अक्सर वेक्टर से तार जोड़ना चाहते हैं (जैसे implode()PHP से):

implode <- function(..., sep='') {
     paste(..., collapse=sep)
}

आपको ऐसा करने की अनुमति देता है:

p('a', 'b', 'c')
#[1] "abc"
vec <- c('a', 'b', 'c')
implode(vec)
#[1] "abc"
implode(vec, sep=', ')
#[1] "a, b, c"

इसके अलावा, बिल्ट-इन है paste0, जो मेरे जैसे ही काम करता है implode, लेकिन बिना कस्टम सेपरेटर की अनुमति के। की तुलना में यह थोड़ा अधिक कुशल है paste()।

Answer 5

> tmp = paste("GAD", "AB", sep = ",")
> tmp
[1] "GAD,AB"

मैंने इसे Google से आर कॉनसैट स्ट्रिंग्स की खोज करके पाया : http://stat.ethz.ch/R-manual/R-patched/library/base/html/paste.html

Answer 6

वैकल्पिक रूप से, यदि आपका उद्देश्य सीधे फ़ाइल या स्टडआउट में आउटपुट करना है, तो आप उपयोग कर सकते हैं cat:

cat(s1, s2, sep=", ")

Comments

तो क्या बिंदु paste4 साल बाद एक जवाब पोस्ट कर रहा है जब pasteपहले से ही लगभग एक दर्जन जवाब हैं?

— डेविड ऐरनबर्ग

उस समय मुझे अपने लिए कई उत्तरों को संक्षेप में प्रस्तुत करने में मदद मिली। उद्देश्य वोट एकत्र करना नहीं था, बल्कि कई प्रस्तावित समाधानों के माध्यम से दूसरों को फ़िल्टर करने में मदद करना था। अक्सर यही मैं ढूंढ रहा हूं।

— मेगाट्रॉन

Answer 7

दूसरा रास्ता:

sprintf("%s you can add other static strings here %s",string1,string2)

यह कभी-कभी paste()फ़ंक्शन की तुलना में उपयोगी होता है। %sउस स्थान को दर्शाता है जहां व्यक्तिपरक तार शामिल किए जाएंगे।

ध्यान दें कि यह तब काम आएगा जब आप एक रास्ता बनाने की कोशिश करेंगे:

sprintf("/%s", paste("this", "is", "a", "path", sep="/"))

उत्पादन

/this/is/a/path

Comments

सी प्रोग्रामर के लिए आर से निपटने के लिए,

— स्प्रिंटफ

बहुत बेहतर imho। pasteयदि आप किसी स्ट्रिंग में कुछ जोड़ना चाहते हैं तो यह पर्याप्त लचीला नहीं है।

— डिस्प्लेनाम

Answer 8

आप अपना खुद का ऑपरेटर बना सकते हैं:

'%&%' <- function(x, y)paste0(x,y)
"new" %&% "operator"
[1] newoperator`

आप 'और' ( &) ऑपरेटर को फिर से परिभाषित कर सकते हैं :

'&' <- function(x, y)paste0(x,y)
"dirty" & "trick"
"dirtytrick"

बेसलाइन सिंटैक्स के साथ खिलवाड़ बदसूरत है, लेकिन इसलिए paste()/paste0()यदि आप अपने स्वयं के कोड के साथ काम करते हैं तो आप (लगभग हमेशा) तार्किक & andऑपरेटर को बदल सकते हैं *और तार्किक मानों का गुणा करें और 'और' का उपयोग करें

Comments

@ रीचर्ड स्क्रिवन मेबी मुझे समझ में नहीं आता है, लेकिन यह सीधा लगता है, तुलना करें: paste0(as.matrix(iris[1:4]) , as.matrix(iris[1:4]))औरas.matrix(iris[1:4]) %&% as.matrix(iris[1:4])

— Qbik

बहुत बहुत अच्छे! और कई भाषाओं में संघटन के लिए मानक है, मुझे वास्तव में लगता है कि आर को डिफ़ॉल्ट रूप से होना चाहिए था। इस तरह से जोरदार सलाह देते हैं

— सिरोही

Answer 9

मैट्रिक्स, tmp को देखते हुए, जो आपने बनाया था:

paste(tmp[1,], collapse = ",")

मुझे लगता है कि वहाँ कुछ कारण है कि आप cbind का उपयोग करके एक मैट्रिक्स बना रहे हैं, जैसा कि बस विरोध किया जाता है:

tmp <- "GAD,AB"

Answer 10

उस मामले पर विचार करें जहां तार स्तंभ हैं और परिणाम एक नया स्तंभ होना चाहिए:

df <- data.frame(a = letters[1:5], b = LETTERS[1:5], c = 1:5)

df$new_col <- do.call(paste, c(df[c("a", "b")], sep = ", ")) 
df
#  a b c new_col
#1 a A 1    a, A
#2 b B 2    b, B
#3 c C 3    c, C
#4 d D 4    d, D
#5 e E 5    e, E

वैकल्पिक रूप से, [c("a", "b")]सभी कॉलमों को चिपकाने की आवश्यकता होने पर , सब्मिट को छोड़ दें ।

# you can also try str_c from stringr package as mentioned by other users too!
do.call(str_c, c(df[c("a", "b")], sep = ", ")) 

Comments

ठीक है, लेकिन stringi, stringrलाइब्रेरीज़ तेज़ हैं।

— एसएमसीआई

Answer 11

एक और गैर-पेस्ट उत्तर:

x <- capture.output(cat(data, sep = ","))
x
[1] "GAD,AB"

कहाँ पे

 data <- c("GAD", "AB")

Answer 12

glue एक नया फ़ंक्शन, डेटा क्लास और पैकेज है जिसे के भाग के रूप में विकसित किया गया है tidyverse बहुत विस्तारित कार्यक्षमता के साथ । यह पेस्ट, स्प्रिंट, और पिछले अन्य उत्तरों से सुविधाओं को जोड़ती है।

tmp <- tibble::tibble(firststring = "GAD", secondstring = "AB")
(tmp_new <- glue::glue_data(tmp, "{firststring},{secondstring}"))
#> GAD,AB

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

हां, यह इस प्रश्न में सरल उदाहरण के लिए ओवरकिल है, लेकिन कई स्थितियों के लिए शक्तिशाली है। (देख https://glue.tidyverse.org/ )

नीचे के pasteसाथ तुलना में त्वरित उदाहरण with। glueकोड टाइप करने के लिए थोड़ा आसान था और थोड़ा आसान को पढ़ने के लिए लग रहा है।

tmp <- tibble::tibble(firststring = c("GAD", "GAD2", "GAD3"), secondstring = c("AB1", "AB2", "AB3"))
(tmp_new <- glue::glue_data(tmp, "{firststring} and {secondstring} went to the park for a walk. {firststring} forgot his keys."))
#> GAD and AB1 went to the park for a walk. GAD forgot his keys.
#> GAD2 and AB2 went to the park for a walk. GAD2 forgot his keys.
#> GAD3 and AB3 went to the park for a walk. GAD3 forgot his keys.
(with(tmp, paste(firststring, "and", secondstring, "went to the park for a walk.", firststring, "forgot his keys.")))
#> [1] "GAD and AB1 went to the park for a walk. GAD forgot his keys."  
#> [2] "GAD2 and AB2 went to the park for a walk. GAD2 forgot his keys."
#> [3] "GAD3 and AB3 went to the park for a walk. GAD3 forgot his keys."

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