08-list.qmd

```{r}
#| include: false

source("_common.R")
```

# 리스트 {#r-list}
\index{리스트}
\index{자료형!리스트}

## 리스트는 시퀀스다 {#r-list-sequence}

문자열처럼, 리스트(list)는 값의 시퀀스다. 문자열에서, 값은 문자지만, 리스트에서는 임의 자료형(type)도 될 수 있다. 리스트 값은 요소(elements)나 때때로 항목(items)으로 불린다.
\index{요소}
\index{시퀀스}
\index{항목}

신규 리스트를 생성하는 방법은 여러 가지가 있다. 가장 간단한 방법은 `list()` 함수로 요소를 감싸는 것이다.


::::: {.columns}

::: {.column width="47.5%"}
### R {.unnumbered}

```{r}
#| eval: false
list(10, 20, 30, 40)
list('crunchy frog', 'ram bladder', 'lark vomit')
list('고양이', '호랑이', '사자')
```

:::

::: {.column width="5%"}

:::

::: {.column width="47.5%"}
### 파이썬 {.unnumbered}

```{python}
#| eval: false
[10, 20, 30, 40]
['crunchy frog', 'ram bladder', 'lark vomit']
['고양이', '호랑이', '사자']
```

:::
:::::

첫 번째 예제는 4개 정수 리스트다. 두번째 예제는 3개 문자열 리스트다.
세 번째 예제는 한글 문자열 리스트다. 리스트 문자열 요소가 동일한 자료형(type)일 필요는 없다. 다음 리스트는 문자열, 부동 소수점 숫자, 정수, (아!) 또 다른 리스트를 담고 있다.

::::: {.columns}

::: {.column width="47.5%"}
### R {.unnumbered}

```{r}
#| eval: false
list('spam', 2.0, 5, list(10, 20))
```

:::

::: {.column width="5%"}

:::

::: {.column width="47.5%"}
### 파이썬 {.unnumbered}

```{python}
#| eval: false
['spam', 2.0, 5, [10, 20]]
```
:::
:::::



또 다른 리스트 내부에 리스트가 **중첩(nested)**되어 있다.
\index{중첩 리스트}
\index{리스트!중첩}

어떤 요소도 담고 있지 않는 리스트를 빈 리스트(empty list)라고 부르고, `list()`로 생성한다.
\index{빈 리스트}
\index{리스트!빈}

예상했듯이, 리스트 값을 변수에 대입할 수 있다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-data
cheeses <- list('체다', '브리', '까망베르')
numbers <- list(17, 123)
empty <- list()
message(cheeses, numbers, empty)
#> 체다브리까망베르17123
```

### 파이썬

```{pyodide-python}
#| label: py-list-data
cheeses = ['체다', '브리', '까망베르']
numbers = [17, 123]
empty = []
print(cheeses, numbers, empty)
#> ['체다', '브리', '까망베르'] [17, 123] []
```

:::

\index{대입}


## 리스트는 변경 가능하다 {#r-list-mutable}
\index{리스트!요소}
\index{접근}
\index{인덱스}
\index{꺾쇠 연산자}
\index{연산자!꺾쇠}

리스트 요소에 접근하는 구문은 문자열 문자에 접근하는 것과 동일한 꺾쇠 괄호 연산자다. 
꺾쇠 괄호 내부 표현식은 인덱스를 명세한다. 
기억할 것은 인덱스는 1에서부터 시작한다는 것이다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-access}
cheeses[1]
#> [[1]]
#> [1] "체다"
```

### 파이썬

```{pyodide-python}
#| label: py-list-access}
cheeses[0]
#> '체다'
```

:::


문자열과 마찬가지로, 리스트 항목 순서를 바꾸거나, 리스트에 새로운 항목을 다시 대입할 수 있기 때문에 리스트는 변경 가능하다. 
꺾쇠 괄호 연산자가 대입문 왼쪽편에 나타날 때, 새로 대입될 리스트 요소를 나타낸다.
\index{변경성}

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-mutable
numbers <- list(17, 123)

numbers[1] <- 5
print(numbers)
#> [[1]]
#> [1] 5
#> 
#> [[2]]
#> [1] 123
```

### 파이썬

```{pyodide-python}
#| label: py-list-mutable
numbers = [17, 123]
numbers[1] = 5
print(numbers)
#> [17, 5]
```

:::

리스트 numbers의 첫 번째 요소는 `123` 값을 가지고 있었으나, 이제 `5` 값을 가진다.
\index{인덱스!1 에서 시작}
\index{1, 인덱스 시작점}


리스트를 인덱스와 요소의 관계로 생각할 수 있다. 이 관계를 **매핑(mapping)**이라고 부른다. 각각의 인덱스는 요소 중 하나에 **대응("maps to")**된다.
\index{항목 대입}
\index{대입!항목}

리스트 인덱스는 문자열 인덱스와 동일한 방식으로 동작한다.

-   어떠한 정수 표현식도 인덱스로 사용할 수 있다.
-   존재하지 않는 요소를 읽거나 쓰려고 하면, 일종의 인덱스 오류(IndexError)로 `NULL`이 반환된다.
-   인덱스가 음의 값이면, 해당 리스트 원소가 누락된다.
\index{예외!인덱스 오류}
\index{인덱스 오류}

`%in%` 연산자도 또한 리스트에서 동작하니 리스트 원소로 존재하는지 여부를 판별하는 데 사용할 수 있다.

\index{리스트!인덱스}
\index{리스트!소속}
\index{소속!리스트}
\index{%in% 연산자}
\index{연산자!%in%}

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-in
cheeses <- list('체다', '브리', '까망베르')
'체다' %in% cheeses
#> [1] TRUE
'고르곤졸라' %in% cheeses
#> [1] FALSE
```

### 파이썬

```{pyodide-python}
#| label: py-list-in
cheeses = ['체다', '브리', '까망베르']
'체다' in cheeses
True
'고르곤졸라' in cheeses
False
```

:::

## 리스트 순회법 {#r-list-traversal}
\index{리스트!운행법}
\index{운행법!리스트}
\index{for 루프}
\index{루프!for}
\index{문장!for}

리스트 요소를 순회하는 가장 흔한 방법은 `for` 문을 사용하는 것이다. 문자열에서 사용한 것과 구문은 동일하다.

::::: {.columns}


::: {.column width="47.5%"}
### R {.unnumbered}
```{r}
#| eval: false
#| label: r-list-for
for(cheese in cheeses) {
  print(cheese)
}
```

:::

::: {.column width="5%"}

:::

::: {.column width="47.5%"}
### 파이썬 {.unnumbered}
```{python}
#| eval: false
#| label: py-list-for
for cheese in cheeses:
    print cheese
```

:::
:::::


리스트 요소를 읽기만 한다면 이것만으로도 잘 동작한다. 하지만, 리스트 요소를 쓰거나 갱신하는 경우, 인덱스가 필요하다. 
리스트 요소를 쓰거나 갱신하는 일반적인 방법은 `seq_along()` 함수를 조합하는 것이다.
\index{루프!인덱스}
\index{인덱스!루프}


:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-seq_along
numbers <- list(1, 2, 3, 4, 5)

for(i in seq_along(numbers)){
  numbers[[i]] <- numbers[[i]] * 2
  message("결과:", numbers[[i]])
}
```

### 파이썬

```{pyodide-python}
#| label: py-list-seq_along
numbers = [1, 2, 3, 4, 5]

for i in range(len(numbers)):
    numbers[i] = numbers[i] * 2
    print("결과:", numbers[i])
```

:::


상기 루프는 리스트를 순회하고 각 요소를 갱신한다. `seq_along()` 함수는 1에서 $n$까지 리스트 인덱스를 반환한다. 
여기서, $n$은 리스트 길이가 된다. 매번 루프가 반복될 때마다, `i`는 다음 요소 인덱스를 얻는다. 몸통 부문 대입문은 `i`를 사용해서 요소의 이전 값을 읽고 새 값을 대입한다.
\index{항목 갱신}
\index{갱신!항목}


빈 리스트(`list()`)에 대해서 `for` 문은 결코 몸통 부문을 실행하지 않는다.

::::: {.columns}

::: {.column width="47.5%"}
### R {.unnumbered}
```{r}
#| eval: false
#| label: r-list-empty
for(x in list()) {
  print('이런 일은 절대 발생하지 않는다.')
}
```

:::

::: {.column width="5%"}

:::

::: {.column width="47.5%"}
### 파이썬 {.unnumbered}
```{python}
#| eval: false
#| label: py-list-empty
for x in empty:
    print('이런 일은 절대 발생하지 않는다.')
```

:::
:::::


리스트가 또 다른 리스트를 담을 수 있지만, 중첩된 리스트는 여전히 요소 하나로 간주된다. 다음 리스트 길이는 4다.
\index{중첩 리스트}
\index{리스트!중첩}


::::: {.columns}

::: {.column width="47.5%"}
### R {.unnumbered}
```{r}
#| eval: false
#| label: r-list-length
list('spam', 1, list('브리', '체다', '까멩베르'), list(1, 2, 3))
```

:::

::: {.column width="5%"}

:::

::: {.column width="47.5%"}
### 파이썬 {.unnumbered}
```{python}
#| eval: false
#| label: py-list-length
['spam', 1, ['Brie', 'Roquefort', 'Pol le Veq'], [1, 2, 3]]
```

:::
:::::

## 리스트 연산자 {#r-list-operator}
\index{리스트!연산}

`c()` 함수 연산자는 리스트를 추가하여 결합시킨다.
\index{연결!리스트}
\index{리스트!연결}


:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-append
a <- list(1, 2, 3)
b <- list(4, 5, 6)
c <- c(a, b)
print(c)
```

### 파이썬

```{pyodide-python}
#| label: py-list-append
a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
print(c)
#> [1, 2, 3, 4, 5, 6]
```

:::

유사하게 `rep()` 함수를 활용하면 주어진 횟수만큼 리스트를 반복한다.
\index{반복!리스트}
\index{리스트!반복}

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-repeat
rep(list(0), 4)

rep(list(1, 2, 3), 3)
```

### 파이썬

```{pyodide-python}
#| label: py-list-repeat
[0] * 4
#> [0, 0, 0, 0]
[1, 2, 3] * 3
#> [1, 2, 3, 1, 2, 3, 1, 2, 3]
```

:::


첫 예제는 `list(0)`을 4회 반복한다. 두 번째 예제는 `list(1, 2, 3)` 리스트를 3회 반복한다.

## 리스트 슬라이스 {#r-list-slice}
\index{슬라이스 연산자}
\index{연산자!슬라이스}
\index{인덱스!슬라이스}
\index{리스트!슬라이스}
\index{슬라이스!리스트}

**슬라이스(slice)** 연산자는 리스트에도 또한 동작한다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-slice}
t <- list('a', 'b', 'c', 'd', 'e', 'f')

t[2:3]

t[1:4]

t[4:length(t)]

t
```

### 파이썬

```{pyodide-python}
#| label: py-list-slice
t = ['a', 'b', 'c', 'd', 'e', 'f']
t[1:3]
#> ['b', 'c']
 t[:4]
#> ['a', 'b', 'c', 'd']
t[3:]
#> ['d', 'e', 'f']
t[:]
#> ['a', 'b', 'c', 'd', 'e', 'f']
```

:::


첫 번째 인덱스를 1로 지정하면, 슬라이스는 처음부터 시작한다. 두 번째 인덱스를 `length()` 함수로 리스트 길이를 지정하면, 슬라이스는 끝까지 간다. 그래서 양쪽의 인덱스를 생략하면, `t`같이 지정하면 슬라이스 결과는 전체 리스트를 복사한 것이 된다.
\index{리스트!복사}
\index{슬라이스!복사}
\index{복사!슬라이스}

리스트는 변경이 가능하기 때문에 리스트를 접고, 돌리고, 훼손하는 연산을 수행하기 전에 복사본을 만들어두는 것이 유용하다.
\index{변경성}

대입문 왼편의 슬라이스 연산자로 복수의 요소를 갱신할 수 있다.
\index{슬라이스!갱신}
\index{갱신!슬라이스}

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-update
t <- list('a', 'b', 'c', 'd', 'e', 'f')
t[2:3] <- list(1, 2)
print(t)
```

### 파이썬

```{pyodide-python}
#| label: py-list-update
t = ['a', 'b', 'c', 'd', 'e', 'f']
t[1:3] = [1, 2]
print(t)
#> ['a', 1, 2, 'd', 'e', 'f']
```

:::


## 리스트 함수 {#r-list-function}
\index{리스트!함수}
\index{함수, 리스트}

R은 리스트 자료형에 연산할 수 있는 함수를 제공한다. 예를 들어, 덧붙이기(`append`) 함수는 리스트 끝에 신규 요소를 추가한다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-function-append
t <- list('a', 'b', 'c')
append(t, 'd')
```

### 파이썬

```{pyodide-python}
#| label: py-list-function-append}
t = ['a', 'b', 'c']
t.append('d')
print(t)
#> ['a', 'b', 'c', 'd']
```

:::

정렬(order) 함수는 낮음에서 높음으로 리스트 요소를 정렬한다. 
리스트에서 `sapply()` 혹은 `unlist()` 함수로 값으로 변환시키고 `order()` 함수를 통해 내림차순 혹은 오름차순으로 정렬 인덱스를 뽑아 리스트 내 원소를 정렬시킨다.
\index{정렬 함수}
\index{함수!정렬}

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-function-sort
t <- list('d', 'c', 'e', 'b', 'a')

t[order(unlist(t), decreasing=FALSE)]
```

### 파이썬

```{pyodide-python}
#| label: py-list-function-sort
t = ['d', 'c', 'e', 'b', 'a']
t.sort()
print(t)
#> ['a', 'b', 'c', 'd', 'e']
```

:::

## 리스트 요소 삭제 {#r-list-delete}
\index{리스트 요소 삭제}
\index{삭제, 리스트 요소}

리스트 요소를 삭제하는 방법이 몇 가지 있다. 리스트 요소 인덱스를 알고 있다면, 숫자 인덱스 앞에 `-` 기호를 붙여 사용한다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-delete-by-index
t <- list('a', 'b', 'c')
x <- t[2]
t <- t[-2]
print(x)
print(t)
```

### 파이썬

```{pyodide-python}
#| label: py-list-delete-by-index
t = ['a', 'b', 'c']
x = t.pop(1)
print(t)
#> ['a', 'c']
print(x)
#> b
```

:::


리스트 요소 명칭을 알고 있다면, 리스트 요소에 `NULL`을 대입하여 삭제시킨다.

```{r}
#| label: r-list-delete-by-name
t <- list(a='a', b='b', c = 'c')
t[["c"]] <- NULL
t$c <- NULL
t
```

`NULL`을 대입하여 삭제시킨 리스트는 제거된 요소를 반환한다.
`t[[1]]` 리스트 인덱스를 통해 요소에 접근하고 `NULL`을 대입하여 삭제한다.
\index{NULL 특수값}
\index{특수값!NULL}

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-delete-by-index
t = list('a', 'b', 'c')
t[[1]] <- NULL
t
```

### 파이썬

```{pyodide-python}
#| label: py-list-delete-by-index
t = ['a', 'b', 'c']
del t[1]
print(t)
#> ['a', 'c']
```

:::


(인덱스 혹은 리스트 요소 이름이 아닌) 제거할 요소값을 알고 있다면, 리스트 요소 값을 활용해서 제거하는 것도 가능하다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-delete-by-value
t <- list('x', 'y', 'z')

t[t != "y"]
```

### 파이썬

```{pyodide-python}
#| label: py-list-delete-by-value
t = ['a', 'b', 'c']
t.remove('b')
print(t)
#> ['a', 'c']
```

:::


하나 이상의 요소를 제거하기 위해서, 슬라이스 인덱스(slice index)를 사용하는 것도 가능하다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-delete-slice
t <- list('a', 'b', 'c', 'd', 'e', 'f')
t[-c(2:5)]
```

### 파이썬

```{pyodide-python}
#| label: py-list-delete-slice
t = ['a', 'b', 'c', 'd', 'e', 'f']
del t[1:5]
print(t)
#> ['a', 'f']
```

:::

위의 예제에서 2에서 5까지 모든 요소를 선택하고 선택된 모든 요소를 제거한다.

## 리스트와 함수

루프를 작성하지 않고도 리스트를 빠르게 살펴볼 수 있는 리스트에 적용할 수 있는 내장 함수를 활용하는 것도 방법이지만, 
깔끔한 세상(tidyverse) 생태계의 일원인 `purrr` 함수형 프로그래밍 패키지에 내장된 함수를 활용하는 것도 권장된다.

하지만, 다음과 같이 1차원 리스트는 `unlist()` 함수를 활용하여 벡터로 변환해서 사용하는 것이 편리한 경우가 많다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-unlist
nums <- list(3, 41, 12, 9, 74, 15) %>% unlist

length(nums)
#> 6
max(nums)
#> 74
min(nums)
#> 3
sum(nums)
#> 154
sum(nums) / length(nums)
#> 25.66667
```

### 파이썬

```{pyodide-python}
#| label: py-list-unlist
nums = [3, 41, 12, 9, 74, 15]

print(len(nums))
#> 6
print(max(nums))
#> 74
print(min(nums))
#> 3  
print(sum(nums))
#> 154  
print(sum(nums) / len(nums))
#> 25.666666666666668
```

:::


`sum()`, `max()`, `length()` 등 함수는 입력 자료형이 무엇이냐에 따라 다르게 동작할 수 있고, 
입력 자료형에 결측값 등 특이값이 들어있는 경우 기대했던 결과가 나올 수 없으니 반드시 자료형을 사전에 점검하고 활용하도록 한다.

리스트를 사용해서, 앞서 작성한 프로그램을 다시 작성해서 사용자가 입력한 숫자 목록 평균을 계산한다.

우선 리스트 없이 평균을 계산하는 프로그램:

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-user-input-average
## 프로그램 명칭: `list_average.R`
total <- 0
count <- 0

while(TRUE) {
  cat("숫자를 입력하세요: ")
  inp <- readLines(file("stdin"), 1)
  if(inp == 'done') {
    break
  }
  value <- as.numeric(inp)
  total <- total + value
  count <- count + 1
}

average <- total / count
message('평균:', average)
#> 숫자를 입력하세요: 10
#> 숫자를 입력하세요: 20
#> 숫자를 입력하세요: 30
#> 숫자를 입력하세요: done
#> 평균: 20
```

### 파이썬

```{pyodide-python}
#| label: py-list-user-input-average
total = 0
count = 0

while True:
    inp = input('숫자를 입력하세요: ')
    if inp == 'done':
        break
    value = float(inp)
    total += value
    count += 1

average = total / count
print('평균:', average)

#> 숫자를 입력하세요: 10
#> 숫자를 입력하세요: 20
#> 숫자를 입력하세요: 30
#> 숫자를 입력하세요: done
#> 평균: 20.0
```

:::


상기 프로그램에서, `count` 와 `sum` 변수를 사용해서 반복적으로 사용자가 숫자를 입력하면 값을 저장하고, 지금까지 사용자가 입력한 누적 합계를 계산한다. R 콘솔에서 `source()` 함수를 사용해서 실행한 결과는 다음과 같다.

```{r r-list-average-run, eval = FALSE}
> source("code/list_average.R")
숫자를 입력하세요: 10
숫자를 입력하세요: 20
숫자를 입력하세요: 30
숫자를 입력하세요: done
평균: 20
```

단순하게, 사용자가 입력한 각 숫자를 리스트로 기억하고 내장 함수를 사용해서 프로그램 마지막에 합계와 갯수를 통해 평균을 계산한다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-user-input-average
# list_average2.R ... 자료구조 사용 
numlist <- list()

while(TRUE) {
  cat("숫자를 입력하세요: ")
  inp <- readLines(file("stdin"), 1)
  if(inp == 'done') {
    break
  }
  value <- as.numeric(inp)
  numlist <- append(numlist, value)
}

average <- sum(unlist(numlist)) / length(numlist)
message('평균:', average)
```

### 파이썬

```{pyodide-python}
#| label: py-list-user-input-average
numlist = list()

while True:
    inp = input('숫자를 입력하세요: ')
    if inp == 'done':
        break
    value = float(inp)
    numlist.append(value)

average = sum(numlist) / len(numlist)
print('평균:', average)
```

:::


루프가 시작되기 전 빈 리스트를 생성하고, 매번 숫자를 입력할 때마다 숫자를 리스트에 추가한다. 프로그램 마지막에 간단하게 리스트 총합을 계산하고, 평균을 산출하기 위해서 입력한 숫자 개수로 나눈다. R 콘솔에서 `source()` 함수를 사용해서 실행한 결과는 다음과 같다.

```{bash}
#| label: r-list-numlist-run
#| eval: false
> source("code/list_average2.R")
숫자를 입력하세요: 10
숫자를 입력하세요: 20
숫자를 입력하세요: 30
숫자를 입력하세요: done
평균: 20
```

## 리스트와 문자열 {#r-list-string}
\index{리스트}
\index{문자열}
\index{시퀀스}

문자열(string)은 **문자 시퀀스**이고, 리스트는 **값 시퀀스**이다. 하지만 리스트 문자는 문자열과 같지는 않다. 문자열을 리스트 문자로 변환하기 위해서, `strsplit()` 함수를 사용한다.
\index{리스트!함수}
\index{함수!리스트}

:::{.panel-tabset}
### R

```{webr-r}
#| label: py-list-strsplit
s <- 'spam'
t <- strsplit(s, "")[[1]] |>  strsplit(NULL)
print(t)
```

### 파이썬

```{pyodide-python}
#| label: r-list-strsplit
s = 'spam'
t = list(s)
print(t)
#> ['s', 'p', 'a', 'm']
```

:::


`list`는 내장 함수 이름이기 때문에, 변수명으로 사용하는 것을 피해야 한다. `l`을 사용하면 1처럼 보이기 때문에 가능하면 피한다. 그래서, `t`를 사용했다.

`strsplit()` 함수는 문자열을 구분자(이번 경우에는 `NULL`)를 사용해서 문자 각각으로 쪼갠다. 문자열 단어로 쪼개려면, 구분자를 바꿔 예를 들어 공백을 기준으로 쪼갠다.
\index{분할 함수}
\index{함수!분할}


:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-split-separator
s <- list('이제는 디지털 글쓰기가 대세다.')
t <- strsplit(s[[1]], " ")[[1]] %>% strsplit(" ")
t
```

### 파이썬

```{pyodide-python}
#| label: py-list-split-separator
s = '이제는 디지털 글쓰기가 대세다.'
t = s.split()
print(t)
#> ['이제는', '디지털', '글쓰기가', '대세다.']
```

:::


분할 함수를 사용해서 문자열을 리스트 토큰으로 쪼개면, 인덱스 연산자('[]')를 사용하여 리스트의 특정 단어를 볼 수 있다.

옵션 인자로 단어 경계로 어떤 문자를 사용할 것인지 지정하는 데 사용되는 구분자(delimiter)를 활용하여 분할 `strsplit()` 함수를 호출한다. 
다음 예제는 구분자로 하이픈('-')을 사용한 사례이다.
\index{옵션 인자}
\index{인자!옵션}
\index{구분자}


:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-delimiter
s <- list('spam-spam-spam')
delimiter <- '-'
strsplit(s[[1]], delimiter)[[1]] %>% strsplit(" ")

```

### 파이썬

```{pyodide-python}
#| label: py-list-delimiter
s = 'spam-spam-spam'
delimiter = '-'
print(s.split(delimiter))
#> ['spam', 'spam', 'spam']
```

:::

합병(`paste`) 함수는 분할(`strsplit`) 함수의 역이다. 문자열 리스트를 받아 리스트 요소를 연결한다.
\index{합병 함수}
\index{합병!paste}
\index{연결}

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-paste
t <- list('이제는', '디지털', '글쓰기가', '대세다.')
delimiter <- ' '
paste0(t, delimiter, collapse = "")
#> [1] "이제는 디지털 글쓰기가 대세다. "
```

### 파이썬

```{pyodide-python}
#| label: py-list-paste
t = ['이제는', '디지털', '글쓰기가', '대세다.']
delimiter = ' '
print(delimiter.join(t))
#> 이제는 디지털 글쓰기가 대세다.
```

:::


상기의 경우, 구분자가 공백 문자여서 결합(`paste`) 함수가 단어 사이에 공백을 넣는다. 공백 없이 문자열을 결합하기 위해서, 구분자로 빈 문자열 ''을 사용한다.
\index{빈 문자열}
\index{문자열!빈}

## 라인 파싱하기 {#r-list-parsing}

파일을 읽을 때 통상, 단지 전체 라인을 출력하는 것 말고 뭔가 다른 것을 하고자 한다. 종종 "흥미로운 라인을" 찾아서 라인을 **파싱(parse)**하여 흥미로운 부분을 찾고자 한다. "From "으로 시작하는 라인에서 요일을 찾고자 하면 어떨까?

> `From stephen.marquard@uct.ac.za` **Sat** `Jan  5 09:14:16 2008`

이런 종류의 문제에 직면했을 때, `stringr` 패키지 분할 `str_split()` 함수가 매우 효과적이다. 
작은 프로그램을 작성하여 "From "으로 시작하는 라인을 찾고 `str_split()` 함수로 파싱하고 라인의 흥미로운 부분을 출력한다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-email-parsing
download.file("https://www.dr-chuck.com/py4inf/code/mbox-short.txt",
              destfile = "mbox-short.txt")

fhand <- readLines('mbox-short.txt')

for (line in fhand) {
    line <- trimws(line)  # 공백 제거
    if (length(grep("^From ", line)) == 0) {
        next
    }
    words <- unlist(strsplit(line, " "))
    if (length(words) >= 3) {
        print(words[3])
    }
}
```

### 파이썬

```{pyodide-python}
#| label: py-list-email-parsing
fhand = open('mbox-short.txt')

for line in fhand:
    line = line.rstrip()
    if not line.startswith('From '):
        continue
    words = line.split()
    print(words[2])
```

:::

`if` 문의 축약 형태를 사용하여 `next` 문을 `if` 문과 동일한 라인에 놓았다. `if` 문 축약 형태는 `next` 문을 들여쓰기를 다음 라인에 한 것과 동일하다.

프로그램은 다음을 출력한다.

```{bash}
#| label: r-list-email-parsing-output
#| eval: false
Sat
Fri
Fri
Fri
...
```

나중에, 매우 정교한 기술에 대해서 학습해서 정확하게 검색하는 비트(bit) 수준 정보를 찾아내기 위해서 작업할 라인을 선택하고, 어떻게 해당 라인을 뽑아낼 것이다.

## 객체와 값 {#r-list-object-value}
\index{객체}
\index{값}

다음 대입문을 실행하면,

```{r r-list-banana}
a <- 'banana'
b <- 'banana'
```

`a`와 `b` 모두 문자열을 참조하지만, 두 변수가 동일한 문자열을 참조하는지 알 수 없다. 두 가지 가능한 상태가 있다.

![문자열 참조](images/list-reference.png){#fig-list-reference}

한 가지 경우는 `a`와 `b`가 같은 값을 가지는 다른 두 객체를 참조하는 것이다. 두 번째 경우는 같은 객체를 참조하는 것이다.
\index{에일리어싱}

두 변수가 동일한 객체를 참조하는지를 확인하기 위해서, 파이썬에서는 `is` 연산자가 사용된다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-a-b-reference
a <- 'banana'
b <- 'banana'
print(identical(a, b))
#> [1] TRUE
```

### 파이썬

```{pyodide-python}
#| label: py-a-b-reference
a = 'banana'
b = 'banana'
print(a is b)
#> True
```

:::


이 경우, 파이썬은 하나의 문자열 객체를 생성하고 `a`와 `b` 모두 동일한 객체를 참조한다.
\index{동일 연산자}
\index{연산자!identical}

하지만, 리스트 두 개를 생성할 때, 객체가 두 개다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-a-b-list
a <- list(1, 2, 3)
b <- list(1, 2, 3)
print(identical(a, b))
```

### 파이썬

```{pyodide-python}
#| label: py-a-b-list
a = [1, 2, 3]
b = [1, 2, 3]
print(a is b)
#> False
```

:::


상기의 경우, 두 개의 리스트는 동등하다고 말할 수 있다. 왜냐하면 동일한 요소를 가지고 있기 때문이다. 
하지만, 같은 객체는 아니기 때문에 동일하지는 않다. 두 개의 객체가 동일하다면, 두 객체는 또한 동등하다. 하지만, 동등하다고 해서 반드시 동일하지는 않다.
\index{동등}
\index{동일}

R과 파이썬이 다른 결과를 출력하는 이유는 무엇일까?
R `identical()` 함수는 객체의 값과 구조가 완전히 동일한지를 확인한다.
`a <- list(1, 2, 3)`와 `b <- list(1, 2, 3)`의 경우, `a`와 `b`는 별도의 객체이지만, 그 내용(값과 구조)이 완전히 동일하기 때문에 `identical(a, b)`는 `TRUE`를 반환한다.
파이썬 `is` 연산자는 객체가 메모리 상에서 동일한 위치를 가리키는지(즉, 같은 객체인지)를 확인한다.
`a = [1, 2, 3]`와 `b = [1, 2, 3]`의 경우, `a`와 `b`는 값은 동일하지만 서로 다른 메모리 위치에 할당된 별개의 리스트 객체라서 `a is b`는 `False`를 반환한다.

지금까지 "객체(object)"와 "값(value)"을 구분 없이 사용했지만, "객체가 값을 가진다."라고 말하는 것이 좀 더 정확하다. 
`a = [1,2,3]`을 실행하면, `a`는 특별한 순서 요소 값을 갖는 리스트 객체로 참조한다. 
만약 다른 리스트가 같은 요소를 가지고 있다면, 그 리스트는 같은 값을 가진다고 말할 수 있다.
\index{객체}
\index{값}

## 에일리어싱 {#r-list-aliasing}

에일리어싱(별칭 부여, Aliasing) 용어는 두 개 이상의 변수가 동일한 객체를 참조할 때 사용된다. 
`a`가 객체를 참조하고, `b <- a` 대입한다면, 두 변수는 동일한 객체를 참조한다.
\index{에일리어싱}
\index{참조!에일리어싱}

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-alias
a <- list(1, 2, 3)
b <- a
identical(a, b)
#> [1] TRUE

a <- list(4,5,6)
identical(a, b)
#> [1] FALSE
```

### 파이썬

```{pyodide-python}
#| label: py-list-alias
a = [1, 2, 3]
b = a
print(a is b)
#> True
a = [4, 5, 6]
print(a is b)
#> False
```

:::


객체와 변수의 연관 짓는 것을 **참조(reference)**라고 한다. 상기의 경우 동일한 객체에 두 개의 참조가 있다.
\index{참조}

하나 이상의 참조를 가진 객체는 한 개 이상의 이름을 갖게 되어서, 객체가 **에일리어스(aliased)** 되었다고 한다. 
만약 에일리어스된 객체가 변경 가능하면, 변화의 여파는 다른 객체에도 파급된다. 
\index{변경성}

R에는 파이썬 문자열(`string`), 튜플(`tuple`)과 같은 변경 불가능한 자료구조가 없다. 대신 객체 복사본을 생성하여 불변성을 유사하게 구현할 수 있다. `dplyr`과 같은 패키지에서 데이터 조작을 위해 내부적으로 데이터 복사본을 만들어 작업하는 경우가 많다. 다음 예제를 통해 R과 파이썬 차이를 확인할 수 있다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-mutable-alias
a <-  list(1, 2, 3)
b <-  a
b[1] <-  17
print(a)
#> [[1]]
#> [1] 1
#> 
#> [[2]]
#> [1] 2
#> 
#> [[3]]
#> [1] 3
```

### 파이썬

```{pyodide-python}
#| label: py-immutable-alias
a = [1, 2, 3]
b = a
b[0] = 17
print(a)
#> [17, 2, 3]
```

:::

이와 같은 행동이 유용하기도 하지만, 오류를 발생시키기도 쉽다. 
일반적으로, **변경 가능한 객체(mutable object)**로 작업할 때 에일리어싱을 피하는 것이 안전하다. 
\index{불변성}

```{python}
#| label: a-b-reference-python-banana
#| eval: false
a = 'banana'
b = 'banana'
```

파이썬 문자열 같이 변경 불가능한 객체에 에일리어싱은 그렇게 문제가되지 않는다. 
상기 파이썬 예제에서, `a`와 `b`가 동일한 문자열을 참조하든 참조하지 않든 거의 차이가 없다.

## 디버깅 {#r-list-debug}
\index{디버깅}

부주의한 리스트 사용이나 변경 가능한 객체를 사용하는 경우 디버깅에 시간이 오래 걸릴 수 있다. 
다음에 일반적인 함정 유형과 회피하는 방법을 소개한다.

1. R에서 리스트 함수가 파이썬과는 다르게 동작한다. 
R 리스트는 기본적으로 변경 가능(mutable)하지만, 리스트를 변형하는 함수 대부분은 새로운 리스트를 반환하고 원본 리스트는 변경하지 않는다. 
파이썬에서 문자열이 작동하는 방식과 유사하지만 차이가 있다. 
예를 들어, R에서 `sort` 함수는 `t` 리스트의 원본 내용을 변경하지 않고, 정렬된 결과를 새로운 벡터 `t_sorted`에 저장한다. 
R에서 리스트나 벡터를 다룰 때는 이러한 특성을 기억하는 것이 중요하다. 
또한 R에서는 인터랙티브 환경에서 함수의 동작을 테스트하고, 관련 문서나 도움말(`?function_name`)을 참조하여 함수가 어떻게 작동하는지 먼저 이해할 것을 권장한다. 
하지만, 파이썬에서 `word = word.strip()`과 같은 코드를 사용하여 문자열에서 공백을 제거하고, `t = t.sort()`처럼 리스트를 정렬할 수 있다. 
하지만 정렬(`sort`) 메서드는 `None`을 반환하기 때문에 주의가 필요하다. 
따라서, 리스트 관련 함수, 메서드, 연산자를 사용하기 전에, 문서를 주의 깊게 읽고, 인터랙티브 모드에서 시험하는 것을 권장한다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-sort-debug
t <- list(4, 2, 3)  
t_sorted <- sort(unlist(t))
print(as.list(t_sorted))
```

### 파이썬

```{pyodide-python}
#| label: py-sort-debug
t = [4,2,3]
t = t.sort() # word = word.strip() 방식과 다름
print(t)
#> None
```

:::

\index{정렬 함수}
\index{함수!정렬}

1.  **관용구를 선택하고 고수하라.**
\index{관용구}

리스트와 관련된 문제 일부는 리스트를 가지고 할 수 있는 것이 너무 많다는 것이다. 
예를 들어, 리스트에서 요소를 제거하기 위해서는 `list` 객체에서 직접 요소를 제거하는 대신, 새로운 리스트를 생성하거나 벡터로 작업을 대신한다. 
R에는 파이썬 `pop`, `remove`, `del`에 해당하는 직접적인 함수가 없으며, 대신 리스트의 특정 요소를 제외한 새로운 리스트를 생성한다. 
요소를 추가하기 위해서 `append` 함수를 사용하거나, `c()` 함수로 리스트 또는 벡터에 요소를 추가한다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-append-debug
t <- list(1, 2, 3, 4)
t <- t[-2]  # 두 번째 요소 제거
t <- append(t, 5) # 요소 추가

# append(t, list(x)) # 신규 x 리스트 t에 추가 안됨
t <- append(t, list(x)) 
# t + list(x) # 신규 x 리스트 t에 추가 안됨
t <- c(t, list(x))
```

### 파이썬

```{pyodide-python}
#| label: py-list-append-debug
t = [4,2,3]
x = 1
t.append(x)
t = t + [x]

t.append([x])     # 틀림(WRONG)!
t = t.append(x)   # 틀림(WRONG)!
t + [x]           # 틀림(WRONG)!
t = t + x         # 틀림(WRONG)!
```

:::


2.  **에일리어싱을 회피하기 위해 사본 만들기.**
\index{에일리어싱!회피하기 위한 복사}
\index{복사!에일리어싱 회피하기}

R에서 리스트나 벡터를 정렬하면서 원본 데이터를 보존하고 싶은 경우, 
정렬 함수가 원본 객체를 변경하지 않고 새로운 객체를 반환하기 때문에 별도의 사본을 만들 필요가 없다. 
하지만, 데이터 분석에서처럼 원본 데이터를 보존하여 만일의 사태에 대비하는 것이 좋다. 
파이썬에서는 원본 리스트를 유지하면서, 변경을 가하는 `sort`와 같은 메서드를 사용하고자 한다면, 사본을 만들어야 한다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-debug-aliasing
t <- list(3, 1, 5, 2)
orig <- t  # 원본 리스트 복사
t <- sort(unlist(t)) 
```

### 파이썬

```{pyodide-python}
#| label: py-list-debug-aliasing
orig = t[:]
t.sort()
```

:::

상기 예제에서 원 리스트는 그대로 둔 상태로 새로 정렬된 리스트를 반환된 결과는 `t`에 저장한다. 하지만 이 경우에는, 변수명으로 `sorted`를 사용하는 것을 피해야 한다!

3.  **리스트, 분할(split), 파일**

파일을 읽고 파싱할 때, 프로그램이 중단될 수 있는 입력값을 마주할 수많은 기회가 있다. 그래서 파일을 훑어 "건초더미에서 바늘"을 찾는 프로그램을 작성할 때 사용한 가디언 패턴(guardian pattern)을 다시 살펴보는 것은 좋은 생각이다.

파일 라인에서 요일을 찾는 프로그램을 다시 살펴보자.

`From stephen.marquard@uct.ac.za` **Sat** `Jan  5 09:14:16 2008`

각 라인을 단어로 나누었기 때문에, startswith를 사용하지 않고, 
라인에 관심 있는 단어가 있는지 살펴보기 위해서 단순하게 각 라인의 첫 단어를 살펴본다. 
다음과 같이 continue 문을 사용해서 "From"이 없는 라인을 건너뛴다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-email-parsing-ex
download.file("https://www.dr-chuck.com/py4inf/code/mbox-short.txt",
              destfile = "mbox-short.txt")

fhand <- readLines('mbox-short.txt')

for (line in fhand) {
    line <- trimws(line)  # 공백 제거
    if (length(grep("^From ", line)) == 0) {
        next
    }
    words <- unlist(strsplit(line, " "))
    if (length(words) >= 3) {
        print(words[3])
    }
}
```

### 파이썬

```{pyodide-python}
#| label: py-list-email-parsing-ex
fhand = open('mbox-short.txt')

for line in fhand:
    words = line.split()
    if words[0] != 'From': 
        continue
    print(words[2])
```

:::

프로그램이 훨씬 간단하고, 파일 끝에 있는 새줄(newline)을 제거하기 위해 `str_trim()` 함수를 사용할 필요도 없다. 하지만, 더 좋아졌는가?

작동하는 것 같지만, 경우에 따라서 첫 줄에 Sat를 출력하고 나서 오류로 프로그램이 정상 동작에 실패하는 경우도 있다. 
무엇이 잘못되었을까? 어딘가 엉망이 된 데이터가 있어 우아하고, 총명하며, 매우 R스러운 프로그램을 망가뜨린 건가?

오랜 동안 프로그램을 응시하고 머리를 짜내거나, 다른 사람에게 도움을 요청할 수 있지만, 빠르고 현명한 접근법은 `print()` 문을 추가하는 것이다. 
`print()` 문을 넣는 가장 좋은 장소는 프로그램이 동작하지 않는 라인 앞이 적절하고, 프로그램 실패를 야기할 것 같은 데이터를 출력한다.

이 접근법이 많은 라인을 출력하지만, 즉석에서 문제에 대해서 손에 잡히는 단서는 최소한 준다. 
그래서 words를 출력하는 출력문을 5번째 라인 앞에 추가한다. "Debug:"를 접두어로 라인에 추가하여, 정상적인 출력과 디버그 출력을 구분한다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-email-parsing-ex-print
fhand <- readLines('mbox-short.txt')

for (line in fhand) {
    line <- trimws(line)  # 공백 제거
    message("Debug: ", line)
    if(!stringr::str_detect(line, "^From ")) next
    words <- unlist(strsplit(line, " "))
    print(words[3])
}
```

### 파이썬

```{pyodide-python}
#| label: py-list-email-parsing-ex-print
fhand = open('mbox-short.txt')

for line in fhand:
    words = line.split()
    print('Debug:', words)
    if words[0] != 'From':
        continue
    print(words[2])
```

:::

프로그램을 실행할 때, 많은 출력결과가 스크롤되어 화면 위로 지나간다. 
마지막에 디버그 결과물과 역추적(traceback)을 보고 역추적(traceback) 바로 앞에서 무슨 일이 생겼는지 알 수 있다.

::::: {.columns}

::: {.column width="47.5%"}
### R {.unnumbered}
```{bash}
#| eval: false
Debug: 'X-DSPAM-Confidence:', '0.8475'
Debug: 'X-DSPAM-Probability:', '0.0000'
Debug: 
```

:::

::: {.column width="5%"}

:::

::: {.column width="47.5%"}
### 파이썬 {.unnumbered}
```{python}
#| eval: false
Debug: ['X-DSPAM-Confidence:', '0.8475']
Debug: ['X-DSPAM-Probability:', '0.0000']
Debug: []
Traceback (most recent call last):
  File "D:/tcs/gpt-coding/data/mbox_debug.py", line 5, in <module>
    if words[0] != 'From':
IndexError: list index out of range
```

:::
:::::


각 디버그 라인은 리스트 단어를 출력하는데, 라인을 분할 `str_split()` 함수를 활용하여 단어로 만들 때 얻어진다. 프로그램이 실패할 때 리스트 단어는 비었다 ''. 텍스트 편집기로 파일을 열어 살펴보면 그 지점은 다음과 같다.

```{r r-list-debug-file, eval = FALSE}
X-DSPAM-Result: Innocent
X-DSPAM-Processed: Sat Jan 5 09:14:16 2008
X-DSPAM-Confidence: 0.8475
X-DSPAM-Probability: 0.0000

Details: http://source.sakaiproject.org/viewsvn/?view=rev&rev=39772
```

프로그램이 빈 라인을 만났을 때, 오류가 발생한다. 물론, 빈 라인은 '0' 단어 ("zero words")다. 프로그램을 작성할 때, 왜 이것을 생각하지 못했을까? 첫 단어(word[1])가 "From"과 일치하는지 코드가 점검할 때, "인덱스 범위 오류(index out of range)"가 발생한다.

물론, 첫 단어가 없다면 첫 단어 점검을 회피하는 **가디언 코드(guardian code)**를 삽입하기 최적 장소이다. 
코드를 보호하는 방법은 많다. 첫 단어를 살펴보기 전에 단어의 개수를 확인하는 방법을 택한다.

:::{.panel-tabset}
### R

```{webr-r}
#| label: r-list-email-parsing-ex-guardian
fhand <- readLines('mbox-short.txt')

for (line in fhand) {
    line <- trimws(line)  # 공백 제거
    # message("Debug: ", line)
    if(length(words) == 0) next
    if(length(grep("^From ", line)) == 0) next
    
    words <- unlist(strsplit(line, " "))
    print(words[3])
}
```

### 파이썬

```{pyodide-python}
#| label: py-list-email-parsing-ex-guardian
fhand = open('mbox-short.txt')

for line in fhand:
    words = line.split()
    # print('Debug:', words)
    if len(words) == 0 : continue
    if words[0] != 'From':
        continue
    print(words[2])
```

:::

```{r 
```

변경한 코드가 실패해서 다시 디버그할 경우를 대비해서, `print`문을 제거하는 대신에 `print`문을 주석 처리한다. 그리고 나서, 단어가 '0' 인지를 살펴보고 만약 '0' 이면, 파일 다음 라인으로 건너뛰도록 `next`문을 사용하는 가디언 문장(guardian statement)을 추가한다.

두 개의 `next`문이 "흥미롭고" 좀 더 처리가 필요한 라인 집합을 정제하도록 돕는 것으로 생각할 수 있다. 
단어가 없는 라인은 "흥미 없어서" 다음 라인으로 건너뛴다. 첫 단어에 "From"이 없는 라인도 "흥미 없어서" 건너뛴다.

변경된 프로그램이 성공적으로 실행되어서, 아마도 올바르게 작성된 것으로 보인다. 가디언 문장(guardian statement)이 `words[1]`가 정상 작동할 것이라는 것을 확인해 주지만, 
충분하지 않을 수도 있다. 프로그램을 작성할 때, "무엇이 잘못될 수 있을까?"를 항상 생각해야 한다.

**연습문제:** 상기 프로그램의 어느 라인이 여전히 적절하게 보호되지 않은지를 생각해 보세요. 텍스트 파일을 구성해서 프로그램이 실패하도록 만들 수 있는지 살펴보세요. 그리고 나서, 프로그램을 변경해서 라인이 적절하게 보호되게 하고, 새로운 텍스트 파일을 잘 다룰 수 있도록 시험하세요.

**연습문제:** 두 `if` 문 없이, 상기 예제의 가디언 코드(guardian code)를 다시 작성하세요. 대신에 단일 `if`문과 `&` 논리 연산자를 사용하는 복합 논리 표현식을 사용하세요.

## 용어 정의 {#r-list-terminology}

-   **에일리어싱(aliasing)**: 하나 혹은 그 이상의 변수가 동일한 객체를 참조하는 상황.
\index{에일리어싱}
-   **구분자(delimiter)**: 문자열이 어디서 분할되어야 할지를 표기하기 위해서 사용되는 문자나 문자열.
\index{구분자}
-   **요소(element)**: 리스트 혹은 다른 시퀀스 값의 하나로 항목(item)이라고도 한다.
\index{요소}
-   **동등한(equivalent)**: 같은 값을 가짐.
\index{동등한}
-   **인덱스(index)**: 리스트의 요소를 지칭하는 정수 값.
\index{인덱스}  
-   **동일한(identical)**: 동등을 함축하는 같은 객체임.
\index{동일한}
-   **리스트(list)**: 시퀀스 값.
\index{리스트}
-   **리스트 순회(list traversal)**: 리스트의 각 요소를 순차적으로 접근함.
\index{리스트 순회}
-   **중첩 리스트(nested list)**: 또 다른 리스트의 요소인 리스트.
\index{중첩 리스트}
-   **객체(object)**: 변수가 참조할 수 있는 무엇. 객체는 자료형(type)과 값(value)을 가진다.
\index{객체}
-   **참조(reference)**: 변수와 값의 연관.
\index{참조}

## 연습문제 {.unnumbered #r-list-ex}

1.  <http://www.py4inf.com/code/romeo.txt>에서 파일 사본을 다운로드 받는다.
`romeo.txt` 파일을 열어, 한 줄씩 읽어들이는 프로그램을 작성하세요. 각 라인마다 stringr 팩키지에서 분할 `str_split()` 함수를 사용하여 라인을 단어 리스트로 쪼갠다.
\index{로미오와 줄리엣}

각 단어마다, 단어가 이미 리스트에 존재하는지를 확인하세요. 만약 단어가 리스트에 없다면, 리스트에 새 단어로 추가한다.

프로그램이 완료되면, 알파벳 순으로 결과 단어를 정렬하고 출력하세요.

```{r r-list-romeo, eval=FALSE}
Enter file: romeo.txt
[1] 'Arise', 'But', 'It', 'Juliet', 'Who', 'already',
'and', 'breaks', 'east', 'envious', 'fair', 'grief',
'is', 'kill', 'light', 'moon', 'pale', 'sick', 'soft',
'sun', 'the', 'through', 'what', 'window',
'with', 'yonder'
```

2.  전자우편 데이터를 읽어 들이는 프로그램을 작성한다.
"From"으로 시작하는 라인을 발견했을 때, stringr 팩키지에서 분할 `str_split()` 함수를 사용하여 라인을 단어로 쪼갠다.
"From" 라인의 두번째 단어, 누가 메시지를 보냈는지에 관심이 있다.

`From stephen.marquard@uct.ac.za Sat Jan  5 09:14:16 2008`

"From" 라인을 파싱하여 각 "From"라인의 두 번째 단어를 출력한다. 그리고 나서, "From:"이 아닌 "From"라인 갯수를 세고, 끝에 갯수를 출력한다.

여기 몇 줄을 삭제한 출력 예시가 있다.

```{r r-list-fromcount, eval=FALSE}
Rscript fromcount.R
Enter a file name: mbox-short.txt

stephen.marquard@uct.ac.za
louis@media.berkeley.edu
zqian@umich.edu

[...some output removed...]

ray@media.berkeley.edu
cwen@iupui.edu
cwen@iupui.edu
cwen@iupui.edu

There were 27 lines in the file with From as the first word
```

3.  사용자가 숫자 리스트를 입력하고, 입력한 숫자 중에 최대값과 최소값을 출력하고 사용자가 "done"을 입력할 때 종료하는 프로그램을 다시 작성한다. 
사용자가 입력한 숫자를 리스트에 저장하고, `max()` 과 `min()` 함수를 사용하여 루프가 끝나면, 최대값과 최소값을 출력하는 프로그램을 작성한다.

```{r r-list-ex03, eval=FALSE}
Enter a number: 6
Enter a number: 2
Enter a number: 9
Enter a number: 3
Enter a number: 5
Enter a number: done
Maximum: 9.0
Minimum: 2.0
```