Downloaded 1,886 times
![g1 = gevent.spawn(requests.get, url1)
g2 = gevent.spawn(requests.get, url2)
g3 = gevent.spawn(requests.get, url3)
gevent.joinall([g1, g2, g3])
print([g.value for g in [g1, g2, g3]])
코루틴을 직접 다루는 건
굉장히 까다로워요.](https://image.slidesharecdn.com/random-161024155628/85/slide-136-320.jpg)
![g1 = gevent.spawn(requests.get, url1)
g2 = gevent.spawn(requests.get, url2)
g3 = gevent.spawn(requests.get, url3)
gevent.joinall([g1, g2, g3])
print([g.value for g in [g1, g2, g3]])
gevent는 다루기 까다로운
greenlet 코루틴을](https://image.slidesharecdn.com/random-161024155628/85/slide-137-320.jpg)
![g1 = gevent.spawn(requests.get, url1)
g2 = gevent.spawn(requests.get, url2)
g3 = gevent.spawn(requests.get, url3)
gevent.joinall([g1, g2, g3])
print([g.value for g in [g1, g2, g3]])
평범한 멀티스레딩 코드처럼
쓸 수 있게 해주죠.](https://image.slidesharecdn.com/random-161024155628/85/slide-138-320.jpg)
![g1 = gevent.spawn(requests.get, url1)
g2 = gevent.spawn(requests.get, url2)
g3 = gevent.spawn(requests.get, url3)
gevent.joinall([g1, g2, g3])
print([g.value for g in [g1, g2, g3]])
특정한 일을 하는
스레드를 띄우고](https://image.slidesharecdn.com/random-161024155628/85/slide-139-320.jpg)
![g1 = gevent.spawn(requests.get, url1)
g2 = gevent.spawn(requests.get, url2)
g3 = gevent.spawn(requests.get, url3)
gevent.joinall([g1, g2, g3])
print([g.value for g in [g1, g2, g3]])
다른 스레드가 일을 다 할 때까지 기다려서
동기화 하는 식이에요.](https://image.slidesharecdn.com/random-161024155628/85/slide-140-320.jpg)
![g1 = gevent.spawn(requests.get, url1)
g2 = gevent.spawn(requests.get, url2)
g3 = gevent.spawn(requests.get, url3)
gevent.joinall([g1, g2, g3])
print([g.value for g in [g1, g2, g3]])
평범하죠?](https://image.slidesharecdn.com/random-161024155628/85/slide-141-320.jpg)
![if key in GLOBAL_DICT:
gevent.sleep(0.001)
del GLOBAL_DICT[key]
쓰는 법이 멀티스레딩과 다르지 않다 보니
코딩할 때 고달플 때도 있어요.](https://image.slidesharecdn.com/random-161024155628/85/slide-148-320.jpg)
![if key in GLOBAL_DICT:
gevent.sleep(0.001)
del GLOBAL_DICT[key]
이렇게 첫 줄에서
아무리 조건을 확보해 놔도](https://image.slidesharecdn.com/random-161024155628/85/slide-149-320.jpg)
![if key in GLOBAL_DICT:
gevent.sleep(0.001)
del GLOBAL_DICT[key]
스레드 봉쇄가 발생한 이후에는](https://image.slidesharecdn.com/random-161024155628/85/slide-150-320.jpg)
![if key in GLOBAL_DICT:
gevent.sleep(0.001)
del GLOBAL_DICT[key] KeyError!
조건이 무효해질 수 있거든요.](https://image.slidesharecdn.com/random-161024155628/85/slide-151-320.jpg)
![if key in GLOBAL_DICT:
gevent.sleep(0.001)
del GLOBAL_DICT[key] KeyError!
그럼에도 저희가
gevent를 택했던 이유는](https://image.slidesharecdn.com/random-161024155628/85/slide-152-320.jpg)
![@asyncio.coroutine
def main():
f1 = aiohttp.get(url1)
f2 = aiohttp.get(url2)
f3 = aiohttp.get(url3)
for fut in [f1, f2, f3]:
yield from fut
print([fut.result() for fut in [f1, f2, f3]])
파이썬의 언어 기능인 제너레이터를 이용해서
명시적인 코루틴을 구현하고 있어요.](https://image.slidesharecdn.com/random-161024155628/85/slide-178-320.jpg)
![@asyncio.coroutine
def main():
f1 = aiohttp.get(url1)
f2 = aiohttp.get(url2)
f3 = aiohttp.get(url3)
for fut in [f1, f2, f3]:
yield from fut
print([fut.result() for fut in [f1, f2, f3]])
gevent와 다르게 코드만 봐도
어디서 봉쇄가 발생할지 명확하게 보이죠.](https://image.slidesharecdn.com/random-161024155628/85/slide-179-320.jpg)
![async def main():
f1 = aiohttp.get(url1)
f2 = aiohttp.get(url2)
f3 = aiohttp.get(url3)
for fut in [f1, f2, f3]:
await fut
print([fut.result() for fut in [f1, f2, f3]])
파이썬 3.5에서는 아예 C#처럼
async와 await 키워드까지 추가돼서](https://image.slidesharecdn.com/random-161024155628/85/slide-180-320.jpg)
![async def main():
f1 = aiohttp.get(url1)
f2 = aiohttp.get(url2)
f3 = aiohttp.get(url3)
for fut in [f1, f2, f3]:
await fut
print([fut.result() for fut in [f1, f2, f3]])
더 편하게 쓸 수 있게 됐어요.](https://image.slidesharecdn.com/random-161024155628/85/slide-181-320.jpg)
![async def main():
f1 = aiohttp.get(url1)
f2 = aiohttp.get(url2)
f3 = aiohttp.get(url3)
for fut in [f1, f2, f3]:
await fut
print([fut.result() for fut in [f1, f2, f3]])
다만 asyncio를 쓰면](https://image.slidesharecdn.com/random-161024155628/85/slide-182-320.jpg)
![async def main():
f1 = aiohttp.get(url1)
f2 = aiohttp.get(url2)
f3 = aiohttp.get(url3)
for fut in [f1, f2, f3]:
await fut
print([fut.result() for fut in [f1, f2, f3]])
asyncio에 맞춰진 라이브러리만
써야해서 선택의 폭이 좁아지긴 해요.](https://image.slidesharecdn.com/random-161024155628/85/slide-183-320.jpg)
![#include "crow.h"
int main() {
crow::SimpleApp app;
CROW_ROUTE(app, "/")([](){
return "Hello world";
});
}
우리 회사 하재승 님이 만드신](https://image.slidesharecdn.com/random-161024155628/85/slide-201-320.jpg)
![#include "crow.h"
int main() {
crow::SimpleApp app;
CROW_ROUTE(app, "/")([](){
return "Hello world";
});
}
C++ 웹 프레임워크 Crow가
여기서 영감을 얻었다고 합니다.](https://image.slidesharecdn.com/random-161024155628/85/slide-202-320.jpg)
![def wsgi_app(environ, start_response):
headers = [('Content-Type', 'text/plain')]
start_response('200 OK', headers)
yield 'Hello, worldn'
WSGI 애플리케이션은 단순히](https://image.slidesharecdn.com/random-161024155628/85/slide-209-320.jpg)
![def wsgi_app(environ, start_response):
headers = [('Content-Type', 'text/plain')]
start_response('200 OK', headers)
yield 'Hello, worldn'
HTTP 요청정보를 담는 environ 인자와](https://image.slidesharecdn.com/random-161024155628/85/slide-210-320.jpg)
![def wsgi_app(environ, start_response):
headers = [('Content-Type', 'text/plain')]
start_response('200 OK', headers)
yield 'Hello, worldn'
HTTP 응답시작을 개시하는 함수인
start_response 인자를 받아서](https://image.slidesharecdn.com/random-161024155628/85/slide-211-320.jpg)
![def wsgi_app(environ, start_response):
headers = [('Content-Type', 'text/plain')]
start_response('200 OK', headers)
yield 'Hello, worldn'
응답 헤더를 결정한 후
start_response를 불러주고](https://image.slidesharecdn.com/random-161024155628/85/slide-212-320.jpg)
![def wsgi_app(environ, start_response):
headers = [('Content-Type', 'text/plain')]
start_response('200 OK', headers)
yield 'Hello, worldn'
내용을 브러우저로 스트리밍할 수 있게끔
yield하거나](https://image.slidesharecdn.com/random-161024155628/85/slide-213-320.jpg)
![def wsgi_app(environ, start_response):
headers = [('Content-Type', 'text/plain')]
start_response('200 OK', headers)
return ['Hello, worldn']
시퀀스 형태로
바로 return하는 함수예요.](https://image.slidesharecdn.com/random-161024155628/85/slide-214-320.jpg)
![def wsgi_app(environ, start_response):
headers = [('Content-Type', 'text/plain')]
start_response('200 OK', headers)
return ['Hello, worldn']
이 인터페이스에만 맞추면
파이썬의 거의 모든 웹 도구를 같이 쓸 수 있어요.](https://image.slidesharecdn.com/random-161024155628/85/slide-215-320.jpg)
![def wsgi_app(environ, start_response):
headers = [('Content-Type', 'text/plain')]
start_response('200 OK', headers)
return ['Hello, worldn']
하지만 생긴 걸 보면 알 수 있듯이](https://image.slidesharecdn.com/random-161024155628/85/slide-216-320.jpg)
![❯ python cli.py -n "Heungsub Lee"
Hi Heungsub Lee!
❯ python cli.py --help
Usage: cli.py [OPTIONS]
Options:
-n, --name TEXT Your name.
--help Show this message and exit.
돌려보면 이렇게 동작합니다.](https://image.slidesharecdn.com/random-161024155628/85/slide-240-320.jpg)
![❯ python cli.py -n "Heungsub Lee"
Hi Heungsub Lee!
❯ python cli.py --help
Usage: cli.py [OPTIONS]
Options:
-n, --name TEXT Your name.
--help Show this message and exit.
보시다시피 리눅스 CLI를
상식적으로 잘 구현하고 있다는 점에서](https://image.slidesharecdn.com/random-161024155628/85/slide-241-320.jpg)
![❯ python cli.py -n "Heungsub Lee"
Hi Heungsub Lee!
❯ python cli.py --help
Usage: cli.py [OPTIONS]
Options:
-n, --name TEXT Your name.
--help Show this message and exit.
애용하는 프레임워크예요.](https://image.slidesharecdn.com/random-161024155628/85/slide-242-320.jpg)
![❯ python cli.py -n "Heungsub Lee"
Hi Heungsub Lee!
❯ python cli.py --help
Usage: cli.py [OPTIONS]
Options:
-n, --name TEXT Your name.
--help Show this message and exit.
상식과 미묘하게 다르게 동작하는
프레임워크도 여럿 봐왔거든요.](https://image.slidesharecdn.com/random-161024155628/85/slide-243-320.jpg)
![@pytest.mark.parametrize('x, y', [
(42, 1), (21, 2), (7, 6)
])
def test_answers(x, y):
assert x * y == 42
가령 테스트케이스에 매개변수를 선언해놓고
parametrize 데코레이터를 붙여놓으면](https://image.slidesharecdn.com/random-161024155628/85/slide-283-320.jpg)
![@pytest.mark.parametrize('x, y', [
(42, 1), (21, 2), (7, 6)
])
def test_answers(x, y):
assert x * y == 42
알아서 인자를 바꿔가면서 테스트해주고](https://image.slidesharecdn.com/random-161024155628/85/slide-284-320.jpg)
![❯ python
Python 2.7.11+ (default, Apr 17 2016, 14:00:29)
[GCC 5.3.1 20160413] on linux2
Type "help", "copyright", "credits" or "license"
for more information.
>>> import os
>>> os.getpid()
42
파이썬 기본 REPL은 다들 아실 테고](https://image.slidesharecdn.com/random-161024155628/85/slide-374-320.jpg)
![❯ ipython
Python 2.7.11+ (default, Apr 17 2016, 14:00:29)
Type "copyright", "credits" or "license" for
more information.
In [1]: import os
In [2]: os.getpid()
Out[2]: 42
IPython이라는 조금 더 스마트한
REPL도 있는데](https://image.slidesharecdn.com/random-161024155628/85/slide-375-320.jpg)
![❯ ipython
Python 2.7.11+ (default, Apr 17 2016, 14:00:29)
Type "copyright", "credits" or "license" for
more information.
In [1]: import os
In [2]: os.getpid()
Out[2]: 42
문법강조도 되고 자동완성도 되고
그 밖에도 다양한 편의기능이 들어있어요.](https://image.slidesharecdn.com/random-161024155628/85/slide-376-320.jpg)
![❯ ipython
Python 2.7.11+ (default, Apr 17 2016, 14:00:29)
Type "copyright", "credits" or "license" for
more information.
In [1]: import os
In [2]: os.getpid()
Out[2]: 42
이 IPython을 터미널 대신
웹에서도 쓸 수 있게 나온 게](https://image.slidesharecdn.com/random-161024155628/85/slide-377-320.jpg)
![>>> world_id = db.find_all(World.id)[0]
>>> world = db.load(World, world_id)
>>> islands = world.all_islands()
>>> for island in islands:
... if 'Python' in island.name:
... break
... else:
... assert False, 'island not found'
...
>>> lakes = island.find_lakes()
>>> lake = lakes[42]
>>> p = Player(id=1)
>>> p.level = 0
>>> for item in INITIAL_ITEMS:
... p.inventory.add_item(item)
...
>>> homes = island.find_homes()
>>> p.home = homes[999]
>>> p.move_to(lake)
Player-1 moved to lake-42!
저희가 만드는 게 MMORPG라서 그런지](https://image.slidesharecdn.com/random-161024155628/85/slide-383-320.jpg)
![>>> world_id = db.find_all(World.id)[0]
>>> world = db.load(World, world_id)
>>> islands = world.all_islands()
>>> for island in islands:
... if 'Python' in island.name:
... break
... else:
... assert False, 'island not found'
...
>>> lakes = island.find_lakes()
>>> lake = lakes[42]
>>> p = Player(id=1)
>>> p.level = 0
>>> for item in INITIAL_ITEMS:
... p.inventory.add_item(item)
...
>>> homes = island.find_homes()
>>> p.home = homes[999]
>>> p.move_to(lake)
Player-1 moved to lake-42!
간단한 게임플레이 테스트 시나리오
하나 짜려고 해도](https://image.slidesharecdn.com/random-161024155628/85/slide-384-320.jpg)
![>>> world_id = db.find_all(World.id)[0]
>>> world = db.load(World, world_id)
>>> islands = world.all_islands()
>>> for island in islands:
... if 'Python' in island.name:
... break
... else:
... assert False, 'island not found'
...
>>> lakes = island.find_lakes()
>>> lake = lakes[42]
>>> p = Player(id=1)
>>> p.level = 0
>>> for item in INITIAL_ITEMS:
... p.inventory.add_item(item)
...
>>> homes = island.find_homes()
>>> p.home = homes[999]
>>> p.move_to(lake)
Player-1 moved to lake-42!
그 시나리오에 필요한
게임 세계를 구축하는데](https://image.slidesharecdn.com/random-161024155628/85/slide-385-320.jpg)
![>>> world_id = db.find_all(World.id)[0]
>>> world = db.load(World, world_id)
>>> islands = world.all_islands()
>>> for island in islands:
... if 'Python' in island.name:
... break
... else:
... assert False, 'island not found'
...
>>> lakes = island.find_lakes()
>>> lake = lakes[42]
>>> p = Player(id=1)
>>> p.level = 0
>>> for item in INITIAL_ITEMS:
... p.inventory.add_item(item)
...
>>> homes = island.find_homes()
>>> p.home = homes[999]
>>> p.move_to(lake)
Player-1 moved to lake-42!
굉장히 깊은 의존성을
풀어야 하는 경우가 있어요.](https://image.slidesharecdn.com/random-161024155628/85/slide-386-320.jpg)
![>>> world_id = db.find_all(World.id)[0]
>>> world = db.load(World, world_id)
>>> islands = world.all_islands()
>>> for island in islands:
... if 'Python' in island.name:
... break
... else:
... assert False, 'island not found'
...
>>> lakes = island.find_lakes()
>>> lake = lakes[42]
>>> p = Player(id=1)
>>> p.level = 0
>>> for item in INITIAL_ITEMS:
... p.inventory.add_item(item)
...
>>> homes = island.find_homes()
>>> p.home = homes[999]
>>> p.move_to(lake)
Player-1 moved to lake-42!
이 코드는 읽으라고 쓴 게 아니에요.](https://image.slidesharecdn.com/random-161024155628/85/slide-387-320.jpg)
![>>> world_id = db.find_all(World.id)[0]
>>> world = db.load(World, world_id)
>>> islands = world.all_islands()
>>> for island in islands:
... if 'Python' in island.name:
... break
... else:
... assert False, 'island not found'
...
>>> lakes = island.find_lakes()
>>> lake = lakes[42]
>>> p = Player(id=1)
>>> p.level = 0
>>> for item in INITIAL_ITEMS:
... p.inventory.add_item(item)
...
>>> homes = island.find_homes()
>>> p.home = homes[999]
>>> p.move_to(lake)
Player-1 moved to lake-42!
여기서 테스트하고 싶은 건](https://image.slidesharecdn.com/random-161024155628/85/slide-388-320.jpg)
![>>> world_id = db.find_all(World.id)[0]
>>> world = db.load(World, world_id)
>>> islands = world.all_islands()
>>> for island in islands:
... if 'Python' in island.name:
... break
... else:
... assert False, 'island not found'
...
>>> lakes = island.find_lakes()
>>> lake = lakes[42]
>>> p = Player(id=1)
>>> p.level = 0
>>> for item in INITIAL_ITEMS:
... p.inventory.add_item(item)
...
>>> homes = island.find_homes()
>>> p.home = homes[999]
>>> p.move_to(lake)
Player-1 moved to lake-42!
그저 플레이어를 호수 근처로
옮기는 것 뿐인데](https://image.slidesharecdn.com/random-161024155628/85/slide-389-320.jpg)
![>>> world_id = db.find_all(World.id)[0]
>>> world = db.load(World, world_id)
>>> islands = world.all_islands()
>>> for island in islands:
... if 'Python' in island.name:
... break
... else:
... assert False, 'island not found'
...
>>> lakes = island.find_lakes()
>>> lake = lakes[42]
>>> p = Player(id=1)
>>> p.level = 0
>>> for item in INITIAL_ITEMS:
... p.inventory.add_item(item)
...
>>> homes = island.find_homes()
>>> p.home = homes[999]
>>> p.move_to(lake)
Player-1 moved to lake-42!
플레이어와 호수를 준비하려면](https://image.slidesharecdn.com/random-161024155628/85/slide-390-320.jpg)
![>>> world_id = db.find_all(World.id)[0]
>>> world = db.load(World, world_id)
>>> islands = world.all_islands()
>>> for island in islands:
... if 'Python' in island.name:
... break
... else:
... assert False, 'island not found'
...
>>> lakes = island.find_lakes()
>>> lake = lakes[42]
>>> p = Player(id=1)
>>> p.level = 0
>>> for item in INITIAL_ITEMS:
... p.inventory.add_item(item)
...
>>> homes = island.find_homes()
>>> p.home = homes[999]
>>> p.move_to(lake)
Player-1 moved to lake-42!
앞쪽에 훨씬 복잡하고 많은 코드가
필요할 수 있다는 걸 보여드리고 싶었어요.](https://image.slidesharecdn.com/random-161024155628/85/slide-391-320.jpg)
![>>> world_id = db.find_all(World.id)[0]
>>> world = db.load(World, world_id)
>>> islands = world.all_islands()
>>> for island in islands:
... if 'Python' in island.name:
... break
... else:
... assert False, 'island not found'
...
>>> lakes = island.find_lakes()
>>> lake = lakes[42]
>>> p = Player(id=1)
>>> p.level = 0
>>> for item in INITIAL_ITEMS:
... p.inventory.add_item(item)
...
>>> homes = island.find_homes()
>>> p.home = homes[999]
>>> p.move_to(lake)
Player-1 moved to lake-42!
게임서버에서는 게임 세계가
알아서 구축되잖아요?](https://image.slidesharecdn.com/random-161024155628/85/slide-392-320.jpg)
![>>> world_id = db.find_all(World.id)[0]
>>> world = db.load(World, world_id)
>>> islands = world.all_islands()
>>> for island in islands:
... if 'Python' in island.name:
... break
... else:
... assert False, 'island not found'
...
>>> lakes = island.find_lakes()
>>> lake = lakes[42]
>>> p = Player(id=1)
>>> p.level = 0
>>> for item in INITIAL_ITEMS:
... p.inventory.add_item(item)
...
>>> homes = island.find_homes()
>>> p.home = homes[999]
>>> p.move_to(lake)
Player-1 moved to lake-42!
만약 서버를 직접 돌리는 방식으로만
테스트하게 되면](https://image.slidesharecdn.com/random-161024155628/85/slide-393-320.jpg)
![>>> world_id = db.find_all(World.id)[0]
>>> world = db.load(World, world_id)
>>> islands = world.all_islands()
>>> for island in islands:
... if 'Python' in island.name:
... break
... else:
... assert False, 'island not found'
...
>>> lakes = island.find_lakes()
>>> lake = lakes[42]
>>> p = Player(id=1)
>>> p.level = 0
>>> for item in INITIAL_ITEMS:
... p.inventory.add_item(item)
...
>>> homes = island.find_homes()
>>> p.home = homes[999]
>>> p.move_to(lake)
Player-1 moved to lake-42!
이런 부분이 고달플 수 있다는 걸
잘 모르고 넘어갈 수 있어요.](https://image.slidesharecdn.com/random-161024155628/85/slide-394-320.jpg)
![> helloworld.py(7)hello_world()
-> return hello
(Pdb) hello
'world'
(Pdb) l
4 def hello_world():
5 hello = 'world'
6 pdb.set_trace()
7 -> return hello
8 hello_world()
[EOF]
실행 도중에 브레이크포인트에 걸리면
디버깅 콘솔이 뜨는데](https://image.slidesharecdn.com/random-161024155628/85/slide-409-320.jpg)
![> helloworld.py(7)hello_world()
-> return hello
(Pdb) hello
'world'
(Pdb) l
4 def hello_world():
5 hello = 'world'
6 pdb.set_trace()
7 -> return hello
8 hello_world()
[EOF]
보통의 IDE 디버거와 마찬가지로](https://image.slidesharecdn.com/random-161024155628/85/slide-410-320.jpg)
![> helloworld.py(7)hello_world()
-> return hello
(Pdb) hello
'world'
(Pdb) l
4 def hello_world():
5 hello = 'world'
6 pdb.set_trace()
7 -> return hello
8 hello_world()
[EOF]
변수 내용을 확인한다거나](https://image.slidesharecdn.com/random-161024155628/85/slide-411-320.jpg)
![> helloworld.py(7)hello_world()
-> return hello
(Pdb) hello
'world'
(Pdb) l
4 def hello_world():
5 hello = 'world'
6 pdb.set_trace()
7 -> return hello
8 hello_world()
[EOF]
실행중인 코드 위치를 확인한다거나](https://image.slidesharecdn.com/random-161024155628/85/slide-412-320.jpg)
![> helloworld.py(7)hello_world()
-> return hello
(Pdb) hello
'world'
(Pdb) l
4 def hello_world():
5 hello = 'world'
6 pdb.set_trace()
7 -> return hello
8 hello_world()
[EOF]
아니면 콜스택 위아래를 오간다거나
한 스텝씩 넘겨본다거나 할 수 있어요.](https://image.slidesharecdn.com/random-161024155628/85/slide-413-320.jpg)
![> helloworld.py(7)hello_world()
-> return hello
(Pdb++) hello
'world'
(Pdb++) l
4 def hello_world():
5 hello = 'world'
6 pdb.set_trace()
7 -> return hello
8 hello_world()
[EOF]
pdb++ 확장을 깔면
문법강조도 볼 수 있죠.](https://image.slidesharecdn.com/random-161024155628/85/slide-414-320.jpg)
![stack = []
while f:
stack.append(f)
f = f.f_back
stack.reverse()
stack = deque()
while f:
stack.appendleft(f)
이런 식으로 list에 순차적으로 쌓은 다음
뒤집는 경우가 있는데](https://image.slidesharecdn.com/random-161024155628/85/slide-439-320.jpg)
![stack = []
while f:
stack.append(f)
f = f.f_back
stack.reverse()
stack = deque()
while f:
stack.appendleft(f)
deque을 쓰면 처음부터
역순으로 쌓을 수 있어요.](https://image.slidesharecdn.com/random-161024155628/85/slide-440-320.jpg)
![>>> sub = OrderedDict([('S', 1), ('U', 2), ('B', 3)])
>>> sub['S']
1
>>> sub.keys()
['S', 'U', 'B']
OrderedDict는 dict의 서브클래스인데
그냥 dict와 달리 순서를 보장해줘서](https://image.slidesharecdn.com/random-161024155628/85/slide-441-320.jpg)
![>>> sub = OrderedDict([('S', 1), ('U', 2), ('B', 3)])
>>> sub['S']
1
>>> sub.keys()
['S', 'U', 'B']
순서도 중요하고
키로 접근하는 것도 중요할 때 쓰면 좋아요.](https://image.slidesharecdn.com/random-161024155628/85/slide-442-320.jpg)
![>>> Vector2 = namedtuple('Vector2', ['x', 'y'])
>>> xy = Vector2(20, 59)
>>> xy.x
20
>>> x, y = xy
namedtuple은 tuple의 서브클래스를
만들어주는 함수인데](https://image.slidesharecdn.com/random-161024155628/85/slide-443-320.jpg)
![>>> Vector2 = namedtuple('Vector2', ['x', 'y'])
>>> xy = Vector2(20, 59)
>>> xy.x
20
>>> x, y = xy
이때 각 원소에
이름을 붙일 수 있어요.](https://image.slidesharecdn.com/random-161024155628/85/slide-444-320.jpg)
![>>> Vector2 = namedtuple('Vector2', ['x', 'y'])
>>> xy = Vector2(20, 59)
>>> xy.x
20
>>> x, y = xy
이것으로 만든 클래스도 tuple 처럼 불변이고
다중대입문에도 쓸 수 있죠.](https://image.slidesharecdn.com/random-161024155628/85/slide-445-320.jpg)
![>>> Vector2 = namedtuple('Vector2', ['x', 'y'])
>>> xy = Vector2(20, 59)
>>> xy.x
20
>>> x, y = xy
저는 사소한 클래스 만들 땐
class문을 직접 쓰는 대신](https://image.slidesharecdn.com/random-161024155628/85/slide-446-320.jpg)
![>>> Vector2 = namedtuple('Vector2', ['x', 'y'])
>>> xy = Vector2(20, 59)
>>> xy.x
20
>>> x, y = xy
이 쪽을 더 선호하는 편이에요.](https://image.slidesharecdn.com/random-161024155628/85/slide-447-320.jpg)
![>>> c = Counter('nexon')
>>> c['n']
2
>>> c['x']
1
Counter는 dict의 서브클래스고
이렇게 뭔가 간단히 셀 때 쓰기 좋아요.](https://image.slidesharecdn.com/random-161024155628/85/slide-448-320.jpg)
![>>> d = defaultdict(int)
>>> d['yo']
0
defaultdict는 없는 키에 접근했을 때
KeyError를 내는 대신](https://image.slidesharecdn.com/random-161024155628/85/slide-449-320.jpg)
![>>> d = defaultdict(int)
>>> d['yo']
0
팩토리함수 실행 결과를
채워주는 dict예요.](https://image.slidesharecdn.com/random-161024155628/85/slide-450-320.jpg)
![root = inf_dict()
root[0][1][2][3][4][5][6][7] = 'So deep!'
그래서 아무 키나
끊임 없이 써내려 갈 수 있어요.](https://image.slidesharecdn.com/random-161024155628/85/slide-453-320.jpg)
![foo = [1, 10, 100, 1000]
x = bisect_left(foo, 42)
foo.insert(x, 42)
from sortedcontainer import SortedList
bar = SortedList([1, 10, 100, 1000])
bar.add(42)
sortedcontainers는
항상 정렬돼있는 list와 dict를 제공해서](https://image.slidesharecdn.com/random-161024155628/85/slide-456-320.jpg)
![foo = [1, 10, 100, 1000]
x = bisect_left(foo, 42)
foo.insert(x, 42)
from sortedcontainer import SortedList
bar = SortedList([1, 10, 100, 1000])
bar.add(42)
굉장히 빠르게 원소를 정렬된 상태로
넣거나 빼는 데 쓸 수 있어요.](https://image.slidesharecdn.com/random-161024155628/85/slide-457-320.jpg)
![foo = [1, 10, 100, 1000]
x = bisect_left(foo, 42)
foo.insert(x, 42)
from sortedcontainer import SortedList
bar = SortedList([1, 10, 100, 1000])
bar.add(42)
표준 list나 set으로는
할 수 없는 일이죠.](https://image.slidesharecdn.com/random-161024155628/85/slide-458-320.jpg)
![>>> from bidict import bidict
>>> type_table = bidict()
>>> type_table[1] = Ping
>>> type_table[2] = Pong
>>> type_table.inv[Pong]
2
bidict는 양방향 dict로,](https://image.slidesharecdn.com/random-161024155628/85/slide-459-320.jpg)
![>>> from bidict import bidict
>>> type_table = bidict()
>>> type_table[1] = Ping
>>> type_table[2] = Pong
>>> type_table.inv[Pong]
2
키로 값을 찾는 것 뿐만 아니라
값으로 키를 찾는 것까지 가능해서](https://image.slidesharecdn.com/random-161024155628/85/slide-460-320.jpg)
![>>> from bidict import bidict
>>> type_table = bidict()
>>> type_table[1] = Ping
>>> type_table[2] = Pong
>>> type_table.inv[Pong]
2
타입코드 테이블 같은 거
만들 때 유용해요.](https://image.slidesharecdn.com/random-161024155628/85/slide-461-320.jpg)
![>>> list(seq)
[1, 9, 25, 49, 81, 121, ...]
결과를 보기 위해 list 등으로 감싸면
그때야 비로소 이터레이션이 돌죠.](https://image.slidesharecdn.com/random-161024155628/85/slide-483-320.jpg)
![>>> list(seq)
[1, 9, 25, 49, 81, 121, ...]
레이지하지 않았다면 이터레이션이
250만 바퀴 돌았을 로직인데](https://image.slidesharecdn.com/random-161024155628/85/slide-484-320.jpg)
![>>> list(seq)
[1, 9, 25, 49, 81, 121, ...]
이 방법으로
딱 100만 바퀴만 돌 수 있게 됩니다.](https://image.slidesharecdn.com/random-161024155628/85/slide-485-320.jpg)
![❯ python -m timeit
-s 'from exm import only_odds' '
seq = list(xrange(1000000))
seq = list(only_odds(seq))
seq = [x ** 2 for x in seq]
'
10 loops, best of 3: 456 msec per loop
반면 매번 이터레이션하는 방식으로는
456ms나 걸리는 걸 볼 수 있었습니다.](https://image.slidesharecdn.com/random-161024155628/85/slide-487-320.jpg)
![>>> list(gen)
[1, 2, 3]
>>> list(gen)
[]
def gen():
yield 1
yield 2
yield 3
제너레이터는 딱 한 바퀴만
돌릴 수 있어서](https://image.slidesharecdn.com/random-161024155628/85/slide-488-320.jpg)
![>>> list(gen)
[1, 2, 3]
>>> list(gen)
[]
def gen():
yield 1
yield 2
yield 3
여러 번 돌려야 하는 경우에
당황스러울 수 있어요.](https://image.slidesharecdn.com/random-161024155628/85/slide-489-320.jpg)
![for filename in filenames:
with open(filename) as f:
dsl = json.load(f)
cls = generate_class(dsl)
locals()[cls.__name__] = cls
__all__.append(cls.__name__)
이것을 이용하면 파이썬 코드가 아닌
다른 파일로 DSL을 만들어서](https://image.slidesharecdn.com/random-161024155628/85/slide-559-320.jpg)
![for filename in filenames:
with open(filename) as f:
dsl = json.load(f)
cls = generate_class(dsl)
locals()[cls.__name__] = cls
__all__.append(cls.__name__)
반복적인 클래스 선언 코드를
줄일 수 있죠.](https://image.slidesharecdn.com/random-161024155628/85/slide-560-320.jpg)
![for filename in filenames:
with open(filename) as f:
dsl = json.load(f)
cls = generate_class(dsl)
locals()[cls.__name__] = cls
__all__.append(cls.__name__)
저희 패킷이나 예외 같은 것도 이렇게
로드타임에 동적으로 생성하고 있어요.](https://image.slidesharecdn.com/random-161024155628/85/slide-561-320.jpg)
![class Person(Model):
__metaclass__ = ModelMeta
name = field(str)
age = field(int)
>>> Person.schema
[('name', str), ('age', int)]
메타클래스는 클래스의 클래스인데](https://image.slidesharecdn.com/random-161024155628/85/slide-562-320.jpg)
![class Person(Model):
__metaclass__ = ModelMeta
name = field(str)
age = field(int)
>>> Person.schema
[('name', str), ('age', int)]
객체가 만들어질 때
클래스에 있는 생성자를 부르듯이](https://image.slidesharecdn.com/random-161024155628/85/slide-563-320.jpg)
![class Person(Model):
__metaclass__ = ModelMeta
name = field(str)
age = field(int)
>>> Person.schema
[('name', str), ('age', int)]
클래스가 만들어질 땐
메타클래스에 정의한 생성자가 불려요.](https://image.slidesharecdn.com/random-161024155628/85/slide-564-320.jpg)
![class Person(Model):
__metaclass__ = ModelMeta
name = field(str)
age = field(int)
>>> Person.schema
[('name', str), ('age', int)]
미래에 쓰기 위해 미리 구워 놓을 만한
정보가 있다면 여기서 구워 둘 수 있죠.](https://image.slidesharecdn.com/random-161024155628/85/slide-565-320.jpg)
![class Dirty(object):
for x in range(100):
r = random()
locals()['x%f' % r] = r
exec '__metaclass__ = DirtyMeta'
로드타임은 처음 진입하는 런타임일 뿐이고
파이썬은 엄청나게 동적인 언어다 보니](https://image.slidesharecdn.com/random-161024155628/85/slide-571-320.jpg)
![class Dirty(object):
for x in range(100):
r = random()
locals()['x%f' % r] = r
exec '__metaclass__ = DirtyMeta'
이런 온갖 지저분한 일을
할 수는 있지만](https://image.slidesharecdn.com/random-161024155628/85/slide-572-320.jpg)
![class Dirty(object):
for x in range(100):
r = random()
locals()['x%f' % r] = r
exec '__metaclass__ = DirtyMeta'
너무 과하면 코드를 이해하거나
디버깅하기 어려워질 수 있으니까](https://image.slidesharecdn.com/random-161024155628/85/slide-573-320.jpg)
![class Dirty(object):
for x in range(100):
r = random()
locals()['x%f' % r] = r
exec '__metaclass__ = DirtyMeta'
중용의 미를 갖추는 게 중요해요.](https://image.slidesharecdn.com/random-161024155628/85/slide-574-320.jpg)
![class Dirty(object):
for x in range(100):
r = random()
locals()['x%f' % r] = r
exec '__metaclass__ = DirtyMeta'
적당한 선에서 반복작업을 줄여주거나](https://image.slidesharecdn.com/random-161024155628/85/slide-575-320.jpg)
![class Dirty(object):
for x in range(100):
r = random()
locals()['x%f' % r] = r
exec '__metaclass__ = DirtyMeta'
런타임에 처리할 일들을
로드타임으로 당겨오는 데 이용하면](https://image.slidesharecdn.com/random-161024155628/85/slide-576-320.jpg)
![class Dirty(object):
for x in range(100):
r = random()
locals()['x%f' % r] = r
exec '__metaclass__ = DirtyMeta'
서버처럼 오랫동안 도는 프로그램에선
좋은 성과를 보실 수 있을 겁니다.](https://image.slidesharecdn.com/random-161024155628/85/slide-577-320.jpg)
![objgraph.show_backrefs(xs[42])
show_backrefs()로는 어디서
주어진 객체를 참조하는지 알아낼 수 있는데](https://image.slidesharecdn.com/random-161024155628/85/slide-598-320.jpg)
![def make_node(children=[]):
return Node(children)
이건 인자 기본값으로
가변 객체를 지정해둔 모습인데](https://image.slidesharecdn.com/random-161024155628/85/slide-644-320.jpg)
![def make_node(children=[]):
return Node(children)
함수 기본값은 로드타임에
딱 한 번만 초기화되니까](https://image.slidesharecdn.com/random-161024155628/85/slide-645-320.jpg)
![def make_node(children=None):
if children is None:
children = []
return Node(children)
꼭 불변 객체를 써주세요.](https://image.slidesharecdn.com/random-161024155628/85/slide-646-320.jpg)
![def make_node(children=None):
if children is None:
children = []
return Node(children)
플레이스홀더로
None을 쓰는 걸 추천합니다.](https://image.slidesharecdn.com/random-161024155628/85/slide-647-320.jpg)
![>>> n1 = make_node()
>>> n1.children.append(n1)
>>> n2 = make_node()
>>> n2.children
[<n1>]
그러지 않을 경우](https://image.slidesharecdn.com/random-161024155628/85/slide-648-320.jpg)
![>>> n1 = make_node()
>>> n1.children.append(n1)
>>> n2 = make_node()
>>> n2.children
[<n1>]
이렇게 엉뚱한 곳에서
간섭을 발견하게 될 수도 있어요.](https://image.slidesharecdn.com/random-161024155628/85/slide-649-320.jpg)
![from setuptools import setup
setup(
name='foobar',
install_requires=[
'profiling',
'trueskill',
'tossi==0.0.1',
],
)
setup.py
setup.py는 프로젝트 메타정보를
정의하는 스크립트인데](https://image.slidesharecdn.com/random-161024155628/85/slide-691-320.jpg)
![from setuptools import setup
setup(
name='foobar',
install_requires=[
'profiling',
'trueskill',
'tossi==0.0.1',
],
)
setup.py
install_requires 옵션에
의존성을 적어두면](https://image.slidesharecdn.com/random-161024155628/85/slide-692-320.jpg)
![from setuptools import setup
setup(
name='foobar',
install_requires=[
'profiling',
'trueskill',
'tossi==0.0.1',
],
)
setup.py
이 프로젝트를 설치할 때
의존성까지 자동으로 풀리게 돼요.](https://image.slidesharecdn.com/random-161024155628/85/slide-693-320.jpg)
![from setuptools import setup
setup(
name='foobar',
install_requires=[
'profiling',
'trueskill',
'tossi==0.0.1',
],
)
setup.py
여기에 패키지명만 적거나
버전을 함께 명시하면 됩니다.](https://image.slidesharecdn.com/random-161024155628/85/slide-694-320.jpg)
Uploaded byHeungsub Lee
파이썬 생존 안내서 (자막)
넥슨코리아 사내 발표자료로 왓 스튜디오에서 파이썬으로 《야생의 땅: 듀랑고》 서버를 비롯한 여러가지 도구를 만든 경험을 공유합니다. - 게임서버와 각종 툴, 테스트/빌드/배포 시스템을 만들 때 사용한 재료 - 파이썬 코드 품질 개선, 디버깅, 프로파일링, 최적화 - 파이썬 오픈소스 생태계와 왓 스튜디오가 하는 오픈소스 활동
![[야생의 땅: 듀랑고] 서버 아키텍처 Vol. 2 (자막)](https://cdn.slidesharecdn.com/ss_thumbnails/vol2-160427160825-thumbnail.jpg?width=640&height=640&fit=bounds)
![[야생의 땅: 듀랑고] 서버 아키텍처 - SPOF 없는 분산 MMORPG 서버](https://cdn.slidesharecdn.com/ss_thumbnails/public-140529222503-phpapp01-thumbnail.jpg?width=640&height=640&fit=bounds)
![[NDC 2018] 신입 개발자가 알아야 할 윈도우 메모리릭 디버깅](https://cdn.slidesharecdn.com/ss_thumbnails/v7-180427162920-thumbnail.jpg?width=640&height=640&fit=bounds)
![[IGC 2017] 아마존 구승모 - 게임 엔진으로 서버 제작 및 운영까지](https://cdn.slidesharecdn.com/ss_thumbnails/igc2017-170904090322-thumbnail.jpg?width=640&height=640&fit=bounds)
![오딘: 발할라 라이징 MMORPG의 성능 최적화 사례 공유 [카카오게임즈 - 레벨 300] - 발표자: 김문권, 팀장, 라이온하트 스튜디오...](https://cdn.slidesharecdn.com/ss_thumbnails/t3s1-221108101729-c6b32f4f-thumbnail.jpg?width=640&height=640&fit=bounds)
![[0903 구경원] recast 네비메쉬](https://cdn.slidesharecdn.com/ss_thumbnails/0903recast-111221053315-phpapp01-thumbnail.jpg?width=640&height=640&fit=bounds)
![[NDC17] Unreal.js - 자바스크립트로 쉽고 빠른 UE4 개발하기](https://cdn.slidesharecdn.com/ss_thumbnails/wjkqukgsqgm2vger5dnt-signature-2cf736e9b897e2aaaa6315f9d31d6951ba19fae7560fe278cefb4644ac0753c6-poli-170428114140-thumbnail.jpg?width=640&height=640&fit=bounds)
![[120316] node.js 프로그래밍 5장](https://cdn.slidesharecdn.com/ss_thumbnails/120316nodejsch5-120319081659-phpapp01-thumbnail.jpg?width=640&height=640&fit=bounds)
![[아꿈사] 게임 기초 수학 물리 1,2장](https://cdn.slidesharecdn.com/ss_thumbnails/12042112-120419104413-phpapp02-thumbnail.jpg?width=640&height=640&fit=bounds)
![PyCon 2017 프로그래머가 이사하는 법 2 [천원경매]](https://cdn.slidesharecdn.com/ss_thumbnails/pycon20172-170813134610-thumbnail.jpg?width=640&height=640&fit=bounds)
![[야생의 땅: 듀랑고] 지형 관리 완전 자동화 - 생생한 AWS와 Docker 체험기](https://cdn.slidesharecdn.com/ss_thumbnails/ndc2016-160426115105-thumbnail.jpg?width=640&height=640&fit=bounds)
파이썬 생존 안내서 (자막)
- 1. 파이썬 생존 안내서 이흥섭@ 왓 스튜디오 2016년 10월 11일 넥슨토크
- 2. 파이썬 생존 안내서 이흥섭@ 왓 스튜디오 2016년 10월 11일 넥슨토크 안녕하세요.
- 3. 이흥섭 게임서버 아키텍트 @ 왓스튜디오 파이썬을 주제로 발표하게 된 왓 스튜디오의 이흥섭입니다.
- 4. 이흥섭 게임서버 아키텍트 @ 왓스튜디오 현재 《야생의 땅: 듀랑고》 프로젝트에서 게임서버 아키텍트로 일하고 있습니다.
- 5. • 《야생의 땅:듀랑고》 • 《카트라이더 대시》 • 《카트라이더 코인러시》 • 한글라이즈 • Profiling • TrueSkill 파이썬 구현 이전엔 《카트라이더 대시》와 《코인러시》 시리즈의 서버를 만들었고
- 6. • 《야생의 땅:듀랑고》 • 《카트라이더 대시》 • 《카트라이더 코인러시》 • 한글라이즈 • Profiling • TrueSkill 파이썬 구현 틈틈이 GitHub 같은 곳에서 오픈소스 활동도 하고 있어요.
- 7. • NDC 2014― 《야생의 땅: 듀랑고》 서버 아키텍처 • 파이콘 KR 2015 ― Profiling • NDC 2016 ― 《야생의 땅: 듀랑고》 서버 아키텍처 Vol. 2 오늘이 제 4번째 발표인데요
- 8. • NDC 2014― 《야생의 땅: 듀랑고》 서버 아키텍처 • 파이콘 KR 2015 ― Profiling • NDC 2016 ― 《야생의 땅: 듀랑고》 서버 아키텍처 Vol. 2 재작년과 올해 NDC에서 《듀랑고》 서버 아키텍처에 대한 얘기를 했었고
- 9. • NDC 2014― 《야생의 땅: 듀랑고》 서버 아키텍처 • 파이콘 KR 2015 ― Profiling • NDC 2016 ― 《야생의 땅: 듀랑고》 서버 아키텍처 Vol. 2 작년 파이콘 KR에선 저희가 만든 파이썬 프로파일러에 대해 얘기한 적이 있습니다.
- 10. 2006년 파이썬 2.4~ 저는2006년, 최신 파이썬 버전이 2.4이던 시절부터 파이썬을 써왔어요.
- 11.
- 12. 코드 의도 써야 되는 코드의양이 적다는 점이 매력으로 느껴졌었는데
- 13. 코드 의도 아무래도 문법도 C스타일 언어에 비해선 짧은 코드에 좀 더 맞춰져 있고
- 14. 코드 의도 표준 라이브러리나 성숙한 써드파티라이브러리도 풍부해서
- 15. 코드 의도 어지간한 기능은 직접짜는 대신 끌어다 쓸 수 있기 때문인 것 같아요.
- 16. 재작년 NDC 발표에서소개했듯이
- 17. • 《야생의 땅: 듀랑고》서버는 파이썬으로 만들고 있습니다.
- 18.
- 19. 파이썬 그럼 본격적인 이야기에앞서 간단히 파이썬을 소개해 볼게요.
- 20. 1989년 12월 Guido vanRossum 제가 1989년 12월 생인데 마침 파이썬도 같은 달에 시작됐더라고요.
- 21. 1989년 12월 Guido vanRossum 그때부터 Guido van Rossum이 만든 언어입니다.
- 22. • https://github.com/python • PEPhttps://www.python.org/dev/peps/ • 파이콘 파이썬은 오픈소스고
- 23. • https://github.com/python • PEPhttps://www.python.org/dev/peps/ • 파이콘 사람들이 PEP이라는 파이썬 개선 제안서를 제출하면
- 24. • https://github.com/python • PEPhttps://www.python.org/dev/peps/ • 파이콘 토론한 후 채택하거나 반려하는 식으로 발전해왔어요.
- 25. • https://github.com/python • PEPhttps://www.python.org/dev/peps/ • 파이콘 파이콘은 파이썬 공식 컨퍼런스인데
- 26. • https://github.com/python • PEPhttps://www.python.org/dev/peps/ • 파이콘 전세계에서 정기적으로 열리고 있고 2014년부터는 한국에서도 진행되고 있습니다.
- 27. import this class Example(object): pass defexample(): return Example() print 'Hello, world' 파이썬 코드는 대충 이렇게 생겼어요.
- 28. import this class Example(object): pass defexample(): return Example() print 'Hello, world' 모듈 체계가 있고
- 29. import this class Example(object): pass defexample(): return Example() print 'Hello, world' 클래스와 함수가 있고
- 30. import this class Example(object): pass defexample(): return Example() print 'Hello, world' Java나 C# 등과 다르게 꼭 메소드 속이 아니더라도 코드를 실행할 수 있어요.
- 31. for x innumbers: if 2 < x < 4: break else: print 'not found' 그리고 은근히 편한 문법이 많은데
- 32. for x innumbers: if 2 < x < 4: break else: print 'not found' 가령 숫자 범위를 검사할 때
- 33. for x innumbers: if 2 < x and x < 4: break else: print 'not found' 부등식 2개를 and로 잇는 대신
- 34. for x innumbers: if 2 < x < 4: break else: print 'not found' 부등호를 숫자 양 옆에 바로 쓸 수도 있고
- 35. for x innumbers: if 2 < x < 4: break else: print 'not found' if 문 뿐만 아니라 루프에도 else 절을 달 수 있어서
- 36. for x innumbers: if 2 < x < 4: break else: print 'not found' 루프가 중간에 멈췄는지 아니면 끝까지 무사히 돌았는지
- 37. for x innumbers: if 2 < x < 4: break else: print 'not found' 표시해둘 변수를 따로 두지 않아도 되죠.
- 38.
- 39.
- 40.
- 41. Erlang Clojure Python Groovy Ruby Magik C# F# Scala Haskell C C++ Perl VB PHP JavaScript Java 동적 정적 약 강 이 사분면은〈 〉란 글에서 따왔어요. Dynamic Typing is NOT Weak Typing
- 42.
- 43.
- 44.
- 45.
- 46. Erlang Clojure Python Groovy Ruby Magik C# F# Scala Haskell C C++ Perl VB PHP JavaScript Java 동적 정적 약 강 아주 강타입인것도 아니지만 그렇다고 JavaScript나 PHP처럼
- 47.
- 48.
- 49. 과학 SciPy, NumPy, matplotlib 파이썬은과학계에서 오랫동안 깊게 쓰여왔는데
- 50. 과학 SciPy, NumPy, matplotlib scipy,numpy, matplotlib 같은 라이브러리가 이 방면에서 아주 유명합니다.
- 51. 데이터분석 Jupyter, Pandas, PySpark 요즘은Scala와 더불어서 데이터분석에도 많이 쓰인다고 해요.
- 52. 데이터분석 Jupyter, Pandas, PySpark Jupyter와Pandas를 이용해서 데이터에 쿼리를 날려보고
- 53. 데이터분석 Jupyter, Pandas, PySpark 결과를읽어서 새로운 통찰을 얻은 다음 다시 새로운 쿼리를 날려보는
- 54. 데이터분석 Jupyter, Pandas, PySpark “탐색적자료 분석”을 많이 추천하더라고요.
- 55. 기계학습 Theano, TensorFlow 김영호, 2016 과학계의연장인지 최근엔 기계학습 쪽에서도 많이 쓰이고 있어요.
- 56. 기계학습 Theano, TensorFlow 김영호, 2016 이영상은 저희 스튜디오 김영호 님이
- 57. 기계학습 Theano, TensorFlow 김영호, 2016 Google에서만든 딥러닝 라이브러리인 TensorFlow를 이용해서
- 58. 기계학습 Theano, TensorFlow 김영호, 2016 알파고처럼AI에게 총알 피하기 게임을 학습시킨 모습이에요.
- 59. 웹 Flask, Django, Requests @app.route('/') defhello(): return 'Hello, world' Ruby에 Rails가 있듯이
- 60. 웹 Flask, Django, Requests @app.route('/') defhello(): return 'Hello, world' 파이썬에도 Flask나 Django 같은 훌륭한 웹 프레임워크들이 있는데
- 61. 웹 Flask, Django, Requests @app.route('/') defhello(): return 'Hello, world' 우리나라 스타트업에서 많이 쓰이고 있는 것 같아요.
- 62. 웹 Flask, Django, Requests @app.route('/') defhello(): return 'Hello, world' 제 홈페이지도 Flask로 만들어져 있죠.
- 63. 웹 Flask, Django, Requests @app.route('/') defhello(): return 'Hello, world' 또 Requests라고 정말 쓰기 편한 HTTP 클라이언트 라이브러리가 있는데
- 64. 웹 Flask, Django, Requests @app.route('/') defhello(): return 'Hello, world' 이게 너무 편해서 표준 라이브러리를 꺾고 사실상 표준이 됐어요.
- 65. 웹 Flask, Django, Requests @app.route('/') defhello(): return 'Hello, world' 저 같은 경우 여러가지 RESTful API 클라이언트 만들 때
- 66. 웹 Flask, Django, Requests @app.route('/') defhello(): return 'Hello, world' Requests 덕을 많이 봤습니다.
- 67. 게임 이브온라인, 페리아연대기, pygame 게임쪽 사례로는 《이브온라인》이 가장 유명한데
- 68. 게임 이브온라인, 페리아연대기, pygame 코루틴을지원하는 변종 파이썬인 Stackless Python으로 서버를 만들었어요.
- 69. 게임 이브온라인, 페리아연대기, pygame 《페리아연대기》에서는유저 스크립트 언어로 파이썬을 쓰는 것 같았습니다.
- 70. 게임 이브온라인, 페리아연대기, pygame pygame이라는 아주작은 게임 엔진도 있는데
- 71. 게임 이브온라인, 페리아연대기, pygame 복잡한건 만들기 어렵지만 간단한 게임 클라이언트 만들기에는 좋아요.
- 72. 게임 이브온라인, 페리아연대기, pygame 아까보신 김영호 님의 총알피하기 게임도 클라이언트를 이것으로 만들었어요.
- 73. 데스크톱 자동화 SikuliX, AutoPy click() type('cmd') type(Key.ENTER) 그밖에 데스크탑 매크로를
- 74. 데스크톱 자동화 SikuliX, AutoPy click() type('cmd') type(Key.ENTER) 스크립트로 짤 수 있게 해주는 프레임워크도 몇 가지 있으니
- 75. 데스크톱 자동화 SikuliX, AutoPy click() type('cmd') type(Key.ENTER) 프로그래밍과는 거리가 먼 사람도, 특히 사무직이라면
- 76. 데스크톱 자동화 SikuliX, AutoPy click() type('cmd') type(Key.ENTER) 이런 것으로 업무 생산성을 많이 높일 수 있을 것 같아요.
- 77.
- 78. Awesome Python http://awesome-python.com/ 파이썬이 어떻게쓰이고 있는지 살펴볼 수 있습니다.
- 79. •듀랑고 서버 •유닛테스트 •빌드/배포 •각종 CLI툴 이제 본론으로 들어가 볼게요.
- 80. •듀랑고 서버 •유닛테스트 •빌드/배포 •각종 CLI툴 저희 스튜디오에선 파이썬을 《듀랑고》 게임서버와 유닛테스트,
- 81. •듀랑고 서버 •유닛테스트 •빌드/배포 •각종 CLI툴 빌드와 배포, 그리고 각종 커맨드라인 툴을 만드는 데 쓰고 있습니다.
- 82. 1. 파이썬, 인터프리터 2.동시성 3. 웹 서버 4. 터미널 앱 5. 빌드와 배포 6. 컨벤션 통일 7. REPL 8. 디버깅 9. 자료구조 10. 제너레이터 11. 성능 측정 12. 로드타임 13. 메모리 최적화 14. 흔한 실수 15. 오픈소스 저희가 이런 걸 만들 때 어떤 재료를 써왔고
- 83. 1. 파이썬, 인터프리터 2.동시성 3. 웹 서버 4. 터미널 앱 5. 빌드와 배포 6. 컨벤션 통일 7. REPL 8. 디버깅 9. 자료구조 10. 제너레이터 11. 성능 측정 12. 로드타임 13. 메모리 최적화 14. 흔한 실수 15. 오픈소스 또 어떤 재료를 안 썼거나 혹은 못 썼는지
- 84. 1. 파이썬, 인터프리터 2.동시성 3. 웹 서버 4. 터미널 앱 5. 빌드와 배포 6. 컨벤션 통일 7. REPL 8. 디버깅 9. 자료구조 10. 제너레이터 11. 성능 측정 12. 로드타임 13. 메모리 최적화 14. 흔한 실수 15. 오픈소스 그리고 코드 품질은 어떻게 관리하고 개선하고 있는지
- 85. 1. 파이썬, 인터프리터 2.동시성 3. 웹 서버 4. 터미널 앱 5. 빌드와 배포 6. 컨벤션 통일 7. REPL 8. 디버깅 9. 자료구조 10. 제너레이터 11. 성능 측정 12. 로드타임 13. 메모리 최적화 14. 흔한 실수 15. 오픈소스 주제가 꽤 다양하긴 한데 하나씩 살펴보겠습니다.
- 86.
- 87. 파이썬, 인터프리터 저희가 쓰는 파이썬버전과 인터프리터에 대해 먼저 얘기해 볼게요.
- 88. CPython, PyPy, Jython, IronPython,Python for .NET 2.6, 2.7, 3.4, 3.5 파이썬엔 여러가지 인터프리터 구현이 있고
- 89. CPython, PyPy, Jython, IronPython,Python for .NET 2.6, 2.7, 3.4, 3.5 언어 버전에도 여러가지가 있어요.
- 90. CPython, PyPy, Jython, IronPython,Python for .NET 2.6, 2.7, 3.4, 3.5 그 중 저희가 사용하는 인터프리터는 C로 만든 공식 구현체인 CPython,
- 91. CPython, PyPy, Jython, IronPython,Python for .NET 2.6, 2.7, 3.4, 3.5 그리고 언어 버전은 2.7이에요.
- 92. 파이썬 2.7 •파이썬 2마지막 마이너 버전 •신기능 패치 중단, 버그/보안 패치는 유지 •2013년엔 라이브러리 호환성이 가장 좋았음. 파이썬 2는 3와 완전히 호환되진 않는데
- 93. 파이썬 2.7 •파이썬 2마지막 마이너 버전 •신기능 패치 중단, 버그/보안 패치는 유지 •2013년엔 라이브러리 호환성이 가장 좋았음. 2.7은 그런 파이썬 2 중에서 마지막 버전이죠.
- 94. 파이썬 2.7 •파이썬 2마지막 마이너 버전 •신기능 패치 중단, 버그/보안 패치는 유지 •2013년엔 라이브러리 호환성이 가장 좋았음. 파이썬 언어 개발자들은 지금 3에 주력하고 있어서
- 95. 파이썬 2.7 •파이썬 2마지막 마이너 버전 •신기능 패치 중단, 버그/보안 패치는 유지 •2013년엔 라이브러리 호환성이 가장 좋았음. 3에서 이룬 수 많은 개선점을 2에는 제공해주지 않고
- 96. 파이썬 2.7 •파이썬 2마지막 마이너 버전 •신기능 패치 중단, 버그/보안 패치는 유지 •2013년엔 라이브러리 호환성이 가장 좋았음. 버그픽스와 보안패치 정도만 해주고 있습니다.
- 97. 파이썬 2.7 •파이썬 2마지막 마이너 버전 •신기능 패치 중단, 버그/보안 패치는 유지 •2013년엔 라이브러리 호환성이 가장 좋았음. 그래서 지금은 굳이 2를 쓸 이유가 없지만
- 98. 파이썬 2.7 •파이썬 2마지막 마이너 버전 •신기능 패치 중단, 버그/보안 패치는 유지 •2013년엔 라이브러리 호환성이 가장 좋았음. 저희가 서버를 만들기 시작한 2013년에만 해도
- 99. 파이썬 2.7 •파이썬 2마지막 마이너 버전 •신기능 패치 중단, 버그/보안 패치는 유지 •2013년엔 라이브러리 호환성이 가장 좋았음. 3를 지원하는 써드파티 라이브러리가 그렇게 많지 않아서 2.7을 선택했었는데
- 100. 파이썬 2.7 •파이썬 2마지막 마이너 버전 •신기능 패치 중단, 버그/보안 패치는 유지 •2013년엔 라이브러리 호환성이 가장 좋았음. 몇 년 새 상황이 많이 달라졌더라고요.
- 101. 파이썬 2.7 •파이썬 2마지막 마이너 버전 •신기능 패치 중단, 버그/보안 패치는 유지 •2013년엔 라이브러리 호환성이 가장 좋았음. 요즘은 써드파티 라이브러리도 어지간해선 3를 지원해요.
- 102. 파이썬 2.7 •파이썬 2마지막 마이너 버전 •신기능 패치 중단, 버그/보안 패치는 유지 •2013년엔 라이브러리 호환성이 가장 좋았음. 저희도 넘어가고 싶지만
- 103. 파이썬 2.7 •파이썬 2마지막 마이너 버전 •신기능 패치 중단, 버그/보안 패치는 유지 •2013년엔 라이브러리 호환성이 가장 좋았음. 이미 2에 맞춰서 짠 코드가 많아서 쉽게 넘어가진 못 하고 있습니다.
- 104. 파이썬 3? •명확한 문자열/바이트열구분 •정돈되고 강해진 표준 라이브러리 •특히 asyncio, typing 파이썬 3를 2와 비교해보면 우선 문자열과 바이트열 구분이 명확해져서
- 105. 파이썬 3? •명확한 문자열/바이트열구분 •정돈되고 강해진 표준 라이브러리 •특히 asyncio, typing 둘이 섞어 써서 인코딩 오류가 나는 참사는 발생하지 않아요.
- 106. 파이썬 3? •명확한 문자열/바이트열구분 •정돈되고 강해진 표준 라이브러리 •특히 asyncio, typing 또 기존에 있던 표준 라이브러리는 깔끔하게 정돈됐고
- 107. 파이썬 3? •명확한 문자열/바이트열구분 •정돈되고 강해진 표준 라이브러리 •특히 asyncio, typing 다만 이 과정에서 하위호환성이 많이 깨졌죠.
- 108. 파이썬 3? •명확한 문자열/바이트열구분 •정돈되고 강해진 표준 라이브러리 •특히 asyncio, typing 또 새로운 표준 라이브러리도 여러가지 생겼는데
- 109. 파이썬 3? •명확한 문자열/바이트열구분 •정돈되고 강해진 표준 라이브러리 •특히 asyncio, typing 특히 비동기 I/O 라이브러리인 asyncio나
- 110. 파이썬 3? •명확한 문자열/바이트열구분 •정돈되고 강해진 표준 라이브러리 •특히 asyncio, typing 파이썬에서 정적 타입힌트를 달 수 있게 해주는 typing 같은 게
- 111. 파이썬 3? •명확한 문자열/바이트열구분 •정돈되고 강해진 표준 라이브러리 •특히 asyncio, typing 아주 탐나더라고요. 못 써서 아쉽습니다.
- 112. from __future__ importunicode_literals import six 아쉬운 대로 저희는 다음 파이썬 버전의 특성 중 일부를 차용할 수 있게 해주는
- 113. from __future__ importunicode_literals import six __future__ 모듈로 3의 특성 중 유용한 몇 가지를 가져와서 쓰고 있어요.
- 114. from __future__ importunicode_literals import six 한편 저희 내부 코드가 아닌 외부에 공개할 오픈소스 라이브러리를 만들 땐
- 115. from __future__ importunicode_literals import six 같은 코드로 파이썬 2와 3를 함께 지원하기 위해서
- 116. from __future__ importunicode_literals import six six라는 라이브러리로 호환성을 갖추고 있어요.
- 117. from __future__ importunicode_literals import six＝6＝2×3 여기서 six는 2 곱하기 3을 뜻한다네요.
- 118. PyPy? 파이썬으로 만든 파이썬인터프리터 공식 구현체인 CPython 말고
- 119. PyPy? 파이썬으로 만든 파이썬인터프리터 파이썬으로 만든 파이썬 인터프리터인 PyPy도 추천합니다.
- 120. PyPy? 파이썬으로 만든 파이썬인터프리터 PyPy는 JavaScript의 V8 처럼 파이썬 코드를 JIT 컴파일 해주는데요
- 121. PyPy ＞ CPython 7.5x 여기서내세우는 비교자료를 보면 CPython보다 7.5배 정도 빠르다고 합니다.
- 122. PyPy ＞ CPython 7.5x 다만C로 구현된 라이브러리 같은 경우는 호환되지 않을 때도 종종 있어서
- 123. PyPy ＞ CPython 7.5x 저희는아직 채택하지 못 했어요.
- 124. 파이썬 3나 PyPy 저희는파이썬 2.7과 CPython 둘 다 벗어나지 못 했지만
- 125. 파이썬 3나 PyPy 그래도언젠가는 파이썬 3나 PyPy로 넘어가고자 합니다.
- 126. 파이썬 3나 PyPy 여러분이만약 새 프로젝트를 시작하신다면 저희보다 나은 선택을 하시길 바랄게요.
- 127.
- 128.
- 129. gevent 코루틴 기반 비동기I/O 저흰 gevent라는 코루틴 기반 비동기 I/O 라이브러리를 쓰고 있습니다.
- 130. greenlet 코루틴 http://lee-seungjae.github.io/greenlet.html ― 이승재,2011 원래 파이썬엔 코루틴이 없지만 greenlet이라는 라이브러리가
- 131. greenlet 코루틴 파이썬을 마개조해서 코루틴을 쓸수 있게 해줬어요. http://lee-seungjae.github.io/greenlet.html ― 이승재, 2011
- 132. greenlet 코루틴 이 라이브러리는 PyPy 만든Armin Rigo와 http://lee-seungjae.github.io/greenlet.html ― 이승재, 2011
- 133. greenlet 코루틴 Stackless Python 만든 ChristianTismer의 합작이에요. http://lee-seungjae.github.io/greenlet.html ― 이승재, 2011
- 134. greenlet 코루틴 아래 링크는 예전에 데브캣스튜디오이승재 님께서 http://lee-seungjae.github.io/greenlet.html ― 이승재, 2011
- 135. greenlet 코루틴 greenlet에 대해 쓰셨던글인데 기억에 남아서 한 번 가져와봤습니다. http://lee-seungjae.github.io/greenlet.html ― 이승재, 2011
- 136. g1 = gevent.spawn(requests.get,url1) g2 = gevent.spawn(requests.get, url2) g3 = gevent.spawn(requests.get, url3) gevent.joinall([g1, g2, g3]) print([g.value for g in [g1, g2, g3]]) 코루틴을 직접 다루는 건 굉장히 까다로워요.
- 137. g1 = gevent.spawn(requests.get,url1) g2 = gevent.spawn(requests.get, url2) g3 = gevent.spawn(requests.get, url3) gevent.joinall([g1, g2, g3]) print([g.value for g in [g1, g2, g3]]) gevent는 다루기 까다로운 greenlet 코루틴을
- 138. g1 = gevent.spawn(requests.get,url1) g2 = gevent.spawn(requests.get, url2) g3 = gevent.spawn(requests.get, url3) gevent.joinall([g1, g2, g3]) print([g.value for g in [g1, g2, g3]]) 평범한 멀티스레딩 코드처럼 쓸 수 있게 해주죠.
- 139. g1 = gevent.spawn(requests.get,url1) g2 = gevent.spawn(requests.get, url2) g3 = gevent.spawn(requests.get, url3) gevent.joinall([g1, g2, g3]) print([g.value for g in [g1, g2, g3]]) 특정한 일을 하는 스레드를 띄우고
- 140. g1 = gevent.spawn(requests.get,url1) g2 = gevent.spawn(requests.get, url2) g3 = gevent.spawn(requests.get, url3) gevent.joinall([g1, g2, g3]) print([g.value for g in [g1, g2, g3]]) 다른 스레드가 일을 다 할 때까지 기다려서 동기화 하는 식이에요.
- 141. g1 = gevent.spawn(requests.get,url1) g2 = gevent.spawn(requests.get, url2) g3 = gevent.spawn(requests.get, url3) gevent.joinall([g1, g2, g3]) print([g.value for g in [g1, g2, g3]]) 평범하죠?
- 142. Greenlet Thread gevent 스레드는 방금 얘기한라이브러리 이름과 같은
- 143.
- 144.
- 145.
- 146.
- 147. Greenlet Thread 특히 네트워크를 많이다룰 때 높은 동시성을 얻을 수 있죠.
- 148. if key inGLOBAL_DICT: gevent.sleep(0.001) del GLOBAL_DICT[key] 쓰는 법이 멀티스레딩과 다르지 않다 보니 코딩할 때 고달플 때도 있어요.
- 149. if key inGLOBAL_DICT: gevent.sleep(0.001) del GLOBAL_DICT[key] 이렇게 첫 줄에서 아무리 조건을 확보해 놔도
- 150. if key inGLOBAL_DICT: gevent.sleep(0.001) del GLOBAL_DICT[key] 스레드 봉쇄가 발생한 이후에는
- 151. if key inGLOBAL_DICT: gevent.sleep(0.001) del GLOBAL_DICT[key] KeyError! 조건이 무효해질 수 있거든요.
- 152. if key inGLOBAL_DICT: gevent.sleep(0.001) del GLOBAL_DICT[key] KeyError! 그럼에도 저희가 gevent를 택했던 이유는
- 153.
- 154. import gevent.monkey gevent.monkey.patch_all() 표준 라이브러리를비롯한 수 많은 라이브러리를
- 155. import gevent.monkey gevent.monkey.patch_all() 모두 그대로쓸 수 있다는 점 때문이었어요.
- 156.
- 157.
- 158.
- 159. import gevent.monkey gevent.monkey.patch_all() 비동기 I/O를고려하지 않던 기존 코드까지도 모두 동시에 실행할 수 있게 되거든요.
- 160. import gevent.monkey gevent.monkey.patch_all() JavaScript처럼 콜백을등록한다거나 C#처럼 async, await 키워드를 쓴다거나
- 161. import gevent.monkey gevent.monkey.patch_all() 그런 특별한코딩법을 필요로 하는 다른 동시성 모델로는
- 162.
- 163. 동시성 (Concurrency) 병렬성 (Parallelism) 단gevent로 확보할 수 있는 건 동시성이지 병렬성은 아닌데
- 164. 동시성 (Concurrency) 병렬성 (Parallelism) 수많은 I/O를 동시에 수행할 순 있지만 실제로는 싱글스레디드로 돌아서
- 165. 동시성 (Concurrency) 병렬성 (Parallelism) 여러CPU 코어를 활용할 순 없어요.
- 166. GIL 사실 이 점은파이썬 표준 멀티스레딩도 마찬가지입니다.
- 167. GIL 파이썬엔 역사적인 이유로 GlobalInterpreter Lock이란 게 있는데
- 168. GIL 이 때문에 파이썬바이트코드는 동시에 여러 스레드에서 실행될 수 없거든요.
- 169. +멀티프로세싱 그래서 저희는 부족한병렬성을 보완하기 위해 멀티프로세싱도 같이 쓰고 있습니다.
- 170. def hang(): while True: pass gevent.spawn(hang) 표준멀티스레딩과 달리 gevent를 쓸 땐 주의해야 할 점이 있는데요
- 171. def hang(): while True: pass gevent.spawn(hang) 선점형멀티태스킹이 아니다 보니 한 스레드가 쉴 새 없이 돌면
- 172. def hang(): while True: pass gevent.spawn(hang) 다른스레드로는 기회가 넘어가지 않는다는 거예요.
- 173. def hang(): while True: pass gevent.spawn(hang) 특히게임서버에서는 이런 일이 절대 생기면 안 되겠죠.
- 174. def hang(): while True: gevent.idle() gevent.spawn(hang) 꼭sleep이나 idle이라도 넣어서
- 175. def hang(): while True: gevent.idle() gevent.spawn(hang) 스레드가잠시나마 봉쇄되게끔 만들어야 이런 일을 방지할 수 있어요.
- 176. asyncio? 파이썬 3.4~ 한편 파이썬3.4부터는 asyncio라는
- 177. asyncio? 파이썬 3.4~ 차세대 비동기I/O 라이브러리를 쓸 수 있는데
- 178. @asyncio.coroutine def main(): f1 =aiohttp.get(url1) f2 = aiohttp.get(url2) f3 = aiohttp.get(url3) for fut in [f1, f2, f3]: yield from fut print([fut.result() for fut in [f1, f2, f3]]) 파이썬의 언어 기능인 제너레이터를 이용해서 명시적인 코루틴을 구현하고 있어요.
- 179. @asyncio.coroutine def main(): f1 =aiohttp.get(url1) f2 = aiohttp.get(url2) f3 = aiohttp.get(url3) for fut in [f1, f2, f3]: yield from fut print([fut.result() for fut in [f1, f2, f3]]) gevent와 다르게 코드만 봐도 어디서 봉쇄가 발생할지 명확하게 보이죠.
- 180. async def main(): f1= aiohttp.get(url1) f2 = aiohttp.get(url2) f3 = aiohttp.get(url3) for fut in [f1, f2, f3]: await fut print([fut.result() for fut in [f1, f2, f3]]) 파이썬 3.5에서는 아예 C#처럼 async와 await 키워드까지 추가돼서
- 181. async def main(): f1= aiohttp.get(url1) f2 = aiohttp.get(url2) f3 = aiohttp.get(url3) for fut in [f1, f2, f3]: await fut print([fut.result() for fut in [f1, f2, f3]]) 더 편하게 쓸 수 있게 됐어요.
- 182. async def main(): f1= aiohttp.get(url1) f2 = aiohttp.get(url2) f3 = aiohttp.get(url3) for fut in [f1, f2, f3]: await fut print([fut.result() for fut in [f1, f2, f3]]) 다만 asyncio를 쓰면
- 183. async def main(): f1= aiohttp.get(url1) f2 = aiohttp.get(url2) f3 = aiohttp.get(url3) for fut in [f1, f2, f3]: await fut print([fut.result() for fut in [f1, f2, f3]]) asyncio에 맞춰진 라이브러리만 써야해서 선택의 폭이 좁아지긴 해요.
- 184. aiobotocore, aiohttp, aiokafka, aiomcache,aiomysql, aioredis, aiorwlock, aiozmq 그래도 보통 이름에 “aio”라는 접두사가 붙어있으니까 쉽게 구별할 순 있을 겁니다.
- 185. •멀티프로세싱 •멀티스레딩 •asyncio •gevent •eventlet •Twisted 제가 소개한 것외에도 파이썬에선 여러가지 방법으로 동시성을 확보할 수 있어요.
- 186.
- 187.
- 188. •멀티프로세싱 •멀티스레딩 •asyncio •gevent •eventlet •Twisted 이런 방법들을 한번 비교해보고 가장 적합한 걸 고르시면 좋을 것 같습니다.
- 189.
- 190. 웹 서버 저희 게임서버는대부분이 소켓을 직접 다루는 데디케이티드 서버지만
- 191. 웹 서버 일부는 RESTful한웹 서버로 돼있어요.
- 192. Flask 거기엔 앞에서도 소개했던Flask라는 간단한 웹 서버 프레임워크를 쓰는데
- 193. •Werkzeug 웹 서버유틸리티 •Jinja2 템플릿 엔진 Flask는 Werkzeug라는 웹 서버 유틸리티와
- 194. •Werkzeug 웹 서버유틸리티 •Jinja2 템플릿 엔진 Jinja2라고, 보통 HTML 페이지 찍어낼 때 쓰는 템플릿엔진 위에서
- 195. •템플릿 엔진 •URL 라우팅 •세션 •서브도메인 •JSON지원 •디버깅 콘솔 몇 가지 편의 기능을 함께 제공하는 작은 웹 서버 프레임워크예요.
- 196. •템플릿 엔진 •URL 라우팅 •세션 •서브도메인 •JSON지원 •디버깅 콘솔 작은 프레임워크이긴 하지만
- 197. •템플릿 엔진 •URL 라우팅 •세션 •서브도메인 •JSON지원 •디버깅 콘솔 일반적으로 웹 개발할 때 필요한 간단한 기능들은 대부분 갖추고 있고
- 198. •템플릿 엔진 •URL 라우팅 •세션 •서브도메인 •JSON지원 •디버깅 콘솔 좀 더 복잡한 기능도 플러그인으로 쉽게 구할 수 있어요.
- 199. app = Flask(__name__) @app.route('/') defindex(): return 'Hello, world', 200 간단한 Flask 예제예요.
- 200. app = Flask(__name__) @app.route('/') defindex(): return 'Hello, world', 200 데코레이터를 이용해서 URL 라우팅 테이블을 직관적으로 만들어내는 게 특징이죠.
- 201. #include "crow.h" int main(){ crow::SimpleApp app; CROW_ROUTE(app, "/")([](){ return "Hello world"; }); } 우리 회사 하재승 님이 만드신
- 202. #include "crow.h" int main(){ crow::SimpleApp app; CROW_ROUTE(app, "/")([](){ return "Hello world"; }); } C++ 웹 프레임워크 Crow가 여기서 영감을 얻었다고 합니다.
- 203. WSGI Web Server GatewayInterface 파이썬엔 WSGI라는 표준화된 웹 애플리케이션 인터페이스가 있어요.
- 204. WSGI Web Server GatewayInterface Flask를 비롯해 아마도 모든 파이썬 웹 서버 라이브러리가
- 205. WSGI Web Server GatewayInterface 이 인터페이스를 따르고 있을 거예요.
- 206. app = Flask(__name__) server= gevent.pywsgi.WSGIServer(socket, app) server.serve_forever() 이 표준 인터페이스 덕분에 Flask를 gevent에도 잘 붙일 수 있었어요.
- 207. app = Flask(__name__) server= gevent.pywsgi.WSGIServer(socket, app) server.serve_forever() gevent엔 고성능 WSGI 서버가 들어있는데
- 208. app = Flask(__name__) server= gevent.pywsgi.WSGIServer(socket, app) server.serve_forever() 이것으로 Flask 웹 서버를 바로 서빙할 수 있는 거죠.
- 209. def wsgi_app(environ, start_response): headers= [('Content-Type', 'text/plain')] start_response('200 OK', headers) yield 'Hello, worldn' WSGI 애플리케이션은 단순히
- 210. def wsgi_app(environ, start_response): headers= [('Content-Type', 'text/plain')] start_response('200 OK', headers) yield 'Hello, worldn' HTTP 요청정보를 담는 environ 인자와
- 211. def wsgi_app(environ, start_response): headers= [('Content-Type', 'text/plain')] start_response('200 OK', headers) yield 'Hello, worldn' HTTP 응답시작을 개시하는 함수인 start_response 인자를 받아서
- 212. def wsgi_app(environ, start_response): headers= [('Content-Type', 'text/plain')] start_response('200 OK', headers) yield 'Hello, worldn' 응답 헤더를 결정한 후 start_response를 불러주고
- 213. def wsgi_app(environ, start_response): headers= [('Content-Type', 'text/plain')] start_response('200 OK', headers) yield 'Hello, worldn' 내용을 브러우저로 스트리밍할 수 있게끔 yield하거나
- 214. def wsgi_app(environ, start_response): headers= [('Content-Type', 'text/plain')] start_response('200 OK', headers) return ['Hello, worldn'] 시퀀스 형태로 바로 return하는 함수예요.
- 215. def wsgi_app(environ, start_response): headers= [('Content-Type', 'text/plain')] start_response('200 OK', headers) return ['Hello, worldn'] 이 인터페이스에만 맞추면 파이썬의 거의 모든 웹 도구를 같이 쓸 수 있어요.
- 216. def wsgi_app(environ, start_response): headers= [('Content-Type', 'text/plain')] start_response('200 OK', headers) return ['Hello, worldn'] 하지만 생긴 걸 보면 알 수 있듯이
- 217. HTTP/2.0, WebSocket 아쉽게도 서버사이드푸시 같은 HTTP/2.0 기능이나
- 218. HTTP/2.0, WebSocket 웹소켓 같은요즘 프로토콜을 구현하진 못해요.
- 219.
- 220. HTTP/2.0, WebSocket 언젠가 차세대WSGI가 나오길 기대해봅니다.
- 221. Django? 파이썬 웹 프레임워크중에선 저는 안 써봤지만
- 222.
- 223. Django Flask 구글 트렌드에서 찾아보니까 인기도가Flask의 4배 정도는 되더라고요.
- 224. Instagram과 Pinterest가 Django 쓰는것으로 유명하다고 합니다.
- 225. • ORM • 템플릿엔진 • URL 라우팅 • 폼 검증 • 캐싱 • 국제화 • XML/JSON 지원 Django는 MVC 구조를 내장하고 있어요.
- 226. • ORM • 템플릿엔진 • URL 라우팅 • 폼 검증 • 캐싱 • 국제화 • XML/JSON 지원 그래서 Flask와 달리 ORM까지 포함하고 있죠.
- 227. • ORM • 템플릿엔진 • URL 라우팅 • 폼 검증 • 캐싱 • 국제화 • XML/JSON 지원 그 밖에도 통합돼있는 기능이 매우 많은데
- 228. • ORM • 템플릿엔진 • URL 라우팅 • 폼 검증 • 캐싱 • 국제화 • XML/JSON 지원 아마 2000년대 후반에 유행했던 Ruby on Rails랑 비슷하지 않을까 싶어요.
- 229. •WSGI •Flask •Django 혹시 파이썬으로 웹서버를 만들려는 분이 계신다면
- 230. •WSGI •Flask •Django 이 두 프레임워크와 WSGI지원하는 도구를 한 번 검토해보세요.
- 231.
- 232. 터미널 앱 저희는 서버개발을 보조하기 위해서
- 233. 터미널 앱 터미널에서 쓸수 있는 도구도 많이 만들고 있어요.
- 234. Click CLI 프레임워크 Click은 CLI를쉽게, 또 잘 만들 수 있게 해주는 프레임워크예요.
- 235. Click CLI 프레임워크 앞에서 소개했던Flask와 이것은 모두 Armin Ronacher가 만들었죠.
- 236. import click @click.command() @click.option('-n', '--name',help='Your name.') def cli(name): click.echo('Hi %s!' % (name or 'NONAME')) if __name__ == '__main__': cli() Click 애플리케이션 코드는 이렇게 생겼는데
- 237. import click @click.command() @click.option('-n', '--name',help='Your name.') def cli(name): click.echo('Hi %s!' % (name or 'NONAME')) if __name__ == '__main__': cli() Flask처럼 데코레이터를 적극적으로 활용하고 있어요.
- 238. import click @click.command() @click.option('-n', '--name',help='Your name.') def cli(name): click.echo('Hi %s!' % (name or 'NONAME')) if __name__ == '__main__': cli() 이렇게 데코레이터로 커맨드 옵션을 선언하면
- 239. import click @click.command() @click.option('-n', '--name',help='Your name.') def cli(name): click.echo('Hi %s!' % (name or 'NONAME')) if __name__ == '__main__': cli() 같은 이름의 매개변수로 값이 들어오게 돼요.
- 240. ❯ python cli.py-n "Heungsub Lee" Hi Heungsub Lee! ❯ python cli.py --help Usage: cli.py [OPTIONS] Options: -n, --name TEXT Your name. --help Show this message and exit. 돌려보면 이렇게 동작합니다.
- 241. ❯ python cli.py-n "Heungsub Lee" Hi Heungsub Lee! ❯ python cli.py --help Usage: cli.py [OPTIONS] Options: -n, --name TEXT Your name. --help Show this message and exit. 보시다시피 리눅스 CLI를 상식적으로 잘 구현하고 있다는 점에서
- 242. ❯ python cli.py-n "Heungsub Lee" Hi Heungsub Lee! ❯ python cli.py --help Usage: cli.py [OPTIONS] Options: -n, --name TEXT Your name. --help Show this message and exit. 애용하는 프레임워크예요.
- 243. ❯ python cli.py-n "Heungsub Lee" Hi Heungsub Lee! ❯ python cli.py --help Usage: cli.py [OPTIONS] Options: -n, --name TEXT Your name. --help Show this message and exit. 상식과 미묘하게 다르게 동작하는 프레임워크도 여럿 봐왔거든요.
- 244.
- 245. 프로그레스바를 띄우는 것도쉽게 할 수 있고 색깔도 깔끔하게 다룰 수 있어요.
- 246. argparse? Click이 나오기 전에는 argparse라는표준 라이브러리를 썼었는데
- 247. import argparse parser =argparse.ArgumentParser() parser.add_argument('-n', '--name', help='Your name.') def cli(name): print('Hi %s!' % (name or 'NONAME')) if __name__ == '__main__': args = parser.parse_args() cli(name=args.name) 이렇게
- 248. import argparse parser =argparse.ArgumentParser() parser.add_argument('-n', '--name', help='Your name.') def cli(name): print('Hi %s!' % (name or 'NONAME')) if __name__ == '__main__': args = parser.parse_args() cli(name=args.name) 옵션을 정의하는 곳과
- 249. import argparse parser =argparse.ArgumentParser() parser.add_argument('-n', '--name', help='Your name.') def cli(name): print('Hi %s!' % (name or 'NONAME')) if __name__ == '__main__': args = parser.parse_args() cli(name=args.name) 파싱하고 넘겨주는 곳이 따로 떨어져 있어서
- 250. import argparse parser =argparse.ArgumentParser() parser.add_argument('-n', '--name', help='Your name.') def cli(name): print('Hi %s!' % (name or 'NONAME')) if __name__ == '__main__': args = parser.parse_args() cli(name=args.name) Click에 비해 불편했습니다.
- 251. Urwid TUI 프레임워크 단순한 CLI말고 리눅스의 top이나 aptitude 같이
- 252. Urwid TUI 프레임워크 텍스트로 된UI를 만들고 싶을 땐 Urwid라는 TUI 프레임워크를 쓰고 있어요.
- 253. Urwid를 쓰면 위젯을조합하는 방식으로 꽤 미려한 텍스트 UI를 만들 수 있죠.
- 254. https://excess.org/article/2012/01/urwid-python-malaysia/ 이건 Urwid로 만든Speedometer라는 건데 멋지지 않나요?
- 255. https://excess.org/article/2012/01/urwid-python-malaysia/ 저희 스튜디오에서 만든 파이썬용 프로파일러에도 Urwid를 사용했는데
- 256. https://excess.org/article/2012/01/urwid-python-malaysia/ 그건 뒤에서 성능측정에 대해 얘기할 때 보여드릴게요.
- 257. curses? Urwid 말고는 curses라는 표준라이브러리가 대안이 될 수 있어요.
- 258. curses? 하지만 저는 정말쓰기 불편했어요.
- 259. curses? API가 너무 저수준이고 조금만실수해도 에러가 빵빵 터졌었거든요.
- 260. win.addstr(y, x, 'Hello,world') 심지어 사용하는 좌표계도
- 261. win.addstr(y, x, 'Hello,world') x, y가 아니라 y, x예요.
- 262. win.addstr(y, x, 'Hello,world') “curse”가 “저주”란 뜻이잖아요? 그 이름값을 하는 거라고 생각합니다.
- 263. •Click •Urwid •argparse •curses 혹시 bash 같은쉘 스크립트를 대신하기 위해서 파이썬을 검토 중이시라면
- 264.
- 265.
- 266.
- 267. 빌드와 배포 저희는 빌드와배포를 자동화하는 데에도 노력을 많이 기울여왔어요.
- 268. 빌드와 배포 여기에도 파이썬을많이 쓰고 있죠.
- 269. build passing 작업자가 Git저장소에 push하면 CI가 자동으로 빌드 스크립트를 돌리면서
- 270. build passing 컴파일해야 할건 컴파일하고, 코드 품질을 검사한다든가,
- 271. build passing 유닛테스트를 돌린다든가, 뭐그런 일을 합니다.
- 272. build passing 빌드에 성공하면브랜치에 따라서 서버에 배포하는 것까지 연계하고 있어요.
- 273.
- 274. def test_answer(): assert answer()== 42 pytest를 쓰면 딸랑 assert 문만 적어놔도
- 275. ❯ pytest test.py =========FAILURES ========= E assert 24 == 42 E + where 24 = answer() def test_answer(): assert answer() == 42 테스트가 실패했을 때 왜 실패했는지 단서까지 함께 보고받을 수 있어요.
- 276. ❯ pytest test.py =========FAILURES ========= E assert 24 == 42 E + where 24 = answer() def test_answer(): assert answer() == 42 여기 보시면 answer의 결과값이 42가 아니라 24였다는 걸 알 수 있죠.
- 277. def test_answer(self): self.assertEqual(answer(), 42) unittest 파이썬엔unittest라는 표준 유닛테스트 프레임워크도 있지만
- 278. def test_answer(self): self.assertEqual(answer(), 42) unittest 이것으로같은 결과를 얻으려면 assertEqual 같은 전용 메소드를 써야만 해요.
- 279. assertEqual(a, b) assertNotEqual(a, b) assertIs(a,b) assertIn(a, b) assertGreater(a, b) unittest assert a == b assert a != b assert a is b assert a in b assert a > b pytest 이런 식으로 비교연산 별로 메소드가 따로 마련돼있죠.
- 280. assertEqual(a, b) assertNotEqual(a, b) assertIs(a,b) assertIn(a, b) assertGreater(a, b) unittest assert a == b assert a != b assert a is b assert a in b assert a > b pytest 훨씬 쓰기 번거로워 보이죠?
- 281. assertEqual(a, b) assertNotEqual(a, b) assertIs(a,b) assertIn(a, b) assertGreater(a, b) unittest assert a == b assert a != b assert a is b assert a in b assert a > b pytest 사실 처음에 제가 pytest를 쓰기 시작했던 이유는 이 점이 전부였는데
- 282. assertEqual(a, b) assertNotEqual(a, b) assertIs(a,b) assertIn(a, b) assertGreater(a, b) unittest assert a == b assert a != b assert a is b assert a in b assert a > b pytest 쓰다 보니까 테스트 만드는 수고를 덜어주는 편의 기능도 많다는 걸 알게 됐어요.
- 283. @pytest.mark.parametrize('x, y', [ (42,1), (21, 2), (7, 6) ]) def test_answers(x, y): assert x * y == 42 가령 테스트케이스에 매개변수를 선언해놓고 parametrize 데코레이터를 붙여놓으면
- 284. @pytest.mark.parametrize('x, y', [ (42,1), (21, 2), (7, 6) ]) def test_answers(x, y): assert x * y == 42 알아서 인자를 바꿔가면서 테스트해주고
- 285. @pytest.fixture def db(request): db =Database() request.addfinalizer(db.close) return db def test_db(db): db.insert('answer', 42) assert db.get('answer') == 42 “픽스처”란 테스트에서 쓰이는 상태가 일관적인 재료를 말하는데
- 286. @pytest.fixture def db(request): db =Database() request.addfinalizer(db.close) return db def test_db(db): db.insert('answer', 42) assert db.get('answer') == 42 이렇게 데코레이터로 픽스처를 정의해두면 매개변수 이름을 이용해서
- 287. @pytest.fixture def db(request): db =Database() request.addfinalizer(db.close) return db def test_db(db): db.insert('answer', 42) assert db.get('answer') == 42 어느 테스트 케이스에서든 쉽게 끌어다 쓸 수 있게 해줘요.
- 288. def test_answer_pid(monkeypatch): monkeypatch.setattr(time, 'time',answer) assert time.time() == 42 monkeypatch라는 픽스처도 기본으로 제공돼요.
- 289. def test_answer_pid(monkeypatch): monkeypatch.setattr(time, 'time',answer) assert time.time() == 42 이것을 쓰면 이 테스트에 한해서 다른 모듈의 기능 일부를 바꿔칠 수 있어요.
- 290. def test_answer_pid(monkeypatch): monkeypatch.setattr(time, 'time',answer) assert time.time() == 42 시간을 다루거나 외부 API를 쓰는 코드를 테스트할 때 굉장히 유용합니다.
- 291.
- 292. pytest-cov 그 중 pytest-cov를쓰면 줄 단위 테스트 커버리지를 구할 수 있어요.
- 293. ❯ pytest test.py--cov=durango ---------- coverage ---------- TOTAL 42 42 100% 테스트 돌릴 때
- 294. ❯ pytest test.py--cov=durango ---------- coverage ---------- TOTAL 42 42 100% 커버리지 측정할 모듈을 같이 적어주면
- 295. ❯ pytest test.py--cov=durango ---------- coverage ---------- TOTAL 42 42 100% 그 모듈에 총 몇 줄이 있고 유닛테스트가 그 중에서
- 296. ❯ pytest test.py--cov=durango ---------- coverage ---------- TOTAL 42 42 100% 얼마나 건드렸는지 정확하게 알 수 있죠.
- 297. coverage 71% 저희는 이방법으로 테스트 커버리지를 지속적으로 관리해왔고
- 298. coverage 71% 충분히 높은건 아니지만 약 71% 정도를 확보해둔 상태입니다.
- 299.
- 300. •pytest-rerunfailures •pytest-xdist 몇 번은 재시도할수 있게끔 해주는 pytest-rerunfailures란 게 있는데
- 301. •pytest-rerunfailures •pytest-xdist 보통 시간에 민감한테스트케이스는 미묘한 시간차로 실패할 때가 있거든요.
- 302.
- 303. •pytest-rerunfailures •pytest-xdist 또 테스트 케이스들을나눠서 여러 스레드나 머신에서 병렬적으로 돌려주는
- 304.
- 305.
- 306. Fabric 서버 소스코드가 빌드를통과하면 적당한 머신에 자동으로 배포되는데
- 307.
- 308. 빌드머신 원격 원격 원격 원격 원격 원격 원격 원격 원격 명령어 보통 여러 원격머신에 한 번에 명령어를 날리려면
- 309.
- 310. 빌드머신 원격 원격 원격 원격 원격 원격 원격 원격 원격 명령어를 SSH로 보통은 sshd가기본으로 깔려 있잖아요?
- 311. 빌드머신 원격 원격 원격 원격 원격 원격 원격 원격 원격 명령어를 SSH로 Fabric은 SSH를명령 채널로 써서 원격 머신에 추가적으로 아무것도 깔지 않아도
- 312.
- 313. @task def setup_durango(): if files.exists('durango'): run('cddurango') run('git pull') else: run('git clone %s durango' % git_url) run('cd durango') Fabric으로 날리는 명령어는 이렇게 파이썬 코드로 짜게 되는데
- 314. @task def setup_durango(): if files.exists('durango'): run('cddurango') run('git pull') else: run('git clone %s durango' % git_url) run('cd durango') 기본적으로는 파이썬 틀 안에 쉘 명령어를 직접 써넣는 방식이에요.
- 315. @task def setup_durango(): if files.exists('durango'): run('cddurango') run('git pull') else: run('git clone %s durango' % git_url) run('cd durango') 배포 스크립트들을 짜다 보면 꼭 이런 식으로
- 316. @task def setup_durango(): if files.exists('durango'): run('cddurango') run('git pull') else: run('git clone %s durango' % git_url) run('cd durango') 처음 돌린 건지 아닌지에 따라 분기를 나누는 패턴이 많이 나타나는데
- 317. @task def setup_durango(): if files.exists('durango'): run('cddurango') run('git pull') else: run('git clone %s durango' % git_url) run('cd durango') 저희는 이런 귀찮음을 해소해주는 도구도 쓰고 있어요.
- 318.
- 319. @task def setup_durango(): require.git.working_copy(git_url, 'durango',update=True) fabtools는 방금 본 것과 같은 각종 예외처리 분기를
- 320. @task def setup_durango(): require.git.working_copy(git_url, 'durango',update=True) 무엇무엇이 필요하다는 형태로 추상화 해줘요.
- 321. @task def setup_durango(): require.git.working_copy(git_url, 'durango',update=True) 이 코드는 원격 머신이 어떤 상황이든 간에
- 322. @task def setup_durango(): require.git.working_copy(git_url, 'durango',update=True) Git 저장소가 필요하니 알아서 만들어 달라는 뜻이에요.
- 323. @task def setup_durango(): require.git.working_copy(git_url, 'durango',update=True) fabtools 덕분에 절차적이던 저희 배포 스크립트를
- 324. @task def setup_durango(): require.git.working_copy(git_url, 'durango',update=True) 선언적으로 만들 수 있게 됐죠.
- 325. coverage 71%build passing 저희에게지속적인 빌드와 배포는
- 326. coverage 71%build passing 병합요청과코드리뷰, 그리고 QA 절차에 필수적이었어요.
- 327. coverage 71%build passing 제가소개한 도구들을 적당한 CI에서 이용하면
- 328. coverage 71%build passing 여러분의개발환경을 개선하는 데에도 도움이 될 것 같습니다.
- 329.
- 330. 컨벤션 통일 다른 모든언어와 마찬가지로
- 331. 컨벤션 통일 파이썬에서도 코딩컨벤션을 통일해두는 게
- 332. 컨벤션 통일 좋은 코드를짜기에도 좋고 나중에 유지보수 하기에도 편리해요.
- 333. PEP8 •4칸 소프트탭 •79칸 제한 •import순서 •snake_case, PascalCase 파이썬엔 표준 컨벤션이 있어요.
- 334. PEP8 •4칸 소프트탭 •79칸 제한 •import순서 •snake_case, PascalCase PEP8이라는 8번째 제안서에서 규정하고 있죠.
- 335. PEP8 •4칸 소프트탭 •79칸 제한 •import순서 •snake_case, PascalCase 하드탭 대신 4칸짜리 스페이스를 써야 한다든가
- 336. PEP8 •4칸 소프트탭 •79칸 제한 •import순서 •snake_case, PascalCase 코드의 최대 폭이 79칸을 넘지 말아야 한다든가
- 337. PEP8 •4칸 소프트탭 •79칸 제한 •import순서 •snake_case, PascalCase import문 종류에 따른 순서를 지켜야 한다든가
- 338. PEP8 •4칸 소프트탭 •79칸 제한 •import순서 •snake_case, PascalCase snake_case나 PascalCase 등을 용도에 맞춰서 써야 한다든가
- 339. PEP8 •4칸 소프트탭 •79칸 제한 •import순서 •snake_case, PascalCase 뭐 그런 식이에요.
- 340. PEP8 •4칸 소프트탭 •79칸 제한 •import순서 •snake_case, PascalCase 여기엔 아무리 파이썬에 익숙해져도
- 341. PEP8 •4칸 소프트탭 •79칸 제한 •import순서 •snake_case, PascalCase 손으로 일일이 맞추기는 어려운 규칙도 많아요.
- 342. Flake8 그래서 저희는 Flake8이라는 파이썬코드 품질 검사기를 쓰고 있어요.
- 343. ❯ flake8 bad.py bad.py:1:1:F401 'sys' imported but unused bad.py:2:1: F401 'os' imported but unused bad.py:7:6: E111 indentation is not a multiple of four 이런 식으로 어떤 코드가 컨벤션에 안 맞는지 아니면 잘못 쓰였는지
- 344. ❯ flake8 bad.py bad.py:1:1:F401 'sys' imported but unused bad.py:2:1: F401 'os' imported but unused bad.py:7:6: E111 indentation is not a multiple of four 코드를 읽어서 정적으로 분석해주는 단순한 Lint인데
- 345. ❯ flake8 bad.py bad.py:1:1:F401 'sys' imported but unused bad.py:2:1: F401 'os' imported but unused bad.py:7:6: E111 indentation is not a multiple of four 이걸 작업자 각자가 에디터에 연동해서 쓰기도 하고
- 346. ❯ flake8 bad.py bad.py:1:1:F401 'sys' imported but unused bad.py:2:1: F401 'os' imported but unused bad.py:7:6: E111 indentation is not a multiple of four CI에서 빌드 돌릴 때 같이 돌리기도 합니다.
- 347.
- 348.
- 349.
- 350. •flake8-import-order •flake8-print •flake8-commas 종류별 순서 뿐아니라 ABC 순 정렬까지도 맞춰주고
- 351.
- 352. •flake8-import-order •flake8-print •flake8-commas flake8-commas는 list나 dict등의 리터럴을 여러 줄에 걸쳐서 쓸 때
- 353.
- 354.
- 355.
- 356.
- 357. Vim+Syntastic|pymode 이렇게 에디터에서도 실수를 바로바로확인할 수 있어요.
- 358.
- 359. Emacs+Flycheck 저는 Vim파지만 저희스튜디오에 Emacs 쓰시는 분도 있는데
- 360. Emacs+Flycheck 그분은 같은 용도로 Flycheck라는걸 쓴다고 해요.
- 361. Emacs+Flycheck 마찬가지로 Flake8 결과를 에디터에서바로 볼 수 있어요.
- 362. • PEP8 • ThePocoo Style Guide PEP8은 파이썬 커뮤니티에선 절대적이라서
- 363. • PEP8 • ThePocoo Style Guide 특히 오픈소스 활동을 할 때는 반드시 지키는 게 좋아요.
- 364. • PEP8 • ThePocoo Style Guide 하지만 PEP8만으로는 간혹 모호한 경우도 있는데
- 365. • PEP8 • ThePocoo Style Guide 그래서 저희는 PEP8을 기반으로 좀 더 구체적이고 실용적인 규칙을 제시하는
- 366. • PEP8 • ThePocoo Style Guide Pocoo 스타일을 따르고 있습니다.
- 367.
- 368. REPL 저는 파이썬으로 코딩할때 REPL을 굉장히 많이 써요.
- 369.
- 370. REPL 터미널에서 인자 없이python 치면 나오는 대화형 인터프리터 콘솔 있잖아요?
- 371.
- 372. REPL 코드를 파일에 적어서 실행하는것도 물론 좋지만
- 373. REPL 문제를 탐색해나가는 REPL만의 방식에도매력이 있습니다.
- 374. ❯ python Python 2.7.11+(default, Apr 17 2016, 14:00:29) [GCC 5.3.1 20160413] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import os >>> os.getpid() 42 파이썬 기본 REPL은 다들 아실 테고
- 375. ❯ ipython Python 2.7.11+(default, Apr 17 2016, 14:00:29) Type "copyright", "credits" or "license" for more information. In [1]: import os In [2]: os.getpid() Out[2]: 42 IPython이라는 조금 더 스마트한 REPL도 있는데
- 376. ❯ ipython Python 2.7.11+(default, Apr 17 2016, 14:00:29) Type "copyright", "credits" or "license" for more information. In [1]: import os In [2]: os.getpid() Out[2]: 42 문법강조도 되고 자동완성도 되고 그 밖에도 다양한 편의기능이 들어있어요.
- 377. ❯ ipython Python 2.7.11+(default, Apr 17 2016, 14:00:29) Type "copyright", "credits" or "license" for more information. In [1]: import os In [2]: os.getpid() Out[2]: 42 이 IPython을 터미널 대신 웹에서도 쓸 수 있게 나온 게
- 378.
- 379. 중간중간 문서도 집어넣을수도 있고
- 380. 데이터를 터미널에서보다 훨씬 풍부하게시각화할 수 있어요.
- 381. 그래서 데이터 과학쪽에선 앞에서 소개했듯이
- 382. 탐색적 분석하는 데에 이것을많이 쓴다고 합니다.
- 383. >>> world_id =db.find_all(World.id)[0] >>> world = db.load(World, world_id) >>> islands = world.all_islands() >>> for island in islands: ... if 'Python' in island.name: ... break ... else: ... assert False, 'island not found' ... >>> lakes = island.find_lakes() >>> lake = lakes[42] >>> p = Player(id=1) >>> p.level = 0 >>> for item in INITIAL_ITEMS: ... p.inventory.add_item(item) ... >>> homes = island.find_homes() >>> p.home = homes[999] >>> p.move_to(lake) Player-1 moved to lake-42! 저희가 만드는 게 MMORPG라서 그런지
- 384. >>> world_id =db.find_all(World.id)[0] >>> world = db.load(World, world_id) >>> islands = world.all_islands() >>> for island in islands: ... if 'Python' in island.name: ... break ... else: ... assert False, 'island not found' ... >>> lakes = island.find_lakes() >>> lake = lakes[42] >>> p = Player(id=1) >>> p.level = 0 >>> for item in INITIAL_ITEMS: ... p.inventory.add_item(item) ... >>> homes = island.find_homes() >>> p.home = homes[999] >>> p.move_to(lake) Player-1 moved to lake-42! 간단한 게임플레이 테스트 시나리오 하나 짜려고 해도
- 385. >>> world_id =db.find_all(World.id)[0] >>> world = db.load(World, world_id) >>> islands = world.all_islands() >>> for island in islands: ... if 'Python' in island.name: ... break ... else: ... assert False, 'island not found' ... >>> lakes = island.find_lakes() >>> lake = lakes[42] >>> p = Player(id=1) >>> p.level = 0 >>> for item in INITIAL_ITEMS: ... p.inventory.add_item(item) ... >>> homes = island.find_homes() >>> p.home = homes[999] >>> p.move_to(lake) Player-1 moved to lake-42! 그 시나리오에 필요한 게임 세계를 구축하는데
- 386. >>> world_id =db.find_all(World.id)[0] >>> world = db.load(World, world_id) >>> islands = world.all_islands() >>> for island in islands: ... if 'Python' in island.name: ... break ... else: ... assert False, 'island not found' ... >>> lakes = island.find_lakes() >>> lake = lakes[42] >>> p = Player(id=1) >>> p.level = 0 >>> for item in INITIAL_ITEMS: ... p.inventory.add_item(item) ... >>> homes = island.find_homes() >>> p.home = homes[999] >>> p.move_to(lake) Player-1 moved to lake-42! 굉장히 깊은 의존성을 풀어야 하는 경우가 있어요.
- 387. >>> world_id =db.find_all(World.id)[0] >>> world = db.load(World, world_id) >>> islands = world.all_islands() >>> for island in islands: ... if 'Python' in island.name: ... break ... else: ... assert False, 'island not found' ... >>> lakes = island.find_lakes() >>> lake = lakes[42] >>> p = Player(id=1) >>> p.level = 0 >>> for item in INITIAL_ITEMS: ... p.inventory.add_item(item) ... >>> homes = island.find_homes() >>> p.home = homes[999] >>> p.move_to(lake) Player-1 moved to lake-42! 이 코드는 읽으라고 쓴 게 아니에요.
- 388. >>> world_id =db.find_all(World.id)[0] >>> world = db.load(World, world_id) >>> islands = world.all_islands() >>> for island in islands: ... if 'Python' in island.name: ... break ... else: ... assert False, 'island not found' ... >>> lakes = island.find_lakes() >>> lake = lakes[42] >>> p = Player(id=1) >>> p.level = 0 >>> for item in INITIAL_ITEMS: ... p.inventory.add_item(item) ... >>> homes = island.find_homes() >>> p.home = homes[999] >>> p.move_to(lake) Player-1 moved to lake-42! 여기서 테스트하고 싶은 건
- 389. >>> world_id =db.find_all(World.id)[0] >>> world = db.load(World, world_id) >>> islands = world.all_islands() >>> for island in islands: ... if 'Python' in island.name: ... break ... else: ... assert False, 'island not found' ... >>> lakes = island.find_lakes() >>> lake = lakes[42] >>> p = Player(id=1) >>> p.level = 0 >>> for item in INITIAL_ITEMS: ... p.inventory.add_item(item) ... >>> homes = island.find_homes() >>> p.home = homes[999] >>> p.move_to(lake) Player-1 moved to lake-42! 그저 플레이어를 호수 근처로 옮기는 것 뿐인데
- 390. >>> world_id =db.find_all(World.id)[0] >>> world = db.load(World, world_id) >>> islands = world.all_islands() >>> for island in islands: ... if 'Python' in island.name: ... break ... else: ... assert False, 'island not found' ... >>> lakes = island.find_lakes() >>> lake = lakes[42] >>> p = Player(id=1) >>> p.level = 0 >>> for item in INITIAL_ITEMS: ... p.inventory.add_item(item) ... >>> homes = island.find_homes() >>> p.home = homes[999] >>> p.move_to(lake) Player-1 moved to lake-42! 플레이어와 호수를 준비하려면
- 391. >>> world_id =db.find_all(World.id)[0] >>> world = db.load(World, world_id) >>> islands = world.all_islands() >>> for island in islands: ... if 'Python' in island.name: ... break ... else: ... assert False, 'island not found' ... >>> lakes = island.find_lakes() >>> lake = lakes[42] >>> p = Player(id=1) >>> p.level = 0 >>> for item in INITIAL_ITEMS: ... p.inventory.add_item(item) ... >>> homes = island.find_homes() >>> p.home = homes[999] >>> p.move_to(lake) Player-1 moved to lake-42! 앞쪽에 훨씬 복잡하고 많은 코드가 필요할 수 있다는 걸 보여드리고 싶었어요.
- 392. >>> world_id =db.find_all(World.id)[0] >>> world = db.load(World, world_id) >>> islands = world.all_islands() >>> for island in islands: ... if 'Python' in island.name: ... break ... else: ... assert False, 'island not found' ... >>> lakes = island.find_lakes() >>> lake = lakes[42] >>> p = Player(id=1) >>> p.level = 0 >>> for item in INITIAL_ITEMS: ... p.inventory.add_item(item) ... >>> homes = island.find_homes() >>> p.home = homes[999] >>> p.move_to(lake) Player-1 moved to lake-42! 게임서버에서는 게임 세계가 알아서 구축되잖아요?
- 393. >>> world_id =db.find_all(World.id)[0] >>> world = db.load(World, world_id) >>> islands = world.all_islands() >>> for island in islands: ... if 'Python' in island.name: ... break ... else: ... assert False, 'island not found' ... >>> lakes = island.find_lakes() >>> lake = lakes[42] >>> p = Player(id=1) >>> p.level = 0 >>> for item in INITIAL_ITEMS: ... p.inventory.add_item(item) ... >>> homes = island.find_homes() >>> p.home = homes[999] >>> p.move_to(lake) Player-1 moved to lake-42! 만약 서버를 직접 돌리는 방식으로만 테스트하게 되면
- 394. >>> world_id =db.find_all(World.id)[0] >>> world = db.load(World, world_id) >>> islands = world.all_islands() >>> for island in islands: ... if 'Python' in island.name: ... break ... else: ... assert False, 'island not found' ... >>> lakes = island.find_lakes() >>> lake = lakes[42] >>> p = Player(id=1) >>> p.level = 0 >>> for item in INITIAL_ITEMS: ... p.inventory.add_item(item) ... >>> homes = island.find_homes() >>> p.home = homes[999] >>> p.move_to(lake) Player-1 moved to lake-42! 이런 부분이 고달플 수 있다는 걸 잘 모르고 넘어갈 수 있어요.
- 395. >>> lake =find_lake('*/42') >>> p = make_player(1, mock=True) >>> p.move_to(lake) Player-1 moved to lake-42! >>> p.is_nearby(lake) True 하지만 REPL을 주로 쓰면 자연스레 귀찮고 반복적인 의존성 풀기를
- 396. >>> lake =find_lake('*/42') >>> p = make_player(1, mock=True) >>> p.move_to(lake) Player-1 moved to lake-42! >>> p.is_nearby(lake) True 최대한 쉽게 쓸 수 있게끔 추상화하게 되곤 합니다.
- 397. >>> lake =find_lake('*/42') >>> p = make_player(1, mock=True) >>> p.move_to(lake) Player-1 moved to lake-42! >>> p.is_nearby(lake) True 그래야 REPL에서 다시 쓰기 편하니까요.
- 398. >>> lake =find_lake('*/42') >>> p = make_player(1, mock=True) >>> p.move_to(lake) Player-1 moved to lake-42! >>> p.is_nearby(lake) True 이런 식으로 REPL에서 한 번 돌려본 명령어들을
- 399. def test_move_to(): lake =find_lake('*/42') p = make_player(1, mock=True) p.move_to(lake) assert p.is_nearby(lake) 복붙해서 테스트케이스로 구워 두면 두고두고 도움 될 거예요.
- 400. def test_move_to(): lake =find_lake('*/42') p = make_player(1, mock=True) p.move_to(lake) assert p.is_nearby(lake) 이렇듯 우리가 만드는 프로그램을 유저로서 테스트하는 데에 그치지 말고
- 401. def test_move_to(): lake =find_lake('*/42') p = make_player(1, mock=True) p.move_to(lake) assert p.is_nearby(lake) REPL을 주요 개발 도구 중 하나로 삼아서
- 402. def test_move_to(): lake =find_lake('*/42') p = make_player(1, mock=True) p.move_to(lake) assert p.is_nearby(lake) API를 직접, 그리고 또 자주 써보는 게
- 403. def test_move_to(): lake =find_lake('*/42') p = make_player(1, mock=True) p.move_to(lake) assert p.is_nearby(lake) API를 더 낫게 만드는 데 도움된다고 생각합니다.
- 404.
- 405. 디버깅 이번엔 파이썬 코드를 디버깅하는방법이에요.
- 406. Pdb 파이썬 표준 라이브러리엔Pdb라고 gdb 같은 콘솔 디버거가 들어있어요.
- 407. def hello_world(): hello ='world' pdb.set_trace() return hello 이렇게 코드 사이에서 pdb.set_trace()를 불러주면
- 408. def hello_world(): hello ='world' pdb.set_trace() return hello 다른 IDE에서 많이 보셨을 브레이크포인트가 걸려요.
- 409. > helloworld.py(7)hello_world() -> returnhello (Pdb) hello 'world' (Pdb) l 4 def hello_world(): 5 hello = 'world' 6 pdb.set_trace() 7 -> return hello 8 hello_world() [EOF] 실행 도중에 브레이크포인트에 걸리면 디버깅 콘솔이 뜨는데
- 410. > helloworld.py(7)hello_world() -> returnhello (Pdb) hello 'world' (Pdb) l 4 def hello_world(): 5 hello = 'world' 6 pdb.set_trace() 7 -> return hello 8 hello_world() [EOF] 보통의 IDE 디버거와 마찬가지로
- 411. > helloworld.py(7)hello_world() -> returnhello (Pdb) hello 'world' (Pdb) l 4 def hello_world(): 5 hello = 'world' 6 pdb.set_trace() 7 -> return hello 8 hello_world() [EOF] 변수 내용을 확인한다거나
- 412. > helloworld.py(7)hello_world() -> returnhello (Pdb) hello 'world' (Pdb) l 4 def hello_world(): 5 hello = 'world' 6 pdb.set_trace() 7 -> return hello 8 hello_world() [EOF] 실행중인 코드 위치를 확인한다거나
- 413. > helloworld.py(7)hello_world() -> returnhello (Pdb) hello 'world' (Pdb) l 4 def hello_world(): 5 hello = 'world' 6 pdb.set_trace() 7 -> return hello 8 hello_world() [EOF] 아니면 콜스택 위아래를 오간다거나 한 스텝씩 넘겨본다거나 할 수 있어요.
- 414. > helloworld.py(7)hello_world() -> returnhello (Pdb++) hello 'world' (Pdb++) l 4 def hello_world(): 5 hello = 'world' 6 pdb.set_trace() 7 -> return hello 8 hello_world() [EOF] pdb++ 확장을 깔면 문법강조도 볼 수 있죠.
- 415. >>> x =0 >>> x / x Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: ... >>> pdb.pm() > <stdin>(1)<module>() (Pdb) x 0 Pdb는 REPL에서 놀다가 에러 났을 때도 유용하게 쓸 수 있어요.
- 416. >>> x =0 >>> x / x Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: ... >>> pdb.pm() > <stdin>(1)<module>() (Pdb) x 0 pdb.pm(), “부검”을 뜻하는 “Post-mortem”의 약자죠.
- 417. >>> x =0 >>> x / x Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: ... >>> pdb.pm() > <stdin>(1)<module>() (Pdb) x 0 이것을 실행하면 마지막 에러가 발생했던 곳을 바로 디버깅할 수 있어요.
- 418. >>> x =0 >>> x / x Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: ... >>> pdb.pm() > <stdin>(1)<module>() (Pdb) x 0 저희 서버도 디버깅 용으로 돌리면 서버 실행 도중 pdb.pm()으로
- 419. >>> x =0 >>> x / x Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: ... >>> pdb.pm() > <stdin>(1)<module>() (Pdb) x 0 마지막 에러를 디버깅해볼 수 있게 연동해놨어요.
- 420. >>> x =0 >>> x / x Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: ... >>> pdb.pm() > <stdin>(1)<module>() (Pdb) x 0 다만 디버깅 콘솔 사용법이 처음엔 조금 생소할 수 있는데
- 421. (Pdb) ? Documented commands(type help <topic>): ======================================== EOF bt cont enable jump pp run unt a c continue exit l q s until alias cl d h list quit step up args clear debug help n r tbreak w b commands disable ignore next restart u whatis break condition down j p return unalias where Miscellaneous help topics: ========================== exec pdb 물음표 치면 설명서가 나오니까
- 422. (Pdb) ? Documented commands(type help <topic>): ======================================== EOF bt cont enable jump pp run unt a c continue exit l q s until alias cl d h list quit step up args clear debug help n r tbreak w b commands disable ignore next restart u whatis break condition down j p return unalias where Miscellaneous help topics: ========================== exec pdb 조금씩 찾아보면서 익히다 보면 아마 금방 익숙해질 수 있을 거예요.
- 423.
- 424. PTVS 마이크로소프트에서 만든 파이썬 개발플러그인인 PTVS를 씁니다.
- 425. PTVS 디버거도 굉장히훌륭해서
- 426.
- 427. 비주얼스튜디오 IDE를 한껏활용하면서 GUI로 편하게 디버깅할 수 있어요.
- 428. print(strange_value) 이렇듯 파이썬에서 print로만 디버깅할수 있는 건 아니니까
- 429. print(strange_value) 여러가지 편한 도구를찾아서 사용해보시면 좋겠습니다.
- 430.
- 431. 자료구조 프로그램 만들 땐언제나 가장 적절한 자료구조를 골라야 하죠.
- 432. 자료구조 그래야 올바른 코드를짤 수 있고 또 성능을 높이는 데도 도움 되니까요.
- 433. 자료구조 list나 set 같은빌트인 자료구조는 이미 다 아실 테니까
- 434. 자료구조 그 밖의 유용한 파이썬자료구조를 소개해볼게요.
- 435.
- 436.
- 437. list.insert(0, x) deque.appendleft(x) 상수시간에 앞뒤양 끝 요소를 조작할 수 있는 자료구조예요.
- 438. list.insert(0, x) deque.appendleft(x) 반면 list는맨 뒤가 아니면 상수시간에 추가하거나 뺄 수 없죠.
- 439. stack = [] whilef: stack.append(f) f = f.f_back stack.reverse() stack = deque() while f: stack.appendleft(f) 이런 식으로 list에 순차적으로 쌓은 다음 뒤집는 경우가 있는데
- 440. stack = [] whilef: stack.append(f) f = f.f_back stack.reverse() stack = deque() while f: stack.appendleft(f) deque을 쓰면 처음부터 역순으로 쌓을 수 있어요.
- 441. >>> sub =OrderedDict([('S', 1), ('U', 2), ('B', 3)]) >>> sub['S'] 1 >>> sub.keys() ['S', 'U', 'B'] OrderedDict는 dict의 서브클래스인데 그냥 dict와 달리 순서를 보장해줘서
- 442. >>> sub =OrderedDict([('S', 1), ('U', 2), ('B', 3)]) >>> sub['S'] 1 >>> sub.keys() ['S', 'U', 'B'] 순서도 중요하고 키로 접근하는 것도 중요할 때 쓰면 좋아요.
- 443. >>> Vector2 =namedtuple('Vector2', ['x', 'y']) >>> xy = Vector2(20, 59) >>> xy.x 20 >>> x, y = xy namedtuple은 tuple의 서브클래스를 만들어주는 함수인데
- 444. >>> Vector2 =namedtuple('Vector2', ['x', 'y']) >>> xy = Vector2(20, 59) >>> xy.x 20 >>> x, y = xy 이때 각 원소에 이름을 붙일 수 있어요.
- 445. >>> Vector2 =namedtuple('Vector2', ['x', 'y']) >>> xy = Vector2(20, 59) >>> xy.x 20 >>> x, y = xy 이것으로 만든 클래스도 tuple 처럼 불변이고 다중대입문에도 쓸 수 있죠.
- 446. >>> Vector2 =namedtuple('Vector2', ['x', 'y']) >>> xy = Vector2(20, 59) >>> xy.x 20 >>> x, y = xy 저는 사소한 클래스 만들 땐 class문을 직접 쓰는 대신
- 447. >>> Vector2 =namedtuple('Vector2', ['x', 'y']) >>> xy = Vector2(20, 59) >>> xy.x 20 >>> x, y = xy 이 쪽을 더 선호하는 편이에요.
- 448. >>> c =Counter('nexon') >>> c['n'] 2 >>> c['x'] 1 Counter는 dict의 서브클래스고 이렇게 뭔가 간단히 셀 때 쓰기 좋아요.
- 449. >>> d =defaultdict(int) >>> d['yo'] 0 defaultdict는 없는 키에 접근했을 때 KeyError를 내는 대신
- 450. >>> d =defaultdict(int) >>> d['yo'] 0 팩토리함수 실행 결과를 채워주는 dict예요.
- 451. def inf_dict(): return defaultdict(inf_dict) 이건파이콘 KR 2014 구종만 님 발표에서 봤던 코드인데
- 452. def inf_dict(): return defaultdict(inf_dict) defaultdict만드는 함수 자체를 defaultdict의 팩토리함수로 쓰고 있죠?
- 453. root = inf_dict() root[0][1][2][3][4][5][6][7]= 'So deep!' 그래서 아무 키나 끊임 없이 써내려 갈 수 있어요.
- 454.
- 455. 써드파티 써드파티에는 더 재밌는게 많아요.
- 456. foo = [1,10, 100, 1000] x = bisect_left(foo, 42) foo.insert(x, 42) from sortedcontainer import SortedList bar = SortedList([1, 10, 100, 1000]) bar.add(42) sortedcontainers는 항상 정렬돼있는 list와 dict를 제공해서
- 457. foo = [1,10, 100, 1000] x = bisect_left(foo, 42) foo.insert(x, 42) from sortedcontainer import SortedList bar = SortedList([1, 10, 100, 1000]) bar.add(42) 굉장히 빠르게 원소를 정렬된 상태로 넣거나 빼는 데 쓸 수 있어요.
- 458. foo = [1,10, 100, 1000] x = bisect_left(foo, 42) foo.insert(x, 42) from sortedcontainer import SortedList bar = SortedList([1, 10, 100, 1000]) bar.add(42) 표준 list나 set으로는 할 수 없는 일이죠.
- 459. >>> from bidictimport bidict >>> type_table = bidict() >>> type_table[1] = Ping >>> type_table[2] = Pong >>> type_table.inv[Pong] 2 bidict는 양방향 dict로,
- 460. >>> from bidictimport bidict >>> type_table = bidict() >>> type_table[1] = Ping >>> type_table[2] = Pong >>> type_table.inv[Pong] 2 키로 값을 찾는 것 뿐만 아니라 값으로 키를 찾는 것까지 가능해서
- 461. >>> from bidictimport bidict >>> type_table = bidict() >>> type_table[1] = Ping >>> type_table[2] = Pong >>> type_table.inv[Pong] 2 타입코드 테이블 같은 거 만들 때 유용해요.
- 462. from cachetools importLRUCache cache = LRUCache(256) cachetools에는 LRU나 TTL을 비롯한
- 463. from cachetools importLRUCache cache = LRUCache(256) 여러가지 캐싱 정책을 구현한 dict의 서브클래스들이 들어있어요.
- 464. from cachetools importLRUCache cache = LRUCache(256) 서버에 캐싱을 구현할 일이 종종 있는데 그럴 때 쓰기 편하더라고요.
- 465. namedtuple, deque, OrderedDict, SortedList,bidict, LRUCache, ... 이렇게 빌트인 말고도 여러가지 자료구조를 라이브러리에서 구할 수 있으니까
- 466. namedtuple, deque, OrderedDict, SortedList,bidict, LRUCache, ... 각각의 용도와 특성을 파악해서 더 효율적인 코드를 쉽게 짜는 데 써보세요.
- 467.
- 468. 제너레이터 파이썬에는 함수 실행을도중에 멈췄다가 재개시킬 수 있는 제너레이터가 있죠.
- 469. 제너레이터 앞서 소개한 asyncio의 재료가되기도 했고요.
- 470. 제너레이터 C# 쓰시는 분들은 이미익숙하실 거예요.
- 471. def only_odds(nums): for nin nums: if n % 2 == 1: yield n 함수 중간에 return 대신 yield를 넣으면 그 지점에서 함수 실행이 중단돼요.
- 472. >>> odds =only_odds(range(100)) >>> next(odds) 1 >>> next(odds) 3 호출한 쪽에선 yield된 값을 받아올 수 있고
- 473. >>> odds =only_odds(range(100)) >>> next(odds) 1 >>> next(odds) 3 next()를 이용해서 다음 이터레이션으로 넘어갈 수 있어요.
- 474. def only_odds(nums): for nin nums: if n % 2 == 1: yield n next() next() next() next() next() 이런 식으로 next()하는 만큼 함수가 실행되게 돼서
- 475. def only_odds(nums): for nin nums: if n % 2 == 1: yield n next() next() next() next() next() 레이지 이터레이터를 아주 쉽게 구현할 수 있죠.
- 476. seq = xrange(1000000) seq= only_odds(seq) seq = (x ** 2 for x in seq) 특히 한 시퀀스를 여러 번 변형하는 경우
- 477. seq = xrange(1000000) seq= only_odds(seq) seq = (x ** 2 for x in seq) 제너레이터를 쓰면 실제 이터레이션을 한 바퀴로 줄일 수 있는데
- 478. seq = xrange(1000000) seq= only_odds(seq) seq = (x ** 2 for x in seq) 이 코드는 0부터 999,999까지의 숫자 중에서
- 479. seq = xrange(1000000) seq= only_odds(seq) seq = (x ** 2 for x in seq) 홀수만 취한 다음
- 480. seq = xrange(1000000) seq= only_odds(seq) seq = (x ** 2 for x in seq) 그 제곱을 구하는 코드입니다.
- 481. seq = xrange(1000000) seq= only_odds(seq) seq = (x ** 2 for x in seq) 세 줄 모두 이터레이터나 제너레이터만 만들고 있고
- 482. >>> seq <generator object<genexpr>> 실제로 이터레이션을 돌리진 않아요.
- 483. >>> list(seq) [1, 9,25, 49, 81, 121, ...] 결과를 보기 위해 list 등으로 감싸면 그때야 비로소 이터레이션이 돌죠.
- 484. >>> list(seq) [1, 9,25, 49, 81, 121, ...] 레이지하지 않았다면 이터레이션이 250만 바퀴 돌았을 로직인데
- 485. >>> list(seq) [1, 9,25, 49, 81, 121, ...] 이 방법으로 딱 100만 바퀴만 돌 수 있게 됩니다.
- 486. ❯ python -mtimeit -s 'from exm import only_odds' ' seq = xrange(1000000) seq = only_odds(seq) seq = (x ** 2 for x in seq) list(seq) ' 10 loops, best of 3: 137 msec per loop 간단히 벤치마킹해보니까 제너레이터를 쓸 땐 137ms가 걸렸어요.
- 487. ❯ python -mtimeit -s 'from exm import only_odds' ' seq = list(xrange(1000000)) seq = list(only_odds(seq)) seq = [x ** 2 for x in seq] ' 10 loops, best of 3: 456 msec per loop 반면 매번 이터레이션하는 방식으로는 456ms나 걸리는 걸 볼 수 있었습니다.
- 488. >>> list(gen) [1, 2,3] >>> list(gen) [] def gen(): yield 1 yield 2 yield 3 제너레이터는 딱 한 바퀴만 돌릴 수 있어서
- 489. >>> list(gen) [1, 2,3] >>> list(gen) [] def gen(): yield 1 yield 2 yield 3 여러 번 돌려야 하는 경우에 당황스러울 수 있어요.
- 490. seq = list(gen) do_something(seq) do_another(seq) 이럴땐 list 등으로 미리 한번 평가해놓고 쓰거나
- 491. gen1, gen2 =itertools.tee(gen) do_something(gen1) do_another(gen2) 아니면 표준 라이브러리 itertools에 있는 tee를 이용해서
- 492. gen1, gen2 =itertools.tee(gen) do_something(gen1) do_another(gen2) 제너레이터를 여러 개의 뷰로 나눠서 쓸 수 있어요.
- 493. gen1, gen2 =itertools.tee(gen) do_something(gen1) do_another(gen2) tee는 리눅스 커맨드에서 따온 이름인데 T자형 파이프를 뜻합니다.
- 494. enemy = player.nearest_player() whileplayer.alive() or enemy.alive(): player.move_to(enemy) player.attack(enemy) yield 제너레이터는 AI 만들 때 쓰기에도 굉장히 편리한데
- 495. enemy = player.nearest_player() whileplayer.alive() or enemy.alive(): player.move_to(enemy) player.attack(enemy) yield 지금이 어떤 상태고 각종 정보를 다음 틱에 어떻게 넘길지
- 496. enemy = player.nearest_player() whileplayer.alive() or enemy.alive(): player.move_to(enemy) player.attack(enemy) yield 고민할 필요 없이 그냥 지역변수를 쓰면 되거든요.
- 497. if self.state isnot Fighting: self.enemy = player.nearest_player() self.state = Fighting elif player.alive() or self.enemy.alive(): player.move_to(self.enemy) player.attack(self.enemy) 제너레이터가 없다면 어떤 형태로든 스테이트머신이 필요하겠죠?
- 498.
- 499. yield 많이 쓰이는 제어구문이고 그만큼쓰기도 쉽습니다.
- 500. yield 제너레이터로 이터레이션을 줄일수 있거나 복잡도를 낮출 수 있는 곳이 없는지
- 501. yield 한 번 확인해보시면좋을 것 같아요.
- 502.
- 503. 성능 측정 프로그램을 최적화하려면 일단성능부터 제대로 측정해야 합니다.
- 504. 성능 측정 이번엔 저희가사용하는 몇 가지 성능 측정 방법을 소개해 볼게요.
- 505. ❯ python -mtimeit -s 한 번 실행할 코드 벤치마킹할 코드 timeit은 표준 라이브러리예요.
- 506. ❯ python -mtimeit -s 한 번 실행할 코드 벤치마킹할 코드 앞에서 제너레이터 벤치마킹할 때 이것을 썼었죠.
- 507. ❯ python -mtimeit -s 한 번 실행할 코드 벤치마킹할 코드 그냥 쉘에다가 이렇게 치면
- 508. ❯ python -mtimeit -s 한 번 실행할 코드 벤치마킹할 코드 적당히 너무 오래 걸리지 않는 선에서 반복실행한 다음
- 509. ❯ python -mtimeit -s 한 번 실행할 코드 벤치마킹할 코드 한 번 돌릴 때 실행시간이 얼마나 걸리는지 알려줍니다.
- 510. ❯ python -mtimeit -s 'import math' 'math.log10(99999999)' 10000000 loops, best of 3: 0.108 usec per loop 이런 식으로요.
- 511. ❯ python -mtimeit -s 'import math' 'math.log10(99999999)' 10000000 loops, best of 3: 0.108 usec per loop 이건 math.log10()을 벤치마킹하는 모습이에요.
- 512. ❯ python -mtimeit -s 'import math' 'math.log10(99999999)' 10000000 loops, best of 3: 0.108 usec per loop 여기서 math 모듈을 import하는 부분은 벤치마킹 대상이 아니잖아요?
- 513. ❯ python -mtimeit -s 'import math' 'math.log10(99999999)' 10000000 loops, best of 3: 0.108 usec per loop 그래서 -s 옵션에 넣어서 한 번만 부르게 했어요.
- 514. ❯ python -mtimeit -s 'import math' 'math.log10(99999999)' 10000000 loops, best of 3: 0.108 usec per loop 1,000만 번 씩 3번 돌려봤고
- 515. ❯ python -mtimeit -s 'import math' 'math.log10(99999999)' 10000000 loops, best of 3: 0.108 usec per loop 그 중 가장 빨랐을 때 log10 한 번에 0.108μs가 걸렸다는 내용입니다.
- 516. •호출 횟수 •고유 실행시간 •하위콜스택 포함 실행시간 ❯ python -m profile 파이썬 파일 profile 역시 표준 라이브러리인데
- 517. •호출 횟수 •고유 실행시간 •하위콜스택 포함 실행시간 ❯ python -m profile 파이썬 파일 함수에 진입하고 나가는 이벤트를 모두 기록해서
- 518. •호출 횟수 •고유 실행시간 •하위콜스택 포함 실행시간 ❯ python -m profile 파이썬 파일 함수 별로 호출 횟수와 실행시간을 측정해주죠.
- 519. •호출 횟수 •고유 실행시간 •하위콜스택 포함 실행시간 ❯ python -m cProfile 파이썬 파일 표준 라이브러리에 cProfile이라고 C로 만들어서 오버헤드가 적은 버전도 있으니까
- 520. •호출 횟수 •고유 실행시간 •하위콜스택 포함 실행시간 ❯ python -m cProfile 파이썬 파일 저희처럼 PyPy가 아닌 CPython을 쓰신다면 이걸 쓰세요.
- 521. ❯ python -mcProfile log10.py 10000002 function calls in 2.269 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.327 0.327 2.269 2.269 log10.py:1(<module>) 10000000 1.942 0.000 1.942 0.000 {math.log10} 측정 결과는 이런 식으로 출력되는데
- 522. ❯ python -mcProfile log10.py 10000002 function calls in 2.269 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.327 0.327 2.269 2.269 log10.py:1(<module>) 10000000 1.942 0.000 1.942 0.000 {math.log10} 함수 별 호출 횟수와
- 523. ❯ python -mcProfile log10.py 10000002 function calls in 2.269 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.327 0.327 2.269 2.269 log10.py:1(<module>) 10000000 1.942 0.000 1.942 0.000 {math.log10} 함수 자체에서 소비된 시간,
- 524. ❯ python -mcProfile log10.py 10000002 function calls in 2.269 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.327 0.327 2.269 2.269 log10.py:1(<module>) 10000000 1.942 0.000 1.942 0.000 {math.log10} 여기에 하위 콜스택에서 소비된 시간은 포함되지 않고
- 525. ❯ python -mcProfile log10.py 10000002 function calls in 2.269 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.327 0.327 2.269 2.269 log10.py:1(<module>) 10000000 1.942 0.000 1.942 0.000 {math.log10} 하위 콜스택까지 포함한 시간은 그 옆에 있어요.
- 526. ❯ python -mcProfile log10.py 10000002 function calls in 2.269 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.327 0.327 2.269 2.269 log10.py:1(<module>) 10000000 1.942 0.000 1.942 0.000 {math.log10} 프로그램 덩치가 커지면 측정 결과를 읽기 좀 힘들어지긴 하지만
- 527. ❯ python -mcProfile log10.py 10000002 function calls in 2.269 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.327 0.327 2.269 2.269 log10.py:1(<module>) 10000000 1.942 0.000 1.942 0.000 {math.log10} 파이썬에서 가장 기본적으로 사용할 수 있는 꽤 쓸만한 프로파일러입니다.
- 528. ❯ python -mcProfile log10.py 10000002 function calls in 2.269 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.327 0.327 2.269 2.269 log10.py:1(<module>) 10000000 1.942 0.000 1.942 0.000 {math.log10} 단 측정 오버헤드가 제법 있으니까 라이브 서버 같은 곳에선 쓰지 마세요.
- 529. + 스레드 별측정 ❯ python -m yappi 파이썬 파일 Yappi는 써드파티 라이브러리고요
- 530. + 스레드 별측정 ❯ python -m yappi 파이썬 파일 앞서 보신 profile과 비슷한데 스레드 별 성능까지 측정해줘요.
- 531. + 스레드 별측정 ❯ python -m yappi 파이썬 파일 C로 구현돼있고 아쉽게도 PyPy에선 쓸 수 없어요.
- 532. ❯ python -myappi log10.py Clock type: CPU Ordered by: totaltime, desc name ncall tsub ttot tavg log10.py:1 <module> 1 0.000113 0.000415 0.000415 log10.py:4 f 2 0.000000 0.000000 0.000000 name id tid ttot scnt Thread 1 140376132327168 0.029194 1 Thread 2 140376123934464 0.029179 1 _MainThread 0 140376158828288 0.004055 2 마찬가지로
- 533. ❯ python -myappi log10.py Clock type: CPU Ordered by: totaltime, desc name ncall tsub ttot tavg log10.py:1 <module> 1 0.000113 0.000415 0.000415 log10.py:4 f 2 0.000000 0.000000 0.000000 name id tid ttot scnt Thread 1 140376132327168 0.029194 1 Thread 2 140376123934464 0.029179 1 _MainThread 0 140376158828288 0.004055 2 함수 별 호출 횟수와
- 534. ❯ python -myappi log10.py Clock type: CPU Ordered by: totaltime, desc name ncall tsub ttot tavg log10.py:1 <module> 1 0.000113 0.000415 0.000415 log10.py:4 f 2 0.000000 0.000000 0.000000 name id tid ttot scnt Thread 1 140376132327168 0.029194 1 Thread 2 140376123934464 0.029179 1 _MainThread 0 140376158828288 0.004055 2 실행시간이 나오고
- 535. ❯ python -myappi log10.py Clock type: CPU Ordered by: totaltime, desc name ncall tsub ttot tavg log10.py:1 <module> 1 0.000113 0.000415 0.000415 log10.py:4 f 2 0.000000 0.000000 0.000000 name id tid ttot scnt Thread 1 140376132327168 0.029194 1 Thread 2 140376123934464 0.029179 1 _MainThread 0 140376158828288 0.004055 2 스레드 별 실행시간과 스케줄링 횟수까지 알 수 있습니다.
- 536. ❯ python -myappi log10.py Clock type: CPU Ordered by: totaltime, desc name ncall tsub ttot tavg log10.py:1 <module> 1 0.000113 0.000415 0.000415 log10.py:4 f 2 0.000000 0.000000 0.000000 name id tid ttot scnt Thread 1 140376132327168 0.029194 1 Thread 2 140376123934464 0.029179 1 _MainThread 0 140376158828288 0.004055 2 게다가 약간만 커스터마이징 하면 gevent 스레드도 측정할 수 있어요.
- 537. + 콜스택 + 실시간 +원격 + 샘플링 + 대화형 TUI. ❯ profiling 파이썬 파일 Profiling은 저희 스튜디오에서 만든 오픈소스 프로파일러예요.
- 538. + 콜스택 + 실시간 +원격 + 샘플링 + 대화형 TUI. ❯ profiling 파이썬 파일 앞에서 보신 측정 결과들에는 함수 목록이 1차원적으로만 나열돼 있었는데
- 539. + 콜스택 + 실시간 +원격 + 샘플링 + 대화형 TUI. ❯ profiling 파이썬 파일 저희는 콜스택 계층구조까지 보고싶어서 만들었어요.
- 540. + 콜스택 + 실시간 +원격 + 샘플링 + 대화형 TUI. ❯ profiling 파이썬 파일 또 라이브 서버도 측정해보고 싶어서
- 541. + 콜스택 + 실시간 +원격 + 샘플링 + 대화형 TUI. ❯ profiling 파이썬 파일 실시간 원격 성능측정 프로토콜과 샘플링 프로파일링 기법,
- 542. + 콜스택 + 실시간 +원격 + 샘플링 + 대화형 TUI. ❯ profiling 파이썬 파일 그리고 아까 봤던 Urwid를 이용해서 대화형 TUI도 만들었습니다.
- 543. 이렇게 펼쳤다 접었다왔다 갔다 하면서 성능을 측정할 수 있어요.
- 544. https://github.com/what-studio/profiling 저희 스튜디오 GitHub에공개돼있으니까 많이들 참여해주세요.
- 545.
- 546. •line_profiler 줄 단위로 성능측정 •memory_profiler 줄 단위로 메모리 사용량과 변화량 측정 이밖에도 여러가지 프로파일러가 더 있는데
- 547. •line_profiler 줄 단위로 성능측정 •memory_profiler 줄 단위로 메모리 사용량과 변화량 측정 함수가 아닌 코드 줄 단위로 성능을 측정해주는 line_profiler나
- 548. •line_profiler 줄 단위로 성능측정 •memory_profiler 줄 단위로 메모리 사용량과 변화량 측정 줄 단위로 메모리 사용량이 얼마나 늘고 줄었는지 측정해주는
- 549. •line_profiler 줄 단위로 성능측정 •memory_profiler 줄 단위로 메모리 사용량과 변화량 측정 memory_profiler 같은 것도 있어요.
- 550. •line_profiler 줄 단위로 성능측정 •memory_profiler 줄 단위로 메모리 사용량과 변화량 측정 알아 두시면 언젠가 쓸모가 있을 것 같습니다.
- 551.
- 552. 로드타임 파이썬엔 컴파일타임이 없어서 컴파일타임최적화 같은 건 할 수 없지만
- 553.
- 554.
- 555. 로드타임 이때 아무 코드나실행할 수 있어요.
- 556. 로드타임 이때를 잘 활용하면생산성을 높이거나 최적화하는 데 도움될 수 있습니다.
- 557. Dog = type('Dog',(object,), {}) effy = Dog() type 클래스를 인자 3개로 호출하면
- 558. Dog = type('Dog',(object,), {}) effy = Dog() 런타임에 새로운 클래스를 동적으로 만들어낼 수 있어요.
- 559. for filename infilenames: with open(filename) as f: dsl = json.load(f) cls = generate_class(dsl) locals()[cls.__name__] = cls __all__.append(cls.__name__) 이것을 이용하면 파이썬 코드가 아닌 다른 파일로 DSL을 만들어서
- 560. for filename infilenames: with open(filename) as f: dsl = json.load(f) cls = generate_class(dsl) locals()[cls.__name__] = cls __all__.append(cls.__name__) 반복적인 클래스 선언 코드를 줄일 수 있죠.
- 561. for filename infilenames: with open(filename) as f: dsl = json.load(f) cls = generate_class(dsl) locals()[cls.__name__] = cls __all__.append(cls.__name__) 저희 패킷이나 예외 같은 것도 이렇게 로드타임에 동적으로 생성하고 있어요.
- 562. class Person(Model): __metaclass__ =ModelMeta name = field(str) age = field(int) >>> Person.schema [('name', str), ('age', int)] 메타클래스는 클래스의 클래스인데
- 563. class Person(Model): __metaclass__ =ModelMeta name = field(str) age = field(int) >>> Person.schema [('name', str), ('age', int)] 객체가 만들어질 때 클래스에 있는 생성자를 부르듯이
- 564. class Person(Model): __metaclass__ =ModelMeta name = field(str) age = field(int) >>> Person.schema [('name', str), ('age', int)] 클래스가 만들어질 땐 메타클래스에 정의한 생성자가 불려요.
- 565. class Person(Model): __metaclass__ =ModelMeta name = field(str) age = field(int) >>> Person.schema [('name', str), ('age', int)] 미래에 쓰기 위해 미리 구워 놓을 만한 정보가 있다면 여기서 구워 둘 수 있죠.
- 566. @on_msg(Ping) def ping_received(msg): return Pong(msg.seq) whileTrue: dispatch_msg(server.recv_msg()) 데코레이터도 보통 로드타임에 평가되니까
- 567. @on_msg(Ping) def ping_received(msg): return Pong(msg.seq) whileTrue: dispatch_msg(server.recv_msg()) 마찬가지로 뭔가 구워 두는 데 쓸 수 있겠죠?
- 568. @on_msg(Ping) def ping_received(msg): return Pong(msg.seq) whileTrue: dispatch_msg(server.recv_msg()) 저희 서버에선 패킷 핸들러를 이런 식으로 선언하는데
- 569. @on_msg(Ping) def ping_received(msg): return Pong(msg.seq) whileTrue: dispatch_msg(server.recv_msg()) 런타임에 패킷 디스패칭을 빠르게 하기 위해서
- 570. @on_msg(Ping) def ping_received(msg): return Pong(msg.seq) whileTrue: dispatch_msg(server.recv_msg()) 로드 타임에 라우팅 테이블이 미리 구워지도록 하고 있어요.
- 571. class Dirty(object): for xin range(100): r = random() locals()['x%f' % r] = r exec '__metaclass__ = DirtyMeta' 로드타임은 처음 진입하는 런타임일 뿐이고 파이썬은 엄청나게 동적인 언어다 보니
- 572. class Dirty(object): for xin range(100): r = random() locals()['x%f' % r] = r exec '__metaclass__ = DirtyMeta' 이런 온갖 지저분한 일을 할 수는 있지만
- 573. class Dirty(object): for xin range(100): r = random() locals()['x%f' % r] = r exec '__metaclass__ = DirtyMeta' 너무 과하면 코드를 이해하거나 디버깅하기 어려워질 수 있으니까
- 574. class Dirty(object): for xin range(100): r = random() locals()['x%f' % r] = r exec '__metaclass__ = DirtyMeta' 중용의 미를 갖추는 게 중요해요.
- 575. class Dirty(object): for xin range(100): r = random() locals()['x%f' % r] = r exec '__metaclass__ = DirtyMeta' 적당한 선에서 반복작업을 줄여주거나
- 576. class Dirty(object): for xin range(100): r = random() locals()['x%f' % r] = r exec '__metaclass__ = DirtyMeta' 런타임에 처리할 일들을 로드타임으로 당겨오는 데 이용하면
- 577. class Dirty(object): for xin range(100): r = random() locals()['x%f' % r] = r exec '__metaclass__ = DirtyMeta' 서버처럼 오랫동안 도는 프로그램에선 좋은 성과를 보실 수 있을 겁니다.
- 578.
- 579. 메모리 최적화 이번엔 저희가메모리 사용량을 줄이려고 쓰는 몇 가지 방법을 소개할게요.
- 580. object.__slots__ 첫 번째로 소개할건 __slots__입니다.
- 581. Point(1, 2) { 'x': 1, 'y':2, } __dict__ 파이썬 객체는 내부적으로 이렇게 생겼어요.
- 582. Point(1, 2) { 'x': 1, 'y':2, } __dict__ 인스턴스마다 속성명을 키로, 속성값을 값으로 갖는 dict가 달려있죠.
- 583. Point(1, 2) { 'x': 1, 'y':2, } __dict__ 파이썬 객체에 아무 속성이나 동적으로 넣었다 뺐다 할 수 있는 이유가 바로 이것이에요.
- 584. Point(1, 2) { 'x': 1, 'y':2, } __dict__ 그런데 모든 인스턴스에 속성명이 들어간다는 게 좀 아깝잖아요?
- 585. Point(1, 2) { 'x': 1, 'y':2, } __dict__ dict에도 오버헤드가 아예 없지는 않을 것 같고요.
- 586. Point(1, 2) 2 x 1 y __slots__를 쓰면dict 없이 객체가 속성값을 직접 가리키게 할 수 있습니다.
- 587. class Point(object): __slots__ =('x', 'y') def __init__(self, x, y): self.x, self.y = x, y 클래스 선언할 때 __slots__에 속성명들을 지정해주면 되는데
- 588. >>> p =Point(1, 2) >>> p.x = 3 >>> p.z = 3 Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'Point' object has no attribute 'z' 대신 동적인 특성은 포기해야 해요.
- 589. >>> p =Point(1, 2) >>> p.x = 3 >>> p.z = 3 Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'Point' object has no attribute 'z' 그래서 저희는 모든 클래스에 쓰진 못 하고
- 590. >>> p =Point(1, 2) >>> p.x = 3 >>> p.z = 3 Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'Point' object has no attribute 'z' 별로 동적일 필요가 없거나
- 591. >>> p =Point(1, 2) >>> p.x = 3 >>> p.z = 3 Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'Point' object has no attribute 'z' 인스턴스가 아주 많이 생성되는 클래스 위주로 적용하고 있습니다.
- 592. objgraph 다음으로 메모리 누수를찾아내고 방지하는 방법을 소개할게요.
- 593. objgraph 써드파티 라이브러리인 objgraph는 메모리누수를 찾을 때 굉장히 유용한데
- 594. >>> objgraph.show_most_common_types() X 9999 wrapper_descriptor1085 function 1020 builtin_function_or_method 699 method_descriptor 538 show_most_common_types()를 부르면
- 595. >>> objgraph.show_most_common_types() X 9999 wrapper_descriptor1085 function 1020 builtin_function_or_method 699 method_descriptor 538 메모리에 가장 많이 떠 있는 타입 탑10을 알 수 있고
- 596. >>> xs =objgraph.by_type('X') >>> len(xs) 9999 by_type()을 부르면 타입 이름만으로
- 597. >>> xs =objgraph.by_type('X') >>> len(xs) 9999 그 타입에 해당하는 객체를 모조리 얻을 수 있어요.
- 598. objgraph.show_backrefs(xs[42]) show_backrefs()로는 어디서 주어진 객체를참조하는지 알아낼 수 있는데
- 599. 이렇게 그래프 형태로시각화해줘서
- 600.
- 601. •쓰레기 수거 •참조 횟수추적 CPython에선 GC와 레퍼런스카운팅이 둘 다 쓰이는데
- 602. •쓰레기 수거 •참조 횟수추적 레퍼런스카운팅은 다소 역사적인 이유로 남아있는 거라
- 603. •쓰레기 수거 •참조 횟수추적 PyPy에선 GC만 쓰인다고 합니다.
- 604. •쓰레기 수거 •참조 횟수추적 CPython에서 대부분의 객체는 레퍼런스카운트가 0이 됐을 때 바로 지워지고
- 605. •쓰레기 수거 •참조 횟수추적 오직 쓰레기 순환참조만 GC로 지워지죠.
- 606. >>> import gc >>>len(gc.get_objects()) 19891212 >>> gc.collect() 19891170 >>> len(gc.get_objects()) 42 GC는 표준 라이브러리 gc로 접근할 수 있고
- 607. >>> import gc >>>len(gc.get_objects()) 19891212 >>> gc.collect() 19891170 >>> len(gc.get_objects()) 42 collect()를 불러서 직접 돌릴 수도 있어요.
- 608. >>> import gc >>>len(gc.get_objects()) 19891212 >>> gc.collect() 19891170 >>> len(gc.get_objects()) 42 사실 불필요한 순환 참조만 방지하면
- 609. >>> import gc >>>len(gc.get_objects()) 19891212 >>> gc.collect() 19891170 >>> len(gc.get_objects()) 42 대부분은 레퍼런스카운팅에 의해서 바로바로 지워지게 만들 수 있어요.
- 610. 약한 참조 • weakref.ref(referent) •weakref.proxy(referent) • weakref.WeakSet • weakref.WeakKeyDictionary • weakref.WeakValueDictionary 그걸 보조하기 위해 werkref라는 표준 라이브러리가 있는데
- 611. 약한 참조 • weakref.ref(referent) •weakref.proxy(referent) • weakref.WeakSet • weakref.WeakKeyDictionary • weakref.WeakValueDictionary 단순한 포인터 같은 것 뿐만 아니라
- 612. 약한 참조 • weakref.ref(referent) •weakref.proxy(referent) • weakref.WeakSet • weakref.WeakKeyDictionary • weakref.WeakValueDictionary 마치 그 객체인양 쓸 수 있게 해주는 proxy나
- 613. 약한 참조 • weakref.ref(referent) •weakref.proxy(referent) • weakref.WeakSet • weakref.WeakKeyDictionary • weakref.WeakValueDictionary 원소를 약한 참조로 관리해주는 WeakSet 같은
- 614. 약한 참조 • weakref.ref(referent) •weakref.proxy(referent) • weakref.WeakSet • weakref.WeakKeyDictionary • weakref.WeakValueDictionary 고수준 API도 제공해요.
- 615. 약한 참조 • weakref.ref(referent) •weakref.proxy(referent) • weakref.WeakSet • weakref.WeakKeyDictionary • weakref.WeakValueDictionary 물론 이걸 안 써도 GC에 의해 언젠가 지워지긴 하겠지만
- 616. 약한 참조 • weakref.ref(referent) •weakref.proxy(referent) • weakref.WeakSet • weakref.WeakKeyDictionary • weakref.WeakValueDictionary 아무도 GC를 달가워하진 않잖아요?
- 617. def fight_with_animal(self): self.victim =load_animal() try: self.fight() finally: del self.victim 한편 아무리 GC가 있다 해도
- 618. def fight_with_animal(self): self.victim =load_animal() try: self.fight() finally: del self.victim 영원히 안 죽는 객체가 불필요한 참조를 놔주지 않으면
- 619. def fight_with_animal(self): self.victim =load_animal() try: self.fight() finally: del self.victim 메모리릭으로 이어지니까
- 620. def fight_with_animal(self): self.victim =load_animal() try: self.fight() finally: del self.victim finally를 이용해 새는 참조가 없게 만드는 게 좋아요.
- 621. def fight_with_animal(self): self.victim =load_animal() try: self.fight() finally: del self.victim try 절 끝에 finally 절을 붙일 수 있는데
- 622. def fight_with_animal(self): self.victim =load_animal() try: self.fight() finally: del self.victim try 절이 성공적으로 끝나든 오류가 나든 finally 절은 무조건 불리게 돼요.
- 623. def fight_with_animal(self): self.victim =load_animal() try: self.fight() finally: del self.victim 쓸모 없어진 참조는 여기서 바로바로 지워주는 게 좋겠죠.
- 624. def fight_with_animal(self): self.victim =load_animal() try: self.fight() finally: del self.victim Go에 있는 defer나 C++의 RAII를 떠올리심 될 것 같아요.
- 625. def fight_with_animal(self): self.victim =load_animal() self.fight() del self.victim finally 없이 그냥 함수 끝에서 정리하기만 하면
- 626. def fight_with_animal(self): self.victim =load_animal() self.fight() del self.victim Error! 이렇게 중간에 오류 났을 때 정리되지 않으니까 꼭 넣어주세요.
- 627. @contextmanager def animal_victim(self): self.victim =load_animal() try: yield finally: del self.victim def fight_with_animal(self): with self.animal_victim(): self.fight() try-finally를 직접 쓰는 대신 with 문을 쓰는 것도 좋은데
- 628. @contextmanager def animal_victim(self): self.victim =load_animal() try: yield finally: del self.victim def fight_with_animal(self): with self.animal_victim(): self.fight() 표준 라이브러리 contextlib에 있는 contextmanager를 쓰면
- 629. @contextmanager def animal_victim(self): self.victim =load_animal() try: yield finally: del self.victim def fight_with_animal(self): with self.animal_victim(): self.fight() with 문 용 객체를 쉽게 만들 수 있어요.
- 630. @contextmanager def animal_victim(self): self.victim =load_animal() try: yield finally: del self.victim def fight_with_animal(self): with self.animal_victim(): self.fight() 비슷한 try-finally가 여기저기에서 반복적으로 필요하다면
- 631. @contextmanager def animal_victim(self): self.victim =load_animal() try: yield finally: del self.victim def fight_with_animal(self): with self.animal_victim(): self.fight() 이렇게 contextmanager로 만들어 두는 게 좋습니다.
- 632.
- 633.
- 634.
- 635. •with, finally •weakref •objgraph 그럼에도 메모리릭이발견되면 objgraph로 디버깅 하고 있습니다.
- 636. •with, finally •weakref •objgraph 그런데 서버를만드는 게 아니라면 이렇게까지 신경쓰진 않으셔도 될 것 같아요.
- 637.
- 638.
- 639. 흔한 실수 저희 프로젝트에서 많은분들과 협업하면서 발견한
- 640. 흔한 실수 흔한 실수몇 가지를 모아봤어요.
- 641. f = open('logs') logs= f.read() with open('logs') as f: logs = f.read() 우선 with 문 없이 파일을 열고나서 안 닫는 경우예요.
- 642. f = open('logs') logs= f.read() with open('logs') as f: logs = f.read() 스트리밍 같은 이유로 파일을 열어놓고 있어야 하는 특별한 경우가 아니면
- 643. f = open('logs') logs= f.read() with open('logs') as f: logs = f.read() 꼭 with 문을 써서 필요 없게 된 파일이 바로 닫힐 수 있게 해주세요.
- 644. def make_node(children=[]): return Node(children) 이건인자 기본값으로 가변 객체를 지정해둔 모습인데
- 645. def make_node(children=[]): return Node(children) 함수기본값은 로드타임에 딱 한 번만 초기화되니까
- 646. def make_node(children=None): if childrenis None: children = [] return Node(children) 꼭 불변 객체를 써주세요.
- 647. def make_node(children=None): if childrenis None: children = [] return Node(children) 플레이스홀더로 None을 쓰는 걸 추천합니다.
- 648. >>> n1 =make_node() >>> n1.children.append(n1) >>> n2 = make_node() >>> n2.children [<n1>] 그러지 않을 경우
- 649. >>> n1 =make_node() >>> n1.children.append(n1) >>> n2 = make_node() >>> n2.children [<n1>] 이렇게 엉뚱한 곳에서 간섭을 발견하게 될 수도 있어요.
- 650. try: do_something() except Exception asexc: handle_error(exc) 이번엔 모든 예외를 잡기 위해 Exception 클래스를 적은 모습인데
- 651. try: do_something() except Exception asexc: handle_error(exc) 최상위 예외처럼 생겼죠?
- 652. • BaseException • SystemExit •KeyboardInterrupt • GeneratorExit • Exception • StopIteration • StandardError • ValueError, KeyError, IndexError, ... • Warning • DeprecationWarning, FutureWarning, ... 하지만 파이썬 표준 예외 체계는 이렇게 돼있어서
- 653. • BaseException • SystemExit •KeyboardInterrupt • GeneratorExit • Exception • StopIteration • StandardError • ValueError, KeyError, IndexError, ... • Warning • DeprecationWarning, FutureWarning, ... Exception으로 잡으면 이쪽은 잡을 수 있지만
- 654. • BaseException • SystemExit •KeyboardInterrupt • GeneratorExit • Exception • StopIteration • StandardError • ValueError, KeyError, IndexError, ... • Warning • DeprecationWarning, FutureWarning, ... 이쪽이 안 잡혀요.
- 655. • BaseException • SystemExit •KeyboardInterrupt • GeneratorExit • Exception • StopIteration • StandardError • ValueError, KeyError, IndexError, ... • Warning • DeprecationWarning, FutureWarning, ... 모든 예외를 빠짐 없이 잡고 싶으면
- 656. • BaseException • SystemExit •KeyboardInterrupt • GeneratorExit • Exception • StopIteration • StandardError • ValueError, KeyError, IndexError, ... • Warning • DeprecationWarning, FutureWarning, ... 진짜 최상위 예외인 BaseException으로 잡아주세요.
- 657. self.found = False whilenot self.found: gevent.sleep(0.001) self.found = True 마지막으로 스핀락 코드예요.
- 658. self.found = False whilenot self.found: gevent.sleep(0.001) self.found = True 이렇게 하면 스레드가 쓸데 없이 자꾸 깨어나서
- 659. self.found = False whilenot self.found: gevent.sleep(0.001) self.found = True 동시성이 떨어질 수 있어요.
- 660. self.found = False whilenot self.found: gevent.sleep(0.001) self.found = True 스레드 10,000개가 이러고 있다고 생각하면 끔찍하죠?
- 661.
- 662. self.found = Event() self.found.wait() self.found.set() Event나Semaphore같은 동기화 프리미티브를 잘 써서
- 663. self.found = Event() self.found.wait() self.found.set() 깨어날시간을 스케줄러에게 맡겨야 해요.
- 664. self.found = Event() self.found.wait() self.found.set() 이런동기화 프리미티브는 gevent 뿐만 아니라
- 665. self.found = Event() self.found.wait() self.found.set() 표준멀티스레딩을 비롯한 모든 비동기 I/O 라이브러리에서
- 666. self.found = Event() self.found.wait() self.found.set() 제공되고있습니다. 꼭 찾아서 써주세요.
- 667. • with open() •def f(default=None) • except BaseException • Event.wait() 네 사례 모두 사소하지만
- 668. • with open() •def f(default=None) • except BaseException • Event.wait() 성능을 떨어뜨리거나 버그를 야기할 수 있고
- 669. • with open() •def f(default=None) • except BaseException • Event.wait() 파이썬에 익숙하지 않으면 쉽게 겪을 수 있을 것 같아요.
- 670. • with open() •def f(default=None) • except BaseException • Event.wait() 파이썬으로 코딩하실 때 이런 것에 주의해주시면 좋겠습니다.
- 671.
- 672.
- 673. 1. 자바스크립트 324k 2.자바 223k 3. 파이썬 165k 7. C++ 87k 8. C 73k 10. C# 56k 출처: http://githut.info/ 파이썬의 가장 큰 강점은 성숙한 오픈소스 커뮤니티라고 생각합니다.
- 674. 1. 자바스크립트 324k 2.자바 223k 3. 파이썬 165k 7. C++ 87k 8. C 73k 10. C# 56k 출처: http://githut.info/ GitHut이라는 GitHub 통계사이트를 보면 2014년 4쿼터 기준으로
- 675. 1. 자바스크립트 324k 2.자바 223k 3. 파이썬 165k 7. C++ 87k 8. C 73k 10. C# 56k 출처: http://githut.info/ 파이썬의 오픈소스 커뮤니티 규모는 3위를 차지했다고 해요.
- 676. PyPI Python Package Index 파이썬에는PyPI라는 중앙 패키지 저장소가 있는데
- 677. PyPI Python Package Index 저는좋은 써드파티 라이브러리를 발굴하러 자주 들어가고 있어요.
- 678.
- 679. ❯ profiling --version commandnot found: profiling ❯ pip install profiling ❯ profiling --version profiling, version 0.1.1 그렇게 찾은 패키지는 pip install 명령어로 설치할 수 있어요.
- 680. virtualenv 이때 보통 프로젝트간에 의존성이 섞이지 않게 하기 위해서
- 681.
- 682. virtualenv Node.js의 npm이 시스템이아닌 현재 폴더에 의존성 푸는 걸 생각하심 될 것 같아요.
- 683. ❯ pip installvirtualenv ❯ virtualenv ~/env ❯ which python /usr/bin/python ❯ source ~/env/bin/activate (env)❯ which python ~/env/bin/python virtualenv로 적당한 폴더에 격리된 환경을 만들고
- 684. ❯ pip installvirtualenv ❯ virtualenv ~/env ❯ which python /usr/bin/python ❯ source ~/env/bin/activate (env)❯ which python ~/env/bin/python 그 환경을 활성화하면
- 685. ❯ pip installvirtualenv ❯ virtualenv ~/env ❯ which python /usr/bin/python ❯ source ~/env/bin/activate (env)❯ which python ~/env/bin/python 시스템에 깔린 파이썬 대신
- 686. ❯ pip installvirtualenv ❯ virtualenv ~/env ❯ which python /usr/bin/python ❯ source ~/env/bin/activate (env)❯ which python ~/env/bin/python 격리된 파이썬이 쓰이게 되죠.
- 687. (env)❯ pip installprofiling (env)❯ python -c 'import profiling' (env)❯ deactivate ❯ python -c 'import profiling' ImportError: No module named profiling 이 안에서 설치하는 라이브러리는 안에만 깔리고
- 688. (env)❯ pip installprofiling (env)❯ python -c 'import profiling' (env)❯ deactivate ❯ python -c 'import profiling' ImportError: No module named profiling 밖에는 영향을 주지 않아요.
- 689.
- 690.
- 691. from setuptools importsetup setup( name='foobar', install_requires=[ 'profiling', 'trueskill', 'tossi==0.0.1', ], ) setup.py setup.py는 프로젝트 메타정보를 정의하는 스크립트인데
- 692. from setuptools importsetup setup( name='foobar', install_requires=[ 'profiling', 'trueskill', 'tossi==0.0.1', ], ) setup.py install_requires 옵션에 의존성을 적어두면
- 693. from setuptools importsetup setup( name='foobar', install_requires=[ 'profiling', 'trueskill', 'tossi==0.0.1', ], ) setup.py 이 프로젝트를 설치할 때 의존성까지 자동으로 풀리게 돼요.
- 694. from setuptools importsetup setup( name='foobar', install_requires=[ 'profiling', 'trueskill', 'tossi==0.0.1', ], ) setup.py 여기에 패키지명만 적거나 버전을 함께 명시하면 됩니다.
- 695.
- 696. profiling trueskill tossi==0.0.1 -r lib/baz/requirements.txt -e git+https://github.com/sublee/hangulize requirements.txt pipinstall 명령어에 넘길 인자를 적어 놓은 텍스트 파일이에요.
- 697. ❯ pip install-r requirements.txt requirements.txt 이렇게 쓰죠.
- 698. ❯ pip install-r requirements.txt requirements.txt 아주 공식적인 방법은 아니지만
- 699.
- 700.
- 701. tossi==0.0.1 tossi>=0.0.1,<0.1 의존성 걸 때 패키지명만적어도 괜찮긴 하지만
- 702. tossi==0.0.1 tossi>=0.0.1,<0.1 마냥 최신 버전을받아들이면 그 라이브러리가 하위호환을 포기했을 때
- 703.
- 704.
- 705.
- 706. tossi==0.0.1 tossi>=0.0.1,<0.1 이 규칙에서 세번째 버전값을 올릴 땐 어지간해선
- 707.
- 708.
- 709. tossi==0.0.1 tossi>=0.0.1,<0.1 아니면 두 번째버전값만이라도 고정해두는 게 좋습니다.
- 710. Profiling, SmartFormat forPython, Tossi, astdispatch, valuedispatch, Gauge 저희는 그동안 파이썬 커뮤니티를 비롯해 오픈소스 문화의 도움을 정말 많이 받아왔고
- 711. Profiling, SmartFormat forPython, Tossi, astdispatch, valuedispatch, Gauge 저희도 그 문화에 동참하고자 꾸준히 오픈소스 활동을 해오고 있어요.
- 712. Profiling, SmartFormat forPython, Tossi, astdispatch, valuedispatch, Gauge 이 프로젝트들은 저희가 개설해서 GitHub에 공개해둔 것이고
- 713. Profiling, SmartFormat forPython, Tossi, astdispatch, valuedispatch, Gauge 2.4k 그중 Profiling은 관심을 좀 받아서 2천 4백여 개의 별을 모을 수 있었습니다.
- 714. gevent, Couchbase PythonClient, Base-65536 for Python, Babel 그밖에 가져다 쓰던 도구에서 발견한 문제를 고쳐서 패치한 적도 종종 있었고
- 715. Couchbase, GitLab, MsgPackfor CLI 직접 고칠 여력이나 능력이 없어서
- 716. Couchbase, GitLab, MsgPackfor CLI 이슈를 던지고 논의에 참여하는 식으로 기여한 적도 종종 있었어요.
- 717. 파이썬은 오픈소스 커뮤니티가 활발한언어인 만큼
- 718. 오픈소스 문화를 가까이하지 않고서는
- 719. 그 잠재력을 최대한으로발휘하기 어렵다고 생각합니다.
- 720. 파이썬을 계기로, 아니면이 발표를 계기로
- 721. 오픈소스 문화가 우리회사에도 조금씩 스며들 수 있으면 좋겠어요.
- 723.
- 724. 표준 라이브러리가 빵빵한걸 배터리를 내장했다고 표현하는데
- 725.
- 726.
- 727. 이런 특성을 잘이해하면 최대한 코딩을 적게 하면서도
- 728. 파이썬으로 재밌게 작업하실 수있을 겁니다.
- 729. 아울러 오늘 이야기한내용은 저 혼자가 아니라
- 730. 저희 스튜디오 분들과 함께쌓은 노하우라는 걸 알려드려요.
- 731. 그리고 분명 저희보다더 좋은 방법을 쓰고 계신 분들도 많을 거라고 생각하는데
- 732. 그런 여러분의 노하우도 공유받을 수 있으면 좋겠습니다.
- 733.