类型数据R

Il tipo di dati è un sistema vasto utilizzato per dichiarare variabili o funzioni di diversi tipi.

Il tipo della variabile determina lo spazio di memoria utilizzato dalla variabile e come interpretare il modello di bit memorizzato.

I tipi di dati più basilari in R sono principalmente tre:

• Numerico

• Logico

• Testo

I costanti numerici principali hanno due tipi:

Il tipo logico, in molti altri linguaggi di programmazione, è chiamato Booleano (Boolean), i valori costanti sono TRUE e FALSE.

Attenzione:R distingue tra maiuscole e minuscole, true o True non rappresentano TRUE.

Il tipo di dati più diretto è il tipo di testo. Il testo è come la stringa (String) appare in altri linguaggi, i costanti sono racchiuse tra virgolette doppi.

> 'w3codebox' == "w3codebox"
[1] TRUE

La definizione delle variabili in R non è come nelle regole sintattiche di linguaggi di programmazione a tipo forte, non è necessario assegnare un nome e un tipo di dati specifici alle variabili, ogni volta che si utilizza l'operatore di assegnazione in R, si definisce una nuova variabile:

a = 1
b <- TRUE
b = "abc"

Divisi per tipo di oggetto, ci sono 6 tipi (che saranno spiegati più avanti):

• Vettore (vector)

• Lista (list)

• Matrice (matrix)

• Array (array)

• Fattore (factor)

• Data frame (data frame)

Vettore

Il vettore (Vector) è spesso fornito nelle librerie standard di linguaggi di programmazione specifici come Java, Rust, C#, poiché il vettore è uno strumento indispensabile per le operazioni matematiche - i vettori più comuni sono i vettori bidimensionali, che sono necessari nel sistema di coordinate piane.

Dal punto di vista della struttura dati, un vettore è una lista lineare e può essere considerato come un array.

In R, il vettore come tipo esiste e rende le operazioni sui vettori più facili:

> a = c(3, 4)
> b = c(5, 0)
> a + b
[1] 8 4
>

c() è una funzione per creare vettori.

Qui si sommano due vettori bidimensionali per ottenere un nuovo vettore bidimensionale (8, 4). Se si esegue un'operazione tra un vettore bidimensionale e un vettore tridimensionale, si perde il significato matematico, anche se il programma non si fermerà, ma verrà avvisato.

Consiglio di evitare questo tipo di situazione abitudinale.

Ogni elemento del vettore può essere estratto singolarmente tramite l'indice:

> a = c(10, 20, 30, 40, 50)
> a[2]
[1] 20

Attenzione:Consiglio di evitare questa situazione abitudinale.

R può anche estrarre facilmente una parte del vettore:

> a[1:4] # Estrarre il 1° fino al 4° elemento, inclusi il 1° e il 4°
[1] 10 20 30 40
> a[c(1, 3, 5)] # Estrarre il 1°, il 3° e il 5° elemento
[1] 10 30 50
> a[c(-1, -5)] # Rimuovere il 1° e il 5° elemento
[1] 20 30 40

Questi tre metodi di estrazione parziale sono tra i più comuni.

I vettori supportano i calcoli scalari:

> c(1.1, 1.2, 1.3) - 0.5
[1] 0.6 0.7 0.8
> a = c(1, 2)
> a ^ 2
[1] 1 4

Le funzioni di calcolo matematico comuni descritte in precedenza, come sqrt, exp, ecc., possono anche essere utilizzate per eseguire calcoli scalari sui vettori.

"Vettore" come struttura di elenco lineare dovrebbe avere alcune funzioni di elaborazione di elenchi lineari comuni, R ha davvero queste funzioni:

Ordinamento vettoriale:

> a = c(1, 3, 5, 2, 4, 6)
> sort(a)
[1] 1 2 3 4 5 6
> rev(a)
[1] 6 4 2 5 3 1
> order(a)
[1] 1 4 2 5 3 6
> a[order(a)]
[1] 1 2 3 4 5 6

La funzione order() restituisce un vettore di indici dopo l'ordinamento del vettore.

Statistica vettoriale

In R ci sono funzioni statistiche molto complete:

Esempio di statistica vettoriale:

> sum(1:5)
[1] 15
> sd(1:5)
[1] 1.581139
> range(1:5)
[1] 1 5

Generazione di vettori

La generazione di vettori può essere fatta con c() La generazione della funzione può essere fatta anche con l'operatore min:max per generare sequenze continue.

Se si desidera generare una sequenza aritmetica con intervalli, si può utilizzare seq Funzione:

> seq(1, 9, 2)
[1] 1 3 5 7 9

seq può generare una sequenza aritmetica da m a n, è sufficiente specificare m, n e la lunghezza della sequenza:

> seq(0, 1, length.out=3)
[1] 0.0 0.5 1.0

Rep significa repeat (ripetere), può essere utilizzato per generare una sequenza di numeri ripetuti:

> rep(0, 5)
[1] 0 0 0 0 0

Questi termini NA e NULL vengono utilizzati spesso nei vettori, ecco una breve introduzione delle loro differenze:

• NA rappresenta 'assente', NULL rappresenta 'in esistenza'.

• NA è come un segnaposto, rappresenta che in questa posizione non c'è un valore, ma la posizione esiste.

• NULL rappresenta la mancanza di dati.

Esempio di spiegazione:

> length(c(NA, NA, NULL))
[1] 2
> c(NA, NA, NULL, NA)
[1] NA NA NA

Chiaramente, NULL non ha alcun significato nel vettore.

Logico

I vettori logici sono utilizzati principalmente per le operazioni logiche sui vettori, ad esempio:

> c(1, 2, 3) > 2
[1] FALSE FALSE TRUE

La funzione which è molto comune e utilizzata per gestire vettori logici, può essere utilizzata per筛选我们需要的数据的下标:

> a = c(1, 2, 3)
> b = a > 2
> print(b)
[1] FALSE FALSE TRUE
> which(b)
> m1[1,3] # 第 1 行 第 3 列

Ad esempio, dobbiamo filtrare i dati da una lista lineare che sono maggiori o uguali a 60 e minori di 70:

> vector = c(10, 40, 78, 64, 53, 62, 69, 70)
> print(vector[which(vector >= 60 & vector < 70)])
[1] 64 62 69

Esistono funzioni simili come all() e any():

> all(c(TRUE, TRUE, TRUE))
[1] TRUE
> all(c(TRUE, TRUE, FALSE))
[1] FALSE
> any(c(TRUE, FALSE, FALSE))
[1] TRUE
> any(c(FALSE, FALSE, FALSE))
[1] FALSE

all() viene utilizzato per verificare se tutti i valori di un vettore logico sono TRUE, mentre any() verifica se il vettore logico contiene TRUE.

Stringa

Il tipo di dati stringa non è complesso di per sé, qui ci concentriamo sull'introduzione delle funzioni di operazione delle stringhe:

> toupper('w3codebox')  # 转换为大写
[1] "w3codebox"
> tolower('w3codebox')  # 转换为小写
[1] "w3codebox"
> nchar('中文', type='bytes')  # 计算字节长度
[1] 4
> nchar("中文", type="char")  # 总计字符数量
[1] 2
> substr("123456789", 1, 5)  # 截取字符串，从 1 到 5
[1] "12345"
> substring("1234567890", 5)  # 截取字符串，从 5 到结束
[1] "567890"
> as.numeric("12")  # 将字符串转换为数字
[1] 12
> as.character(12.34)  # 将数字转换为字符串
[1] "12.34"
> strsplit("2019;10;1", ";")  # 分隔符拆分字符串
[[1]]
[1] "2019" "10" "1"
> gsub("/", "-", "2019/10/1")  # 替换字符串
[1] "2019-10-1"

在 Windows 计算机上实现，使用的是 GBK 编码标准，所以一个中文字符是两个字节，如果在 UTF-8 编码的计算机上运行，单个中文字符的字节长度应该是 3。

R 支持 perl 语言格式的正则表达式：

> gsub("[[:alpha:]]+", "$", "Two words")
[1] "$ $"

更多字符串内容参考：R 语言字符串介绍.

矩阵

R 语言为线性代数的研究提供了矩阵类型，这种数据结构很类似于其它语言中的二维数组，但 R 提供了语言级的矩阵运算支持。

首先看看矩阵的生成：

> vector=c(1, 2, 3, 4, 5, 6)
> matrix(vector, 2, 3)
　　　　　[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6

矩阵初始化内容是由一个向量来传递的，其次要表达一个矩阵有几行、有几列。

向量中的值会一列一列的填充到矩阵中。如果想按行填充，需要指定 byrow 属性：

> matrix(vector, 2, 3, byrow=TRUE)
　　　　　[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6

矩阵中的每一个值都可以被直接访问：

> m1 = matrix(vector, 2, 3, byrow=TRUE)
>　m1[1,1]　#　第　1　行　第　1　列　
> m1[1,1] # 第 1 行 第 1 列
[1] 1
> m1[1,3] # 第 1 行 第 3 列

[1] 3

> R中的矩阵的每一个列和每一行都可以设定名称，这个过程通过字符串向量批量完成：
> colnames(m1) = c("x", "y", "z")
> rownames(m1) = c("a", )
　　> m1["a", ]
> m1
a 1 2 3
b 4 5 6
> m1["a", ]　
x y z

1 2 3

运算矩阵的四则与向量基本一致，既可以与标量做运算，也可以与同规模的矩阵做对应位置的运算。

> m1 = matrix(c(1, 2), 1, 2)
> m2 = matrix(c(3, 4), 2, 1)
> m1 %*% m2
　　　　　[,1]
[1,] 11

逆矩阵：

> A = matrix(c(1, 3, 2, 4), 2, 2)
> solve(A)
　　　　　[,1] [,2]
[1,] -2.0 1.0
[2,] 1.5 -0.5

函数apply()可以将矩阵的每一行或每一列当作向量来进行操作：

> (A = matrix(c(1, 3, 2, 4), 2, 2))
　　　　　[,1] [,2]
[1,] 1 2
[2,] 3 4
> apply(A, 1, sum) # 第二个参数为 1 按行操作，用 sum() 函数
[1] 3 7
> apply(A, 2, sum) # 第二个参数为 2 按列操作
[1] 4 6

更多内容矩阵参考：矩阵R.