मैं किसी सूची से एक तत्व कैसे निकाल सकता हूं?

Question

मेरे पास एक सूची है और मैं इसमें से एक भी तत्व निकालना चाहता हूं। मैं यह कैसे कर सकता हूँ?

मैंने यह देखने की कोशिश की है कि मुझे क्या लगता है कि इस फ़ंक्शन के लिए स्पष्ट नाम संदर्भ पुस्तिका में होंगे और मुझे कुछ भी उपयुक्त नहीं मिला है।

Comments

निर्भर करता है कि क्या आप इसे मान द्वारा हटाना चाहते हैं जैसे "मान 5", या सूचकांक / सूचकांक "सूचकांक 5 पर तत्व" या "सूचकांकों c (5: 6,10) पर? यदि आप मूल्य और वहाँ से हटाना चाहते हैं? डुप्लिकेट हैं, तो क्या आप केवल डुप्लिकेट, पहली या अंतिम घटना, या सभी को निकालना चाहते हैं? क्या यह गारंटी है कि सूची में आपका तत्व / सूचकांक है? क्या हमें उस मामले को संभालने की आवश्यकता है जहां सूची खाली है? क्या हमें ज़रूरत है? सुनिश्चित करें कि NA उत्तीर्ण (/ बहिष्कृत) है? क्या सूची फ्लैट होने की गारंटी है या इसे नेस्टेड किया जा सकता है? कितने लेटर्स गहरे?

— smci

setdiff (myList, elementToRemove)

— JStrahl

Answer 1

मैं आर को बिलकुल नहीं जानता, लेकिन थोड़ा सा रचनात्मक गुगली मुझे यहाँ ले गया: http://tolstoy.newcastle.edu.au/R/help/05/04/1919.html

वहां से प्रमुख बोली:

मुझे सूची से तत्वों को हटाने के लिए आर के लिए स्पष्ट दस्तावेज नहीं मिलते हैं, लेकिन परीक्षण और त्रुटि मुझे बताती है

myList [[5]] <- NULL

5 वें तत्व को हटा देगा और फिर उस तत्व को हटाने के कारण छेद को "बंद" करेगा। यह सूचकांक मूल्यों को प्रभावित करता है, इसलिए मुझे तत्वों को छोड़ने में सावधान रहना होगा। मुझे सूची के पीछे से सामने की ओर काम करना चाहिए।

एक कि पोस्ट बाद में सूत्र में के जवाब कहता है:

किसी सूची के एक तत्व को हटाने के लिए, R FAQ 7.1 देखें

और R FAQ का प्रासंगिक खंड कहता है:

... x [i] या x [[i]] को NULL में सेट न करें, क्योंकि यह सूची से संबंधित घटक को हटा देगा।

जो आपको (कुछ हद तक पीछे की ओर) एक तत्व को हटाने के बारे में बताता है।

आशा है कि मदद करता है, या कम से कम आपको सही दिशा में ले जाता है।

Comments

धन्यवाद, mylist [i] <- NULL बिल्कुल इसे करने का तरीका है।

— डेविड लोके

इसने मेरे लिए काम नहीं किया। मुझे मिलता है:Error in list[length(list)] <- NULL : replacement has length zero

— wfbarksdale

@Aleksandr Levchuck की पोस्ट से पता चला कि मैं वास्तव में एक वेक्टर के साथ काम कर रहा था और एक नई वस्तु बनाने की आवश्यकता थी

— wfbarksdale

Answer 2

यदि आप सूची को इन-प्लेस में बदलना नहीं चाहते (उदाहरण के लिए किसी फ़ंक्शन को निकाले गए तत्व के साथ सूची पास करने के लिए), तो आप अनुक्रमण का उपयोग कर सकते हैं: नकारात्मक सूचकांकों का अर्थ है "इस तत्व को शामिल न करें"।

x <- list("a", "b", "c", "d", "e"); # example list

x[-2];       # without 2nd element

x[-c(2, 3)]; # without 2nd and 3rd

इसके अलावा, तार्किक सूचकांक वैक्टर उपयोगी हैं:

x[x != "b"]; # without elements that are "b"

यह डेटाफ्रेम के साथ भी काम करता है:

df <- data.frame(number = 1:5, name = letters[1:5])

df[df$name != "b", ];     # rows without "b"

df[df$number %% 2 == 1, ] # rows with odd numbers only

Comments

आपका लॉजिकल इंडेक्स तभी काम करता है, जब आपके पास एक सूची तत्व में वह एकल आइटम "बी" हो। आप x$bउस तरह से नहीं कह सकते हैं, न ही किसी सूची तत्व से "b" हटा सकते हैं x[[2]] = c("b","k") ।

— कार्ल विटथॉफ्ट

एकल बनाम कई मदों के बारे में: आप %in%कई वस्तुओं के खिलाफ परीक्षण के लिए उपयोग कर सकते हैं । मुझे यकीन नहीं है कि आप "x $ b को हटा नहीं सकते" का क्या मतलब है - क्या आपका मतलब पूरे कॉलम को हटाने से है b?

— फ्लोरियन जेन

Answer 3

यहाँ कैसे R में एक सूची के अंतिम तत्व को हटा दिया गया है :

x <- list("a", "b", "c", "d", "e")
x[length(x)] <- NULL

यदि x एक वेक्टर हो सकता है तो आपको एक नई वस्तु बनाने की आवश्यकता होगी:

x <- c("a", "b", "c", "d", "e")
x <- x[-length(x)]

• सूचियों और वैक्टर के लिए काम करें

Comments

@krlmlr: इसके विपरीत, यह समाधान फ्लोरियन के उत्तर की तुलना में अधिक सामान्य है, क्योंकि यह संग्रह के प्रकार में बहुरूपी है।

— बजे दान Barowy

@DanBarowy: मैं गलत था: यह चाड के उत्तर (स्वीकृत एक) और फ्लोरियन के ... का एक संश्लेषण प्रतीत होता है ... एक अच्छा संक्षिप्त सारांश, हालांकि।

— krlmlr

Answer 4

एकल लाइन में सूची से अशक्त तत्वों को हटाना:

x=x[-(which(sapply(x,is.null),arr.ind=TRUE))]

चियर्स

Comments

xखाली सूची होने पर यह कोड टूट जाता है। का प्रयोग करें compactसे plyrबजाय इस कार्य के लिए।

— रिची कॉटन

इसके अलावा अगर सूची में कोई नल नहीं है, तो -(which(sapply(x,is.null),arr.ind=TRUE))रिटर्न named integer(0)जो उस पंक्ति को पूरी तरह से छोड़ देगा।

— user3055034

Answer 5

मैं जोड़ना चाहूंगा कि यदि यह एक नामित सूची है तो आप बस इसका उपयोग कर सकते हैं within।

l <- list(a = 1, b = 2)    
> within(l, rm(a))
$b
[1] 2

तो आप मूल सूची को ओवरराइट कर सकते हैं

l <- within(l, rm(a)) 

aसूची से नाम का तत्व निकालने के लिए l।

Comments

कई करने के लिएwithin(l, rm(a, b))

— व्लाद

Answer 6

यदि आपके पास एक नामित सूची है और आप एक विशिष्ट तत्व को निकालना चाहते हैं, तो आप कोशिश कर सकते हैं:

lst <- list(a = 1:4, b = 4:8, c = 8:10)

if("b" %in% names(lst)) lst <- lst[ - which(names(lst) == "b")]

इस सूची बनाएगा lstतत्वों के साथ a, b, c। दूसरी पंक्ति तत्व को bजांचने के बाद हटाती है कि यह मौजूद है (समस्या से बचने के लिए @hjv का उल्लेख किया गया है)।

या और अच्छा:

lst$b <- NULL

इस तरह एक गैर-मौजूद तत्व (जैसे lst$g <- NULL) को हटाने की कोशिश करना कोई समस्या नहीं है

Answer 7

विभिन्न प्रकार की सूची संचालन से निपटने के लिए रिटेल पैकेज ( http://cran.r-project.org/web/packages/rlist/index.html ) है।

उदाहरण ( http://cran.r-project.org/web/packages/rlist/vignettes/Filtering.html ):

library(rlist)
devs <- 
  list(
    p1=list(name="Ken",age=24,
      interest=c("reading","music","movies"),
      lang=list(r=2,csharp=4,python=3)),
    p2=list(name="James",age=25,
      interest=c("sports","music"),
      lang=list(r=3,java=2,cpp=5)),
    p3=list(name="Penny",age=24,
      interest=c("movies","reading"),
      lang=list(r=1,cpp=4,python=2)))

list.remove(devs, c("p1","p2"))

का परिणाम:

# $p3
# $p3$name
# [1] "Penny"
# 
# $p3$age
# [1] 24
# 
# $p3$interest
# [1] "movies"  "reading"
# 
# $p3$lang
# $p3$lang$r
# [1] 1
# 
# $p3$lang$cpp
# [1] 4
# 
# $p3$lang$python
# [1] 2

Comments

इस उदाहरण में अजगर या लंग आइटम को कैसे हटाया जा सकता है?

— आर्थर यिप

Answer 8

अगर आपको अभी भी इसका जवाब चाहिए तो नहीं पता, लेकिन मुझे मेरे सीमित (3 सप्ताह के स्व-शिक्षण आर) के अनुभव के साथ आर के साथ अनुभव हुआ, NULLअसाइनमेंट का उपयोग करना वास्तव में गलत या उप-इष्टतम है खासकर यदि आप गतिशील रूप से अपडेट कर रहे हैं एक सूची में कुछ के लिए एक लूप की तरह।

अधिक सटीक होना, का उपयोग करना

myList[[5]] <- NULL

त्रुटि फेंक देंगे

myList [[5]] <- NULL: प्रतिस्थापन की लंबाई शून्य है

या

अधिक तत्वों की आपूर्ति की तुलना में वहाँ प्रतिस्थापित करने के लिए कर रहे हैं

मुझे जो काम लगातार मिला, वह है

myList <- myList[[-5]]

Comments

अच्छा उत्तर! हालाँकि, मुझे लगता है कि [[-5]]एकल वर्ग कोष्ठक होना चाहिए, अन्यथा आप केवल उस सूची तत्व की सामग्री का ही चयन कर रहे हैं, तत्व का नहीं। खैर, कम से कम डबल स्क्वायर ब्रैकेट का उपयोग करने से मुझे यह त्रुटि मिलती है: "एक से अधिक तत्वों का चयन करने का प्रयास"। मेरे लिए क्या काम करता था myList <- myList[-5]:।

— n1k31t4

Answer 9

बस जल्दी से जोड़ना चाहता था (क्योंकि मैंने इसे किसी भी उत्तर में नहीं देखा था), एक नामित सूची के लिए, आप भी कर सकते हैं l["name"] <- NULL। उदाहरण के लिए:

l <- list(a = 1, b = 2, cc = 3)
l['b'] <- NULL

Answer 10

-तत्व की स्थिति के साथ (नकारात्मक संकेत) का उपयोग करें , उदाहरण के लिए यदि 3 तत्व को हटाया जाना है तो इसका उपयोग करेंyour_list[-3]

इनपुट

my_list <- list(a = 3, b = 3, c = 4, d = "Hello", e = NA)
my_list
# $`a`
# [1] 3

# $b
# [1] 3

# $c
# [1] 4

# $d
# [1] "Hello"

# $e
# [1] NA

सूची से एकल तत्व निकालें

 my_list[-3]
 # $`a`
 # [1] 3

 # $b
 # [1] 3

 # $d
 # [1] "Hello"

 # $e
 [1] NA

सूची से कई तत्व निकालें

 my_list[c(-1,-3,-2)]
 # $`d`
 # [1] "Hello"

 # $e
 # [1] NA

---

 my_list[c(-3:-5)]
 # $`a`
 # [1] 3

 # $b
 # [1] 3

---

 my_list[-seq(1:2)]
 # $`c`
 # [1] 4

 # $d
 # [1] "Hello"

 # $e
 # [1] NA

Answer 11

नामित सूचियों के मामले में मुझे उन सहायक कार्यों को उपयोगी लगता है

member <- function(list,names){
    ## return the elements of the list with the input names
    member..names <- names(list)
    index <- which(member..names %in% names)
    list[index]    
}


exclude <- function(list,names){
     ## return the elements of the list not belonging to names
     member..names <- names(list)
     index <- which(!(member..names %in% names))
    list[index]    
}  
aa <- structure(list(a = 1:10, b = 4:5, fruits = c("apple", "orange"
)), .Names = c("a", "b", "fruits"))

> aa
## $a
##  [1]  1  2  3  4  5  6  7  8  9 10

## $b
## [1] 4 5

## $fruits
## [1] "apple"  "orange"


> member(aa,"fruits")
## $fruits
## [1] "apple"  "orange"


> exclude(aa,"fruits")
## $a
##  [1]  1  2  3  4  5  6  7  8  9 10

## $b
## [1] 4 5

Answer 12

Lapply और grep का उपयोग करना:

lst <- list(a = 1:4, b = 4:8, c = 8:10)
# say you want to remove a and c
toremove<-c("a","c")
lstnew<-lst[-unlist(lapply(toremove, function(x) grep(x, names(lst)) ) ) ]
#or
pattern<-"a|c"
lstnew<-lst[-grep(pattern, names(lst))]

Answer 13

इस बारे में कैसा है? फिर, सूचकांकों का उपयोग करते हुए

> m <- c(1:5)
> m
[1] 1 2 3 4 5

> m[1:length(m)-1]
[1] 1 2 3 4

या

> m[-(length(m))]
[1] 1 2 3 4

Comments

m एक वेक्टर है, सूची नहीं

— C8H10N4O2

विधि सूचियों के लिए काम करती है, लेकिन ओपी भाग्यशाली है और शायद कुछ अधिक कोष्ठक चाहता है:m[1:(length(m) - 1)]

— ग्रेगर थॉमस

Answer 14

यदि आप संख्यात्मक सूचकांक से बचना चाहते हैं, तो आप उपयोग कर सकते हैं

a <- setdiff(names(a),c("name1", ..., "namen"))

नाम को हटाने के लिए namea...namenएक से। यह सूचियों के लिए काम करता है

> l <- list(a=1,b=2)
> l[setdiff(names(l),"a")]
$b
[1] 2

वैक्टर के लिए भी

> v <- c(a=1,b=2)
> v[setdiff(names(v),"a")]
b 
2

Answer 15

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

x<-c(1:5)
x
#[1] 1 2 3 4 5
x<-x[-which(x==4)]
x
#[1] 1 2 3 5

Comments

यह एक नहीं हैlist

— GSee