一.R環(huán)境設置

嘗試在線環(huán)境

你真的不需要設置自己的環(huán)境來開始學習R編程語言县忌。 原因很簡單，我們已經(jīng)在線設置了R編程環(huán)境继效，以便您可以在進行理論工作的同時在線編譯和執(zhí)行所有可用的示例症杏。 這給你對你正在閱讀的信心，并用不同的選項檢查結果瑞信。 隨意修改任何示例并在線執(zhí)行厉颤。
實例：

# Print Hello World. 
print("Hello World") 
 
# Add two numbers. 
print(23.9 + 11.6)

Windows安裝

您可以從R-3.2.2 for Windows（32/64位）下載R的Windows安裝程序版本，并將其保存在本地目錄中凡简。

因為它是一個名為“R-version-win.exe”的Windows安裝程序（.exe）逼友。 您只需雙擊并運行安裝程序接受默認設置即可。 如果您的Windows是32位版本秤涩，它將安裝32位版本翁逞。 但是如果你的窗口是64位，那么它安裝32位和64位版本溉仑。

安裝后挖函，您可以找到該圖標，以在Windows程序文件下的目錄結構“R \ R3.2.2 \ bin \ i386 \ Rgui.exe”中運行程序浊竟。 單擊此圖標會打開R-GUI怨喘，它是R控制臺來執(zhí)行R編程。

Linux安裝

R語言適用于多版本的Linux系統(tǒng)振定。

各版本Linux的各有不同必怜。具體的安裝步驟在上述資源中有對應的教程。但是后频，如果你是在趕時間梳庆，那么你可以用yum命令暖途，如下所示的安裝指令
安裝R

$ yum install R

以上命令將安裝R編程的核心功能與標準包，額外的包需要另外安裝膏执，而后你可以按如下提示啟動R驻售。

$ R

R version 3.2.0 (2015-04-16) -- "Full of  Ingredients"          
Copyright (C) 2015 The R Foundation for Statistical Computing
Platform: x86_64-redhat-linux-gnu (64-bit)
        
R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.
            
R is a collaborative project with many  contributors.                    
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

>  

現(xiàn)在，您可以在R語言提示符下使用install命令安裝所需的軟件包更米。 例如欺栗，以下命令將安裝為3D圖表所需的plotrix軟件包。

> install.packages("plotrix")

二.R語言 基本語法

命令提示符

如果你已經(jīng)配置好R語言環(huán)境征峦，那么你只需要按一下的命令便可輕易開啟命令提示符

$ R

這將啟動R語言解釋器迟几，你會得到一個提示 > 在那里你可以開始輸入你的程序，具體如下栏笆。

> myString <- "Hello, World!"
> print ( myString)
[1] "Hello, World!"

在這里类腮，第一個語句先定義一個字符串變量myString，并將“Hello蛉加，World蚜枢！”賦值其中，第二句則使用print()語句將變量myString的內容進行打印七婴。

腳本文件

通常祟偷，您將通過在腳本文件中編寫程序來執(zhí)行編程，然后在命令提示符下使用R解釋器（稱為Rscript）來執(zhí)行這些腳本打厘。 所以讓我們開始在一個命名為test.R的文本文件中編寫下面的代碼

# My first program in R Programming
myString <- "Hello, World!"

print ( myString)

將上述代碼保存在test.R文件中修肠，并在Linux命令提示符下執(zhí)行，如下所示户盯。 即使您使用的是Windows或其他系統(tǒng)嵌施，語法也將保持不變。

$ Rscript test.R 

當我們運行上面的程序莽鸭，它產(chǎn)生以下結果吗伤。

[1] "Hello, World!"

注釋

注釋能幫助您解釋R語言程序中的腳本，它們在實際執(zhí)行程序時會被解釋器忽略硫眨。 單個注釋使用＃在語句的開頭寫入足淆，如下所示

# My first program in R Programming

R語言不支持多行注釋，但你可以使用一個小技巧礁阁，如下

if(FALSE) {
   "This is a demo for multi-line comments and it should be put inside either a single
      OR double quote"
}

myString <- "Hello, World!"
print ( myString)

雖然上面的注釋將由R解釋器執(zhí)行巧号，但它們不會干擾您的實際程序。 但是你必須為內容加上單引號或雙引號姥闭。

三.數(shù)據(jù)結構

通常丹鸿，在使用任何編程語言進行編程時，您需要使用各種變量來存儲各種信息棚品。 變量只是保留值的存儲位置靠欢。 這意味著廊敌，當你創(chuàng)建一個變量，你必須在內存中保留一些空間來存儲它們门怪。

您可能想存儲各種數(shù)據(jù)類型的信息骡澈，如字符，寬字符薪缆，整數(shù)秧廉，浮點伞广，雙浮點拣帽，布爾等〗莱基于變量的數(shù)據(jù)類型减拭，操作系統(tǒng)分配內存并決定什么可以存儲在保留內存中。

與其他編程語言（如C中的C和java）相反区丑，變量不會聲明為某種數(shù)據(jù)類型拧粪。 變量分配有R對象，R對象的數(shù)據(jù)類型變?yōu)樽兞康臄?shù)據(jù)類型沧侥。盡管有很多類型的R對象可霎，但經(jīng)常使用的是：

• 矢量
• 列表
• 矩陣
• 數(shù)組
• 因子
• 數(shù)據(jù)幀
  這些對象中最簡單的是向量對象，并且這些原子向量有六種數(shù)據(jù)類型宴杀，也稱為六類向量癣朗。 其他R對象建立在原子向量之上。
• Logical（邏輯型）：TRUE, FALSE
• Numeric（數(shù)字） 12.3旺罢，5旷余，999
• Integer（整型） 2L，34L扁达，0L
• Complex（復合型） 3 + 2i
• Character（字符） 'a' , '"good", "TRUE", '23.4'
• Raw（原型） "Hello" 被存儲為 48 65 6c 6c 6f
  在R編程中正卧，非常基本的數(shù)據(jù)類型是稱為向量的R對象跪解，其保存如上所示的不同類的元素炉旷。 請注意，在R中叉讥，類的數(shù)量不僅限于上述六種類型窘行。 例如，我們可以使用許多原子向量并創(chuàng)建一個數(shù)組节吮，其類將成為數(shù)組抽高。

Vectors 向量

當你想用多個元素創(chuàng)建向量時，你應該使用c()函數(shù)透绩，這意味著將元素組合成一個向量翘骂。

# Create a vector.
apple <- c('red','green',"yellow")
print(apple)

# Get the class of the vector.
print(class(apple))

當我們執(zhí)行上面的代碼壁熄，它產(chǎn)生以下結果

[1] "red"    "green"  "yellow"
[1] "character"

Lists 列表

列表是一個R對象，它可以在其中包含許多不同類型的元素碳竟，如向量草丧，函數(shù)甚至其中的另一個列表。

# Create a list.
list1 <- list(c(2,5,3),21.3,sin)

# Print the list.
print(list1)

當我們執(zhí)行上面的代碼莹桅，它產(chǎn)生以下結果

[[1]]
[1] 2 5 3

[[2]]
[1] 21.3

[[3]]
function (x)  .Primitive("sin")
### Matrices 矩陣

矩陣是二維矩形數(shù)據(jù)集昌执。 它可以使用矩陣函數(shù)的向量輸入創(chuàng)建。

# Create a matrix.
M = matrix( c('a','a','b','c','b','a'), nrow = 2, ncol = 3, byrow = TRUE)
print(M)

當我們執(zhí)行上面的代碼诈泼，它產(chǎn)生以下結果

     [,1] [,2] [,3]
[1,] "a"  "a"  "b" 
[2,] "c"  "b"  "a"

Arrays 數(shù)組

雖然矩陣被限制為二維懂拾，但陣列可以具有任何數(shù)量的維度辣卒。 數(shù)組函數(shù)使用一個dim屬性創(chuàng)建所需的維數(shù)庭再。 在下面的例子中凳宙，我們創(chuàng)建了一個包含兩個元素的數(shù)組兴猩，每個元素為3x3個矩陣浅缸。

# Create an array.
a <- array(c('green','yellow'),dim = c(3,3,2))
print(a)

當我們執(zhí)行上面的代碼卖漫，它產(chǎn)生以下結果

, , 1

     [,1]     [,2]     [,3]    
[1,] "green"  "yellow" "green" 
[2,] "yellow" "green"  "yellow"
[3,] "green"  "yellow" "green" 

, , 2

     [,1]     [,2]     [,3]    
[1,] "yellow" "green"  "yellow"
[2,] "green"  "yellow" "green" 
[3,] "yellow" "green"  "yellow"  

Factors 因子

因子是使用向量創(chuàng)建的r對象柑船。 它將向量與向量中元素的不同值一起存儲為標簽澎怒。 標簽總是字符杭抠，不管它在輸入向量中是數(shù)字還是字符或布爾等脸甘。 它們在統(tǒng)計建模中非常有用。
使用factor()函數(shù)創(chuàng)建因子偏灿。nlevels函數(shù)給出級別計數(shù)丹诀。

# Create a vector.
apple_colors <- c('green','green','yellow','red','red','red','green')

# Create a factor object.
factor_apple <- factor(apple_colors)

# Print the factor.
print(factor_apple)
print(nlevels(factor_apple))

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果

[1] green  green  yellow red    red    red    yellow green 
Levels: green red yellow
# applying the nlevels function we can know the number of distinct values
[1] 3

Data Frames 數(shù)據(jù)幀

數(shù)據(jù)幀是表格數(shù)據(jù)對象菩混。 與數(shù)據(jù)幀中的矩陣不同忿墅，每列可以包含不同的數(shù)據(jù)模式。 第一列可以是數(shù)字沮峡，而第二列可以是字符疚脐，第三列可以是邏輯的。 它是等長度的向量的列表邢疙。
使用data.frame()函數(shù)創(chuàng)建數(shù)據(jù)幀棍弄。

# Create the data frame.
BMI <-  data.frame(
   gender = c("Male", "Male","Female"), 
   height = c(152, 171.5, 165), 
   weight = c(81,93, 78),
   Age = c(42,38,26)
)
print(BMI)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果

  gender height weight Age
1   Male  152.0     81  42
2   Male  171.5     93  38
3 Female  165.0     78  26  

四.變量

變量為我們提供了我們的程序可以操作的命名存儲疟游。 R語言中的變量可以存儲原子向量呼畸，原子向量組或許多Robject的組合。 有效的變量名稱由字母颁虐，數(shù)字和點或下劃線字符組成蛮原。 變量名以字母或不以數(shù)字后跟的點開頭。
注：有字母另绩，數(shù)字儒陨，點和下劃線花嘶，其中只能字母開頭

變量賦值

可以使用向左，向右和等于運算符來為變量分配值蹦漠。 可以使用print()或cat()函數(shù)打印變量的值椭员。 cat()函數(shù)將多個項目組合成連續(xù)打印輸出。

# Assignment using equal operator.
var.1 = c(0,1,2,3)           

# Assignment using leftward operator.
var.2 <- c("learn","R")   

# Assignment using rightward operator.   
c(TRUE,1) -> var.3           

print(var.1)
cat ("var.1 is ", var.1 ,"
")
cat ("var.2 is ", var.2 ,"
")
cat ("var.3 is ", var.3 ,"
")

當我們執(zhí)行上面的代碼笛园，它產(chǎn)生以下結果 -

[1] 0 1 2 3
var.1 is  0 1 2 3 
var.2 is  learn R 
var.3 is  1 1 

注 - 向量c（TRUE隘击，1）具有邏輯和數(shù)值類的混合。 因此研铆，邏輯類強制轉換為數(shù)字類埋同，使TRUE為1。

變量的數(shù)據(jù)類型

在R語言中蚜印，變量本身沒有聲明任何數(shù)據(jù)類型莺禁，而是獲取分配給它的R - 對象的數(shù)據(jù)類型留量。 所以R稱為動態(tài)類型語言窄赋，這意味著我們可以在程序中使用同一個變量時，一次又一次地更改變量的數(shù)據(jù)類型楼熄。

var_x <- "Hello"
cat("The class of var_x is ",class(var_x),"
")

var_x <- 34.5
cat("  Now the class of var_x is ",class(var_x),"
")

var_x <- 27L
cat("   Next the class of var_x becomes ",class(var_x),"
")

當我們執(zhí)行上面的代碼忆绰，它產(chǎn)生以下結果 -

The class of var_x is  character 
   Now the class of var_x is  numeric 
      Next the class of var_x becomes  integer

查找變量

要知道工作空間中當前可用的所有變量，我們使用ls()函數(shù)可岂。 ls()函數(shù)也可以使用模式來匹配變量名错敢。

print(ls())

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

[1] "my var"     "my_new_var" "my_var"     "var.1"      
[5] "var.2"      "var.3"      "var.name"   "var_name2."
[9] "var_x"      "varname" 

注意 - 它是一個示例輸出缕粹，取決于在您的環(huán)境中聲明的變量稚茅。
ls()函數(shù)可以使用模式來匹配變量名。
ls()函數(shù)可以使用模式來匹配變量名平斩。

# List the variables starting with the pattern "var".
print(ls(pattern = "var"))   

當我們執(zhí)行上面的代碼亚享，它產(chǎn)生以下結果 -

[1] "my var"     "my_new_var" "my_var"     "var.1"      
[5] "var.2"      "var.3"      "var.name"   "var_name2."
[9] "var_x"      "varname"    

以點(.)開頭的變量被隱藏，它們可以使用ls()函數(shù)的“all.names = TRUE”參數(shù)列出绘面。

print(ls(all.name = TRUE))

當我們執(zhí)行上面的代碼欺税，它產(chǎn)生以下結果 -

[1] ".cars"        ".Random.seed" ".var_name"    ".varname"     ".varname2"   
[6] "my var"       "my_new_var"   "my_var"       "var.1"        "var.2"        
[11]"var.3"        "var.name"     "var_name2."   "var_x"  

刪除變量

可以使用rm()函數(shù)刪除變量。 下面我們刪除變量var.3揭璃。 打印時晚凿，拋出變量錯誤的值。

rm(var.3)
print(var.3)

當我們執(zhí)行上面的代碼瘦馍，它產(chǎn)生以下結果 -

[1] "var.3"
Error in print(var.3) : object 'var.3' not found

所有的變量可以通過使用rm()和ls()函數(shù)一起刪除歼秽。

rm(list = ls())
print(ls())

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

character(0)

五.運算符

運算符是一個符號情组，通知編譯器執(zhí)行特定的數(shù)學或邏輯操作燥筷。 R語言具有豐富的內置運算符扛吞，并提供以下類型的運算符。

運算符的類型

R語言中擁有如下幾種運算符類型：

• 算術運算符
• 關系運算符
• 邏輯運算符
• 賦值運算符
• 其他運算符
• 算術運算符
  下表顯示了R語言支持的算術運算符荆责。 操作符對向量的每個元素起作用滥比。
  除了加減乘除
• %% 兩個向量求余
• ％/％ 兩個向量相除求商
• ^ 將第二向量作為第一向量的指數(shù)

關系運算符

即大于小于等于以及不等于

邏輯運算符

下表顯示了R語言支持的邏輯運算符。 它只適用于邏輯做院，數(shù)字或復雜類型的向量盲泛。 所有大于1的數(shù)字被認為是邏輯值TRUE。
將第一向量的每個元素與第二向量的相應元素進行比較键耕。 比較的結果是布爾值寺滚。

• & 它被稱為元素邏輯AND運算符。 它將第一向量的每個元素與第二向量的相應元素組合屈雄，并且如果兩個元素都為TRUE村视，則給出輸出TRUE。
• | 它被稱為元素邏輯或運算符酒奶。 它將第一向量的每個元素與第二向量的相應元素組合蚁孔，并且如果元素為真，則給出輸出TRUE惋嚎。
• ! 它被稱為邏輯非運算符杠氢。 取得向量的每個元素，并給出相反的邏輯值另伍。
  邏輯運算符&&和|| 只考慮向量的第一個元素鼻百，給出單個元素的向量作為輸出。
• && 稱為邏輯AND運算符摆尝。 取兩個向量的第一個元素温艇，并且只有兩個都為TRUE時才給出TRUE。
• || 稱為邏輯OR運算符堕汞。 取兩個向量的第一個元素勺爱，如果其中一個為TRUE，則給出TRUE臼朗。

賦值運算符

這些運算符用于向向量賦值邻寿。

• <? or = or <<? 稱為左分配
• -> or ->> 稱為右分配

其他運算符

這些運算符用于特定目的，而不是一般的數(shù)學或邏輯計算视哑。

• : 冒號運算符绣否。 它為向量按順序創(chuàng)建一系列數(shù)字。
• %in% 此運算符用于標識元素是否屬于向量挡毅。
• %*% 此運算符用于將矩陣與其轉置相乘蒜撮。

六.決策

決策結構要求程序員指定要由程序評估或測試的一個或多個條件，以及如果條件被確定為真則要執(zhí)行的一個或多個語句，如果條件為假則執(zhí)行其他語句段磨。

以下是在大多數(shù)編程語言中的典型決策結構的一般形式

做決定

R提供以下類型的決策語句取逾。 單擊以下鏈接以檢查其詳細信息。

• if語句

if語句由一個布爾表達式后跟一個或多個語句組成苹支。

• if ... else語句

if語句后面可以有一個可選的else語句砾隅，當布爾表達式為false時執(zhí)行。

• switch語句

switch語句允許根據(jù)值列表測試變量的相等性债蜜。

七.包

R語言的包是R函數(shù)晴埂，編譯代碼和樣本數(shù)據(jù)的集合。 它們存儲在R語言環(huán)境中名為“l(fā)ibrary”的目錄下寻定。 默認情況下儒洛，R語言在安裝期間安裝一組軟件包。 隨后添加更多包狼速，當它們用于某些特定目的時琅锻。 當我們啟動R語言控制臺時，默認情況下只有默認包可用向胡。 已經(jīng)安裝的其他軟件包必須顯式加載以供將要使用它們的R語言程序使用恼蓬。

所有可用的R語言包都列在R語言的包。
下面是用于檢查捷枯，驗證和使用R包的命令列表滚秩。

檢查可用R語言的包

獲取包含R包的庫位置

.libPaths()

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果淮捆。 它可能會根據(jù)您的電腦的本地設置而有所不同。

[2] "C:/Program Files/R/R-3.2.2/library"

獲取已安裝的所有軟件包列表

library()

當我們執(zhí)行上面的代碼本股，它產(chǎn)生以下結果攀痊。 它可能會根據(jù)您的電腦的本地設置而有所不同。

Packages in library ‘C:/Program Files/R/R-3.2.2/library’:

base                    The R Base Package
boot                    Bootstrap Functions (Originally by Angelo Canty
                        for S)
class                   Functions for Classification
cluster                 "Finding Groups in Data": Cluster Analysis
                        Extended Rousseeuw et al.
codetools               Code Analysis Tools for R
compiler                The R Compiler Package

獲取當前在R環(huán)境中加載的所有包

search()

當我們執(zhí)行上述代碼時拄显，它產(chǎn)生了以下結果苟径。它會根據(jù)你的個人電腦的本地設置而異。

[1] ".GlobalEnv"        "package:stats"     "package:graphics" 
[4] "package:grDevices" "package:utils"     "package:datasets" 
[7] "package:methods"   "Autoloads"         "package:base" 

安裝一個新的軟件包

有兩種方法來添加新的R包躬审。 一個是直接從CRAN目錄安裝棘街，另一個是將軟件包下載到本地系統(tǒng)并手動安裝它。

直接從CRAN安裝

以下命令直接從CRAN網(wǎng)頁獲取軟件包承边，并將軟件包安裝在R環(huán)境中遭殉。 可能會提示您選擇最近的鏡像。 根據(jù)您的位置選擇一個博助。

# Install the package named "XML".
 install.packages("XML")

手動安裝包

轉到鏈接R Packages下載所需的包险污。 將包作為.zip文件保存在本地系統(tǒng)中的適當位置。
現(xiàn)在您可以運行以下命令在R環(huán)境中安裝此軟件包。

# Install the package named "XML"
install.packages("E:/XML_3.98-1.3.zip", repos = NULL, type = "source")

裝載包到庫中

在包可以在代碼中使用之前蛔糯，必須將其加載到當前R環(huán)境中拯腮。 您還需要加載先前已安裝但在當前環(huán)境中不可用的軟件包。

使用以下命令加載包：

library("package Name", lib.loc = "path to library")

# Load the package named "XML"
install.packages("E:/XML_3.98-1.3.zip", repos = NULL, type = "source")

九.循環(huán)

可能有一種情況蚁飒，當你需要執(zhí)行一段代碼幾次动壤。 通常，順序執(zhí)行語句淮逻。 首先執(zhí)行函數(shù)中的第一個語句狼电，然后執(zhí)行第二個語句，依此類推弦蹂。

編程語言提供允許更復雜的執(zhí)行路徑的各種控制結構肩碟。

循環(huán)語句允許我們多次執(zhí)行一個語句或一組語句，以下是大多數(shù)編程語言中循環(huán)語句的一般形式 -

環(huán)路結構

R編程語言提供以下種類的循環(huán)來處理循環(huán)需求凸椿。 單擊以下鏈接以檢查其詳細信息削祈。

• repeat循環(huán)

多次執(zhí)行一系列語句，并簡化管理循環(huán)變量的代碼脑漫。

• while循環(huán)

在給定條件為真時髓抑，重復語句或語句組。 它在執(zhí)行循環(huán)體之前測試條件优幸。

• for循環(huán)

像while語句吨拍，不同之處在于它測試在循環(huán)體的端部的條件。

循環(huán)控制語句

循環(huán)控制語句從其正常序列改變執(zhí)行网杆。 當執(zhí)行離開作用域時羹饰，在該作用域中創(chuàng)建的所有自動對象都將被銷毀。
R語言支持以下控制語句碳却。 單擊以下鏈接以檢查其詳細信息队秩。

• break語句

終止循環(huán)語句，并將執(zhí)行轉移到循環(huán)后立即執(zhí)行的語句昼浦。

• next語句

next語句模擬R語言switch語句的行為馍资。

十.數(shù)據(jù)重塑

R語言中的數(shù)據(jù)重塑是關于改變數(shù)據(jù)被組織成行和列的方式。 大多數(shù)時間R語言中的數(shù)據(jù)處理是通過將輸入數(shù)據(jù)作為數(shù)據(jù)幀來完成的关噪。 很容易從數(shù)據(jù)幀的行和列中提取數(shù)據(jù)鸟蟹，但是在某些情況下，我們需要的數(shù)據(jù)幀格式與我們接收數(shù)據(jù)幀的格式不同使兔。 R語言具有許多功能建钥，在數(shù)據(jù)幀中拆分，合并和將行更改為列火诸，反之亦然锦针。

于數(shù)據(jù)幀中加入列和行

我們可以使用cbind()函數(shù)連接多個向量來創(chuàng)建數(shù)據(jù)幀。 此外，我們可以使用rbind()函數(shù)合并兩個數(shù)據(jù)幀奈搜。

# Create vector objects.
city <- c("Tampa","Seattle","Hartford","Denver")
state <- c("FL","WA","CT","CO")
zipcode <- c(33602,98104,06161,80294)

# Combine above three vectors into one data frame.
addresses <- cbind(city,state,zipcode)

# Print a header.
cat("# # # # The First data frame
") 

# Print the data frame.
print(addresses)

# Create another data frame with similar columns
new.address <- data.frame(
   city = c("Lowry","Charlotte"),
   state = c("CO","FL"),
   zipcode = c("80230","33949"),
   stringsAsFactors = FALSE
)

# Print a header.
cat("# # # The Second data frame
") 

# Print the data frame.
print(new.address)

# Combine rows form both the data frames.
all.addresses <- rbind(addresses,new.address)

# Print a header.
cat("# # # The combined data frame
") 

# Print the result.
print(all.addresses)

當我們執(zhí)行上面的代碼悉盆，它產(chǎn)生以下結果 -

# # # # The First data frame
     city       state zipcode
[1,] "Tampa"    "FL"  "33602"
[2,] "Seattle"  "WA"  "98104"
[3,] "Hartford" "CT"   "6161" 
[4,] "Denver"   "CO"  "80294"

# # # The Second data frame
       city       state   zipcode
1      Lowry      CO      80230
2      Charlotte  FL      33949

# # # The combined data frame
       city      state zipcode
1      Tampa     FL    33602
2      Seattle   WA    98104
3      Hartford  CT     6161
4      Denver    CO    80294
5      Lowry     CO    80230
6     Charlotte  FL    33949

合并數(shù)據(jù)幀

我們可以使用merge()函數(shù)合并兩個數(shù)據(jù)幀。 數(shù)據(jù)幀必須具有相同的列名稱馋吗，在其上進行合并焕盟。

在下面的例子中，我們考慮圖書館名稱“MASS”中有關Pima Indian Women的糖尿病的數(shù)據(jù)集宏粤。 我們基于血壓（“bp”）和體重指數(shù)（“bmi”）的值合并兩個數(shù)據(jù)集脚翘。 在選擇這兩列用于合并時，其中這兩個變量的值在兩個數(shù)據(jù)集中匹配的記錄被組合在一起以形成單個數(shù)據(jù)幀绍哎。

library(MASS)
merged.Pima <- merge(x = Pima.te, y = Pima.tr,
   by.x = c("bp", "bmi"),
   by.y = c("bp", "bmi")
)
print(merged.Pima)
nrow(merged.Pima)

當我們執(zhí)行上面的代碼来农，它產(chǎn)生以下結果 -

   bp  bmi npreg.x glu.x skin.x ped.x age.x type.x npreg.y glu.y skin.y ped.y
1  60 33.8       1   117     23 0.466    27     No       2   125     20 0.088
2  64 29.7       2    75     24 0.370    33     No       2   100     23 0.368
3  64 31.2       5   189     33 0.583    29    Yes       3   158     13 0.295
4  64 33.2       4   117     27 0.230    24     No       1    96     27 0.289
5  66 38.1       3   115     39 0.150    28     No       1   114     36 0.289
6  68 38.5       2   100     25 0.324    26     No       7   129     49 0.439
7  70 27.4       1   116     28 0.204    21     No       0   124     20 0.254
8  70 33.1       4    91     32 0.446    22     No       9   123     44 0.374
9  70 35.4       9   124     33 0.282    34     No       6   134     23 0.542
10 72 25.6       1   157     21 0.123    24     No       4    99     17 0.294
11 72 37.7       5    95     33 0.370    27     No       6   103     32 0.324
12 74 25.9       9   134     33 0.460    81     No       8   126     38 0.162
13 74 25.9       1    95     21 0.673    36     No       8   126     38 0.162
14 78 27.6       5    88     30 0.258    37     No       6   125     31 0.565
15 78 27.6      10   122     31 0.512    45     No       6   125     31 0.565
16 78 39.4       2   112     50 0.175    24     No       4   112     40 0.236
17 88 34.5       1   117     24 0.403    40    Yes       4   127     11 0.598
   age.y type.y
1     31     No
2     21     No
3     24     No
4     21     No
5     21     No
6     43    Yes
7     36    Yes
8     40     No
9     29    Yes
10    28     No
11    55     No
12    39     No
13    39     No
14    49    Yes
15    49    Yes
16    38     No
17    28     No
[1] 17

melt()拆分數(shù)據(jù)和cast()數(shù)據(jù)重構

R語言編程的一個最有趣的方面是關于在多個步驟中改變數(shù)據(jù)的形狀以獲得期望的形狀。 用于執(zhí)行此操作的函數(shù)稱為melt()和cast()崇堰。

我們考慮稱為船舶的數(shù)據(jù)集稱為“MASS”沃于。

library(MASS)
print(ships)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

     type year   period   service   incidents
1     A   60     60        127         0
2     A   60     75         63         0
3     A   65     60       1095         3
4     A   65     75       1095         4
5     A   70     60       1512         6
.............
.............
8     A   75     75       2244         11
9     B   60     60      44882         39
10    B   60     75      17176         29
11    B   65     60      28609         58
............
............
17    C   60     60      1179          1
18    C   60     75       552          1
19    C   65     60       781          0
............
............

melt()拆分數(shù)據(jù)

現(xiàn)在我們拆分數(shù)據(jù)進行重組海诲，將除類型和年份以外的所有列轉換為多行展示繁莹。

molten.ships <- melt(ships, id = c("type","year"))
print(molten.ships)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

      type year  variable  value
1      A   60    period      60
2      A   60    period      75
3      A   65    period      60
4      A   65    period      75
............
............
9      B   60    period      60
10     B   60    period      75
11     B   65    period      60
12     B   65    period      75
13     B   70    period      60
...........
...........
41     A   60    service    127
42     A   60    service     63
43     A   65    service   1095
...........
...........
70     D   70    service   1208
71     D   75    service      0
72     D   75    service   2051
73     E   60    service     45
74     E   60    service      0
75     E   65    service    789
...........
...........
101    C   70    incidents    6
102    C   70    incidents    2
103    C   75    incidents    0
104    C   75    incidents    1
105    D   60    incidents    0
106    D   60    incidents    0
...........
...........

cast()重構數(shù)據(jù)

我們可以將被拆分的數(shù)據(jù)轉換為一種新形式特幔，使用cast()函數(shù)創(chuàng)建每年每種類型的船的總和咨演。

recasted.ship <- cast(molten.ships, type+year~variable,sum)
print(recasted.ship)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

     type year  period  service  incidents
1     A   60    135       190      0
2     A   65    135      2190      7
3     A   70    135      4865     24
4     A   75    135      2244     11
5     B   60    135     62058     68
6     B   65    135     48979    111
7     B   70    135     20163     56
8     B   75    135      7117     18
9     C   60    135      1731      2
10    C   65    135      1457      1
11    C   70    135      2731      8
12    C   75    135       274      1
13    D   60    135       356      0
14    D   65    135       480      0
15    D   70    135      1557     13
16    D   75    135      2051      4
17    E   60    135        45      0
18    E   65    135      1226     14
19    E   70    135      3318     17
20    E   75    135       542      1

十一.函數(shù)

函數(shù)是一組組合在一起以執(zhí)行特定任務的語句蚯斯。 R語言具有大量內置函數(shù)薄风，用戶可以創(chuàng)建自己的函數(shù)。

在R語言中溉跃，函數(shù)是一個對象村刨，因此R語言解釋器能夠將控制傳遞給函數(shù)，以及函數(shù)完成動作所需的參數(shù)撰茎。

該函數(shù)依次執(zhí)行其任務并將控制返回到解釋器以及可以存儲在其他對象中的任何結果。

函數(shù)定義

使用關鍵字函數(shù)創(chuàng)建R語言的函數(shù)打洼。 R語言的函數(shù)定義的基本語法如下

function_name <- function(arg_1, arg_2, ...) {
   Function body 
}

函數(shù)組件

函數(shù)的不同部分 -

• 函數(shù)名稱 -這是函數(shù)的實際名稱龄糊。 它作為具有此名稱的對象存儲在R環(huán)境中。

• 參數(shù) -參數(shù)是一個占位符募疮。 當函數(shù)被調用時炫惩，你傳遞一個值到參數(shù)。 參數(shù)是可選的; 也就是說阿浓，一個函數(shù)可能不包含參數(shù)他嚷。 參數(shù)也可以有默認值。

• 函數(shù)體 -函數(shù)體包含定義函數(shù)的功能的語句集合。

• 返回值 -函數(shù)的返回值是要評估的函數(shù)體中的最后一個表達式筋蓖。
  R語言有許多內置函數(shù)卸耘，可以在程序中直接調用而無需先定義它們。我們還可以創(chuàng)建和使用我們自己的函數(shù)粘咖，稱為用戶定義的函數(shù)蚣抗。

內置功能

內置函數(shù)的簡單示例是seq()，mean()瓮下，max()翰铡，sum(x)和paste(...)等。它們由用戶編寫的程序直接調用讽坏。 您可以參考最廣泛使用的R函數(shù)锭魔。

# Create a sequence of numbers from 32 to 44.
print(seq(32,44))

# Find mean of numbers from 25 to 82.
print(mean(25:82))

# Find sum of numbers frm 41 to 68.
print(sum(41:68))

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

[1] 32 33 34 35 36 37 38 39 40 41 42 43 44
[1] 53.5
[1] 1526

用戶定義的函數(shù)

我們可以在R語言中創(chuàng)建用戶定義的函數(shù)路呜。它們特定于用戶想要的迷捧，一旦創(chuàng)建，它們就可以像內置函數(shù)一樣使用拣宰。 下面是一個創(chuàng)建和使用函數(shù)的例子党涕。

# Create a function to print squares of numbers in sequence.
new.function <- function(a) {
   for(i in 1:a) {
      b <- i^2
      print(b)
   }
}   

調用函數(shù)

# Create a function to print squares of numbers in sequence.
new.function <- function(a) {
   for(i in 1:a) {
      b <- i^2
      print(b)
   }
}

# Call the function new.function supplying 6 as an argument.
new.function(6)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

[1] 1
[1] 4
[1] 9
[1] 16
[1] 25
[1] 36

調用沒有參數(shù)的函數(shù)

# Create a function without an argument.
new.function <- function() {
   for(i in 1:5) {
      print(i^2)
   }
}   

# Call the function without supplying an argument.
new.function()

當我們執(zhí)行上面的代碼巡社，它產(chǎn)生以下結果 -

[1] 1
[1] 4
[1] 9
[1] 16
[1] 25

使用參數(shù)值調用函數(shù)（按位置和名稱）
函數(shù)調用的參數(shù)可以按照函數(shù)中定義的順序提供膛堤，也可以以不同的順序提供，但分配給參數(shù)的名稱晌该。

# Create a function with arguments.
new.function <- function(a,b,c) {
   result <- a * b + c
   print(result)
}

# Call the function by position of arguments.
new.function(5,3,11)

# Call the function by names of the arguments.
new.function(a = 11, b = 5, c = 3)

當我們執(zhí)行上面的代碼肥荔，它產(chǎn)生以下結果 -

[1] 26
[1] 58

使用默認參數(shù)調用函數(shù)
我們可以在函數(shù)定義中定義參數(shù)的值，并調用函數(shù)而不提供任何參數(shù)以獲取默認結果朝群。 但是我們也可以通過提供參數(shù)的新值來獲得非默認結果來調用這樣的函數(shù)燕耿。

# Create a function with arguments.
new.function <- function(a = 3, b = 6) {
   result <- a * b
   print(result)
}

# Call the function without giving any argument.
new.function()

# Call the function with giving new values of the argument.
new.function(9,5)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

[1] 18
[1] 45

功能的延遲計算
對函數(shù)的參數(shù)進行延遲評估姜胖，這意味著它們只有在函數(shù)體需要時才進行評估誉帅。

# Create a function with arguments.
new.function <- function(a, b) {
   print(a^2)
   print(a)
   print(b)
}

# Evaluate the function without supplying one of the arguments.
new.function(6)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

[1] 36
[1] 6
Error in print(b) : argument "b" is missing, with no default

十二.字符串

在R語言中的單引號或雙引號對中寫入的任何值都被視為字符串.R語言存儲的每個字符串都在雙引號內右莱，即使是使用單引號創(chuàng)建的依舊如此蚜锨。

在字符串構造中應用的規(guī)則

在字符串的開頭和結尾的引號應該是兩個雙引號或兩個單引號。它們不能被混合慢蜓。

• 雙引號可以插入到以單引號開頭和結尾的字符串中亚再。

• 單引號可以插入以雙引號開頭和結尾的字符串。

• 雙引號不能插入以雙引號開頭和結尾的字符串晨抡。

• 單引號不能插入以單引號開頭和結尾的字符串氛悬。

有效字符串的示例

以下示例闡明了在? 語言中創(chuàng)建33字符串的規(guī)則则剃。

a <- 'Start and end with single quote'
print(a)

b <- "Start and end with double quotes"
print(b)

c <- "single quote ' in between double quotes"
print(c)

d <- 'Double quotes " in between single quote'
print(d)

當運行上面的代碼，我們得到以下輸出 -

[1] "Start and end with single quote"
[1] "Start and end with double quotes"
[1] "single quote ' in between double quote"
[1] "Double quote " in between single quote"

無效字符串的示例

e <- 'Mixed quotes" 
print(e)

f <- 'Single quote ' inside single quote'
print(f)

g <- "Double quotes " inside double quotes"
print(g)

當我們運行腳本失敗給下面的結果如捅。

...: unexpected INCOMPLETE_STRING

.... unexpected symbol 
1: f <- 'Single quote ' inside

unexpected symbol
1: g <- "Double quotes " inside

字符串操作

連接字符串 - paste（）函數(shù)

R 語言中的許多字符串使用paste（）函數(shù)組合棍现。它可以采取任何數(shù)量的參數(shù)組合在一起旺遮。

語法

對于粘貼功能的基本語法是 -

paste(..., sep = " ", collapse = NULL)

以下是所使用的參數(shù)的說明 -

• ...表示要組合的任意數(shù)量的自變量排惨。

• 九月表示參數(shù)之間的任何分隔符。它是可選的剪廉。

• collapse用于消除兩個字符串之間的空格烈涮。但不是一個字符串的兩個字內的空間朴肺。

例

a <- "Hello"
b <- 'How'
c <- "are you? "

print(paste(a,b,c))

print(paste(a,b,c, sep = "-"))

print(paste(a,b,c, sep = "", collapse = ""))

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

[1] "Hello How are you? "
[1] "Hello-How-are you? "
[1] "HelloHoware you? "

格式化數(shù)字和字符串 - format（）函數(shù)

可以使用格式（）函數(shù)將數(shù)字和字符串格式化為特定樣式坚洽。

語法

格式化函數(shù)的基本語法是 -

format(x, digits, nsmall, scientific, width, justify = c("left", "right", "centre", "none")) 

以下是所使用的參數(shù)的描述 -

• X是向量輸入戈稿。

• 數(shù)字是顯示的總位數(shù)。

• nsmall是小數(shù)點右邊的最小位數(shù)讶舰。

• 科學設置為TRUE以顯示科學記數(shù)法鞍盗。

• 寬度指示通過在開始處填充空白來顯示的最小寬度。

• 理由是字符串向左跳昼，右或中心的顯示般甲。

例

# Total number of digits displayed. Last digit rounded off.
result <- format(23.123456789, digits = 9)
print(result)

# Display numbers in scientific notation.
result <- format(c(6, 13.14521), scientific = TRUE)
print(result)

# The minimum number of digits to the right of the decimal point.
result <- format(23.47, nsmall = 5)
print(result)

# Format treats everything as a string.
result <- format(6)
print(result)

# Numbers are padded with blank in the beginning for width.
result <- format(13.7, width = 6)
print(result)

# Left justify strings.
result <- format("Hello", width = 8, justify = "l")
print(result)

# Justfy string with center.
result <- format("Hello", width = 8, justify = "c")
print(result)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

[1] "23.1234568"
[1] "6.000000e+00" "1.314521e+01"
[1] "23.47000"
[1] "6"
[1] "  13.7"
[1] "Hello   "
[1] " Hello  "

計算字符串中的字符數(shù) - nchar（）函數(shù)

此函數(shù)計算字符串中包含空格的字符數(shù)鹅颊。

語法

nchar（）函數(shù)的基本語法是 -

nchar(x)
以下是所使用的參數(shù)的描述 -

• X是向量輸入敷存。

例

result <- nchar("Count the number of characters")
print(result)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

[1] 30

更改案例 - toupper（）和tolower（）函數(shù)

這些函數(shù)改變字符串的字符的大小寫堪伍。

語法

toupper（）和tolower（）函數(shù)的基本語法是 -

toupper(x)
tolower(x)

以下是所使用的參數(shù)的描述 -

• X是向量輸入锚烦。

例

# Changing to Upper case.
result <- toupper("Changing To Upper")
print(result)

# Changing to lower case.
result <- tolower("Changing To Lower")
print(result)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

[1] "CHANGING TO UPPER"
[1] "changing to lower"

提取字符串的一部分 - substring（）函數(shù)

此函數(shù)提取字符串的部分帝雇。

語法

substring（）函數(shù)的基本語法是 -

substring(x,first,last)

以下是所使用的參數(shù)的描述 -

• X是字符向量輸入涮俄。

• 首先是要提取的第一個字符的位置。

• 最后是要提取的最后一個字符的位置尸闸。

例

# Extract characters from 5th to 7th position.
result <- substring("Extract", 5, 7)
print(result)

當我們執(zhí)行上面的代碼彻亲，它產(chǎn)生以下結果 -

[1] "act"

十三.向量

向量是最基本的R語言數(shù)據(jù)對象，有六種類型的原子向量吮廉。 它們是邏輯睹栖，整數(shù)，雙精度茧痕，復雜，字符和原始恼除。

創(chuàng)建向量

單元素向量

即使在R語言中只寫入一個值踪旷，它也將成為長度為1的向量曼氛，并且屬于上述向量類型之一。

# Atomic vector of type character.
print("abc");

# Atomic vector of type double.
print(12.5)

# Atomic vector of type integer.
print(63L)

# Atomic vector of type logical.
print(TRUE)

# Atomic vector of type complex.
print(2+3i)

# Atomic vector of type raw.
print(charToRaw('hello'))

當我們執(zhí)行上面的代碼令野，它產(chǎn)生以下結果 -

[1] "abc"
[1] 12.5
[1] 63
[1] TRUE
[1] 2+3i
[1] 68 65 6c 6c 6f

多元素向量

對數(shù)值數(shù)據(jù)使用冒號運算符

# Creating a sequence from 5 to 13.
v <- 5:13
print(v)

# Creating a sequence from 6.6 to 12.6.
v <- 6.6:12.6
print(v)

# If the final element specified does not belong to the sequence then it is discarded.
v <- 3.8:11.4
print(v)

當我們執(zhí)行上面的代碼舀患，它產(chǎn)生以下結果 -

[1]  5  6  7  8  9 10 11 12 13
[1]  6.6  7.6  8.6  9.6 10.6 11.6 12.6
[1]  3.8  4.8  5.8  6.8  7.8  8.8  9.8 10.8

使用sequence (Seq.)序列運算符

# Create vector with elements from 5 to 9 incrementing by 0.4.
print(seq(5, 9, by = 0.4))

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

[1] 5.0 5.4 5.8 6.2 6.6 7.0 7.4 7.8 8.2 8.6 9.0

使用C()函數(shù)

如果其中一個元素是字符气破，則非字符值被強制轉換為字符類型聊浅。

# The logical and numeric values are converted to characters.
s <- c('apple','red',5,TRUE)
print(s)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

[1] "apple" "red"   "5"     "TRUE" 

訪問向量元素

使用索引訪問向量的元素现使。 []括號用于建立索引低匙。 索引從位置1開始。在索引中給出負值會丟棄來自result.TRUE碳锈，F(xiàn)ALSE或0和1的元素顽冶，也可用于索引。

# Accessing vector elements using position.
t <- c("Sun","Mon","Tue","Wed","Thurs","Fri","Sat")
u <- t[c(2,3,6)]
print(u)

# Accessing vector elements using logical indexing.
v <- t[c(TRUE,FALSE,FALSE,FALSE,FALSE,TRUE,FALSE)]
print(v)

# Accessing vector elements using negative indexing.
x <- t[c(-2,-5)]
print(x)

# Accessing vector elements using 0/1 indexing.
y <- t[c(0,0,0,0,0,0,1)]
print(y)

當我們執(zhí)行上面的代碼售碳，它產(chǎn)生以下結果 -

[1] "Mon" "Tue" "Fri"
[1] "Sun" "Fri"
[1] "Sun" "Tue" "Wed" "Fri" "Sat"
[1] "Sun"

向量操作

向量運算

可以添加强重，減去，相乘或相除兩個相同長度的向量贸人，將結果作為向量輸出间景。

# Create two vectors.
v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11,0,8,1,2)

# Vector addition.
add.result <- v1+v2
print(add.result)

# Vector substraction.
sub.result <- v1-v2
print(sub.result)

# Vector multiplication.
multi.result <- v1*v2
print(multi.result)

# Vector division.
divi.result <- v1/v2
print(divi.result)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

[1]  7 19  4 13  1 13
[1] -1 -3  4 -3 -1  9
[1] 12 88  0 40  0 22
[1] 0.7500000 0.7272727       Inf 0.6250000 0.0000000 5.5000000

向量元素回收

如果我們對不等長的兩個向量應用算術運算艺智，則較短向量的元素被循環(huán)以完成操作倘要。

v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11)
# V2 becomes c(4,11,4,11,4,11)

add.result <- v1+v2
print(add.result)

sub.result <- v1-v2
print(sub.result)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

[1]  7 19  8 16  4 22
[1] -1 -3  0 -6 -4  0

向量元素排序

向量中的元素可以使用sort()函數(shù)排序力惯。

v <- c(3,8,4,5,0,11, -9, 304)

# Sort the elements of the vector.
sort.result <- sort(v)
print(sort.result)

# Sort the elements in the reverse order.
revsort.result <- sort(v, decreasing = TRUE)
print(revsort.result)

# Sorting character vectors.
v <- c("Red","Blue","yellow","violet")
sort.result <- sort(v)
print(sort.result)

# Sorting character vectors in reverse order.
revsort.result <- sort(v, decreasing = TRUE)
print(revsort.result)

當我們執(zhí)行上面的代碼碗誉，它產(chǎn)生以下結果 -

[1]  -9   0   3   4   5   8  11 304
[1] 304  11   8   5   4   3   0  -9
[1] "Blue"   "Red"    "violet" "yellow"
[1] "yellow" "violet" "Red"    "Blue" 

十四.列表

列表是R語言對象，它包含不同類型的元素父晶，如數(shù)字哮缺，字符串，向量和其中的另一個列表甲喝。列表還可以包含矩陣或函數(shù)作為其元素尝苇。列表是使用list（）函數(shù)創(chuàng)建的。

創(chuàng)建列表

以下是創(chuàng)建包含字符串埠胖，數(shù)字糠溜，向量和邏輯值的列表的示例

# Create a list containing strings, numbers, vectors and a logical values.
list_data <- list("Red", "Green", c(21,32,11), TRUE, 51.23, 119.1)
print(list_data)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

[[1]]
[1] "Red"

[[2]]
[1] "Green"

[[3]]
[1] 21 32 11

[[4]]
[1] TRUE

[[5]]
[1] 51.23

[[6]]
[1] 119.1

命名列表元素

列表元素可以給出名稱直撤，并且可以使用這些名稱訪問它們非竿。

# Create a list containing a vector, a matrix and a list.
list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2),
   list("green",12.3))

# Give names to the elements in the list.
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")

# Show the list.
print(list_data)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

$`1st_Quarter`
[1] "Jan" "Feb" "Mar"

$A_Matrix
     [,1] [,2] [,3]
[1,]    3    5   -2
[2,]    9    1    8

$A_Inner_list
$A_Inner_list[[1]]
[1] "green"

$A_Inner_list[[2]]
[1] 12.3

訪問列表元素

列表的元素可以通過列表中元素的索引訪問谋竖。在命名列表的情況下红柱，它也可以使用名稱來訪問承匣。

我們繼續(xù)使用在上面的例子列表 -

# Create a list containing a vector, a matrix and a list.
list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2),
   list("green",12.3))

# Give names to the elements in the list.
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")

# Access the first element of the list.
print(list_data[1])

# Access the thrid element. As it is also a list, all its elements will be printed.
print(list_data[3])

# Access the list element using the name of the element.
print(list_data$A_Matrix)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

$`1st_Quarter`
[1] "Jan" "Feb" "Mar"

$A_Inner_list
$A_Inner_list[[1]]
[1] "green"

$A_Inner_list[[2]]
[1] 12.3

     [,1] [,2] [,3]
[1,]    3    5   -2
[2,]    9    1    8

操控列表元素

我們可以添加锤悄，刪除和更新列表元素韧骗，如下所示。我們只能在列表的末尾添加和刪除元素零聚。但我們可以更新任何元素袍暴。

# Create a list containing a vector, a matrix and a list.
list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2),
   list("green",12.3))

# Give names to the elements in the list.
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")

# Add element at the end of the list.
list_data[4] <- "New element"
print(list_data[4])

# Remove the last element.
list_data[4] <- NULL

# Print the 4th Element.
print(list_data[4])

# Update the 3rd Element.
list_data[3] <- "updated element"
print(list_data[3])

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

[[1]]
[1] "New element"

$
NULL

$`A Inner list`
[1] "updated element"

合并列表

通過將所有列表放在一個列表（）函數(shù)中隶症，您可以將許多列表合并到一個列表中政模。

# Create two lists.
list1 <- list(1,2,3)
list2 <- list("Sun","Mon","Tue")

# Merge the two lists.
merged.list <- c(list1,list2)

# Print the merged list.
print(merged.list)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 3

[[4]]
[1] "Sun"

[[5]]
[1] "Mon"

[[6]]
[1] "Tue"

將列表轉換為向量

列表可以轉換為向量沿腰，使得向量的元素可以用于進一步的操作览徒。可以在將列表轉換為向量之后應用對向量的所有算術運算颂龙。要做這個轉換习蓬，我們使用unlist（）函數(shù)。它將列表作為輸入并生成向量措嵌。

# Create lists.
list1 <- list(1:5)
print(list1)

list2 <-list(10:14)
print(list2)

# Convert the lists to vectors.
v1 <- unlist(list1)
v2 <- unlist(list2)

print(v1)
print(v2)

# Now add the vectors
result <- v1+v2
print(result)

當我們執(zhí)行上面的代碼躲叼，它產(chǎn)生以下結果 -

[[1]]
[1] 1 2 3 4 5

[[1]]
[1] 10 11 12 13 14

[1] 1 2 3 4 5
[1] 10 11 12 13 14
[1] 11 13 15 17 19

十五.矩陣

矩陣是其中元素以二維矩形布局布置的R對象。 它們包含相同原子類型的元素企巢。 雖然我們可以創(chuàng)建一個只包含字符或只包含邏輯值的矩陣枫慷，但它們沒有太多用處。 我們使用包含數(shù)字元素的矩陣用于數(shù)學計算浪规。

使用matrix()函數(shù)創(chuàng)建一個矩陣或听。

語法

在R語言中創(chuàng)建矩陣的基本語法是 -

matrix(data, nrow, ncol, byrow, dimnames)

以下是所使用的參數(shù)的說明 -

• 數(shù)據(jù)是成為矩陣的數(shù)據(jù)元素的輸入向量。

• nrow是要創(chuàng)建的行數(shù)笋婿。

• ncol是要創(chuàng)建的列數(shù)誉裆。

• byrow是一個邏輯線索。 如果為TRUE缸濒，則輸入向量元素按行排列足丢。

• dimname是分配給行和列的名稱。

例

創(chuàng)建一個以數(shù)字向量作為輸入的矩陣

# Elements are arranged sequentially by row.
M <- matrix(c(3:14), nrow = 4, byrow = TRUE)
print(M)

# Elements are arranged sequentially by column.
N <- matrix(c(3:14), nrow = 4, byrow = FALSE)
print(N)

# Define the column and row names.
rownames = c("row1", "row2", "row3", "row4")
colnames = c("col1", "col2", "col3")

P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))
print(P)

當我們執(zhí)行上面的代碼庇配，它產(chǎn)生以下結果 -

     [,1] [,2] [,3]
[1,]    3    4    5
[2,]    6    7    8
[3,]    9   10   11
[4,]   12   13   14
     [,1] [,2] [,3]
[1,]    3    7   11
[2,]    4    8   12
[3,]    5    9   13
[4,]    6   10   14
     col1 col2 col3
row1    3    4    5
row2    6    7    8
row3    9   10   11
row4   12   13   14

訪問矩陣的元素

可以通過使用元素的列和行索引來訪問矩陣的元素斩跌。 我們考慮上面的矩陣P找到下面的具體元素。

# Define the column and row names.
rownames = c("row1", "row2", "row3", "row4")
colnames = c("col1", "col2", "col3")

# Create the matrix.
P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))

# Access the element at 3rd column and 1st row.
print(P[1,3])

# Access the element at 2nd column and 4th row.
print(P[4,2])

# Access only the  2nd row.
print(P[2,])

# Access only the 3rd column.
print(P[,3])

當我們執(zhí)行上面的代碼捞慌，它產(chǎn)生以下結果 -

[1] 5
[1] 13
col1 col2 col3 
   6    7    8 
row1 row2 row3 row4 
   5    8   11   14 

矩陣計算

使用R運算符對矩陣執(zhí)行各種數(shù)學運算耀鸦。 操作的結果也是一個矩陣。
對于操作中涉及的矩陣啸澡，維度（行數(shù)和列數(shù)）應該相同揭糕。

矩陣加法和減法

# Create two 2x3 matrices.
matrix1 <- matrix(c(3, 9, -1, 4, 2, 6), nrow = 2)
print(matrix1)

matrix2 <- matrix(c(5, 2, 0, 9, 3, 4), nrow = 2)
print(matrix2)

# Add the matrices.
result <- matrix1 + matrix2
cat("Result of addition","
")
print(result)

# Subtract the matrices
result <- matrix1 - matrix2
cat("Result of subtraction","
")
print(result)

當我們執(zhí)行上面的代碼萝快，它產(chǎn)生以下結果 -

     [,1] [,2] [,3]
[1,]    3   -1    2
[2,]    9    4    6
     [,1] [,2] [,3]
[1,]    5    0    3
[2,]    2    9    4
Result of addition 
     [,1] [,2] [,3]
[1,]    8   -1    5
[2,]   11   13   10
Result of subtraction 
     [,1] [,2] [,3]
[1,]   -2   -1   -1
[2,]    7   -5    2

矩陣乘法和除法

# Create two 2x3 matrices.
matrix1 <- matrix(c(3, 9, -1, 4, 2, 6), nrow = 2)
print(matrix1)

matrix2 <- matrix(c(5, 2, 0, 9, 3, 4), nrow = 2)
print(matrix2)

# Multiply the matrices.
result <- matrix1 * matrix2
cat("Result of multiplication","
")
print(result)

# Divide the matrices
result <- matrix1 / matrix2
cat("Result of division","
")
print(result)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

     [,1] [,2] [,3]
[1,]    3   -1    2
[2,]    9    4    6
     [,1] [,2] [,3]
[1,]    5    0    3
[2,]    2    9    4
Result of multiplication 
     [,1] [,2] [,3]
[1,]   15    0    6
[2,]   18   36   24
Result of division 
     [,1]      [,2]      [,3]
[1,]  0.6      -Inf 0.6666667
[2,]  4.5 0.4444444 1.5000000

十六.數(shù)組

數(shù)組對可以在兩個以上維度中存儲數(shù)據(jù)的R數(shù)據(jù)對象著角。例如 - 如果我們創(chuàng)建一個維度（2,3,4）的數(shù)組，則它創(chuàng)造4個矩形矩陣旋恼，每個矩陣具有2行和3列數(shù)組只能存儲數(shù)據(jù)類型吏口。
使用array（）函數(shù)創(chuàng)建數(shù)組。它使用向量作為輸入冰更，并使用dim參數(shù)中的值創(chuàng)建數(shù)組产徊。

例

以下示例創(chuàng)建一個由兩個3x3的矩陣組成的數(shù)組，每個矩陣具有3行和3列蜀细。

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2))
print(result)

當我們執(zhí)行上面的代碼舟铜，它產(chǎn)生以下結果 -

, , 1

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

, , 2

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

命名列和行

我們可以使用dimnames參數(shù)給數(shù)組中的行，列和矩陣命名奠衔。

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")

# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,column.names,
   matrix.names))
print(result)

當我們執(zhí)行上面的代碼谆刨，它產(chǎn)生以下結果 -

, , Matrix1

     COL1 COL2 COL3
ROW1    5   10   13
ROW2    9   11   14
ROW3    3   12   15

, , Matrix2

     COL1 COL2 COL3
ROW1    5   10   13
ROW2    9   11   14
ROW3    3   12   15

訪問數(shù)組元素

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")

# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,
   column.names, matrix.names))

# Print the third row of the second matrix of the array.
print(result[3,,2])

# Print the element in the 1st row and 3rd column of the 1st matrix.
print(result[1,3,1])

# Print the 2nd Matrix.
print(result[,,2])

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

COL1 COL2 COL3 
   3   12   15 
[1] 13
     COL1 COL2 COL3
ROW1    5   10   13
ROW2    9   11   14
ROW3    3   12   15

操作數(shù)組元素

由于數(shù)組由多維構成矩陣归斤，所以對數(shù)組元素的操作通過訪問矩陣的元素來執(zhí)行痊夭。

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Take these vectors as input to the array.
array1 <- array(c(vector1,vector2),dim = c(3,3,2))

# Create two vectors of different lengths.
vector3 <- c(9,1,0)
vector4 <- c(6,0,11,3,14,1,2,6,9)
array2 <- array(c(vector1,vector2),dim = c(3,3,2))

# create matrices from these arrays.
matrix1 <- array1[,,2]
matrix2 <- array2[,,2]

# Add the matrices.
result <- matrix1+matrix2
print(result)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

     [,1] [,2] [,3]
[1,]   10   20   26
[2,]   18   22   28
[3,]    6   24   30

跨數(shù)組元素的計算

我們可以使用適用（）函數(shù)在數(shù)組中的元素上進行計算脏里。

語法

apply(x, margin, fun)

以下是所使用的參數(shù)的說明 -

• X是一個數(shù)組她我。

• 保證金是所使用的數(shù)據(jù)集的名稱。

• 有趣的是要應用于數(shù)組元素的函數(shù)迫横。

例
我們使用下面的適用（）函數(shù)計算所有矩陣中數(shù)組行中元素的總和番舆。

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Take these vectors as input to the array.
new.array <- array(c(vector1,vector2),dim = c(3,3,2))
print(new.array)

# Use apply to calculate the sum of the rows across all the matrices.
result <- apply(new.array, c(1), sum)
print(result)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

, , 1

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

, , 2

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

[1] 56 68 60

十七.因子

因子是用于對數(shù)據(jù)進行分類并將其存儲為級別的數(shù)據(jù)對象矾踱。 它們可以存儲字符串和整數(shù)恨狈。 它們在具有有限數(shù)量的唯一值的列中很有用。 像“男性”介返，“女性”和True拴事，F(xiàn)alse等。它們在統(tǒng)計建模的數(shù)據(jù)分析中很有用圣蝎。
使用factor()函數(shù)通過將向量作為輸入創(chuàng)建因子刃宵。
例

# Create a vector as input.
data <- c("East","West","East","North","North","East","West","West","West","East","North")

print(data)
print(is.factor(data))

# Apply the factor function.
factor_data <- factor(data)

print(factor_data)
print(is.factor(factor_data))

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

 [1] "East"  "West"  "East"  "North" "North" "East"  "West"  "West"  "West"  "East" "North"
[1] FALSE
 [1] East  West  East  North North East  West  West  West  East  North
Levels: East North West
[1] TRUE

數(shù)據(jù)幀的因子

在創(chuàng)建具有文本數(shù)據(jù)列的任何數(shù)據(jù)框時徘公，R語言將文本列視為分類數(shù)據(jù)并在其上創(chuàng)建因子牲证。

# Create the vectors for data frame.
height <- c(132,151,162,139,166,147,122)
weight <- c(48,49,66,53,67,52,40)
gender <- c("male","male","female","female","male","female","male")

# Create the data frame.
input_data <- data.frame(height,weight,gender)
print(input_data)

# Test if the gender column is a factor.
print(is.factor(input_data$gender))

# Print the gender column so see the levels.
print(input_data$gender)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

  height weight gender
1    132     48   male
2    151     49   male
3    162     66 female
4    139     53 female
5    166     67   male
6    147     52 female
7    122     40   male
[1] TRUE
[1] male   male   female female male   female male  
Levels: female male

更改級別順序

可以通過使用新的等級次序再次應用因子函數(shù)來改變因子中的等級的順序关面。

data <- c("East","West","East","North","North","East","West","West","West","East","North")
# Create the factors
factor_data <- factor(data)
print(factor_data)

# Apply the factor function with required order of the level.
new_order_data <- factor(factor_data,levels = c("East","West","North"))
print(new_order_data)

當我們執(zhí)行上面的代碼坦袍，它產(chǎn)生以下結果 -

 [1] East  West  East  North North East  West  West  West  East  North
Levels: East North West
 [1] East  West  East  North North East  West  West  West  East  North
Levels: East West North

生成因子級別

我們可以使用gl()函數(shù)生成因子級別十厢。 它需要兩個整數(shù)作為輸入，指示每個級別有多少級別和多少次捂齐。

語法

gl(n, k, labels)

以下是所使用的參數(shù)的說明 -

• n是給出級數(shù)的整數(shù)蛮放。

• k是給出復制數(shù)目的整數(shù)。

• labels是所得因子水平的標簽向量奠宜。

例

v <- gl(3, 4, labels = c("Tampa", "Seattle","Boston"))
print(v)

當我們執(zhí)行上面的代碼包颁，它產(chǎn)生以下結果 -

Tampa   Tampa   Tampa   Tampa   Seattle Seattle Seattle Seattle Boston 
[10] Boston  Boston  Boston 
Levels: Tampa Seattle Boston

十八.數(shù)據(jù)幀

數(shù)據(jù)幀是表或二維陣列狀結構，其中每一列包含一個變量的值压真，并且每一行包含來自每一列的一組值娩嚼。
以下是數(shù)據(jù)幀的特性。

• 列名稱應為非空滴肿。
• 行名稱應該是唯一的岳悟。
• 存儲在數(shù)據(jù)幀中的數(shù)據(jù)可以是數(shù)字，因子或字符類型泼差。
• 每個列應包含相同數(shù)量的數(shù)據(jù)項贵少。

創(chuàng)建數(shù)據(jù)幀

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Print the data frame.         
print(emp.data) 

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

 emp_id    emp_name     salary     start_date
1     1     Rick        623.30     2012-01-01
2     2     Dan         515.20     2013-09-23
3     3     Michelle    611.00     2014-11-15
4     4     Ryan        729.00     2014-05-11
5     5     Gary        843.25     2015-03-27

獲取數(shù)據(jù)幀的結構

通過使用str()函數(shù)可以看到數(shù)據(jù)幀的結構拴驮。

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Get the structure of the data frame.
str(emp.data)

當我們執(zhí)行上面的代碼春瞬，它產(chǎn)生以下結果 -

'data.frame':   5 obs. of  4 variables:
 $ emp_id    : int  1 2 3 4 5
 $ emp_name  : chr  "Rick" "Dan" "Michelle" "Ryan" ...
 $ salary    : num  623 515 611 729 843
 $ start_date: Date, format: "2012-01-01" "2013-09-23" "2014-11-15" "2014-05-11" ...

數(shù)據(jù)框中的數(shù)據(jù)摘要

可以通過應用summary()函數(shù)獲取數(shù)據(jù)的統(tǒng)計摘要和性質。

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Print the summary.
print(summary(emp.data))  

當我們執(zhí)行上面的代碼套啤，它產(chǎn)生以下結果 -

     emp_id    emp_name             salary        start_date        
 Min.   :1   Length:5           Min.   :515.2   Min.   :2012-01-01  
 1st Qu.:2   Class :character   1st Qu.:611.0   1st Qu.:2013-09-23  
 Median :3   Mode  :character   Median :623.3   Median :2014-05-11  
 Mean   :3                      Mean   :664.4   Mean   :2014-01-14  
 3rd Qu.:4                      3rd Qu.:729.0   3rd Qu.:2014-11-15  
 Max.   :5                      Max.   :843.2   Max.   :2015-03-27 

從數(shù)據(jù)幀提取數(shù)據(jù)

使用列名稱從數(shù)據(jù)框中提取特定列宽气。

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),
   
   start_date = as.Date(c("2012-01-01","2013-09-23","2014-11-15","2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Extract Specific columns.
result <- data.frame(emp.data$emp_name,emp.data$salary)
print(result)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

  emp.data.emp_name emp.data.salary
1              Rick          623.30
2               Dan          515.20
3          Michelle          611.00
4              Ryan          729.00
5              Gary          843.25

先提取前兩行潜沦，然后提取所有列

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Extract first two rows.
result <- emp.data[1:2,]
print(result)

當我們執(zhí)行上面的代碼萄涯，它產(chǎn)生以下結果 -

  emp_id    emp_name   salary    start_date
1      1     Rick      623.3     2012-01-01
2      2     Dan       515.2     2013-09-23

用第2和第4列提取第3和第5行

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
    start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)

# Extract 3rd and 5th row with 2nd and 4th column.
result <- emp.data[c(3,5),c(2,4)]
print(result)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

  emp_name start_date
3 Michelle 2014-11-15
5     Gary 2015-03-27

擴展數(shù)據(jù)幀

可以通過添加列和行來擴展數(shù)據(jù)幀唆鸡。

添加列

只需使用新的列名稱添加列向量涝影。

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)

# Add the "dept" coulmn.
emp.data$dept <- c("IT","Operations","IT","HR","Finance")
v <- emp.data
print(v)

當我們執(zhí)行上面的代碼，它產(chǎn)生以下結果 -

  emp_id   emp_name    salary    start_date       dept
1     1    Rick        623.30    2012-01-01       IT
2     2    Dan         515.20    2013-09-23       Operations
3     3    Michelle    611.00    2014-11-15       IT
4     4    Ryan        729.00    2014-05-11       HR
5     5    Gary        843.25    2015-03-27       Finance

添加行

要將更多行永久添加到現(xiàn)有數(shù)據(jù)幀争占，我們需要引入與現(xiàn)有數(shù)據(jù)幀相同結構的新行燃逻，并使用rbind()函數(shù)。
在下面的示例中臂痕，我們創(chuàng)建一個包含新行的數(shù)據(jù)幀伯襟，并將其與現(xiàn)有數(shù)據(jù)幀合并以創(chuàng)建最終數(shù)據(jù)幀。

# Create the first data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   dept = c("IT","Operations","IT","HR","Finance"),
   stringsAsFactors = FALSE
)

# Create the second data frame
emp.newdata <-  data.frame(
   emp_id = c (6:8), 
   emp_name = c("Rasmi","Pranab","Tusar"),
   salary = c(578.0,722.5,632.8), 
   start_date = as.Date(c("2013-05-21","2013-07-30","2014-06-17")),
   dept = c("IT","Operations","Fianance"),
   stringsAsFactors = FALSE
)

# Bind the two data frames.
emp.finaldata <- rbind(emp.data,emp.newdata)
print(emp.finaldata)

當我們執(zhí)行上面的代碼握童，它產(chǎn)生以下結果 -

  emp_id     emp_name    salary     start_date       dept
1      1     Rick        623.30     2012-01-01       IT
2      2     Dan         515.20     2013-09-23       Operations
3      3     Michelle    611.00     2014-11-15       IT
4      4     Ryan        729.00     2014-05-11       HR
5      5     Gary        843.25     2015-03-27       Finance
6      6     Rasmi       578.00     2013-05-21       IT
7      7     Pranab      722.50     2013-07-30       Operations
8      8     Tusar       632.80     2014-06-17       Fianance

下一篇：R語言——進階篇