R語言：基礎(chǔ)

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

嘗試在線環(huán)境

你真的不需要設(shè)置自己的環(huán)境來開始學(xué)習(xí)R編程語言。 原因很簡單，我們已經(jīng)在線設(shè)置了R編程環(huán)境，以便您可以在進行理論工作的同時在線編譯和執(zhí)行所有可用的示例。 這給你對你正在閱讀的信心，并用不同的選項檢查結(jié)果。 隨意修改任何示例并在線執(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）。 您只需雙擊并運行安裝程序接受默認設(shè)置即可。 如果您的Windows是32位版本，它將安裝32位版本。 但是如果你的窗口是64位，那么它安裝32位和64位版本。

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

Linux安裝

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

各版本Linux的各有不同。具體的安裝步驟在上述資源中有對應(yīng)的教程。但是，如果你是在趕時間，那么你可以用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的內(nèi)容進行打印。

腳本文件

通常，您將通過在腳本文件中編寫程序來執(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)生以下結(jié)果。

[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í)行，但它們不會干擾您的實際程序。 但是你必須為內(nèi)容加上單引號或雙引號。

三.數(shù)據(jù)結(jié)構(gòu)

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

您可能想存儲各種數(shù)據(jù)類型的信息，如字符，寬字符，整數(shù)，浮點，雙浮點，布爾等?；谧兞康臄?shù)據(jù)類型，操作系統(tǒng)分配內(nèi)存并決定什么可以存儲在保留內(nèi)存中。

與其他編程語言（如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（復(fù)合型） 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)建向量時，你應(yī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)生以下結(jié)果

[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)生以下結(jié)果

[[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)生以下結(jié)果

     [,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)生以下結(jié)果

, , 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)生以下結(jié)果

[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)生以下結(jié)果

  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)生以下結(jié)果 -

[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ù)值類的混合。 因此，邏輯類強制轉(zhuǎn)換為數(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)生以下結(jié)果 -

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)生以下結(jié)果 -

[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)生以下結(jié)果 -

[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)生以下結(jié)果 -

[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)生以下結(jié)果 -

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

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

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

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

character(0)

五.運算符

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

運算符的類型

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

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

關(guān)系運算符

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

邏輯運算符

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

  • & 它被稱為元素邏輯AND運算符。 它將第一向量的每個元素與第二向量的相應(yīng)元素組合，并且如果兩個元素都為TRUE，則給出輸出TRUE。
  • | 它被稱為元素邏輯或運算符。 它將第一向量的每個元素與第二向量的相應(yīng)元素組合，并且如果元素為真，則給出輸出TRUE。
  • ! 它被稱為邏輯非運算符。 取得向量的每個元素，并給出相反的邏輯值。
    邏輯運算符&&和|| 只考慮向量的第一個元素，給出單個元素的向量作為輸出。
  • && 稱為邏輯AND運算符。 取兩個向量的第一個元素，并且只有兩個都為TRUE時才給出TRUE。
  • || 稱為邏輯OR運算符。 取兩個向量的第一個元素，如果其中一個為TRUE，則給出TRUE。

賦值運算符

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

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

其他運算符

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

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

六.決策

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

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

做決定

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

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

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

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)生以下結(jié)果。 它可能會根據(jù)您的電腦的本地設(shè)置而有所不同。

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

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

library()

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

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)生了以下結(jié)果。它會根據(jù)你的個人電腦的本地設(shè)置而異。

[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")
手動安裝包

轉(zhuǎn)到鏈接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í)行第二個語句，依此類推。

編程語言提供允許更復(fù)雜的執(zhí)行路徑的各種控制結(jié)構(gòu)。

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

環(huán)路結(jié)構(gòu)

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

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

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

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

循環(huán)控制語句

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

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

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

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

R語言中的數(shù)據(jù)重塑是關(guān)于改變數(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)生以下結(jié)果 -

# # # # 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”中有關(guān)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)生以下結(jié)果 -

   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ù)重構(gòu)

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

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

library(MASS)
print(ships)

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

     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ù)進行重組，將除類型和年份以外的所有列轉(zhuǎn)換為多行展示。

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

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

      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()重構(gòu)數(shù)據(jù)

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

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

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

     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í)行特定任務(wù)的語句。 R語言具有大量內(nèi)置函數(shù)，用戶可以創(chuàng)建自己的函數(shù)。

在R語言中，函數(shù)是一個對象，因此R語言解釋器能夠?qū)⒖刂苽鬟f給函數(shù)，以及函數(shù)完成動作所需的參數(shù)。

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

函數(shù)定義

使用關(guān)鍵字函數(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ù)被調(diào)用時，你傳遞一個值到參數(shù)。 參數(shù)是可選的; 也就是說，一個函數(shù)可能不包含參數(shù)。 參數(shù)也可以有默認值。

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

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

內(nèi)置功能

內(nèi)置函數(shù)的簡單示例是seq()，mean()，max()，sum(x)和paste(...)等。它們由用戶編寫的程序直接調(diào)用。 您可以參考最廣泛使用的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)生以下結(jié)果 -

[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)建，它們就可以像內(nèi)置函數(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)
   }
}

調(diào)用函數(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)生以下結(jié)果 -

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

調(diào)用沒有參數(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)生以下結(jié)果 -

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

使用參數(shù)值調(diào)用函數(shù)（按位置和名稱）
函數(shù)調(diào)用的參數(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)生以下結(jié)果 -

[1] 26
[1] 58

使用默認參數(shù)調(diào)用函數(shù)
我們可以在函數(shù)定義中定義參數(shù)的值，并調(diào)用函數(shù)而不提供任何參數(shù)以獲取默認結(jié)果。 但是我們也可以通過提供參數(shù)的新值來獲得非默認結(jié)果來調(diào)用這樣的函數(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)生以下結(jié)果 -

[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)生以下結(jié)果 -

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

十二.字符串

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

在字符串構(gòu)造中應(yīng)用的規(guī)則

在字符串的開頭和結(jié)尾的引號應(yīng)該是兩個雙引號或兩個單引號。它們不能被混合。

  • 雙引號可以插入到以單引號開頭和結(jié)尾的字符串中。

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

  • 雙引號不能插入以雙引號開頭和結(jié)尾的字符串。

  • 單引號不能插入以單引號開頭和結(jié)尾的字符串。

有效字符串的示例

以下示例闡明了在? 語言中創(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)

當我們運行腳本失敗給下面的結(jié)果。

...: 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用于消除兩個字符串之間的空格。但不是一個字符串的兩個字內(nèi)的空間。

例

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)生以下結(jié)果 -

[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ù)。

  • 科學(xué)設(shè)置為TRUE以顯示科學(xué)記數(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)生以下結(jié)果 -

[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)生以下結(jié)果 -

[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)生以下結(jié)果 -

[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)生以下結(jié)果 -

[1] "act"

十三.向量

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

創(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)生以下結(jié)果 -

[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)生以下結(jié)果 -

[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)生以下結(jié)果 -

[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ù)

如果其中一個元素是字符，則非字符值被強制轉(zhuǎn)換為字符類型。

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

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

[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)生以下結(jié)果 -

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

向量操作

向量運算

可以添加，減去，相乘或相除兩個相同長度的向量，將結(jié)果作為向量輸出。

# 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)生以下結(jié)果 -

[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
向量元素回收

如果我們對不等長的兩個向量應(yīng)用算術(shù)運算，則較短向量的元素被循環(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)生以下結(jié)果 -

[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)生以下結(jié)果 -

[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)生以下結(jié)果 -

[[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)生以下結(jié)果 -

$`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)生以下結(jié)果 -

$`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)生以下結(jié)果 -

[[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)生以下結(jié)果 -

[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 3

[[4]]
[1] "Sun"

[[5]]
[1] "Mon"

[[6]]
[1] "Tue"

將列表轉(zhuǎn)換為向量

列表可以轉(zhuǎn)換為向量，使得向量的元素可以用于進一步的操作?？梢栽趯⒘斜磙D(zhuǎn)換為向量之后應(yīng)用對向量的所有算術(shù)運算。要做這個轉(zhuǎn)換，我們使用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)生以下結(jié)果 -

[[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ù)學(xué)計算。

使用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)生以下結(jié)果 -

     [,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)生以下結(jié)果 -

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

矩陣計算

使用R運算符對矩陣執(zhí)行各種數(shù)學(xué)運算。 操作的結(jié)果也是一個矩陣。
對于操作中涉及的矩陣，維度（行數(shù)和列數(shù)）應(yīng)該相同。

矩陣加法和減法
# 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)生以下結(jié)果 -

     [,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)生以下結(jié)果 -

     [,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)生以下結(jié)果 -

, , 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)生以下結(jié)果 -

, , 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)生以下結(jié)果 -

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ù)組由多維構(gòu)成矩陣，所以對數(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)生以下結(jié)果 -

     [,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ù)集的名稱。

  • 有趣的是要應(yīng)用于數(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)生以下結(jié)果 -

, , 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)生以下結(jié)果 -

 [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)生以下結(jié)果 -

  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

更改級別順序

可以通過使用新的等級次序再次應(yīng)用因子函數(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)生以下結(jié)果 -

 [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是給出復(fù)制數(shù)目的整數(shù)。

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

例

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

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

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

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

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

  • 列名稱應(yīng)為非空。
  • 行名稱應(yīng)該是唯一的。
  • 存儲在數(shù)據(jù)幀中的數(shù)據(jù)可以是數(shù)字，因子或字符類型。
  • 每個列應(yīng)包含相同數(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)生以下結(jié)果 -

 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ù)幀的結(jié)構(gòu)

通過使用str()函數(shù)可以看到數(shù)據(jù)幀的結(jié)構(gòu)。

# 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)生以下結(jié)果 -

'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ù)摘要

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

# 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)生以下結(jié)果 -

     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)生以下結(jié)果 -

  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)生以下結(jié)果 -

  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)生以下結(jié)果 -

  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)生以下結(jié)果 -

  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ù)幀相同結(jié)構(gòu)的新行，并使用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)生以下結(jié)果 -

  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語言——進階篇

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容