
개인적으로 개발을 하는데 DB Schema는 보존하면서 DB에 있는 모든 내용은 지우는 작업을 해야 할 필요가 생겼습니다.
테스트용 Dummy data를 발생시켜야 하는데 중복되는 dummy가 발생되면 안 되기 때문이었죠.
단순히 생각하면 모든 테이블을 지우고 새로 만들어버리면 되지만, 별로 그러고 싶지 않았습니다.
저는 SQLAlchemy와 Alembic의 조합으로 개발중이었는데, 테이블을 지우고 새로 만드는 것을 하려면 다음과 같은 작업을 해야할 필요가 있습니다.

1. metadata에서 `.drop_all()` 하여 모든 테이블을 없앤다
2. Alembic의 내부 버전 관리를 None으로 내린다.
3. Alembic을 통해서 `None`에서부터 head까지 올린다.
4. dummy data를 넣는다.

여기서 3번 과정을 그냥 `.create_all()`하면 모든 과정이 생략되고 최신의 DB가 생성됩니다.
문제는 너무나도 최신의 상태가 되어버려서, Alembic의 head와 일치하지 않는 상태가 되어버립니다.

발생 가능한 상황은 이런 식입니다.

1. alembic의 head까지 이미 upgrade가 완료되있으나 아직 생성되지 않은 revision에 포함되어야 할 정보로 인해 Schema 불일치
2. alembic이 아직 head까지 upgrade가 되있지도 않은데 head, 혹은 그 이상의 정보로 Schema가 생성되서 불일치

하지만 이 문제를 해결하려면 Alembic을 상당히 많이 뜯어봐야할 것 같은 예감이 들었습니다.
단순히 Database 내의 자료를 모두 지우기만 하면 되는 문제인데 너무 멀리 나가는 느낌이 들었습니다.
저는 이미 MySQL에 `truncate table`이라는 편리한 기능이 있음을 알고 있으니 그냥 이걸 쓰고 싶었습니다.

## SQLAlchemy에서 RAW DDL Query 날리기

SQLAlchemy에서는 transaction을 시작하고 명령을 내릴 수 있는 방법이 두 가지 있는데, 하나는 [engine 레벨](http://docs.sqlalchemy.org/en/rel_1_0/core/connections.html#sqlalchemy.engine.Connection.execute)이고 또 하나는 [session 레벨](http://docs.sqlalchemy.org/en/rel_1_0/orm/session_api.html#sqlalchemy.orm.session.Session.execute)입니다.
제가 하려는 것은 Truncate, 즉 DDL에 해당하는 Query이므로 engine레벨에서 작업하기로 했습니다.

```py
engine = get_database_engine() # 여러분의 engine을 가져오세요!
with engine.begin() as conn:
    conn.execute('TRUNCATE TABLE users;') # 아직 MySQL만 되요!
```

이런 식으로 하면 DDL을 실행할 수 있습니다.

## 테이블 목록 받아오기

하지만 테이블을 모두 타이핑 해서 적어야 한다면 매우 귀찮은 작업일 것입니다.
이미 SQLAlchemy는 알고 있을테니 내부 변수에서 캐내보기로 했습니다.
MetaData에겐 [sorted_tables](http://docs.sqlalchemy.org/en/rel_1_0/core/metadata.html#sqlalchemy.schema.MetaData.sorted_tables)라는 속성과 [tables](http://docs.sqlalchemy.org/en/rel_1_0/core/metadata.html#sqlalchemy.schema.MetaData.tables)라는 속성이 있습니다.
전자는 이미 foreign key constraint등을 고려하여 정렬된 table 순서입니다.
가장 의존되는 table이 맨 처음 나오게 되어 있습니다.
따라서 sorted_tables를 뒤집어서 접근하면 foreign key constraint를 최소한으로 건드리고도 작업이 가능합니다.

```py
engine = get_database_engine() # 여러분의 engine을 가져오세요!
metadata = Base.metadata # 여러분의 Base를 가져오세요!
with engine.begin() as conn:
    for table in reversed(metadata.sorted_tables):
        conn.execute('TRUNCATE TABLE {};'.format(table.name)) # 아직 MySQL만 되요!
```

하지만, 이렇게 해도 foreign key constraint에서 완전히 해방되진 못합니다.

## Foreign Key Constrant를 잠시 끄기

다행히도 제가 주로 쓰는 3개의 RDBMS는 모두 constraint 문제를 잠시 덮어둘 수 있습니다.

### MySQL[^1]/MariaDB[^2]

```sql
SET FOREIGN_KEY_CHECKS=0;
```

이렇게 하면 외래키 검사를 하지 않습니다.
되돌리는 방법은 0 대신 1을 넣으면 됩니다.
기본적으로 세션 단위입니다.

### PostgreSQL[^3]

```sql
SET CONSTRAINTS ALL DEFERRED;
```

이렇게 하면 현 transaction에서 모든 검사를 하지 않습니다.

### SQLite[^4]

```sql
PRAGMA foreign_keys = OFF;
```

이렇게 하면 각 connection마다 검사를 하지 않습니다.
주의할 점은, sqlite는 기본값이 OFF입니다.

## Truncate table

DBMS별로 constraint 종료법이 이정도로 다른 것으로 볼 때, truncate 또한 다를 것이 명백합니다.

### MySQL[^5]/MariaDB[^6]

```sql
TRUNCATE TABLE tb_name;
```

### PostgreSQL[^7]

기본적으로 MySQL과 용법이 같습니다만 옵션을 더 줄 수 있습니다.

```sql
TRUNCATE TABLE tb_name RESTART IDENTITY CASCADE;
```

`RESTART IDENTITY`로 인해 sequence의 번호가 처음부터 시작됩니다.
`CASCADE`로 인해 foreign key에 걸려도 무시합니다.

### SQLite[^8]

사실 가상 기상천외한 동작방식은 SQLite로부터 찾을 수 있는데, 다른 DDL이 필요 없습니다.

```sql
DELETE FROM tb_name;
```

SQLite는 `WHERE`절을 생략하면 자동으로 truncate에 최적화된 동작을 수행한다고 합니다.

## 조합하기

조합해보면 다음과 같습니다.

일단 모든 경우를 if문으로 표기해봤습니다.

```py
engine = get_database_engine() # 여러분의 engine을 가져오세요!
metadata = Base.metadata # 여러분의 Base를 가져오세요!
engine_name = engine.name
with engine.begin() as conn:
    if engine_name == 'mysql':
        conn.execute('SET FOREIGN_KEY_CHECKS=0;')
    elif engine_name == 'postgresql':
        conn.execute('SET CONSTRAINTS ALL DEFERRED;')
    elif engine_name == 'sqlite':
        conn.execute('PRAGMA foreign_keys = OFF;')

    for table in reversed(metadata.sorted_tables):
        if engine_name == 'mysql':
            conn.execute('TRUNCATE TABLE {};'.format(table.name))
        elif engine_name == 'postgresql':
            conn.execute('TRUNCATE TABLE {} RESTART IDENTITY CASCADE;'.format(table.name))
        elif engine_name == 'sqlite':
            conn.execute('DELETE FROM {};'.format(table.name))

    if engine_name == 'mysql':
        conn.execute('SET FOREIGN_KEY_CHECKS=1;')
    elif engine_name == 'postgresql':
        conn.execute('SET CONSTRAINTS ALL IMMEDIATE;')
    elif engine_name == 'sqlite':
        conn.execute('PRAGMA foreign_keys = ON;')
```

하지만 소스가 너무 길어지는 느낌이 있으므로 조금 더 정리해보자면 다음과 같아집니다.

```py
engine = get_database_engine() # 여러분의 engine을 가져오세요!
metadata = Base.metadata # 여러분의 Base를 가져오세요!
engine_name = engine.name
foreign_key_turn_off = {
    'mysql': 'SET FOREIGN_KEY_CHECKS=0;',
    'postgresql': 'SET CONSTRAINTS ALL DEFERRED;',
    'sqlite': 'PRAGMA foreign_keys = OFF;',
}
foreign_key_turn_on = {
    'mysql': 'SET FOREIGN_KEY_CHECKS=1;',
    'postgresql': 'SET CONSTRAINTS ALL IMMEDIATE;',
    'sqlite': 'PRAGMA foreign_keys = ON;',
}
truncate_query = {
    'mysql': 'TRUNCATE TABLE {};',
    'postgresql': 'TRUNCATE TABLE {} RESTART IDENTITY CASCADE;',
    'sqlite': 'DELETE FROM {};',
}

with engine.begin() as conn:
    conn.execute(foreign_key_turn_off[engine.name])

    for table in reversed(metadata.sorted_tables):
        conn.execute(truncate_query[engine.name].format(table.name))

    conn.execute(foreign_key_turn_on[engine.name])
```

[^1]: http://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html#sysvar_foreign_key_checks
[^2]: https://mariadb.com/kb/en/mariadb/server-system-variables/#foreign_key_checks
[^3]: http://www.postgresql.org/docs/9.5/static/sql-set-constraints.html
[^4]: https://www.sqlite.org/pragma.html#pragma_foreign_keys
[^5]: https://dev.mysql.com/doc/refman/5.7/en/truncate-table.html
[^6]: https://mariadb.com/kb/en/mariadb/truncate-table/
[^7]: http://www.postgresql.org/docs/current/static/sql-truncate.html
[^8]: https://www.sqlite.org/lang_delete.html


SQLAlchemy에서 모든 테이블의 모든 자료 지우기


**프로그래머는 코드를 코드로 테스트해야합니다.**

이 말을 하면 두 가지 반응이 있을 수 있습니다.

1. 어떻게? 왜? 테스트는 테스터가 하는거 아냐?
2. 너무 당연한거 아닌가?

이 글은 1번으로 생각하는 분들을 위해 쓰여집니다.

※ 이 글은 이모콘2016SS의 [Test first!](https://github.com/ahastudio/til/blob/master/blog/2016/03-18.md) 세션의 내용에 영감을 받았습니다.

## 명세 문서와 개발품

우리는 개발 착수 전에 무엇을 개발할 것인지 명세를 꾸립니다.
DB Model도 정해야하고, API도 정해야 하죠.
하지만 개발은 우리가 원하는 대로 흘러가는 경우가 많지 않습니다.
보통 바뀐 사항은 코드에 먼저 반영이 되고 문서에는 없다던가 하는 상황이 벌어지죠.

이런 상황에서, 특정 반응 A에 대해 테스터가 판단할 수 있는 기준은 무엇일까요?
갱신되지 않은 명세 문서를 봐야할까요?
테스트를 할 수 없게 됩니다.

## 명세 문서를 코드로 만들면 어떨까

이러므로 명세 문서를 코드로 만들고, 실제 구현과 비교검증해보면 어떨까요?

심플한 예를 들어봅시다.
Python으로 곱하기를 해주는 함수를 하나 만든다고 해보죠.
우리는 이미 `*` 연산자가 있음은 알고 있지만 이건 쓰지 않고 구현한다고 해보죠.

### 일단 명세를 만들어봅시다.

```py
import unittest  # Python에서 테스트를 할 때 쓸 수 있는 기본 내장 모듈입니다.


class MulTest(unittest.TestCase):  # unittest 대상입니다.
    def test_simple(self):
        self.assertEqual(6, mul(2, 3))  # mul(2, 3)을 실행하면 6이 나와야 한다는 의미

if __name__ == '__main__':
    unittest.main()
```

당연히 `mul`을 정의하지 않았으니 에러가 날 것입니다.
한번 실행해볼까요?

```py
E
======================================================================
ERROR: test_simple (__main__.MulTest)
-----------------------------------------------------------------------
Traceback (most recent call last):
  File "t.py", line 6, in test_simple
    self.assertEqual(6, mul(2, 3))  # mul(2, 3)을 실행하면 6이 나와야 한다는 의미
NameError: name 'mul' is not defined

-----------------------------------------------------------------------
Ran 1 test in 0.000s

FAILED (errors=1)
```

정말 예상한대로 에러가 나왔습니다.

### 구현을 해봅시다

이제 구현을 해볼 생각입니다.
일단 우리는 명세에 2와 3을 넣으면 6이 나오면 된다고 했으니 그냥 6을 뱉어줘보죠.

```py
import unittest


def mul(a, b):
    return 6  # 우린 이게 비정상적이란 것을 이미 알고 있습니다만, 어디까지나 예시입니다.


class MulTest(unittest.TestCase):
    def test_simple(self):
        self.assertEqual(6, mul(2, 3))

if __name__ == '__main__':
    unittest.main()
```

한번 실행해봅시다.

```py
.
-----------------------------------------------------------------------
Ran 1 test in 0.000s

OK
```

어머, 괜찮다고 합니다.
그럼 우리 할 일은 끝난걸까요?

### 보다 정밀한 테스트를 위해

하지만 명세를 만들어놓고 보니 `mul`의 인자로 `2, 3` 외의 다른 것도 올 수 있을 것 같습니다.
예시를 좀 더 늘려보기로 합니다.

```py
import unittest


def mul(a, b):
    return 6


class MulTest(unittest.TestCase):
    def test_simple(self):
        self.assertEqual(6, mul(2, 3))
        self.assertEqual(6, mul(3, 2))
        self.assertEqual(4, mul(1, 4))
        self.assertEqual(20, mul(4, 5))
        self.assertEqual(0, mul(10, 0))

if __name__ == '__main__':
    unittest.main()
```

```py
F
======================================================================
FAIL: test_simple (__main__.MulTest)
-----------------------------------------------------------------------
Traceback (most recent call last):
  File "t.py", line 12, in test_simple
    self.assertEqual(4, mul(1, 4))
AssertionError: 4 != 6

-----------------------------------------------------------------------
Ran 1 test in 0.000s

FAILED (failures=1)
```

에러가 납니다. 1과 4의 곱은 4인데 우리 함수는 6만 반환하고 있으니까 어쩔 수 없죠.

### 구현을 옳게

이번엔 구현이 정상적이게 만들어볼 차례입니다.

```py
import unittest


def mul(a, b):
    result = 0  # 초기값은 0이라고 치고
    for x in range(b):  # b번 반복해서
        result +=  a  # 결과값에 더해주고
    return result  # 리턴합시다


class MulTest(unittest.TestCase):
    def test_simple(self):
        self.assertEqual(6, mul(2, 3))
        self.assertEqual(6, mul(3, 2))
        self.assertEqual(4, mul(1, 4))
        self.assertEqual(20, mul(4, 5))
        self.assertEqual(0, mul(10, 0))

if __name__ == '__main__':
    unittest.main()
```

테스트 해봅시다.

```py
.
-----------------------------------------------------------------------
Ran 1 test in 0.000s

OK
```

잘 된다고 합니다.

## 이런 코드를 짜서 무슨 득이 있지?

만약에 외부 요청에 따라 `mul` 함수의 구현을 바꾸게 되었다고 칩시다.
그런데 mul 함수가 한두곳에 쓰인 것이 아니라면 변경점마다 모두 테스트를 해야하죠.
이때, mul 함수의 테스트가 빛을 발합니다.

```py
import unittest


def mul(a, b):
    return sum(a for x in range(b))  # 문법이 복잡해졌어요!


class MulTest(unittest.TestCase):
    def test_simple(self):
        self.assertEqual(6, mul(2, 3))
        self.assertEqual(6, mul(3, 2))
        self.assertEqual(4, mul(1, 4))
        self.assertEqual(20, mul(4, 5))
        self.assertEqual(0, mul(10, 0))

if __name__ == '__main__':
    unittest.main()
```

역시 테스트를 돌려봅니다.

```py
.
-----------------------------------------------------------------------
Ran 1 test in 0.000s

OK
```

구현을 바꿨음에도 잘 동작함이 검증되었습니다.

## 아직 감이 잘 안와요

조금 더 실용적인 예시를 들어볼까 합니다.
주어진 GitHub 사용자 이름이 있을 때, 해당 사용자의 email 주소를 얻어오는 소스를 만들어봅시다.

### 또다시 막장 코드

```py
import unitest


def get_email(username):
    return 'armin.ronacher@active-4.com'


class GetEmailTest(unittest.TestCase):
    def test_simple(self):
        self.assertEqual('armin.ronacher@active-4.com', get_email('mitsuhiko'))

if __name__ == '__main__':
    unittest.main()
```

일단 지금 상태에선 잘 동작할 것입니다.
하지만 다른 이름을 넣으면 바로 깨지겠죠.

```py
import unitest


def get_email(username):
    return 'armin.ronacher@active-4.com'


class GetEmailTest(unittest.TestCase):
    def test_simple(self):
        self.assertEqual('armin.ronacher@active-4.com', get_email('mitsuhiko'))
        self.assertEqual('neosoyn@gmail.com', get_email('camsong'))  # 여기서 에러!

if __name__ == '__main__':
    unittest.main()
```

### 구현

우리는 이 문제를 해결하기 위해 GitHub API를 사용하기로 합니다.
실제로 실행해보실 분은 의존성 설치를 위해 `pip install requests`를 실행해주세요.

```py
import json  # JSON을 처리하기 위해서 불러왔어요
import unittest

import requests  # 보다 쉽게 외부 자료를 가져오기 위한 의존성입니다.


def get_email(username):
    data = requests.get('https://api.github.com/users/' + username).text
    user = json.loads(data)
    return user['email']


class GetEmailTest(unittest.TestCase):
    def test_simple(self):
        self.assertEqual('armin.ronacher@active-4.com', get_email('mitsuhiko'))
        self.assertEqual('neosoyn@gmail.com', get_email('camsong'))

if __name__ == '__main__':
    unittest.main()
```

테스트를 돌려보니 잘 됩니다.

```py
.
-----------------------------------------------------------------------
Ran 1 test in 2.123s

OK
```

### 사실 완전한 구현이 아니었다

사실 이 구현엔 헛점이 있습니다.
바로 존재하지 않는 사용자를 맞닥드렸을 경우입니다.

```py
import json
import unittest

import requests


def get_email(username):
    data = requests.get('https://api.github.com/users/' + username).text
    user = json.loads(data)
    return user['email']


class GetEmailTest(unittest.TestCase):
    def test_simple(self):
        self.assertEqual('armin.ronacher@active-4.com', get_email('mitsuhiko'))
        self.assertEqual('neosoyn@gmail.com', get_email('camsong'))
        self.assertEqual('alphago@sky.net', get_email('alphago_will_destroy_the_world'))  # 이런 사용자는 없어요!

if __name__ == '__main__':
    unittest.main()
```

실행해보면 당연히 에러가 납니다.

```py
E
======================================================================
ERROR: test_simple (__main__.GetEmailTest)
-----------------------------------------------------------------------
Traceback (most recent call last):
  File "t.py", line 17, in test_simple
    self.assertEqual('alphago@sky.net', get_email('alphago_will_destroy_the_world'))  # 이런 사용자는 없어요!
  File "t.py", line 10, in get_email
    return user['email']
KeyError: 'email'

-----------------------------------------------------------------------
Ran 1 test in 3.001s

FAILED (errors=1)
```

### 구현 변경

이런 추가적인 경우를 맞이하여 이전에 없던 경우에 대한 새로운 정의를 만들기로 합니다.
존재하지 않는 사용자를 넣으면 `RuntimeError`가 발생하도록 만들어봅시다.

```py
import json
import unittest

import requests


def get_email(username):
    response = requests.get('https://api.github.com/users/' + username)
    if response.status_code != 200:
        raise RuntimeError()
    user = json.loads(response.text)
    return user['email']


class GetEmailTest(unittest.TestCase):
    def test_simple(self):
        self.assertEqual('armin.ronacher@active-4.com', get_email('mitsuhiko'))
        self.assertEqual('neosoyn@gmail.com', get_email('camsong'))
        with self.assertRaises(RuntimeError):  # Exception 발생 여부를 검사해요
            get_email('alphago_will_destroy_the_world')

if __name__ == '__main__':
    unittest.main()
```

실행해봅시다.

```py
.
-----------------------------------------------------------------------
Ran 1 test in 2.943s

OK
```

잘 되는 것을 확인했습니다.

### 구현이 바뀌었다면?

하지만 코드리뷰를 해봤는데 소스가 개선이 가능하다고 합니다.
조금 더 고쳐보려고 하는데 과연 안전할까요?
이 역시 테스트를 통해 검증할 수 있습니다.

```py
import unittest

import requests


def get_email(username):
    response = requests.get('https://api.github.com/users/' + username)
    if response.status_code != 200:
        raise RuntimeError()
    user = response.json()  # requests 라이브러리가 자체 지원하는 것을 사용해요
    return user['email']


class GetEmailTest(unittest.TestCase):
    def test_simple(self):
        self.assertEqual('armin.ronacher@active-4.com', get_email('mitsuhiko'))
        self.assertEqual('neosoyn@gmail.com', get_email('camsong'))
        with self.assertRaises(RuntimeError):
            get_email('alphago_will_destroy_the_world')

if __name__ == '__main__':
    unittest.main()
```

실행해봅니다.

```py
.
-----------------------------------------------------------------------
Ran 1 test in 2.918s

OK
```

실험결과 안전한 것으로 밝혀졌습니다.

## 마무리

테스트를 미리 작성해서 개발의 흐름을 정하는 것을 TDD, 테스트 등을 작성해서 프로그램의 명세를 구체화하고 명세대로 구현하는 것을 BDD라고 합니다.[^1]
테스트를 작성하는 것 만으로도 개발 대상이 상당히 명확해지고, 추후 검증에 유리합니다.
보다 나은 개발을 위해 테스트를 작성해보는 것은 어떨까요?

[^1]: 정확한 설명은 아닐 수 있습니다.


Python으로 테스트 코드를 짜는 간단한 사례

테스트 코드랑 코딩하기


※ 알파고가 딥러닝을 쓴 것은 알고 있지만 사람이 아닌 것이 배운다는 측면에서 머신러닝이란 단어로 모두 통일했습니다.

사실 저는 머신러닝, AI, Data Science등의 분야에 대해 저랑은 좀 멀리 있는 일이라고 생각하고 있었습니다.
해당 기술들의 실용성은 인정하지만, "내가 저것을 쓸 일이 있을까?" 하는 생각이었죠.
해당 분야로 진입하기 위해 필요한 수학적 지식등의 요구사항이 너무 어렵게 느껴진 것도 한 몫 한 것 같습니다.

하지만 오늘 알파고와 이세돌의 대결에서, 알파고의 신의 한 수에 경악하는 이세돌 표정을 보고 제 생각이 잘못됬음을 깨달았습니다.

![경악](awe1.jpg)
![경악](awe2.jpg)
![경악](awe3.jpg)

머신러닝은 모든 사람에게 **이미 매우 가까이 와있는** 요소였습니다.
제가 배우고 말고를 떠나서 이미 모든 이의 삶의 영역에 이미 일부분 침범해 있는 것이었죠.

알파고는 전문성이 필요한 부분을 머신러닝으로 극복할 수 있다는 사례를 보여주었습니다.
이 이후의 대국에서 이세돌이 완승을 하더라도 머신러닝은 그마저도 극복할 수 있을 것입니다.
단순히 바둑이라고 생각할 수도 있겠지만, 저는 앞으로의 세계의 판도가 뒤바뀔 것이라는 하나의 신호탄 같은 느낌입니다.

정확한 시기는 모르지만 장기적으로는 프로그래머라는 직종도 AI에게 대체당할 것입니다.
그런 의미에서 머신러닝을 지금 배운다고 제 일자리의 안전정이 보장되는 것은 아니겠지만 저런 것이 가능한 분야에 대한 동경 및 관심이 커진 것은 사실입니다.
그 시점에 실직하는 것은 피할 수 없더라도, 인류사의 전환점이 될 부분을 익혀둘 필요는 있지 않을까 생각하게 되었습니다.

예전에 "나는 리눅스 서버에서 뭘 하는 일은 없을거야"라며 외면했다가 데인 상처가 이번에는 배워야 한다고 말하는 느낌입니다.
머신러닝 또한 언젠가는 일반적인 **흔한** 기술이 되어서 모든 서비스에 필요해지는 때가 있을테니 머신러닝 등의 분야도 더 이상 외면할 수 없게 되었습니다.
지금 보고 있는 웹 말고도 시야를 넓혀야 한다는 생각입니다.
한국에선 엔터테인먼트 요소로 여겨지는 바둑을 보고는 오히려 공부를 더 많이, 더 열심히 해야한다는 생각을 하게 되었습니다.


알파고와 머신러닝에 대한 짧은 생각

알파고와 머신러닝에 대한 생각


가끔씩 개발하다가 프로세스를 죽여버리고 나면 글씨를 써도 안보이고, prompt가 이상한 곳에 나오는 등 오작동을 보곤 합니다.
이제까진 그냥 터미널을 닫고 다시 켰었지만, 매번 그러다보니 짜증나서 해결법을 찾았습니다.

```bash
stty sane
```

이러면 원래대로 돌아옵니다.

문제는 이 9글자를 침착하게(?) 적어야 하는데, 저는 자신이 없어서 이렇게 해버렸습니다.

```bash
alias c='stty sane'
```


터미널 고치기


Python 소스를 줄 단위로 실행하고 즉각적인 반응을 보는데에 있어서 REPL는 상당히 편리한 도구입니다.
하지만 매번 실행할때마다 import를 새로 해야한다던가 하는 부분이 있다면 상당히 귀찮은 문제가 됩니다.
이 문제는 사실 아주 간단하게 해결할 수 있는지라, 간단한 솔루션을 첨부합니다.

## Python 기본

```python
import code

context = dict(some_variable=1234)
code.interact(local=context)
```

![Python 기본](python.png)

## IPython

하지만 IPython을 쓰고 싶다면 어떻게 해야할까요?
역시 간단합니다.

```python
from IPython.terminal.embed import InteractiveShellEmbed

context = dict(some_variable=1234)
shell = InteractiveShellEmbed()
shell(local_ns=context)
```

![IPython](ipython.png)

## bpython

비슷한 방법으로 bpython도 지원할 수 있습니다.

```python
import bpython

context = dict(some_variable=1234)
bpython.embed(locals_=context)
```

![bpython](bpython.png)

## 사용법

위에서 만든 `context`라는 dict에 원하는 내용을 모두 넣으면 됩니다.
가령 `datetime.datetime`을 바로 사용하고 싶다면 이렇게 하면 됩니다.

```python
import datetime

context = dict(datetime=datetime.datetime)
```


Python REPL를 원하는 Context로 열기

item4 dev story

Posts