R 연습도 할겸, 재미로 대선 주자들(문재인, 이재명, 안희정, 황교안, 안철수, 유승민) 총 6명의 페이스북 페이지를 분석해 보았습니다. 분석에는 R을 사용하였고 Facebook API를 구현한 Rfacebook 패키지를 이용하였습니다. 

2016년 11월 1일 ~ 2016년 2월 19일 분석 기간으로 정하였고, 총 3가지에 관하여 분석해보았습니다. 

• 총 포스팅 횟수
• 포스팅당 평균 좋아요 수
• 날짜별 좋아요수 변화 그래프 

총 포스팅 횟수

총 포스팅 횟수는 이재명-안철수-문재인 순으로 나타났습니다. 이재명과 안철수가 해당 기간 (2016년 11월 1일 ~ 2017년 2월 19일) 동안 300개가 넘는 포스팅으로 나란히 1, 2위를 차지하였고, 페이스북 포스팅에 적극적인 모습을 보였습니다. 반면 6등인 황교안은 83 포스팅으로 가장 적은 포스팅을 하였습니다.

포스팅당 평균 좋아요 수

포스팅당 평균 좋아요수는 위와 같이 나타났습니다. 문재인이 포스팅당 6146로 다른 후보들과 비교하여 압도적인 좋아요수를 기록하였고 2위인 안희정과 비교하여 거의 2배의 평균 좋아요 수를 보였습니다. 이를 실제 대선 주자 지지도 조사와 비교하여볼까요?

리얼미터에서 조사한 대선후보 지지율은 위와 같습니다. 문재인-안희정-황교안-안철수-이재명-유승민 순입니다. 페이스북 페이지 평균 좋아요수는 문재인-안희정-황교안-이재명-안철수-유승민 순으로 단순 순위만 봤을 때 안철수, 이재명의 차이만 빼고는 같다는 것을 알 수 있습니다. 이를 해석해보면 이재명은 페이스북에서 비교적 인기가 많다고도 볼 수 있을것 같습니다. 주로 20, 30대들이 페이스북을 많이하니 20, 30대들이 좋아하는 이재명이 페이스북에서 강세를 보이는 것으로 보입니다.

날짜별 좋아요수 변화 그래프

다음은 날짜별로 좋아요 수가 어떻게 변하는지 그래프를 그려보았는데요. 자세히 보시면 문재인 후보의 좋아요수가 평균적으로 점점 감소해가는 것을 볼 수 있습니다. 또한 자세히 보시면 안희정 후보들의 포스팅에서 최근들어 좋아요를 많이 받은 포스팅이 점점 많아지는 것이 보입니다. 다른 후보들에서는 생각외로 뚜렷한 패턴을 발견할 수 없어보이네요.

이러한 분석을 통해 대선 결과를 예측하거나 할 수는 없을 것 같습니다. 단순한 통계 분석에 그치기 때문입니다. 그냥 재미로 봐주셨으면 좋겠습니다. 하지만 최근 많이 사용하는 텍스트 마이닝, 감정 분석등의 머신러닝 알고리즘을 통해 네티즌들의 반응, 포스팅 내용 등을 분석하면 조금 더 깊고 의미있는 통찰을 할 수 있을 것입니다.

제가 사용한 R 코드는 아래에 첨부합니다. 

facebook.R

# https://cran.r-project.org/web/packages/Rfacebook/Rfacebook.pdf
library(Rfacebook)
library(ggplot2)
library(scales)
# get auth token
fb_oauth = fbOAuth(app_id = "310016876042099", app_secret = "6772bfc30e27720eac8d67122157aa47", extended_permissions = FALSE)

# 해당 페이지의 시작날짜와 종료날짜 사이의 모든 포스트 가져옴
getPosts <- function(page_name, start_date, end_date) {
  # 날짜 sequence
  scrape_days <- seq(from=as.Date(start_date), to=as.Date(end_date), by='days')
  posts = c()
  for(scrape_day in scrape_days){
    daypost = c()
    tryCatch({
      daypost = getPage(page=page_name, token=fb_oauth,
                        since=as.Date(scrape_day, origin='1970-01-01'),
                        until=as.Date(scrape_day, origin='1970-01-01')+1)},
      error = function(e){})
    posts = rbind(posts, daypost)
  }
  return(posts)
}

drawLikeGraph <- function(data){
  ggplot(data, aes(x=created_time, y=likes_count)) + geom_line() + 
    theme_bw() + scale_x_date(labels = date_format("%m-%Y")) +
    labs(x = "날짜(MM-yyyy)", y = "좋아요수(n)") + 
    ggtitle(paste(start_date, end_date, sep="~"))
}

drawPostNumGraph <- function(data){
  ggplot(data=data, aes(x=name, y=num, fill=name)) +
    geom_bar(stat="identity", width=0.8) +
    labs(x='대선주자', y='포스트수') +
    geom_text(aes(label=num), vjust=1.6, color="white", size=3.5) +
    theme_minimal() +
    ggtitle(paste(start_date, end_date, sep="~"))
}

drawAverageLikeGraph <- function(data){
  ggplot(data=data, aes(x=name, y=average_like, fill=name)) +
    geom_bar(stat="identity", width=0.8) +
    labs(x='대선주자', y='평균 좋아요수') +
    geom_text(aes(label=round(average_like, 0)), vjust=1.6, color="white", size=3.5) +
    theme_minimal() +
    ggtitle(paste(start_date, end_date, sep="~"))
}

getSummaryDataFrame <- function(posts, name){
  average_like = sum(posts$likes_count)/nrow(posts)
  summary <- data.frame(name=name, num=nrow(posts),
                        average_like=average_like)
  return(summary)
}

moon_page = "moonbyun1" # 문재인 페이지 
lee_page = "jaemyunglee1" # 이재명 페이지
hwang_page = "PM0415HwangKyoahn" # 황교안 페이지
yoo_page = "yooseongmin21" # 유승민 페이지
ahn_hwee_page = "steelroot" # 안희정 페이지
ahn_chul_page = "ahncs111" # 안철수 페이

start_date <- '2016/11/01' # 시작 날짜
end_date <- '2017/02/19' # 종료 날짜

moon_posts <- getPosts(moon_page, start_date, end_date)
lee_posts <- getPosts(lee_page, start_date, end_date)
hwang_posts <- getPosts(hwang_page, start_date, end_date)
yoo_posts <- getPosts(yoo_page, start_date, end_date)
ahn_hwee_posts <- getPosts(ahn_hwee_page, start_date, end_date)
ahn_chul_posts <- getPosts(ahn_chul_page, start_date, end_date)

print(nrow(hwang_posts))

# preprocess
moon_posts$created_time <- as.Date(moon_posts$created_time) # string to date
lee_posts$created_time <- as.Date(lee_posts$created_time)
hwang_posts$created_time <- as.Date(hwang_posts$created_time)
yoo_posts$created_time <- as.Date(yoo_posts$created_time)
ahn_hwee_posts$created_time <- as.Date(ahn_hwee_posts$created_time)
ahn_chul_posts$created_time <- as.Date(ahn_chul_posts$created_time)

# summary 데이터 프레임 만듦
moon_summary <- getSummaryDataFrame(moon_posts, '문재인')
lee_summary <- getSummaryDataFrame(lee_posts, '이재명')
hwang_summary <- getSummaryDataFrame(hwang_posts, '황교안')
yoo_summary <- getSummaryDataFrame(yoo_posts, '유승민')
ahn_hwee_summary <- getSummaryDataFrame(ahn_hwee_posts, '안희정')
ahn_chul_summary <- getSummaryDataFrame(ahn_chul_posts, '안철수')

summary <- data.frame() # 빈 데이터 프레임을 만듦
summary <- rbind(summary, moon_summary) # 행추가
summary <- rbind(summary, lee_summary)
summary <- rbind(summary, hwang_summary)
summary <- rbind(summary, yoo_summary)
summary <- rbind(summary, ahn_hwee_summary)
summary <- rbind(summary, ahn_chul_summary)

drawPostNumGraph(summary)
drawAverageLikeGraph(summary)

# reactions <- getReactions(post=posts$id, fb_oauth, verbose=TRUE)
drawLikeGraph(moon_posts)
drawLikeGraph(lee_posts)
drawLikeGraph(hwang_posts)
drawLikeGraph(yoo_posts)
drawLikeGraph(ahn_hwee_posts)
drawLikeGraph(ahn_chul_posts)

all_posts <- data.frame()
all_posts <- rbind(all_posts, moon_posts)
all_posts <- rbind(all_posts, lee_posts)
all_posts <- rbind(all_posts, hwang_posts)
all_posts <- rbind(all_posts, yoo_posts)
all_posts <- rbind(all_posts, ahn_hwee_posts)
all_posts <- rbind(all_posts, ahn_chul_posts)

ggplot(all_posts, aes(x=created_time, y=likes_count, group=from_name, colour=from_name)) + geom_line(size=0.5) + 
  geom_smooth() +
  theme_minimal() + scale_x_date(labels = date_format("%m-%Y")) +
  labs(x = "날짜(MM-yyyy)", y = "좋아요수(n)") + 
  ggtitle(paste(start_date, end_date, sep="~"))

(7) 함수

함수는 특정한 태스크를 하기 위한 구문들의 집합이다. R에는 in-built 함수들이 많이 있고 또한 직접 함수를 정의하여 사용할 수도 있다. 한 가지 주의할 점은 R에서 함수는 객체이다. 

함수 정의

R에서 함수는 function() 키워드를 통해 만들 수 있다.

function_name <- function(arg_1, arg_2, ...) {
   Function body 
}

함수의 구성요소 

• Function Name : 함수의 실제 이름이다. R environment에 해당 이름의 객체로 저장된다. 
  
• Arguments : Arguments는 placeholder이다. 함수가 호출 될 때, arguments에 값이 할당된다. arguments는 없어도 되며, 또한 default 값을 가질 수 있다.
• Function Body : function이 하는 일을 기술한 구문들이다.
• Return Value : function body가 최종적으로 리턴한 값이다.

Built-in 함수

in-built 함수의 간단한 예에는 seq(), mean(), max(), sum() 등이 있다.

더 많은 in-built function 보기

https://cran.r-project.org/doc/contrib/Short-refcard.pdf 

# Create a sequence of numbers from 32 to 44.
print(seq(32,44))

# Find mean of numbers from 25 to 82.
print(mean(25:82))

# Find sum of numbers frm 41 to 68.
print(sum(41:68))

사용자 정의 함수

사용자 정의 함수의 예이다.

# Create a function to print squares of numbers in sequence.
new.function <- function(a) {
   for(i in 1:a) {
      b <- i^2
      print(b)
   }
}   

# Call the function new.function supplying 6 as an argument.
new.function(6)

다음과 같이 argument의 이름을 명시적으로 지정하여 호출할 수도 있다.

# Create a function with arguments.
new.function <- function(a,b,c) {
   result <- a * b + c
   print(result)
}

# Call the function by position of arguments.
new.function(5,3,11)

# Call the function by names of the arguments.
new.function(a = 11, b = 5, c = 3)

Default 값

다음과 같이 함수 내부에 default 값을 선언할 수도 있다. argument가 아무것도 주어지지 않는다면 default 값을 사용한다.

# Create a function with arguments.
new.function <- function(a = 3, b = 6) {
   result <- a * b
   print(result)
}

# Call the function without giving any argument.
new.function()

# Call the function with giving new values of the argument.
new.function(9,5)

https://www.tutorialspoint.com/r/r_operators.htm 

6. 반복문

(1) repeat

repeat는 계속해서 내부 코드를 반복한다. 반복문을 제어하는 내부 변수와 break 문을 통해 반복문을 탈출한다.

v <- c("Hello","loop")
cnt <- 2

repeat {
   print(v)
   cnt <- cnt+1
   
   if(cnt > 5) {
      break
   }
}

[1] "Hello" "loop" 
[1] "Hello" "loop" 
[1] "Hello" "loop" 
[1] "Hello" "loop" 

(2) while

while은 주어진 조건문이 true일때 계속 반복한다.

v <- c("Hello","while loop")
cnt <- 2

while (cnt < 7) {
   print(v)
   cnt = cnt + 1
}

(3) for 

for문은 vector나 list의 마지막 원소까지 반복한다.

v <- LETTERS[1:4]
for ( i in v) {
   print(i)
}

https://www.tutorialspoint.com/r/r_operators.htm 

5. If, if else, switch

If 문

x <- 30L
if(is.integer(x)) {
   print("X is an Integer")
}

[1] "X is an Integer"

If else 문

x <- c("what","is","truth")

if("Truth" %in% x) {
   print("Truth is found")
} else {
   print("Truth is not found")
}

[1] "Truth is not found"

Switch 문

switch 문은 일반적인 C, Java등의 프로그래밍 언어와는 조금 다르다.

# by index
switch(1, "one", "two")
## [1] "one"


# by index with complex expressions
switch(2, {"one"}, {"two"})
## [1] "two"


# by index with complex named expression
switch(1, foo={"one"}, bar={"two"})
## [1] "one"


# by name with complex named expression
switch("bar", foo={"one"}, bar={"two"})
## [1] "two"

https://www.tutorialspoint.com/r/r_operators.htm 

• 산술 연산자 (Arithmetic Operators)
• 관계 연산자 (Relational Operators)
• 논리 연산자 (Logical Operators)
• 할당 연산자 (Assignment Operators)
• 기타 연산자

v <- c(2,5.5,6)
t <- c(8, 3, 4)
print(v+t)

[1] 10.0  8.5  10.0

v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v-t)

[1] -6.0  2.5  2.0

v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v*t)

[1] 16.0 16.5 24.0

v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v/t)

[1] 0.250000 1.833333 1.500000

v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v%%t)

[1] 2.0 2.5 2.0

v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v%/%t)

[1] 0 1 1

v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v^t)

[1]  256.000  166.375 1296.000

v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v>t)

[1] FALSE  TRUE FALSE FALSE

v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v < t)

[1]  TRUE FALSE  TRUE FALSE

v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v == t)

[1] FALSE FALSE FALSE  TRUE

v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v<=t)

[1]  TRUE FALSE  TRUE  TRUE

v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v>=t)

[1] FALSE  TRUE FALSE  TRUE

v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v!=t)

[1]  TRUE  TRUE  TRUE FALSE

v <- c(3,1,TRUE,2+3i)
t <- c(4,1,FALSE,2+3i)
print(v&t)

[1]  TRUE  TRUE FALSE  TRUE

v <- c(3,0,TRUE,2+2i)
t <- c(4,0,FALSE,2+3i)
print(v|t)

[1]  TRUE FALSE  TRUE  TRUE

v <- c(3,0,TRUE,2+2i)
print(!v)

[1] FALSE  TRUE FALSE FALSE

v <- c(3,0,TRUE,2+2i)
t <- c(1,3,TRUE,2+3i)
print(v&&t)

[1] TRUE

v <- c(0,0,TRUE,2+2i)
t <- c(0,3,TRUE,2+3i)
print(v||t)

[1] FALSE

v1 <- c(3,1,TRUE,2+3i)
v2 <<- c(3,1,TRUE,2+3i)
v3 = c(3,1,TRUE,2+3i)
print(v1)
print(v2)
print(v3)

[1] 3+0i 1+0i 1+0i 2+3i
[1] 3+0i 1+0i 1+0i 2+3i
[1] 3+0i 1+0i 1+0i 2+3i

c(3,1,TRUE,2+3i) -> v1
c(3,1,TRUE,2+3i) ->> v2 
print(v1)
print(v2)

[1] 3+0i 1+0i 1+0i 2+3i
[1] 3+0i 1+0i 1+0i 2+3i

v <- 2:8
print(v) 

[1] 2 3 4 5 6 7 8

v1 <- 8
v2 <- 12
t <- 1:10
print(v1 %in% t) 
print(v2 %in% t) 

[1] TRUE
[1] FALSE

M = matrix( c(2,6,5,1,10,4), nrow = 2,ncol = 3,byrow = TRUE)
t = M %*% t(M)
print(t)

      [,1] [,2]
[1,]   65   82
[2,]   82  117

https://www.tutorialspoint.com/r/r_operators.htm 

https://www.tutorialspoint.com/r/r_variables.htm

변수

변수는 변수명을 통해 프로그램에서 데이터를 조작할 수 있도록 한다. 변수를 통하여 여러가지 자료구조를(atomic vector, vector, R-Object들의 여러가지 조합) 저장할 수 있다. 변수명에는 숫자, 문자, ., _가 포함될 수 있으며, 문자 또는 .을 첫글자로 하여야 한다. 단 .를 첫글자로 할 때는 .뒤에 숫자가 오면 안된다. 아래의 예를 참고하라.

변수 할당

# Assignment using equal operator.
var.1 = c(0,1,2,3)           

# Assignment using leftward operator.
var.2 <- c("learn","R")   

# Assignment using rightward operator.   
c(TRUE,1) -> var.3           

print(var.1)
cat ("var.1 is ", var.1 ,"\n")
cat ("var.2 is ", var.2 ,"\n")
cat ("var.3 is ", var.3 ,"\n")

변수할당은 = 또는 <-, -> 을 통해 할 수 있다. 또한 출력은 print(), cat()을 통해 할 수 있다. cat() 함수는 여러개의 인풋을 합쳐서 프린트한다.

결과

[1] 0 1 2 3
var.1 is  0 1 2 3 
var.2 is  learn R 
var.3 is  1 1 

변수들의 데이터 타입

R에서 변수의 데이터 타입은 변수에 할당되는 R-Object의 데이터 타입을 따른다. 그래서 R을 동적인 언어(dynamically typed language)라고 부른다. R에서는 변수의 데이터 타입이 하나에 고정되는 것이 아니라 계속해서 바꿀 수 있다. 

var_x <- "Hello"
cat("The class of var_x is ",class(var_x),"\n")

var_x <- 34.5
cat("  Now the class of var_x is ",class(var_x),"\n")

var_x <- 27L
cat("   Next the class of var_x becomes ",class(var_x),"\n")

The class of var_x is  character 
   Now the class of var_x is  numeric 
      Next the class of var_x becomes  integer

변수 찾기

현재 사용되고 있는 변수들의 목록을 보기 위해서는 ls() 함수를 이용한다. 또한 ls() 함수는 변수를 찾기 위해 '패턴'을 이용할 수도 있다. 

print(ls())

[1] "my var"     "my_new_var" "my_var"     "var.1"      
[5] "var.2"      "var.3"      "var.name"   "var_name2."
[9] "var_x"      "varname" 

# List the variables starting with the pattern "var".
print(ls(pattern = "var"))   

[1] "my var"     "my_new_var" "my_var"     "var.1"      
[5] "var.2"      "var.3"      "var.name"   "var_name2."
[9] "var_x"      "varname"  

주의할 점은 .으로 시작하는 변수들은 hidden 이다. 이것을 보기 위해서는 아래와 같이 all.name 파라미터를 TRUE로 설정한다.

print(ls(all.name = TRUE))

변수 삭제

변수는 rm() 함수를 사용해 지울 수 있다. 

rm(var.3)
print(var.3)

위의 스크립트를 실행시키면 var.3 변수를 삭제시키고 두 번째 줄에서는 에러가 뜬다.

rm(list = ls())
print(ls())

모든 변수를 지우고 싶으면 rm()과 ls()를 위와 같이 결합한다.

https://www.tutorialspoint.com/r/r_data_types.htm

일반적인 프로그래밍에서는 값들을 저장하기 위하여 다양한 변수(Variables)들이 필요하다. 변수는 값을 저장한 메모리의 위치를 나타낸다. 이것은 변수를 만들면 그것이 메모리를 일정 공간을 차지한다는 것을 뜻한다. 문자, 정수, 실수, 진릿값 등 다양한 데이터를 변수에 저장하는 것이 필요할 것이다. 운영체제는 이러한 데이터 타입에 알맞게 변수에 메모리를 할당한다. 

R에서는 C나 Java와 같은 프로그래밍 언어와는 다르게 R 에서는 변수를 만들 때 데이터 타입을 선언하지 않는다. 변수는 R-Object로 할당되며 R-Object의 데이터타입이 변수의 데이터타입이 된다. 다양한 타입의 R-Object가 있지만 자주 사용되는 R-Object의 타입은 아래와 같다.

자주 사용하는 데이터 타입

• Vectors
• Lists
• Matrices
• Arrays
• Factors
• Data Frames

• Logical     
• ex) TRUE, FALSE
• Numeric
• 12.3, 5, 999
• Integer
• 2L, 34L
• Complex
• 3+2i
• Character
• 'a', 'good'
• Raw
• "Hello" 는 48 64 6c 6c 6f로 저장된다.

v <- TRUE 
print(class(v))

v <- 23.5
print(class(v))

v <- 2L
print(class(v))

v <- 2+5i
print(class(v))

v <- "TRUE"
print(class(v))

v <- charToRaw("Hello")
print(class(v))

결과 : 

[1] "logical"

[1] "numeric"
[1] "integer"
[1] "complex"
[1] "character"
[1] "raw"

Vectors

R 언어에서 가장 많이 사용되고 기본적인 R-Object는 Vectors이다. 이것은 위의 열거된 atomic vector들을 저장한다. Vectors는 c() 함수를 사용하여 만들 수 있다. 이것은 엘리먼트들을 벡터로 합친다는 뜻이다. (combine의 c)


# Create a vector.
apple <- c('red','green',"yellow")
print(apple)

# Get the class of the vector.
print(class(apple))


[1] "red"   "green" "1"    
[1] "character"



Matrices


매트릭스는 2차원의 데이터셋이다. 이것은 매트릭스 함수에 벡터를 제공함으로써 만들 수 있다.


# Create a matrix.
M = matrix( c('a','a','b','c','b','a'), nrow = 2, ncol = 3, byrow = TRUE)
print(M)
print(class(M))

     [,1] [,2] [,3]
[1,] "a"  "a"  "b" 
[2,] "c"  "b"  "a" 
[1] "matrix"


Arrays

매트릭스는 2차원에 한정되지만 arrays는 어떠한 차원으로 만들 수 있다. 

# Create an array.
a <- array(c('green','yellow'),dim = c(3,3,2))
print(a)

, , 1

     [,1]     [,2]     [,3]    
[1,] "green"  "yellow" "green" 
[2,] "yellow" "green"  "yellow"
[3,] "green"  "yellow" "green" 

, , 2

     [,1]     [,2]     [,3]    
[1,] "yellow" "green"  "yellow"
[2,] "green"  "yellow" "green" 
[3,] "yellow" "green"  "yellow"


위 코드는 3차원의 array를 만들고, 원소들을 차례대로 green, yellow로 지정한다.


Factors

Factors는 vector로 만들어지는 R-object이다. Factors는 vector의 element들의 고유값(distinct value)를 레이블로 저장한다. 이 레이블들은 벡터 원소 타입이 어떻든 간에 항상 문자이다. Factors는 통계적 모델링에 유용하다. Factors는 factor()함수를 사용하여 만들 수 있다. nlevels() 함수를 통해 factors의 레벨을 알 수 있다.

# Create a vector.
apple_colors <- c('green','green','yellow','red','red','red','green')

# Create a factor object.
factor_apple <- factor(apple_colors)

# Print the factor.
print(factor_apple)
print(nlevels(factor_apple))

[1] green  green  yellow red    red    red    green 
Levels: green red yellow
[1] 3


Data Frames

데이터프레임은 구조화된 데이터 오브젝트이다. 매트릭스와 다른점은 데이터프레임은 컬럼으로 어떠한 데이터타입이든 넣을 수 있다. 첫 번째 컬럼은 numeric, 두 번째 컬럼은 문자열, 세 번째 컬럼은 논릿값 등 자유롭게 지정할 수 있다. 이것은 같은 길이의 vector들의 list로 볼 수 있다.

데이터 프레임은 data.frame() 함수를 통해 생성할 수 있다.

 # Create the data frame.
BMI <-  data.frame(
   gender = c("Male", "Male","Female"), 
   height = c(152, 171.5, 165), 
   weight = c(81,93, 78),
   Age = c(42,38,26)
)
print(BMI)

gender height weight Age
1   Male  152.0     81  42
2   Male  171.5     93  38
3 Female  165.0     78  26

원문 : https://www.tutorialspoint.com/r/index.htm

R tutorial

R은 통계 분석, 그래픽 표현 그리고 리포팅을 위한 프로그래밍 언어 및 소프트웨어 환경이다. R은 뉴질랜드 오클랜드 대학교의 Ross Ihaka and Robert Gentleman에 의해 만들어졌고, 현재는 R Development Core Team가 R을 개발하고 있다. R은 GNU(General Public License) 라이센스하에서 자유롭게 이용가능하며, 리눅스, 윈도우즈, 맥과 같은 다양한 운영체제에 컴파일된 바이너리를 제공하고 있다.  이 프로그래밍 언어 R은 두 명의 개발자, Ross Ihaka and Robert Gentleman 이름의 가장 앞 글자를 딴 것이다. 그리고 Bell Labs에서 만든 프로그래밍 언어 S를 근간으로한다.

대상 독자

이 튜토리얼은 R을 이용하여 통계 소프트웨어를 만들고자하는 소프트웨어 개발자, 통계학자, 데이터 마이너를 대상으로 한다. 만약 당신이 R에 처음이라면, 이 튜토리얼을 통해 R 언어의 대부분의 컨셉을 이해할 수 있고, 이를 통해 더 높은 레벨의 전문가가 될 수 있을 것이다.

선행 조건

이 튜토리얼을 시작하기 앞서 컴퓨터 프로그래밍 언어의 용어들에 대한 기본적인 이해가 필요하다. 프로그래밍 언어에 대한 기본적인 이해는 R 언어의 컨셉을 이해하고 학습하는데 도움이 될 것이다.