Vectors

26 Sep 2022 in Notes / Dataanalytics / R / R Programming Language

Vectors don’t start with index 0

• Important
  • 헷갈리는 데이터 접근법 (index와 값)
• 벡터의 생성과 연산 (01)
  • Create Vector
  • Vector 연산
  • Vector 연결
  • 단일 유형의 값으로 구성되는 벡터
  • 연습문제
• 벡터의 인덱싱과 비교연산자 (02)
  • 연습문제
  • 내장 변수 (built-in variable)
  • vector와 indexing
  • 연습 문제
  • 비교/논리 연산자
• 백터와 함수 I (03)
  • 벡터와 함수 function
  • 함수 sample
  • 함수 str
  • 함수 rep
  • 함수 seq
  • 연습문제
• 벡터와 함수 II (04)
  • 데이터타입 변환
  • 함수 names
  • 함수 print vs. 함수 cat
  • 함수 round
  • 함수 which
  • 함수 length
  • 함수 sum
  • 함수 table
  • 값 편집
• 몇 가지 함수와 파일 (05)
  • Value Matching
  • 집합론 함수
  • 벡터 정렬
  • 연습문제
  • 텍스트 파일 불러오기
  • 조건을 이용한 검색 및 추출
  • 값의 편집
• 벡터 연습과 활용 (06)
  • 연습문제 모음

Important

헷갈리는 데이터 접근법 (index와 값)

> x <- 10:1
> (x>3 & x<8)
 [1] FALSE FALSE FALSE TRUE TRUE TRUE TRUE FALSE FALSE FALSE
> x[ x>3 & x<8 ]
 [1] 7 6 5 4
> x[ which( x>3 & x<8 )]
 [1] 7 6 5 4
> which( x>3 & x<8 )
 [1] 4 5 6 7 #index 값 반환

벡터의 생성과 연산 (01)

Create Vector

> 1
[1] 1
# str() 하면 벡터형식으로 출력 X
> str( "apple" )
 chr "apple"
> str( 1.25 )
 num 1.25
> str( 3L )
 int 3
> str( TRUE )
 logi TRUE
> str(2+3i)
 cplx 2+3i

> a <- 1:30         # 1~30
> b <- 5.5:20.5     # 5.5 ~ 20.5(포함)
> c <- 5.5:20.6     # 5.5 ~ 20.5 까지만
> d <- 5.5:20.4     # 5.5 ~ 19.5 까지만
> a
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 [25] 25 26 27 28 29 30
> b
 [1]  5.5  6.5  7.5  8.5  9.5 10.5 11.5 12.5 13.5 14.5 15.5 16.5 17.5 18.5
 [15] 19.5 20.5
> c
 [1]  5.5  6.5  7.5  8.5  9.5 10.5 11.5 12.5 13.5 14.5 15.5 16.5 17.5 18.5
 [15] 19.5 20.5
> d
 [1]  5.5  6.5  7.5  8.5  9.5 10.5 11.5 12.5 13.5 14.5 15.5 16.5 17.5 18.5
 [15] 19.5

Vector 연산

• vector 끼리의 연산은 제어구문 (for loop같은) 필요 없음

x <- c( 1, 3, 5, 6, 9 )   #[1] 1 3 5 6 9
y <- c( 2, 4, 6, 8, 10)   #[1] 2 4 6 8 10

방법 #1

z <- x + y      #[1]  3  7 11 14 19

방법 #2

- 변수에 저장X
y - 2    # [1]  0 2 4 6 8
y * 3    # [1]  6 12 18 24 30

방법 #3

z <- c( 3, 7, 11, 14, 19)   #총 5개

z * c( 2, 4, 5)     #되긴 되는데 WARNING 뜸 . 5개의 항목을 3개 번갈아가기 부족
[1] 3  14  33  56  95  18  49  88 126 190
    WARNING

z * 1:10            #바로됨 (총 5개의 항목을 10 => 각 2번씩 사용)
[1]  3  14  33  56  95  18  49  88 126

Vector 연결

x <- c( 'A', 'B', 'C' )
y <- c( "a", "b", "c" )
#아래 두 연결방법은 같은 결과를 가진다
z <- c( x, y )                                      #[1] "A" "B" "C" "a" "b" "c"
z <- c( c( 'A', 'B', 'C' ), c( "a", "b", "c" ) )    #combining 2 combined vectors

단일 유형의 값으로 구성되는 벡터

#같은 유형의 값으로 바뀜
a <- c( 1, 2, "3" )     #[1] "1" "2" "3"
b <- c( 1, 2, "A" )     #[1] "1" "2" "A"

연습문제

• 밑 답 출력하게 코드 작성

1. a #[1] 1 2 3 4 5 6 7 8 9 10

a <- 1:10

2. b #[1] 10 9 8 7 6 5 4 3 2 1

b <- 10:1

3. c #[1] 11 11 11 11 11 11 11 11 11 11

c <- a+b

4. c #[1] "1" "2" "3" "4" "5" "6" "7" "8" "9" "10" "10" "9" "8" "7" "6" "5" "4" "3" "2" "1" "0"

d <- c( a, b, "0" )

벡터의 인덱싱과 비교연산자 (02)

연습문제

1. > class('2+4')

[1] "character"

2. > a <- c('red', 'green', "yellow") > class(a); str(a); is.vector(a)

[1] "character"
[1] chr [1:3] "red" "green" "yellow"
[1] TRUE

3. > z <- c( 3, 7, 11, 15, 19) > z * c(2,4,5)

[1] 6, 28, 55, 30, 76
Warning 어쩌고...

내장 변수 (built-in variable)

• letters : “a” ~ “z” in 벡터
• LETTERS : “A” ~ “Z” in 벡터
• month.name : “January” ~ “December” in 벡터
• month.abb : “Jan” ~ “Dec” in 벡터

vector와 indexing

• month.abb[ 1 ] : [1] “Jan”
• month.abb[ 2 ] : [1] “Feb”
• month.abb[ 1:5 ] : [1] “Jan” “Feb” “Mar” “Apr” “May”
• month.abb[ c( 1, 3, 5) ] : [1] “Jan” “Mar” “May”
• month.abb[ c( 2, 1, 1, 3) ] : [1] “Feb” “Jan” “Jan” “Mar”
  
  
• month.abb[ c( -1, -3, -5) ] : [1] “Feb” “Apr” “Jun” “Jul” “Aug” “Sep” “Oct” “Nov” “Dec”
• month.abb[ -c( 1, 3, 5) ] : [1] “Feb” “Apr” “Jun” “Jul” “Aug” “Sep” “Oct” “Nov” “Dec”
  • -c( 1, 3, 5) : [1] -1 -3 -5
• month.abb[ -c( 1: 5 ) ] : [1] “Jun” “Jul” “Aug” “Sep” “Oct” “Nov” “Dec”
  • -c( 1: 5 ) : [1] -1 -2 -3 -4 -5
• month.abb[ -1:5 ] : “Error in month.abb[-1:5] : only 0’s may be mix
  • c( -1: 5 ) : [1] -1 -0 1 2 3 4 5

Vector does have index 0

• month.abb[ 0 ] : character(0)

연습 문제

1. > month.abb[1:3]

[1] "Jan" "Feb" "Mar"

2. > month.abb[1:3][c(TRUE, FALSE, TRUE)]

[1] "Jan" "Mar"

3. > month.abb[c(TRUE, FALSE, TRUE)]

[1] "Jan" "Mar" "Apr" "Jun" "Jul" "Sep" "Oct" "Dec"

4. > month.abb[1:3][c(1,0,1)]

[1] "Jan" "Jan" #0은 아무 역할도 안한다..

5. > month.abb[1:3][c(1,1,1)]

[1] "Jan" "Jan" "Jan"

비교/논리 연산자

& : and
| : or

> month.abb == "Feb"
 [1] FALSE  TRUE FALSE FALSE FALSE FALSE FALSE
 [8] FALSE FALSE FALSE FALSE FALSE
> month.abb == 'Feb' | month.abb == 'Jan'
 [1] TRUE TRUE FALSE FALSE FALSE FALSE FALSE
 [8] FALSE FALSE FALSE FALSE FALSE
> month.abb == 'Feb' | 'Jan'
 Error ...

1. > month.abb != 'Feb' | month.abb != 'Jan

[1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE 
(all true)

2. > month.abb != 'Feb' & month.abb != 'Jan'

[1] FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE TRUE  TRUE  TRUE  TRUE  TRUE

3. month.abb[ month.abb == 'Feb' ]

[1] "Feb"

4. month.abb[ month.abb != 'Feb' ]

[1] "Jan" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"

5. month.abb[ month.abb == 'Feb' | month.abb == 'Jan' ]

[1] "Jan" "Feb"

 > x <- 10 : 1
 [1] 10 9 8 7 6 5 4 3 2 1

1. x <= 7

[1] FALSE FALSE FALSE TRUE TRUE TRUE TRUE TRUE TRUE TRUE

2. x > 8 | x < 3

[1] TRUE TRUE FALSE FALSE FALSE FALSE FALSE FALSE TRUE TRUE

3. x[ (x > 8 | x < 3) ]

 [1] 10  9  2  1

4. x[ x != 8 ]

[1] 10  9  7  6  5  4  3  2  1

교훈:
month.abb[‘Jan’] = [1] NA
[대괄호] 안에 index를 넣어야한다 (context가 아닌)

1. > month.abb[ -c( 1:5 ) ]

[1] "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"

2. > month.abb[ c( TRUE, FALSE, TRUE ) ]

[1] "Jan" "Mar" "Apr" "Jun" "Jul" "Sep" "Oct" "Dec"

 > x <- 30 : 1
 [1] 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 [25] 25 26 27 28 29 30

3. [1] "Jan" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"

> month.abb[month.abb!='Feb']

4. [1] 1 2 3 4 5 6 7 8 9 21 22 23 24 25 26 27 28 29 30

> x[ x< 10 | x>20 ] 
> x[-10:-20]

5. [1] 30 29 28 27 26 25 24 23 22 21 20 19 18 17 ..역방향

> x[ c(30:1) ]
> x[ 30: 1 ]

백터와 함수 I (03)

벡터와 함수 function

> a <- 1:5
[1] 1 2 3 4 5

length(a) : [1] 5
sum(a) : [1] 15
mean(a) : [1] 3

함수 sample

sample ( data_name, size = 5, replace = T )

• 주어진 데이터에서 랜덤으로 샘플링 해주는 함수
  > sample ( data_name, 5, T ) - 중복 허용 replace = T - 중복 허용 안할 시 size는 데이터의 사이즈보다 커야 함
  
• 확률 추가
  > sample ( data_name, size = 5, replace = T, prob=c(0.2, 0.2, 0.8) )
  [1] 3 3 2 3 3
• 미중복, 무작위
  > x <- sample(10) [1] 7 3 6 2 9 10 5 4 1 8 (무작위, 미중복)

함수 str

이거 다시 정리

> x <- sample(10)   # [1] 7 3 6 2 9 10 5 4 1 8
> y <- sample(letters, 10, replace = F )  #[무작위로 10개 뽑음, 중복 없이]

> str(x)
int [1:10] 7 3 6 2 9 10 5 4 1 8
> str(y)
chr [1:10] "l" "n" "v" ... #10개

함수 rep

> rep ( c(1, 2, 3), 4 )     #times = 4
[1] 1 2 3 1 2 3 1 2 3 1 2 3

• Replicate 함수
  
• rep함수의 2번째 parameter은 정수 (반복횟수와 관련있기 때문)
• times: rep ( c(1, 2, 3), times = 4 ) [1] 1 2 3 1 2 3 1 2 3 1 2 3

• each: rep ( c(1, 2, 3), each = 4 ) [1] 1 1 1 1 2 2 2 2 3 3 3 3

  • each = vector 시도 시 Warning 출력
• vector: TIMES와 같이 동작한다.
  • rep( 1:3 , 1:3 ) [1] 1 2 2 3 3 3
  • rep( 1:3 , 1:2 ) Warning
  • rep( 1:3 , 3:1 ) 1 1 1 2 2 3
  • rep( 1:3 , c(2, 4, 6) ) 1 1 2 2 2 2 3 3 3 3 3 3

함수 seq

• 아래는 다 같은 결과를 출력한다

> 1:10
> seq(1, 10)
> seq(1, 10 , 1)
> seq( from = 1, to = 10 )
> seq( from = 1, to = 10, by = 1)

• 인자명 붙일 시 순서 변경 가능
  • 예: seq( by = 2, to = 10, from = 3) # [1] 3, 5, 7, 9
• 인자명 3개 중 2개만 써도 됨
  • 예: seq( 2, to = 10, from = 3) # [1] 3, 5, 7, 9
  • [참고] : 하나만 쓸 시 Error 발생
• seq( 10, 2, 3 ) => Error

• seq( 10, 2, -3 ) [1] 10 7 4

• seq 에 length 인자 추가

  • seq( 1, 8, length = 5 ) [1] 1.00 2.75 4.50 6.25 8.00
  • length == length
• seq 에 length 와 by 인자 추가
  • seq( 1, by = 3, length = 5 ) [1] 1 4 7 10 13

연습문제

1. > rep( c( 1, 2, 3), 1:3)

[1] 1 2 2 3 3 3

2. > rep( c( 1, 2, 3), each = 2)

[1] 1 1 2 2 3 3 

3. > y <- seq( 1.5, 5, 1) ; [1] 1 2 3 4로 만들기

> as.integer(y) 

4. letters 거꾸로<

> letters[length(letters):1] 

5. letters 한개씩 건너뛰기

> letters[seq(1, length(letters), 2)] 

6. letters a는 한번, z는 26번까지

> rep(letters, 1:length(letters))

벡터와 함수 II (04)

데이터타입 변환

> x <- 1:5
> class(x)  #[1] "integer"
> str(x)    # int [1:5] 1 2 3 4 5
> as.numeric(x) #[1] 1 2 3 4 5
> class(as.numeric(x))  #[1] "numeric"

> z <- letters[1:5]     #[1] "a" "b" "c" "d" "e"
> as.numeric(z)
 [1] NA NA NA NA NA
 경고 메시지 ...

함수 names

> x <- 1:3
> names(x) <- c( "one", "two" "three" )
> x
  one    two     three
    1      2        3
> class(x)
[1] "integer"
> str(x)
 Named int [1:3] 1 2 3
 - attr(*, "names") = chr [1:3] "one" "two" "three"

• named int 가 붙는다

• names(x) : [1] “one” “two” “three”
• unname(x) : [1] 1 2 3

> x[1]
one
  1
> x[1:2]
one  two
  1    2
> x[ 'one' ]
one
  1
> x[ c( 'one', 'three')]
  one three
    1    3
> x[ 'one' : 'two' ]
 Error 어쩌고...

• names 할 경우 hash처럼 index가 붙는듯 함

함수 print vs. 함수 cat

> x
  one  two  three
    1    2      3

print	cat
> print( x ) one two three 1 2 3	> cat( x ) 1 2 3 >(nextcommand) > cat( x, '\n') => 정상 출력
print( names( x )) [1] "one" "two" "three"	cat( names( x ), '\n' ) one two three
> print( unname( x )) [1] 1 2 3	> cat( unname( x ), '\n' ) 1 2 3
> print( as.vector(x)) [1] 1 2 3	전자 출판
> as.vector(x) [1] 1 2 3	> cat( as.vector( x ), '\n') 1 2 3
기본: vector로 출력	기본: 그냥 출력

• print(a) 는 다른 변수에 저장 됨
• cat(a), str(a) 는 한번은 출력하지만 변수에 저장은 안됨 (호출 시 NULL 출력)

함수 round

> x <- seq( 3.4, 3.49, 0.01 )
> x
 [1] 3.40 3.41 3.42 3.43 3.44 3.45 3.46 3.47 3.48 3.49
> round( x, 1 )
 [1] 3.4 3.4 3.4 3.4 3.4 3.4 3.5 3.5 3.5 3.5

• 이처럼 3.45는 3.5가 아닌 3.4로 round될 수 있다. IEEE 기준, 이진수 연산에 따른 오차이다.

함수 which

> x <- 10 : 1
> x
 [1] 10 9 8 7 6 5 4 3 2 1
> x == 4
 [1] FALSE FALSE FALSE FALSE FALSE FALSE TRUE FALSE FALSE FALSE
> which(x == 4)
 [1] 7
> x > 3 & x < 6
 [1] FALSE FALSE FALSE FALSE FALSE TRUE TRUE FALSE FALSE FALSE
> which ( x>3 & x<6 )
 [1] 6 7
> x[ x>3 & x<6 ]
 [1] 5 4
> x[which( x>3 & x<6 )]
 [1] 5 4

• which함수는 index값을 반환한다.
• 인자로는 조건이 들어간다

함수 length

1. > length( which ( letters == "a" | letters == "b"))

[1] 2

2. > length( which ( letters != "a" & letters != "b"))

[1] 24

3. > length( letters == "a" | letters == "b")

[1] 26  #결과는 TRUE 또는 FALSE 값 26개가 나온다

4. > length( letters != "a" | letters != "b")

[1] 26  #결과는 TRUE 또는 FALSE 값 26개가 나온다

함수 sum

> x
 [1] 10 9 8 7 6 5 4 3 2 1
> sum(x)
 [1] 55
> sum(x==4)
 [1] 1          #TRUE 값 하나
> sum( x>8 | x<3 )
 [1] 4          #TRUE 값 4개

함수 table

> x
[1] 10 9 8 7 6 5 4 3 2 1
> table(x)
x
 1  2  3  4  5  6  7  8  9 10
 1  1  1  1  1  1  1  1  1  1
> class(table(x))
 [1] "table"

> str(table(x))
 'table' int [1:10(1d)] 어쩌고..나옴

> table( x==4 )
FALSE   TRUE
    9      1
> table( x>8 | x<3 )
FALSE    TRUE
    6       4

• 각 항목이 몇 개 있는지 알려준다

값 편집

> x
 [1] 10 9 8 7 6 5 4 3 2 1
> x[ which( x>8 ) ] <- NA
> x
 [1] NA NA 8 7 6 5 4 3 2 1
> x[ x< 3 ] <- NA
 [1] NA NA 8 7 6 5 4 3 NA NA

몇 가지 함수와 파일 (05)

Value Matching

> x <- c("a", "b", "c", "d")
> y <- c( "g", "x", "d", "e", "f", "a", "c")
> z <- c( "g", "a", "d", "e", "c", "a", "c")    #a, c 중복
> match(x, y)
[1] 6 NA 7 3
> x %in% y
[1] TRUE FALSE TRUE TRUE
> match(x, y)
[1] 2 NA 5 3
> x %in% y
[1] TRUE FALSE TRUE TRUE
> which( y %in% x)  #True의 index값 변환
[1] 2 3 5 6 7

• match : x를 기준으로 y가 있다면 y의 index값 반환
• %in% : x를 기준으로 x 개수 만큼 TRUE FALSE 값 반환
• which : True의 index값 변환

집합론 함수

• unique(x), union(x,y), intersect(x, y), setdiff(x,y)
• any( 조건 ), all( 조건 )

> unique(y)
 [1] "g" "a" "d" "e" "c"
> union( x, y )
 [1] "a" "b" "c" "d" "g" "e"
> union( y, x )
 [1] "g" "a" "d" "e" "c" "b"
> intersect( x, y )
 [1] "a" "c" "d"
> intersect( y, x )
 [1] "a" "d" "c"
> setdiff( x, y )
 [1] "b"
> setdiff( y, x )
 [1] "g" "e"

> x
 [1] 1 2 3 4 5 6 7 8 9 10
> any( x> 8)
 [1] TRUE
> any( x> 10 )
 [1] FALSE
> all( x> 8 )
 [1] FALSE
> all( x> 0)
 [1] TRUE

벡터 정렬

> x <- c("a", "b", "c", "d")
> y <- c( "g", "a", "d", "e", "c", "a", "c")
> sort(x, decreasing= T)
[1] "d" "c" "b" "a"

> order(x)
[1] 1 2 3 4
> order(x, decreasing = T)
[1] 4 3 2 1
> order(y)
[1] 2 6 5 7 3 4 1

• sort : 실제 값 sort
• order : sorted의 index값 보여줌

연습문제

1. > x <- 10:1 ; x == 4

[1] FALSE FALSE FALSE FALSE FALSE FALSE TRUE FALSE FALSE FALSE

2. > which( x == 4)

[1] 7

3. > x <- 1:3 ; names(x) <- c( "one", "two", "three"); x;

one  two  three
  1    2      3

4. letters를 반대로 출력</code>

letters[ order(letters, decreasing = T)]

5. letters를 반대로 하나씩 건너뛰면서 출력</code>

letters[ seq(length(letters), 1, -2 )]

텍스트 파일 불러오기

# 파일 불러오기
TEXT <- scan(file = "filename.txt", what = "char", quote = NULL)
Read xxx items
#파일 저장하기 (한줄씩)
cat(TEXT, file = "vector.txt.", sep= "\n")

• head(TEXT) #첫 5 단어
• tail(TEXT) #마지막 5단어
• head(TEXT, 10) #첫 10 단어

조건을 이용한 검색 및 추출

> TEXT[TEXT == "a" ]
[1] "a" "a" "a" "a" ....
> length( TEXT[ TEXT == "a" ])
[1] 13
> TEXT[TEXT=="AJSLFIEJF"]
character(0)    #txt파일이 character이기 때문

값의 편집

> TEXT[TEXT=="an"] <- "a"
> TEXT[TEXT == "an"]
character(0)            #성공적

벡터 연습과 활용 (06)

연습문제 모음

1. > length(TEXT[TEXT=="a" | TEXT=="the"])시 [1] 35 나오게

    TEXT <- scan( file= "03_WhatIsR.txt", what = "char", quote = NULL )
    TEXT[TEXT=="an"] <- "a"
    TEXT[TEXT=="The"] <- "the"

2. "a"가 총 18개일때, "a" 다음 단어 출력

    TEXT[which(TEXT=="a")+1]

• 답: “language”, “GNU”, “different”..etc

3. 변수명 Sample을 어휘 타입(type) 또는 표제어목록으로 구성되는 벡터로 만드시오.

    Sample <- unique(TEXT)

4. 변수명 Sample을 알파벳 오름차순, 내림차순으로 정렬

    sort(Sample)
    sort(Sample, decreasing = T)

5. 벡터 Sample을 알파벳 내림차순으로 정렬하여변수명 S2로 저장하고 벡터 S2에 대해 원소의 순서에 따라 다음과 같이1, 2, 3, …의 출력결과를 갖도록 만드시오.

    S2 <- sort(Sample, decreasing = T)
    names(S2) <- c(1:length(S2))

6. 벡터 Sample을 알파벳 내림차순으로 정렬하여변수명 S2로 저장하고 벡터 S2에 대해 원소의 순서에 따라 다음과 같이1, 2, 3, …의 출력결과를 갖도록 만드시오.

    S2 <- sort(Sample, decreasing = T)
    names(S2) <- c(1:length(S2))

7. 벡터 TEXT (03_WhatIsR.txt)와 벡터 TEXT2 (03_CakeRecipe.txt)에서 공통적으로 사용된어휘타입/표제어 목록을 변수명 S3로 만드시오

    S3 <- intersect(unique(TEXT), TEXT2)

8. 벡터 TEXT2 (03_CakeRecipe.txt)에서는 사용되지않은, 즉, 벡터 TEXT (03_WhatIsR.txt)에서만사용된 사용된 어휘 타입/표제어 목록을 변수명 S4로만드시오. 그 후 라인단위로 오름차정렬된 S4을 출력하시오.

    S4 <- setdiff(TEXT, TEXT2)
    cat(S4, file = "S4.txt", sep = "\n")