R Language
वैक्टर बनाना

संख्या का अनुक्रम

उपयोग करें : संख्याओं के अनुक्रम बनाने के लिए ऑपरेटर, जैसे कि आपके कोड के बड़े हिस्से को वेक्टर करने में उपयोग के लिए:

x <- 1:5
x
## [1] 1 2 3 4 5

यह दोनों तरह से काम करता है

10:4
# [1] 10  9  8  7  6  5  4

और फ्लोटिंग पॉइंट नंबरों के साथ भी

1.25:5
# [1] 1.25 2.25 3.25 4.25

या नकारात्मक

-4:4
#[1] -4 -3 -2 -1  0  1  2  3  4

सेक ()

seq एक अधिक लचीला कार्य है : ऑपरेटर को 1 के अलावा अन्य चरणों को निर्दिष्ट करने की अनुमति देता है।

फ़ंक्शन start से एक क्रम बनाता है (डिफ़ॉल्ट 1 है) उस नंबर सहित अंत तक।

आप केवल अंतिम ( to ) पैरामीटर की आपूर्ति कर सकते हैं

seq(5)
# [1] 1 2 3 4 5

साथ ही शुरुआत भी

seq(2, 5) # or seq(from=2, to=5)
# [1] 2 3 4 5

और अंत में कदम ( by )

seq(2, 5, 0.5) # or seq(from=2, to=5, by=0.5)
# [1] 2.0 2.5 3.0 3.5 4.0 4.5 5.0

जब वैकल्पिक रूप से आउटपुट की वांछित लंबाई ( length.out ) की आपूर्ति की जाती है, तो seq वैकल्पिक रूप से (समान रूप से length.out ) चरणों का अनुमान लगा सकता है

seq(2,5, length.out = 10)
# [1] 2.0 2.3 2.6 2.9 3.2 3.5 3.8 4.1 4.4 4.7 5.0

अनुक्रम की जरूरत है एक और वेक्टर के रूप में एक ही लंबाई के लिए अगर हम उपयोग कर सकते हैं along.with के लिए एक आशुलिपि के रूप में length.out = length(x)

x = 1:8
seq(2,5,along.with = x)
# [1] 2.000000 2.428571 2.857143 3.285714 3.714286 4.142857 4.571429 5.000000

वहाँ में दो उपयोगी सरलीकृत कार्य हैं seq : परिवार seq_along , seq_len , और seq.int । seq_along और seq_len कार्यों एन 1 से जहां एन समारोह तर्क, एक वेक्टर या के साथ सूची की लंबाई से निर्धारित होता है से प्राकृतिक (बढ़ रहा है) संख्याएं बनाने seq_along , और साथ पूर्णांक तर्क seq_len ।

seq_along(x)
# [1] 1 2 3 4 5 6 7 8

ध्यान दें कि seq_along किसी मौजूदा वस्तु के सूचकांकों को लौटाता है।

# counting numbers 1 through 10
seq_len(10)
[1]  1  2  3  4  5  6  7  8  9 10
# indices of existing vector (or list) with seq_along
letters[1:10]
[1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j"
seq_along(letters[1:10])
[1]  1  2  3  4  5  6  7  8  9 10

seq.int वही है जो प्राचीन संगतता के लिए seq बनाए रखा है।

एक पुराना फ़ंक्शन sequence भी है जो एक गैर नकारात्मक तर्क से अनुक्रमों का एक वेक्टर बनाता है।

sequence(4)
# [1] 1 2 3 4
sequence(c(3, 2))
# [1] 1 2 3 1 2
sequence(c(3, 2, 5))
# [1] 1 2 3 1 2 1 2 3 4 5

वैक्टर

R में वैक्टर अलग-अलग प्रकार के हो सकते हैं (जैसे पूर्णांक, तार्किक, वर्ण)। वेक्टर को परिभाषित करने का सबसे सामान्य तरीका फ़ंक्शन vector() का उपयोग करके है।

vector('integer',2) # creates a vector of integers of size 2.
vector('character',2) # creates a vector of characters of size 2.
vector('logical',2) # creates a vector of logicals of size 2.

हालांकि, आर में, शॉर्टहैंड फ़ंक्शन आमतौर पर अधिक लोकप्रिय हैं।

integer(2) # is the same as vector('integer',2) and creates an integer vector with two elements
character(2) # is the same as vector('integer',2) and creates an character vector with two elements
logical(2) # is the same as vector('logical',2) and creates an logical vector with two elements

डिफ़ॉल्ट मानों के अलावा मानों के साथ वैक्टर बनाना भी संभव है। अक्सर फ़ंक्शन c() का उपयोग इसके लिए किया जाता है। कॉम्बिनेशन या कॉन्टेनेट के लिए c छोटा है।

c(1, 2) # creates a integer vector of two elements: 1 and 2.
c('a', 'b') # creates a character vector of two elements: a and b.
c(T,F) # creates a logical vector of two elements: TRUE and FALSE.

यहां ध्यान रखना महत्वपूर्ण है कि R किसी भी पूर्णांक (जैसे 1) की व्याख्या एक आकार के पूर्णांक वेक्टर के रूप में करता है। एक ही अंक (जैसे 1.1), तार्किक (जैसे टी या एफ), या वर्ण (जैसे 'ए') के लिए है। इसलिए, आप सार संयोजनों में वैक्टर हैं, जो बदले में वैक्टर हैं।

ध्यान दें कि आपको हमेशा समान वैक्टर को संयोजित करना होगा। अन्यथा, आर एक ही प्रकार के वैक्टर में वैक्टर को बदलने की कोशिश करेगा।

c(1,1.1,'a',T) # all types (integer, numeric, character and logical) are converted to the 'lowest' type which is character.

वैक्टर में तत्वों को खोजना [ संचालक] के साथ किया जा सकता है।

vec_int <- c(1,2,3)
vec_char <- c('a','b','c')
vec_int[2] # accessing the second element will return 2
vec_char[2] # accessing the second element will return 'b'

इसका उपयोग मूल्यों को बदलने के लिए भी किया जा सकता है

vec_int[2] <- 5 # change the second value from 2 to 5
vec_int # returns [1] 1 5 3

अंत में : ऑपरेटर (फ़ंक्शन seq() लिए संक्षिप्त) का उपयोग जल्दी से संख्याओं के वेक्टर बनाने के लिए किया जा सकता है।

vec_int <- 1:10
vec_int # returns [1] 1 2 3 4 5 6 7 8 9 10

यह वैक्टर को कम करने के लिए भी इस्तेमाल किया जा सकता है (आसान से अधिक जटिल सबसेट तक)

vec_char <- c('a','b','c','d','e')
vec_char[2:4] # returns [1] "b" "c" "d"
vec_char[c(1,3,5)] # returns [1] "a" "c" "e"

वैक्टर नाम का बनाना

नामित वेक्टर को कई तरीकों से बनाया जा सकता है। c साथ:

xc <- c('a' = 5, 'b' = 6, 'c' = 7, 'd' = 8)

जिसके परिणामस्वरूप:

> xc
a b c d 
5 6 7 8

list साथ:

xl <- list('a' = 5, 'b' = 6, 'c' = 7, 'd' = 8)

जिसके परिणामस्वरूप:

> xl
$a
[1] 5

$b
[1] 6

$c
[1] 7

$d
[1] 8

setNames फ़ंक्शन के साथ, एक ही लंबाई के दो वैक्टर का उपयोग एक नामित वेक्टर बनाने के लिए किया जा सकता है:

x <- 5:8
y <- letters[1:4]

xy <- setNames(x, y)

जिसका नाम पूर्णांक वेक्टर है:

> xy
a b c d 
5 6 7 8

जैसा कि देखा जा सकता है, यह c विधि के समान परिणाम देता है।

आप परिणाम प्राप्त करने के लिए names फ़ंक्शन का उपयोग भी कर सकते हैं:

xy <- 5:8
names(xy) <- letters[1:4]

इस तरह के एक वेक्टर के साथ नाम से तत्वों का चयन करना संभव है:

> xy["c"]
c 
7 

यह सुविधा ऐसे नामांकित वेक्टर का उपयोग डेटाफ़्रेम में किसी अन्य वेक्टर या स्तंभ के मूल्यों से मेल खाने के लिए लुक-अप वेक्टर / टेबल के रूप में करना संभव बनाती है। निम्नलिखित डेटाफ़्रेम को ध्यान में रखते हुए:

mydf <- data.frame(let = c('c','a','b','d'))

> mydf
  let
1   c
2   a
3   b
4   d

मान लें कि आप पंक्तियों में xy से सही मानों के साथ num नामक mydf में एक नया चर बनाना चाहते हैं। match फ़ंक्शन का उपयोग करके xy से उपयुक्त मानों का चयन किया जा सकता है:

mydf$num <- xy[match(mydf$let, names(xy))]

जिसके परिणामस्वरूप:

> mydf
  let num
1   c   7
2   a   5
3   b   6
4   d   8

रेप () फ़ंक्शन के साथ एक वेक्टर का विस्तार करना

rep फ़ंक्शन का उपयोग वेक्टर को काफी लचीले तरीके से दोहराने के लिए किया जा सकता है।

# repeat counting numbers, 1 through 5 twice
rep(1:5, 2)
[1] 1 2 3 4 5 1 2 3 4 5

# repeat vector with incomplete recycling
rep(1:5, 2, length.out=7)
[1] 1 2 3 4 5 1 2

प्रत्येक तर्क विशेष रूप से इन इकाइयों के बार-बार टिप्पणियों के साथ डेटा.फ्रेम के वेक्टर में अवलोकन / प्रयोगात्मक इकाइयों के आंकड़ों के एक वेक्टर के विस्तार के लिए उपयोगी है।

# same except repeat each integer next to each other
rep(1:5, each=2)
[1] 1 1 2 2 3 3 4 4 5 5

ऐसी डेटा संरचना के विस्तार को शामिल करने के बारे में rep की एक अच्छी विशेषता यह है कि एक वेक्टर का असंतुलित पैनल में विस्तार एक वेक्टर के साथ लंबाई तर्क को प्रतिस्थापित करके पूरा किया जा सकता है जो वेक्टर में प्रत्येक तत्व को दोहराने के लिए कई बार निर्धारित करता है:

# automated length repetition
rep(1:5, 1:5)
 [1] 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
# hand-fed repetition length vector
rep(1:5, c(1,1,1,2,2))
[1] 1 2 3 4 4 5 5

डेटा के अनुसार विस्तार करने वाले वेक्टर को गतिशील रूप से बनाने के लिए किसी बाहरी फ़ंक्शन को rep के दूसरे तर्क को खिलाने की अनुमति देने की संभावना को उजागर करना चाहिए।

साथ के रूप में seq , तेज, का सरलीकृत संस्करण rep कर रहे हैं rep_len और rep.int । ये कुछ गुण ड्रॉप कि rep का कहना है और इसलिए स्थितियों में, जहां गति है एक चिंता का विषय है और बार-बार वेक्टर के अतिरिक्त पहलुओं अनावश्यक हैं में सबसे अधिक उपयोगी हो सकता है।

# repeat counting numbers, 1 through 5 twice
rep.int(1:5, 2)
[1] 1 2 3 4 5 1 2 3 4 5

# repeat vector with incomplete recycling
rep_len(1:5, length.out=7)
[1] 1 2 3 4 5 1 2

बिल्डरों में स्थिरांक से: पत्र और महीने के नाम के अनुक्रम

R स्थिरांक में निर्माण की एक संख्या है। निम्नलिखित स्थिरांक उपलब्ध हैं:

• LETTERS : रोमन वर्णमाला के 26 ऊपरी-केस पत्र
• letters : रोमन वर्णमाला के 26 निचले मामले पत्र
• month.abb : अंग्रेजी महीने के नाम के लिए तीन अक्षर का संक्षिप्त नाम
• month.name : वर्ष के महीनों के लिए अंग्रेजी नाम
• pi : इसके व्यास के लिए एक वृत्त की परिधि का अनुपात

अक्षरों और महीने के स्थिरांक से, वैक्टर बनाए जा सकते हैं।

1) पत्रों के अनुक्रम:

> letters
[1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z"

> LETTERS[7:9]
[1] "G" "H" "I"

> letters[c(1,5,3,2,4)]
[1] "a" "e" "c" "b" "d"

2) महीने के संक्षिप्त या महीने के नाम के अनुक्रम:

> month.abb
 [1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"

> month.name[1:4]
[1] "January"  "February" "March"    "April"   

> month.abb[c(3,6,9,12)]
[1] "Mar" "Jun" "Sep" "Dec"