[코딩] Circle Square

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열