09-dictionaries.qmd

```{r}
#| include: false

source("_common.R")
```

# 딕셔너리 {#named-list}
\index{딕셔너리}
\index{자료형!딕셔너리}
\index{키}
\index{키-값 페어}
\index{인덱스}
\index{명칭을 갖는 리스트}

## 명칭을 갖는 리스트 {#r-named-list}

**명칭을 갖는 리스트(named list)**는 딕셔너리로 더 잘 알려져 있고, 
**딕셔너리(dictionary)**는 리스트와 유사하지만 좀 더 일반적이다. 
리스트에서 위치(인덱스)가 정수이지만, 딕셔너리에서 인덱스는 임의 자료형(type)이 될 수 있다.

딕셔너리를 인덱스 집합(**키(keys)**라고 부름)에서 값(value) 집합으로 사상(mapping)하는 것으로 생각할 수 있다. 
각각의 키는 값에 대응한다. 키와 값을 연관시키는 것을 **키-값 페어(key-value pair)**라고 부르고, 종종 항목(item)으로도 부른다.

한 예제로, 영어 단어에서 한국어 단어로 매핑되는 사전을 만들 것이다. 키와 값은 모두 문자열이다.

`list` 함수는 항목이 전혀 없는 리스트를 신규로 생성한다. `list`는 내장함수명이기 때문에 변수명으로 사용하는 것을 피해야 한다.

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

```{webr-r}
#| label: r-named-list
eng2kr <- list()
eng2kr
#> list()
```

### 파이썬

```{pyodide-python}
#| label: py-named-list
eng2kr = dict()
print(eng2kr)
#> {}
```

:::

`list()`는 빈 리스트임을 나타낸다. 리스트에 신규 요소를 추가하기 위해서 `list()` 함수 내부에 `'명칭'='값'`과 같이 명칭과 값을 지정한다. 
상기 코드는 키(명칭) `'one'`에서 값 `'하나'`를 매핑하는 항목을 생성한다. 명칭을 갖는 리스트를 다시 출력하면, 키-값 페어(key-value pair)를 볼 수 있다.

다수 키-값을 갖는 명칭을 갖는 리스트를 제작할 경우
순차적으로 작성하고 `list()`로 감싼다.예를 들어, 세개 항목을 가진 
명칭을 갖는 리스트를 생성할 수 있다. `eng2kr`을 출력하면 다음과 같다.

:::{.panel-tabset}

### R

```{webr-r}
#| label: r-named-list-one
eng2kr <- list('one' = '하나')
eng2kr
#> $one
#> [1] "하나"

eng2kr <- list('one' = '하나',
               'two' = '둘',
               'three' = '셋')
eng2kr
#> $one
#> [1] "하나"
#> 
#> $two
#> [1] "둘"
#> 
#> $three
#> [1] "셋"
```

### 파이썬

```{pyodide-python}
#| label: py-named-list-one
eng2kr['one'] = '하나'
print(eng2kr)
#> {'one': '하나'}
eng2kr = {'one': '하나', 'two': '둘', 'three': '셋'}
print(eng2kr)
#> {'one': '하나', 'two': '둘', 'three': '셋'}
```

:::



::: {.callout-warning}
### 파이썬 딕셔너리

파이썬 3.7 버전 이전에는 키-값 페어(key-value pair)의 순서가 같지 않다. 
사실 동일한 사례를 여러분의 컴퓨터에서 입력하면, 다른 결과를 얻게 된다. 
일반적으로, 딕셔너리 항목 순서는 예측 가능하지 않았다. 
파이썬 3.7 버전 이후부터는 딕셔너리 항목 순서가 입력한 순서대로 유지된다. 딕셔너리 요소가 정수 인덱스로 색인되지 않아서 문제되지는 않는다. 
대신에, 키를 사용해서 항상 상응하는 값을 찾을 수 있다. R 네임드 리스트(named list)는 항상 정의한 순서대로 요소를 유지한다. 
리스트에 요소를 추가하면 추가된 순서대로 요소가 유지되며, 이 순서는 변경되지 않는다.
:::


명칭을 갖는 리스트에서 키를 사용해서 상응하는 값을 찾을 수 있다.

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

```{webr-r}
#| label: r-named-list-extraction
eng2kr['one']
#> $one
#> [1] "하나"
```

### 파이썬

```{pyodide-python}
#| label: py-named-list-extraction
print(eng2kr['two'])
#> 둘
```

:::

`'two'` 키는 항상 값 `'둘'`에 상응되어서 명칭을 갖는 리스트 항목 순서는 문제가 되지 않는다. 만약 키가 리스트에 존재하지 않으면, `NULL` 값을 반환한다. 
`length()` 함수를 리스트에 사용하여 키-값 페어(key-value pair) 항목 개수를 파악할 수 있다.
\index{length 함수}
\index{함수!length}

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

```{webr-r}
#| label: r-named-list-out-of-range
eng2kr['four']
#> $<NA>
#> NULL
length(eng2kr)
#> [1] 3
```

### 파이썬

```{pyodide-python}
#| label: py-named-list-out-of-range
print(eng2kr['four'])
#> KeyError: 'four'
print(len(eng2kr))
#> 3
```

:::

`%in%` 연산자는 명칭을 갖는 리스트에 키(Key, 명칭)가 있는지 알려준다. `%in%` 연산자는 각 항목마다 키(명칭)가 있는지 참/거짓으로 알려주기 때문에 
`any()`와 결합해서 사용하게 되면 리스트에 키가 있는지 없는지만 확인할 때 요긴하다.
\index{소속!딕셔너리}
\index{%in% 연산자}
\index{연산자!%in%}

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

```{webr-r}
#| label: r-named-list-true
'one' %in% names(eng2kr)
#> [1] TRUE

'하나' %in% names(eng2kr)
#> [1] FALSE
```

### 파이썬

```{pyodide-python}
#| label: py-named-list-true
'one' in eng2kr
#> True
'uno' in eng2kr
#> False
```

:::

이번에는 리스트에 값이 있는지를 확인해보자. `unlist()` 함수를 사용해서 값을 얻은 후에 `%in%` 연산자를 사용해서 값이 있는지를 확인할 수 있다.

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

```{webr-r}
#| label: r-named-list-value
vals <- unlist(eng2kr)
print(vals)
#> "하나" "둘" "셋"

'하나' %in% vals
#> [1] TRUE
```

### 파이썬

```{pyodide-python}
#| label: py-named-list-value
vals = eng2kr.values()
print(vals)
#> dict_values(['하나', '둘', '셋'])
'하나' in vals
#> True
```

:::

"둘" 값을 갖는 항목이 있는지를 `%in%` 연산자를 사용해서 확인했다.
조금 확장해서 "둘", "셋"이 있는지도 없는지도 쉽게 확인할 수 있다.

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

```{webr-r}
#| label: r-named-list-value-three
vals %in% c("둘", "셋")
#> [1] FALSE  TRUE  TRUE
```

### 파이썬

```{pyodide-python}
#| label: py-named-list-value-three
eng2kr = {'one': '하나', 'two': '둘', 'three': '셋'}
results = [item in ["둘", "셋"] for item in eng2kr.values()]
print(results)
#> [False, True, True]
```

:::



### 연습문제 

`words.txt` 단어를 읽어서 명칭을 갖는 리스트에 키로 저장하는 프로그램을 작성한다.
값이 무엇이든지 상관없다. 리스트에 문자열을 확인하는 가장 빠른 방법으로 명칭을 확인할 경우 
`names()` 함수와 값을 확인할 경우 그냥 `%in%` 연산자와 조합하여 사용할 수 있다.

## 계수기로 리스트 사용하기 {#named-list-wordlist}
\index{계수기}

문자열이 주어진 상태에서, 각 문자가 얼마나 나타나는지를 센다고 가정한다. 몇 가지 방법이 아래에 있다.

1.  26개 변수를 알파벳 문자 각각에 대해 생성한다. 그리고 나서 아마도 연쇄 조건문을 사용하여 문자열을 훑고 해당 계수기(counter)를 하나씩 증가한다.

2.  26개 요소를 가진 리스트를 생성한다. 리스트 안에 인덱스로 숫자를 사용해서 적당한 계수기(counter)를 증가한다.

3.  키(key)로 문자, 계수기(counter)로 해당 값(value)을 갖는 리스트를 생성한다. 처음 문자를 만나면, 딕셔너리에 항목으로 추가한다. 추가한 후에는 기존 항목 값을 증가한다.

상기 3개 옵션은 동일한 연산을 수행하지만, 각각은 다른 방식으로 연산을 구현한다.

**구현(implementation)**은 연산(computation)을 수행하는 방법이다. 어떤 구현 방법이 다른 것보다 낫다. 다음에 명칭을 갖는 리스트로 구현한 코드가 있다.
\index{구현}

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

```{webr-r}
#| label: r-brontosaurus
word <- "brontosaurus"
d <- list()

chars <- strsplit(word, "")[[1]]

for (c in chars) {
  if (is.null(d[[c]])) {
    d[[c]] <- 1
  } else {
    d[[c]] <- d[[c]] + 1
  }
}

print(unlist(d))
#> b r o n t s a u 
#> 1 2 2 1 1 2 1 2 
```

### 파이썬

```{pyodide-python}
#| label: py-brontosaurus
word = 'brontosaurus'
d = dict()

for c in word:
  if c not in d:
    d[c] = 1
  else:
    d[c] = d[c] + 1

print(d)
#> {'b': 1, 'r': 2, 'o': 2, 'n': 1, 't': 1, 's': 2, 'a': 1, 'u': 2}
```

:::

계수기(counter) 혹은 빈도에 대한 통계 용어인 **히스토그램(histogram)**을
효과적으로 산출할 수 있다.
\index{히스토그램}
\index{빈도}
\index{운행법}

`for` 루프는 문자열을 훑는다. 매번 루프를 반복할 때마다 리스트에 문자 `c`가 없다면, 
키 `c`와 초기값 1을 가진 새로운 항목을 생성한다. 
문자 `c`가 이미 리스트에 존재한다면, `d[[c]]`를 증가한다.

파이썬 딕셔너리에는 키와 디폴트(default) 값을 갖는 `get` 메서드가 있다. 딕셔너리에 키가 나타나면, 
`get` 메서드는 해당 값을 반환하고, 해당 값이 없으면 지정한 디폴트 값 `0` 을 반환한다. 
예를 들어, `counts.get('jan', 0)`은 `100`을 반환하고, 
`counts.get('tim', 0)`은 `0`을 반환한다. 
하지만, R에는 이와 같은 기능이 없기 때문에 `get_value()` 함수를 제작하여 구현한다.

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

```{webr-r}
#| label: r-get-default
counts <- list(chuck = 1, annie = 42, jan = 100)

get_value <- function(list, key, default) {
  if (!is.null(list[[key]])) {
    return(list[[key]])
  } else {
    return(default)
  }
}

print(get_value(counts, 'jan', 0))
#> [1] 100
print(get_value(counts, 'tim', 0))
#> [1] 0
```

### 파이썬

```{pyodide-python}
#| label: py-get-default
counts = { 'chuck' : 1 , 'annie' : 42, 'jan': 100}
print(counts.get('jan', 0))
#> 100
print(counts.get('tim', 0))
#> 0
```

:::

히스토그램은 문자 `'a'`, `'b'`는 1회, `'o'`는 2회 등등 나타남을 보여준다. 
R은 태생이 통계를 근간으로 하기 때문에 빈도수를 구하거나 하는 문제를 아주 쉽고 간결하게 작성할 수 있다. 
앞선 `for`, `if` 문을 명칭이 있는 리스트 자료구조를 이용해서 길게 작성했지만, 
`table()` 함수를 사용하면 훨씬 간결하게 동일한 효과를 낼 수 있다. 
파이썬에 `get` 메서드를 사용해서 상기 히스토그램 루프를 좀 더 간결하게 작성할 수 있다. 
`get` 메서드는 딕셔너리에 키가 존재하지 않는 경우를 자동적으로 다루기 때문에, `if`문을 없애 4줄을 1줄로 줄일 수 있다.

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

```{webr-r}
#| label: r-named-list-shorten
word <- 'brontosaurus'
word_split <- strsplit(word, "")[[1]]

table(word_split) %>% 
  unlist()
```

### 파이썬

```{pyodide-python}
#| label: py-named-list-shorten
word = 'brontosaurus'
d = dict()
for c in word:
  d[c] = d.get(c,0) + 1
print(d)
#> {'b': 1, 'r': 2, 'o': 2, 'n': 1, 't': 1, 's': 2, 'a': 1, 'u': 2}
```

:::

시간을 가지고서 잠시 `if` 문과 `in` 연산자를 사용한 루프와 적절한 전처리 과정을 거쳐 자료형을 맞추고 나서 `table()` 함수를 사용한 방식을 비교해 보세요. 
동일한 연산을 수행하지만, 루프를 사용한 방식은 더 많은 코드를 필요로 한다. 
파이썬에서도 계수기(counter) 루프를 단순화하려고 `get` 메서드를 사용하는 것은 파이썬에서 흔히 사용되는 일종의 '숙어(idiom)'다. 
`if` 문과 `in` 연산자를 사용한 루프와 비교하여 `get`메서드를 사용한 루프를 비교해 보면 동일한 연산을 수행하지만, 뒷쪽 구현이 코드도 작고 더 간결하다.

## 리스트와 파일 {#named-list-file}

딕셔너리의 흔한 사용법 중의 하나는 텍스트로 작성된 파일에 단어 빈도를 세는 것이다. 
<http://shakespeare.mit.edu/Tragedy/romeoandjuliet/romeo_juliet.2.2.html> 사이트 덕분에 *로미오와 쥴리엣(Romeo and Juliet)* 텍스트 파일에서 시작한다.
처음 연습으로 구두점이 없는 짧고 간략한 텍스트 버전을 사용한다. 나중에 구두점이 포함된 전체 텍스트로 작업할 것이다.

```bash
But soft what light through yonder window breaks
It is the east and Juliet is the sun
Arise fair sun and kill the envious moon
Who is already sick and pale with grief
```

파일 라인을 읽고, 각 라인을 단어 리스트로 쪼개고, 루프를 돌려 사전을 이용하여 각 단어의 빈도수를 세는 R 프로그램을 작성한다.

두 개의 `for` 루프를 사용한다. 외곽 루프는 파일 라인을 읽고, 내부 루프는 특정 라인의 단어 각각에 대해 반복한다. 
하나의 루프는 *외곽* 루프가 되고, 또 다른 루프는 *내부* 루프가 되어서 **중첩 루프(nested loops)**라고 불리는 패턴 사례다.

외곽 루프가 한번 반복을 할 때마다 내부 루프는 모든 반복을 수행하기 때문에 내부 루프는 "좀 더 빨리" 반복을 수행하고 외곽 루프는 좀 더 천천히 반복을 수행하는 것으로 생각할 수 있다.

두 중첩 루프의 조합이 입력 파일의 모든 라인에 있는 모든 단어의 빈도를 계수(count)하는 것을 보증한다.

중첩루프를 돌려 단어 빈도수를 계산하는 것도 가능하지만 R의 강력한 내장함수를 활용하여 간결하게 다음과 같이 작성할 수도 있다.

```{r read-file-and-count}
romeo_text <- "But soft what light through yonder window breaks It is the east and Juliet is the sun Arise fair sun and kill the envious moon Who is already sick and pale with grief"

romeo_split <- stringr::str_split(romeo_text, " ")[[1]]

romeo_freq <- romeo_split %>% 
  table() %>% 
  unlist()
```

프로그램을 실행하면, 정렬되지 않은 해시 순서로 모든 단어의 빈도수를 출력한다. 
`romeo.txt` 파일은 [www.py4inf.com/code/romeo.txt](www.py4inf.com/code/romeo.txt)에서 다운로드 가능하다. 
다운로드 받은 `romeo.txt` 파일을 로컬 파일에 저장한 후에 파일명을 읽어 실행하는 코드를 작성하여 실행하면 다음과 같은 결과를 확인할 수 있다.

이를 위해서 앞서 작성한 코드를 다음과 같이 사용자 입력을 받아 처리할 수 있도록 `count1.R` 파일에 저장한다.

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

```{webr-r}
#| label: r-script-count1
## romeo_count.R
download.file("https://www.dr-chuck.com/py4inf/code/romeo.txt", 
              destfile = "romeo.txt")

# cat("파일명을 입력하세요: ")
# fname <- readLines(file("stdin"), 1) 

fname <- "romeo.txt"

fhand <- tryCatch({
  romeo_text <- readLines(fname)
}, error = function(e) {
  message("파일을 열 수 없습니다:", fname)
  quit(save = "no", status = 1)
})

romeo_split <- stringr::str_split(romeo_text, " ")

romeo_freq <- romeo_split |> unlist() |> 
  table() |>
  unlist()

romeo_freq

#> already     and   Arise  breaks     But    east envious    fair   grief      is
#>       1       3       1       1       1       1       1       1       1       3
#>      It  Juliet    kill   light    moon    pale    sick    soft     sun     the
#>       1       1       1       1       1       1       1       1       2       3
#> through    what     Who  window    with  yonder
#>       1       1       1       1       1       1
```

### 파이썬

```{pyodide-python}
#| label: python-script-count1
fname = input('파일명을 입력하세요: ')

try:
    fhand = open(fname)
except:
    print('파일을 열 수 없습니다:', fname)
    exit()

counts = dict()
for line in fhand:
    words = line.split()
    for word in words:
        if word not in counts:
            counts[word] = 1
        else:
            counts[word] += 1

print(counts)
#> 파일명을 입력하세요: romeo.txt
#> {'But': 1, 'soft': 1, 'what': 1, 'light': 1, 'through': 1, 'yonder': 1, 'window': 1, 'breaks': 1, 'It': 1, 'is': 3, 'the': 3, 'east': 1, 'and': 3, 'Juliet': 1, 'sun': 2, 'Arise': 1, 'fair': 1, 'kill': 1, 'envious': 1, 'moon': 1, 'Who': 1, 'already': 1, 'sick': 1, 'pale': 1, 'with': 1, 'grief': 1}
```

:::

상기 코드를 쉘에서 Rscript 명령어로 실행하게 되면 `romeo.txt` 파일에 담긴 
단어 빈도수를 계산할 수 있게 된다.

```{bash}
#| eval: false
$ Rscript --vanilla code/romeo_count.R

파일명을 입력하세요? data/romeo.txt
#> already     and   Arise  breaks     But    east envious    fair   grief      is
#>       1       3       1       1       1       1       1       1       1       3
#>      It  Juliet    kill   light    moon    pale    sick    soft     sun     the
#>       1       1       1       1       1       1       1       1       2       3
#> through    what     Who  window    with  yonder
#>       1       1       1       1       1       1
```

가장 높은 빈도 단어와 빈도수를 찾기 위해서 리스트를 훑는 것이 불편하다. 
좀 더 도움이 되는 출력결과를 만들려고 코드를 바꿔보자.

## 반복과 리스트 {#named-list-loop}

`for`문에 순서(sequence)로서 리스트를 사용한다면, 리스트 키를 훑는다. 
루프는 각 키와 해당 값을 출력한다.

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

```{webr-r}
#| label: r-list-loop
counts <- list(chuck = 1, annie = 42, jan = 100)

for (key in names(counts)) {
    message(key, " ", counts[[key]])
}
#> chuck 1
#> annie 42
#> jan 100
```

### 파이썬

```{pyodide-python}
#| label: python-dict-loop
counts = { 'chuck' : 1 , 'annie' : 42, 'jan': 100}

for key in counts:
  print(key, counts[key])
#> chuck 1
#> annie 42
#> jan 100
```

:::

이 패턴을 사용해서 앞서 기술한 다양한 루프 숙어를 구현한다. 
예를 들어, 리스트에서 10보다 큰 값을 가진 항목을 모두 찾고자 한다면, 다음과 같이 코드를 작성한다. 
`for` 루프는 딕셔너리 *키(keys)*를 반복한다. 

그래서, 인덱스 연산자를 사용해서 각 키에 상응하는 *값(value)*을 가져와야 한다. 
출력값에서 10 이상 값만 가진 항목만 볼 수 있다.

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

```{webr-r}
#| label: r-list-loop-if
counts <- list(chuck = 1, annie = 42, jan = 100)

for (key in names(counts)) {
    if (counts[[key]] > 10) {
        cat(key, counts[[key]], "\n")
    }
}

#> annie 42
#> jan 100
```

### 파이썬

```{pyodide-python}
#| label: py-dict-loop-if
counts = { 'chuck' : 1 , 'annie' : 42, 'jan': 100}

for key in counts:
  if counts[key] > 10 :
    print(key, counts[key])

#> annie 42
#> jan 100
```

:::

알파벳 순으로 키를 출력하고자 한다면, 리스트 객체에서 이름을 따로 추출해서 알파벳순서로 정렬한다. 
그리고 이를 리스트 객체에 반영하여 정렬된 명칭이 있는 리스트를 준비한다. 
아래와 같이 정렬된 순서로 키/값 페어(key/value pair)를 출력한다. 
파이썬 `dict_keys` 객체는 `sort()` 메서드가 지원되지 않아서 `list()` 함수를 사용해서 리스트로 변환한 후 정렬한다.

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

```{webr-r}
#| label: r-list-loop-evaluation-sort
counts <- list(chuck = 1, annie = 42, jan = 100)
lst <- sort(names(counts))

for (key in lst) {
    cat(key, counts[key], "\n")
}

#> annie 42
#> chuck 1
#> jan 100
```

### 파이썬

```{pyodide-python}
#| label: py-list-loop-evaluation-sort
counts = {'chuck': 1, 'annie': 42, 'jan': 100}

lst = list(counts.keys()) 
lst.sort()

for key in lst:
    print(key, counts[key])

#> annie 42
#> chuck 1
#> jan 100
```

:::

첫 명칭이 있는 리스트는 정렬되지 않은 키 리스트였다면, 
`for` 루프로 정렬된 키/값 페어(key/value pair)를 확인할 수 있다.

## 고급 텍스트 파싱{#named-list-advanced}
\index{로미오와 쥴리엣}

`romeo.txt` 파일을 사용한 상기 예제에서, 수작업으로 모든 구두점을
제거해서 가능한 단순하게 만들었다. 실제 텍스트는 아래 보여지는 것처럼
많은 구두점이 있다.

```bash
But, soft! what light through yonder window breaks?
It is the east, and Juliet is the sun.
Arise, fair sun, and kill the envious moon,
Who is already sick and pale with grief,
```

R `stringr` 패키지 `str_split()` 함수는 공백을 찾고 공백으로 구분되는 토큰으로 단어를 처리하기 때문에, 
"soft!" 와 "soft"는 다른 단어로 처리되고 각 단어에 대해서 별도 딕셔너리 항목을 생성한다.

파일에 대문자가 있어서, "who"와 "Who"를 다른 단어, 다른 빈도수를 가진 것으로 처리한다.

`stringr` 패키지 `str_to_lower`, `str_squish`, `str_replace_all`, 문자열 함수를 사용해서 상기 문제를 해결할 수 있다. 
`str_replace_all` 함수가 가장 적합하다. `str_replace_all` 함수에 대한 문서는 다음과 같다.

```{r}
#| eval: false
str_replace_all(string, pattern, replacement)
```

`pattern` 매개변수를 사용해서 모든 구두점을 삭제할 수 있다.
"구두점"으로 간주되는 문자 리스트는 `[[:punct:]]`에 정의되어 있어
별도 `~!@#$%^&*(){}_+:\"<>?,./;'[]-=`와 같이 지정하지 않아도 된다.
`replacement`에는 삭제 혹은 교체 문자를 지정하면 된다.

프로그램을 다음과 같이 수정한다.

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

```{webr-r}
#| label: r-romeo-advanced-parsing
# romeo_parsing.R --------------
library(stringr)

cat("파일명을 입력하세요: ")
fname <- readLines(con = "stdin", n = 1)

fhand <- tryCatch({
  romeo_text <- readLines(fname)
}, error = function(e) {
  message("파일을 열 수 없습니다:", fname)
  quit(save = "no", status = 1)
})


romeo_split <- str_split(romeo_text, " ") |> 
  unlist() |> 
  str_to_lower() |> 
  str_replace_all(pattern = "[[:punct:]]",
                  replacement = "")

romeo_freq <- romeo_split |> unlist() |>
  table() |>
  unlist()

romeo_freq
```

### 파이썬

```{pyodide-python}
#| label: py-romeo-advanced-parsing
import string

fname = input('파일명을 입력하세요: ')

try:
    fhand = open(fname)
except:
    print('파일을 열 수 없습니다:', fname)
    exit()

counts = dict()
for line in fhand:
    line = line.translate(str.maketrans('', '', string.punctuation))
    line = line.lower()
    words = line.split()
    for word in words:
        if word not in counts:
            counts[word] = 1
        else:
            counts[word] += 1

print(counts)

```

:::

`str_replace_all` 함수를 사용해서 모든 구두점을 제거했고, 
`str_to_lower` 함수를 사용해서 라인을 소문자로 수정했다. 
나머지 프로그램은 변경된 것이 없다.

상기 프로그램을 실행한 출력결과는 다음과 같다.

```{r}
#| eval: false
#| label: named-list-advanced-output
$ Rscript.exe code/romeo_parsing.R

파일명을 입력하세요? romeo.txt
#> already     and   Arise  breaks     But    east envious    fair   grief      is
#>       1       3       1       1       1       1       1       1       1       3
#>      It  Juliet    kill   light    moon    pale    sick    soft     sun     the
#>       1       1       1       1       1       1       1       1       2       3
#> through    what     Who  window    with  yonder
#>       1       1       1       1       1       1
```

출력결과는 여전히 다루기 힘들어 보인다. 
R 프로그래밍을 통해 정확히 찾고자 하는 것을 찾았으나 R **튜플(tuples)**(다양한 자료형을 갖는 리스트)에 대해서 학습할 필요성을 느끼게 한다. 

## 디버깅 {#r-dicionaries-debugging}
\index{디버깅}

점점 더 큰 데이터로 작업함에 따라, 
수작업으로 데이터를 확인하거나 출력을 통해서 디버깅을 하는 것이 어려울 수 있다. 
큰 데이터를 디버깅하는 몇 가지 방법은 다음과 같다.

1. **입력값을 줄여라: Scale down the input**

    가능하면, 데이터 크기를 줄여라. 
    예를 들어, 프로그램이 텍스트 파일을 읽는다면, 첫 10줄로 시작하거나, 찾을 수 있는 작은 예제로 시작하라. 
     데이터 파일을 편집하거나, 프로그램을 수정해서 첫 `n` 라인만 읽도록 프로그램을 변경하라.

    오류가 있다면, `n`을 줄여서 오류를 재현하는 가장 작은 값으로 만들어라. 
    그리고 나서, 오류를 찾고 수정해 나감에 따라 점진적으로 늘려나가라.

2. **요약값과 자료형을 확인하라: Check summaries and types**

    전체 데이터를 출력하고 검증하는 대신에 데이터를 요약하여 출력하는 것을 생각하라. 
    예를 들어, 딕셔너리 항목의 숫자 혹은 리스트 숫자의 총계

    실행 오류(runtime errors)의 일반적인 원인은 올바른 자료형(right type)이 아니기 때문이다. 
    이런 종류의 오류를 디버깅하기 위해서, 종종 값의 자료형을 출력하는 것으로 충분하다.

3. **자가 진단 작성: Write self-checks**

    종종 오류를 자동적으로 검출하는 코드를 작성한다. 
    예를 들어, 리스트 숫자의 평균을 계산한다면, 결과값은 리스트의 가장 큰 값보다 클 수 없고, 가장 작은 값보다 작을 수 없다는 것을 확인할 수 있다. 
    "완전히 비상식적인" 결과를 탐지하기 때문에 "건전성 검사(sanity check)"라고 부른다.

    또 다른 검사법은 두 가지 다른 연산의 결과를 비교해서 일치하는지 살펴보는 것이다. "일치성 검사(consistency check)"라고 부른다.
\index{건전성 검사}
\index{일치성 검사}

4. **고급 출력: Pretty print the output**

   디버깅 출력결과를 서식화하는 것은 오류 발견을 용이하게 한다.

다시 한번 강조하면, 발판(scaffolding)을 만드는데 들인 시간이 디버깅에 소비되는 시간을 줄일 수 있다.
\index{발판}

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

- **명칭있는 리스트/딕셔너리(dictionary)**: 키(key)에서 해당 값으로 매핑(mapping)
\index{딕셔너리}
\index{명칭있는 리스트}
- **해시테이블(hashtable)**: 파이썬 딕셔너리를 구현하기 위해 사용된 알고리즘
\index{해시테이블}
- **해시 함수(hash function)**: 키에 대한 위치를 계산하기 위해서 해시테이블에서 사용되는 함수
\index{해시 함수}
- **히스토그램(histogram)**: 계수기(counter) 집합.
\index{히스토그램}  
- **구현(implementation)**: 연산(computation)을 수행하는 방법
\index{구현}
- **항목(item)**: 키-값 페어(key-value pair)에 대한 또 다른 이름.
\index{항목}
- **키(key)**: 키-값 페어(key-value pair)의 첫 번째 부분으로 딕셔너리에 나타나는 객체.
\index{키}
- **키-값 페어(key-value pair)**: 키에서 값으로 매핑 표현.
\index{키-값 페어}
- **룩업(lookup)**: 키를 가지고 해당 값을 찾는 딕셔너리 연산.
\index{룩업}
- **중첩 루프(nested loops)**: 루프 "내부"에 하나 혹은 그 이상의 루프가 있음. 외곽 루프가 1회 실행될 때, 내부 루프는 전체 반복을 완료함.
\index{중첩 루프}
- **값(value)**:키-값 페어(key-value pair)의 두 번째 부분으로 딕셔너리에 나타나는 객체. 앞에서 사용한 단어 "값(value)"보다 더 구체적이다.
\index{값}

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

1. 커밋(commit)이 무슨 요일에 수행되었는지에 따라 전자우편 메시지를 구분하는 프로그램을 작성하세요. 
"From"으로 시작하는 라인을 찾고, 3번째 단어를 찾아서 요일별 횟수를 계수(count)하여 저장하세요. 
프로그램 끝에 딕셔너리 내용을 출력하세요. (순서는 문제가 되지 않습니다.)

```bash
라인 예시:
From stephen.marquard@uct.ac.za Sat Jan  5 09:14:16 2008

실행 예시:
Rscript --vanilla dow.R
파일명을 입력하세요: mbox-short.txt
{'Fri': 20, 'Thu': 6, 'Sat': 1}
```    

2. 전자우편 로그(log)를 읽고, 히스토그램을 생성하는 프로그램을 작성하세요.
딕셔너리를 사용해서 전자우편 주소별로 얼마나 많은 전자우편이 왔는지를 계수(count)하고 딕셔너리를 출력합니다.

```bash
파일명을 입력하세요: mbox-short.txt
{'gopal.ramasammycook@gmail.com': 1, 'louis@media.berkeley.edu': 3, 
'cwen@iupui.edu': 5, 'antranig@caret.cam.ac.uk': 1, 
'rjlowe@iupui.edu': 2, 'gsilver@umich.edu': 3, 
'david.horwitz@uct.ac.za': 4, 'wagnermr@iupui.edu': 1, 
'zqian@umich.edu': 4, 'stephen.marquard@uct.ac.za': 2, 
'ray@media.berkeley.edu': 1}
```    

4. 상기 프로그램에 누가 가장 많은 전자우편 메시지를 가졌는지 알아내는 코드를 추가한다.

결국, 모든 데이터를 읽고, 딕셔너리를 생성한다. 
최대 루프를 사용해서 딕셔너리를 훑어서 누가 가장 많은 전자우편 메시지를 갖는지, 
그리고 그 사람이 얼마나 많은 메시지를 갖는지 출력한다.

```bash
파일명을 입력하세요: mbox-short.txt
cwen@iupui.edu 5

파일명을 입력하세요: mbox.txt
zqian@umich.edu 195
```

5. 다음 프로그램은 주소 대신에 도메인 이름을 기록한다. 
누가 메일을 보냈는지 대신(즉, 전체 전자우편 주소) 메시지가 어디에서부터 왔는지 출처를 기록한다. 
프로그램 마지막에 딕셔너리 내용을 출력한다.

```bash
Rscript --vanilla schoolcount.R
파일명을 입력하세요: mbox-short.txt
{'media.berkeley.edu': 4, 'uct.ac.za': 6, 'umich.edu': 7, 
'gmail.com': 1, 'caret.cam.ac.uk': 1, 'iupui.edu': 8}
```