3. 자료구조(객체타입)
1. vector : 1차원 배열
2. matrix : 2차원 배열
1. vector : 1차원 배열형태의 자료구조. - 동일한 데이터만 저장
1 벡터 생성
year <- 2021
is.vector(year) # is.vector() : 벡터인지 확인
name <-'tom'
is.vector(name)
year
year[1] # index가 1부터 시작
seq(1,5) # seq() : 수열 생성
1:5
seq(1,10,2) # 1~10까지 2 간격으로 생성.
seq(1,10,length.out = 4) # 1~10까지 간격이 같은 4개의 수열.
rep(1:3, 3) # 1~3까지 3번 반복. 1 2 3 1 2 3 1 2 3
rep(1:3, times=3) # 동일
rep(1:3, each=3) # 1~3까지 각각 반복. 1 2 3 1 2 3 1 2 3
aa <- c(10,20,30,-10,-5)
x<- c(1,3,5)
y<- c(1:3,1:3)
2 이름 설정
age <- c(10,20,30)
names(age) <- c("홍길동", "김길동", "이길동") # names(x) <- : age에 이름을 설정
age[1] # index로 값 호출
age["홍길동"] # 이름으로 값 호출
age[10] <- 50 # 없는 값은 NA
length(age) # 길이는 10
age <- NULL # NULL값 set
3 우선순위
kk <- c(1, 3, FALSE, T, 3.5, 'hi') # 벡터는 값은 데이터 타입을 가지기 때문에 우선순위에 따라 전체 타입이 정해짐
# 우선순위 : 문자열 > 실수 > 정수 > bool
4 벡터 요소 조회(index) : 슬라이싱
v1 <-c(13,-5,20:23, 12, -2:3)
v1 <- append(v1, 60, after=5) # v1벡터의 5번째 인자 이후에 60이 들어간다.
v1[1] # 첫번째 값. index 1부터 시작
v1[c(1, 3, 6)] # 1, 3, 6 인덱스 값
v1[1:5] # 1~5 인덱스 값
v1[c(3, 5, 1, 8, 9)]
v1[-1] # 1번째 요소를 제외한 나머지를 반환
v1[-c(1, 3, 5)] # 1, 3, 5번째 요소를 제외한 나머지
5 연산
# 하나의 벡터 연산
a <-1:5
a + 5 # 각 요소에 연산적용
a ^ 2 # 제곱
a ** 2 # 제곱
sqrt(a) # 제곱근
sqrt(a) ** 2 # a
# 두 개의 벡터 연산
a <- 1:3
b <- 4:6
a + b # 각 index끼리 연산
a * b
a + 10
a[4] <-2
b[4] <-2
6 집합
a # 1 2 3 2
b # 4 5 6 2
union(a,b) # 합집합. 중복값 하나만 포함. 1 2 3 4 5 6
c(a, b) # 중복 허용. 1 2 3 2 4 5 6 2
setdiff(a,b) # 차집합. a-b 1 3
intersect(a, b) # 교집합 2
2. matrix : 2차원 배열
1
a <- 1:8
dim(a) <- c(2, 4) # 2행 4열의 2차원 배열을 생성.(a의 원소)
# [,1] [,2] [,3] [,4]
#[1,] 1 3 5 7
#[2,] 2 4 6 8
class(a) # "matrix" "array"
m <- matrix(1:5) # 5행 1열
m
dim(m) # 5행 1열
m <- matrix(1:9, nrow = 3) # 3열
# [,1] [,2] [,3]
#[1,] 1 4 7
#[2,] 2 5 8
#[3,] 3 6 9
m <- matrix(1:9, nrow = 3, byrow = T) # 행 우선
# [,1] [,2] [,3]
#[1,] 1 2 3
#[2,] 4 5 6
#[3,] 7 8 9
m2 <- matrix(1:10,2) # 2행
dim(m2) # 2 5
m2 <- matrix(1:9, 3) # 3행
class(m2) # matrix array
2 인덱싱
m2[1,] # 1행 전체
m2[,1] # 1열 전체
m2[2,3] # 2행 3열
m2[2,2:4] # 2행 2,3,4열
3 이름 설정
m2 <- matrix(1:12, 3)
colnames(m2) <- c("a", "b", "c", "d")
rownames(m2) <- c("r1", "r2", "r3")
# a b c d
# r1 1 4 7 10
# r2 2 5 8 11
# r3 3 6 9 12
4 연산
a <- matrix(c(1,2,3,4),2,2)
b <- matrix(5:8, 2)
a + b
a - b
a * b
a %*% b # 행렬 곱(내적)
diag(a) # 행, 열 인덱스가 같은 라인의 요소
diag(2)
# 1 0
# 0 1
solve(a) # 역행렬
solve(solve(a))
a %*% solve(a) %*% a
5 행 묶음
x1 <- c(5, 40, 50:52)
# 5 40 50 51 52
x2 <- c(30, 5, 6:8)
# 30 5 6 7 8
mr <- rbind(x1, x2) # 행 묶음
# [,1] [,2] [,3] [,4] [,5]
# x1 5 40 50 51 52
# x2 30 5 6 7 8
mc <- cbind(x1, x2) # 열 묶음
# x1 x2
# [1,] 5 30
# [2,] 40 5
# [3,] 50 6
# [4,] 51 7
# [5,] 52 8
6. apply()
x <- matrix(1:9, 3)
# [,1] [,2] [,3]
# [1,] 1 4 7
# [2,] 2 5 8
# [3,] 3 6 9
apply(x, 1, max) # max함수를 실행하는 함수(행방향)
# 7 8 9
apply(x, 1, min) # min함수를 실행하는 함수(행방향)
apply(x, 1, mean) # 행 방향 평균
# 4 5 6
apply(x, 2, mean) # 열 방향 평균
# 2 5 8
func <- function(x){
x + c(5, 10, 15)
}
func(x)
# [,1] [,2] [,3]
# [1,] 6 9 12
# [2,] 12 15 18
# [3,] 18 21 24
apply(x, 1, func) # 행렬 or 배열에 적용
# [,1] [,2] [,3]
# [1,] 6 7 8
# [2,] 14 15 16
# [3,] 22 23 24
lapply(x, func) # 결과가 list
# [[1]]
# [1] 6 11 16
# [[2]]
# [1] 7 12 17
# [[3]]
# [1] 8 13 18
# [[4]]
# [1] 9 14 19
# [[5]]
# [1] 10 15 20
# [[6]]
# [1] 11 16 21
# [[7]]
# [1] 12 17 22
# [[8]]
# [1] 13 18 23
# [[9]]
# [1] 14 19 24
sapply(x, func) # 결과가 벡터, 행렬 or 배열
# [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9]
# [1,] 6 7 8 9 10 11 12 13 14
# [2,] 11 12 13 14 15 16 17 18 19
# [3,] 16 17 18 19 20 21 22 23 24
iris # 붓 꽃 데이터 Sepal.Length Sepal.Width Petal.Length Petal.Width Species
dim(iris) # 150 5
apply(iris[,1:4], 2, mean)
lapply(iris[,1:4], mean)
sapply(iris[,1:4], mean)
3. Array : 다차원 배열
d <- c(1:12)
class(d) # class 확인- "integer"
is.vector(d) # TRUE
arr1 <- array(d) # array() : 배열 생성함수
class(arr1) # class 확인- "array"
is.vector(arr1) # FALSE
is.array(arr1) # TRUE
dim(arr1) # 12
arr2 <- array(c(1:12), dim=c(6,2))
# [,1] [,2]
# [1,] 1 7
# [2,] 2 8
# [3,] 3 9
# [4,] 4 10
# [5,] 5 11
# [6,] 6 12
dim(arr2) # 6 2
arr3 <- array(c(1:12), dim=c(3,2,2))
# , , 1
#
# [,1] [,2]
# [1,] 1 4
# [2,] 2 5
# [3,] 3 6
#
# , , 2
#
# [,1] [,2]
# [1,] 7 10
# [2,] 8 11
# [3,] 9 12
dim(arr3) # 3 2 2 - 행 열 면
arr3[,,1]
arr3[,1,1]
arr3[1,,1]
arr3[1,1,1]
a1 <- array(1:8, dim = c(2,2,2))
a2 <- array(8:1, dim = c(2,2,2))
a1 + a2
a1 * a2
a1 %*% a2
sum(a1 * a2)
4. List : 서로 다른 타입의 자료를 기억 가능. java의 레코드형 기억장소. c: 구조체.
li <- list('1', '이순신', 70, '2', '한송이', 80)
class(li) # list
unli <- unlist(li) # list에서 되돌리기
num <- list(1:5, 6:10, c("a", "b", "c")) # 1, 2, 3 key에 값을 넣는다.
num[1]; print(class(num[1])) # list
num[[1]]; print(class(num[[1]])) # integer
num[[1]][2] # 1번 list의 index 2번의 값
num2 <- list(x=1:5, y=6:10) # x, y key에 값을 넣는다.
num2$x # num list의 x key의 데이터
num2$y
mem <- list(name='tom', age=22) # name, age key에 값을 넣는다.
a<-list(c(1:5)) # 1~5
b <- list(6:10) # 6~10
result <- lapply(c(a,b), max) # 결과 값을 list로 반환
# [[1]]
# [1] 5
#
# [[2]]
# [1] 10
5. DataFrame : DB의 테이블 구조와 유사.
- vetor로 DataFrame 생성
no <- c(1,2,3)
name <- c("tom", "james", "jonh")
pay <- c(300, 400, 500)
df <- data.frame(bunho = no, irum = name, imkum = pay)
#bunho irum imkum
#1 1 tom 300
#2 2 james 400
#3 3 jonh 500
class(df) # data.frame
df[1:2]
df[c(1,3)]
df[2,2]
df[-1,]
df[,-1]
df <- data.frame(irum = c('aa', 'bb', 'cc'), nai = c(22,25,33), row.names = c("one","two", "three"))
df
nrow(df) # 행 수
ncol(df) # 열 수
str(df) # 구조
names(df) # 이름 확인
head(df, n=2) # 앞의 2개 데이터 출력
tail(df, n=2) # 뒤의 2개 데이터 출력
names(iris)
head(iris,3)
class(iris) # data.frame
class(Nile) # ts
class(ChickWeight) #"nfnGroupedData" "nfGroupedData" "groupedData" "data.frame"
- matrix로 DataFrame 생성
m <- matrix(c(1,'hong',300,2,'lee',350,3,'kim',320), 3, by =T)
# [,1] [,2] [,3]
# [1,] "1" "hong" "300"
# [2,] "2" "lee" "350"
# [3,] "3" "kim" "320"
mdf <- data.frame(m)
colnames(mdf) <- c("c1", "c2", "c3") # column name설정
# c1 c2 c3
# 1 1 hong 300
# 2 2 lee 350
# 3 3 kim 320
mdf$c1 # column data
mdf['c1'] # column data
mdf[1,2] # 1행 2열
