Python의 반복문

보통 for 구문을 사용해서 0부터 99까지 반복한다고 하면 다른 프로그래밍 언어에선 이런 느낌이 됩니다.

for (let i = 0; i < 99; ++i) {
  do_something(i);
}

하지만 Python에선 for문이 저런 구조가 아닙니다. 그렇기에 우리는 range를 쓴다고 알고 있습니다.

for i in range(100):
    do_something(i)

그럼, range는 뭘까요? range(100)을 실행하면 어떻게 되길래 우리가 원하는 반복문이 되버리는 걸까요? 일단 Python 2에서 확인해보도록 합시다.

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> type(range(10))
<type 'list'>
>>> for i in range(10):
...   print i**3
...
0
1
8
27
64
125
216
343
512
729

100은 블로그에 담기엔 예시결과로는 너무 큰 관계로 10으로 줄였습니다. 실행하면 list로 0 이상 10 미만의 숫자가 들어가는 것을 확인할 수 있습니다. 도움말을 읽으면 당연히 알 수 있지만, range 함수는 정해진 범위를 list로 만들어줍니다. for문은 range의 결과로 나온 list에서 1개씩 뽑아서 사용하는 것이구요. Python의 for는 다른 언어에서의 foreach라고 부르는 것들과 비슷합니다.

for (let i of myArray) {
  do_something(i);
}

Python의 이런 반복은 얼핏보면 편하지만 함정이 있습니다. 만약 0부터 1000억까지 반복을 해야한다면 어떨까요? range(100000000)이라고 적으면 0부터 1000억-1 만큼의 인자가 들어있는 list가 생겨날 것입니다. list에 들어있는 것도 결국 컴퓨터가 저장하고 있어야 하는데 이대로 가다간 메모리가 버틸까요? 이 방법으로 접근하면 너무나도 비효율적입니다. Python으론 이런 방법밖에 없는걸까요?

이 문제를 해결하기 위해 Python 2에는 xrange라는 함수가 있습니다. Python 3에서는 기존의 range를 xrange가 대체했습니다. 위의 예제들을 xrange로 바꿔서 다시 해보죠.

>>> xrange(10)
xrange(10)
>>> type(xrange(10))
<type 'xrange'>
>>> for i in xrange(10):
...   print i**3
...
0
1
8
27
64
125
216
343
512
729

일단 반복문이 잘 돌아간다는 것은 알 수 있지만 그 외의 값은 미궁속입니다.

Python 2의 xrange / Python 3 range 동작 살펴보기

일단 xrange가 어떻게 for문에 값을 전달하는지 알아봅시다. 먼저 xrange 값을 하나 만듭니다. 그리고 iter함수로 iterator를 받습니다.

>>> ten = xrange(10)
>>> it = iter(ten)
>>> it
<rangeiterator object at 0x10f27bde0>

그러면 이제 받은 값으로 ten의 구성요소에 하나씩 접속해볼 수 있습니다.

>>> next(it)
0
>>> next(it)
1
>>> next(it)
2

그리고 next 함수를 이용해서 값을 원하는 시점에 하나씩 받아올 수 있습니다. for문은 이 방식을 이용해서 xrange값의 iterator를 받고 내부적으로 next를 호출해서 사용합니다.

이것은 Python 3의 range도 동일합니다.

>>> ten = range(10)
>>> ten
range(0, 10)
>>> it = iter(ten)
>>> it
<range_iterator object at 0x106c70ed0>
>>> next(it)
0
>>> next(it)
1
>>> next(it)
2

Generator

하지만 이건 Python에서 기본 지원하는 경우이고, 만약 수없이 많은 자료를 돌아다니면서 반복문을 돌려야한다면 어떨까요? 가령 수백만줄의 파일을 읽어서 한줄씩 처리중이었다면 어떻게 해야할까요? 모두 list에 올려놓고 하기엔 메모리가 버티지 못할 것입니다. 그 경우를 위해 Generator가 있습니다.

가볍게 0에서 9까지의 세제곱을 출력하는 Generator를 만들어서 사용해봅시다.

def gen():
    for i in range(10):
        yield i ** 3

for x in gen():
    print(x)

여기서 gen 함수가 바로 generator입니다.

>>> gen()
<generator object gen at 0x106aec1a8>

yield

Generator에서는 yield라는 키워드를 사용합니다. yield의 동작을 알아봅시다.

def gen():
    yield 'one'
    yield 'two'
    yield 'three'

g = gen()
print(next(g))  # one
print(next(g))  # two
print(next(g))  # three
print(next(g))  # raise StopIteration

yield는 함수 실행 중간에 빠져나올 수 있는 generator를 만들 때 사용합니다. return이었다면 'one'이 반환되고 끝났겠지만 실제로는 그 뒤로도 다시 사용할 수 있었죠.

yield는 단순히 값을 내보낼 수만 있는 것은 아니고, 넣어줄 수도 있습니다.

def gen():
    val = 111111
    while True:
        val = (yield val) * 111111

g = gen()
print(next(g))  # 111111
print(g.send(2))  # 222222
print(g.send(3))  # 333333

뭐에 쓰지?

위에서도 언급했지만 대용량 자료 처리등은 메모리에 모두 올려놓고 할 수 없습니다. 그런 경우 한 줄씩 읽은 뒤 generator를 이용한 반복처리를 하면 편합니다. 실제로도 Flask에서의 대용량 파일 전송, Sphinx의 확장 개발등에 사용됩니다.

요약

1. yield 키워드를 사용하면 generator를 만들 수 있다.
2. generator는 한번에 끝나지 않고 여러번에 걸쳐 입출력을 받을 수 있다.
3. 대용량 처리 함수 제작 등에 편리하다
4. 따라서, list가 필요한게 아니라면 Python 2에서 반복은 xrange를 쓰자.

function convertJsonStr($row) {

if(is_null($row)) { 

return "{}"; 

}

$r = "{"; 

for($i = 0; $i < count($row); $i++) { 

$r .= "{"; 

$curr = $row[$i]; 

$end = count($curr); 

$ep = 0; 

foreach($curr as $k => $v) { 

$ep++; 

$r .= "\"" . $k . "\":\"" . $v . "\""; 

if($ep == $end) {

// 할일없음 

}

else {

$r .= ", "; 

}

}

$r .= $row[i]; 

$r .= "}"; 

if($i < count($row) - 1) {

$r .= ", "; 

}

}

$r .= "}"; 

return $r; 

}

자꾸 가물가물해서 퍼왔습니다.

http://byneonkid.tistory.com/98

이번엔 Python을 가상 환경에서 설치하는 방법을 알아봅시다.

왜 Python을 가상 환경에서 설치해야 할까요?

Python의 버전은 현재 2.7 버전과 3.x 버전이 존재합니다. 아마 프로그래밍을 조금 해보신 분들 중에 Java 라는 언어로 프로그래밍을 많이 해보신 분들이라면, 이런 버전의 차이에 굉장히 반감을 하거나 민감하게 반응하실 수 있습니다.

그렇습니다. 그 이유 중에 하나는 바로 여러분들이 프로그램을 개발하다 반드시 사용하게 되는 바로 "라이브러리"라는 녀석 때문이죠. 물론 공개된 라이브러리들은 대부분 최신 버전에 맞춰 수정이 되긴 하지만, 자신이 개발하는 프로젝트 내지 프로그램이 한 라이브러리만 쓰는 것은 아니기 때문에 모든 라이브러리에 버전을 맞추려면 여러 가지 고려해야될 사항이 많아집니다. 

Java의 경우, Java 7 버전과 Java 8 버전을 동시에 설치해야하는 번거로움이 생깁니다. 물론 설치에 대한 번거로움이 끝이 아니죠. 여기에 자신이 어떤 버전의 Java를 쓸 것인지 물어보지도 않고, 그냥 갔다가 컴파일 해버려서 라이브러리 간에 버전 충돌이 일어나는 일이 생기기도 합니다. 여간 불편한 것이 아니죠..

그래서 Python에는 이 개발 환경을 분리시키기 위해 가상 환경이라는 것을 제공합니다.

그림으로 보면, 현재 여러분 PC에 현재 Python이 설치되어 있고, 현재 설치된 Python을 두 공간으로 분리해서 위 프로젝트는 2.7버전, 아래 프로젝트는 3.x 버전으로 환경을 나누게 되면 버전 충돌 문제가 해소됩니다.

Python을 가상 환경으로 구축하는 방법에는 여러 가지가 있지만, 가장 대표적인 방법은 Virtualenv, Anaconda, Docker  방법이 있습니다.

그 중 가장 쉽고 편한 것이 Virtualenv이고, Docker는 최근에 나온 컨테이너 형태의 환경이기 때문에 Python의 가상 환경 뿐만이 아니라 서버의 가상 환경으로도 사용하실 수도 있고, 만약 개발하는 프로젝트가 웹 서버 등의 프로젝트라면, Virtualenv보다는 Docker가 더 좋을 수 있습니다.

이 포스트에서는 간단히 Virtualenv를 사용해 가상 환경을 구축하는 방법을 알아보도록 하겠습니다.

Virtualenv 설치

Virtualenv의 설치는 pip로 간단히 설치할 수 있습니다.

$ sudo pip install --upgrade virtualenv

Linux나 OS X의 경우, sudo 명령어를 이용하여 virtualenv를 설치하시면 됩니다.

혹은 Ubuntu Repository에서도 받으실 수 있습니다.

C:\> pip install --upgrade virtualenv

Windows는 관리자 명령으로 명령 프롬포트를 열어주시고, 위 명령어를 타이핑 하시면 됩니다.

가상 환경 구축

이제 Virtualenv를 설치했으니 이를 이용해 가상 환경을 직접 만들어보도록 하겠습니다.

매우 쉬우니, 그냥 보고 따라하기만 하시면 됩니다.

$ mkdir CVProject

여러분들이 원하시는 경로에 디렉토리를 만들어줍니다. Linux, OS X 에서는 mkdir 명령어를 사용합니다.

C:\Users\K.I.D> md CVProject

Windows는 md 명령어를 사용합니다. (사실 Windows에서 그냥 새 폴더 하나 만든다고 생각하시면 됩니다 ^^;)

$ virtualenv -p ${PYTHON_VERSION} ${DIRECTORY}

virtualenv의 p 옵션을 이용해서 원하시는 Python 버전을 입력하시고, 위에서 만든 디렉토리 이름을 치면, 해당 디렉토리에 Python 가상 환경이 생성됩니다.

ex) Python 2.x 버전은 그냥 Python, Python 3.x 버전은 Python3 라고 입력.

가상 환경 실행

이제 구축을 해봤으니 가상 환경이 제대로 실행되는지 확인해보겠습니다.

$ source CVProject/bin/activate.sh

Linux, OS X는 위 명령어를 이용해 가상 환경을 실행합니다.

C:\Users\K.I.D> CVProject\Scripts\activate

Windows는 Scripts 폴더에 실행 파일이 미리 만들어져 있으므로 이를 실행하면 됩니다.

(CVProject) $ python --version

그럼 이제는 쉘 앞에 자신의 프로젝트 폴더명이 앞에 보일 것입니다.

CVProject) C:\Users\K.I.D> python --version

Windows는 위와 같이 보입니다.

python --version 명령어를 입력해, 자신이 원하는 Python의 버전으로 구축이 되었는지를 확인합니다.

$ whereis python

Linux에서 whereis 명령어를 사용해 python의 PATH를 확인합니다. 마지막 부분에 자신의 가상 환경 경로가 표시됨을 확인할 수 있습니다.

각종 라이브러리 등의 설치는 반드시 (${가상환경 이름})이 나온 상태에서 진행하셔야만 가상 환경에 라이브러리가 설치됩니다. 그렇지 않은 상태에서는 시스템에 설치되므로 반드시 확인바랍니다.

autoenv 사용 (Linux, OS X only)

virtualenv를 사용하려하니 일일이 source 명령어를 사용하는게 매우 번거롭습니다. 그렇다고 터미널이나 쉘을 띄울 때마다 가상 환경을 실행하자니 그것도 문제이지요?

그래서 autoenv를 사용해보기로 했습니다.

$ sudo pip install --upgrade autoenv

autoenv는 kennethreitz님이 개발하신 코드로 virtualenv 디렉토리에 접근하면 자동으로 원하는 커맨드를 입력하게 하는 코드입니다.

작동 방식은 다음과 같습니다.

사실 커맨드 실행이 맞는 표현이겠지만, 우리가 원하는 것은 Virtualenv 실행이 목적이기 때문에, 그렇게 적었습니다 ^^;

이제 실행 방식을 알았으니 자신의 virtualenv 공간에 .env 파일을 생성해봅시다.

$ vim .env

vim 혹은 nano, emacs 같은 에디터를 이용해 .env 파일을 생성합니다.

source ~/CVProject/bin/activate

간단하게 virtualenv만 실행시키는 커맨드를 적었습니다.

source ~/CVProject/bin/activate
clear
echo ''
echo ' I'm CVProject'
echo ' enjoy Coding!'
echo ''
echo '           Created by. Neon K.I.D'
echo ''

고급된 방법(?)으로 스크립트를 작성하실 수도 있습니다.

그럼 이제, 터미널과 쉘을 새로 실행시켜, CVProject 폴더에 들어가면..

$ cd CVProject

Virtualenv 환경에 접근이 가능하다는 것을 알 수 있습니다.

"그런데, 아 나는 이것도 불편해, 간단한 명령어로 처리할 수 있는 방법이 없을까?"

그러시는 분들은, alias를 사용해보는 방법도 있으니, 해당 방법을 써보는 것도 나쁘지 않겠습니다.

$ alias cv='cd CVProject'

저는 간단히 상대 경로를 넣었지만 원래 alias를 하실 때는 절대 경로를 하셔야 됩니다 ^^;

명령어가 잘 동작하는지 확인했으면, 이제 프로필에 넣어주면 되겠죠?

$ vim .bashrc

bashrc 파일을 로드하고, alias 부근이나 아무 군데에 다음과 같이 추가합니다.

alias cv='cd CVProject'

추가하고 저장 한 뒤, 새로운 쉘이나 터미널을 실행하고, cv 명령어만 입력하면 자동으로 가상 환경에 들어가집니다. 

마치며... 

여러가지 내용이 섞여있어 어떤 말인지 모르시는 분들이 많으실 수도 있습니다. 개발 환경을 구축하는 데는 마치 코딩과 같아 여러분들이 얼마든지 튜닝만 한다면 편한 개발 환경이 될 수도 있고, 그렇지 않을 수 있습니다.

Python의 가상 환경은 그만큼의 메리트가 존재합니다. (언어의 사용도 그만큼 메리트가 있었으면.... (?) ) Java에도 개인적으로 이런 환경이 나오기를 원하지만, 그 환경을 Docker가 그나마 메꿔주고 있기 때문에 참 Docker 정말 좋습니다 ^^

여기까지 Virtualenv를 이용한 Python 개발 환경 구축이었습니다.

출처: http://byneonkid.tistory.com/98 [긁적긁적.....]

text = 'foo = 23 + 42 * 10'

tokens = [('NAME', 'foo'), ('EQ', '='), ('NUM', '23'), ('PLUS', '+'),
          ('NUM', '42'), ('TIMES', '*'), ('NUM', '10')]

import re
NAME = r'(?P<NAME>[a-zA-Z_][a-zA-Z_0-9]*)'
NUM = r'(?P<NUM>\d+)'
PLUS = r'(?P<PLUS>\+)'
TIMES = r'(?P<TIMES>\*)'
EQ = r'(?P<EQ>=)'
WS = r'(?P<WS>\s+)'

master_pat = re.compile('|'.join([NAME, NUM, PLUS, TIMES, EQ, WS]))

from collections import namedtuple
import json
Token = namedtuple('Token', ['type', 'value'])

def generate_tokens(pat, text):
    scanner = pat.scanner(text)
    for m in iter(scanner.match, None):
        yield Token(m.lastgroup, m.group())

for tok in generate_tokens(master_pat, 'foo = 42'):
    print(tok)

tokens = (tok for tok in generate_tokens(master_pat, text) if tok.type != 'WS')
#print(list(tokens))
jj = {}
for tok in tokens:
    #print(tok)
    #t = "'{0}':'{1}'".format(tok.type, tok.value)
    #t = ':'.join([tok.type, tok.value])
    jj[tok.type] = tok.value

print(jj)

jj2 = json.dumps(jj)
print(jj2)

print("")
# 테스트용 Dictionary
customer = {
    'id': 152352,
    'name': '강진수',
    'history': [
        {'date': '2015-03-11', 'item': 'iPhone'},
        {'date': '2016-02-23', 'item': 'Monitor'},
    ]
}

# JSON 인코딩
jsonString = json.dumps(customer)

# 문자열 출력
print(jsonString)
print(type(jsonString))  # class str

• 파이썬 이터레이터

지난 글에서는, 생산자-소비자 패턴(Producer-Consumer Pattern)의 소비자 쪽의 코드를, 함축적이면서도 자연스럽게 기술할 수 있는 방법을 제공하는 이터레이터를 살펴봤습니다. 오늘은 생산자 쪽을 들여다봅니다.

앞서 Range 라는 클래스를 통해 이터레이터를 살펴보았습니다만, 이 코드에는 불편한 부분이 있습니다. 대부분의 작업은 __next__() 메쏘드를 통해 구현되는데, 매번 예전의 상태를 복구한 후, 작업을 수행하고, 다시 상태를 저장하는 작업을 반복하게 됩니다. Range 와 같은 간단한 작업에서야 문제될 것이 없지만, 알고리즘을 기술하는 자연스러운 방식에서 벗어나 있기 때문에, 작업이 복잡해질수록 점점 문제가 됩니다. 이런 스타일의 프로그래밍은 이벤트 주도형 프로그래밍(event-driven programming)에서 자주 등장하는데, 비동기 IO(Asynchronous IO) 나 GUI 프로그래밍을 해 보셨다면 이미 익숙할 겁니다.(지금 우리가 걷고 있는 길은 이 문제들에 대한 직접적인 해결책으로 이어집니다. 하지만 아직은 갈 길이 멉니다.)

파이썬에서는 제너레이터(generator)라는 이터레이터의 확장을 제공합니다. 이터레이터가 단지 프로토콜인데 반해, 제너레이터는 yield 라는 전용의 키워드를 통해 문법적인 특별함을 더합니다. Range 를 제너레이터로 다시 구현해 보겠습니다. (되도록 이터레이터 구현과 유사하게 코드를 구성했습니다.)

>>> def Range(n):
...     c = 0
...     while c < n:
...         yield c
...         c += 1
>>> for x in Range(3):
...     print(x)
0
1
2

파이썬은 함수 정의에 yield 키워드가 등장하면 그 함수 전체를 제너레이터로 인식하고, 특별한 VM 코드를 생성해냅니다. 함수의 코드를 재구성해서 같은 일을 하는 이터레이터를 만든 다음, 원래 함수는 그 이터레이터 인스턴스를 돌려주는 함수로 바꾼다고 보시면 됩니다.

>>> Range(3)
<generator object Range at 0x1017d3370>

제너레이터는 이터레이터입니다.

>>> r = Range(3)
>>> next(r)
0
>>> next(r)
1
>>> next(r)
2
>>> next(r)
Traceback (most recent call last):
  File "<console>", line 1, in <module>
StopIteration

이터레이터 구현과 제너레이터 구현간에는 이런 문법적인 차이가 있습니다.

• 이터레이터 구현에서 __next__() 의 return 값은, 제너레이터 구현에서는 yield 값으로 대체됩니다.
• 제너레이터에서 return 문은 StopIteration 예외를 일으킵니다. 함수의 끝에 도달해도 마찬가지 입니다. 파이썬 3 에서는 return 문이 값을 포함할 수도 있지만, 오늘 다룰 범위를 벗어납니다.

제너레이터를 위해 파이썬이 만들어내는 이터레이터를 제너레이터-이터레이터(generator-iterator)라고 부르는데, 이터레이터는 프로토콜인 반면 제너레이터-이터레이터는 실제 구현이 제공되는 것이라, 일반적인 이터레이터에서 지정하지 않은 동작들이 구체적으로 정의되기도 합니다.

가령 예외의 경우, 이터레이터의 __next__() 가 StopIteration 또는 그 외의 예외를 일으킨 후에 이터레이터가 어떤 상태가 되는지는 정의되어있지 않습니다. 하지만 제너레이터의 경우는 항상 이렇게 됩니다.

• 일단 StopIteration 예외가 일어나면 그 이후에는 계속 StopIteration 예외를 일으킵니다.
• StopIteration 이외의 예외가 일어나면, 일단 caller 에게 예외가 전달됩니다. 하지만 그 이후로는 계속 StopIteration 예외를 일으킵니다.

재진입(Reentrancy) 문제도 이터레이터에서는 정의되어있지 않습니다. 가령 __next__() 메쏘드 내에서 직접적이던 간접적이던 next(self)를 호출했을 때 어떤 일이 일어나야 할지 지정되어 있지 않다는 것입니다. 그러니 재귀적인 구현도 생각해볼 수 있습니다. 하지만 제너레이터에서는 재진입이 허락되지 않습니다.

>>> this = (lambda: (yield next(this)))()
>>> next(this)
Traceback (most recent call last):
  File "<console>", line 1, in <module>
  File "<console>", line 1, in <lambda>
ValueError: generator already executing

그런데 이 예에서 볼 수 있듯이 lambda 로 제너레이터를 만들어도 문제가 되지는 않습니다. 그런데 lambda 의 바디에는 문장(statement)이 아니라 표현식(expression) 이 온다는 것을 기억하십니까? yield 를 둘러싼 괄호가 yield 가 표현식임을 알려줍니다. 예 지금까지 저희는 yield 를 문장처럼 사용해 왔습니다만, 사실 yield 는 표현식입니다. 그러면 그 값은 뭘까요?

지금까지의 예 에서 yield 표현식(yield expression)의 값은 None 입니다.

>>> def G():
    while True:
        input = yield 'output'
        print(repr(input))
>>> g = G()
>>> next(g)
'output'
>>> next(g)
None
'output'

처음 인쇄된 'output' 은 next(g) 의 반환 값이고, 다음 next(g) 호출의 처음에 인쇄된 None 이 yield 표현식의 결과값입니다. 순서를 잘 기억하세요, 첫 번째 next() 에서 yield 로 값을 전달한 후에, 다음 next() 가 호출될 때야 비로소 yield 표현식이 값을 전달합니다.

caller 가 제너레이터로 값을 전달해 준다면 yield 표현식은 None 이외의 값을 가질 수 있습니다. 이를 위해 제너레이터에는 send() 라는 메쏘드가 제공됩니다.

>>> g = G()
>>> next(g)
'output'
>>> g.send('input')
'input'
'output'

None 이 send() 가 전달한 'input'으로 대체된 것을 확인하실 수 있습니다. 주의할 부분은 첫 번째 next(g) 대신 g.send('input') 을 사용할 수 없다는 것입니다.

>>> g = G()
>>> g.send('input')
Traceback (most recent call last):
  File "<console>", line 1, in <module>
TypeError: can't send non-None value to a just-started generator

이유는 앞에서 주의를 부탁한 실행 순서 때문입니다. 첫 번째 yield 표현식은 최초의 yield 가 일어난 후에 전달됩니다. 즉 send() 메쏘드는 yield 로 값을 전달한 후에, caller 가 next() 나 send() 를 호출해주기를 기다리고 있는 제너레이터에만 사용될 수 있습니다. 꼭 send()를 사용해야 한다면 None 을 전달할 수 있습니다.

>>> g = G()
>>> g.send(None)
'output'

next(g) 는 g.send(None) 과 같은 의미로 해석됩니다.

제너레이터에는 send() 외에도 throw() 와 close() 라는 메쏘드가 더 제공됩니다. 이 메쏘드들은 나중에 다룰 기회가 있을 겁니다만, 제너레이터에 이런 기능들이 들어간 목적이 무엇일까요? 그 것은 바로 다음에 다룰 코루틴(coroutine) 때문입니다.

http://www.flowdas.com/blog/iterators-in-python/

대부분의 파이썬 튜토리얼들과는 달리 파이썬 3.3을 중심으로 기술하고 파이썬 2를 포함한 하위 버전에서 차이를 보이면 따로 설명합니다.

파이썬의 시퀀스는 for 루프로 탐색할 수 있습니다.

>>> for e in [1,2,3]: # 리스트
...     print(e)
1
2
3
>>> for e in (1,2,3): # 튜플
...     print(e)
1
2
3
>>> for e in 'abc': # 문자열
...     print(e)
a
b
c

for 루프는 시퀀스가 아닌 딕셔너리(dictionary)에서도 가능합니다.

>>> for k in {'a':1, 'b':2, 'c':3}: # 딕셔너리
...     print(k)
b
c
a

이 경우 딕셔너리의 키를 탐색하게 되는데, 키가 전달되는 순서는 정해지지 않았습니다. 때문에 여러분이 직접 실행할 경우, 위의 예와는 다른 순서로 키가 인쇄될 수 있습니다. 이터레이터(iterator)를 제공한다면 시퀀스가 아닌 타입도 for 루프로 탐색할 수 있습니다. 이터레이터는 내장 함수 iter() 를 사용해서 얻습니다.

>>> iter({})
<dict_keyiterator object at 0x108f7afc8>

이렇게 얻은 이터레이터를 탐색하려면 내장 함수 next() 를 사용하면 됩니다.

>>> it = iter({'a':1, 'b':2, 'c':3})
>>> print(next(it))
b
>>> print(next(it))
c
>>> print(next(it))
a
>>> next(it)
Traceback (most recent call last):
  File "<console>", line 1, in <module>
StopIteration

next() 를 사용해 한 번에 하나씩 탐색해 나가다가, StopIteration 예외가 발생하면 끝냅니다. 이러한 탐색 법에 대한 약속을 이터레이터 프로토콜(Iterator Protocol)이라고 부르는데, for 루프는 간결한 문법을 제공합니다.

>>> for e in container:
...     print(e)

는 다음과 같은 while 루프와 동일한 결과를 줍니다.

>>> it = iter(container)
>>> while True:
...     try:
...         e = next(it)
...         print(e)
...     except StopIteration:
...         break

사용자가 정의한 클래스가 이터레이터를 지원하려면 __iter__() 메쏘드를 정의하면 됩니다. iter() 는 객체의 __iter__() 메쏘드가 돌려주는 값을 이터레이터로 사용합니다. next() 에 이터레이터를 전달하면 이터레이터의 __next__() 메쏘드를 호출합니다. 때문에 최소한의 이터레이터는 이렇게 구성할 수 있습니다.

>>> class Range:
...     def __init__(self, n):
...         self.n = n
...         self.c = 0
...     def __iter__(self):
...         return self # 이터레이터인 경우는 자신을 돌려주면 됩니다.
...     def __next__(self):
...         if self.c < self.n:
...             v = self.c
...             self.c += 1
...             return v
...         else:
...             raise StopIteration
...     next = __next__ # 파이썬 2 에서는 __next__ 대신 next 를 사용합니다.
>>> for x in Range(3):
...     print(x)
0
1
2

Range 클래스는 이터레이터 외의 용도가 없습니다. 하지만 딕셔너리는 별도의 용도가 있고, 사실 딕셔너리는 이터레이터가 아닙니다.

>>> next({})
Traceback (most recent call last):
  File "<console>", line 1, in <module>
TypeError: 'dict' object is not an iterator

딕셔너리를 for 루프에 직접 사용할 수 있는 이유는 딕셔너리 역시 __iter__() 메쏘드를 제공하고 있기 때문입니다. 비슷한 방법으로 RangeFactory 라는 클래스를 만들어보면:

>>> class RangeFactory:
...     def __init__(self, n):
...         self.n = n
...     def __iter__(self):
...         return Range(self.n)
>>> for x in RangeFactory(3):
...     print(x)
0
1
2

__next__() 메쏘드를 제공하고 있지 않기 때문에 RangeFactory 의 인스턴스는 이터레이터가 아닙니다만, __iter__() 메쏘드를 통해 이터레이터(이 경우에는 Range 인스턴스)를 제공하고 있기 때문에 for 루프에서 사용될 수 있습니다. 사실은 이 용법 때문에 이터레이터에도 큰 의미 없는 __iter__() 메쏘드를 만들어주도록 요구하고 있습니다.

이렇게 for 루프에 이터레이터를 직접 요구하지 않고, 이터레이터를 만드는 객체를 요구함으로써, 많은 경우에 for 루프가 깔끔해지기는 하지만, 간혹 혼란을 야기할 수 있는 경우도 발생할 수 있습니다.

>>> r = Range(3)
>>> for x in r:
...     print(x)
...     if x == 1:
...         break
0
1
>>> for x in r:
...     print(x)
2

두 개의 for 루프는 동일한 Range 인스턴스를 사용하고 있습니다. 반면에 RangeFactory 를 사용하는 경우는:

>>> r = RangeFactory(3)
>>> for x in r:
...     print(x)
...     if x == 1:
...         break
0
1
>>> for x in r:
...     print(x)
0
1
2

이 경우는 for 루프를 시작할 때마다 새로운 이터레이터(Range 인스턴스)가 만들어집니다. 때문에 매번 새로운 루프가 시작되는 것이지요. for 루프가 이터레이터를 재사용하는 것으로 보일 때는, 인스턴스가 이터레이터인지 이터레이터를 제공하는 객체인지를 확인하는 것이 중요할 수 있습니다.

프로그래밍을 하다 보면 한쪽에서 생산하고(produce), 다른 쪽에서 소비(consume) 하는 상황을 자주 만납니다. 이를 생산자-소비자 패턴(Producer-Consumer Pattern)이라고 하는데, 이터레이터는 소비자 쪽의 코드를 함축적이면서도 자연스럽게 기술할 수 있는 방법을 제공합니다. 이제 필요한 것은 생산자 쪽의 코드를 자연스럽게 구성할 수 있는 방법입니다. 다음에 다룰 제너레이터(Generator) 가 파이썬의 대답입니다.

• 파이썬 제너레이터

import pymongo

con = pymongo.Connection('localhost', port=27017)

tweets = con.db.tweets

import requests, json

url = 'http://search.twitter.com/search.json?q=python%20pandas'

data = json.loads(requests.get(url).text)

for tweet in data['results']:

    tweets.save(tweet)

cursor = tweets.find({'from_user' : 'wesmckinn'})

tweet_fields = ['created_at', 'from_user', 'id', 'text']

result = pd.DataFrame(list(cursor), columns=tweet_fields)

지난번에 다룬 keras를 활용해서 LSTM(Long Short-Term Memory)을 이용한 감성 분석을 해보겠습니다.

데이터는 이전과 마찬가지로 train/test 각각 2천개 씩 배정해서 모델을 학습하고, test set에 대한 accuracy를 구하는 과정으로 진행됩니다.

Keras에는 imdb 데이터가 이미 전처리되어 저장되어있기 때문에 그대로 불러옵니다. 이때 상위 5000개의 단어만 활용하겠습니다.

train/test 데이터를 알맞은 형태로 바꿔주고

lstm을 이용해서 모델을 만들어줍니다. 모델에 대한 설명은 다른 포스팅을 통해 다루겠습니다.

위와 같은 옵션으로 컴파일링을 하고 fitting을 시킨 다음 test data를 학습합니다.

0.76의 accuracy가 나왔습니다.

지금까지 여러가지 statistical methods를 통해 분석을 해보았습니다. 그 결과 2000개의 train data에 대해서

SentiWordnet : 71%

Naive Bayes : 82%

Doc2Vec : 91.8%

LSTM : 76%

의 정확도를 보였습니다.

물론 가장 기본적인 모형만 만들었기 때문에 parameter를 튜닝하거나 모델을 변형해서 더 나은 accuracy를 만들수 있을 것입니다.

저번 시간의 Naive Bayes Classifier에 이어서 Doc2Vec에 대해 알아보겠습니다.

Doc2Vec은 벡터 공간 모형의 일종으로 간단한 신경망 모형을 통해 만들어지는 모델입니다.

Word2Vec과 유사하지만 단어가 아닌 문장, 문단, 문서를 통해 벡터를 만들기 때문에 단어간의 유사성 뿐만 아니라 문서의 구성요소간의 유사성을 정의하고 계산할 수 있습니다.

즉, 문맥을 고려한 분석이 가능하다는 것이 가장 큰 장점입니다.

Doc2Vec을 활용한 감성 분석을 하기 위해 먼저 gensim 외 필요한 패키지를 불러옵니다.

Doc2Vec 모델 생성을 위한 gensim 패키지!

Text preprocessing 을 위한 nltk패키지

Naive Bayes와 같은 방식을 통해 전처리와 train/test data셋을 생성합니다.

리뷰 리스트와 레이블 리스트를 합쳐서 LabeledLineSentence 객체를 생성합니다.

그 다음 Doc2Vec모델을 다음과 같이 학습시킵니다.

size 는 feature 벡터의 차원입니다.

window는 문서의 내에서의 예측을 위한 예측된 단어와 문맥의 단어들 사이의 최대 거리입니다.

dm은 트레이닝 알고리즘으로 distributed memory가 default 값입니다.

alpha값은 초기 학습률(learning rate)이고 min_alpha는 alpha값이 학습과정에서 선형으로 줄어들어서 도달하는 최소 값입니다.

min_count 이하의 total frequency를 가진 단어들은 모두 무시됩니다.

workers는 cpu의 코어 수에 따라 multi-threads를 지원해서 병렬처리하는 옵션입니다.

그 밖의 옵션에 대한 설명은 https://radimrehurek.com/gensim/models/doc2vec.html을 참고해 주세요.

이제 생성된 모델을 통해서 앞서 NBC와 같이 train 셋에 대해 감성 분석을 시행하겠습니다.

logistic regression classifier를 이용해서 긍, 부정으로 분류하였습니다.

test 셋에서 출력해본 결과 약 91.65%의 정확도를 보였습니다. NBC보다 높은 정확도를 보였지만 전체데이터(25000)를 대상으로 한 경우 정확도가 79%대로 떨어지는 모습을 보였습니다.

특정 분석법이 절대 우위에 있는 것이 아니라 다양한 분석방법을 시행해보고 결과를 비교해 보는 것이 좋은 방법 같습니다.

다음 시간에는 감성 분석의 마지막 시간으로 인공신경망(ANN)을 활용한 감성분석을 해보도록 하겠습니다.

저번 포스팅에서는 Sentiment Analysis(SA)의 방법 중 하나인 knowledge based technique에 대해서 살펴봤습니다.

이번에는 Statistical methods을 통해서 감성 분석을 해보겠습니다.

1. Naive Bayes classifier

나이브 베이즈 분류기를 다루기 전에 먼저 TF-IDF(Term Frequency – Inverse Document Frequency)와 같은 벡터 공간 모형에 대해서 알아보겠습니다.

TF_IDF는 이와 같은 형태로 문장에서 해당하는 단어의 등장 여부에 따라서 다음과 같이 나타냅니다. 이 때 단어의 등장여부를 T/F로 보는 boolean model, 단어의 등장 횟수로 보는 frequency model 둘다 가능합니다.

여기서 자주 등장하는 단어를 통해 하나하나의 dimension을 생성하는 것이 벡터 공간 모형의 기초적인 형태입니다. 그리고 이러한 feature에 기계학습 알고리즘을 통해서 train을 진행합니다.

먼저 긍정 학습 데이터에서의 모든 토큰을 words라는 리스트에 저장합니다.  이때  Stopwords도 함께 제거해줍니다

같은 방식으로 부정 학습 데이터에서 Stopwords 를 제거하고 words리스트에 붙여 넣습니다.

words리스트를 이용해서 3000 dimension의 word feature를 생성합니다.

word feature를 통해서 분석할 데이터의 feature를 생성하는 함수도 만들어 줍니다.

이제 첫번째 리뷰 데이터의 문장들을 이용해서 feature를 생성해보겠습니다.

첫 번째 리뷰 데이터의 feature생성 결과입니다.

같은 방법으로 1000개의 리뷰 데이터에 대해 feature set을 생성해서 리스트에 저장합니다.

본격적으로 나이브 베이즈 분류기(Naive Bayes Classifier)를 통해 감성분석을 시작하겠습니다. 분류기는 nltk에 내장되어 있기 때문에 따로 설치할 것은 없습니다.

가장 먼저 2000개의 영화 리뷰를 긍/부정으로 분류해보겠습니다.

training,test set을 위한 feature set을 만들어준다음

순서대로 앞의 2000 set은 training 나머지는 test set으로 분류합니다

그 다음 nltk의 나이브 베이즈 분류기를 실행해주면 됩니다. 전처리에 비해 정말 간단합니다…

분류기를 training한 뒤에는 test set에서 얼마나 잘 작동하는지 살펴봅니다.

82%의 분류율이 나옵니다. 샘플 데이터라서 그런지 생각보다 높은 분류율을 보여주는 것 같네요. 같은 방법으로 전체 데이터(train 25000, test 25000)으로 한 결과 82.756의 정확도로 2000개의 train 데이터의 경우와 비교해 크게 향상되진 않았습니다.

다음 포스팅에서는 나머지 감성 분석 방법들에 대해 알아보겠습니다.

책, 영화등과 같은 매체를 보고나면 그에 대한 피드백이 발생합니다. 어떤 사람들은 주위 지인들에게 평가를 공유하기도 하고 어떤 사람들은 어떤 인상을 받았는지 인터넷 상에 글을 남깁니다. 이번 포스팅에서는 이러한 리뷰들의 단어에 긍/부정을 평가하여 그 리뷰, 더나아가 그 영화에 대한 감정이 긍정적인지 부정적인지 살펴보려고 합니다.

Sentiment Analysis(SA) 에는 크게 세 가지 방식이 있습니다.

• knowledge-based techniques
• statistical methods
• hybrid approaches

먼저 knowledge-based technique은 단어들의 감정의 정도를 평가하는 사전을 만들고 이를 활용해서 단어 또는 글의 감정 상태를 평가하는 방법입니다.

예를 들어 SentiWordnet은 단어 마다의 긍/부정 척도를 더한 대표적인 db로 Python의 nltk에 포함되어 있습니다.

다음으로 statistical method는 SVM(support vector machine)이나 ‘bag of words’등 다양한 ML 방법론을 활용해서 단어의 감정을 분류하는 방법입니다. Python의 nltk 패키지에 naive bayes classifier도 통계적 방법 중 하나입니다.

마지막으로 hybrid approaches의 경우 두 방법을 적절하게 혼합하여 활용하는 방법입니다.

SA에서 가장 힘든 부분 중 하나는 비정형인 자연어의 노이즈들이 많다는 점입니다. 인간의 경우 다양한 문맥에 따라서 흐름을 쉽게 파악할 수 있지만 기계는 어렵습니다.

예를 들어 ‘내가 치킨을 싫어하는 것은 아니야.’ 라는 문장을 보았을 때 사람들은 이 문장이 postive 또는  neutral 하다고 쉽게 판단하지만 긍/부정 단어에 점수를 매기는 knowledge-based technique에서는 negative 문장으로 해석될 수 있습니다. 이처럼 이중 부정문을 다루거나 비속어, 은유, 비유 또는 풍자 등과 같은 skill을 학습하기 힘들기 때문에 현재까지는 한계점이 뚜렸하다고 생각합니다.

네이버 평점 9점대에 빛나는 바로 그 영화! – sarcastic review의 대표적인 사례

이제 본격적으로 샘플 데이터를 활용해서 SA를 해보겠습니다.

http://ai.stanford.edu/~amaas/data/sentiment/

에서 데이터셋을 받습니다. 이 데이터는 IMDb라는 미국 영화 사이트의 리뷰를 50,000개 수집하여 리뷰마다 각각 긍/부정 분류로 나눈 데이터 셋입니다.

os 패키지는 operating system의 약자로 운영체제에서 쓰는 여러 기능들을 python에서도 쓸수 있게 해주는 패키지입니다.

먼저 긍정 리뷰중 하나를 review에 담았습니다.

제대로 리뷰가 담긴것을 확인하시면 for문을 이용해서 전체 긍정 리뷰를 pos_train_list에 저장합니다.

train positive 리뷰를 모두 저장했다면 이제 knowledge-based techniques 중 하나인 SentiWordNet에 대해 알아보겠습니다.

[SentiSynset(‘hate.n.01’), SentiSynset(‘hate.v.01’)]

sentiwordnet을 쓰기 위해 nltk 패키지를 import하고 ‘hate’라는 단어를 불러왔습니다. filter object 타입을 list로 바꾸면 n, v로 각각 명사 동사의 유의어가 나온것을 볼 수 있습니다.

0.0

0.75

hate라는 동사의 긍/부정 스코어를 확인하면 각각 0, 0.75점 입니다.

단어마다 여러 유의어가 존재하는 경우가 있습니다. 그래서 편의를 위해 특정 단어의 모든 유의어의 긍/부정 스코어를 각각 평균한 것으로 쓰기 위해 함수를 정의합니다.

(0.625, 0.03125)

love의 동사 유의어 점수 평균은 0.625이다.

2.5/4=0.625이므로 잘 동작하는 것을 알 수 있습니다.

원리를 그대로 사용해서 for문을 이용하면 문장에서의 긍/부정 지수도 쉽게 구할 수 있습니다.

이제 본격적으로 아까 다운받은 영화 리뷰 자료에서 postive train 리뷰 10가지와 negative train 리뷰 10가지를 불러와 SA를 해보겠습니다.

긍정적 리뷰와 부정적 리뷰를 순서대로 10개씩 불러왔기 때문에 actual에는 1(긍정)을 10번 반복하고 0(부정)을 10번 반복했습니다. 그 다음 과정은 앞과 마찬가지로 리뷰를 10개씩 불러와서 tokenize를 하고 pos_tag를 붙여서 리스트로 만들어주는 작업입니다. 합산된 긍/부정 스코어를 if문을 통해 대소비교를 하는데, 긍정 수치가 높으면 1을 반환하고 그렇지 않다면 0을 predicted에 반환합니다.

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1]
Number of correct instance: 12
Number of incorrect instance: 8

코드를 실행하면 다음과 같은 결과가 출력됩니다. 60%의 확률로 긍/부정 리뷰를 맞추는 성능을 보이고 있습니다.

다음 포스팅에서는 statistical methods중 하나인 Naive Bayes를 통한 감성 분석에 대해 알아보겠습니다.

첫번째 글에 이어서 이번에는 단어들간의 관계를 살펴보도록 하겠습니다.

similarity를 구해 리뷰의 단어 중 문맥상 서로 유사한 단어를 살펴보겠습니다.

텍스트의 연어(Collocation)을 출력해보면 아래와 같습니다.

dark knight; heath ledger; christian bale; harvey dent; comic book; christopher nolan; brucewayne; aaron eckhart; gary oldman; two face; maggie gyllenhaal; morgan freeman; rachel dawes;special effects; batman begins; gotham city; 've seen; district attorney; michael caine; superhero

빈번하게 같이 사용되는 단어들이 출력된 것을 확인할 수 있습니다.

마지막으로 연관 단어 그래프를 만들어 보도록 하겠습니다.

리뷰의 텍스트를 바탕으로 같은 문장에서 등장하는 명사들끼리 연결된 그래프를 만드려고 합니다. 먼저 unique 명사들을 추출해서 uniqueNouns 리스트에 추가하는 과정입니다.

위와 같이 행렬을 생성한 다음

이중 for문을 이용해 각 원소에 명사가 들어온 경우 1의 값을 반환하게 합니다.

그리고 이 행렬의 전치와 곱하여 co-occurrence matrix(동시 발생 행렬)를 생성합니다

행렬에서 값이 30이상은 결과 값을 이용해 노드를 만들었습니다.

http://www.imdb.com/title/tt0110912/?ref_=nv_sr_1

영어로 된 영화 평점 사이트에서 리뷰를 크롤링하고 간단한 텍스트 마이닝을 해보겠습니다.