남미 여행 다녀온지 5개월이 지난 것 같다. (_._)


Fastcampus에서 공부를 시작한지 3주차에 접어들었다.


2주 동안 한 학기 분량의 통계를 공부하는건 힘들다....


친구들과 국내여행은 매번 못 가는 것 같다. 언제쯤 갈 수 있으려나?

'Daily life' 카테고리의 다른 글

2017 하반기 회고  (0) 2017.11.30
넋두리 02  (0) 2017.08.22

강의 : [Fast campus] Data Science with R 1기 - 이부일 강사님

공부하면서 배운 내용 복습 겸 정리하는 곳입니다.


# R에서 제공해주는 hflights 패키지 사용
# 예제 데이터 : hflights::hflights
# 패키지::데이터 : 괄호가 없으면 데이터 불러오기

자료의 종류 : 통계적인 관점

  # 질적 자료 vs 양적자료

  # 질적 자료 : 글자(문자), 숫자(의미가 없는 숫자)

  # 양적 자료 : 숫자(의미가 있는 숫자 - 사칙연산이 가능)


일변량(Uni-variate) 질적 자료의 분석

  # 일변량 => 하나의 열


1. 표 = 빈도표 

  # 빈도(frequence), 백분율(percent)


  (1) 빈도 : table(데이터명$변수명)

# R에서 table은 질적자료의 빈도를 구할 때 많이 사용

1
2
3
4
5
> sort(table(hflights$Month),
+      decreasing = TRUE)
 
    7     8     6     3     5    12     1    10     4     9    11     2 
20548 20176 19600 19470 19172 19117 18910 18696 18593 18065 18021 17128
cs


  (2) 백분율 = (빈도/합계) * 100

# prop.table(빈도결과) * 100

# prop = proportional(비율)

# 비율 : 0~1 / 백분율 : 0~100

# 백분율은 소수점 한 자리 까지만 보고서에 작성 

1
2
3
4
5
6
> round(sort(prop.table(table(hflights$Month))*100,
+            decreasing = TRUE),
+       digits = 1)
 
  7   8   6   3   5  12   1  10   4   9  11   2 
9.0 8.9 8.6 8.6 8.4 8.4 8.3 8.2 8.2 7.9 7.9 7.5
cs


     ## prettyR 패키지

# prettyR::freq(데이터명$변수명)

1
2
3
4
5
6
7
> prettyR::freq(hflights$Month)
 
Frequencies for hflights$Month 
        7    8    6      3     5    12    1     10     4     9    11     2    NA
     20548 20176 19600 19470 19172 19117 18910 18696 18593 18065 18021 17128  0
%       9  8.9  8.6  8.6  8.4  8.4  8.3  8.2  8.2  7.9  7.9  7.5    0 
%!NA    9  8.9  8.6  8.6  8.4  8.4  8.3  8.2  8.2  7.9  7.9  7.5
cs

# 결과는 백분율과 유효백분율이 나타남

# 유효백분율 : 실질적으로 응답한 사람(NA제외)

# display.na = FALSE : 유효백분율이 출력되지 않음



2. 그래프 : 막대그래프(세로, 가로), 원그래프

  (1) 막대그래프

# barplot(빈도결과) - 기본 세로 막대그래프

# 그래프에 다양한 arguments를 추가

1
2
3
4
5
6
barplot(sort(table(hflights$Month), decreasing = TRUE),
        col  = "skyblue",
        main = "월별 운항의 현황",
        ylab = "운항 횟수",
        ylim = c(025000)
)
cs

   # 막대 색깔 : col = "color"

# 그래프 제목 : main = "제목"

# y축 제목 : ylab = "축제목"

   ylab = y label의 약자

   y축 제목은 꼭 써야한다.

# y축 눈금 : ylim = c(최소값, 최대값)

   ylim = y limit의 약자

   y축의 최소값은 0으로 해야된다.

   * 절단효과 : 최소값을 올리게 되면 전체적인 차이가 더 크게 보일 수 있기 때문


# 가로 막대 그래프 : horiz = TRUE

1
2
3
4
5
6
7
barplot(sort(table(hflights$Month), decreasing = TRUE),
        col   = "skyblue",
        main  = "월별 운항의 현황",
        xlab  = "운항 횟수",
        xlim  = c(025000),
        horiz = TRUE
) 
cs

가로 막대 그래프로 변경 했기에 xlab, xlim 으로 바꿔야 함

젤 위에 가장 큰 값을 주어야 한다. => 내림차순


  

(2) 원그래프

# pie(빈도)

# 원 그래프는 조각이 5개 이하인 경우에만 사용

1
2
3
pie(sort(table(hflights$Month), decreasing = TRUE),
    radius     = 1.0,
    init.angle = 90)
cs

# 반지름 : radius = 0.8 (기본값)

# 첫 번째 조각의 각도 : init.angle = 



  일변량(Uni-variate) 양적 자료의 분석


1. 표

  # 구간의 빈도, 백분율

  # 최소값, 최대값

1
2
3
> range(hflights$ArrDelay,
+       na.rm = TRUE)
[1-70 978
cs

  

  # 구간의 개수 구하는 법

1. Sturge's : 1+3.3*log10(데이터의 개수)

1
2
> 1 + 3.3*log10(length(hflights$ArrDelay))
[118.67801
cs


2. sqrt(데이터의 개수) 

1
2
> sqrt(length(hflights$ArrDelay))
[1476.9654
cs

... 기타 등


  # 구간의 폭 = 계급의 폭

  # (최대값 - 최소값) / 구간의 개수

  # 첫 번째 구간에는 최소값 포함, 마지막 구간에는 최대값이 포함되어야 함    

1
2
3
4
5
> range(hflights$ArrDelay, na.rm = TRUE)
[1-70 978
 
> diff(range(hflights$ArrDelay, na.rm = TRUE))
[11048
cs

  # diff(숫자)

  # diff( c(1, 3, 5) ) => 3-1 / 5-3 => 2개씩 짝 지어서 계산됨

1
2
> diff( c(135)
[12 2
cs


  # cut을 통해 내가 원하는 구간별로 나눌 수 도 있다.

1
2
3
4
5
hflights$ArrDelay.group = cut(hflights$ArrDelay,
                              breaks = seq(from = -120,
                                           to = 1020,
                                           by = 60),
                              right = FAㅣSE
cs


2. 그래프

  (1) 히스토그램(Histogram)

i. hist(데이터명$변수명) : Sturge 공식 적용

1
hist(hflights$ArrDelay)
cs


ii. hist(데이터명$변수명, breaks = 구간의 개수)

1
2
hist(hflights$ArrDelay,
     breaks = 100)
cs


iii. hist(데이터명$변수명, breaks = 구간의 정보)

1
2
3
4
5
6
hist(hflights$ArrDelay,
     breaks = seq(from = -120,
                  to = 1020,
                   by = 60),
     xlim = c(-1201020))
 
cs

  

  (2) 상자그림(Boxplot) : 이상치 유무 판별

i. boxplot(데이터명$변수명)

1
boxplot(hflights$ArrDelay)
cs


ii. 집단별 상자그림

# boxplot(데이터명$변수명 ~ 데이터명$변수명)

# boxplot(     양적자료        ~      질적자료      )

# R의 관점에서 factor형태로 되어 있어야 한다.

1
2
boxplot(hflights$ArrDelay ~ hflights$Origin)
boxplot(hflights$ArrDelay ~ hflights$Month)
cs

# boxplot을 통해 각 이상치를 제거할까? 변환할까? 등을 판별


3. 기술통계량 = 요약통계량 => 숫자

  # Descriptive Statistics = Summary Statistics


  # 모수(Parameter)       vs  통계량(Statistics)

  # 모집단(Population)   vs  표본(Sample)


  # 기술통계량, 요약통계량 => 표본에서 나온 것

  # 모수는 모집단이 어떻게 형태인지 알려주는 수많은 숫자들

  # 모집단의 평균, 표준편차, 최소값, 최대값... 등 => 모수 (하지만 현실에서는 대부분 알 수 없다.)

  # 표본에서 나온 평균, 표준편차, 최소값, 최대값... 등 => 통계량

  # 양적 자료를 바탕으로 다양한 숫자를 만들어내는 것 = 통계량

  # 통계적 추론 : 표본으로 부터 나온 통계량을 바탕으로 모집단의 모수들을 추측


  (1) 중심 = 대표값

# 평균, 절사평균, 중위수(중앙값), 최빈수(최빈값)

# 절사평균 : 평균은 이상치(Outlier)에 영향을 많이 받는다. -> 이상치를 뺀 평균

# 최빈수 : 동일한 값이 많이 나타난 수


i. 평균

# mean(데이터명$변수명, na.rm = TRUE)

1
2
> mean(hflights$ArrDelay, na.rm = TRUE)
[17.094334
cs

# 하지만 이 평균을 가지고 분석을 시행하기에는 위험하다.

# 이상치(Outlier)의 존재 때문


ii. 5% 절사평균(Trimmed Mean)

# mean(데이터명$변수명, trim = 0.05, na.rm = TRUE)

# 작은쪽, 큰쪽 각 5%씩 절사해서 90%의 평균을 계산하여 분석

# 5%는 바꿔도 되는 기준

1
2
3
4
5
> mean(hflights$ArrDelay, trim = 0.05, na.rm = TRUE)
[13.121585
 
> mean(hflights$ArrDelay, trim = 0.1, na.rm = TRUE)
[11.847091
cs


iii. 중위수

# median(데이터명$변수명, na.rm = TRUE)

1
2
> median(hflights$ArrDelay, na.rm = TRUE)
[10
cs

# 중위수 0을 기준으로 일찍 오거나 늦게 온 비행기가 50%씩 존재한다.


iv. 최빈수(Mode)

  1) which.max(table(데이터명$변수명)

1
2
> which.max(c(1053200))
[14
cs

  # 벡터의 가장 큰 값 200의 index를 알려준다.


1
2
3
> which.max(table(hflights$ArrDelay))
-4 
54 
cs

  # -4가 54번째 있었다.

  # ArrDelay 데이터에서 4분 일찍 도착한 게 가장 많았다.


  2) prettyR::Mode()

1
2
> prettyR::Mode(hflights$ArrDelay)
[1"-4"
cs


  (2) 퍼짐 = 산포 = '다름' 

# 통계는 '다름'이 존재하기에 분석한다. 이 다름의 차이를 수치화 하여 나타냄

# 이 '다름'은 왜 발생했을까?

# 범위, 사분위수범위, 분산

# 표준편차(평균과의 차이), 중위수 절대편차(중위수와 차이)

# 범위와 표준편차는 이상치(Outlier)에 영향을 많이 받는다.

# 중위수 절대편차는 이상치(Outlier)의 영향을 적게 받는다.


i. 범위(Range)

1
2
> range(hflights$ArrDelay, na.rm = TRUE)
[1-70 978
cs

# R에서 range()는 최소값, 최대값 2개를 알려준다.

# diff()를 통해 2개의 차이를 계산

1
2
> diff(range(hflights$ArrDelay, na.rm = TRUE))
[11048
cs

# 범위는 이상치의 영향을 많이 받는다.

# 그래서 나온게 사분위수 범위


ii. 사분위범위 = 사분위수범위 = IQR(Inter Quartile Range)

# IQR(데이터명$변수명, na.rm = TRUE)

1
2
> IQR(hflights$ArrDelay, na.rm = TRUE)
[119
cs

# 범위(1048) , 사분위범위(19) 의 차이는 다르다.

# 사분위범위를 보고 항공기들은 19분정도 늦거나 일찍 도착하네 라고 생각 할 수 있음.


iii. (표본) 분산(Variance)

# 모든 데이터에서 평균을 빼고 제곱을 한다.

# 데이터 - 평균 : 편차(Deviation) => 편차를 다 더하면 0 => 따라서 제곱한 값을 사용

# 통게는 데이터의 합계가 아닌 '자유도'로 나눈다

# df : degree of freedom

# var(데이터명$변수명, na.rm = TRUE)

1
2
> var(hflights$ArrDelay, na.rm = TRUE)
[1943.013
cs

# 분산은 각 데이터 제곱을 통해 계산하므로 ArrDelay의 결과는 '분의 제곱'이다.


iv. (표본) 표준편차(SD : Standard Deviation)

# sd(데이터명$변수명, na.rm = TRUE)

1
2
> sd(hflights$ArrDelay, na.rm = TRUE)
[130.70852
cs

# 평균은 7분 정도 늦는데, 각 데이터들마다 평균과의 차이가 다름

# 여기서 평균과의 차이는 약 30분(표준편차)

# 즉, -27분 ~ 37분 범위 안에서 대부분 도착한다.

# 표준편차가 작다 - 평균이랑 가까운 데이터들

# 표준편차가 크다 - 평균이랑 먼 데이터들


v. 중위수 절대편차(MAD : Median Absolute Deviation)

# mad(데이터명$변수명, na.rm = TRUE)

1
2
> mad(hflights$ArrDelay, na.rm = TRUE)
[113.3434
cs

# 중위수 절대편차를 기준으로 비행기들이 13분 늦거나 일찍오는구나 라고 생각


  (3) 분포의 모양

# 데이터는 하나가 아니라 여러개다.

# R의 기본 기능에서는 못 구함 - 왜도, 첨도

i. 왜도(Skewness) : 대칭여부

# 왜도가 0에 가까운 값이라면 '데이터들이 대칭이다' 라고 볼 수 있다.

# 왜도가 0에서 멀어진다면 ' 데이터들이 비대칭이다'라고 볼 수 있다.

# 왜도 > 0 : 이상하게 큰 애가 있다면 오른쪽으로 긴 곡선

# 왜도 < 0 : 이상하게 작은 애가 있다면 왼쪽으로 긴 곡선


ii. 첨도(Kurtosis) : 중심이 얼마나 뾰족한가?

# 첨도가 0에 가까운 값이라면 중심이 보통높이

# 첨도 > 0 : 중심이 높아진다 -> 비슷한 데이터가 많이 있다.

# 첨도 < 0 : 중심이 낮아진다 -> 비슷한 데이터가 적다.


# psych::describe(), describeBy()

# R에서 by가 있다면 항상 집단별로 무엇을 한다는 의미

1
2
3
> psych::describe(hflights$ArrDelay)
   vars      n mean    sd median trimmed   mad min max range skew kurtosis   se
X1    1 223874 7.09 30.71      0    1.85 13.34 -70 978  1048 5.04    55.57 0.06
cs

# 결과 중 se : standard error(표준오차) : 0.06

# 지금 표본에서 평균이 7.09분이 나왔는데,

# '다른 표본'을 뽑으면 평균이 지금 표본의 평균과 달라질 것이다.

# 그렇다면 얼마나 달라질까를 알려주는 값 -> 표준오차


# psych::describeBy(데이터명$변수명, 데이터명$변수명)

# psych::describeBy(양적자료, 질적자료)

1
2
3
4
5
6
7
8
9
10
> psych::describeBy(hflights$ArrDelay, hflights$Origin)
 
 Descriptive statistics by group 
group: HOU
   vars     n mean    sd median trimmed   mad min max range skew kurtosis   se
X1    1 51309 7.49 31.95     -1    1.77 11.86 -44 822   866 4.98    46.08 0.14
---------------------------------------------------------------- 
group: IAH
   vars      n mean    sd median trimmed   mad min max range skew kurtosis   se
X1    1 172565 6.98 30.33      0    1.87 13.34 -70 978  1048 5.05    58.88 0.07
cs


# summary(데이터명$변수명)

# 질적 자료 = 빈도, 백분율 / 만약에 factor라면 빈도만 알려줌

# 양적 자료 = 6개(최소값, 최대값, 평균, 123사분위수)


# by(양적자료, 질적자료, 함수명)

1
2
3
4
5
6
> by(hflights$ArrDelay, hflights$Origin, mean, na.rm = TRUE)
hflights$Origin: HOU
[17.487946
---------------------------------------------------------------- 
hflights$Origin: IAH
[16.977301
cs

# 공항이 2개가 있는데 각 공항에 대하서 ArrDelay에 대한 평균을 구해줘

# 질적자료를 기준으로 양적자료에 함수를 적용한 결과를 알려줌

[Fast campus] Data Science with R 1기 - 이부일 강사님

공부하면서 배운 내용 복습 겸 정리하는 곳입니다.


# R.utils 패키지를 통해 printf() 사용 가능

install.packages("R.utils")

library(R.utils)


1. 반복문 : for

  # 동일한 일을 여러 번 하거나

  # 비슷한 일을 여러 번 할 때

1
2
3
4
5
6
7
8
9
10
11
12
13
> for(i in 1:10){
+   cat("hello,", i, "\n")
+ }
hello, 1 
hello, 2 
hello, 3 
hello, 4 
hello, 5 
hello, 6 
hello, 7 
hello, 8 
hello, 9 
hello, 10
cs

  # in은 대입, 할당하는 역할

  # 1:10 => 데이터의 개수(10개) 만큼 for문이 시행된다.

  # cat 대신 printf("hello, %d \n", i) 를 사용해도 동일한 결과 출력


  # 구구단

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
> for(i in 1:9){
+   cat(i, "단 이에요!""\n")
+   for(j in 1:9){
+     cat(i, "x", j, "=", i*j, "\n")
+   }
+   cat("\n")
+ }
 
1 단 이에요! 
1 x 1 = 1 
1 x 2 = 2 
1 x 3 = 3 
1 x 4 = 4 
1 x 5 = 5 
1 x 6 = 6 
1 x 7 = 7 
1 x 8 = 8 
1 x 9 = 9 
...
cs

  # 2~9단도 동일한 결과로 출력됨



2. 조건문

  (1) if( 조건 ){ 실행문 } - 조건이 TRUE면 실행문을 실행

1
2
3
4
5
6
7
8
9
> x = c(1003060)
> for(i in 1:3){
+   if(x[i] > 50){
+     printf("%d Very large number!!! \n", x[i])
+   } 
+ }
 
100 Very large number!!! 
60 Very large number!!!
cs


  (2) if (조건문) { 조건이 참일 때 실행문 1} 
       else{ 조건이 거짓일 때 실행문 2}

1
2
3
4
5
6
7
8
> y  = 10
> if(y > 5){
+   print("Large!!")
+ } else{
+   print("Small!!")
+ }
 
[1"Large!!"
cs


  (3) if( 조건문1) { 실행문 1 }

      else if( 조건문 2) { 실행문 2}

      else{ 실행문 3 }

# else if 조건 추가 가능

1
2
3
4
5
6
7
8
9
10
> z = 7
> if(z>10){
+   print("Large")
+ } else if(z>5){
+   print("medium")
+ } else{
+   print("small")
+ }
 
[1"medium"
cs



3. 사용자 함수

  # 함수명 = function( ) { 실행문 }

1
2
3
4
5
6
7
8
9
10
11
12
> hello = function(){
+   print("hello, world")
+   return("hello, fastcampus")
+ }
 
> hello()
[1"hello, world"
[1"hello, fastcampus"
 
> x = hello()
> x
[1"hello, world"
cs

  # return 의 의미를 생각


  # 숫자 x를 입력받으면 x*3 을 해주는 함수 작성

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
> triple = function(x){
+   if(mode(x) == "numeric"){
+  #if(is.numeric(x)) 을 사용해도 된다
+     tmp = 3*x
+     return (tmp)
+   } else{
+     print("숫자를 넣어주세요")
+   }
+ }
 
> triple(10)
[130
 
> triple("10")
[1"숫자를 넣어주세요"
cs


  # 구구단 : 해당 숫자의 구구단을 출력

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
> gugudan = function(x){
+   if(is.numeric(x)){
+     printf("%d단 \n", x)
+     for(i in 1:9){
+       printf("%d x %d = %d \n", x,i,x*i)
+     }
+   } else{
+     print("숫자를 넣어주세요")
+   }
+ }
 
> gugudan(3)
3단 
3 x 1 = 3 
3 x 2 = 6 
3 x 3 = 9 
3 x 4 = 12 
3 x 5 = 15 
3 x 6 = 18 
3 x 7 = 21 
3 x 8 = 24 
3 x 9 = 27
cs


[Fast campus] Data Science with R 1기 - 이부일 강사님

공부하면서 배운 내용 복습 겸 정리하는 곳입니다.


6. 새로운 변수 만들기

  # 데이터$변수명 = 연산(수식)

  # bmi 수치를 계산해서 새로운 변수로 추가

1
student$bmi = student$weight / ((student$height/100)^2)
cs


  # ifelse(조건, 참일 때 표현식, 거짓일 때 표현식)

  # 30대 이상 / 20대 이하를 나타내는 새로운 변수(age_group)를 추가

1
student$age_group = ifelse(student$age >= 30"30대 이상""20대 이하")
cs


  # 20대 초반, 20대 중반, 30대 이상으로 나뉘는 age_group2를 만들어라

1
2
student$age_group = ifelse(student$age >= 30"30대 이상",
                            ifelse(student$age >= 25"20대 중반""20대 초반")

cs


  # cut(데이터명$변수명, breaks = 구간정보) => numeric data에 적용

   경도 비만(1단계 비만) : 25 - 30

   과체중 : 23 - 24.9

   정상 : 18.5 - 22.9

   저체중 : 18.5 미만

1
2
student$bmi_group = cut(student$bmi, 
                        breaks = c(018.5232530))
cs

  # 데이터의 결과를 보면 ( ] 와 같이 소괄호 괄호로 표현된다

  # (18.5, 23] => 18.5 초과 23이하

  # ( ) 소괄호는 초과

  # [ ] 대괄호는 이하

  # 0과 30 초과 값들은 NA로 입력이됨

  # 위 코드에 right = FALSE 라는 argument 를 추가해보자

1
2
3
student$bmi_group = cut(student$bmi, 
                        breaks = c(018.5232530), 
                        right  = FALSE)
cs

  # right = FALSE 를 하게되면 괄호의 위치가 바뀌게 됨

  # [18.5, 23) => 18.5 이상 23미만

  # 30 이상의 값들은 NA로 표시됨


  # 각 행들의 평균 구하기

1
score$avg = rowMeans(score[ , 2:6])
cs

  # 각 열들의 평균은 colMeans( ) 



7. 데이터의 값을 수정하기

  # home 이라는 데이터

1
2
3
4
5
6
7
8
9
10
11
> home
# A tibble: 7 x 4
     id  room price  area
  <dbl> <dbl> <dbl> <dbl>
1     1     1    40     13
2     2     4 50000    55
3     3     3 20000    35
4     4     3 50000    35
5     5     1    43     2
6     6     4 50000    45
7     7     1   500    15
cs
  
  # 500이라는 값을 변경
1
2
3
4
5
6
7
8
9
10
11
12
> home[home$price == 500"price"] = 50
> home
# A tibble: 7 x 4
     id  room price  area
  <dbl> <dbl> <dbl> <dbl>
1     1     1    40     1
2     2     4 50000    55
3     3     3 20000    35
4     4     3 50000    35
5     5     1    43     2
6     6     4 50000    45
7     7     1    50    15 
cs



8. 데이터 정렬하기

  (1) 벡터를 정렬하기 : sort(벡터, decreasing = )

      # 기본값 = 오름차순

1
2
3
4
5
6
> money = c(455040505030500)
> sort(money)
[1]  30  40  45  50  50  50 500
 
> sort(money, decreasing = TRUE
[1500  50  50  50  45  40  30
cs

 

  (2) order(데이터명$변수명, decreasing = )

  # sort는 벡터에서만 사용가능

  # data.frame에서는 order 함수를 사용

1
2
> order(money)
[16 3 1 2 4 5 7
cs

  # order는 정렬될 인덱스를 알려준다.

  # data.frame에서 데이터 정렬은 행이 바뀌는 것

  # 슬라이싱의 행 자리에 order가 들어간다.


# 성별 내림차순

1
student[ order(student$height, decreasing = TRUE) , ]
cs


# 성별 내림차순 / 키 내림차순

1
student[ order(student$gender, student$height, decreasing = TRUE ) , ]
cs


# 성별 오름차순 / 키 내림차순

# 조건이 다르니 -를 사용

1
student[ order(student$gender, -student$height) , ]
cs


# 성별 내림차순 / 키 오름차순

# - 는 numeric에만 적용 가능

1
student[ order(student$gender, -student$height, decreasing = TRUE ) , ]
cs


# 성별 오름차순 / 거주지 내림차순

# character 타입의 데이터를 따로 정렬하려면? 

# - 는 numeric에만 적용된다 => 기본 기능에서는 불가능

# data.table 패키지를 사용하여 데이터를 data.table로 변경

1
studentDT = as.data.table(student), ]
cs
# str(studentDT)를 통해 확인해보면 data.frame, data.table 2가지 형태를 모두 인식하는 것을 볼 수 있다.

1
studentDT[ order(gender, -address) , ]  
cs

# 데이터의 column에 바로 접근 가능

# 결과를 콘솔 화면에 보여주기만 함

 

1
setorder(studentDT, gender, -address)  
cs

# setorder( ) 를 사용하면 데이터를 정렬해서 결과 저장


※ data.frame vs data.table 참고

http://using.tistory.com/81 

# data.table()_cheet sheet 확인

# setkey(), J(), fread() 공부



9. 데이터 합치기

  (1) rbind(데이터1, 데이터2, ... ) => 위, 아래로 데이터 합치기


  (2) merge(데이터1, 데이터2, ..., by=, all=, all.x=, all.y=)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
> df4 = data.frame(id  = c(1247),
+                  age = c(10204070))
> df5 = data.frame(id = c(123610),
+                  gender = c("M""M""F""M""F"))
> df4;df5
  id age
1  1  10
2  2  20
3  4  40
4  7  70
  id gender
1  1      M
2  2      M
3  3      F
4  6      M
5 10      F
cs


# merge 4가지 방법

① inner join(교집합)

# inner join은 2가지 데이터만, 3가지 이상은 다른 기능으로

# by는 PK(Primary Key) => 데이터를 구분해주는 값 

# PK 예) 사람-주민등록번호, 회사직원-사원

1
2
3
4
> merge(df4, df5, by="id")
  id age gender
1  1  10      M
2  2  20      M
cs


# outer join

② full join(합집합) - all=TRUE

1
2
3
4
5
6
7
8
9
> merge(df4, df5, by="id", all=TRUE)
  id age gender
1  1  10      M
2  2  20      M
3  3  NA      F
4  4  40   <NA>
5  6  NA      M
6  7  70   <NA>
7 10  NA      F
cs

# R에서 숫자는 NA / 문자는<NA>로 표시해서 구분해준다.


③ left join - all.x=TRUE

1
2
3
4
5
6
> merge(df4, df5, by="id", all.x=TRUE)
  id age gender
1  1  10      M
2  2  20      M
3  4  40   <NA>
4  7  70   <NA>
cs


④ right join - all.y=TRUE

1
2
3
4
5
6
7
> merge(df4, df5, by="id", all.y=TRUE)
  id age gender
1  1  10      M
2  2  20      M
3  3  NA      F
4  6  NA      M
5 10  NA      F
cs



10. R데이터 저장하기

  (1) 외부 데이터로 저장하기

1
2
3
write.csv(student,
          file      = "fs/data/student.csv",
          row.names = FALSE)
cs

# row.names = FALSE 를 주게되면 행 이름은 저장하지 않음


  (2) R데이터로 저장하기

1
save(R데이터, file = "파일위치/파일명.RData")
cs


  (3) R데이터 불러오기

1
load(file = "파일위치/파일명.RData") 
cs


[Fast campus] Data Science with R 1기 - 이부일 강사님

공부하면서 배운 내용 복습 겸 정리하는 곳입니다.


Data Handling = Data Pre-processing


## 사용할 데이터 읽어오기

# 외부 데이터를 읽어오면 data.frame 형태로 저장된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
> student = readxl::read_excel(path = "fs/data/student.xlsx",
+                              sheet = "data",
+                              col_names = TRUE)
> student
# A tibble: 12 x 8
      id gender   age height weight  address
   <dbl>  <chr> <dbl>  <dbl>  <dbl>    <chr>
 1     1   남자    29    188     80   구파발
 2     2   남자    28    185     63     강동
 3     3   남자    25    172     63 압구정동
 4     4   여자    24    160     48     수원
 5     5   남자    26    180     80     용인
 6     6   남자    26    188     77     성수
 7     7   남자    59    170     63     수원
 8     8   여자    25    160     45     분당
 9     9   남자    27    178     78     강동
10    10   남자    31    181     95     의왕
11    11   여자    27    167     58     길동
12    12   남자    40    175     70     부산
# ... with 2 more variables: major <chr>,
#   company <chr>
cs


1. 데이터 전체보기

  (1) View(데이터) 

View(student)

# 별도의 팝업 창으로 데이터를 볼 수 있음

  

  (2) 데이터 : 콘솔(Console)에 출력

student



2. 데이터 구조(Structure) 보기

  (1) str(데이터)

str(student)

1
2
3
4
5
6
7
8
9
10
> str(student)
Classes ‘tbl_df’, ‘tbl’ and 'data.frame':    12 obs. of  8 variables:
 $ id     : num  1 2 3 4 5 6 7 8 9 10 ...
 $ gender : chr  "남자" "남자" "남자" "여자" ...
 $ age    : num  29 28 25 24 26 26 59 25 27 31 ...
 $ height : num  188 185 172 160 180 188 170 160 178 181 ...
 $ weight : num  80 63 63 48 80 77 63 45 78 95 ...
 $ address: chr  "구파발" "강동" "압구정동" "수원" ...
 $ major  : chr  "경영정보학" "산업경영학" "경영학" "수학" ...
 $ company: chr  "NC소프트" "구글" "아마존" "SK" ...
cs

# student의 id만 보고 싶다면 => str(student$id)



3. 데이터의 일부 보기

  (1) head(데이터) 

# 상위 6개의 데이터를 보여줌

1
2
3
4
5
6
7
8
9
10
11
12
> head(student)
# A tibble: 6 x 8
     id gender   age height weight  address
  <dbl>  <chr> <dbl>  <dbl>  <dbl>    <chr>
1     1   남자    29    188     80   구파발
2     2   남자    28    185     63     강동
3     3   남자    25    172     63 압구정동
4     4   여자    24    160     48     수원
5     5   남자    26    180     80     용인
6     6   남자    26    188     77     성수
# ... with 2 more variables: major <chr>,
#   company <chr>
cs

# head(student, n = 3)

# 출력 데이터 개수 지정 가능

  

  (2) tail(데이터)

# 하위 6개의 데이터를 보여줌

# head와 동일한 출력 형태

# tail(student)

# tail(student, n = 3)



4. 데이터 프레임의 속성

  (1) 행의 개수 : nrow(데이터)

1
2
> nrow(student)
[112
cs


  (2) 열의 개수 => 변수의 개수 : ncol(데이터)

1
2
> ncol(student)
[18
cs


  (3) 행의 이름 : rownames(데이터)

# 결과는 character

1
2
3
> rownames(student)
 [1"1"  "2"  "3"  "4"  "5"  "6"  "7"  "8" 
 [9"9"  "10" "11" "12"
cs

  

  (4) 열의 이름 => 변수의 이름 : colnames(데이터)

# 결과는 character

1
2
3
> colnames(student)
[1"id"      "gender"  "age"     "height" 
[5"weight"  "address" "major"   "company"
cs


  (5) 차원(dimension) : 행, 렬 : dim(데이터)

1
2
3
4
5
6
7
8
> dim(student)
[112  8
 
> dim(student)[1
[112
 
> dim(student)[2
[18
cs


  (6) 차원의 이름 : 행의 이름, 열의 이름 : dimnames(데이터)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
> dimnames(student)
[[1]]
 [1"1"  "2"  "3"  "4"  "5"  "6"  "7"  "8" 
 [9"9"  "10" "11" "12"
 
[[2]]
[1"id"      "gender"  "age"     "height" 
[5"weight"  "address" "major"   "company"
 
> dimnames(student)[1#리스트
[[1]]
 [1"1"  "2"  "3"  "4"  "5"  "6"  "7"  "8" 
 [9"9"  "10" "11" "12"
 
> dimnames(student)[[1]] #벡터
 [1"1"  "2"  "3"  "4"  "5"  "6"  "7"  "8" 
 [9"9"  "10" "11" "12"
 
> dimnames(student)[[1]][3#벡터(dimnames(student)[[1]]) 의 3번 째 값
[1"3"
cs


5. 데이터(data.frame)의 슬라이싱

  # 데이터[행index, 열index] => data.frame은 행,열의 2차원 구조

  # Vectorization 이 적용됨, for문 없이 연산이 끝까지 수행


  (1) 열(column) 

# 데이터[ , index]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
> student[ , 2]
# A tibble: 12 x 1
   gender
    <chr>
 1   남자
 2   남자
 3   남자
 4   여자
 5   남자
 6   남자
 7   남자
 8   여자
 9   남자
10   남자
11   여자
12   남자
cs


문제. 짝수번째 열 가져오기

1
2
3
student[ , seq(from = 2,
               to   = ncol(student),
               by   = 2)] 
cs

# vector 에서는 length

# data.frame 에서는 nrow, ncol


문제. weight, height의 데이터를 가져오기

1
student[ , c("weight""height")
cs

# index가 character 이므로 c( )를 사용


# 변수명에 특정한 패턴이 있는 것을 추출

# grep("패턴", 문자열)

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
26
27
28
# 변수명 중에서 'e'라는 글자를 포함하고 있는 변수명의 위치
grep("e"
     colnames(student))
 
# 'e'라는 글자를 포함하고 있는 변수명
grep("e"
     colnames(student), 
     value=TRUE
 
# 'e'라는 글자를 포함하고 있는 데이터를 추출
student[ , grep("e"
                colnames(student), 
                value=TRUE)]
 
# 'a'라는 글자로 시작하는 데이터를 추출 => ^a
student[ , grep("^a"
                colnames(student), 
                value=TRUE)]
 
# 't'라는 글자로 끝나는 데이터를 추출 => t$
student[ , grep("t$"
                colnames(student), 
                value=TRUE)]
 
# 't'라는 글자로 끝나거나, 'a'라는 글자로 시작하는 데이터를 추출
student[ , grep("t$|^a"
                colnames(student), 
                value=TRUE)]
cs

# 정규표현식을 익히자

# https://wikidocs.net/1669 

# http://www.nextree.co.kr/p4327/


  (2) 행(row)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 성별이 여자인 데이터만 가져오기
student.female = student[student$gender == "여자"]
 
# 거주지가 수원이 아닌 사람들의 데이터
student[student$address != "수원"]
 
# 몸무게가 50 이하인 사람들의 데이터
student[student$weight <= 50]
 
# 나이가 30대 이상이고, 키는 175 이상인 사람
student[(student$age >= 30& (student$height >= 175), ]
 
# 나이가 30대 이상이거나 키는 175 이상인 사람
student[(student$age >= 30| (student$height >= 175), ]
cs


  (3) 행, 열

1
2
3
4
# 키가 170cm 이상이고, 몸무게가 60kg 이상인 사람들 중에서 
# 변수명에 'e'라는 글자가 들어가는 데이터
student[(student$height >= 170& (student$weight >= 60), 
        grep("e", colnames(student))]
cs








[Fast campus] Data Science with R 1기 - 이부일 강사님

공부하면서 배운 내용 복습 겸 정리하는 곳입니다.


외부 데이터 : txt, csv, excel(xls, xlsx) 


1. 텍스트 데이터 : txt

  (1) 구분자(Separator) : 공백 하나(blank, white space)

1
2
3
데이터명 = read.table(file  = "파일위치/파일명.txt",
                     header = TRUE,
                     sep    = " "
cs


  (2) 구분자(Separator) : comma(,)

1
2
3
데이터명 = read.table(file   = "파일위치/파일명.txt",
                     header = TRUE,
                     sep    = ","
cs


  (3) 구분자(Separator) : 탭(tab)

1
2
3
데이터명 = read.table(file   = "파일위치/파일명.txt",
                     header = TRUE,
                     sep    = "\t"
cs



2. CSV(Comma Separated Value)

# 엑셀의 특수한 형태

1
2
3
데이터명 = read.table(file   = "파일위치/파일명.txt",
                     header = TRUE,
                     sep    = "\t"
cs


3. 엑셀 : xls, xlsx

# R의 기본 기능에서는 못 읽어 옴

# 추가 기능(패키지(Package))을 설치 - install.packages("패키지명")

# 패키지 로딩하기, 구동하기 - library(패키지명)

1
2
3
4
5
6
> install.packages("readxl")
package ‘readxl’ successfully unpacked and MD5 sums checked

The downloaded binary packages are in
    C:\Users\JungChul\AppData\Local\Temp\RtmpG8Gy4u\downloaded_packages
> library(readxl)
cs

  # 패키지 설치 명령어 후 successfully 메시지가 나오면 설치 완료

  # 패키지는 항상 코드 가장 위( 다른 pc에서 실행 할 수도 있으니 install.packages명령어도 같이 적어두기 )

  # 패키지 내 함수를 사용할 때는 '패키지명::함수' 형태로 사용하자

1
2
3
데이터명 = readxl::read_excel(path="파일위치/파일명.xlsx",
                             sheet=index or "시트명",
                             col_names=TRUE)
cs


[Fast campus] Data Science with R 1기 - 이부일 강사님

공부하면서 배운 내용 복습 겸 정리하는 곳입니다.


IV. 배열(Array)
  # 다차원
  # vector, 행렬의 확장
  # 벡터의 특징( Recycling Rule, Vectorization ) 그대로 적용됨
  # array(vector, dim=)
1
2
> array(1:10, dim=10)
 [1]  1  2  3  4  5  6  7  8  9 10
cs
  # dim에 1개의 숫자
  # 1차원 형태를 지닌 벡터의 결과

1
2
3
4
5
> array(1:10, dim=3:4)
     [,1[,2[,3[,4]
[1,]    1    4    7   10
[2,]    2    5    8    1
[3,]    3    6    9    2
cs
  # dim에 3,4 => 2개의 숫자
  # 2차원 형태를 지닌 행렬의 결과

1
2
3
4
5
6
7
8
9
10
11
12
13
14
> array(1:10, dim=c(3,4,2))
, , 1
 
     [,1[,2[,3[,4]
[1,]    1    4    7   10
[2,]    2    5    8    1
[3,]    3    6    9    2
 
, , 2
 
     [,1[,2[,3[,4]
[1,]    3    6    9    2
[2,]    4    7   10    3
[3,]    5    8    1    4
cs
  # dim에 숫자 3,4,2 => 3개의 숫자
  # 3행 4열 2높이 => 3차원


V. 데이터 프레임(Data.Frame)
  # 행, 열로 구성. 2차원
  # 여러 개의 데이터 유형을 가질 수 있음 
  # 단, 하나의 열은 하나의 데이터 유형만 가짐 
  # data.frame(벡터1, 벡터2, 행렬, ...)
1
2
3
4
5
6
7
8
9
10
11
> id = 1:5
> gender = c("m""m""m""f""m")
> address = c("구파발""강동""압구정""수원""용인")
> survey = data.frame(id, gender, address)
> survey
  id gender address
1  1      m  구파발
2  2      m    강동
3  3      m  압구정
4  4      f    수원
5  5      m    용인
cs


VI. 리스트(List)
  # 분석한 결과를 저장할 때에 많이 사용하는 형태
  # 가장 유연한 데이터 형태
  # 리스트의 원소로 vector, factor, matrix, array, data.frame, list를 가질 수 있다.
  # list(vector, factor, matrix, array, data.frame, list, ...)
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
> v1 = 1:10
> v2 = 1:3
> v3 = c("ch""nu""lo")
> v4 = c(TRUEFALSE)
> m1 = cbind(v1, v2)
> result = list(v1, v2, v3, v4, m1, survey)
> result
[[1]]
 [1]  1  2  3  4  5  6  7  8  9 10
 
[[2]]
[11 2 3
 
[[3]]
[1"ch" "nu" "lo"
 
[[4]]
[1]  TRUE FALSE
 
[[5]]
      v1 v2
 [1,]  1  1
 [2,]  2  2
 [3,]  3  3
 [4,]  4  1
 [5,]  5  2
 [6,]  6  3
 [7,]  7  1
 [8,]  8  2
 [9,]  9  3
[10,] 10  1
 
[[6]]
  id gender address
1  1      m  구파발
2  2      m    강동
3  3      m  압구정
4  4      f    수원
5  5      m    용인
 
cs

  리스트의 슬라이싱
  # 리스트의 슬라이싱은 [ ] , [[ ]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
> a1 = result[1]
> a2 = result[[1]]
> a1
[[1]]
 [1]  1  2  3  4  5  6  7  8  9 10
 
> a2
 [1]  1  2  3  4  5  6  7  8  9 10
 
> b1 = result[4]
> b2 = result[[4]]
> b1
[[1]]
[1]  TRUE FALSE
 
> b2
[1]  TRUE FALSE
cs

  # 대괄호 1개 사용 : 결과는 list

  # 대괄호 2개 사용 : numeric, character, logical, list로 나타남.

 


[Fast campus] Data Science with R 1기 - 이부일 강사님

공부하면서 배운 내용 복습 겸 정리하는 곳입니다.


II. 요인(Factor)

  # 벡터의 일종

  # 차이점 : 집단(group)으로 인식함

  # 1차원 - 하나의 열로 구성

  # 벡터는 집단으로 인식하지 않음

  # factor(vector, labels=, levels=, ordered=) 


  bt(blood type) 예제

1
2
3
> bt = c("ab""ab""a""a""b")
> bt
[1"ab" "ab" "a"  "a"  "b"
cs


  bt를 factor로 바꿔보자

1
2
3
4
> bt_factor <- factor(bt)
> bt_factor
[1] ab ab a  a  b 
Levels: a ab b
cs

  # Levels : a ab b => 3개의 집단(a, ab, b)으로 인식함    


  bt_factor2 - labels

1
2
3
4
5
> bt_factor2 <- factor(bt, 
                       labels = c("A형","AB형","B형"))
> bt_factor2
[1] AB형 AB형 A형  A형  B형 
Levels: A형 AB형 B형
cs

  # labels : 데이터 값과 결과가 바뀜


  bt_factor3 - levels

1
2
3
4
5
> bt_factor3 <- factor(bt,
                       levels = c("b","ab","a"))
> bt_factor3
[1] ab ab a  a  b 
Levels: b ab a
cs

  # levels : 집단의 순서 - 데이터 자체는 바뀌지 않지만 b, ab, a 순으로 Levels이 바뀌게 됨


  bt_factor4 - labels, levels

1
2
3
4
5
6
> bt_factor4 <- factor(bt,
+                      levels = c("b","ab","a"),
+                      labels = c("B형","AB형","A형"))
> bt_factor4
[1] AB형 AB형 A형  A형  B형 
Levels: B형 AB형 A형
cs

  # 2개의 argument 같이 사용할 시 labels의 값들은 levels에 대응되도록 사용해야 한다


  bt_factor5

1
2
3
4
5
6
7
> bt_factor5 <- factor(bt, 
+                      levels  = c("b","ab","a")
+                      labels  = c("A형","AB형","B형"),
+                      ordered = TRUE)
> bt_factor5
[1] AB형 AB형 B형  B형  A형 
Levels: A형 < AB형 < B형
cs

  # ordered : 특정한 결과값을 의미있게 구분할 때 사용 => 부등호가 나타남


 factor의 속성

  (1) levels(요인)

1
2
> levels(bt_factor)
[1"a"  "ab" "b" 
cs

  (2) ordered(요인)

# 집단의 순서가 의미 있도록 변경

1
2
3
> ordered(bt_factor)
[1] ab ab a  a  b 
Levels: a < ab < b
cs

# bt_factor의 속성을 ordered=TRUE로 만들어 주겠다는 것



III. 행렬(Matrix)

  # 행(row)와 열(column)로 구성되어 있음

  # 2차원 (행, 열)

  # 벡터의 확장 -> 1차원에서 2차원으로

  # 벡터의 규칙이 대부분 적용( Recycling Rule, Vectorization )


  1. 행렬을 만드는 방법

(1) rbind(벡터1, 벡터2, ...)  /  cbind(벡터1, 벡터2, ...)

1
2
3
4
5
6
7
> v1 = 1:3
> v2 = 4:6
> M1 = rbind(v1, v2)
> M1
   [,1[,2[,3]
v1    1    2    3
v2    4    5    6
cs

# rbind : row를 기준으로 벡터를 결합하여 생성

# cbind : column을 기준으로 벡터를 결합하여 생성


(2) matrix(vector, nrow=, ncol=, byrow=)

1
2
3
4
> matrix(1:4, nrow=2, ncol=2)
     [,1[,2]
[1,]    1    3
[2,]    2    4
cs

# R에서 행렬은 열(column)이 우선으로 채워진다.


1
2
3
4
> matrix(1:4, nrow=2, ncol=2, byrow=TRUE)
     [,1[,2]
[1,]    1    2
[2,]    3    4
cs

# byrow = TRUE는 행(row)을 우선으로 행렬을 채우는 것



  2. 행렬의 슬라이싱

     # 행렬[ 행index, 열index ]

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
26
27
> M3
     [,1[,2]
[1,]    1    2
[2,]    3    4
 
> M3[1]    # 1행
[11 2
 
> M3[2]    # 2행
[13 4
 
> M3[1:2]  #1,2행 
     [,1[,2]
[1,]    1    2
[2,]    3    4
 
> M3[ ,1 ]    # 2열
[11 3
 
> M3[ ,1:2 ]  # 1,2열
     [,1[,2]
[1,]    1    2
[2,]    3    4
 
> M3[1,2]   # 1행, 2열
[12
 
cs

  


3. 행렬의 덧셈과 뺄셈

# 형태(shape)가 동일해야 한다. 

# 2x3 은 2x3 끼리만 연산 가능

1
2
3
4
5
6
7
8
9
10
11
12
> A <- matrix(1:4, nrow=2, ncol=2)
> B <- matrix(5:8, nrow=2, ncol=2)
 
> A + B
     [,1[,2]
[1,]    6   10
[2,]    8   12
 
> A - B
     [,1[,2]
[1,]   -4   -4
[2,]   -4   -4
cs


# A*B -> 행렬의 곱셈? 

1
2
3
4
> A * B
     [,1[,2]
[1,]    5   21
[2,]   12   32
cs

# A*B는 단순히 index가 같은 값 끼리 연산하는 것으로 행렬의 곱셈은 아니다.


  4. 행렬의 곱셈

# A_r1,c1 %*% B_r2,c2

# 조건 : c1 = r2 -> 곱하고자 하는 A의 열과 B의 행의 개수가 같아야 한다.

# 최종 결과는 r1xc2 matrix

1
2
3
4
5
6
> A = matrix(1:4, nrow=2, ncol=2)
> B = matrix(5:8, nrow=2, ncol=2)
> A %*% B
     [,1[,2]
[1,]   23   31
[2,]   34   46
cs



  5. 역행렬(Reverse Matrix)

# 조건 1 : 정방행렬(Square Matrix) - 행과 열의 개수가 같음

# 조건 2 : 행렬식이 0이 아니어야 함

ex) 

A( a11, a12

    a21, a22)

# 조건 1 : 2x2 행렬

# 조건 2 : (a11 x a22) - (a12 x a21) != 0

# 조건 2가지가 성립하므로 역행렬 결과는

A( a22, -a12

    -a21, a11)

# 위의 결과에 1/(a11 x a22) - (a12 x a21) 을 곱해줌

# solve() 함수를 사용하여 역행렬을 구함 

1
2
3
4
5
6
7
8
9
10
11
> A1 = matrix(1:4, nrow=2, ncol=2)
> A1
     [,1[,2]
[1,]    1    3
[2,]    2    4
 
> A2 = solve(A1)
> A2
     [,1[,2]
[1,]   -2  1.5
[2,]    1 -0.5
cs


# A1과 A2(A1의 역행렬)을 곱하면 단위행렬이 나옴

1
2
3
4
> A1 %*% A2
     [,1[,2]
[1,]    1    0
[2,]    0    1
cs


# 방정식 계산

2x + y = 3

-x + 3y = 10

1
2
3
4
5
6
> B1 = matrix(c(21-13), nrow=2, ncol=2)
> B2 = matrix(c(310), nrow=2, ncol=1)
> solve(B1) %*% B2
         [,1]
[1,] 2.714286
[2,] 2.428571
cs

 


  6. 전치행렬(Transpose Matrix)

# 행과 열을 바꿈

# t(행렬)

1
2
3
4
5
6
7
8
9
> A
     [,1[,2]
[1,]    1    3
[2,]    2    4
 
> t(A)
     [,1[,2]
[1,]    1    2
[2,]    3    4
cs


[Fast campus] Data Science with R 1기 - 이부일 강사님

공부하면서 배운 내용 복습 겸 정리하는 곳입니다.


※ 데이터의 유형(Type of Data)

1. 벡터(Vector) 

2. 요인(Factor)

3. 행렬(Matrix)

4. 배열(Array)

5. 데이터 프레임(Data.Frame)

6. 리스트(List)

7. 데이터 테이블(Data.Table)

8. 시계열(Time Series)



I. 벡터(Vector)

  # 하나 이상의 값(원소 : element)으로 이루어짐

  # 하나의 열(column)로 되어 있음

  # 하나의 데이터 유형만 가짐 


1. 벡터를 생성하는 방법 -> 원소가 2개 이상일 때 사용하는 방법

  # 벡터를 생성하기 보다는 데이터의 일부를 추출할 때 많이 사용

  (1) c(원소1, 원소2, ...)

# c : combine, concatenate의 약자

# numeric, character, logical 타입의 벡터를 만들 수 있다.

# 원소들 간의 규칙이 없을 경우에 사용

# vector는 하나의 유형만 가진다.

1
2
3
4
5
6
7
> v1 = c(1"Lee"FALSE
> v1
[1"1"  "Lee"  "FALSE"
 
> v2 = c(1TRUEFALSE)
> v2
[11 1 0
cs

# 데이터 유형의 우선 순위 : character > numeric > logical

# 우선 순위가 높은 유형에서 하위 유형으로 변환은 잘 이루어지지 않는다.

# character -> numeric : "숫자" 일 경우 변환 가능

# logical -> numeric : TRUE는 1, FALSE는 0를 반환


  (2) :

# numeric vector에만 적용됨

# 1씩 증가 or 감소되는 숫자로 이루어진 벡터를 생성할 때 사용

# 규칙이 있는 숫자 


# start : end

# start < end : 1씩 증가

# start > end : 1씩 감소

# start = end : start or end


# start부터 시작해서 end를 넘지 않을 때 까지 1씩 증가 or 감소

# 항상 start 부터 시작한다.

1
2
3
4
5
6
7
8
> 1:5
[11 2 3 4 5
 
> -2.3:1
[1-2.3 -1.3 -0.3  0.7
 
> 1:-2.3
[1]  1  0 -1 -2
cs

# start가 실수면 마무리도 실수

# start가 정수면 마무리도 정수


  (3) seq(from=, to=, by=)  

# argument 명은 항상 적어주자

# seq : sequence의 약자 - 수열

# numeric vector에만 사용

# : 의 확장 개념

# from : start  /  to : end  /   by : 증가 or 감소 폭

1
2
3
4
5
6
> seq(from = 1, to = 100, by = 5)
 [1]  1  6 11 16 21 26 31 36 41 46 51 56 61 66
[1571 76 81 86 91 96
 
> seq(from = 1, to = 5, by = 0.5)
[11.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
cs


문제. 5부터 시작해서 1을 넘지 않을 때 까지 0.1씩 감소

1
2
3
> seq(from = 5, to = 3, by = -0.1)
 [15.0 4.9 4.8 4.7 4.6 4.5 4.4 4.3 4.2 4.1 4.0
[123.9 3.8 3.7 3.6 3.5 3.4 3.3 3.2 3.1 3.0
cs

# by에는 감소는 '-' 부호가 필요하다. 


  (4) sequence(숫자)

# numeric vector 에만 적용됨

# 1 ~ '숫자' 사이의 정수로 이루어진 벡터

1
2
> sequence(10)
 [1]  1  2  3  4  5  6  7  8  9 10
cs


  (5) rep(vector, times=, each=)

# each는 vector 각각의 원소를 반복

# times는 vector를 반복

# argument 우선순위 : each > times

# numeric, character, logical vector에 적용됨

# rep : replicate의 약자


문제. "남자" 3개, "여자" 3개를 가지는 벡터를 생성

1
2
> rep(c("남자","여자"), each = 3)
[1"남자" "남자" "남자" "여자" "여자" "여자"
cs

# ex = c("남자", "여자") 를 생성하고 rep(ex, each=3)로 사용할 시 ex라는 메모리 낭비가 발생

# 필요없는 변수는 만들지 말자


* ?rep의 examples - 반올림 오차(round off error)

1. rep(1, 40*(1-.8)) # length 7 on most platforms

2. rep(1, 40*(1-.8+1e-7) # better

1
2
3
4
5
> rep(140*(1-.8))
[11 1 1 1 1 1 1
 
> rep(140*(1-.8)+1e-7)
[11 1 1 1 1 1 1 1
cs

두 코드를 실행시 1의 출력 개수가 7번, 8번으로 다른 것을 볼 수 있다.

# (1-.8) 이라는 값이 0.2지만 R상에서는 0.2에 근사한 0.199999와 같은 값을 가지는게 아닐까?

# 따라서 rep함수의 argument로 사용시 40*(1-.8)이 7이라는 값으로 인식되어서 반올림오차(round off error)가 발생 하므로,
# 1e-7 이라는 값을 더해서 문제를 해결


  (6) paste(벡터1, 벡터2, ..., sep=)

# 벡터의 각각의 원소들을 합쳐서 character 형태의 원소를 생성

# 결과는 character 형태. sep을 주지 않으면 공백이 들어간다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
> paste(11)
[1"1 1"
 
> paste(11, sep="-")
[1"1-1"
 
> paste(11, sep="")
[1"11"
 
> paste("x"1, sep="")
[1"x1"
 
> paste("X"1:4, sep="")
[1"X1" "X2" "X3" "X4"
cs

# 재활용 규칙과 벡터화가 같이 적용됨



2. 벡터의 속성

  (1) length(벡터) 

# 벡터가 가지는 원소의 개수

1
2
3
> age = c(262725)
> length(age)
[13
cs

  (2) names(벡터)

# 원소의 이름

1
2
3
4
5
6
7
8
> age = c(262725)
> age
[126 27 25
 
> names(age) = c("Ha""Jeong""Kim")
> age
   Ha Jeong   Kim 
   26    27    25 
cs

# age는 하나의 열을 가지는 벡터일뿐 names는 age 벡터의 부수적인 설명 역할

# NA(Not Available) - Missing Value = 결측치, 결측값

# 전체에서 특정 부분에 데이터가 없는 경우

# NULL : 객체, 개체(Object) 자체가 없는 경우

# 데이터를 그래프로 나타낼 때 NA는 특정 값이 존재 하지 않는 것이고,

# NULL은 그래프 자체가 없다는 의미



3. 벡터의 슬라이싱(Slicing) = 인덱싱(Indexing)

     # 벡터 중 일부의 원소(들)을 추출

     # 벡터[index]

     # R에서 index는 1부터 시작한다


문제. 1,4,5 번째 원소를 한번에 가져오기

1
2
3
> income = c(50010003500400300)
> income[c(1,4,5)] 
[1500 400 300
cs


문제. 2번째 부터 5번째 가져오기

1
2
> income[2:5
[11000 3500  400  300
cs


문제. 홀수 번째 원소 값 가져오기 

1
2
3
4
> income[seq(from = 1
             to = length(income), 
             by = 2)] 
[1]  500 3500  300
cs



4. 벡터의 연산 : +, -, *, /

     # R의 특징 - 재활용 규칙(Recycling Rule)

1
2
3
4
5
> v1 = 1:3
> v2 = 4:6
> v3 = v1 + v2
> v3
[15 7 9
cs


1
2
3
> v3 = 1:6
> v1 + v3
[12 4 6 5 7 9
cs

# 데이터의 개수 v1 = 3 / v3 = 6

# 연산시 데이터의 개수가 큰 만큼 채워준다.

# Recycling Rule


# Warning message

1
2
3
4
5
6
> v4 = 1:8
> v1 + v4
[1]  2  4  6  5  7  9  8 10
Warning message:
In v1 + v4 :
  longer object length is not a multiple of shorter object length
cs

# Warning message는 R이 결과에 이상이 있는거 같지 않니? 라고 물어봐주는 역할

# 결과에 문제가 없다면 그냥 사용하면 된다.


01Basic

[Fastcampus] R 데이터 분석 집중완성 SCHOOL - 이부일 강사님

  • 주석=설명=comment
  • 명령어의 끝 : ;
  • 명령어의 실행 : Ctrl + Enter
  • 다음 줄로 이동 : Enter
  • Argument 위치 맞추기 : Shift + Enter
  • 대소문자 구분 : Case Sensitive

  • 1. 연산자(Operator)

    1.1 산술 연산자(Arithmetic Operator)
    +, -, *, /, **, ^, %%, %/%

    3 + 4    # 더하기
    3 - 4    # 빼기
    3 * 4    # 곱하기
    3 / 4    # 나누기
    3 ** 4   # 거듭제곱
    3 ^ 4    # 거듭제곱
    13 %% 4  # 나머지
    13 %/% 4 # 몫
    

    1.2 할당 연산자(Allocation Operator)
    <-, =

    x <- 1:10
    mean(x)
    mean(x, trim = 0.1)
    

    1.3 비교 연산자(Comparison Operator)
    >=, >, <, <=, ==, !=, !

    3 > 4
    3 >= 4
    3 < 4
    3 <= 4
    3 == 4
    3 != 4
    !(3 == 4)
    

    1.4 논리 연산자(Logic Operator)
    &, |

    (3 > 4) & (4 < 5)
    (3 > 4) | (4 < 5)
    

    2. 데이터의 유형(Type of Data)
    데이터의 하나의 값이 무엇으로 이루어 졌는가?

    2.1 Character : 문자형

    x1 <- 'Love is choice.'
    x2 <- "buillee"
    

    2.2 Numeric : 수치형, integer(정수), double(실수)

    x3 <- 10
    x4 <- 10.5
    

    2.3 Logical : 논리형, TRUE, FALSE, T, F

    x5 <- TRUE
    x6 <- FALSE
    

    3. 데이터의 유형 알아내기

    3.1 mode(data)

    mode(x1) mode(x3) mode(x5)

    3.2 is.xxxx(data)

    is.character(x1)
    is.numeric(x1)
    is.numeric(x3)
    is.logical(x5)
    


    + Recent posts