R Language
डेटा फ्रेम

वाक्य - विन्यास

• data.frame (..., row.names = NULL, check.rows = FALSE, check.names = TRUE, stringsAsFactors = default.stringsAsFactors ())

• as.data.frame (x, row.names = NULL, वैकल्पिक = FALSE, ...) # सामान्य कार्य

• as.data.frame (x, ..., stringsAsFactors = default.stringsAsFactors ()) वर्ग 'वर्ण' के लिए # S3 विधि

• as.data.frame (x, row.names = NULL, वैकल्पिक = FALSE, ..., स्ट्रिंग्सएफ़एक्टर्स = default.stringsAsFactors ()) क्लास 'मैट्रिक्स' के लिए # S3 विधि

• is.data.frame (एक्स)

एक खाली डेटा बनाएँ

डेटा.फ्रेम एक विशेष प्रकार की सूची है: यह आयताकार है । सूची के प्रत्येक तत्व (स्तंभ) की लंबाई समान है, और जहां प्रत्येक पंक्ति में "पंक्ति नाम" है। प्रत्येक कॉलम की अपनी कक्षा होती है, लेकिन एक कॉलम का वर्ग दूसरे कॉलम के वर्ग (मैट्रिक्स के विपरीत, जहां सभी तत्वों का समान वर्ग हो सकता है) से भिन्न हो सकता है।

सिद्धांत रूप में, data.frame में कोई पंक्तियाँ और कोई स्तंभ नहीं हो सकता है:

> structure(list(character()), class = "data.frame")
NULL
<0 rows> (or 0-length row.names)

लेकिन यह असामान्य है। डेटा.फ्रेम के लिए कई कॉलम और कई पंक्तियों का होना आम है। यहां तीन पंक्तियों और दो कॉलमों के साथ एक डेटा है। ( a संख्यात्मक वर्ग है और b चरित्र वर्ग है):

> structure(list(a = 1:3, b = letters[1:3]), class = "data.frame")
[1] a b
<0 rows> (or 0-length row.names)

डेटा.फ्रेम को प्रिंट करने के लिए, हमें कुछ पंक्ति नामों की आपूर्ति करनी होगी। यहां हम सिर्फ 1: 3 नंबर का उपयोग करते हैं:

> structure(list(a = 1:3, b = letters[1:3]), class = "data.frame", row.names = 1:3)
  a b
1 1 a
2 2 b
3 3 c

अब यह स्पष्ट हो जाता है कि हमारे पास 3 पंक्तियों और 2 स्तंभों के साथ एक data.frame है। आप इसे nrow() , ncol() , और dim() का उपयोग करके देख सकते हैं:

> x <- structure(list(a = numeric(3), b = character(3)), class = "data.frame", row.names = 1:3)
> nrow(x)
[1] 3
> ncol(x)
[1] 2
> dim(x)
[1] 3 2

R दो अन्य फ़ंक्शंस प्रदान करता है ( structure() अलावा) जिसका उपयोग डेटा बनाने के लिए किया जा सकता है। पहले कहा जाता है, intuitively, data.frame() । यह सुनिश्चित करने के लिए जाँच करता है कि आपके द्वारा प्रदत्त स्तंभ नाम मान्य हैं, कि सूची तत्व सभी समान लंबाई के हैं, और कुछ स्वचालित रूप से उत्पन्न पंक्ति नामों की आपूर्ति करते हैं। इसका मतलब है कि data.frame() का आउटपुट अब हमेशा वही हो सकता है जो आप उम्मीद करते हैं:

> str(data.frame("a a a" = numeric(3), "b-b-b" = character(3)))
'data.frame':   3 obs. of  2 variables:
 $ a.a.a: num  0 0 0
 $ b.b.b: Factor w/ 1 level "": 1 1 1

दूसरे फ़ंक्शन को as.data.frame() कहा जाता है। यह एक data.frame अस्तित्व में के माध्यम से यह चल रहा द्वारा एक वस्तु है कि एक data.frame नहीं है मजबूर करने के लिए इस्तेमाल किया जा सकता data.frame() एक उदाहरण के रूप में, एक मैट्रिक्स पर विचार करें:

> m <- matrix(letters[1:9], nrow = 3)
> m
     [,1] [,2] [,3]
[1,] "a"  "d"  "g" 
[2,] "b"  "e"  "h" 
[3,] "c"  "f"  "i" 

और परिणाम:

> as.data.frame(m)
  V1 V2 V3
1  a  d  g
2  b  e  h
3  c  f  i
> str(as.data.frame(m))
'data.frame':   3 obs. of  3 variables:
 $ V1: Factor w/ 3 levels "a","b","c": 1 2 3
 $ V2: Factor w/ 3 levels "d","e","f": 1 2 3
 $ V3: Factor w/ 3 levels "g","h","i": 1 2 3

डेटा फ़्रेम से पंक्तियों और स्तंभों को सबसेट करना

पंक्तियों और स्तंभों तक पहुँचने के लिए सिंटैक्स: [ , [[ , और $

यह विषय किसी डेटा फ़्रेम की विशिष्ट पंक्तियों और स्तंभों तक पहुंचने के लिए सबसे आम सिंटैक्स को कवर करता है। य़े हैं

• एकल कोष्ठक data[rows, columns] साथ एक matrix तरह
  • पंक्ति और स्तंभ संख्याओं का उपयोग करना
  • कॉलम (और पंक्ति) नामों का उपयोग करना
• एक list तरह:
  • एकल ब्रैकेट data[columns] डेटा फ़्रेम प्राप्त करने के लिए
  • वेक्टर प्राप्त करने के लिए डबल ब्रैकेट data[[one_column]] के साथ
• एकल कॉलम data$column_name लिए $ के साथ

हम चित्रण करने के लिए अंतर्निहित mtcars डेटा फ़्रेम का उपयोग करेंगे।

एक मैट्रिक्स की तरह: data[rows, columns]

संख्यात्मक सूचकांक के साथ

अंतर्निहित डेटा फ़्रेम mtcars का उपयोग करके, हम शामिल किए गए अल्पविराम के साथ [] कोष्ठक का उपयोग करके पंक्तियों और स्तंभों को निकाल सकते हैं। अल्पविराम से पहले संकेत पंक्तियाँ हैं:

# get the first row
mtcars[1, ]
# get the first five rows
mtcars[1:5, ]

इसी तरह, अल्पविराम के बाद कॉलम हैं:

# get the first column
mtcars[, 1]
# get the first, third and fifth columns:
mtcars[, c(1, 3, 5)]

जैसा कि ऊपर दिखाया गया है, अगर या तो पंक्तियाँ या कॉलम खाली छोड़ दिए जाते हैं, तो सभी का चयन किया जाएगा। mtcars[1, ] सभी स्तंभों के साथ पहली पंक्ति को इंगित करता है।

कॉलम (और पंक्ति) नामों के साथ

अब तक, यह समान है कि कैसे मैट्रीस की पंक्तियों और स्तंभों तक पहुँचा जाता है। data.frame एस के साथ, ज्यादातर समय एक कॉलम नाम का उपयोग करना बेहतर होता है एक कॉलम इंडेक्स। यह एक स्तंभ संख्या के साथ numeric बजाय स्तंभ नाम के साथ एक character का उपयोग करके किया जाता है:

# get the mpg column
mtcars[, "mpg"]
# get the mpg, cyl, and disp columns
mtcars[, c("mpg", "cyl", "disp")]

हालांकि कम सामान्य, पंक्ति नामों का भी उपयोग किया जा सकता है:

mtcars["Mazda Rx4", ]

पंक्तियाँ और स्तंभ एक साथ

पंक्ति और स्तंभ तर्क एक साथ उपयोग किए जा सकते हैं:

# first four rows of the mpg column
mtcars[1:4, "mpg"]

# 2nd and 5th row of the mpg, cyl, and disp columns
mtcars[c(2, 5), c("mpg", "cyl", "disp")]

आयामों के बारे में चेतावनी:

इन विधियों का उपयोग करते समय, यदि आप कई कॉलम निकालते हैं, तो आपको डेटा फ़्रेम वापस मिलेगा। हालाँकि, यदि आप किसी एकल स्तंभ को निकालते हैं, तो आपको एक वेक्टर मिलेगा, न कि डिफ़ॉल्ट विकल्पों के तहत डेटा फ़्रेम।

## multiple columns returns a data frame
class(mtcars[, c("mpg", "cyl")])
# [1] "data.frame"
## single column returns a vector
class(mtcars[, "mpg"])
# [1] "numeric"

इसके चारों ओर दो रास्ते हैं। एक डेटा फ़्रेम को एक सूची (नीचे देखें) के रूप में माना जाता है, दूसरा एक drop = FALSE तर्क जोड़ना है। यह आर को "अप्रयुक्त आयामों को नहीं छोड़ने" के लिए कहता है:

class(mtcars[, "mpg", drop = FALSE])
# [1] "data.frame"

ध्यान दें कि मैट्रीस उसी तरह काम करते हैं - डिफ़ॉल्ट रूप से एक एकल स्तंभ या पंक्ति एक वेक्टर होगी, लेकिन यदि आप drop = FALSE निर्दिष्ट करते हैं तो आप इसे एक-स्तंभ या एक-पंक्ति मैट्रिक्स के रूप में रख सकते हैं।

एक सूची की तरह

डेटा फ़्रेम अनिवार्य रूप से list एस हैं, अर्थात, वे स्तंभ वैक्टर की एक सूची है (कि सभी की लंबाई समान होनी चाहिए)। सूची एकल कोष्ठक के लिए [ उप-सूची के लिए, या दोहरे कोष्ठक [[ एक तत्व के लिए] का उपयोग करके सबसेट हो सकती है।

एकल कोष्ठक data[columns]

जब आप एकल कोष्ठक और कोई अल्पविराम का उपयोग करते हैं, तो आपको स्तंभ वापस मिल जाएगा क्योंकि डेटा फ़्रेम स्तंभों की सूची है।

mtcars["mpg"]
mtcars[c("mpg", "cyl", "disp")]
my_columns <- c("mpg", "cyl", "hp")
mtcars[my_columns]

data[columns] और data[, columns] बीच का अंतर यह है कि जब data.frame को एक list (कोष्ठक में कोई अल्पविराम) के रूप में data.frame जाता है, तो data.frame गई वस्तु data.frame होगी। यदि आप data.frame तरह व्यवहार करने के लिए अल्पविराम का उपयोग करते हैं। matrix तरह तो एकल कॉलम का चयन करने पर एक वेक्टर वापस आ जाएगा लेकिन कई कॉलम का चयन करने से data.frame वापस आ जाएगा।

## When selecting a single column
## like a list will return a data frame
class(mtcars["mpg"])
# [1] "data.frame"
## like a matrix will return a vector
class(mtcars[, "mpg"])
# [1] "numeric"

डबल ब्रैकेट data[[one_column]]

अपने data.frame उपचार करते समय वेक्टर के रूप में एक एकल कॉलम निकालने के लिए। एक list रूप में, आप डबल ब्रैकेट का उपयोग कर सकते हैं [[ । यह एक समय में केवल एक कॉलम के लिए काम करेगा।

# extract a single column by name as a vector 
mtcars[["mpg"]]

# extract a single column by name as a data frame (as above)
mtcars["mpg"]

कॉलम तक पहुंचने के लिए $ का उपयोग करना

एक कॉलम कॉलम नाम का उपयोग किए बिना जादुई शॉर्टकट $ का उपयोग करके एक एकल कॉलम निकाला जा सकता है:

# get the column "mpg"
mtcars$mpg

$ द्वारा एक्सेस किए गए कॉलम हमेशा वैक्टर होंगे, डेटा फ़्रेम नहीं।

कॉलम तक पहुँचने के लिए $ कमियाँ

$ एक सुविधाजनक शॉर्टकट हो सकता है, खासकर यदि आप एक पर्यावरण (जैसे RStudio) में काम कर रहे हैं जो इस मामले में कॉलम नाम को स्वचालित रूप से पूरा करेगा। हालांकि, $ में कमियां भी हैं: यह उद्धरण की आवश्यकता से बचने के लिए गैर-मानक मूल्यांकन का उपयोग करता है, जिसका अर्थ है कि यह काम नहीं करेगा यदि आपका स्तंभ नाम किसी चर में संग्रहीत है।

my_column <- "mpg"
# the below will not work
mtcars$my_column
# but these will work
mtcars[, my_column]  # vector
mtcars[my_column]    # one-column data frame
mtcars[[my_column]]  # vector

इन चिंताओं के कारण, आपके स्तंभ नाम स्थिर होने पर इंटरेक्टिव आर सत्रों में $ का सबसे अच्छा उपयोग किया जाता है। प्रोग्रामेटिक उपयोग के लिए, उदाहरण के लिए, एक सामान्य फ़ंक्शन लिखने में जिसका उपयोग विभिन्न कॉलम नामों के साथ विभिन्न डेटा सेटों पर किया जाएगा, $ से बचा जाना चाहिए।

यह भी ध्यान दें कि डिफ़ॉल्ट व्यवहार का उपयोग केवल आंशिक मिलान का उपयोग करने के लिए किया जाता है जब $ द्वारा पुनरावर्ती वस्तुओं (पर्यावरण को छोड़कर) से निकाला जाता है

# give you the values of "mpg" column 
# as "mtcars" has only one column having name starting with "m"
mtcars$m 
# will give you "NULL" 
# as "mtcars" has more than one columns having name starting with "d"
mtcars$d

उन्नत अनुक्रमण: नकारात्मक और तार्किक सूचकांक

जब भी हमारे पास सूचकांक के लिए संख्याओं का उपयोग करने का विकल्प होता है, तो हम निश्चित संख्याओं या बूलियन (तार्किक) वेक्टर को छोड़ने के लिए ऋणात्मक संख्याओं का उपयोग भी कर सकते हैं ताकि यह इंगित किया जा सके कि किन वस्तुओं को रखना है।

नकारात्मक सूचकांक तत्वों को छोड़ देते हैं

mtcars[1, ]   # first row
mtcars[ -1, ] # everything but the first row
mtcars[-(1:10), ] # everything except the first 10 rows

तार्किक वैक्टर रखने के लिए विशिष्ट तत्वों का संकेत देते हैं

हम एक स्थिति का उपयोग कर सकते हैं जैसे < एक तार्किक वेक्टर उत्पन्न करने के लिए, और केवल उन पंक्तियों को निकालें जो स्थिति को पूरा करती हैं:

# logical vector indicating TRUE when a row has mpg less than 15
# FALSE when a row has mpg >= 15
test <- mtcars$mpg < 15 

# extract these rows from the data frame 
mtcars[test, ]

हम मध्यवर्ती चर को बचाने के चरण को भी बायपास कर सकते हैं

# extract all columns for rows where the value of cyl is 4.
mtcars[mtcars$cyl == 4, ]
# extract the cyl, mpg, and hp columns where the value of cyl is 4
mtcars[mtcars$cyl == 4, c("cyl", "mpg", "hp")]

डेटा.फ्रेम में हेरफेर करने की सुविधा

data.frames में हेरफेर करने के लिए कुछ सुविधा फ़ंक्शंस हैं subset() , transform() , with() और within() ।

सबसेट

subset() फ़ंक्शन आपको अधिक सुविधाजनक तरीके से data.frame को data.frame करने की अनुमति देता है (सबसेट अन्य वर्गों के साथ भी काम करता है):

subset(mtcars, subset = cyl == 6, select = c("mpg", "hp"))
                mpg  hp
Mazda RX4      21.0 110
Mazda RX4 Wag  21.0 110
Hornet 4 Drive 21.4 110
Valiant        18.1 105
Merc 280       19.2 123
Merc 280C      17.8 123
Ferrari Dino   19.7 175

ऊपर दिए गए कोड में हम केवल उन पंक्तियों के लिए पूछ रहे हैं जिनमें cyl == 6 और कॉलम mpg और hp । आप निम्नलिखित कोड के साथ [] का उपयोग करके समान परिणाम प्राप्त कर सकते हैं:

mtcars[mtcars$cyl == 6, c("mpg", "hp")]

परिवर्तन

transform() फ़ंक्शन data.frame अंदर कॉलम बदलने के लिए एक सुविधा फ़ंक्शन है। उदाहरण के लिए निम्न कोड mpg2 के परिणाम के साथ mpg2 नाम का एक और कॉलम जोड़ता है। mtcars data.frame करने के लिए mpg^2 :

mtcars <- transform(mtcars, mpg2 = mpg^2)

साथ और भीतर

दोनों with() और within() आपको data.frame अंदर अभिव्यक्तियों का मूल्यांकन करने data.frame पर्यावरण, कुछ हद तक क्लीनर सिंटैक्स की अनुमति देता है, जिससे आपको कुछ $ या [] का उपयोग करने की बचत होती है।

उदाहरण के लिए, यदि आप airquality data.frame में कई कॉलम बनाना, बदलना और / या निकालना data.frame :

aq <- within(airquality, {     
    lOzone <- log(Ozone) # creates new column
    Month <- factor(month.abb[Month]) # changes Month Column
    cTemp <- round((Temp - 32) * 5/9, 1) # creates new column
    S.cT <- Solar.R / cTemp  # creates new column
    rm(Day, Temp) # removes columns
})

परिचय

डेटा फ़्रेम संभावना डेटा संरचना है जिसका आप अपने विश्लेषणों में सबसे अधिक उपयोग करेंगे। एक डेटा फ्रेम एक विशेष प्रकार की सूची है जो विभिन्न वर्गों के समान-लंबाई वाले वैक्टर को संग्रहीत करती है। आप data.frame फ़ंक्शन का उपयोग करके डेटा फ़्रेम बनाते हैं। नीचे दिया गया उदाहरण एक संख्यात्मक और एक चरित्र वेक्टर को डेटा फ़्रेम में जोड़कर दिखाता है। यह उपयोग करता है : ऑपरेटर, जो 1 से 3 तक सभी पूर्णांकों से युक्त एक वेक्टर बनाएगा।

df1 <- data.frame(x = 1:3, y = c("a", "b", "c"))
df1
##   x y
## 1 1 a
## 2 2 b
## 3 3 c
class(df1)
## [1] "data.frame"

डेटा फ़्रेम ऑब्जेक्ट्स उद्धरण चिह्नों के साथ प्रिंट नहीं करते हैं, इसलिए स्तंभों का वर्ग हमेशा स्पष्ट नहीं होता है।

df2 <- data.frame(x = c("1", "2", "3"), y = c("a", "b", "c"))
df2
##   x y
## 1 1 a
## 2 2 b
## 3 3 c

आगे की जांच के बिना, df1 और df2 में "x" कॉलम को df1 नहीं किया जा सकता है। कक्षा की तुलना में अधिक विस्तार के साथ वस्तुओं का वर्णन करने के लिए str फ़ंक्शन का उपयोग किया जा सकता है।

str(df1)
## 'data.frame':    3 obs. of  2 variables:
##  $ x: int  1 2 3
##  $ y: Factor w/ 3 levels "a","b","c": 1 2 3
str(df2)
## 'data.frame':    3 obs. of  2 variables:
##  $ x: Factor w/ 3 levels "1","2","3": 1 2 3
##  $ y: Factor w/ 3 levels "a","b","c": 1 2 3

यहां आप देखते हैं कि df1 एक data.frame और इसमें 2 चर के 3 अवलोकन हैं, "x" और "y।" फिर आपको बताया जाता है कि "x" में डेटा प्रकार पूर्णांक है (इस वर्ग के लिए महत्वपूर्ण नहीं है, लेकिन हमारे उद्देश्यों के लिए यह एक संख्यात्मक की तरह व्यवहार करता है) और "y" तीन स्तरों वाला एक अन्य कारक है (दूसरे डेटा वर्ग जिसकी हम चर्चा नहीं कर रहे हैं)। यह ध्यान रखना महत्वपूर्ण है कि, डिफ़ॉल्ट रूप से, डेटा फ़्रेम वर्णों को कारकों के साथ जोड़ता है। डिफ़ॉल्ट व्यवहार को stringsAsFactors पैरामीटर के साथ बदला जा सकता है:

df3 <- data.frame(x = 1:3, y = c("a", "b", "c"), stringsAsFactors = FALSE)
str(df3)
## 'data.frame':    3 obs. of  2 variables:
##  $ x: int  1 2 3
##  $ y: chr  "a" "b" "c"

अब "y" कॉलम एक वर्ण है। जैसा कि ऊपर उल्लेख किया गया है, डेटा फ्रेम के प्रत्येक "कॉलम" की लंबाई समान होनी चाहिए। वैक्टर से अलग लंबाई के साथ data.frame बनाने की कोशिश करने के परिणामस्वरूप त्रुटि होगी। (परिणामी त्रुटि को देखने के लिए data.frame(x = 1:3, y = 1:4) चलाने का प्रयास करें।)

डेटा फ़्रेम के लिए परीक्षण-मामलों के रूप में, कुछ डेटा R द्वारा डिफ़ॉल्ट रूप से प्रदान किए जाते हैं। उनमें से एक परितारिका है, इस प्रकार लोड:

mydataframe <- iris
str(mydataframe)

किसी सूची में संग्रहीत डेटा को do.call का उपयोग करके एकल डेटा फ़्रेम में कनवर्ट करें

यदि आपके पास आपका डेटा किसी सूची में संग्रहीत है और आप इस सूची को डेटा फ़्रेम में परिवर्तित करना चाहते हैं तो do.call फ़ंक्शन इसे प्राप्त करने का एक आसान तरीका है। हालांकि, यह महत्वपूर्ण है कि मूल्यों की अनपेक्षित रीसाइक्लिंग को रोकने के लिए सभी सूची तत्वों की लंबाई समान है।

dataList  <- list(1:3,4:6,7:9)  
dataList
# [[1]]
# [1] 1 2 3
#
# [[2]]
# [1] 4 5 6
#
# [[3]]
# [1] 7 8 9

dataframe <- data.frame(do.call(rbind, dataList))
dataframe
#   X1 X2 X3
# 1  1  2  3
# 2  4  5  6
# 3  7  8  9 

यह भी काम करता है अगर आपकी सूची में डेटा फ़्रेम ही होते हैं।

dataframeList  <- list(data.frame(a = 1:2, b = 1:2, c = 1:2), 
                       data.frame(a = 3:4, b = 3:4, c = 3:4))
dataframeList
# [[1]]
#   a b c
# 1 1 1 1
# 2 2 2 2

# [[2]]
#   a b c
# 1 3 3 3
# 2 4 4 4

dataframe      <- do.call(rbind, dataframeList)
dataframe
#   a b c
# 1 1 1 1
# 2 2 2 2
# 3 3 3 3
# 4 4 4 4

Data.frame के सभी स्तंभों को वर्ण वर्ग में बदलें

एक सामान्य कार्य हेरफेर में आसानी के लिए data.frame के सभी स्तंभों को वर्ण वर्ग में बदलना है, जैसे कि RDBMS में data.frames भेजने या data. वर्कफ़्लो को मर्ज करने के मामलों में, जहां इनपुट डेटा के बीच स्तर भिन्न हो सकते हैं। ।

लगभग सभी इनपुट विधि बनाने कि डेटा फ्रेम एक विकल्प हैं - यह करने के लिए सबसे अच्छा समय है जब डेटा में पढ़ा है stringsAsFactors जो करने के लिए सेट किया जा सकता है FALSE ।

यदि डेटा पहले से ही बनाया गया है, तो कारक कॉलम को वर्ण स्तंभों में परिवर्तित किया जा सकता है जैसा कि नीचे दिखाया गया है।

bob <- data.frame(jobs = c("scientist", "analyst"), 
                  pay  = c(160000, 100000), age = c(30, 25))
str(bob)

'data.frame':    2 obs. of  3 variables:
 $ jobs: Factor w/ 2 levels "analyst","scientist": 2 1
 $ pay : num  160000 100000
 $ age : num  30 25

# Convert *all columns* to character
bob[] <- lapply(bob, as.character)
str(bob)

    'data.frame':    2 obs. of  3 variables:
 $ jobs: chr  "scientist" "analyst"
 $ pay : chr  "160000" "1e+05"
 $ age : chr  "30" "25"

# Convert only factor columns to character
bob[] <- lapply(bob, function(x) {
    if is.factor(x) x <- as.character(x)
    return(x)
})

कॉलम मूल्यों द्वारा सबसेटिंग पंक्तियाँ

फ़ंक्शंस में निर्मित columns उन rows साथ rows को कम कर सकते columns जो शर्तों को पूरा करते हैं।

df <- data.frame(item = c(1:10),
                 price_Elasticity = c(-0.57667, 0.03205, -0.04904, 0.10342, 0.04029, 
                                       0.0742, 0.1669, 0.0313, 0.22204, 0.06158),
                 total_Margin = c(-145062, 98671, 20576, -56382, 207623, 43463, 1235, 
                                   34521, 146553, -74516))

price_Elasticity > 0 साथ rows को खोजने के लिए:

df[df$price_Elasticity > 0, ]

   item price_Elasticity total_Margin
2     2          0.03205        98671
4     4          0.10342       -56382
5     5          0.04029       207623
6     6          0.07420        43463
7     7          0.16690         1235
8     8          0.03130        34521
9     9          0.22204       146553
10   10          0.06158       -74516

सबसे अच्छी कीमत के आधार पर price_Elasticity > 0 और total_Margin > 0 :

df[df$price_Elasticity > 0 & df$total_Margin > 0, ]

  item price_Elasticity total_Margin
2    2          0.03205        98671
5    5          0.04029       207623
6    6          0.07420        43463
7    7          0.16690         1235
8    8          0.03130        34521
9    9          0.22204       146553