Mark Lee (이원하)

스마트 컨트랙트(Smart Contarct) 개발환경 구축 (Geth)

Tue, 30 Jun 2020 01:01:01 +0000

스마트 컨트랙트(Smart Contarct) 개발환경 구축 (Geth)

블록체인은 중앙 집중화된 서버의 형식으로 동작하지 않고 각각의 노드들이 분산 되어 서로간의 연결(Peer to peer)로 이루져 있다. 이렇게 서로 노드간의 통신을 할 수 있는 표준을 준수하는 프로그램들을 “이더리움 클라이언트 프로그램”이라고 정의한다. 이더리움 클라이언트는 다양한 언어로 개발할 수 있으며 그중 많이 사용하는 것이 구글에서 개발하는 “GO” 언어로 개발된 “Go Ethereum”이다.

실제 이더리움 클라이언트 프로그램은 이더리움의 메인 네트워크에 접속하고 하나의 노드로 동작하도록 구성되어 있다. 만약 이러한 클라이언트를 이용하여 스마트 컨트랙트를 작성하고 배포한다면 우리는 채굴자에게 실제 비용(가스비라고 한다)을 이더로 지불해야 한다.

프로그램을 개발해 본 독자라면 누구나 동의하겠지만 프로그램이 한번에 완벽하게 끝나는 경우는 없을 것이다. 항상 개발하고 테스트 하고 오류를 수정하는 과정을 거쳐야 하는데, 이 때마다 비용을 지불하면서 개발을 하기에는 너무 큰 어려움이 있다. 이러한 점을 해결해 주기 위하여 이더리움 클라이언트는 메인 네트워크에 접속하지 않고 개인 네트워크를 직접 설정하여 구성할 수 있는 방법을 제공해 준다.

일반적으로 스마트 컨트랙트를 개발하고 배포하는 과정은 “Test RPC(사설 네트워크)”에서 개발 및 디버깅을 한 후 이더리움 메인 네트워크와 동일한 구조를 가진 “TestNet”에서 테스트를 하고 완료되면 메인 네트워크(Ethereum Main Network)에 배포한다.

1. Go Ethereum

이더리움 네트워크의 구조를 알아보기 위해서는 사용에는 조금 불편하지만 “Go Ethereum(이하 Geth)를 이용하는 방법에 대해 알아보는 것이 필요하다. “Geth”는 “HTTP JSON RPC”, “web3.js” 및 “Solidity” 인터페이스를 제공해 주며, 이를 이용하여 스마트 컨트랙트를 작성하거나 계정간의 데이터를 전송할 수 있다. 실제 책에서 본 과정을 진행하면서 우리는 가나슈(Ganache)라는 테스트 네트워크를 이용할 것이지만 기본적인 개념을 위하여 먼저 “Geth”를 설치해 보도록 하자.

먼저 “Geth”의 공식 사이트인 https://geth.ethereum.org/downloads/ 에 접속하여 독자의 운영체제에 맞는 프로그램을 다운로드 받는다.

[그림 1] Go Ethereum 다운로드 페이지 (https://geth.ethereum.org/downloads)

2020년 6월 현재 “Geth”는 v1.9.15까지 배포되었다. 본 책에서는 윈도우즈를 기반으로 설명할 예정이므로 “Geth 1.9.15 for Windows”를 클릭하여 다운로드 받은 후 설치 파일을 실행한다. 설치 파일을 실행하면 다음과 같이 라이센스 부분에 대한 동의를 요구하는 대화상자가 나타난다.

[그림 2] 라이센스 동의

[I Agree]를 클릭하여 다음으로 이동하면 설치할 항목을 지정할 수 있는 대화상자가 나타난다.

[그림 3] 설치 파일의 선택

노드를 형성하고 블록 체인에 접속하기 위한 “Geth” 이더리움 클라이언트와 콘솔 모드에서 개발을 도와줄 수 있는 “Development tools”를 선택한 후 [Next] 버튼을 누른다.

[그림 4] 설치 경로의 지정

“Geth”가 설치될 디렉터리를 지정한 후 [Install]을 클릭하면 설치가 진행된다.

[그림 5] 설치의 진행

설치 과정중에 [그림 6]과 같이 환경 변수 설정에 대한 정보가 나타난다.

[그림 6] PATH 설정

“Geth”는 설치되면서 윈도우 환경변수에 실행 파일에 대한 경로를 지정하도록 되어 있는데, 정상적으로 경로가 업데이트 되는 경우에도 가끔 “PATH not updated, …“이라는 메시지가 나타난다. 설치가 완료된 후 정상적으로 “Geth” 가 실행되지 않는 경우에는 시스템 환경변수를 설정해 주어야 한다. 설치가 완료되면 [Close] 버튼이 활성화 된다. [Close] 버튼을 눌러 프로그램의 설치를 마친다.

정상적으로 설치되었는지 확인하기 위하여 명령 프롬프트를 관리자 모드로 실행한 후 프롬프트 상에 다음과 같이 “Geth” 실행 명령을 입력한 후 엔터키를 입력하여 구동시킨다.

c:\Users\MarkLee\geth

정상적으로 “Geth”가 실행되면 [그림 7]과 같이 환경 설정 정보들이 나타나면서 구동을 시작한다.

[그림 7] “Geth”의 실행

앞에서 “Go Ethereum”은 이더리움 클라이언트로 메인 네트워크에 접속하여 노드를 형성한다고 하였다. “Geth”를 기동하면 실제 이더리움 네트워크에 접속하여 블록들을 다운로드 받기 시작한다. 실제 모든 블록의 정보를 다운로드 받으려면 네트워크 상황에 따라 다르지만 하루 정도의 시간이 소요되고 저장되는 데이터도 상당하다.

우리는 이더리움 메인 네트워크의 노드로 ‘Geth”를 사용하는 것이 아니라 사설(private) 이더리움 네트워크를 설치하고 스마트 컨트랙트를 개발하는 것이 목적이므로 프로그램을 종료 시킨 후 (Ctrl + C 키 이용) 사설 네트워크를 구동하도록 하겠다.

시스템 환경 변수 설정
윈도우 시스템은 실행 파일의 경로를 PATH에 기록하여 어떠한 디렉터리에서도 실행이 가능하도록 설정해 놓을 수 있다. [제어판] → [시스템 보안] → [시스템]으로 이동한 후 왼쪽의 [고급 시스템 설정]을 클릭한다.

[그림 8] 고급 시스템 설정

시스템 속성 설정창에서 [환경 변수] 부분을 클릭 한다.

[그림 9] 시스템 Path 선택

하단의 “시스템 변수(S)” 부분에서 “Path” 부분을 선택한 후 [편집] 버튼을 클릭한다. [그림 10] 환경 변수 추가

환경 변수 부분에 설치한 “Geth” 의 경로가 나타나지 않는다면 [새로 만들기(N)]를 클릭하여 설치된 경로를 추가하여 주면 된다.

1.1 사설 이더리움의 설치

공용 이더리움에 DApp을 배포하게 되는 경우 비용(Gas)이 발생하게 되므로 사설 이더리움을 설치하여 개발한 후 최종본을 공용 이더리움에 배포를 하는 것이 일반적이다. 사설 이더리움 네트워크를 설치하기 위해서는 다음과 같은 환경을 설정하여야 한다.

1) 제네시스 블록(Genesis Block) 생성: 이더리움 네트워크에서 사용되는 블록체인의 최초 시작 블록으로 이전 블록을 지시하는 정보를 포함하고 있지 않으며 어떤 계정에서 얼만큼의 암호화폐를 가지고 있는지 지정해 준다.

2) Data Directory 설정: 이더리움이 동작하면서 발생하는 데이터(계좌 정보, 블록 정보 등)들이 저장될 기본 디렉터리를 지정한다. 이더리움이 동작하면서 하위에 여러 디렉터리가 생긴다.

3) Network ID 설정: 이더리움 네트워크 ID 정의. 10 이하의 네트워크 아이디는 기존의 네트워크에 할당되어 있다. “1”의 경우 메인 네트워크를 의미하며 “3”의 경우에는 “Ropsten” 테스트 네트워크 등으로 사용된다. 사설 네트워크를 구성하고 외부와 통신하지 않는 경우에는 크게 상관할 필요 없지만, 10이상의 값을 상용하는 것이 좋다.

4) Node Discovery 비활성화: 이더리움은 다른 노드들과 상호작용을 하게 구성되어 있다. 이런 경우 다른 노드의 정보와 동기화 등에 시간이 발생하게 되므로 이더리움이 다른 노드를 찾아 peer로 등록하는 과정을 비활성화한다.

위의 4가지를 지정함으로 사설 네트워크를 구성할 수 있는데, 기동시 부여할 수 있는 옵션은 다음과 같다.

1.1.1 Geth 클라이언트 계좌 생성 및 조회

사설 네트워크의 구축에 앞서 Geth 클라이언트용 계좌(Account)를 개설한다. 처음 생성하는 계좌는 “Base Address” 또는 “Coin base”라고 부르며 추후 채굴(mining)을 하면 모든 이더(Ether)가 쌓이는 기본 계정이다.

geth --datadir "c:\geth\data" account new

[그림 11] 계정의 생성 및 Key File의 확인

“–datadir” 옵션을 지정하여 생성되는 계좌의 정보가 저장될 위치(실제 계좌의 정보는 해당 디렉터리 밑에 “keystore”에 저장된다) 를 지정하고 신규 계정을 생성하는 명령어를 실행하면 해당 계좌에 대한 비밀 번호를 입력하라고 요청 받는다. 비밀번호와 확인을 위해 두번의 동일한 비밀번호를 입력하면 “Geth”에서 사용할 수 있는 계좌가 “0x 05f32de3f4abb1ca3a2de5fa8842d39fc462ecb1”와 같이 생성된다(이 주소는 각자 다르게 생성된다).

위에서 지정한 “–datadir” 밑의 “keystore” 디렉터리로 이동하면 실제 하나의 데이터 파일이 생성된 것을 확인할 수 있다. 파일의 내용은 생성된 주소와 암호화된 개인키 정보 등을 포함하고 있는 JSON 형태로 되어있다. 이 파일은 실제 비밀번호만 알고 있으면 복호화 할 수 있으며, 복호화된 개인키로 계정을 이용할 수 있기 때문에 잘 보관하여야 한다.

생성된 계좌의 목록은 “account list”를 통해 확인할 수 있다.

geth --datadir "c:\geth\data" account list

[그림 12] 생성된 계좌의 목록 확인

1.1.2 사설 네트워크(Private Network)의 제네시스 블록 정의

제네시스 블록은 이더리움 블록의 가장 첫번째 블록으로 이전 블록에 대한 정보를 가지고 있지 않는 유일한 블록이다. 제네시스 블록은 사설 네트워크의 특성을 정의하는 최초의 블록이며 사설 네트워크를 구성하는 경우 정의가 필요하다. 제네시스 블록은 json 형태로 구성된다. 다음은 제네시스 블록의 예이다.

{
    "config": {
        "chainId": 15, 
        "homesteadBlock": 0,
        "eip155Block": 0,
        "eip158Block": 0
    },
    "difficulty" : "1024",
    "gasLimit" : "2100000",
    "alloc": {
        "05f32de3f4abb1ca3a2de5fa8842d39fc462ecb1": {"balance": "300000000"}
    }
}

Genesis 블록을 생성하기 위하여 앞에서 생성한 json형태의 스크립트를 메모장등을 이용하여 작성한 후 저장하고 “init” 인자를 이용하여 geth를 실행한다(예제에서는 c:/geth/script 디렉터리 밑에 genesis.json 파일명으로 저장하였다).

geth --datadir "c:\geth\data" init "c:/geth/script/genesis.json"

[그림 13] 제네시스 블록의 생성

정상적으로 Genesis 블록이 생성되었으면 “Successfully wrote genesis state” 문구가 화면에 나타난다.

1.1.3 사설 이더리움 네트워크 실행

“Geth” 이더리움 클라이언트는 두가지 모드로 실행이 가능하다.

1) 단순 이더리움 클라이언트 실행:
추가적인 설정의 변경없이 기동하는 경우.

2) 이더리움 클라이언트 실행과 동시에 자바스크립트 콘솔 환경으로 접근:
API를 이용하여 옵션을 조정하거나 채굴, 계좌의 생성 등을 수행할 수 있다. 콘솔 환경을 구동하고자 하는 경우에는 옵션 부분에 “console”을 추가한다. 이제 제네시스 블록까지 생성을 마쳤으므로 사설 이더리움을 동작하기 1.1에서 알아본 옵션을 이용하여 다음과 같이 실행한다.

geth --identity “MyNetwork” --networkid 15 --datadir "c:/geth/data" --port "30303" --rpc --rpcaddr 0.0.0.0 --rpcport "8545" --rpcapi "eth, net, web3, miner" --rpccorsdomain "*" --nodiscover --nat "any" console

[그림 14] 외부 접속을 지원하는 환경의 Geth

정상적으로 수행되면 명령 프롬프트로 돌아오지 않고 Console을 이용하여 이더리움이 제공하는 기능들을 활용할 수 있도록 “>” 프롬프트가 나타난다(나오지 않는 경우에는 엔터키를 치면 나타날 것이다).

1.1.4 Geth 콘솔의 활용

우리는 “Geth”를 실행시키면서 맨 뒤에 “console”을 명시하여 자바스크립트 콘솔 모드에서 명령어 수행이 가능하다고 이야기하였다. 여기서는 몇가지 기능을 테스트해 보도록 하겠다.

1) 계좌 목록(accounts) 및 잔고(balance) 확인
클라이언트 노드에 계설된 계좌는 “account”라고 하며 목록을 확인하기 위하여 “eth.accounts”를 사용한다.

> eth.accounts

[그림 15] 계정 목록의 확인 - eth.accounts

우리는 먼저 “Geth”를 생성하고 하나의 계좌를 생성하였다. 동일한 계좌의 목록이 조회됨을 확인할 수 있다. 조금 눈치가 빠른 독자의 경우에는 “account”라는 메소드를 사용하지 않고 “accounts”라는 복수형 이름을 사용한 것을 알 수 있을 것이다. “Geth”의 계정은 리스트 형태로 관리되며 각각의 인덱스를 이용하여 접근할 수 있기 때문에 “accounts”를 사용하는 것이다.
특정 계좌의 잔고를 확인하기 위하여 “eth.getBalance()”를 사용한다

> eth.getBalance(eth.accounts[0])
> eth.getBalance(eth.coinbase)

[그림 16] 계정 잔고의 확인 - eth.getBalance()

제일 먼저 생성한 계좌는 accounts[0]에 저장되어 있으며, 모든 채굴된 이더가 모인다는 의미로 “coinbase”로 지정되어 있다. 앞서 제네시스 블록을 생성하면서 계좌에 “300000000”을 할당하였는데 정상적으로 입금되어 있는 것을 확인할 수 있다. 이더리움 네트워크의 계좌가 가지고 있는 이더는 “wei”라는 가장 작은 값을 기준으로 계산된다. 1이더는 1018 wei이다. 다음은 이더의 단위를 나타낸다.

명칭	Wei 기준	Ether 기준
WEI	1	0.000000000000000001
Ada	1000	0.000000000000001
Fentoether	1000	0.000000000000001
Kwei	1000	0.000000000000001
Mwei	1000000	0.000000000001
Babbage	1000000	0.000000000001
Pictoether	1000000	0.000000000001
Shannon	1000000000	0.000000001
Gwei	1000000000	0.000000001
Nano	1000000000	0.000000001
Szabo	1000000000000	0.000001
Micro	1000000000000	0.000001
Microether	1000000000000	0.000001
Finney	1000000000000000	0.001
Milli	1000000000000000	0.001
Milliether	1000000000000000	0.001
Ether	1000000000000000000	1

출력값을 이더로 변경하고 싶은 경우에는 “web3.fromWei()”를 사용하여 단위 변환이 가능하다

[그림 17] 계정 잔고의 단위 변환 - web3.fromWei()

2) 채굴(Mining)
이더리움은 거래가 이루어지는 경우 채굴을 통하여 블록에 거래의 내역을 쓰는 과정이 이루어진다. 즉, 스마트 컨트랙트를 작성하고 개인 네트워크에 올려 놓았다 할지라도 채굴이 이루어지지 않으면 그 거래는 블록체인 내에 기록되지 않는다는 것을 의미한다.
채굴 기능을 활성화 하는 방법은 geth를 실행시킬 때 인자로 “–mine” 옵션을 함께 넣어주는 방법과 콘솔에서 실행시키는 방법을 사용할 수 있다. 콘솔 상태에서 채굴을 시작하기 위해서는 프롬프트 상에서 “miner.start()”를 실행시킨다. 이 때 miner는 “–rpcapi” 옵션에서 “miner” API를 추가한 상태여야 한다.

> miner.start()
> miner.stop()

[그림 18] 채굴의 시작과 종료 - miner.start() / miner.stop()

블록체인과 이더리움이란?

Fri, 19 Jun 2020 01:01:01 +0000

블록체인과 이더리움이란?

2017년말 한차례 광풍이 불었다. 모든 언론에서는 블록체인이 앞으로 4차 산업혁명시대의 선두주자로 모든 산업 기반을 바꿀 것이라며 이야기하였고, 비트코인은 매일 최고가를 갱신하며 2018년 1월에 1 비트코인이 2,660만원이라는 엄청난 금액으로 판매되었다. 모든 사람들이 너도나도 비트코인을 사지 않으면 시대에 뒤떨어지고 투자가치를 모르는 사람처럼 취급 받았고 블록체인을 하지 않는 기업은 뒤떨어질 것이라 많은 분석가들이 언론에서 이야기하였다. 그러나 아이러니하게도 2020년 6월 현재 비트코인의 가격은 1,100만원 선을 유지하고 있다.

[그림 1] 비트코인 시세 변동

가상화폐를 부정적으로 보는 사람들의 공통된 논리는 최종 보증자가 없다는 것이다. 일반적으로 통용되는 화폐는 각 발행 국가 또는 기관이 최종적으로 회수하고 다른 재화로 변경할 수 있는 보증을 제공하고 있으나, 비트코인과 같은 가상화폐는 상장되어 있는 거래소(국내의 빗썸, 업비트 등)에서 다른 매수자에게 매도할 수 밖에 없기 때문에 화폐의 가치가 없다고 이야기하고 있다. 그러나 점차 가상화폐를 이용하여 실제 재화를 구매하고 서비스를 이용할 수 있게 됨으로써 어느정도 이러한 의심을 해결할 수 있으리라 기대하지만 완벽하게 화폐를 대체할 수는 없을지도 모른다.

블록체인을 설명하기 이전에 가상화폐를 먼저 설명하고 부정적인 이야기를 한 것은 적어도 개발자의 입장에서는 가상화폐의 투기적인 요소를 배제하고 블록체인이 가지고 있는 기술적인 특징과 이를 통해 좀더 좋은 서비스를 개발할 수 있도록 하자는 데 목적이 있다. 일반인이 생각하는 “블록체인 = 가상화폐”가 아닌 “블록체인을 유지하기 위한 수단인 가상화폐”라는 관점과 블록체인이 가지고 있는 기술적인 특징, 이더리움에서 추구하는 스마트 컨트렉트가 개발자로서 알아야 할 지식이라고 생각하며 앞으로 이러한 기술에 대해 알아보도록 하겠다.

1. 블록체인이란?

블록체인에 대한 언급은 1991년 스튜어트 하버(Stuart Haber)와 스캇 스토네타(W. Scott Stornetta)에 의해 처음 제안되고 1992년 머클 트리(Merkle Tree – 또는 해시트리라고 한다)라는 설계를 통해 각 문서간의 타임스탬프(timestamp)가 조작되지 않도록 하는 제안을 하였다. 이후 2008년도에 사토시 나카모토(Satoshi Nakamoto)라고 알려진 인물로부터 블록체인(blockchain)이라는 개념이 논문으로 발표되었다. 초기 논문에서는 블록(block)과 체인(chain)이 분리된 개념으로 설명되었으며 2016년도경에 하나의 단어인 블록체인(blockchain)이라는 용어로 통용되기 시작하였다.

블록 체인은 블록(Block)과 체인(Chain)의 합성어로 블록들이 사슬로 연결되어 있다는 의미를 가지고 있다. 블록은 데이터들을 포함하는 하나의 덩어리이고 이 덩어리들이 서로 연결되어 있다고 생각하면 된다. 이때 초기에 생성된 블록을 제네시스 블록(genesis block)이라고 하며, 그 다음에 생성되는 블록들은 자기 이전 블록에 대한 정보(해쉬값)를 가지고 있어 서로 연결되었다는 의미의 체인(chain)으로 설명된다.

현재의 전산 시스템은 몇 대의 서버를 중심으로 여러 사용자가 접속하여 데이터를 입력하고, 처리하며 처리된 결과를 데이터베이스에 저장하고 관리하는 형태로 구성되어 있다. 중앙 집중화된 시스템 구조는 유지관리 편의성은 존재할지 모르겠지만 대용량의 서버와 관리 인력, 그리고 데이터 해킹 및 유실에 따른 위험성이 존재한다. 만약, 거래하는 은행의 계좌정보가 해커에 의해 탈취되어 잔고가 0으로 변경되거나 시스템이 갑자기 파손되어 데이터를 복구할 수 없는 경우가 발생한다면 엄청난 손실이 발생할 것이다. 이런 문제를 해결하기 위하여 중앙 집중화된 서비스는 각종 보안 솔루션과 중복된 메인 프레임을 통해 데이터를 관리하고 이중, 삼중으로 데이터를 백업하여 재난에 대비하고 있다.

[그림 2] 중앙 집중형 서비스와 분산형 서비스

이런 중앙 집중적인 데이터의 문제점을 해결하고자 여러 곳에 동일한 데이터를 분산하여 저장하고(복사본을 여러 곳에 저장) 관리의 주체 또한 중앙 집중적인 관리 단체(은행 등)가 아닌 개인에게 분산하여 어떠한 실력자가 시스템의 통제를 하지 못하도록 하는 방식을 실현한 것이 블록체인이다.

분산 서비스로 구성된 시스템에서는 특정 서버(블록체인에서는 노드라고 한다)의 이상이 발생하는 경우 다른 노드들은 정확한 값을 가지고 있으므로 새로 복제하거나 잘못된 노드를 전체 네트워크에서 제외함으로써 일관성을 유지할 수 있는 장점을 가지고 있다.

분산서비스의 경우 모든 노드들이 동일한 원장을 가지고 있으므로 시스템의 오류 등에 강한 장점을 가지고 있지만 각각 일어나는 거래에 대해서는 단일 시점에 한곳에서 발생하게 되므로 위조 또는 변조가 가능하다. 이러한 문제점을 해결하기 위하여 블록체인에서는 암호학의 ‘디지털 서명(Digital Sign)’ 기술의 도움을 받아 해결하고 있다.

[그림 3] 공개키 – 개인키 디지털 서명 (https://commons.wikimedia.org/wiki/File:Digital_Signature_diagram.svg)

발생한 트랜젝션은 자신의 개인키를 이용하여 송신하고 수신측에서는 송신자의 공개키를 이용하여 복호화 한 후 데이터의 정합성을 확인하는 디지털 서명 방식은 생성한 트랜젝션이 안전하게 원장에 기록될 수 있는 기술적인 근거를 제공해 준다. 이제 블록체인을 구성하는 블록과 체인을 연결하는 방법에 대해 알아보도록 하자.

1.1 블록(Block)

데이터들을 포함하고 있는 블록은 헤더(Header)와 거래 내역(Tx: Transaction)들로 구성된다. 헤더에는 일반적으로 다음과 같은 내용이 포함된다(아래 표의 설명은 비트코인을 기준으로 설명하였다).

필드명	크기(byte)	설명
Version	4	버전 정보
Previous Block Hash	32	이전 블록 헤더의 해쉬 값
Merkle Root	32	블록내 트랜젝션들의 머클 트리의 루트에 대한 해쉬 값
Timestamp	4	UNIX 시간 형식으로 표현되는 블록이 생성된 시간
Difficulty Target	4	블록의 난이도 목표 값
Nonce	4	채굴자가 올바른 해쉬값을 찾을때 까지의 회수

헤더 정보중 이전 블록 헤더의 해쉬값을 이용하여 서로의 체인을 구성하게 되므로 각각의 블록을 찾기 위해서 헤더는 매우 중요한 역할을 한다. 각각의 해쉬 값은 SHA256 해쉬 함수를 이용하여 계산되는 32바이트의 값이다.

[그림 4] 블록체인의 기본적인 구조

[그림 4]에서 해쉬값이 계산되는 방식에 대해 좀더 자세히 알아보도록 하자. 거래 A가 발생하면 이 거래정보에 대한 해쉬값 Hash(A)를 계산한다. 만약 거래 A에 대한 내역이 변경된다면 해쉬값 A도 변경되게 될 것이다. 그리고 거래 B에 대한 해쉬값 Hash(B)을 계산한 후 이 두 해쉬값에 대한 해쉬 값 Hash(Hash(A), Hash(B))을 계산한다. 이렇게 만들어진 머클트리의 루트에 대한 해쉬 값을 계산하여 머클트리 루트에 기록한다. 이로써 개별 거래들에 대한 모든 정보는 하나의 대표적인 머클트리 루트의 해쉬 값으로 연결되게 되고, 하위 노드의 값이 변경되게 되는 경우 해쉬값이 일치하지 않게 되어 위조 및 변조에 대한 적발이 가능해 진다.

블록헤더에 필요한 머클트리 루트 해쉬값과 소프트웨어 버전, 이전 블록의 해쉬값, 타임스탬프 및 블록의 난이도 목표값은 계산이 완료되고 Nonce의 값만이 계산되면 이 값들을 이용하여 블록에 대한 대표 해쉬값을 계산할 수 있게 된다. 대표 해쉬값이 계산되면 하나의 블록은 완성된 것이라고 판단할 수 있으며, Nonce를 계산하여 하나의 블록에 대한 블록 해쉬를 구하는 과정을 ‘작업증명(Proof or Work)’이라고 하며 다른 말로는 ‘채굴(Mining)’이라고 한다.

1.2 체인(Chain)의 구성 및 역할

블록 체인은 블록들이 연결(Chain)되어 구성된다고 이야기하였다. 이를 위해서는 이전의 정보를 찾기 위한 정보가 필요하며 이를 위해 이전 블록의 해쉬값을 현재 블록의 헤더에 [그림 5]와 같이 저장한다.

[그림 5] 블록 체인의 구성

즉, 블록체인은 하나의 링크드 리스트(Linked List)와 같은 형식으로 되어 있다.

1.3 Nonce 값의 계산 - 작업 증명(POW: Proof Of Work)

앞에서 블록 헤더에 대한 해쉬값을 구하기 위해서는 Nonce에 해당하는 값을 계산하는 과정이 필요하다고 언급하였다. ‘채굴’ 또는 ‘작업증명’이라는 과정은 Nonce의 값을 변화시키면서 해당 블록이 요구하는 해쉬값 보다 작은 해쉬값이 나오도록 하는 반복 과정이다.

[그림 6] 블록 해쉬값 계산: Nonce의 조정

[그림 6]에서 Nonce를 제외한 나머지 값들은 블록 해쉬를 계산하기 전에 이미 상수로 고정되며, Nonce의 값만이 변수로 입력된다. 목표 해쉬값인 ‘0x0000001A’보다 작은 값이 나올 때까지 임의의 값을 Nonce에 주면서 계산을 해 보니 Nonce의 값이 9가 되었을 때 목표 해쉬값보다 작게 되었다고 가정해 보자. 이런 경우 작업 증명이 완료되었다고 하며, Nonce의 값을 9로 하여 블록 헤더에 대한 해쉬값을 계산하게 된다. 이 때 적합한 Nonce를 찾은 사람은 채굴(Mining)의 보상을 받게 설계되어 있다.

실제 이러한 계산은 상당히 많은 계산량을 필요로 하기 때문에 그래픽카드나 전용 기계를 사용하는 채굴자와 마이닝 풀(여러 명이 동맹을 맺어 자신에게 주어진 범위의 Nonce값을 입력하여 계산하고, 작업증명이 되면 풀에 있는 사용자들이 보상을 나눠 가지는 형태)이 등장한 것이다.

1.4. 블록체인의 위변조 방지

[그림 7] 거래 데이터 변경에 따른 해쉬값 변경

블록 내부와 연결 사이에는 연산량이 많은 해쉬 함수를 이용한다. 연산량이 많은 해쉬값을 이용하여 리스트를 구성하는 이유는 거래 정보등이 변조되는 경우를 막기 위해서이다. [그림 7]의 ‘블록 #1’의 거래 중 ‘Tx0(김영희 -> 박나래 100BTC)’의 거래를 ‘Tx0(김영희 -> 박나래 1BTC)’로 누군가 변경하였다고 가정해 보자. 이 경우 일단 ‘블록 #1’의 머클 루트에 해당하는 값이 변경되어야 한다. 또한 이 값의 변경으로 인해 ‘블록 #1’의 블록 해쉬값이 변경되어야 한다(이때는 작업 증명이 필요할 정도로 많은 계산이 필요하다). 이후 ‘블록 #2’의 ‘Previous Hash Block’의 값이 변경되어야 하며, 그 뒤에 모든 블록의 값들이 전부 새로 계산되어야 하는 것이다. 이 과정을 통해 블록의 위변조에 대한 안전성을 보장할 수 있다.

1.5 거래내역의 전파 및 충돌해소

블록체인은 동일한 원장을 모든 노드들이 동일하게 유지하고 관리한다. 새로운 거래가 생성되면 거래의 내용은 블록체인 네트워크 상의 한 노드에 전송되게 된다. 거래 정보를 받은 노드는 이 거래가 정확한지 검증한 후 블록의 거래내역에 추가하고 거래 정보를 다른 인접한 노드로 전달한다. 이 거래 전파의 과정이 전 노드에 대해 확산되면 하나의 거래 정보가 동일하게 유지되게 되는 것이다. 블록의 거래가 일정량만큼 채워지게 되면 블록을 생성한다. 거래 내역의 전파는 다음과 같은 순서로 이루어 진다.

1) 거래 내역의 확인
어떤 거래가 발생하면 해당 정보는 가장 인접한 노드로 전달된다. 거래 정보를 수신한 노드는 해당 거래의 디지털 서명이 정상적인지, 거래 내용이(예를 들어 비트코인을 전송한다면 보내는 사람의 계좌에 정상적으로 송금액 이상의 비트코인이 있는지 여부) 정상적인지등을 확인한다. 만약 비정상적인 거래정보인 경우에는 해당 노드에서 바로 폐기시켜 버리고 정상인 경우에는 해당 정보를 자신 노드의 메모리영역에 저장하고 주변 노드로 거래 내역을 전송한다.

일반적으로 하나의 노드는 주변의 8개 정도의 노드와 연결되어 있으며, 각각의 노드는 수신받은 거래 정보를 검증하고 자신의 메모리에 저장한다.

2) 채굴의 진행
메모리 영역에 어느 정도의 데이터(약 1Mbyte)가 쌓이게 되면 새로운 블록을 생성하기 위하여 앞에서 설명한 Nonce값을 변경시켜 가면서 채굴이 발생하게 된다. 이 때 거래의 내역은 메모리상에 도달한 순서가 아니라 채굴 보상을 위하여 제시한 금액(채굴자에게 돌아가는 보상 금액)이 높은 순으로 블록에 추가하는 작업을 하게 된다.

노드에서 해당 블록의 목표 해쉬값보다 작은 Nonce를 구하게 되면 완성된 블록을 주변 노드에 전송하게 된다. 이 때 다른 노드들도 자신의 블록을 생성하기 위하여 열심히 채굴을 하고 있는 상태이다. 만약 다른 노드가 채굴중에 해당 블록에 대한 정보를 수신하게 되면 채굴을 포기하고 해당 블록을 자신의 블록체인에 추가한 후 다른 노드로 블록정보를 전송한다.

3) 블록체인의 충돌 검토
정상적인 거래의 전파라면 앞의 두 과정만으로 모든 노드들의 블록체인 정보가 업데이트 될 것이다. 그렇지만 실질적으로는 새로운 블록을 만들기 위하여 모든 노드들이 경쟁을 하면서 거의 동시에 두개의 블록이 생성될 수 있는 가능성이 존재하게 된다.

[그림 8] 생성된 블록(#4)의 충돌

[그림 8]에서 A노드와 H노드가 거의 동시에 4번 블록을 생성했다고 가정해 보자. 각자 생성한 블록은 블록체인에 등록한 후 블록을 인접한 노드로 전달하기 시작한다. A노드에서 생성한 블록은 B, C, D 노드로 전파되고, H노드에서 생성한 블록은 F, G, E로 전파된다. D노드는 수신 받은 블록을 E 노드로 전파하고, E노드는 D노드로 블록을 전파하게 된다. 이 때 각자의 노드는 이미 4번 블록을 블록체인에 가지고 있으므로 자신의 블록체인을 업데이트 하지 않고 수신한 블록을 버려 버리게 된다.

위의 상황의 경우 A, B, C, D 노드가 가지고 있는 블록체인과 E, F, G, H 노드가 가지고 있는 불록체인 데이터가 상이하게 되는 현상이 발생한다. 이후 [그림 9]와 같이 새로운 블록이 B 노드에서 생성된다고 가정하자.

[그림 9] 새로운 블록(#5)의 생성과 전파

B의 노드에서 발생한 5번 블록은 인접한 노드로 블록을 전달하게 된다. 이 때 A, C, D 노드의 경우에는 5번 블록의 이전블록 해쉬값이 일치하므로 단순하게 블록체인에 블록을 추가한다. 그러나 E, F, G, H의 경우에는 5번 블록이 가지고 있는 이전 블록의 해쉬값이 불일치 하므로 기존에 유지하던 체인을 2차 체인으로 만든 후 A쪽에서 생성했던 4번 블록과 수신한 5번 블록을 받아 체인을 구성하게 된다. 이때 [그림 10]과 같이 하늘색의 블록은 고아 블록(Orphan Block)이라고 한다.

[그림 10] 고아(Orphan) 블록의 생성

5번 블록으로 인해 고아 블록이 생기게 되는 현상을 “분기가 발생”했다고 하며 분기가 발생하는 경우 메인 체인을 선택하는 것은 작업 증명을 가장 많이 한 체인(블록의 길이가 가장 긴 체인)으로 선택한다.

2. 이더리움

이더리움은 2013년 비탈릭 부테린(Vitalik Buterin)이 제안한 후 2015년 7월 세상에 공표한 블록체인 기반의 암호화폐 플랫폼이다(현재도 계속 개발 중이다). 비트코인으로 대표되는 블록체인은 거래 내역을 여러 노드에 동일하게 분산하여 관리하는 것을 기본으로 하고 있지만 비탈릭의 경우에는 단순한 화폐 원장의 기능과 더불어 솔리디티(Solidity)라는 프로그래밍 언어를 통하여 자동으로 실행되는 스마트 컨트랙트(Smart Contract)를 개발할 수 있는 환경을 제공하였다. 이 스마트 컨트랙트를 이용하여 계약서, 공증, 전자 투표 등의 다양한 서비스를 개발하고, 정보를 블록체인 내부에 저장할 수 있는 분산 네트워크 플랫폼이다.

2.1 스마트 컨트랙트

스마트 컨트랙트는 블록체인 상에서 계약의 당사자들 상호간에 합의된 규칙에 따라 진행될 수 있도록 구현된 소프트웨어이다. 사전에 정의된 규칙에 만족하는 상황이 발생하면 지정해 놓은 계약은 자동적으로 처리되고 모든 처리된 거래 내역은 블록체인상에 기록되어 안전한 거래를 보장한다.

현실세계에서는 일반적으로 A와 B의 거래에 있어서 서로 상호 신뢰를 목적으로 계약서를 작성한다. 또한 계약서를 확인하기 위하여 제 삼자(공증이나 거래 중계인 등)가 개입하는 경우가 일반적이다. 이 과정에서 우리는 상당한 수수료를 지불해야 한다. 이제 자동차 계약을 예로 한번 알아보자.

[그림 11] 고전적 차량 계약

[그림 11]은 고전적인 중고차 거래 방식을 표현하고 있다. 차량 판매자는 중고차 딜러에게 차량 매매의사를 밝히고 자신의 차량 정보를 제공한다. 딜러는 해당 차량에 대한 광고를 인터넷 등에 게시하고 구매자를 찾는다. 구매자는 인터넷 정보를 보고 해당 딜러에게 연락하여 구매 의사를 밝힌다. 판매자는 차량과 제반 서류, 자동차 키를 가지고 딜러 사무실로 가고 구매자는 딜러 사무실에서 계약서를 작성한다. 이 때 입금 이전이므로 자동차 키 등을 딜러가 가지고 있고, 구매자로부터 입금이 완료된 것을 확인하며 딜러는 이전 수속을 위한 업무를 진행하고 수수료 등을 양측으로부터 수령한 후 차량을 구매자에게 전달한다. 이 때 판매자와 구매자는 딜러 수수료, 차량 등록 수수료 등을 지불해야 한다. 이 때 구매자가 판매자에게 금액을 송금하고 자신에게 차량이 인도될 때 까지는 딜러를 전적으로 신뢰하여야 하며 불미스러운 일이 발생하여 차량을 인도 받지 못하는 경우도 발생할 수 있는 위험이 있다.

이제 이와 같은 거래를 스마트 컨트랙트를 이용하는 경우에 대해 알아보자.

[그림 12] 스마트 컨트랙트를 이용한 차량 계약

먼저 판매자는 자신 차량의 정보와 판매 금액 및 조건을 기반으로 하는 스마트 컨트랙트를 작성하여 블록체인 상에 게시한 후 차량을 스마트 컨트랙트가 동작해서 열 수 있는 곳에 차량을 주차한다. 차량 구매자는 스마트 컨트랙트를 조회(컨트랙트의 내용을 웹이나 앱을 통하여 게시할 수 있다)하여 지정된 계좌로 비용을 송금하는 거래를 발생시킨다. 거래정보를 수신한 노드는 스마트 컨트랙트의 내용에 따라 거래를 요청하였는지 확인한 후 해당 내용을 블록 체인에 기록한다. 구매자는 차고로 가서 차량을 수령한다.

이 과정중에 우리는 중간 딜러나 차량 등록 사무소에 서류를 처리하는 행위를 할 필요가 없다. 홍길동이 김철수로부터 1,000만원을 주고 차량을 인도 받았다는 기록이 블록체인상의 모든 노드에 기록되어 있기 때문이다.

2.2 가스(Gas) 비용

앞서서 차량을 거래하는 데 있어서 서류를 작성하거나 거래를 보증하는 제 3자가 필요하지 않아 비용이 발생하지 않는다고 하였다. 그러나 이러한 거래가 모든 블록체인에 기록되기 위해서는 채굴이라는 과정이 필요하므로 이를 위한 비용이 필요하다. 이 비용을 이더리움에서는 ‘가스비’라고 한다. 이더리움상의 모든 거래는 가스 한계(Gas Limit)와 가스비(Gas Price)가 포함되어 있어야 한다

1) 가스 한계(Gas Limit)

“가스 한계”는 하나의 트랜젝션을 처리하기 위하여 거래 당사자가 할당한 최대 가스비를 의미한다. 가스 한계를 넘어서는 거래는 즉시 중지되고 거래는 블록체인에 기록되지 않는다. 이 때 중지될 때까지 사용한 비용은 없어진다. 이러한 이유로 가스 한계를 크게 잡아 놓는 것이 좋은데, 너무 크게 된 경우에도 채굴자가 선택하지 못하는 경우가 발생한다. 각각의 블록은 “블록 가스 한계(Block Gas Limit)”를 가지고 있는데 하나의 블록에는 최대 담을 수 있는 가스의 한계값이 존재한다. 채굴자가 트랜젝션을 블록에 추가할 때 블록이 가질 수 있는 가스 한계를 넘어서게 되면 블록에 해당 트랜젝션을 추가할 수 없다.

가스 한계값은 단순히 거래에 할당할 수 있는 최대값을 의미하는 것으로 만약 실제 사용한 가스의 양이 이보다 적은 경우에는 실제 사용한 비용만 지출이 된다. 일반적으로 개인 지갑의 코인이나 토큰을 다른 사람의 지갑으로 이동하는 트랜젝션의 경우 21,000가스가 사용된다.

스마트 컨트랙트를 수행하면서 발생하는 개별의 코드는 각각 지정한 가스 사용량이 결정되어 있고, 이를 통해 전체적으로 필요한 가스의 양을 결정할 수 있다.

2) Gas Price(Gas Price)

스마트 컨트랙트를 수행하기 위하여 실행되는 각각의 코드 단위에 지정된 가스 사용량과 함께 우리는 단위 가스 가격을 설정할 수 있다. 이 가격 설정을 통하여 실제 사용되는 가스비용을 계산할 수 있다.

가스 비용을 설정하는 이유는 동일한 거래에 있어서 단위 가스의 비용이 큰 거래를 채굴자들이 먼저 선택하기 때문이다.

3) 수수료

실제 이더리움상에서 거래에 발생하는 수수료는 “사용한 가스의 총량”과 “단위당 가스 비용”의 곱으로 나타낼 수 있다. 즉, 가스 비용이 높아지게 되면 수수료가 높아지게 되고, 채굴자가 해당 거래를 즉시 선택해서 블록에 추가할 가능성이 높아지게 되는 것이다.

위의 내용을 자동차와 비교하면 [그림 13]과 같다.

[그림 13] Gas Limit / Gas Price / Fee

탱크 용량이 75L인 택시(가스 자동차)가 손님을 어느 목적지까지 모시고 가기 위해 가스 충전소에 들렸다고 가정해 보자. 운전자는 이 차를 처음 운행하기 때문에 차량의 연비를 모르고, 거리도 정확하게 알 수 없어서 일단 가스탱크를 가득 채우고 출발하기로 마음 먹었다. 이 경우 75L 탱크에 리터당 1,000원씩 계산된 총 75,000원의 가스가 채워지게 된다. 가스를 채운 후 목적지까지 운행을 하고 확인해 보니 실제 사용한 가스는 10L이므로 실제 가스값으로 사용한 것은 10,000원이 되게 되고 차량의 가스 탱크에는 65,000원에 해당하는 가스가 남아 있게 된다.

즉, 택시는 최대 75L의 가스를 사용할 수 있지만(가스 한계) 실제 사용한 가스의 양은 10L에 해당하는 10,000원(수수료)만 지불하면 된다. 그리고 안타깝게 75L의 가스를 전부 사용하고도 목적지까지 도착하지 못하면 가스 75L만 사용하고 목적지 도달은 실패하게 되는 것이다(거래의 취소).

또한, 급하게 목적지에 가야 하는데 택시가 승차거부를 한다면(요즘은 이런 기사님은 없으시다) 승객은 목적지까지 비용을 더 비싸게(소위 따블) 제시하는 경우가 생긴다. 이런 경우 택시 기사는 정해진 비용보다 더 많이 지불을 할 손님을 태우게 될 것이다. 만약 차량의 연비가 10Km/L라고 가정을 하면 10Km 이동에 필요한 가스비용은 10Km/L * 1L = 1,000원이고 1Km당 100원의 가스가 사용되게 되는 것이다. 그런데 손님이 1Km를 이동하는데 200원의 가스비를 계산해 주겠다고 하하는 것 같은 경우가 되는 것이다. 이와 마찬가지로 채굴자들은 단위 가스비가 높은 거래를 먼저 택하게 되는 것이다.

3. 블록체인을 이용한 서비스

블록체인은 중앙 집중화된 데이터를 분산 원장으로 관리하고 스마트 컨트랙트를 이용하여 자동화된 거래를 실행시킬 수 있다는 측면에서 앞으로 많은 산업에 영향을 미치고 발전해 나갈 것이다. [그림 14]는 유명한 컨설팅 그룹에서 제시한 스마트 컨트랙트와 블록체인의 서비스 가능 영역을 나타낸 것이다.

[그림 14] 스마트 컨트랙트의 활용 예 (출처: PricewaterhouseCoopers)

스마트 컨트렉트와 블록체인은 송금과 국가간 거래 등의 금융서비스, 디지털 자산에 대한 권리의 양도 및 보존, 부동산 거래, 물류 등에서 활용될 수 있으며 많은 시도들이 이루어 지고 있다. 그러나 실제 중앙 집권식 데이터 관리에 비해 데이터 정합성을 위한 네트워크 사용에 따른 속도의 저하, 블록 생성 및 합의에 이르기 까지 걸리는 시간 지연 등의 문제등을 극복할 기술적인 발전이 더욱 필요한 상황이다.

6. 지도 시각화 – Folium

Sun, 21 Jan 2018 14:01:00 +0000

6. 지도 시각화 - 포리움(Folium)의 설치 및 활용

Folium(https://folium.readthedocs.io/en/latest) 은 ‘Open Street Map’과 같은 지도데이터에 ‘Leaflet.js’를 이용하여 위치정보를 시각화하기 위한 라이브러리다. 기본적으로 ‘GeoJSON(http://geojson.org/)’ 형식 또는 ‘topoJSON’ 형식으로 데이터를 지정하면, 오버레이를 통해 마커의 형태로 위치 정보를 지도상에 표현할 수 있다.

우리가 현실세계에서 지도상의 위치를 표시하기 위해 ‘위도(latitude)’와 ‘경도(longitude)’를 사용한다. ‘위도’는 적도를 기준으로 하여 남쪽으로 남극점까지 90°, 북쪽으로 북극점까지 90°로 나누어 표시한다(우리나라는 적도의 북쪽인 북위 34° ~ 38° 사이에 위치). ‘경도(longitude)는 런던 그리니치천문대를 지나는 본초자오선을 중심으로 동서로 나누어 동경 180°, 서경 180°로 분리한다(서울의 경우 동경 127°에 위치).

‘GeoJSON’은 다양한 지리 데이터 구조를 인코딩하기 위한 형식을 제공한다. 객체는 지오메트리, 지형지물을 표시할 수 있으며, Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon 및 GeometryCollection과 같은 속성들을 지정할 수 있다. 다음은 GeoJSON 형식을 나타낸다.

{
  "type": "Feature",
  "geometry": {
    "type": "Point",
    "coordinates": [125.6, 10.1]
  },
  "properties": {
    "name": "Dinagat Islands"
  }
}

TopoJSON은 GeoJSON의 확장형식으로 각 영역을 아크(arcs)들의 영역으로 구분하여 표시하는 기능을 제공해주어 연산량을 적게 해주는 장점을 가지고 있다.

특정 지역의 위도와 경도값을 찾는 방법은 구글맵이나 네이버지도와 같은 지도 서비스 포털을 이용할 수 있다. 예제로 사용할 위치를 구하기 위하여 구글맵(https:www.google.com/maps)을 호출한 후 [그림 1]과 같이 ‘서울특별시청’을 검색하여 보자.

[그림 1] 구글맵을 통한 지리정보 찾기

[그림 1]의 상단 URL 정보를 보면 인자값으로 위도와 경도 정보가 전달되는 것을 알 수 있다. 그러나 이 값은 현재 우리가 검색한 ‘서울특별시청’의 위치좌표가 아니라 지금 표시한 지도의 중간 위·경도 값을 의미한다. 정확한 좌표값을 얻기 마커를 선택한 후 오른쪽 마우스를 누르면 [이곳이 궁금한가요?]라는 메뉴가 나타난다. 클릭을 하면 [그림 2]와 같이 세부 정보가 하단에 나타난다.

[그림 2] 구글맵을 통한 지리정보 찾기

‘이곳이 궁금한가요?’를 통하여 얻은 위도 값은 37고 56분 63.45초이고 경도의 값은 126분 97도 78.93초이다.

6.1 Folium 설치 및 객체 생성

먼저 도스창을 띄워 파이썬이 설치된 경로로 이동하여 ‘folium’을 인스톨한다.

[파이썬 설치 경로]>pip install folium

인스톨이 정상적으로 되었으며 파이썬 쉘을 실행시킨 후 ‘folium’을 임포트(import)하는 것만으로준비는 끝난다.

초기 객체의 생성은 ‘.Map()’ 메소드에 중심 좌표값을 지정함으로 간단하게 생성할 수 있다.

>>> import folium
>>> map_osm = folium.Map(location=[37.566345, 126.977893])
>>> map_osm.save('d:/temp/chicken_data/map1.html') #파일이 저장될 위치

서울특별시청의 위도는 37도 56분 63.45초 이고, 경도는 126도 97분 78.93초이므로 포리움맵을 생성하면서 서울특별시청의 값을 중심값으로 하여 지도를 생성한다. 만약 주피터 노트북을 개발환경으로 사용하면 단순하게 생성된 객체를 호출(»>map_osm)하면 지도를 보여주지만, 우리는 파이썬 쉘을 사용하므로 생성된 객체를 저장하여야 확인할 수 있다. 생성된 객체를 특정 위치에 저장한 후 탐색기를 이용하여 해당 파일을 브라우저로 열면 [그림 3]과 같이 서울 시청을 중심값으로 하는 지도파일이 호출되는 것을 확인할 수 있다.

[그림 3] 서울특별시청을 중심으로 포리움 맵 생성

초기 화면의 크기를 지정하는 방법은 ‘zoom_start’ 속성을 주면 가능하다. [그림 4]는 초기 화면의 크기를 확대하여 보여주는 예이다.

>>> map_osm = folium.Map(location=[37.566345, 126.977893], zoom_start=17)
>>> map_osm.save('d:/temp/chicken_data/map2.html')

[그림 4] zoom_start 속성값을 부여하여 초기 지도의 확대

6.2 다른 유형의 맵 호출

포리움은 기본적으로 ‘Open Street Map’을 기반으로 동작하지만 내부적으로는 ‘Stamen Terrain’, ‘Stamen Toner’, ‘Mapbox Bright’, 와 ‘Mapbox Control room tiles’ 형식을 내장하고 있다.

>>> map_osm = folium.Map(location=[37.566345, 126.977893], zoom_start=17, tiles='Stamen Terrain')
>>> map_osm.save('d:/temp/chicken_data/map3.html')
>>> map_osm = folium.Map(location=[37.566345, 126.977893], zoom_start=17, tiles='Stamen Toner')
>>> map_osm.save('d:/temp/chicken_data/map4.html')

[그림 5]는 ‘Stamen Terrain’형식의 지도를 사용한 것이고 [그림 6]은 ‘Stamen Toner’형식을 사용한 것이다.

[그림 5] Stamen Terrain 형식의 지도 생성

[그림 6] Stamen toner 형식의 지도 생성

‘Cloudmade’나 ‘Mapbox’를 사용하는 경우에는 사이트에 등록시 발급받은 API 키 정보를 아래와 같이 ‘API_key’ 속성으로 지정하여 준다.

>>> map_osm = folium.Map(location=[37.5660, 126.9757], tiles=’Mapbox', API_key=’API키값’)

6.3 마커(Marker)와 팝업(Popup)의 설정

포리움은 다양한 형식의 마커(특정 위치를 표시하는 표식)과 마커를 클릭하였을 때 나타나는 정보(Popup)을 지정할 수 있다.

>>> map_osm = folium.Map(location=[37.566345, 126.977893], zoom_start=17)
>>> folium.Marker([37.566345, 126.977893], popup='서울특별시청').add_to(map_osm)
>>> folium.Marker([37.5658859, 126.9754788], popup='덕수궁').add_to(map_osm)
>>> map_osm.save('d:/temp/chicken_data/map5.html')

마커의 생성은 ‘.Marker()’ 메소드를 이용하여 생성한다. 마커의 인자값으로 위경도 값 리스트와 마커를 클릭할 시 보여줄 문자열을 전달하고, 생성한 포리움 객체에 추가(.add_to())하면 간단하게 마커를 생성할 수 있다. [그림 7]은 생성된 포리움 맵의 마커를 클릭하여 팝업을 생성한 예이다.

[그림 7] 포리움 마커의 생성

포리움 마커는 부트스트랩(bootstrap)을 이용하여 아이콘 타입을 설정할 수 있으며, 범위를 설정하기 위하여 circle 속성을 줄 수 있다.

>>> map_osm = folium.Map(location=[37.566345, 126.977893], zoom_start=17)
>>> folium.Marker([37.566345, 126.977893], popup='서울특별시청', icon=folium.Icon(color='red',icon='info-sign')).add_to(map_osm)
>>> folium.CircleMarker([37.5658859, 126.9754788], radius=100,color='#3186cc',fill_color='#3186cc', popup='덕수궁').add_to(map_osm)
>>> map_osm.save('d:/temp/chicken_data/map6.html')

[그림 8]은 덕수궁의 위치를 좀더 크게 마커로 표시하고, 서울특별시청은 적색의 ‘info-sign’ 마커로 표시한 예이다.

[그림 8] 마커의 변경

6.4 JSON 활용 데이터

geoJSON 형식과 topoJSON은 지도상의 경계 영역 등을 표시하기에 효율적이다. https://github.com/southkorea 를 방문하면 통계청 데이터를 기반으로 하여 작성한 JSON 형식 행정구역 데이터를 얻을 수 있다(https://github.com/southkorea/southkorea-maps). 해당 데이터를 다운로드 받아 특정 위치에 저장한 후 파일을 읽어 ‘GeoJson()’메소드에 링크 시킨다(직접 open 파라미터를 사용하여도 되는데 이 때 디코딩 에러가 나는 경우가 있으므로, 예제에서는 파일을 직접 읽은 후 데이터를 링크 시켰다).

>>> import folium
>>> import json
>>> map_osm = folium.Map(location=[37.566345, 126.977893])
>>> rfile = open('d:/temp/chicken_data/skorea_provinces_geo_simple.json', 'r', encoding='utf-8').read()
>>> jsonData = json.loads(rfile)
>>> folium.GeoJson(jsonData, name='json_data').add_to(map_osm)
>>> map_osm.save('d:/temp/chicken_data/map7.html')

[그림 9]는 행정구역이 “MultiPolygon“ 형식으로 입력되어 있는 JSON 데이터를 불러들여 지도에 표시한 예이다.

[그림 9] GeoJSON 데이터 매핑

6.5 네이버 주소 API를 이용하여 지도에 표시

포리움을 사용하는 방법을 이해했으니 실제 데이터를 가지고 지도에 표시하는 방법에 대해 알아보도록 하겠다. 본 절에서 다룰 데이터는 서울열린데이터광장에서 제공하는 서울시 초등학교현황(http://data.seoul.go.kr/dataList/datasetView.do?infId=OA-12059&srvType=S&serviceKind=1&currentPageNo=1)을 다운로드 받아 사용하였다.

CSV 파일 : 서울시 초등학교 현황.csv

먼저 다음의 코드를 작성하자.

import folium
import pandas as pd
import urllib.request
import datetime
import time
import json
import webbrowser

#[CODE 1]
def get_request_url(url):
    req = urllib.request.Request(url)
    req.add_header("X-Naver-Client-Id", "NAVER API ID")
    req.add_header("X-Naver-Client-Secret", "NAVER API SECRET")
    try:
        response = urllib.request.urlopen(req)
        if response.getcode() == 200:
            print ("[%s] Url Request Success" % datetime.datetime.now())
            return response.read().decode('utf-8')
    except Exception as e:
        print(e)
        print("[%s] Error for URL : %s" % (datetime.datetime.now(), url))
        return None

#[CODE 2]
def getGeoData(address):
    base = "https://openapi.naver.com/v1/map/geocode"
    
    try:
        parameters = "?query=%s" % urllib.parse.quote(address)
    except:
        return None
    
    url = base + parameters
    
    retData = get_request_url(url)
    if retData == None:
        return None

    jsonAddress = json.loads(retData)

    if 'result' in jsonAddress.keys():
        latitude = jsonAddress['result']['items'][0]['point']['y']
        longitude = jsonAddress['result']['items'][0]['point']['x']
    else:
        return None
    
    return [latitude, longitude]

def main():
   
    #[CODE 3]
    map = folium.Map(location=[37.5103, 126.982], zoom_start=12)

    filename = 'd:/tmp/서울시 초등학교 현황.csv'
    df = pd.DataFrame.from_csv(filename, encoding='CP949', index_col=0, header=0)
    geoData = []
    
    #[CODE 4]
    for index, row in df.iterrows():
        geoData = getGeoData(row['주소'])
        if geoData != None:
            folium.Marker(geoData, popup=row['학교명'], icon=folium.Icon(color='red')).add_to(map)
    
    svFilename = 'd:/tmp/elementary_school.html'
    map.save(svFilename)
    webbrowser.open(svFilename)  
    
if __name__ == "__main__":
    main()

해당 코드를 수행하면 [그림 1]과 같이 프렌차이즈 위치 정보를 포함하는 지오맵(GeoMap)이 생생성된 것 확인할 수 있다.

[그림 1] 서울특별시 초등학교 현황

네이버로 부터 주소를 가지고 오는 방법은 PYTHON 크롤링 » 9. 네이버 지도 API(주소, 좌표변환) 활용을 참조하기 바란다.

[CODE 3]은 저장되어 있는 서울시 초등학교 현황 파일을 읽어와 DataFrame의 형식으로 저장한다.

[CODE 4]는 DataFrame내의 데이터를 한 행(row)씩 가져오면서 ‘주소’ 컬럼의 데이터를 네이버 API를 호출하기 위한 함수로 전달하고 반환값을 받는다. 이후 반환값이 있는 경우에는 .Marker() 메소드를 이용하여 해당 위,경도값에 학교명을 팝업으로 지정하여 추가한 후 반복이 종료되면 webbrowser.open()을 이용하여 화면에 나타낸다.

5. 히트맵(Heatmap) – seaborn, numpy

Sun, 21 Jan 2018 13:01:00 +0000

5. 히트맵(Heatmap) – seaborn, numpy

‘seaborn’은 ‘matplotlib’와 함께 효과적인 시각화 라이브러리를 제공해준다. ‘seaborn’을 사용하기위해서는 ‘numpy’와 ‘scipy’가 설치되어야 하는데, 윈도우에서는 pip install을 사용하는 경우 설치오류가 발생하는 경우가 많다.

먼저 numpy-mkl 버전을 인스톨 한다. numpy mkl 버전은 ‘numpy’와 인텔의 수학 커널 라이브러리를 지원하는 dll 파일들이 함께 포함되어 있는 패키지이다. 인터넷을 검색하여 numpy mkl 버전을 다운로드 받는다(http://www.lfd.uci.edu/~gohlke/pythonlibs/#numpy).

‘.whl’ 파일의 경우에는 사용하고 있는 파이썬 버전(cpXX로 표시)과 윈도우 32/64 비트를 개발 환경에 맞게 다운로드 받는다. 동일한 형식으로 ‘scipy’ 및 ‘seborn’ 파일을 받고 인스톨 한다(필자의 경우에는 파이썬 3.5 = CP25-의 64비트 버전을 다운로드받아 D:\Temp 폴더에 저장하였고, Python 설치 경로는 D:\Program Files\Python 이다). 패키지 인스톨에 대하여 잘 모르는 경우에는 파이썬 기초 » 7. 패키지(Package) 설치 부분 참조 ^^

D:\Program Files\Python\pip install d:\temp\numpy-1.12.1+mkl-cp35-cp35m-win_amd64.whl
Processing d:\program files\python\scripts\numpy-1.12.1+mkl-cp35-cp35m-win_amd64.whl
Installing collected packages: numpy
Successfully installed numpy-1.12.1+mkl

D:\Program Files\Python>pip install d:\temp\scipy-0.19.0-cp35-cp35m-win_amd64.whl
Processing d:\temp\scipy-0.19.0-cp35-cp35m-win_amd64.whl
Requirement already satisfied: numpy>=1.8.2 in d:\program files\python\lib\site-
packages (from scipy==0.19.0)
Installing collected packages: scipy
Successfully installed scipy-0.19.0

D:\Program Files\Python>pip install d:\temp\seaborn-0.7.1-py2.py3-none-any.whl
Processing d:\temp\seaborn-0.7.1-py2.py3-none-any.whl
Installing collected packages: seaborn
Successfully installed seaborn-0.7.1

D:\Program Files\Python>

설치가 완료되면 파이썬 쉘을 수행한 후 중국 입국자수(JSON 파일 : 중국(112)_해외방문객정보_2011_2016.json)를 가지고 히트맵을 작성하여 보자. 먼저 저장된 중국 입국자수 json 파일을 불러들여 데이터 프레임으로 저장한다.

>>> import pandas as pd
>>> import json
>>> fv_CFileName = 'd:/Temp/public_data/중국(112)_해외방문객정보_2011_2016.json'
>>> jsonFV = json.loads(open(fv_CFileName, 'r', encoding='utf-8').read())
>>> china_table = pd.DataFrame(jsonFV, columns=('yyyymm', 'visit_cnt'))
>>> china_table.head()
   yyyymm  visit_cnt
0  201101      91252
1  201102     140571
2  201103     141457
3  201104     147680
4  201105     154066

데이터프레임에 저장되어 있는 데이터는 연도와 월이 문자열로 결합된 ‘yyyymm’필드와 방문객수인 ‘visit_cnt’ 열로 구성되어 있다. 해당연도와 월을 가로와 세로로 가지는 표의 형태로 구성하기 위하여 ‘yyyymm’ 필드를 먼저 ‘datetime’형식으로 변환한 후 ‘year’ 컬럼과 ‘month’ 컬럼을 생성한다.

>>> china_table.yyyymm = pd.to_datetime(china_table.yyyymm, format='%Y%m')
>>> china_table['year'] = china_table.yyyymm.dt.year
>>> china_table['month'] = china_table.yyyymm.dt.month
>>> china_table.head()
      yyyymm  visit_cnt  year  month
0 2011-01-01      91252  2011      1
1 2011-02-01     140571  2011      2
2 2011-03-01     141457  2011      3
3 2011-04-01     147680  2011      4
4 2011-05-01     154066  2011      5

‘year’ 컬럼과 ‘month’ 컬럼이 생성된 것이 확인되면 이제 표 형식으로 데이터 프레임을 변경한 후 ‘saborn’을 import 한 후 ‘heatmap’ 객체를 생성하고 ‘show()’를 이용하여 그래프를 출력한다.

>>> china_table = china_table.set_index(['month','year'])['visit_cnt'].unstack(fill_value=0)
>>> print (china_table)
year     2011    2012    2013    2014    2015    2016
month                                                
1       91252  113927  167022  196371  296708  394345
2      140571  157019  173790  249698  326295  516787
3      141457  163261  183691  276479  423768  515130
4      147680  153875  222114  335069  531947  641610
5      154066  152347  210439  278723  517031  618083
6      150119  179508  234482  399031  573852  315095
7      195188  244573  322917  569787  692053  255632
8      241987  276299  359065  642258  757683  513275
9      176196  231462  283402  483518  564078  591242
10     181428  214681  279440  343273  562278  650174
11     136152  174164  204533  276428  460671  507579
12     119061  159080  195997  276234  420501  465218
>>> import matplotlib.pyplot as plt
>>> import seaborn as sns
>>> sns.heatmap(china_table)
>>> plt.show()

[그림 1]은 생성된 Heatmap을 나타낸다.

[그림 1] 국내 중국인 입국수 시각화(Heatmap)

4. 데이터 기반 추천서비스 - 상관관계분석, pandas

Sun, 21 Jan 2018 12:01:00 +0000

4. 데이터 기반 추천: 데이터 상관 관계 분석

요즘 빅데이터 열풍이 불면서 ‘추천서비스’에 대한 이야기가 많이 들린다. 데이터를 분석해서 사용자에게 필요한 정보를 ‘맞춤형’으로 제공하고자 하는 시도는 여러곳에서 수행되고 있으며 그중에서 가장 많이 사용하는 분석 방법중 한가지가 ‘상관관계 분석’이다. 통계학도가 아니여도 ‘상관관계 분석’이라는 말은 데이터 분석에 관심이 있다면 한번쯤은 들어 보았을 것이다. 간단하게 ‘상관관계 분석’이 어떤 것인지 알아보고 이를 데이터 분석에 활용하는 방법에 대해 알아보자.

4.1 상관분석과 상관계수

우리는 일상생활에서 “키가 크면 발이 크다”, “교육수준이 높을수록 자녀의 대학 진학률이 높다”등의 이야기를 많이 한다. 이러한 두 개의 변수 ‘키’와 ‘발’, ‘교육수준’과 ‘자녀 대학 진학률’간의 관계가 어떠한 관계를 가지고 있는지 성향을 분석하는 것이 “상관분석”이다. 이를 ‘산포도’ 또는 ‘산점도’라는 그래프로 그리면 직관적으로 두 변수간의 관계를 파악할 수 있다.

만약 어느 집단의 키와 발크기를 조사하였더니 다음의 표와 같이 정리가 되었다고 하자(극단적인 예를 만든것임).

키(Cm)	100	120	130	140	150	160	170	180	190
발크기(mm)	200	205	210	220	230	250	270	280	285

직관적으로 표만 보아도 키가 커지면 발크기가 커지는 것을 확인할 수 있다. 이를 산포도로 그려보기 위하여 다음과 같이 코드를 작성해 보자.

>>> import matplotlib.pyplot as plt
>>> from matplotlib import font_manager, rc
>>> import matplotlib
>>> font_location = "c:/Windows/fonts/malgun.ttf"
>>> font_name = font_manager.FontProperties(fname=font_location).get_name()
>>> matplotlib.rc('font', family=font_name)
>>> height = [100, 120, 130, 140, 150, 160, 170, 180, 190]
>>> foot_size = [200, 205, 210, 220, 230, 250, 270, 280, 285]
>>> plt.scatter(height, foot_size)
>>> plt.xlabel('키(Cm)')
>>> plt.ylabel('발크기(mm)')
>>> plt.show()

코드를 수행하면 [그림 1]과 같이 그려진다. 그래프로 그려보니 더욱더 확실하게 증가하는 형태가 보인다.

[그림 1] x가 증가함에 따라 y가 증가하는 경우

다음으로 산의 높이에 따른 온도의 변화를 표로 나타내보자(일반적으로 산의 높이가 100m 올라갈때마다 평균 0.65℃ ~ 0.75℃ 정도 낮아진다고 한다)

산의 높이(m)	100	200	300	400	500	600	700	800	900
온도(℃)	18.0	17.5	17	16.5	15	14.5	13	12	11

위의 표를 이용하여 산포도를 그려보자.

>>> height = [100, 200, 300, 400, 500, 600, 700, 800, 900]
>>> temperature = [18.0, 17.5, 17, 16.5, 15, 14.5, 13, 12, 11]
>>> plt.scatter(height, temperature)
>>> plt.xlabel('산의높이(m)')
>>> plt.ylabel('온도(℃)')
>>> plt.show()

[그림 2] 산의 높이에 따른 온도의 변화

[그림 2]에서 보듯이 산의 높이가 높아질수록 온도가 낮아짐을 확인할 수 있다. 다음의 코드를 작성해 보자.

>>> import numpy as np
>>> random_x = np.random.random_integers(0, 100, 50)
>>> random_y = np.random.random_integers(0, 100, 50)
>>> plt.scatter(random_x, random_y)
>>> plt.show()

위의 코드를 생성하면 [그림 3]과 같이 어떤 관계가 보이지 않는 데이터가 나타난다.

[그림 3] 데이터간의 관계가 보이지 않는 경우

이 예제에서는 데이터 연관성을 없애기 위하여 numpy모듈의 random_interger()함수를 사용하였다. ‘random_interger(arg1, arg2, number)’는 ‘arg1’과 ‘arg2’사이의 임의의 난수를 ‘number’ 개수만큼 만들어준다.

상관분석에서는 x의 값이 증가함에 따라 y의 값이 증가하는 경우 우리는 “양의 상관관계”를 가지고 있다고 이야기하며(키 vs. 발크기), 반대로 x가 증가함에 따라 y의 값이 감소(산의 높이 vs. 온도)하는 경우 “음의 상관관계”를 가지고 있다고 이야기한다.

상관 계수는 서로간의 데이터가 어느 정도의 근접도를 가지고 있는지 표현하는 방법이다. [그림 4]는 둘 다 양의 상관관계를 가지고 있으나 두 점들이 모여있는 근접도(밀도)가 차이를 가진다.

[그림 4] 양의 상관관계를 가지고 있으나 근접도가 다른 경우

이러한 근접도를 함께 포함하도록 표현한 방법이 “상관계수(기호로는 r)”이다. 상관계수는 -1≤r≤1 의 값을 가지며, 수치가 0에 근접할 수록 두 변수간에 상관관계가 없음을 의미하고, -1의 경우에는 음(-)의 상관 관계가 강하며, +1에 근접할수록 양(+)의 상관관계가 크다고 본다.

일반적으로 각 상관계수 값은 다음과 같은 의미로 해석된다(음의 상관계수는 절대값을 붙여 생각하면 된다). 이 해석은 분석하는 사람에 따라 편차가 있다.

0.0 ~ 0.2	상관 관계가 거의 없다
0.2 ~ 0.4	약한 상관 관계
0.4 ~ 0.6	상관 관계가 있다
0.6 ~ 0.8	강한 상관 관계
0.8 ~ 1.0	매우 강한 상관 관계

상관관계 분석식은 다음과 같이 표현된다.

4.2 데이터 테이블 생성: pandas 패키지

‘pandas’ 패키지는 데이터를 엑셀 스프레드시트(excel spreadsheet)나 SQL 테이블과 같이 서로 다른 속성을 가지는 컬럼들로 구성된 데이터 테이블 형태(DataFrame)이나 시계열 데이터와 같이 연속된 데이터 셋(Series)으로 구성하고, 이를 분석하기 위한 도구로 사용된다.

‘pandas’ 패키지는 데이터 구조를 위하여 일차원 데이터인 ‘Series’와 이차원 데이터인 ‘DataFrame’을 사용한다. 먼저 파이썬 에뮬레이터를 실행하고 ‘pandas’와 ‘numpy’를 ‘import’한다. ‘numpy’는 파이썬을 이용하여 과학 계산과 같은 고성능 수치계산을 위해 만들어진 패키지로써 다차원 배열을 사용하기 위하여 주로 사용한다(‘numpy’에 대한 활용은 필요한 부분에서만 잠시 하겠다).

>>> import numpy as np
>>> import pandas as pd

4.2.1 Series

‘Series’는 이차원의 인덱스를 가지는 배열(labeled array)로써 integer, string, float, 파이썬 객체(object)등 다양한 형식의 데이터 타입을 가질 수 있으며 함수의 사용법은 다음과 같다.

pd.Series(data, index=index)

1) 일차원(array) 데이터의 활용

>>> s = pd.Series(np.random.randn(5))
>>> s
0    0.636579
1    1.429441
2   -0.056851
3   -0.330899
4    0.690789
dtype: float64
>>> s = s = pd.Series(np.random.randn(5), index=['A','B','C','D','E'])
>>> s
A    0.449761
B   -0.288997
C   -0.263346
D    1.673738
E   -0.437203
dtype: float64

두 예제에서 보듯이, 인덱스의 값을 부여하지 않으면 ‘pandas’는 자동적으로 0부터 len(data)-1까지의 값을 부여하며, 인덱스 값을 부여하는 경우에는 해당 인덱스로 매칭된다. 인덱스를 부여하는 경우에는 인덱스의 개수와 데이터의 개수가 반듯이 일치하여야 한다.

‘numpy’에서 가장 많이 사용하는 ‘ndarray’는 ‘N’차원의 배열 객체로써 기존의 파이썬은 어떠한 형식이라도 어레이에 담을 수 있으나, ‘ndarray’는 동일한 형태의 데이터만 배열에 담을 수 있는 차이점을 가지고 있다. 우리가 자료를 임의로 생성하여는 경우가 많으므로 난수(random) 데이터를 얻는 함수에 대해 살펴보자

rand(d0, d1, …, dn)	N차원 배열의 난수 발생
randn(d0, d1, …, dn)	표준 정규분포에 따른 N차원 난수 발생
randint(low[, high, size])	low 이상 high 미만의 정수형 난수 발생
random_integers(low[, high, size])	low이상 high이하의 정수형 난수 발생
random_sample([size]) random([size]) ranf([size]) sample([size])	0.0이상 1.0미만의 실수형 난수 발생
choice(a[, size, replace, p])	주어진 1차원 배열을 기반으로 무작위 샘플 추출
bytes(length)	바이트형 난수 발생

2) 딕셔너리(Dictionary)

>>> d = {'a' : 0., 'b' : 1., 'c' : 2.}
>>> pd.Series(d)
a    0.0
b    1.0
c    2.0
dtype: float64
>>> pd.Series(d, index=['a', 'b', 'B', 'c'])
a    0.0
b    1.0
B    NaN
c    2.0
dtype: float64

딕셔너리 형태의 데이터는 인덱스를 부여하지 않으면 딕셔너리 키값이 인덱스로 들어가며, 만약 ‘index값을 지정하는 경우에는 데이터 값에서 해당 인덱스의 값만을 가지고 들어온다. 위의 예에서 ‘d’인덱스에는 ‘B’가 없으므로 생성된 시리즈에는 ‘B’의 값이 ‘NaN(Not a Number)‘으로 들어가 있게 된다.

3) 스칼라(Scalar) 값

>>> pd.Series(7, index=['a', 'b', 'c', 'd', 'e'])
a    7
b    7
c    7
d    7
e    7
dtype: int64

스칼라 값을 이용하여 초기화를 하는 경우에는 반듯이 인덱스가 들어가야 한다.

생성된 데이터의 값을 가지고 오는 방법은 배열에서 데이터를 가지고 오는 방법과 동일한 형식을 가지고 있으며 데이터 연산이 다음과 같이 가능하다.

>>> s = pd.Series([1,2,3,4,5], index=['a', 'b', 'c', 'd', 'e'])
>>> s[0]
1
>>> s[:3]
a    1
b    2
c    3
dtype: int64
>>> s[[4,1]]
e    5
b    2
dtype: int64
>>> np.power(s, 2)
a     1
b     4
c     9
d    16
e    25
dtype: int64

4.2.2 DataFrame

‘DataFrame’은 가장 많이 사용하는 ‘pandas’의 객체로 엑셀과 같이 표의 형식으로 데이터를 표현할수 있어 다양한 형태로 데이터 분석에 사용된다. ‘DataFrame’은 각개의 열은 데이터 형식이 동일하지만 서로 다른 열끼리는 데이터의 형식이 달라도 되기 때문에 하나의 테이블 형태로 데이터를 표현하기에 적합한 형태이다.

1) Series/Dict 데이터의 활용

>>> d = {'one' : pd.Series([1., 2., 3.], index=['a', 'b', 'c']),
         'two' : pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])}
>>> d
{'two': 
a    1.0
b    2.0
c    3.0
d    4.0
dtype: float64, 
'one': 
a    1.0
b    2.0
c    3.0
dtype: float64}
>>> df = pd.DataFrame(d)
>>> df
   one  two
a  1.0  1.0
b  2.0  2.0
c  3.0  3.0
d  NaN  4.0
>>> d = {'one' : pd.Series([1., 2., 3.]),
         'two' : pd.Series([1., 2., 3., 4.])}
>>> df = pd.DataFrame(d)
>>> df
   one  two
0  1.0  1.0
1  2.0  2.0
2  3.0  3.0
3  NaN  4.0

>>> d = {'one' : [1., 2., 3., 4.],
         'two' : [4., 3., 2., 1.]}
>>> df = pd.DataFrame(d)
>>> df
   one  two
0  1.0  4.0
1  2.0  3.0
2  3.0  2.0
3  4.0  1.0

결과값을 보면 알 수 있듯이 인덱스의 값은 다른 한쪽이 없는 경우에는 해당 인덱스를 가지면서 값에는 ‘NaN’를 입력하게 된다. 만약 인덱스 값을 부여하지 않으면 자동으로 0부터 두개의 데이터 중 큰 배열의 길이 – 1 만큼이 부여된다.

2) Dict 리스트 데이터의 활용

>>> data2 = [{'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20}]
>>> pd.DataFrame(data2)
   a   b     c
0  1   2   NaN
1  5  10  20.0
>>> pd.DataFrame(data2, index=['first', 'second'])
        a   b     c
first   1   2   NaN
second  5  10  20.0
>>> pd.DataFrame(data2, columns=['a', 'b'])
   a   b
0  1   2
1  5  10
>>> df.rename(columns={'a':'COL1'})
   COL1   b
0     1   2
1     5  10
>>> df.set_index('b')
    a
b    
2   1
10  5

‘Dict List’는 가장 많이 사용하는 데이터 형식으로 내가 원하는 열의 값만 선택하여 하나의 테이블로 만들 수 있는 장점이 있다. 또한 rename()을 이용하여 지정한 열의 이름을 바꿀 수 있으며 특정 열을 인덱스 열로 변경할 수 있다.

3) 데이터 추가 및 합치기(merge)

>>> data1 = [{'name':'Mark'},{'name':'Eric'},{'name':'Jennifer'}]
>>> df = pd.DataFrame(data1)
>>> df
       name
0      Mark
1      Eric
2  Jennifer
>>> df['age'] = [10, 11, 12]
>>> df
       name  age
0      Mark   10
1      Eric   11
2  Jennifer   12
>>> data2 = [{'sido':'서울'}, {'sido':'경기'}, {'sido':'인천'}]
>>> df2 = pd.DataFrame(data2)
>>> df2
  sido
0   서울
1   경기
2   인천
>>> pd.merge(df1, df2, left_index=True, right_index=True)
       name sido
0      Mark   서울
1      Eric   경기
2  Jennifer   인천

기존의 ‘DataFrame’에 새로운 행을 추가하는 것은 단순하게 컬럼명을 부여하고 데이터 리스트를 만들어 주면 된다. 또한 서로 다른 두개의 ‘DataFrame’을 원하는 형식대로 합치기 위하여 ‘merge()’ 함수를 제공한다. ‘merge()’ 함수는 SQL문과 유사하게 여러 형태의 조인(join)을 수행할 수 있으며, 양 쪽 ‘DataFrame’이 인덱스를 가지고 있을 경우 이를 이용하여 동일한 행으로 추출하여 새로운 테이블을 만들 수 있다. 이외에도 ‘appen()’를 이용하면 동일한 형식의 ‘DataFrame’을 연결할 수 있다.

‘pandas’는 상당히 광범위한 패키지여서 여기서는 우리가 사용하는데 필요한 기능만을 간략하게 설명하였다. 좀더 자세한 사항은 공식 페이지의 매뉴얼을 확인하기 바란다.

4.3 공공데이터를 이용한 상관분석

이번절에서는PYTHON 크롤링 » 10. 공공 정보 데이터 수집하기 에서 수집한 데이터를 이용하여 데이터 분석을 수행하고자 한다. 데이터셋을 만들기 위하여 2011년 1월부터 2016년 9월까지의 서울특별시 유료 관광지 입장 정보 파일을 JSON 형태로 저장한다. 그리고 중국, 일본, 미국인의 입국수 정보를 JSON으로 저장한다. 이제 저장이 완료되었으면 다음과 같이 코드를 작성한다.

저장된 JSON 파일 : 서울특별시_관광지입장정보_2011_2016.json / 중국(112)_해외방문객정보_2011_2016.json / 일본(130)_해외방문객정보_2011_2016.json / 미국(275)_해외방문객정보_2011_2016.json

import json
import math
import numpy as np

import matplotlib.pyplot as plt
import matplotlib
from matplotlib import font_manager, rc

import pandas as pd

#[CODE 1]
def correlation(x, y):
    n = len(x)
    vals = range(n)

    x_sum = 0.0
    y_sum = 0.0
    x_sum_pow = 0.0
    y_sum_pow = 0.0
    mul_xy_sum = 0.0
    
    for i in vals:
        mul_xy_sum = mul_xy_sum + float(x[i]) * float(y[i])
        x_sum = x_sum + float(x[i])
        y_sum = y_sum + float(y[i])
        x_sum_pow = x_sum_pow + pow(float(x[i]), 2)
        y_sum_pow = y_sum_pow + pow(float(y[i]), 2)
    
    try:
        r = ((n * mul_xy_sum) - (x_sum * y_sum)) / math.sqrt( ((n*x_sum_pow) - pow(x_sum, 2)) * ((n*y_sum_pow) - pow(y_sum, 2)) )
    except:
        r = 0.0
    
    return r

#[CODE 2]    
def setScatterGraph(tour_table, visit_table, tourpoint):
    
    #[CODE 8]
    tour = tour_table[tour_table['resNm'] == tourpoint]
    merge_table = pd.merge(tour, visit_table, left_index=True, right_index=True)

    fig = plt.figure()
    
    fig.suptitle(tourpoint + '상관관계 분석')
    
    plt.subplot(1, 3, 1)
    plt.xlabel('중국인 입국수')
    plt.ylabel('외국인 입장객수')
    r = correlation(list(merge_table['china']), list(merge_table['ForNum']))
    plt.title('r = {:.5f}'.format(r))
    plt.scatter(list(merge_table['china']), list(merge_table['ForNum']), edgecolor='none', alpha=0.75, s=6, c='black')

    plt.subplot(1, 3, 2)
    plt.xlabel('일본인 입국수')
    plt.ylabel('외국인 입장객수')
    r = correlation(list(merge_table['japan']), list(merge_table['ForNum']))
    plt.title('r = {:.5f}'.format(r))
    plt.scatter(list(merge_table['japan']), list(merge_table['ForNum']), edgecolor='none', alpha=0.75, s=6, c='black')

    plt.subplot(1, 3, 3)
    plt.xlabel('미국인 입국수')
    plt.ylabel('외국인 입장객수')
    r = correlation(list(merge_table['usa']), list(merge_table['ForNum']))
    plt.title('r = {:.5f}'.format(r))
    plt.scatter(list(merge_table['usa']), list(merge_table['ForNum']), edgecolor='none', alpha=0.75, s=6, c='black')

    plt.tight_layout()

    #fig = matplotlib.pyplot.gcf()
    #fig.set_size_inches(10, 7)
    #fig.savefig(tourpoint+'.png', dpi=300)
 
    plt.show()

def main():

    font_location = "c:/Windows/fonts/malgun.ttf"
    font_name = font_manager.FontProperties(fname=font_location).get_name()
    matplotlib.rc('font', family=font_name)

    #[CODE 4]
    tpFileName = 'd:/Temp/public_data/서울특별시_관광지입장정보_2011_2016.json'
    jsonTP = json.loads(open(tpFileName, 'r', encoding='utf-8').read())
    tour_table = pd.DataFrame(jsonTP, columns=('yyyymm', 'resNm', 'ForNum'))
    tour_table = tour_table.set_index('yyyymm')
    
    #[CODE 5]
    resNm = tour_table.resNm.unique()
    
    #[CODE 6]
    fv_CFileName = 'd:/Temp/public_data/중국(112)_해외방문객정보_2011_2016.json'
    jsonFV = json.loads(open(fv_CFileName, 'r', encoding='utf-8').read())
    china_table = pd.DataFrame(jsonFV, columns=('yyyymm', 'visit_cnt'))
    china_table = china_table.rename(columns={'visit_cnt': 'china'})
    china_table = china_table.set_index('yyyymm')

    fv_JFileName = 'd:/Temp/public_data/일본(130)_해외방문객정보_2011_2016.json'
    jsonFV = json.loads(open(fv_JFileName, 'r', encoding='utf-8').read())
    japan_table = pd.DataFrame(jsonFV, columns=('yyyymm', 'visit_cnt'))
    japan_table = japan_table.rename(columns={'visit_cnt': 'japan'})
    japan_table = japan_table.set_index('yyyymm')

    fv_UFileName = 'd:/Temp/public_data/미국(275)_해외방문객정보_2011_2016.json' 
    jsonFV = json.loads(open(fv_UFileName, 'r', encoding='utf-8').read())
    usa_table = pd.DataFrame(jsonFV, columns=('yyyymm', 'visit_cnt'))
    usa_table = usa_table.rename(columns={"visit_cnt": "usa"})
    usa_table = usa_table.set_index('yyyymm')

    #[CODE 7]
    fv_table = pd.merge(china_table, japan_table, left_index=True, right_index=True)
    fv_table = pd.merge(fv_table, usa_table, left_index=True, right_index=True)

    for tourpoint in resNm:
        setScatterGraph(tour_table, fv_table, tourpoint)
           
if __name__ == "__main__":
    main()

코드를 수행하면 서울시 입장객과 각국 입국수에 따른 상관분석 자료가 [그림 5]와 같이 나타난다.

[그림 5] 경복궁 입장객 상관관계 분석

그럼 이제 코드를 살펴 보도록 하자. [CODE 1]은 파이썬으로 상관관계 분석을 하는 함수이다. ‘scipy’를 이용하면 상관분석 계수가 하나의 함수로 간단하게 나오지만, 여기서는 상관분석 함수를 직접 작성하여 보았다.

[CODE 2]는 ‘scatter()’ 함수를 이용하여 그래프를 그린다. 1 x 3 의 형태로 나타내기 위하여 subplot()함수를 사용하였다. ‘pyplot’의 그래프는 앞절에서 설명하였으므로 참고하기 바란다(내용중 [CODE 8]에 대한 설명은 잠시 후 하기로 한다).

본 과정에서는 데이터를 어떻게 분석하는가에 관점이 맞추어져 있으므로 python 쉘에서 [CODE 4], [CODE 5], [CODE 6]을 통해 ‘DataFrame’을 어떻게 사용하는지 설명하도록 하겠다. 먼저 저장된 파일이 JSON 형태이므로 ‘json’을 ‘import’하고 ‘DataFrame’을 위하여 ‘pandas’를 ‘import’ 한다.

>>> import json
>>> import pandas as pd

‘import’를 마치면 저장한 서울특별시 유료 관광객 파일을 JSON 형태로 읽어들여와 ‘DataFrame’으로 변환한다([CODE 4] 부분).

>>> tpFileName = 'd:/Temp/public_data/서울특별시_관광지입장정보_2011_2016.json'
>>> jsonTP = json.loads(open(tpFileName, 'r', encoding='utf-8').read())
>>> tour_table = pd.DataFrame(jsonTP)
>>> tour_table.head()

로드된 ‘tour_table’은 다음과 같은 형태로 표현된다(‘DataFrame’의 값을 보고자 할 때는 ‘.head()’를 사용하면 맨 앞 5개의 데이터를 보여준다. 괄호안에 숫자를 넣으면 해당 숫자만큼 열을 반환하며 기본값은 n=5이다).

	ForNum	NatNum	addrCd	gungu	resNm	rnum	sido	yyyymm
0	14137	43677	1111	종로구	창덕궁	1	서울특별시	201101
1	0	6523	1111	종로구	운현궁	2	서울특별시	201101
2	40224	141183	1111	종로구	경복궁	3	서울특별시	201101
3	697	17644	1111	종로구	창경궁	4	서울특별시	201101
4	6837	11486	1111	종로구	종묘	5	서울특별시	201101

상기 표에서 보듯이 JSON 형식의 각 키에 해당하는 값들이 테이블의 형태로 간단하게 입력된것을 확인할 수 있다. 그러나 우리는 모든 데이터를 사용할 것이 아니고 외국인 입장객수와, 관광지명, 그리고 입장년월만이 필요하므로 ‘column’ 인자를 사용하여 데이터를 불러온다

>>> tour_table = pd.DataFrame(jsonTP, columns=('yyyymm', 'resNm', 'ForNum'))
>>> tour_table.head()

	yyyymm	resNm	ForNum
0	201101	창덕궁	14137
1	201101	운현궁	0
2	201101	경복궁	40224
3	201101	창경궁	697
4	201101	종묘	6837

데이터 처리에 필요한 ‘yyyymm’, ‘resNm’, ‘ForNum’만을 ‘column’의 인자값으로 주어 필요한 데이터만 추출하였다. 이제 출입국자들의 정보와 나중에 합치기 위하여 ‘연월’에 해당하는 ‘yyyymm’을 ‘set_index()’를 이용하여 인덱스 값으로 지정한다.

>>> tour_table = tour_table.set_index('yyyymm')
>>> tour_table.head(3)
resNm  ForNum
yyyymm              
201101   창덕궁   14137
201101   운현궁       0
201101   경복궁   40224

저장된 데이터 프레임에서 서울시 유료 관광지로 통계가 잡히는 곳이 어떤 곳인지 확인하기 위하여 ‘unique()’ 함수를 사용할 수 있다. ‘unique()’를 사용하면 해당 컬럼의 중복되지않는 값만을 확인할 수 있다([CODE 5] 부분).

>>> resNm = tour_table.resNm.unique()
>>> resNm
array(['창덕궁', '운현궁', '경복궁', '창경궁', '종묘', '국립중앙박물관', '서울역사박물관', '덕수궁',
     '서울시립미술관 본관', '태릉·강릉·조선왕릉전시관', '서대문형무소역사관', '서대문자연사박물관',
     '트릭아이미술관', '헌릉ㆍ인릉', '선릉·정릉', '롯데월드'], dtype=object)

서울시의 유료 관광객 입장수가 집계되는 곳은 경복궁, 종묘 등 총 16군데이다. 이 값을 ‘resNm’ 부분에 저장해서 추후에 데이터를 불러오는 키값으로 사용한다.

이제 앞장에서 저장한 JSON 형식의 국가별 입국 정보를 ‘DataFrame’으로 변환하고 인덱스 값을 ‘yyyymm’ 컬럼으로 대치한다([CODE 6] 부분)

>>> fv_CFileName = 'd:/Temp/public_data/중국(112)_해외방문객정보_2011_2016.json'
>>> jsonFV = json.loads(open(fv_CFileName, 'r', encoding='utf-8').read())
>>> china_table = pd.DataFrame(jsonFV, columns=('yyyymm', 'visit_cnt'))
>>> china_table.head()
   yyyymm  visit_cnt
0  201101      91252
1  201102     140571
2  201103     141457
3  201104     147680
4  201105     154066
>>> china_table = china_table.rename(columns={'visit_cnt': 'china'})
>>> china_table = china_table.set_index('yyyymm')
>>> china_table.head()
         china
yyyymm        
201101   91252
201102  140571
201103  141457
201104  147680
201105  154066

동일한 방식으로 일본인 입국수와 미국인 입국수를 처리한후 다음과 같이 국가별 입국수를 합쳐서 하나의 데이터 프레임으로 만든다.

>>> fv_table = pd.merge(china_table, japan_table, left_index=True, right_index=True)
>>> fv_table.head()
         china   japan
yyyymm                
201101   91252  209184
201102  140571  230362
201103  141457  306126
201104  147680  239075
201105  154066  241695
>>> fv_table = pd.merge(fv_table, usa_table, left_index=True, right_index=True)
>>> fv_table.head()
         china   japan    usa
yyyymm                       
201101   91252  209184  43065
201102  140571  230362  41077
201103  141457  306126  54610
201104  147680  239075  59616
201105  154066  241695  59780

이제 각 입국자 숫자가 하나의 데이터 프레임으로 만들어 졌으니 ‘resNM’에서 추출하는 관광지 이름과, ‘tour_table’, ‘fv_table’을 인자로 하여 ‘setScatterGraph()’ 함수를 호출하면 함수 내부에서는 전달받은 인자값으로 데이터 프레임을 생성한다. 다음의 예는 ‘경복궁’을 관광지 이름으로 받았다는 전제하에서 수행한다([CODE 8] 부분).

>>> tour = tour_table[tour_table['resNm'] == '경복궁']
>>> tour.head()
       resNm  ForNum
yyyymm              
201101   경복궁   40224
201102   경복궁   44906
201103   경복궁   73166
201104   경복궁   89972
201105   경복궁   80539
>>> merge_table = pd.merge(tour, fv_table, left_index=True, right_index=True)
>>> merge_table.head()
          resNm  ForNum   china   japan    usa
yyyymm                                     
201101   경복궁   40224   91252  209184  43065
201102   경복궁   44906  140571  230362  41077
201103   경복궁   73166  141457  306126  54610
201104   경복궁   89972  147680  239075  59616
201105   경복궁   80539  154066  241695  59780

전달받은 ‘tour_table’은 16개 관광지에 대한 모든 데이터를 가지고 있기 때문에 계산할 관광지명에 해당하는 데이터만을 뽑아 ‘tour’ 데이터 프레임에 저장하고 이를 전달받은 외국인 방문객 데이터 프레임과 병합(merge)시키면 우리가 지정한 관광지에 대한 입장객수, 입국 외국인수가 결합된 데이터 프레임이 완성된다. 이제 그래프를 그리기 위하여 입장객수(ForNum)과 해당 국가(china, japan, 또는 usa) 열을 scatter()함수로 전달하면 원하는 그래프와 상관계수 값을 얻게 된다.

[CODE 9]에서는 함수를 수행하면서 반환한 리스트 값을 추가하여, 각 관광지마다 상관계수 값을 가지고 온다. 다음 예에서 ‘r_list’는 코드를 수행하여 반환한 값이다. 수신한 리스트 값을 ‘r_table’ 데이터 프레임으로 만들고, 인덱스를 ‘tourpoint’로 변환한다([CODE 10] 참조).

r_list = [['창덕궁', -0.058791104060063125, 0.27744435701410114, 0.40281606330501574], ['운현궁', 0.44594488384450376, 0.3026152182879861, 0.2812576500158649], ['경복궁', 0.5256734293511214, -0.4352281861341233, 0.42513726387044926], ['창경궁', 0.4512325398089607, -0.16458589402253013, 0.6245403780269381], ['종묘', -0.5834218986767474, 0.5298702802205213, -0.12112666829294959], ['국립중앙박물관', 0.39663594900292837, -0.06923889417914424, 0.3789788348060077], ['서울역사박물관', 0.4169985898874495, 0.4929777868070643, 0.2411976107709704], ['덕수궁', 0.4332132943587757, -0.4326719125679966, 0.4808588469548069], ['서울시립미술관 본관', 0.0, 0.0, 0.0], ['태릉 ·  강릉 · 조선왕릉전시관', -0.08179909096513825, 0.0634032985209752, -0.06884011648164298], ['서대문형무소역사관', 0.47262271531670347, 0.006098570233700235, 0.22900879409607508], ['서대문자연사박물관', 0.0, 0.0, 0.0], ['트릭아이미술관', 0.340084882575556, -0.15036015533747007, 0.18094502388483083], ['헌릉ㆍ인릉', -0.5813250357820897, 0.46453007122911255, -0.1853887818740637], ['선릉·정릉', -0.5715258789199192, 0.38806730592260075, -0.12494498568749024], ['롯데월드', 0.5105587922155749, 0.23511773800458452, -0.12673869767365747]]

>>> r_table = pd.DataFrame(r_list, columns=('tourpoint', 'china', 'japan', 'usa'))
>>> r_table = r_table.set_index('tourpoint')
>>> r_table
                       		china     	japan       	usa
tourpoint                                       
창덕궁                		-0.058791  	0.277444  	0.402816
운현궁                 		0.445945  	0.302615  	0.281258
경복궁                 		0.525673 	-0.435228  	0.425137
창경궁                 		0.451233 	-0.164586  	0.624540
서울시립미술관 본관          	0.000000  	0.000000  	0.000000
서대문자연사박물관           	0.000000  	0.000000  	0.000000
…

r_table을 확인하면 ‘서울시립미술관 본관’과 ‘서대문자연사박물관’의 경우 상관계수값이 없는 것을 확인할 수 있다. 그래프에서 필요없는 열은 다음과 같이 삭제를 한다.

>>> r_table.drop('서울시립미술관 본관')
>>> r_table.drop('서대문자연사박물관')
>>> r_table = r_table.sort('china', ascending=False)
>>> r_table.head()
              		china     	japan       	usa
tourpoint                              
경복궁        		0.525673 	-0.435228  	0.425137
롯데월드       		0.510559  	0.235118 	-0.126739
서대문형무소역사관  	0.472623  	0.006099  	0.229009
창경궁        		0.451233 	-0.164586  	0.624540
운현궁        		0.445945  	0.302615  	0.281258

해당 열의 인덱스 값을 가지고 ‘drop()’ 함수를 사용하여 데이터를 삭제한 후 ‘sort()’를 이용하여 ‘china’ 열을 내림차순으로 정렬하였다.

>>> font_location = "c:/Windows/fonts/malgun.ttf"
>>> font_name = font_manager.FontProperties(fname=font_location).get_name()
>>> matplotlib.rc('font', family=font_name)
>>> r_table.plot(kind='bar', rot=70)
<matplotlib.axes._subplots.AxesSubplot object at 0x00000082F2368BA8>
>>> plt.show()

정렬이 되었으면 그래프를 그리기 위하여 한글 폰트를 로드하고, ‘plot()’ 함수를 이용하여 그래프를 그려보면 [그림 6]과 같이 중국인 입국수 대비 관광객 입장객수의 상관계수가 높은 순서대로 3개국의 계속 비교를 할 수 있다

[그림 6] 중국, 일본, 미국 입국객과 서울특별시 관광지 입장객의 상관계수 분석

그래프를 보면 재미있는 현상이 보이는데 중국인 상관계수가 높은 관광지와 일본인 상관계수가 완전히 상반되게 나오는 관광지가 ‘경복궁’, ‘덕수궁’ ‘선릉·정릉’, 헌릉·인릉’과 ‘종묘’로 나타난다. 분석한 데이터가 6년치 관광지 입장객 통계에 불과하여 정확한 결론을 내기 힘들지만, 적어도 중국인에게 관광지를 추천한다면 ‘경복궁’, ‘롯데월드’ 순서가 될것이고 일본인에게는 ‘종묘’, ‘헌릉·인릉’순이 아닐까 생각된다(역사적 배경을 따져 보더라도 조금 의미있는 부분이 되지 않을까 생각이 들지만 정확한 결과를 도출하기 위해서는 패키지관광인지 자유관광인지, 숙박업소가 어느쪽에 편중되는지 등 영향을 미칠 요소 데이터를 확보해서 분석이 필요한 부분이다).

3. 다빈도 명사추출 시각화 - KoNLPy, matplotlib, PyTagCloud

Sun, 21 Jan 2018 11:01:00 +0000

3. 명사 추출 및 빈도 분석

이번절에서는 앞에서 알아본 1. 빈도 분석 - KoNLPy 설치하기(문장 형태소 분석)을 이용하여 수집된 데이터의 명사를 추출하고 이를 2. 그래프를 그리자 : matplotlib를 이용하여 그래프로 표시하고, ‘pytagcloud’를 이용하여 워드클라우드로 표현해 본다.

먼저 데이터 수집을 위하여 페이스북의 조선일보(chosun)과 JTBC 뉴스(jtbcnews)를 ‘2016-10-01’부터 ‘2017-03-12’일 까지의 데이터를 PYTHON 크롤링 » 5. Facebook 데이터 수집에서 제작한 페이스북 크롤러를 이용하여 수집하였다. 먼저 다음과 같이 코드를 작성한다.

저장된 JSON 파일 : 조선일보데이터 / JTBC데이터

import json
import re

from konlpy.tag import Twitter
from collections import Counter

import matplotlib.pyplot as plt
import matplotlib
from matplotlib import font_manager, rc

import pytagcloud
import webbrowser

#[CODE 1]
def showGraph(wordInfo):
    
    font_location = "c:/Windows/fonts/malgun.ttf"
    font_name = font_manager.FontProperties(fname=font_location).get_name()
    matplotlib.rc('font', family=font_name)

    plt.xlabel('주요 단어')
    plt.ylabel('빈도수')
    plt.grid(True)
    
    Sorted_Dict_Values = sorted(wordInfo.values(), reverse=True)
    Sorted_Dict_Keys = sorted(wordInfo, key=wordInfo.get, reverse=True)

    plt.bar(range(len(wordInfo)), Sorted_Dict_Values, align='center')
    plt.xticks(range(len(wordInfo)), list(Sorted_Dict_Keys), rotation='70')

    plt.show()

#[CODE 2]
def saveWordCloud(wordInfo, filename):
    
    taglist = pytagcloud.make_tags(dict(wordInfo).items(), maxsize=80)
    pytagcloud.create_tag_image(taglist, filename, size=(640, 480), fontname='korean', rectangular=False)
    webbrowser.open(filename)   
    
    
def main():
    #여기서 파일의 경로는 실제 JSON 데이터가 저장된 경로이다
    openFileName = 'd:/Temp/FB_DATA/chosun_facebook_2016-10-01_2017-03-12.json'
    #openFileName = 'd:/Temp/FB_DATA/jtbcnews_facebook_2016-10-01_2017-03-12.json'
    cloudImagePath = openFileName + '.jpg'
    
    rfile = open(openFileName, 'r', encoding='utf-8').read()
    
    jsonData = json.loads(rfile)
    message = ''

    #[CODE 3]
    for item in jsonData:
        if 'message' in item.keys():
            message = message + re.sub(r'[^\w]', ' ', item['message']) + ' '
    
    #[CODE 4]
    nlp = Twitter()
    nouns = nlp.nouns(message)
    count = Counter(nouns)

#[CODE 5]
    wordInfo = dict()
    for tags, counts in count.most_common(50):
        if (len(str(tags)) > 1):
            wordInfo[tags] = counts
            print ("%s : %d" % (tags, counts))
            
    showGraph(wordInfo)
    saveWordCloud(wordInfo, cloudImagePath)
    
if __name__ == "__main__":
    main()

코드를 수행하여 ‘조선일보’와 ‘jtbc뉴스’에 대한 다빈도 명사를 확인하여 보면 [그림 1]과 [그림 2]와 같이 나타남을 확인할 수 있다.

[그림 1] 조선일보 페이스북에서 2016-10-01~2017-03-12간 사용한 다빈도 명사

[그림 2] JTBC 페이스북에서 2016-10-01~2017-03-12간 사용한 다빈도 명사

[그림 1]과 [그림 2]에서 보면 의미없는 명사들도 보이는데, 이러한 데이터는 분석을 위해서는 제제거 사용하는 것이 좋을 듯 하다. 조선일보의 경우에는 ‘최순실’이라는 단어가 ‘탄핵’이라는 단어보다 많이 나오지만, JTBC의 경우에는 반대 경우로 나타난다. 또한 ‘조선일보’의 경우에는 상대적으로 ‘박근혜’라는 이름을 적게 언급한 것으로 볼 수 있다. 또한 조선일보에서는 ‘사드’라는 단어가 보이자만 JTBC의 경우에는 상위 부분에서 ‘사드’라는 단어가 검색되지 않았음이 확인되었다. 그러나 전체 기사의 총수가 포함되지 않은 상태에서 이를 비교하기란 조금 억지스러운 부분이 있고, 추출된 데이터를 각 페이스북의 기사수로 정규화하여 비교하는 것이 의미있을 것이다.

[그림 3]과 [그림 4]는 해당 추출된 단어들을 가지고 워드 클라우드 - 글자들로 구성된 구름 모양의 그림이라고 해석해야 할 것 같다 – 를 생성한 것이다.

[그림 3] 조선일보 페이스북 다빈도 명사 워드 클라우드

[그림 4] JTBC뉴스 페이스북 다빈도 명사 워드 클라우드

그럼 이제 코드를 살펴 보도록 하자.

#[CODE 1]
def showGraph(wordInfo):
    
    font_location = "c:/Windows/fonts/malgun.ttf"
    font_name = font_manager.FontProperties(fname=font_location).get_name()
    matplotlib.rc('font', family=font_name)

    plt.xlabel('주요 단어')
    plt.ylabel('빈도수')
    plt.grid(True)
    
    Sorted_Dict_Values = sorted(wordInfo.values(), reverse=True)
    Sorted_Dict_Keys = sorted(wordInfo, key=wordInfo.get, reverse=True)

    plt.bar(range(len(wordInfo)), Sorted_Dict_Values, align='center')
    plt.xticks(range(len(wordInfo)), list(Sorted_Dict_Keys), rotation='70')

    plt.show()

[CODE 1]의 showGraph()는 wordInfo라고 하는 딕셔너리(Dictionary)형식의 데이터를 받아 막대 그래프를 그리는 함수이다. 먼저 한글 폰트를 지원하기 위하여 ‘fontmanager’와 ‘rc’를 사용하였고, 라벨에 값을 부여하였다. 딕셔너리 형식의 데이터에서 키값과 밸류값을 별도로 분리하여 리스트 형태고 작성하였으며, 최대빈도부터 표현하기 위하여 sorted()함수를 사용하였다. 이렇게 구성하면 ‘Sorted_Dict_Keys’와 ‘Sorted_Dict_Values’쌍에는 최대 빈도수값과 최대빈도수 단어가 저장되게 된다.

‘pyplot.bar(index, list, args…)’ 함수는 막대 그래프를 그리는 함수로 필수 인자로는 데이텅 인덱스(X축), 데이터 리스트값(인덱스에 해당하는 데이터값)이며 막대그래프의 폭(width), 색상(color), 에러편차값(yerr)등을 인자로 전달할 수 있다.

‘pyplot.xticks(index, list, args…)’ 함수는 x축의 각 데이터별 문자열(tick)을 지정한다. rotation을 사용하면 문자열을 회전시킬 수 있어 열에 표시하는 데이터가 많은 경우에는 좌우 문자열(tick)과 겹치지 않도록 하기 위하여 많이 사용한다.

#[CODE 2]
def saveWordCloud(wordInfo, filename):
    taglist = pytagcloud.make_tags(dict(wordInfo).items())
    pytagcloud.create_tag_image(taglist, filename, size=(640, 480), fontname='korean', rectangular=False)
    webbrowser.open(filename)

파이썬은 워드클라우드를 만들기 위하여 다양한 패키지를 제공한다. 이중 일반적으로 많이 사용하는 패키지가 ‘pytagcloud’이다. 먼저 패키지 사용을 위하여 설치를 한다.

[파이썬 설치 경로]\\pip install pytagcloud

‘pytagcloud’도 역시 한글 폰트를 제공하지 않는다. ‘[파이썬이 설치된 경로]\Lib\site-packages\pytagclod\fonts’ 디렉터리로 이동하면 여러 개의 ‘.ttf’ 파일과 ‘font.json’파일이 [그림 5]와 같이 존재할 것이다(저자의 경우 파이썬이 설치된 경로는 D:\Program Files\Python이다)

[그림 5] pytagcloud font 디렉터리

실제 ‘pytagcloud’ 코드를 확인해보면 기본 폰트로 ‘Droid Sans’ 지정되어 있고, fonts.json 파일을 참조하여 폰트를 가지고 오게 되어있다. 먼저 우리가 사용할 폰트를 윈도우 폰트 디렉터리에서(PYTHON 시각화 » 2.3 한글 처리에서 설명) 사용할 폰트를 복사하여 ‘[파이썬이 설치된 경로]\Lib\site-packages\pytagclod\fonts’ 디렉터리에 복사한 후 에디터를 이용하여 ‘fonts.json’ 파일을 [그림 6]과 같이 수정한다.

[그림 6] 한글 지원을 위한 fonts.json 파일의 수정

‘pytagcloud’는 사용하는 폰트 정보를 ‘fonts.json’에서 관리한다. font.json 파일을 다음과 같이 수정한다.

{
	"name": "korean",
	"ttf": "malgun.ttf",
	"web": http://fonts.googleapis.com/css?family=Nobile
},

JSON 파일에서 접근할 폰트명과 실제 사용할 폰트파일을 지정해 준다. ‘pytagcloud’의 공식문서에는 자세하게 ‘web’에 대해 설명하고 있지 않는데 코드를 찾아 보아도 크게 쓰이는 부분을 확인하기 힘들다.

먼저 추출된 문자열을 리스트로 생성하여 pytagcloud.create_tag_image(데이터리스트, 저장할 파일명, 저장할 크기, fontname=’korean’, args…)함수로 전달한다. 여기서 ‘fontname’은 JSON 파일에서 지정한 ‘name’의 값을 지정한다. ‘pytagcloud.create_tag_image()’ 함수를 사용하면 간단하게 한줄로 워드 클라우드를 생성할 수 있다(역시 파이썬은 참 편하게 사용할 수 있는 언어이다).

저장된 파일은 ‘webbrowser’ 모듈은 open()함수를 이용하여 저장한 파일을 불러올 수 있다.

def main():
    
    openFileName = 'd:/Temp/FB_DATA/chosun_facebook_2016-10-01_2017-03-12.json'
    #openFileName = 'd:/Temp/FB_DATA/jtbcnews_facebook_2016-10-01_2017-03-12.json'
    cloudImagePath = openFileName + '.jpg'
    
    rfile = open(openFileName, 'r', encoding='utf-8').read()
    
    jsonData = json.loads(rfile)
    message = ''

    #[CODE 3]
    for item in jsonData:
        if 'message' in item.keys():
            message = message + re.sub(r'[^\w]', ' ', item['message']) + ' '
    
    #[CODE 4]
    nlp = Twitter()
    nouns = nlp.nouns(message)
    count = Counter(nouns)

#[CODE 5]
    wordInfo = dict()
    for tags, counts in count.most_common(50):
        if (len(str(tags)) > 1):
            wordInfo[tags] = counts
            print ("%s : %d" % (tags, counts))
            
    showGraph(wordInfo)
    saveWordCloud(wordInfo, cloudImagePath)
    
if __name__ == "__main__":
    main()

작성된 함수를 사용하기 위해서 main()에서는 JSON 형태로 저장된 페이스북 피드 파일을 불러와서 jsonData에 저장하고, [CODE 3]과 같이 ‘message’의 내용을 합쳐 하나의 문자열로 만드는 작업을 수행한다. 이 때 의 json 형태 파일중에 메시지 부분의 데이터를 불러와 이를 문자열로 구성한다. 정규식 처리를 한 이유는 ‘message’ 부분에 ‘\t’이나 ‘\n’등의 문자를 제거하기 위해서 문자나 숫자가 아닌 경우에는 공란(‘ ‘)으로 바꾼후 넣어 문자열을 작성한다.

[CODE 4]에서는 konlpy.tag의 Twitter() 품사 클래스를 이용하였다. ‘KoNLPy’는 Kkma, Komoranm Twitter, Mecab(윈도우에서는 사용 불가), Hannanum 등의 여러 품사 클래스가 있는데 사용을 해보면 긴 데이터를 넣는 경우에 일부 클래스에서는 응답이 상당히 늦거나 동작을 안하는 경우가 발생하였다. ‘Twitter()’ 클래스의 ‘nouns()’를 이용하여 명사만을 추출한 리스트를 작성한다.

작성된 명사 리스트는 Counter()를 이용하여(인스톨 안되어 있으면 추가) 개수를 세고, 이중에 most_common(50) 함수를 이용하여 상위 50개의 리스트를 가지고 온다. 이 때 실제 명사가 한글자인경우는 제외하였는데 의미있는 명사일 수 있지만 품사클래스에 따라 의미없는 것이 많으므로 제외하였다(필터 함수를 제작하여 걸러내는것도 의미 있을 것이다).

우리는 이번절에서 KoNLPy와 PyTagCloud 패키지를 이용하여 데이터열에서 간단하게 명사만을 추출하고, 이를 워드클라우드 형태의 이미지 파일로 생성하는 방법을 알아 보았다. 파이썬은 편의성을 확장하기 위하여 계속 진화하고 있으며, 수많은 개발자들에 의하여 다양한 모듈이 매일 개발되거나 업그레이드되고 있어 어디까지 우리를 편하게 해줄기 상상만해도 즐겁다.

2. 그래프를 그리자 - matplotlib

Sun, 21 Jan 2018 11:01:00 +0000

2. 그래프를 그리자 : matplotlib

우리는 공공 정보 데이터 수집하기에서 ‘출입국 관광객 정보 서비스’ 부분에서 ‘matplotlib’를 활용하여 그래프를 그리는 방법에 대해 알아보았다. ‘matplotlib’은 파이썬을 이용한 데이터 분석에 있어서 가장 일반적으로 사용되는 라이브러리로 수치해석에 많이 사용되는 ‘MATLAB’과 유사한 형태의 차트를 그릴 수 있는 다양한 함수를 제공해 준다.

2.1 기본 그래프 그리기

이중 먼저 pyplot을 이용하는 방법에 대해 알아보도록 하자. 단위 코딩을 하기 위하여 python 에뮬레이터를 실행시키거나 python IDLE를 실행시킨후 다음과 같이 작성한다.

>>> import matplotlib.pyplot as plt
>>> plt.plot([1,2,3,4])
>>> plt.xlabel('X-axis label’)
>>> plt.ylabel('Y-axis label')
>>> plt.show()

plt.show()를 실행하면 [그림 1]과 같이 그래프 윈도우가 나타날 것이다.

[그림 1] pyplot 예제 1

plot()함수는 다양현 형태의 인자값을 가진다. 먼저, [그림 1]을 보면 y축의 값은 1부터 시작되는데 x축의 값은 0부터 시작함을 알 수 있다. 이는 우리가 plot()함수에 y값만을 할당하고 x값은 함수 내부에서 지정하는 값(인덱스 값이므로 0부터 시작)으로 매칭되었기 때문이다. 만약 인덱스를 주고 싶다면 다음과 같이 plot()함수를 수정한 후 수행해 보자.

>>> plt.plot([1,2,3,4],[1,2,3,4])
>>> plt.show()

코드를 수행하면 [그림 2]와 같이 x축의 인덱스가 1부터 시작하는 것을 확인할 수 있다.

[그림 2] x축에 인덱스를 준 경우

그런데 이상한 것은 이 그래프가 직선을 유지하고 있다는 것이다. 원래 원하는 것은 x=1일 때 y=1 이고 x=2일 때 y=2 인 그래프를 그리는 것이 목적일 수 있다. plot()함수는 기본적으로 꺽은선 그래프를 기본값을 하고 있다. 이 인자값을 바꾸기 위하여 다음과 같이 해보자.

>>> plt.plot([1,2,3,4], [1,2,3,4], 'ro')
>>> plt.show()

코드를 수행하면 [그림 3]과 같이 화면에 나타나는 것을 확인할 수 있다

[그림 3] ‘ro’ 옵션으로 값 표시하기

기본적으로 ‘plot()’은 ‘b-‘ 옵션을 기본값으로 가지고 있는데, 파란색(b)라인(-) 이라는 뜻이고, ‘ro’ 옵션을 주면 ‘적색(r)’ 으로 ‘o’ 표시를 의미한다. 만약 ‘파란색’을 이용하여 ‘v’ 마크를 표시하고 싶다면 인자값으로 ‘bv’라고 지정하면 된다. 두개의 리스트가 같은 인덱스에 해당하는 값으로 표시하는 것을 알 수 있다. ‘plot()’의 옵션으로 사용되는 값들은 그래프 형식 이외에 여러가지가 있는데 ‘matplotlib’ 공식 사이트(http://matplotlib.org)에서 확인하기 바란다.

2.2 복수개의 시리즈 그리기

이제는 한 개의 그래프에 여러 개의 데이터를 표현하는 방법에 대해 알아보자.

>>> plt.plot([1,2,3,4],[1,2,3,4],'r-', [1,2,3,4],[3,4,5,6],'v-')
>>> plt.show()

코드를 수행하면 [그림 4]와 같이 두개의 그래프를 하나의 그림에 나타낼 수 있다.

[그림 4] 하나의 화면에 여러 개의 그래프 그리기

2.3 한글 처리

[그림 1]에서 우리는 X축과 Y축에 ‘.xlabel()’과 ‘.ylabel()’을 이용하여 ‘라벨’을 넣을 수 있었다. 그런데 아래와 같이 입력을 한 후 수행을 하면 [그림 5]처럼 글자가 깨져 나오는 것을 확인할 수 있다.

>>> plt.plot([1,2,3,4])
>>> plt.xlabel('x축 한글표시')
>>> plt.show()

[그림 5] pyplot에서의 한글 깨짐

‘matplotlib’에서 한글을 사용하기 위해서는 약간의 작업이 필요하다. 먼저 탐색기를 이용하여 윈도우 폰트 디렉터리로 [그림 6]처럼 이동해 보자.

[그림 6] 윈도우 설치 디렉터리 아래 Fonts 폴더로 이동

상당한 수의 폰트가 설치되어 있는 것을 확인할 수 있는데, 아쉽게도 여기서는 폰트의 파일명을 확인할 수 없고 적용된 폰트 리스트만 확인이 된다. 이 이유는 실제 폰트 파일은 일반폰트, 두꺼운(bold) 폰트등 여러 개의 파일로 구성되어 있는 패키지이기 때문이다. 해당 파일(여기서는 맑은 고딕)을 선택한 후 오른쪽 마우스를 눌러 [열기]를 선택하면 [그림 7]과 같이 복수개의 폰트가 존재함을 확인할 수 있다.

[그림 7] 폰트 파일명 확인

이제 폰트 패키지의 개별 파일들이 보이게 되므로 사용할 파일을 선택한 후 오른쪽 마우스를 눌러 속성을 확인하면 상단에 파일명이 나타나는 것을 확인할 수 있다. ‘matplotlib’에서는 직접 설치된 폰트 파일명을 경로와 함께 지정해 주면 해당 폰트를 사용할 수 있도록 해준다. 이제 다음과 같이 코드를 작성해 보자.

>>> from matplotlib import font_manager, rc
>>> import matplotlib
>>> font_location = "c:/Windows/fonts/malgun.ttf"
>>> font_name = font_manager.FontProperties(fname=font_location).get_name()
>>> matplotlib.rc('font', family=font_name)
>>> plt.plot([1,2,3,4])
>>> plt.xlabel('x축 한글표시')
>>> plt.show()

코드를 수행하면 [그림 8]과 같이 정상적으로 한글이 표현됨을 확인할 수 있다.

[그림 8] pyplot에서 한글 사용하기

‘matplotlib’는 폰트 관리를 위한 ‘fontmanager’와 리소스 관리를 위한 ‘rc’를 제공한다. ‘fontmanager’를 이용하여 [그림 7]에서 확인한 내 컴퓨터상의 한글 폰트 파일명을 가지고 온 후 이를 리소스에 할당하면 해당 폰트를 사용할 준비가 된다. 이 후 ‘matplotlib’내에서 한글을 사용하면 [그림 8]처럼 정상적으로 나타난다.

2.4 한 화면에 여러개 그래프 그리기

앞서 우리는 [그림 4]와 같이 하나의 그래프에 여러 개의 데이터를 그리는 방법을 알아보았다. 이와 함께 하나의 화면에 여러 개의 그래프를 개별적으로 그려야 하는 경우가 있다. 이를 위하여 다음과 같이 작성해 보자.

>>> plt.figure()
>>> plt.subplot(2, 1, 1)
>>> plt.plot([1,2,3,4], [1,2,3,4])
>>> plt.subplot(2,1,2)
>>> plt.plot([5,6,7,8],[5,6,7,8])
>>> plt.show()

[그림 9] 한 개의 창에 여러 개의 그래프 그리기(세로형)

코드를 실행하면 [그림 9]와 같이 하나의 창에 두개의 그래프가 그려지는 것을 확인할 수 있다. 기본적으로 pyplot은 figure()라는 함수를 이용하여 하나의 캔버스(그림창)을 생성한다. 그리고 이 창에 여러 개의 그래프를 넣기 위해서는 ‘subplot(m , n, idx)’ 함수를 사용한다.

‘m’과 ‘n’은 매트릭스(matrix)형태로써 ‘2,1’을 지정하면 행(row)가 2개이고 열(column)이 1개인 창을 의미한다. 그리고 ‘idx’는 ‘m x n’ 형태의 창중에 ‘idx’번째 위치를 의미하는 것이다. 우리가 앞에서 plt.subplot(2, 1, 1)을 이용하여 그린 것이 [그림 9]의 상단의 그래프가 되는 것이고 plt.subplot(2, 1, 2)가 하단의 그래프가 되는 것이다(총 2 x 1의 그래프를 생성하였고 1은 첫번째 열, 2는 두번쨰 열(컬럼이 한 개밖에 없으므로 다음번으로 넘어가게 된다).

만약 하나의 행에 여러 개의 열(column)을 표시하는 형태라면 다음과 같이 작성해 본다.

>>> plt.figure()
>>> plt.subplot(1, 2, 1)
>>> plt.plot([1,2,3,4], [1,2,3,4])
>>> plt.subplot(1, 2, 2)
>>> plt.plot([5,6,7,8],[5,6,7,8])
>>> plt.show()

[그림 10] 한 개의 창에 여러 개의 그래프 그리기(가로형)

[그림 10]에서는 ‘1 x 2’ 형태의 캔버스를 생성하였고, (1, 2, 1)은 1행의 첫번째 컬럼, (1, 2, 2)는 1행의 두번째 컬럼을 의미한다.

2.5 그래프에 문자 삽입

그래프 표현을 하면서 특정 값을 그래프 안에 삽입하여 표시하여야 하는 경우가 많이 생긴다. 문자열 처리를 위하여 다음과 같이 코드를 작성한다.

>>> plt.plot([1,2,3,4], [1,2,3,4])
>>> plt.xlabel('x축')
>>> plt.ylabel('y축')
>>> plt.title('matplotlib 활용')
>>> plt.text(3.5, 3.0, '평균:2.5')
>>> plt.grid(True)
>>> plt.show()

코드를 수행하면 [그림 11]과 같이 나타난다.

[그림 11] 문자열 할당

‘.xlabel()’은 x축의 라벨을, ‘.ylabel()’은 y축의 라벨에 문자열을 지정한다. ‘.title()’은 그래프의 제목을상단에 표시한다. ‘.text(x, y, 문자열)’은 그래프의 지정 위치에 문자열을 표시하는데, x와 y의 값은 그래프상의 x축과 y축의 값을 의미한다. ‘.grid()’는 각 인덱스마다 격자를 표시하는데 사용한다. 모든 함수들은 위치값과 문자 색상등을 지정할 수 있으며, 자세한 내용은 공식 홈페이지에서 확인하기 바란다.

1. 빈도 분석 - KoNLPy 설치하기(문장 형태소 분석)

Sun, 21 Jan 2018 10:01:00 +0000

1. 빈도 분석: 문장 형태소 분석 - KoNLPy

자연어 처리는 우리가 사용하는 문장을 기계적으로 분석하여 컴퓨터가 이해할 수 있는 형태로 만드는 기술이라고 할 수 있다. 자연어 분석은 요즘 경쟁적으로 개발하는 인공지능(AI) 기술에서 고전적으로 요구되는 기술로써 수집한 데이터를 효율적으로 가공하기 위해서는 필수적이라 할 수 있다.

형태소 분석이란 어떤 대상 어절의 모든 가능한 분석 결과를 출력하는 것을 의미한다. 정보를 효율적으로 검색하기 위해서는 문장중 주요 단어(색인어)를 추출할 수 있어야 하며, 이를 위해서 문장중에 ‘명사’에 해당하는 부분만을 추출하여야 하는데 한글은 조사와 복합명사(명사 두개가 합쳐져 만들어진 명사)등을 분리하기가 상대적으로 영어권 문장에 비하여 힘들다.

복합 명사의 예	“논밭” : ‘논’ + ‘밭’ 또는 “논밭” “눈물” : ‘눈’ + ‘물’ 또는 “눈물”
조사의 예	“나는” : ‘나’(대명사) + ‘는’(조사)
어미의 예	“나는” : ‘나’(동사: 날다) + ‘는’(관형형 어미)

위의 예에서 보듯이 다양한 형태의 활용과 의미 분석이 필요하므로 자연어 처리와 형태소 분석은 단순한 문제가 아니다. 국내에서는 이러한 형태소 분석을 효율적으로 하고 명사를 추출하기 위한 ‘코엔엘파이’, ‘은전한닢’ 등 여러 오픈소스 프로젝트가 진행되고 있으며, 본 과정에서는 “코엔엘파이(KoNLPy)”를 이용하여 형태소 분석을 진행하도록 하겠다.

1.1 코엔엘파이(KoNLPy)의 설치 및 활용?

본 절에서는 코엔엘파이를 설치하고 간단한 프로그램을 작성하여 정상적으로 동작하는지 확인하도록 한다. 본 과정은 윈도우를 기반으로 하기 때문에 기타 다른 OS의 경우에는 참고 문헌( http://konlpy-ko.readthedocs.io/ko/v0.4.3/install )을 확인하여 진행하기 바란다.

코엔엘 파이를 설치하기 위해서는 다음과 같은 절차가 필요하다. 만약 자바가 설치되어 있는 경우에는 1)과 2)의 과정은 수행하지 않아도 된다.

1) JAVA 1.7 이상의 설치
오라클(Oracle) 사이트(http://www.oracle.com/technetwork/java/javase/downloads/index.html)로 이동하여 해당 OS에 맞는 JDK를 설치한다.

2) JAVA_HOME Path 설정
• JDK가 정상적으로 동작하기 위하여 JAVA_HOME 경로(Path)를 설정한다. 탐색기의 “내 컴퓨터”를 선택한 후 오른쪽 마우스를 눌러 “속성”을 선택한다.
• [고급 시스템 설정]을 선택한 후 [고급] 탭을 누르고 [환경변수]를 선택한다.
• [시스템 변수]영역의 [새로 만들기]를 선택한 후 변수 이름이 “JAVA_HOME”을 기입하고, 변수값 부분에 JDK가 설치되어있는 경로를 입력한다.

3) JPype1 (>=0.5.7) 설치
‘코엔엘파이’의 경우 JAVA로 작성된 모듈을 로드하여야 하기 때문에 JPype1 0.5.7 이상이 설치되어야 한다.

[파이썬이 설치된 경로]\\pip install jpype1

만약 정상적으로 설치가 안되는 경우에는 (http://www.lfd.uci.edu/~gohlke/pythonlibs/#jpype)로 이동하여 시스템에 맞는 .whl(윈도우 wheel 파일)을 다운로드 받아 설치하기 바란다.

4) KoNLPy 설치 파이썬이 설치된 디렉터리로 이동하여 [표 1] 과 같이 KoNLPy를 설치하고, 테스트해 보자(필자는 파이썬이 설치된 경로가 ‘D:\Program Files\Python’이다).

D:\Program Files\Python>pip install JPype1
Collecting JPype1
  Using cached JPype1-0.6.2.tar.gz
Installing collected packages: JPype1
  Running setup.py install for JPype1 ... done
Successfully installed JPype1-0.6.2

D:\Program Files\Python>pip install KoNLPy
Collecting KoNLPy
  Using cached konlpy-0.4.4-py2.py3-none-any.whl
Installing collected packages: KoNLPy
Successfully installed KoNLPy-0.4.4

D:\Program Files\Python>python
Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 25 2016, 22:18:55) [MSC v.1900 64 bit (AM
D64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> from konlpy.tag import Kkma
>>> from konlpy.utils import pprint
>>> kkma = Kkma()
>>> pprint(kkma.nouns(u'명사만을 추출하여 워드클라우드를 그려봅니다'))
['명사', '추출', '워드', '워드클라우드', '클라우드']
>>>

정상적으로 설치가 되었다면 파이썬을 실행하여 Kkma 클래스의 nouns() 함수를 이용하여 문장중 명사만을 추출고 정상적으로 동작하는지 확인한다.

5) 설치가 안될 경우
설치중 오류가 발생하거나 정상적으로 동작을 하지 않는 경우에는 다음을 살펴 보도록 한다

• JAVA_HOME의 경로 확인: 자신이 설치한 JAVA 경로와 일치하는지 확인한다.

D:\Program Files\Python>set java
JAVA_HOME=c:\Program Files\Java\Jre1.8.0_111
D:\Program Files\Python>

• “numpy” 설치: 우리는 PYTHON 크롤링 » 10. 공공 정보 데이터 수집하기에서 “matplotlib”를 설치하면서 “numpy” 패키지를 설치하였다. 만약 설치가 되지 않았다면 “numpy” 패키지를 설치한다.

D:\Program Files\Python>pip list
JPype1 (0.6.2)
konlpy (0.4.4)
matplotlib (2.0.0)
numpy (1.12.0)
pip (9.0.1)
…
D:\Program Files\Python>

• “dll load failed 지정된 모듈을 찾을 수 없습니다” 오류: “matplotlib” 패키지 설치시 언급하였던 Visual Studio 재배포 패키지를 설치하여 주면 해결된다.

11. 웹 페이지 크롤링

Sun, 21 Jan 2018 10:01:00 +0000

11. 일반적인 웹 페이지 크롤링

우리는 앞절에서 다양한 API를 이용하여 서비스 업체에서 제공하는 데이터를 수집하였다. 과거의 고전적인 웹 클롤링은 서비스업체에서 제공해주는 API를 사용하는 것이 아니라 웹 페이지에 직접 방문하여 HTML 파일을 읽어오고 이를 분석하여 필요한 데이터를 추출, 정보로 가공하였다. 그러나 웹 서비스되는 컨텐츠들은 해당 서비스업체의 자산으로 분류될 수 있으며, 이를 동의없이 가가져오는 것 심각한 저작권 문제를 가질 수 있다.

일반적인 저작권법에 의하면 단순 링크(사이트 대표 주소의 링크) 및 직접 링크(특정 게시물을 링크)하는 것에 대해서는 허용하고 있으나, 저작물의 일부를 홈페이지에 프레임을 이용하여 표시(프레임 링크)하거나 저작물 전체를 홈페이지에 표시(임베드 링크)하는 것에 대해서는 위반으로 판단하고 있다. 또한 웹 사이트에 로봇(크롤러)이 접근하는 것을 방지하기 위한 규약을 웹 페이지 루트(root)에 ‘robots.txt’ 파일로 지정할 수 있다. 다음은 ‘robots.txt’ 파일을 작성하는 예이다.

Site	Status
모두 허용	User-agent:* Allow: /
모두 차단	User-agent:* Disallow: /
다른 예	User-agent: googlebot #googlebot만 허용 Disallow: /bbs/ # /bbs 데렉터리 접근 차단

저작권에 대한 부분은 각자의 몫으로 남겨두고 이번장에서는 일반적인 웹 서비스의 데이터를 처리하기 위하여 이상한 나라의 엘리스에 나오는 ‘Beautiful Soup, so rich and green,…’에 나오는 맛있는(?) 스프와 이름이 같은 ‘BeautifulSoup’을 이용하는 방법에 대해 알아보고, 국내 프렌차이즈 닭집 가맹점 주소를 가지고 오는 방법을 알아보도록 하겠다.

11.1 이상한 나라의 엘리스 맛있는 스프: BeautifulSoup

‘BeautifulSoup’ 패키지는 파이썬에서 제공해주는 HTML 파싱(parsing) 라이브러리로써 웹의 태그나 클래스의 값을 손쉽게 가져올 수 있도록 지원한다. Beautiful Soup 3.x 버전까지는 파이썬 2.x 버전만을 지원하였으나 새로운 bs4 파서를 통하여 파이썬 3.x 버전을 지원하게 되었다. ‘BeautifulSoup’의 기능적인 특징은 다음과 같다.

1) 단순한 몇 개의 메소드를 가지고 웹페이지의 내용을 검색하거나 필요한 태그, 클래스등에서 데이터를 추출할 수 있다

2) HTML 문서 뿐만이 아니라 XML 형식의 데이터도 읽고, 분석할 수 있다

3) 다국어 지원을 위하여 Encoding 형식을 지정할 수 있다(이 부분은 한국어 홈페이지의 데이터를 분석하는데 상당히 중요하다. 요즘은 기본적으로 ‘UTF-8’ 형식을 사용하지만, ‘CP949’ 형식의 홈페이지도 상당수 존재한다)

설치는 단순하게 pip를 이용하여 이루어진다. 우리는 파이썬 3.x 버전을 사용하고 있으므로 ‘beautifulsoup4’를 설치한다.

[파이썬이 설치된 경로]\\pip install beautifulsoup4

이제 예제를 좀더 간단하게 하기 위하여 연습용 html을 만들고 각 태그의 값을 조회하기 위하여파이썬 쉘을 수행하고 다음의 예를 실행하여 보자

1) Tag 및 Tag Name 조회

>>> from bs4 import BeautifulSoup
>>> html = '<td class="title"><div class="tit3"><a href="/movie/bi/mi/basic.nhn?code=136872" title="미녀와 야수">미녀와 야수</a></div></td>'
>>> soup = BeatifulSoup(html, 'html.parser')
>>> soup
<td class="title"><div class="tit3"><a href="/movie/bi/mi/basic.nhn?code=136872" title="미녀와 야수">미녀와 야수</a></div></td>
>>> tag = soup.td
>>> tag
<td class="title"><div class="tit3"><a href="/movie/bi/mi/basic.nhn?code=136872" title="미녀와 야수">미녀와 야수</a></div></td>
>>> tag = soup.div
>>> tag
<div class="tit3"><a href="/movie/bi/mi/basic.nhn?code=136872" title="미녀와 야수">미녀와 야수</a></div>
>>> tag = soup.a
>>> tag
<a href="/movie/bi/mi/basic.nhn?code=136872" title="미녀와 야수">미녀와 야수</a>
>>> tag.name
'a'

위의 예제에서 손쉽게 태그명을 가지고 해당 데이터를 가지고 올 수 있으며, 해당 데이터는 각 Name을 가지고 있는 것이 확인된다.

2) 속성(Attribute) 값

>>> tag = soup.td
>>> tag['class']
['title']
>>> tag = soup.div
>>> tag['class']
['tit3']
>>> >>> tag.attrs
{'class': ['tit3']}

각 태그의 속성값은 ‘class’값을 가지고 있으며, 속성값을 이용하여 데이터를 조회할 수 있다. 또한 내가 지금 가지고 있는 데이터의 속성(attr)이 어떤 것인지 확인할 수 있다.

3) 속성 (Attribute) 조회
‘BeautifulSoup’은 태그 속성값을 이용하여 데이터 조회를 할 수 있다.

>>> tag = soup.find('td', attrs={'class':'title'})
>>> tag
<td class="title"><div class="tit3"><a href="/movie/bi/mi/basic.nhn?code=136872" title="미녀와 야수">미녀와 야수</a></div></td>
>>> tag = soup.find('div', attrs={'class':'tit3'})
>>> tag
<div class="tit3"><a href="/movie/bi/mi/basic.nhn?code=136872" title="미녀와 야수">미녀와 야수</a></div>

이 부분은 우리가 목적으로 하는 HTML을 파싱하는데 상당히 중요한 부분으로 만약 모든 <td> 태그 내의 데이터를 가지고 오고 원하는 데이터만을 찾기는 상당히 어렵다. 잘 만든 홈페이지라면 각 태그의 ‘class’ 명등을 가지고 있고, 이를 이용하여 데이터를 편하게 조회할 수 있다. 복수개의 데이터를 조회하기 위해서는 ‘find()’ 대신 ‘findAll()’을 사용하면 된다.

이제 본격적으로 HTML에서 데이터를 가지고 오기 위하여 다음과 같이 코드를 작성해 본다.

>>> import urllib.request
>>> from bs4 import BeautifulSoup
>>> html = urllib.request.urlopen('http://movie.naver.com/movie/sdb/rank/rmovie.nhn')
>>> soup = BeautifulSoup(html, 'html.parser')
>>> print(soup.prettify())
<!DOCTYPE html>
<html>
 <head>
  <meta content="text/html; charset=utf-8" http-equiv="Content-Type">
   <meta content="IE=edge" http-equiv="X-UA-Compatible">
    <meta content="http://imgmovie.naver.com/today/naverme/naverme_profile.jpg" property="me2:image"/>
    <meta content="네이버영화 " property="me2:post_tag"/>
    <meta content="네이버영화" property="me2:category1"/>
    ....(이하 중략)
<!-- //Footer -->
  </div>
 </body>
</html>

본 예제에서는 네이버 영화의 랭킹(‘http://movie.naver.com/movie/sdb/rank/rmovie.nhn’) 사이트를 urllib.urlopen() 메소드를 이용하여 읽어온 후 ‘BeautifulSoup’ 객체를 ‘html.parser’ 기본 객체를 이용하여 생성하였다. ‘soup.prettify()’ 메소드를 이용하면 ‘BeautifulSoup’ 객체를 들여쓰기(indent)한 상태로 확인할 수 있다. 실제 호출한 홈페이지는 [그림 1]과 같은 형태를 가진다.

[그림 1] 네이버 영화 랭킹 페이지

우리가 자료로 가지고 오고 싶은 데이터는 영화제목이므로 HTML이 어떻게 구성되어있는지 확인하기 위하여 브라우저의 소스보기 기능을 이용하면 [그림 2]와 같이 구성되어 있는 것을 확인할 수 있다.

[그림 2] 네이버 영화 랭킹 HTML 구조

HTML의 형식을 확인해 보니 영화제목은 ‘<td>’쌍 안에 ‘<div>쌍을 가지고 있으며, 그 내부에 ‘a’ 태그로 구성되어 있음이 확인된다(실제 앞에서 사용한 예제다). 먼저 ‘<div>’ 태그의 속성이 class=’tit3’인 값들을 페이지에서 모두 찾아보자.

>>> import urllib.request
>>> from bs4 import BeautifulSoup
>>> html = urllib.request.urlopen('http://movie.naver.com/movie/sdb/rank/rmovie.nhn')
>>> soup = BeautifulSoup(html, 'html.parser')
tags = soup.findAll('div', attrs={'class':'tit3'})
>>> tags
[<div class="tit3">
<a href="/movie/bi/mi/basic.nhn?code=136872" title="미녀와 야수">미녀와 야수</a>
</div>, <div class="tit3">
<a href="/movie/bi/mi/basic.nhn?code=146517" title="프리즌">프리즌</a>
</div>, <div class="tit3">
<a href="/movie/bi/mi/basic.nhn?code=152161" title="비정규직 특수요원">비정규직 특수요원</a>
</div>, <div class="tit3">
<a href="/movie/bi/mi/basic.nhn?code=117787" title="로건">로건</a>
… (이하 중략)
</div>, <div class="tit3">
<a href="/movie/bi/mi/basic.nhn?code=17796" title="일 포스티노">일 포스티노</a>
</div>]
>>>

실제 HTML내의 데이터와 확인을 해보면 총 50개의 랭크 데이터를 가지고 온 것을 확인할 수 있다. 이제 우리가 원하는 것은 제목만을 추출하는 것이므로 다음과 같이 작성한다.

>>> for tag in tags:
	print(tag.a)

<a href="/movie/bi/mi/basic.nhn?code=136872" title="미녀와 야수">미녀와 야수</a>
<a href="/movie/bi/mi/basic.nhn?code=146517" title="프리즌">프리즌</a>
… (이하 중략)
<a href="/movie/bi/mi/basic.nhn?code=143499" title="콜로설">콜로설</a>
<a href="/movie/bi/mi/basic.nhn?code=17796" title="일 포스티노">일 포스티노</a>

>> for tag in tags:
	print(tag.a.text)

미녀와 야수
프리즌
… (이하 중략)
콜로설
일 포스티노

>>> for tag in tags:
	tag.a['title']
'미녀와 야수'
'프리즌'
… (이하 중략)
'콜로설'
'일 포스티노'

우리는 수집한 ‘<div>’ 태그 내에서 ‘a’ 태그에 대한 값을 확인하였고, ‘a’ 태그 내에 있는 텍스트를 ‘.text’ 속성을 이용하여 손쉽게 네이버 영화 랭킹 50개의 제목을 추출하였다. 또한 ‘a’ 태그 내의 ‘title’ 속성에도 제목을 포함하고 있으므로 tag.a[‘title’] 과 같은 방식으로도 제목의 추출이 가능하다.

10. 공공 정보 데이터 수집하기

Sun, 21 Jan 2018 09:01:00 +0000

10. 공공 정보 데이터 수집하기

우리는 정부3.0 공공 데이터 포털 API 사용하기에서 공공 데이터 포털 API를 사용하기 위한 가입 및 서비스 요청 방법을 알아보았다. 공공 데이터 포털 개발 계정 신청을 통해 발급되는 일반 인증키는 API 요청 신청을 한 모든 API에 대하여 동일한 UTF-8 형식의 키값을 사용한다. 개발자의 입장에서는 편리할 수 있지만, 보안 측면에서는 개별 서비스마다 별도의 API 키 값을 부여하는 것이 어떨까 생각만(!) 해본다.

10.1 전국 유료 관광지 입장객 정보

관광 자원 통계 서비스 중 유료관광지방문객수조회 기능은 기간별 외국인방문객수와 내국인방문객수, 관광지의 주소 정보, 지역코드 정보를 제공한다. 지역별 관광지 입장객 수를 분석하기 위하여 다음의 코드를 작성한다.

import os
import sys
import urllib.request
import datetime
import time
import json
from config import *
import math

def get_request_url(url):
    
    req = urllib.request.Request(url)
    
    try: 
        response = urllib.request.urlopen(req)
        if response.getcode() == 200:
            print ("[%s] Url Request Success" % datetime.datetime.now())
            return response.read().decode('utf-8')
    except Exception as e:
        print(e)
        print("[%s] Error for URL : %s" % (datetime.datetime.now(), url))
        return None

#[CODE 1]
def getTourPointVisitor(yyyymm, sido, gungu, nPagenum, nItems):
    
    end_point = "http://openapi.tour.go.kr/openapi/service/TourismResourceStatsService/getPchrgTrrsrtVisitorList"
    
    parameters = "?_type=json&serviceKey=" + access_key
    parameters += "&YM=" + yyyymm
    parameters += "&SIDO=" + urllib.parse.quote(sido)
    parameters += "&GUNGU=" + urllib.parse.quote(gungu)
    parameters += "&RES_NM=&pageNo=" + str(nPagenum)
    parameters += "&numOfRows=" + str(nItems)

    url = end_point + parameters
    
    retData = get_request_url(url)
    
    if (retData == None):
        return None
    else:
        return json.loads(retData)

#[CODE 2]
def getTourPointData(item, yyyymm, jsonResult):
    
    addrCd = 0 if 'addrCd' not in item.keys() else item['addrCd']
    gungu = '' if 'gungu' not in item.keys() else item['gungu']
    sido = '' if 'sido' not in item.keys() else item['sido']
    resNm = '' if 'resNm' not in item.keys() else item['resNm']
    rnum = 0 if 'rnum' not in item.keys() else item['rnum']
    ForNum = 0 if 'csForCnt' not in item.keys() else item['csForCnt']
    NatNum = 0 if 'csNatCnt' not in item.keys() else item['csNatCnt']
    
    jsonResult.append({'yyyymm': yyyymm, 'addrCd': addrCd,
                    'gungu': gungu, 'sido': sido, 'resNm': resNm, 
                    'rnum': rnum, 'ForNum': ForNum, 'NatNum': NatNum})
    return    

def main():

    jsonResult = []

    sido = '서울특별시'
    gungu = ''
    nPagenum = 1
    nTotal = 0
    nItems = 100
    
    nStartYear = 2011
    nEndYear = 2017

    for year in range(nStartYear, nEndYear):
        for month in range(1, 13):

            yyyymm = "{0}{1:0>2}".format(str(year), str(month))

            nPagenum = 1

            #[CODE 3]
            while True:
                jsonData = getTourPointVisitor(yyyymm, sido, gungu, nPagenum, nItems)
    
                if (jsonData['response']['header']['resultMsg'] == 'OK'):
                    nTotal = jsonData['response']['body']['totalCount']
            
                    if nTotal == 0:
                        break

                    for item in jsonData['response']['body']['items']['item']:
                        getTourPointData(item, yyyymm, jsonResult)
            
                    nPage = math.ceil(nTotal / 100)
                    if (nPagenum == nPage):
                        break

                    nPagenum += 1
                
                else:
                    break
    
    with open('%s_관광지입장정보_%d_%d.json' % (sido, nStartYear, nEndYear-1), 'w', encoding='utf8') as outfile:
        retJson = json.dumps(jsonResult,
                        indent=4, sort_keys=True,
                        ensure_ascii=False)
        outfile.write(retJson)
        
    print ('%s_관광지입장정보_%d_%d.json SAVED' % (sido, nStartYear, nEndYear-1))            
    
if __name__ == '__main__':
    main()

코드를 수행하여 얻은 결과를 바탕으로 2011년 1월부터 2016년 9월까지 수집된 경복궁의 입장객 정보를 확인해보면 [그림 1]과 같다. [그림 1]은 수집된 데이터를 액셀을 이용하여 그래프 작업을 한 것이며 다음절에서는 수집된 데이터를 가지고 직접 파이썬을 이용하여 그래프를 그려 보도록 하겠다.

[그림 1] 경복궁 내•외국인 입장객 현황

이제 코드를 살펴 보기로 하자. 위 코드는 유료 관광지 정보 및 입장객수를 조회하기 위한 코드이다. 실제 데이터를 조회하면 분기별로 업데이트 되고 있는 것으로 파악되며, 공공정보가 제공하는 서울특별시 입장 정보 데이터의 수량이 많은 편은 아니여서 조금 아쉬운 상황이다.

#[CODE 1]
def getTourPointVisitor(yyyymm, sido, gungu, nPagenum, nItems):
    
    end_point = "http://openapi.tour.go.kr/openapi/service/TourismResourceStatsService/getPchrgTrrsrtVisitorList"
    
    parameters = "?_type=json&serviceKey=" + access_key
    parameters += "&YM=" + yyyymm
    parameters += "&SIDO=" + urllib.parse.quote(sido)
    parameters += "&GUNGU=" + urllib.parse.quote(gungu)
    parameters += "&RES_NM=&pageNo=" + str(nPagenum)
    parameters += "&numOfRows=" + str(nItems)

    url = end_point + parameters
    
    retData = get_request_url(url)
    
    if (retData == None):
        return None
    else:
        return json.loads(retData)

유료 관광지 방문객수 조회를 위한 End Point는 “http://openapi.tour.go.kr/openapi/service/TourismResourceStatsService/getPchrgTrrsrtVisitorList” 이며 전달하는 요청 변수는 다음과 같다.

항목	파라미터명	형식	설명
년월	YM	YYYYMM(ex: 201703)	검색 연월
시도	SIDO	STRING (ex: 서울특별시)	시도명
군구	GUNGU	STRING (ex: 중구)	시군구
관광지	RES_NM	STRING (ex: 경복궁)	관광지명
페이지 번호	pageNo	INT (ex: 1)	페이지 번호
조회 레코드 수	numOfRow	INT(ex: 100)	조회 레코드 최대수(Max: 100)

전달하는 변수는 UTF-8 형식으로 인코딩 되어 있어야 한다. 또한 해당 검색 조건에 부합하는 데이터가 ‘numOfRow’의 수보다 많은 경우에는 페이지로 분리된다. 이 경우 동일한 검색 조건에 pageNO 값을 변경하여 해당 페이지의 값을 가지고 올 수 있다. 페이징 처리와 수신하는 데이터의 형식을 알아보기 위해 다음 코드를 알아보자.

#[CODE 3]
            while True:
                jsonData = getTourPointVisitor(yyyymm, sido, gungu, nPagenum, nItems)
    
                if (jsonData['response']['header']['resultMsg'] == 'OK'):
                    nTotal = jsonData['response']['body']['totalCount']
            
                    if nTotal == 0:
                        break

                    for item in jsonData['response']['body']['items']['item']:
                        getTourPointData(item, yyyymm, jsonResult)
            
                    nPage = math.ceil(nTotal / 100)
                    if (nPagenum == nPage):
                        break

                    nPagenum += 1
                
                else:
                    break

[CODE 3]에서는 getTourPointVisitor() 함수를 이용하여 JSON 형식의 데이터를 먼저 가지고 온다. 다음은 수신한 JSON 데이터의 예이다.

{
    "response": {
        "body": {
            "items": {
                "item": [
                    {
                        "addrCd": 1111,
                        "csForCnt": 40224,
                        "csNatCnt": 141183,
                        "gungu": "종로구",
                        "resNm": "경복궁",
                        "rnum": 3,
                        "sido": "서울특별시",
                        "ym": 201101
                    },
                   …
                ]
            },
            "numOfRows": 100,
            "pageNo": 1,
            "totalCount": 16
        },
        "header": {
            "resultCode": "0000",
            "resultMsg": "OK"
        }
    }
}

정상적으로 데이터를 수신한 경우에는 [“response”][“header”][“resultMsg”]에 ‘OK’값이 회신되며, 요청한 전체 item의 수가 [“response”][“body”][‘totalCount’]에 저장되어 있다 데이터에서 보면 알 수 있듯이 현재 조회된 item의 수는 16개여서 조회 요청한 100개의 Row보다 작다. 그러나 “경기도”로 “SIDO”값을 지정하게 되는 경우에는 160여개의 데이터가 조회되므로 page 처리를 해 주어야 한다.

[CODE 3]에서는 nTotal의 값을 의 총수를 numOfRow(=100)으로 나눈 후 올림하여 총 페이지수를 구하고, 만약 페이지 수가 2 이상인 경우에는 While문 안에서 다시 데이터를 요청하게 처리한다.

[CODE 2]는 수신한 JSON 형식의 데이터 중 개별 item을 전달받아 해당하는 값을 jsonResult에 저장한다. 각 name별 데이터는 다음의 표와 같은 의미를 가진다. 자세한 부분은 공공 데이터 포털을 참조하기 바란다.

항목	Name	형식	설명
지역코드	addrCd	INT	지역코드(우편번호와 일치하지 않음)
외국인 방문객수	csForCnt	INT
내국인 방문객수	csNatCnt	INT
관광지 코드	rnum	INT	관광지에 고유 부여된 코드 값

10.2 파이썬 그래프 모듈: matplotlib

파이썬의 장점을 들자면 파이썬은 여러 모듈이 그래프 기능을 지원하는데 가장 일반적으로 사용하는 모듈은 ‘matplotlib’ 이다. 일반적으로 “pip install matplotlib” 을 이용하여 설치가 가능한데 몇 가지 제약 사항이 있다.

‘matplotlib’는 파이썬 2.7 또는 3.4 이상을 사용한다면 정상적으로 설치가 안된다고 matplotlib의 설치 가이드(http://matplotlib.org/users/installing.html)에 다음과 같이 설명하고 있다.

2.7 또는 3.4 이상의 경우에는 Microsoft Visual C++ 2008(64 bit or 32 bit: 파이썬 2.7) 또는 Microsoft Visual C++ 2010 (64 bit or 32 bit : 파이썬 3.4) 배포 패키지(redistributable package) 필요합니다

먼저 [제어판]의 [프로그램 및 기능]으로 이동하여 “Microsoft Visual C++ Redistibutable…” 패키지가 설치되어 있는지 확인한다.

[그림 1] Visual C++ 재 배포 파일 설치 여부 확인

필자의 경우에는 Visual Studio를 이용하여 프로그래밍을 하기 때문에 여러 버전의 재배포 패키지가 설치되어 있다. 만약 검색이 되지 않는 경우에는 [그림 2]와 같이 마이크로소프트 다운로드 사이트(https://www.microsoft.com/ko-KR/download/detail.aspx?id=53587)로 이동하여 다운로드 받은 후 설치한다(다운로드 경로의 경우 수시로 바뀌기 때문에 해당 URL이 접근이 불가한 경우 검색을 이용하여 찾기 바란다)

[그림 2] Visual C++ 재배포 가능 패키지 다운로드

재배포 패키지가 설치되어 있는 경우 도스창(Command Prompot)을 뛰운 후 파이썬이 설치되어 있는 경로로 이동한 후

c:\\[파이썬 설치 경로]\\pip install matplotlib

를 실행하면 [그림 3]과 같이 설치 과정이 진행된다.

[그림 3] “matplotlib” 설치

정상적으로 설치가 되면 ‘matplotlib’에서 사용하는 ‘numpy’, ‘pyparsing’ 및 ‘cycler’ 패키지가 함께 설치된다. 정상적으로 모듈이 설치되었는지 확인하기 위하여 python을 실행한 후 아래와 같이 코드를 작성한다.

>>> from matplotlib import pyplot
>>> pyplot.plot([1,2,3,4],[10,30,20,40])
>>> pyplot.show()

만약 모듈이 정상적으로 설치되었다면 ‘matplotlib’가 [그림 4]와 같이 그래프 폼을 화면에 나타낸다.

[그림 4] “matplotlib”를 이용한 그래프 그리기

필자가 초기에 ‘matplotlib’를 설치했을 경우에는 ‘import’를 하면 프로그램 실행시 ‘font_manager.py’ 쪽에서 에러를 발생하면서 연관 모듈을 프로그램상에 올리지 못한다는 에러가 나오는 현상이 발견되었다.

File "C:\Anaconda3\lib\site-packages\matplotlib\font_manager.py", line 1412, in <module>
    fontManager = pickle_load(_fmcache)

국내 사이트에서 관련 오류에 대한 사항을 찾아도 해결책이 나오지 않다가 스택오버플로우(http://stackoverflow.com/questions/34004063/error-on-import-matplotlib-pyplot-on-anaconda3-for-windows-10-home-64-bit-pc)에서 관련 문제점 및 해결 방법을 발견하였다. 문제의 원인은 윈도우 폰트 디렉터리에서 폰트 정보를 가지고 오면서 발생하는 것이였고, 이를 해결하기 위해서는 “[파이썬 설치 경로]\Lib\site-packages\matplotlib” 아래에 존재하는 “font_manager.py” 파일의

def win32InstalledFonts(directory=None, fontext='ttf'):

함수의 일부분을 수정하면 해결된다.

key, direc, any = winreg.EnumValue( local, j)
if not is_string_like(direc):
    continue
if not os.path.dirname(direc):
    direc = os.path.join(directory, direc)
direc = direc.split(‘\0’, 1)[0] #파이썬 경로 문제 해결
direc = os.path.abspath(direc).lower()

한동안을 이 부분을 수정하여 사용하였는데 ‘matplotlib 2.0.0’버전으로 업데이트를 한 후 이 부분을 수정하지 않고 사용하여도 문제가 없이 동작하였다. 어느 부분에서 이 부분을 해결하였는지는 귀챠니즘이 발동하여 찾아보지 않았으니 독자분중에 문제가 발생하였다며, 상기 사항을 확인하여 보기 바란다.

10.3 출입국 관광 통계 서비스

출입국 관광 통계 서비스를 이용하면 기간, 방문객 국가의 검색 조건에 따라 출입국자수를 조회 서비스를 제공한다. 국가별 입국자수를 수집하기 위하여 다음의 코드를 작성한다.

import os
import sys
import urllib.request
import datetime
import time
import json
from config import *

import matplotlib.pyplot as plt
import matplotlib
from matplotlib import font_manager, rc

def get_request_url(url):
    
    req = urllib.request.Request(url)
    
    try: 
        response = urllib.request.urlopen(req)
        if response.getcode() == 200:
            print ("[%s] Url Request Success" % datetime.datetime.now())
            return response.read().decode('utf-8')
    except Exception as e:
        print(e)
        print("[%s] Error for URL : %s" % (datetime.datetime.now(), url))
        return None

#[CODE 1]
def getNatVisitor(yyyymm, nat_cd, ed_cd):
    
    end_point = "http://openapi.tour.go.kr/openapi/service/EdrcntTourismStatsService/getEdrcntTourismStatsList"
    
    parameters = "?_type=json&serviceKey=" + access_key
    parameters += "&YM=" + yyyymm
    parameters += "&NAT_CD=" + nat_cd
    parameters += "&ED_CD=" + ed_cd
    
    url = end_point + parameters
    
    retData = get_request_url(url)
    
    if (retData == None):
        return None
    else:
        return json.loads(retData)

def main():

    jsonResult = []

    #중국: 112 / 일본: 130 / 미국: 275
    national_code = "112"
    ed_cd = "E"

    nStartYear = 2011
    nEndYear = 2017

    for year in range(nStartYear, nEndYear):
        for month in range(1, 13):

            yyyymm = "{0}{1:0>2}".format(str(year), str(month))

            jsonData = getNatVisitor(yyyymm, national_code, ed_cd)
    
            if (jsonData['response']['header']['resultMsg'] == 'OK'):
                krName = jsonData['response']['body']['items']['item']["natKorNm"]
                krName = krName.replace(' ', '')
                iTotalVisit = jsonData['response']['body']['items']['item']["num"]
                print('%s_%s : %s' %(krName, yyyymm, iTotalVisit))
                jsonResult.append({'nat_name': krName, 'nat_cd': national_code,
                                 'yyyymm': yyyymm, 'visit_cnt': iTotalVisit})

    cnVisit = []
    VisitYM = []
    index = []
    i = 0
    for item in jsonResult:
        index.append(i)
        cnVisit.append(item['visit_cnt'])
        VisitYM.append(item['yyyymm'])
        i = i + 1
            
    with open('%s(%s)_해외방문객정보_%d_%d.json' % (krName, national_code, nStartYear, nEndYear-1), 'w', encoding='utf8') as outfile:
        retJson = json.dumps(jsonResult,
                        indent=4, sort_keys=True,
                        ensure_ascii=False)
        outfile.write(retJson)
    

    #[CODE 2]
    font_location = "c:/Windows/fonts/malgun.ttf"
    font_name = font_manager.FontProperties(fname=font_location).get_name()
    matplotlib.rc('font', family=font_name)

    plt.xticks(index, VisitYM)
    plt.plot(index, cnVisit)
    plt.xlabel('방문월')
    plt.ylabel('방문객수')
    plt.grid(True)
    plt.show()           
    
if __name__ == '__main__':
    main()

코드를 수행하면 특정 기간 동안 특정 국가의 입국 인원수를 가지고 온 후 그래프를 생성해 낸다. [그림 5]는 2011.01부터 2016.12월까지 중국인 입국자수를 그래프로 표시한 것이다.

[그림 5] 국내 중국 입국자수 추이 (2011.01 ~ 2016.12)

이제 코드를 살펴 보도록 하자.

#[CODE 1]
def getNatVisitor(yyyymm, nat_cd, ed_cd):
    
    end_point = "http://openapi.tour.go.kr/openapi/service/EdrcntTourismStatsService/getEdrcntTourismStatsList"
    
    parameters = "?_type=json&serviceKey=" + access_key
    parameters += "&YM=" + yyyymm
    parameters += "&NAT_CD=" + nat_cd
    parameters += "&ED_CD=" + ed_cd
    
    url = end_point + parameters
    
    retData = get_request_url(url)
    
    if (retData == None):
        return None
    else:
        return json.loads(retData)

출입국 데이터 조회를 위한 End Point는 “http://openapi.tour.go.kr/openapi/service/EdrcntTourismStatsService/getEdrcntTourismStatsList” 이며 전달하는 요청 변수는 다음의 표와 같다.

항목	파라미터명	형식	설명
년월	YM	YYYYMM(ex: 201703)	검색 연월
국가코드	NAT_CD	DDD (ex: 100)	세자리 국가 코드
출/입국	ED_CD	‘D’ or ‘E’	D: 국민 해외 관광객 E: 방한 외래 관광객

전달하는 변수는 UTF-8 형식으로 인코딩 되어 있어야 하며 다음 표는 국가 코드중 일부이다. 자세한 사항은 공공데이터 포털 출입국관광통계서비스 활용가이드를 참조하기 바란다.

국가명	국가 코드
한국	100
중국	112
일본	130
미국	275
영국	316

정상적으로 데이터를 수신한 경우에는 [“response”][“header”][“resultMsg”]에 ‘OK’값이 회신되며, 수신한 JSON 형식의 데이터 중 각 name별 데이터는 다음 표와 같은 의미를 가지며 수신한 JSON 형식의 예는 다음과 같다.

항목	Name	형식	설명
국가명	natKorNm	STRING	국가 코드에 해당하는 한글 국가명
입출국수	csForCnt	INT

{
    "response": {
        "body": {
            "items": {
                "item": {
                    "ed": "방한외래관광객",
                    "edCd": "E",
                    "natCd": 112,
                    "natKorNm": "중  국",
                    "num": 91252,
                    "rnum": 1,
                    "ym": 201101
                }
            },
            "numOfRows": 10,
            "pageNo": 1,
            "totalCount": 1
        },
        "header": {
            "resultCode": "0000",
            "resultMsg": "OK"
        }
    }
}

#[CODE 2]
    font_location = "c:/Windows/fonts/malgun.ttf"
    font_name = font_manager.FontProperties(fname=font_location).get_name()
    matplotlib.rc('font', family=font_name)

    plt.xticks(index, VisitYM)
    plt.plot(index, cnVisit)
    plt.xlabel('방문월')
    plt.ylabel('방문객수')
    plt.grid(True)
    plt.show()

[CODE 2]는 ‘matplotlib’를 이용하여 그래프를 그리는 코드를 포함하고 있다. 이 책을 읽는 독자들은 아마 한번 정도씩은 문자열 처리를 하면서 ‘UTF-8’과 ‘CP949’ 때문에 고생을 한적이 있을 것이다. ‘matplotlib’에서도 마찬가지로 그래프를 그리면서 한글을 처리하고자 하면 깨지는 현상이 발생한다. 이는 모듈이 기본으로 “sans-serif” 폰트를 사용하기 떄문이다. 이를 해결하기 위해서 ‘matplotlib’의 ‘font_manager’와 ‘resource’에 윈도우에서 사용하는 한글 폰트를 지정하여 주면 해결된다(만약 리눅스나 Mac을 사용하는 경우에는 시스템 해당 경로를 지정해 주면 된다).

‘matplotlib’에 관하여는 PYTHON 시각화 » 2. 그래프를 그리자 - matplotlib에서 좀더 자세히 다루도록 하겠다.

9. 네이버 지도 API(주소, 좌표변환) 활용

Sun, 21 Jan 2018 08:01:00 +0000

9. 네이버 지도 API(주소, 좌표변환) 활용

지도 API는 네이버에서 활용도를 극대화 하기 위하여 오픈 소스로 비중 있게 공개하고 있는 부분이다. 자바 스크립트등을 이용하면 네이버 지도 서비스를 그대로 사용할 수 있고, 위성 지도, 파노라마, 교통 상화, 레이어 지도 등 다양한 서비스를 활용할 수 있어 지도와 관련된 어플리케이션 구성에 편의성을 제공해준다. 이번 절에서는 우리가 수신한 데이터를 지오(Geo)데이터(위경도 데이터)와 활용하기 위하여 주소, 좌표변환 서비스를 활용해 보도록 하겠다.

먼저 네이버 개발자 페이지로 이동한 후에 상단 메뉴의 [Application] » [내 어플리케이션]으로 이동한 후 개발자 ID를 받은 애플리케이션으로 이동하면 [그림 1]과 같이 상세 정보가 나타난다.

[그림 1] 사용 API의 추가

[그림 1]의 적색 상자로 표시한 부분의 “선택하세요”를 누른 후 [지도]를 선택한 후 하단의 [수정]버튼을 누르면 지도 API가 추가된다. 이제 아래와 같이 코드를 작성한다.

import os
import sys
import urllib.request
import datetime
import time
import json
from config import *

def get_request_url(url):
    
    req = urllib.request.Request(url)
    req.add_header("X-Naver-Client-Id", client_id)
    req.add_header("X-Naver-Client-Secret", client_secret)
    try: 
        response = urllib.request.urlopen(req)
        if response.getcode() == 200:
            print ("[%s] Url Request Success" % datetime.datetime.now())
            return response.read().decode('utf-8')
    except Exception as e:
        print(e)
        print("[%s] Error for URL : %s" % (datetime.datetime.now(), url))
        return None

#[CODE 1]
def getGeoData(address):
    
    base = "https://openapi.naver.com/v1/map/geocode"
    node = ""
    parameters = "?query=%s" % urllib.parse.quote(address)
    url = base + node + parameters
    
    retData = get_request_url(url)
    
    if (retData == None):
        return None
    else:
        return json.loads(retData)

def main():

    jsonResult = getGeoData('서울특별시 종로구 사직로 161 경복궁') 

    if 'result' in jsonResult.keys():
        print('총 검색 결과: ', jsonResult['result']['total'])
        print('검색어: ', jsonResult['result']['userquery'])
        
        for item in jsonResult['result']['items']:
            print('=======================')
            print('주소: ', item['address'])
            print('위도: ', str(item['point']['y']))
            print('경도: ', str(item['point']['x']))

if __name__ == '__main__':
    main()

코드를 실행하면 [그림 2]와 같이 주소를 위도와 경도로 변환한 값을 가지고 올 수 있다.

[그림 2] 주소 » 위경도 좌표 변환 결과

지오 데이터를 얻기 위하여 네이버는 https://openapi.naver.com/v1/map/geocode (json 형식)과 https://openapi.naver.com/v1/map/geocode.xml (xml 형식)의 End Point를 제공한다.

#[CODE 1]
def getGeoData(address):
    
    base = "https://openapi.naver.com/v1/map/geocode"
    node = ""
    parameters = "?query=%s" % urllib.parse.quote(address)
    url = base + node + parameters
    
    #이하 생략

전달하는 매개 변수의 형식은 다음과 같다.

query	검색어 파라미터(UTF-8 인코딩 형식)
encoding	출력 결과 인코딩값 (UTF-8 기본값 / EUC-KR)
coordType	출력 좌표 체계 (latlng(위경도) 기본값 / tm 128(카텍))

전달한 매개변수를 통해 수신하는 JSON 데이터의 형식은 [그림 3]과 같다.

[그림 3] 저장된 JSON 형식의 주소 검색 결과

이번 절에서 우리는 네이버 비로그인 API를 이용하여 뉴스 나 블로그등을 검색하는 방법과 주어진 주소를 가지고 위경도 좌표계로 변경하는 방법을 알아보았다. 주소 » 위경도 변경은 추후 알아보게 될 공공정보 데이터와 연계를 위하여 필요한 부분이므로 미리 숙지하고 가는 것이 좋을 것이다.

8. 네이버 데이터 수집하기

Sun, 21 Jan 2018 07:01:00 +0000

8. 네이버(NAVER) 데이터 수집하기

네이버의 서비스는 ‘네이버 아이디로 로그인’ 이라는 서버 인증을 통해 Access Token을 가지고온후 API를 사용할 수 있는 서비스와, HTTP 헤더에 클라이언트 아이디와 시크릿(secret) 값만을 얹어 전송하면 되는 비로그인 서비스로 나뉜다. 네이버의 뉴스, 블로그 및 까페의 글들은 로그인을 하지 않고 비로그인 방식으로 데이터를 조회하여 가지고 올 수 있도록 설계되어 있어 복잡한 인증 과정을 거치지 않아도 되고 어플리케이션을 만들 경우 Access Token을 얻기 위한 웹 페이지 처리를 하지 않아도 되는 장점이 있다. 그러나 2가지 제약 사항을 가진다.

1) 하루 검색 기사수: API 호출이 25,000회/일로 제한되어 있다. 최대 한번 호출에 100개의 검색을 가지고 올 수 있으므로 250,000건의 데이터를 가지고 올 수 있다.

2) 검색 포인터 문제: 본 책을 쓰고 있는 시점에 가장 검색 이슈가 되는 부분은 대통령 탄핵(언제 책이 출간될지 모르겠지만..) 부분이였다. 실제 네이버에서 “탄핵”이라는 데이터를 검색하면 뉴스에서만 약 43만건의 데이터가 검색되는데 최대 1,000개밖에 API를 이용하여 가지고 올 수 없다(코드에서 자세히 설명하겠다)

물론 상업적으로 네이버의 기사를 크롤링한다면, 계약을 통하여 제약 사항을 해결할 수 있으리라 생각이 들지만 2)번 사항에 대해서는 조금 가혹하다는 생각이 든다.

8.1 검색 API의 활용

뉴스, 블로그 및 까페의 글들을 수집하기 위하여 다음의 코드를 작성한다.(코드를 작성하기 전에 먼저 네이버에 계발자 계정을 가지고 있어야 한다. 개발자 계정을 만드는 방법은 3. 네이버(Naver) API 사용하기 를 참조하기 바란다)

import os
import sys
import urllib.request
import datetime
import time
import json
from config import *

#[CODE 1]
def get_request_url(url):
    
    req = urllib.request.Request(url)
    req.add_header("X-Naver-Client-Id", app_id)
    req.add_header("X-Naver-Client-Secret", "scxKeSJYib")
    try: 
        response = urllib.request.urlopen(req)
        if response.getcode() == 200:
            print ("[%s] Url Request Success" % datetime.datetime.now())
            return response.read().decode('utf-8')
    except Exception as e:
        print(e)
        print("[%s] Error for URL : %s" % (datetime.datetime.now(), url))
        return None

#[CODE 2]
def getNaverSearchResult(sNode, search_text, page_start, display):
    
    base = "https://openapi.naver.com/v1/search"
    node = "/%s.json" % sNode
    parameters = "?query=%s&start=%s&display=%s" % (urllib.parse.quote(search_text), page_start, display)
    url = base + node + parameters
    
    retData = get_request_url(url)
    
    if (retData == None):
        return None
    else:
        return json.loads(retData)

#[CODE 3]
def getPostData(post, jsonResult):
    
    title = post['title']
    description = post['description']
    org_link = post['originallink']
    link = post['link']

    #Tue, 14 Feb 2017 18:46:00 +0900
    pDate = datetime.datetime.strptime(post['pubDate'],  '%a, %d %b %Y %H:%M:%S +0900')
    pDate = pDate.strftime('%Y-%m-%d %H:%M:%S')
    
    jsonResult.append({'title':title, 'description': description,
                    'org_link':org_link, 'link': org_link, 
                    'pDate':pDate})
    return    

def main():

    jsonResult = []

    # 'news', 'blog', 'cafearticle'
    sNode = 'news'
    search_text = '탄핵'
    display_count = 100
    
    jsonSearch = getNaverSearchResult(sNode, search_text, 1, display_count)
    
    while ((jsonSearch != None) and (jsonSearch['display'] != 0)):
        for post in jsonSearch['items']:
            getPostData(post, jsonResult)
        
        nStart = jsonSearch['start'] + jsonSearch['display']
        jsonSearch = getNaverSearchResult(sNode, search_text, nStart, display_count)
    
    with open('%s_naver_%s.json' % (search_text, sNode), 'w', encoding='utf8') as outfile:
        retJson = json.dumps(jsonResult,
                        indent=4, sort_keys=True,
                        ensure_ascii=False)
        outfile.write(retJson)
        
    print ('%s_naver_%s.json SAVED' % (search_text, sNode))

    
if __name__ == '__main__':
    main()

코드를 수행하여 저장한 json 데이터를 열어보면 [그림 1]과 같다.

[그림 1] 뉴스에서 수집된 JSON 데이터

실제 네이버에서 동일한 ‘탄핵’ 이라는 데이터를 검색한 화면을 보면 [그림 2]와 같다.

[그림 2] 네이버 페이지 검색 결과

[그림 1]의 사각형으로 표시된 기사 내용이 [그림 2]의 처음과 두 번째 기사임이 확인된다. 프로그램을 수행하고 잠시 시간이 지난 후여서 약간 뒤로 기사가 밀렸지만, 정확하게 시간순으로 데이터를 반환하는 것을 확인할 수 있다.

이미 페이스북과 트위터를 진행하면서 많은 부분의 코드가 유사하게 사용되고 있어 특정 부분만 살펴 보도록 하자.

#[CODE 1]
def get_request_url(url):
    
    req = urllib.request.Request(url)
    req.add_header("X-Naver-Client-Id", client_id)
    req.add_header("X-Naver-Client-Secret", client_secret)

    #이하 생략

우리는 네이버 개발자 애플리케이션을 등록한 후 Client ID와 Client Secret을 부여 받았다. 비인증 API 방식에서는 단순하게 Request 헤더부분에 ID와 Secret을 함께 전송함으로써 REST API를 사용할 수 있다.

#[CODE 2]
def getNaverSearchResult(sNode, search_text, page_start, display):
    
    base = "https://openapi.naver.com/v1/search"
    node = "/%s.json" % sNode
    parameters = "?query=%s&start=%s&display=%s" % (urllib.parse.quote(search_text), page_start, display)
    url = base + node + parameters
    
    #이하 생략

네이버 검색은 뉴스(news.json), 블로그(blog.json) 및 까페(cafearticle.json)의 요청 End Point 형식만 다르고 전달하는 매개 변수의 형식은 동일하다.

query	검색어 파라미터(UTF-8 인코딩 형식)
start	검색의 시작점(최대값 1,000)
display	1회 검색에 가지고 올 데이터 레코드 수(최대 100)
sort	sim(유사도순: 기본값), date(날짜순)

앞에서 언급하였지만 3월 초 현재 ‘탄핵’이라는 검색어로 조회되는 기사는 43만건이다. 이를 REST API를 이용한다면, 1회 검색할 수 있는 display값이 100 이므로 4,300(430,000 / 100)회의 조회를 해야 한다. 그러나 검색의 시작점 최대가 1,000이므로 우리는 최대 1,099건의 데이터를 가지고 올 수 있다(start=999, display=100으로 전달 하는 경우). 결국 그 이후(시간상은 이전)의 데이터는 검색할 수 있는 방법이 없는 것이다(유료로 계약하면 달라질 것으로 예상한다).

#[CODE 3]
def getPostData(post, jsonResult):
    
    title = post['title']
    description = post['description']
    org_link = post['originallink']
    link = post['link']

    #Tue, 14 Feb 2017 18:46:00 +0900
    pDate = datetime.datetime.strptime(post['pubDate'],  '%a, %d %b %Y %H:%M:%S +0900')
    pDate = pDate.strftime('%Y-%m-%d %H:%M:%S')
    
    jsonResult.append({'title':title, 'description': description,
                    'org_link':org_link, 'link': org_link, 
                    'pDate':pDate})
    return

JSON 형식으로 수신되는 데이터는 [‘items’] 내부에 레코드 형태로 존재하며, 제목(title), 간단한 내용(description), 링크(link)를 공통으로 가지며 검색 영역(뉴스, 블로그, 까페 등)에 따라 고유한 네임을 가지고 있다. 예제 코드는 뉴스를 검색하여 저장하기 위한 형식이다. 자세한 부분은 네이버 개발자 페이지를 참고하기 바란다.

7. 트위터 스트립(Stream) 수집하기

Sun, 21 Jan 2018 06:01:00 +0000

7. 트윗(Tweet) 스트림 가지고 오기

페이스북에서는 현재까지 전체 타임라인을 검색하여 업데이트 된 정보를 제공해 주는 API를 제공해 주고 있지 않다. 트위터의 경우 생산되는 모든 데이터는 공유자산이라는 개념으로 시작하였으나 페이스북은 자신의 친구와 사생활을 공유하는 목적으로 개발되었기에 그들의 개인 보호 정책상에 맞지 않는 이유라 할 수 있겠다. 또한 페이스북의 데이터는 트위터에 비해 상대적으로 큰 사이즈이기 때문에 스트리밍 데이터를 처리하기에는 부적절 하다고 볼 수 있다. 최근 들어 페이스북은 “Webhooks”라는 API를 제공하고 있다. 그러나 웹 훅(과거에는 실시간 업데이트라고 함)의 경우에는 실시간으로 자신이 등록해 놓은 받아보기 리스트를 통해서 데이터의 업데이트 여부를 확인할 수 있다.

이러한 페이스북의 정책은 실제로 소셜 데이터 분석에 불편함을 제공한다. 트위터의 경우에는 필터를 통해 주된 관심사의 트윗이 얼마나 발생하고 있는지 확인할 수 있고, 이 데이터를 바탕으로 추가 분석을 할 수 있는 장점을 제공한다.

특정 검색어에 대한 스트림 데이터를 가지고 오기 위하여 다음의 코드를 작성한다

import oauth2
import urllib
import json
import urllib.request
import datetime
import time
from config import *

#[CODE 1]
class TWoauth():

    def __init__(self, consumer_key, consumer_secret, access_key, access_secret):
        self.oauth_consumer = oauth2.Consumer(key=consumer_key, secret=consumer_secret)
        self.oauth_token = oauth2.Token(key=access_key, secret=access_secret)
        self.signature_method_hmac_sha1 = oauth2.SignatureMethod_HMAC_SHA1()
        self.http_method = "GET"
        self.http_handler = urllib.request.HTTPHandler(debuglevel=0)
        self.https_handler = urllib.request.HTTPSHandler(debuglevel=0)

    def getTWRequest(self, url, method, parameters):
        
        req = oauth2.Request.from_consumer_and_token(self.oauth_consumer,
                                                token=self.oauth_token,
                                                http_method=self.http_method,
                                                http_url=url,
                                                parameters=parameters)
        req.sign_request(self.signature_method_hmac_sha1, self.oauth_consumer, self.oauth_token)

        if method == "POST":
            encoded_post_data = req.to_postdata()
        else:
            encoded_post_data = None

        to_url = req.to_url()

        opener = urllib.request.OpenerDirector()
        opener.add_handler(self.http_handler)
        opener.add_handler(self.https_handler)

        response = opener.open(to_url, encoded_post_data)
        
        return response

def getTwitterTwit(tweet, jsonResult):

    tweet_id = tweet['id_str']
    tweet_message = '' if 'text' not in tweet.keys() else tweet['text']
    
    screen_name = '' if 'user' not in tweet.keys() else tweet['user']['screen_name']

    tweet_link = ''
    if tweet['entities']['urls']: #list
        for i, val in enumerate(tweet['entities']['urls']):
            tweet_link = tweet_link + tweet['entities']['urls'][i]['url'] + ' '
    else:
        tweet_link = ''
        
    hashtags = ''
    if tweet['entities']['hashtags']: #list
        for i, val in enumerate(tweet['entities']['hashtags']):
            hashtags = hashtags + tweet['entities']['hashtags'][i]['text'] + ' '
    else:
        hashtags = ''

    if 'created_at' in tweet.keys():
        # Twitter used UTC Format. EST = UTC + 9(Korean Time) Format ex: Fri Feb 10 03:57:27 +0000 2017
        tweet_published = datetime.datetime.strptime(tweet['created_at'],'%a %b %d %H:%M:%S +0000 %Y')
        tweet_published = tweet_published + datetime.timedelta(hours=+9)
        tweet_published = tweet_published.strftime('%Y-%m-%d %H:%M:%S')   
    else:
        tweet_published = ''

    num_favorite_count = 0 if 'favorite_count' not in tweet.keys() else tweet['favorite_count']
    num_comments = 0    
    num_shares = 0 if 'retweet_count' not in tweet.keys() else tweet['retweet_count']
    num_likes = num_favorite_count
    num_loves = num_wows = num_hahas = num_sads = num_angrys = 0
    
    jsonResult.append({'post_id':tweet_id, 'message':tweet_message,
                    'name':screen_name, 'link':tweet_link, 
                    'created_time':tweet_published, 'num_reactions':num_favorite_count,
                    'num_comments':num_comments, 'num_shares':num_shares,
                    'num_likes':num_likes, 'num_loves':num_loves,
                    'num_wows':num_wows, 'num_hahas':num_hahas,
                    'num_sads':num_sads, 'num_angrys':num_angrys, 'hashtags': hashtags})

#[CODE 2]
def fetch(filter, jsonResult):

    twoauth = TWoauth(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN, ACCESS_SECRET)

    url = "https://stream.twitter.com/1.1/statuses/filter.json" 
    parameters = []
    parameters.append({'track', filter})

    try:
        f = twoauth.getTWRequest(url, "GET", parameters)
        while True:
            line = f.readline()
            if line:
                try:
                    tweet = json.loads(line.decode('utf-8'))
                    print('#####[Scrapped Time : %s]' % datetime.datetime.now())
                    print(tweet['text'])
                    getTwitterTwit(tweet, jsonResult)
                except ValueError as ve:
                    print (ve)
                except KeyError as e:
                    print(e)
            else:
                time.sleep(0.1)
    except KeyboardInterrupt:
        # Ctrl-C Detected
        f.close()
        with open('%s_twitter.json' % (filter), 'w', encoding='utf8') as outfile:
            retJson = json.dumps(jsonResult,
                            indent=4, sort_keys=True,
                            ensure_ascii=False)
            outfile.write(retJson)
        
        print ('%s_twitter.json SAVED' % (filter))
    
if __name__ == '__main__':
    jsonResult = []
    filter_name = '탄핵,박근혜,광화문'
    fetch (filter_name, jsonResult)

코드를 수행하면 스트리밍되는 관심어에 대한 내용이 화면에 나타나고 Control-C를 누르면 해당 .py 폴더에 filter_name_twitter.json 파일이 생성되고 프로그램이 종료된다. [그림 1]은 코드가 동작되는 화면을 보여준다.

[그림 1] 실시간으로 수집되는 트윗

[그림 1]의 스크랩되는 시간을 보면 실시간으로 증가하면서 나타나는 것을 확인할 수 있다. 이제 코드를 살펴보도록 하자.

#[CODE 1]
class TWoauth():

    def __init__(self, consumer_key, consumer_secret, access_key, access_secret):
        self.oauth_consumer = oauth2.Consumer(key=consumer_key, secret=consumer_secret)
        self.oauth_token = oauth2.Token(key=access_key, secret=access_secret)
        self.signature_method_hmac_sha1 = oauth2.SignatureMethod_HMAC_SHA1()
        self.http_method = "GET"
        self.http_handler = urllib.request.HTTPHandler(debuglevel=0)
        self.https_handler = urllib.request.HTTPSHandler(debuglevel=0)

    def getTWRequest(self, url, method, parameters):
        
        req = oauth2.Request.from_consumer_and_token(self.oauth_consumer,
                                                token=self.oauth_token,
                                                http_method=self.http_method,
                                                http_url=url,
                                                parameters=parameters)
        req.sign_request(self.signature_method_hmac_sha1, self.oauth_consumer, self.oauth_token)

        if method == "POST":
            encoded_post_data = req.to_postdata()
        else:
            encoded_post_data = None

        to_url = req.to_url()

        opener = urllib.request.OpenerDirector()
        opener.add_handler(self.http_handler)
        opener.add_handler(self.https_handler)

        response = opener.open(to_url, encoded_post_data)
        
        return response

[CODE 1]은 oauth2 모듈을 이용하여 트위터에 인증을 수행하기 위하여 TWoauth 클래스를 생성하였다. 초기 클래스를 생성하면서 우리는 사용할 ‘consumer_key/secret’과 ‘access_token/secret’을 저장하고 기본적으로 Token을 요구하기 위하여 필요한 암호화 방식과 서버에 접근 방식을 저장하였다. 또한 인증이 완료되고 서비스 API를 사용하기 위해서는 인증 정보를 유지하여야 하므로 Opener를 생성하기 위하여 기본적으로 ‘http_handler’와 ‘https_handler’를 설정하였다.

‘getTWRequest()’ 함수는 실질적으로 인증 과정을 수행한다. ‘oauth2.Request.from_consumer_and_token()’ 함수를 이용하여 ‘access_token’을 요청하는 ‘request’를 생성한다. [그림 2]는 ‘access_token’을 요청하기 위하여 기본적인 값들을 생성한 데이터이다.

[그림 2] Request를 요청할 파라미터를 위한 기본 데이터를 생성

‘sign_request()’를 이용하여 request를 지정한 암호화 방식으로 암호화한 시그네처(signature)를 생성하고, 추가한다.

[그림 3] oauth_signature의 추가

만약 “POST” 방식을 이용하는 경우에는 ‘to_postdata()’를 이용하여 파라미터를 인코딩한다. 우리는 “GET”방식을 이용하기 때문에 사용하지 않는다. 이제 트위터 API를 사용하기 위한 URL이 완성되었다.

다음은 “/statuses/filter.json”에 접근하기 위한 URL의 예를 나타낸다.

https://stream.twitter.com/1.1/statuses/filter.json?oauth_consumer_key=MlQHYIaVcsmjr2h4defzRi88H&oauth_nonce=98691135&oauth_signature=6bIsjX0caJt7vQbKYuCJdPU1u%2Fk%3D&oauth_signature_method=HMAC-SHA1&oauth_token=836816176235888640-6lFKqe8OkkUA8NxYz6cWRdv7cJTEALb&%ED%83%84%ED%95%B5%2C%EB%B0%95%EA%B7%BC%ED%98%9C%2C%EA%B4%91%ED%99%94%EB%AC%B8=track&oauth_timestamp=1488649098&oauth_version=1.0&oauth_body_hash=2jmj7l5rSw0yVb%2FvlWAYkK%2FYBwk%3D

해당 URL로 데이터를 요청하게 되는 경우 ‘oauth_token’을 계속 유지하여야 하기 때문에 ‘urllib.request.OpenerDirector()’를 이용하여 핸들러를 등록하고 유지한다.

#[CODE 2]는 TWoauth클래스를 생성하고, 검색어 필터를 지정한다. 검색어는 ‘,’를 이용하여 복수개를 지정할 수 있다.

#[CODE 2]
def fetch(filter, jsonResult):
    
    twoauth = TWoauth(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN, ACCESS_SECRET)

    url = "https://stream.twitter.com/1.1/statuses/filter.json" 
    parameters = []
    parameters.append({'track', filter})

‘/statuses/filter.json’ 엔드포인트(endpoint)는 필터(track)의 조건에 맞는 모든 공개 트윗을 반환해준다. “POST”와 “GET” 방식을 모두 허용하지만 매개변수가 너무 많아 길어지게 되면 요청이 거부될 수 있으므로, 매개변수가 많은 경우에는 “POST’를 사용하는 것이 좋다.

기본적으로 최대 400개의 검색어와 5,000개의 사용자 ID를 허용하므로 최근 이슈가 되고 있는 검색어를 분석하기에 충분할 수 있다고 볼 수 있다.

6. 트위터 데이터 수집하기

Fri, 05 Jan 2018 06:01:00 +0000

6. Twitter 데이터 수집

우리는 2. Twitter API 사용하기에서에서 트위터 App을 설정하였다. 이제 해당 앱 ID와 비밀키를 가지고 파이썬을 이용하여 데이터를 가지고 오는 방법에 대하여 설명하고자 한다. 페이스북의 경우에는 앱 아이디와 토큰을 요청 URL에 파라미터로 전송하여 간단하게 데이터를 가지고 올 수 있는 기능을 제공한다. 그러나 트위터의 경우에는 OAuth1.0a의 기본에 충실하게 억세스 토큰을 가지고 와야 실제 원하는 데이터를 조회 할 수 있다.

6.1 OAuth란?

사용자는 특정 서비스를 사용하기 위하여 아이디와 비밀번호라는 고전적인 방법을 이용하였다. 이를 위하여 서비스 제공자는 사용자의 아이와 비밀번호를 관리하여야 하는데 서버의 공격등으로 인해 아이디와 비밀번호가 노출되는 사고가 빈번히 발생하고 이를 위하여 데이터베이스에 비밀번호를 암호화 하는 등 다양한 형태의 보안 기술이 발생하였다.

OAuth의 시작은 2006년에 트위터와 소셜 북마크 서비스인 Gnolia사의 개발자들은 접속한 사용자들이 서비스를 사용하기 위하여 사용자를 인증(Authentication)하고 특정한 서비스만 사용하기 위한 권한(Authorization)을 주기 위한 적당한 인증 알고리즘이 없다고 판단하여 개발에 착수, 2007년 10월에 OAuth1.0을 발표하였다. 그 이후 세션 고정 공격(Session Fixation Attack: 세션 하이재킹(Hijacking) 기법중의 하나로 유요한 유저 세션을 탈취하여 인증을 회피하는 공격 방법)에 취약함이 발견되어 이를 개선하고 “The OAuth 1.0 Protocol”이라는 이름으로 2010년에 표준안이 RFC5849로 IETF에 의해 체택 되었다. 기존의 1.0에서 보안된 개념으로 실제 1.0이라고 제정되었지만 많은 사람들은 OAuth 1.0a라고 부른다. 현재 OAuth는 처음 설계를 한 트위터를 필두로, 구글, 페이스북, 마이크로 소프트 등의 외국 거대 서비스 회사 및 국내의 네이버, 다음 카카오 등에서 사용하고 있다.

OAuth의 장점은 사용자의 아이디와 비밀번호를 이용하여 인증을 하는 것이 아니고, 특정 서비스를 사용하고자 할 때 임시 사용 티켓을 발급하여, 서비스가 만료되거나 특정 기간이 종료하면 티켓을 사용할 수 없는 구조로 되어있다.

6.1.1 OAuth 1.0a 인증 과정

OAuth를 이용하여 사용자를 인증하는 과정을 OAuth Dance – ‘춤’이라고 표현할 수 있는 개발자들의 자유스러움이 부럽다 - 라고 한다. 먼저 OAuth 인증을 위하여 사용하는 주체를 표현하는 용어는 다음과 같다.

소비자 Consumer	OAuth를 사용해 서비스 제공자의 기능을 사용하려는 프로그램 : 우리가 제작하는 프로그램의 입장
서비스 제공자 Service Provider	OAuth를 사용하는 Open API 제공자 : 트위터, 페이스 북 등
요청 토큰 Request Token	OA소비자(Consumer)가 서비스제공자(Service Provider)에게 접근 권한을 받기 위해 사용하는 값, 인증이 완료되면 접근 토큰(Access Token)으로 변경된다
접근 토큰 Access Token	인증 후 소비자(Consumer)가 서비스제공자(Service Provider)의 자원에 접근하기 위한 키를 포함한 값
사용자 User	서비스제공자(Service Provider)에 계정을 가지고 있으면서, 소비자(Consumer)를 이용하려는 사용자

[그림 1]은 OAuth 1.0a의 인증 과정을 나타낸다.

[그림 1] OAuth 1.0a 인증 과정 (http://oauth.net/core/diagram.png)

1) Request Token 요청 및 발급

Consumer Key와 요청 시간(timestamp), 요청자료를 암호화 한 방식(HMAC-SHA1 등), 버전(1.0) 정보, 악의적인 정보 요청을 방지하기 위한 임의 문자열과 서명값을 만든후 해당 서버로 요청한다.
서명값(oauth_signature) 앞에서 설명한 각 변수값과 HTTP 요청 방식(POST 또는 GET)을 지정한 암호화 방식으로 암호화하여 만들어 낸다.
서비스 제공자에게 Request Token을 요청하면, 서비스 제공자는 ‘oauth_token’과 ‘oauth_token_secret’값을 회신한다.

2) 사용자 인증 페이지 호출 및 수락

수신한 ‘oauth_token’을 가지고 서비스 제공자가 지정한 인증페이지로 인증 수락을 요청한다. 인증 페이지는 각 서비스제공자가 제공한다.

3) Access Token 요청 및 발급

‘consumer_key’와 ‘oauth_token’ 및 기타 변수들을 이용하여 ‘oauth_signature’ 를 생성한 후 요청하면 서비스 제공자는 ‘oauth_token’과 ‘oauth_token_secret’ 및 부가 정보를 회신한다.

4) 해당 API 접근

수신한 ‘oauth_token’을 이용하여 서비스제공자의 API를 사용한다.

6.1.2 OAuth 2.0의 탄생

아쉽게도 OAuth 2.0은 OAuth 1.0a와 호환성을 가지고 개발되지 않았다. OAuth 2.0은 시그네처(signature)의 생성이 복잡하고 CPU 부하를 많이 가지고 있어서 모바일 환경에 적합하지 않아 시작된 표준이다. 그러나 하나의 표준이 존재하지 않고 프레임워크(Framework)라고 부르며, 여러 개의 표준 작업이 기업의 목적에 따라 이루어지고 있다. 간단하고 더 많은 인증 방법을 제공하고 있으나 각 기업이나 단체가 자신들의 서비스를 목적으로 표준 작업을 진행하다 보니 복잡하고 방대해져서 OAuth 1.0a를 대체하는데 많은 시간이 걸릴 것이라 관측하는 사람들도 적지 않다.

6.2 트윗(Tweet) 가지고 오기

파이썬에서 트위터를 사용하기 위해서는 다양한 모듈이 공개되고, 업그레이도 되고 있다. 그중에서 가장 보편적으로 사용하는 것은 “Tweepy” 모듈이다. 그러나 본 책에서는 최대한 모듈의 종속성을 배제하고 기본적인 접근 방법을 인지하기 위하여 최소한의 모듈만을 사용하는 것을 원칙으로 한다.

앞 절에서 언급하였듯이 트위터는 OAuth 1.0a 표준을 사용하여 응용 프로그램의 인증을 하고, 서비스 API를 사용할 수 있는 키값을 제공하여 준다. 이를 위하여 OAuth를 이해하는 것이 이전 절의 목적이었다면, 이번절에서는 OAuth를 이용하여 인증하는 방법에 대하여 알아 볼 것이다. OAuth는 암호화 알고리즘 및 시그네처(signature)의 구성을 위하여 많은 코딩이 필요하므로 현재 OAuth인증을 위하여 개발되고 업그레이드 되고 있는 파이썬 “OAuth2” 모듈을 import 하여 사용하고, 각 인증 과정은 6.3절에서 살펴 보도록 하겠다.

특정 트위터의 트윗을 가져오기 위하여 다음의 코드를 작성한다.

import oauth2
import json
import datetime
import time
from config import *

#[CODE 1]
def oauth2_request(consumer_key, consumer_secret, access_token, access_secret):
    try:
        consumer = oauth2.Consumer(key=consumer_key, secret=consumer_secret)
        token = oauth2.Token(key=access_token, secret=access_secret)
        client = oauth2.Client(consumer, token)
        return client
    except Exception as e:
        print(e)
        return None

#[CODE 2]
def get_user_timeline(client, screen_name, count=50, include_rts='False'):
    base = "https://api.twitter.com/1.1"
    node = "/statuses/user_timeline.json"
    fields = "?screen_name=%s&count=%s&include_rts=%s" % (screen_name, count, include_rts)
    #fields = "?screen_name=%s" % (screen_name)
    url = base + node + fields

    response, data = client.request(url)

    try:
        if response['status'] == '200':
            return json.loads(data.decode('utf-8'))
    except Exception as e:
        print(e)
        return None

#[CODE 3]
def getTwitterTwit(tweet, jsonResult):

    tweet_id = tweet['id_str']
    tweet_message = '' if 'text' not in tweet.keys() else tweet['text']

    screen_name = '' if 'user' not in tweet.keys() else tweet['user']['screen_name']

    tweet_link = ''
    if tweet['entities']['urls']: #list
        for i, val in enumerate(tweet['entities']['urls']):
            tweet_link = tweet_link + tweet['entities']['urls'][i]['url'] + ' '
    else:
        tweet_link = ''

    hashtags = ''
    if tweet['entities']['hashtags']: #list
        for i, val in enumerate(tweet['entities']['hashtags']):
            hashtags = hashtags + tweet['entities']['hashtags'][i]['text'] + ' '
    else:
        hashtags = ''

    if 'created_at' in tweet.keys():
        # Twitter used UTC Format. EST = UTC + 9(Korean Time) Format ex: Fri Feb 10 03:57:27 +0000 2017
        tweet_published = datetime.datetime.strptime(tweet['created_at'],'%a %b %d %H:%M:%S +0000 %Y')
        tweet_published = tweet_published + datetime.timedelta(hours=+9)
        tweet_published = tweet_published.strftime('%Y-%m-%d %H:%M:%S')
    else:
        tweet_published = ''

    num_favorite_count = 0 if 'favorite_count' not in tweet.keys() else tweet['favorite_count']
    num_comments = 0
    num_shares = 0 if 'retweet_count' not in tweet.keys() else tweet['retweet_count']
    num_likes = num_favorite_count
    num_loves = num_wows = num_hahas = num_sads = num_angrys = 0

    jsonResult.append({'post_id':tweet_id, 'message':tweet_message,
                    'name':screen_name, 'link':tweet_link,
                    'created_time':tweet_published, 'num_reactions':num_favorite_count,
                    'num_comments':num_comments, 'num_shares':num_shares,
                    'num_likes':num_likes, 'num_loves':num_loves,
                    'num_wows':num_wows, 'num_hahas':num_hahas,
                    'num_sads':num_sads, 'num_angrys':num_angrys, 'hashtags': hashtags})

def main():
    screen_name = "jtbc_news"

    num_posts = 50

    jsonResult = []

    client = oauth2_request(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN, ACCESS_SECRET)
    tweets = get_user_timeline(client, screen_name)

    for tweet in tweets:
        getTwitterTwit(tweet, jsonResult)

    with open('%s_twitter.json' % (screen_name), 'w', encoding='utf8') as outfile:
        str_ = json.dumps(jsonResult,
                      indent=4, sort_keys=True,
                      ensure_ascii=False)
        outfile.write(str_)

    print ('%s_twitter.json SAVED' % (screen_name))

if __name__ == '__main__':
    main()

코드를 수행하면 jtbc_news_twitter.json 파일이 .py 가 있는 폴더에 저장되어 있을 것이다. 해당 파일을 JSON 뷰어를 이용하여 읽어 보면 [그림 2]와 같이 트윗(tweet)이 JSON 형태로 저장된 것을 확인할 수 있다.

[그림 2] JTBC_NEWS 트위터를 크롤링한 JSON 모습

[그림 2]의 처음 JSON 데이터는 [그림 3]의 내용을 나타내고 있다.

[그림 3] 저장한 JTBC뉴스 트윗

실제 이전 절에서 페이스북 API를 이용하여 JSON 형태의 데이터를 수신하고, 취급하는 방법에 대하여 충분히 이해하였으리라 생각하여 중복되는 내용은 5. Facebook 데이터 수집을 확인하기 바란다.

먼저 빈번하게 사용하는 환경변수의 값인 Cusomer_key 와 Customer_Secret, Access_token과 Access_token은 congi.py라는 파일로 따로 작성한 후 import 하여 사용하였다.

CONSUMER_KEY = "[COUSUMER_KEY]"
CONSUMER_SECRET = "[COSUMER_SECRET]"
ACCESS_TOKEN = "[ACCESS_TOKEN]"
ACCESS_SECRET = "[ACCESS_SECRET]"

해당 .py 파일의 키값은 트위터에서 제공받은 값으로 변경하기 바란다.(Part I.의 트위터 개발자 계정 부분을 참조하기 바란다)

#[CODE 1] oauth2 모듈을 이용한 키 인증
def oauth2_request(consumer_key, consumer_secret, access_token, access_secret):
    try:
        consumer = oauth2.Consumer(key=consumer_key, secret=consumer_secret)
        token = oauth2.Token(key=access_token, secret=access_secret)
        client = oauth2.Client(consumer, token)
        return client
    except Exception as e:
        print(e)
        return None

oauth2 모듈은 OAuth의 복잡한 과정을 간단하게 해결해주는 모듈을 제공한다. 우리는 부여받은 consumer_key와 해당 secret, 그리고 acces_token과 secret을 oath2에 전달해 줌으로써 기본적인 인증을 위한 준비를 마친다.

기본값을 지정한 후 consumer와 token 오브젝트(object)를 Client 클래스로 전달하면 복잡한 댄싱과정을 마치고 access_token을 포함하는 OAuthClient를 반환한다.

#[CODE 2] 사용자의 timeline 트윗을 수신
def get_user_timeline(client, screen_name, count=50, include_rts='False'):
    base = "https://api.twitter.com/1.1"
    node = "/statuses/user_timeline.json"
    fields = "?screen_name=%s&count=%s&include_rts=%s" % (screen_name, count, include_rts)
    url = base + node + fields

    response, data = client.request(url)

    try:
        if response['status'] == '200':
            return json.loads(data.decode('utf-8'))
    except Exception as e:
        print(e)
        return None

[CODE 2]의 경우에는 페이스북의 타임라인을 얻어 오는것과 동일한 형식을 가진다. 여기서 screen_name은 트위터에서 사용하는 공식 이름(영문)이다. 페이스북은 Numeric ID 형식의 page id를 가지고 타임라인을 요청하여야 하기 때문에 변환 과정을 거쳐야 하나, 트위터는 편하게 screen_name을 가지고 요청이 가능하다.

수신받은 데이터는 페이스북과 마찬가지로 ‘utf-8’로 인코딩 되어있는 바이너리 JSON 데이터 형식이여서 ’utf-8’로 디코딩 한 후 반환한다.

#[CODE 3] 사용자의 timeline 트윗을 수신
def getTwitterTwit(tweet, jsonResult):

    tweet_id = tweet['id_str']
    tweet_message = '' if 'text' not in tweet.keys() else tweet['text']

    screen_name = '' if 'user' not in tweet.keys() else tweet['user']['screen_name']

    tweet_link = ''
    if tweet['entities']['urls']: #list
        for i, val in enumerate(tweet['entities']['urls']):
            tweet_link = tweet_link + tweet['entities']['urls'][i]['url'] + ' '
    else:
        tweet_link = ''

    hashtags = ''
    if tweet['entities']['hashtags']: #list
        for i, val in enumerate(tweet['entities']['hashtags']):
            hashtags = hashtags + tweet['entities']['hashtags'][i]['text'] + ' '
    else:
        hashtags = ''

    if 'created_at' in tweet.keys():
        # Twitter used UTC Format. EST = UTC + 9(Korean Time) Format ex: Fri Feb 10 03:57:27 +0000 2017
        tweet_published = datetime.datetime.strptime(tweet['created_at'],'%a %b %d %H:%M:%S +0000 %Y')
        tweet_published = tweet_published + datetime.timedelta(hours=+9)
        tweet_published = tweet_published.strftime('%Y-%m-%d %H:%M:%S')
    else:
        tweet_published = ''

    num_favorite_count = 0 if 'favorite_count' not in tweet.keys() else tweet['favorite_count']
    num_comments = 0
    num_shares = 0 if 'retweet_count' not in tweet.keys() else tweet['retweet_count']
    num_likes = num_favorite_count
    num_loves = num_wows = num_hahas = num_sads = num_angrys = 0

    jsonResult.append({'post_id':tweet_id, 'message':tweet_message,
                    'name':screen_name, 'link':tweet_link,
                    'created_time':tweet_published, 'num_reactions':num_favorite_count,
                    'num_comments':num_comments, 'num_shares':num_shares,
                    'num_likes':num_likes, 'num_loves':num_loves,
                    'num_wows':num_wows, 'num_hahas':num_hahas,
                    'num_sads':num_sads, 'num_angrys':num_angrys, 'hashtags': hashtags})

[CODE 3]은 수신한 JSON 형식에서 우리가 원하는 데이터의 값을 키값과 그에 해당하는 데이터값을 조회한다. 페이스북은 reaction이라는 레코드셋을 가지고 “좋아요, 사랑해요” 등의 리액션 데이터를 가지고 있지만 트위터는 단순하게 ‘좋아요’의 데이터만 가지고 있다. [그림 4]는 트위터의 JSON 구성 형태를 알아보기 편하도록 작성된 맵이다.

[그림 4] 트위터 Status 객체 구성 요소

트위터에서는 API를 활용하기 위한 다양한 페이지 URL(endpoint)를 제공한다(코드에서 사용한 node 부분).

용도	Endpoint
내 타임라인	/statuses/home_timeline.json allowed_param:’since_id’, ‘max_id’, ‘count’
특정 사용자 타임라인	/statuses/user_timeline.json allowed_param:’id’, ‘user_id’, ‘screen_name’, ‘since_id’
맨션 타임라인	/statuses/mentions_timeline.json allowed_param:’since_id’, ‘max_id’, ‘count’
나를 리트윗한 정보	/statuses/retweets_of_me.json allowed_param:’since_id’, ‘max_id’, ‘count’
사용자 정보	/users/show.json allowed_param:’id’, ‘user_id’, ‘screen_name’
사용자 검색	/users/search.json allowed_param:’q’, ‘count’, ‘page’
팔로워	/followers/list.json allowed_param: ‘id’, ‘user_id’, ‘screen_name’, ‘cursor’, ‘count’, ‘skip_status’, ‘include_user_entities’
검색	/search/tweets.json allowed_param: ‘q’, ‘lang’, ‘locale’, ‘since_id’, ‘geocode’, ‘max_id’, ‘since’, ‘until’, ‘result_type’, ‘count’, ‘include_entities’, ‘from’, ‘to’, ‘source’

트위터는 큰 결과 세트를 검색하기 위하여 페이징 기법으로 커서링(cursoring)이라는 기법을 사용한다. 먼저 처음에는 cursor의 값을 ‘-1’로 지정하여 결과를 검색하면 ‘previous_cursor’, ‘next_cursor’, ‘previous_cursor_str’ 및 ‘next_cursor_str’을 반환한다. [그림 4]에서 JSON 구조를 잘 살펴 보았다면 트위터는 숫자문자열의 경우에는 항상 해당 ‘키’값과 ‘키_str’을 제공하는 것을 확인할 수 있다.

다음 페이지를 얻기 위하여 우리는 ‘cursor’에 ‘next_cursor’의 값을 전달하여 페이지를 요청하면 된다. 만약 ‘next_cursor’의 값이 ‘0’으로 반환되면 더 이상의 페이지는 없는 것을 의미한다(페이스북에서는 다음 페이지를 요청하는 URL을 보내주므로 단순하게 해당 URL을 호출하는 것으로 데이터를 획득할 수 있었다). 또한 페이스북의 since와 until의 개념은 트위터에서는 Search API에서 사용되며, ‘statuses’에서는 지원하지 않는다. 자세한 부분은 Search API를 참조하기 바란다.

5. Facebook 데이터 수집

Fri, 05 Jan 2018 06:01:00 +0000

5. Facebook 데이터 수집

우리는 1. Facebook API 사용등록에서 페이스북 App을 설정하였다. 이제 해당 앱 ID와 비밀키를 가지고 파이썬을 이용하여 데이터를 가지고 오는 방법에 대하여 설명하고자 한다.

일반적으로 근래 서비스되는 모든 웹 서비스는 OAuth라는 인증 방식을 통하여 사용자 계정에 대한 접근을 하게 된다. 그러나 페이스북은 OAuth2 방식을 채용하면서 기본적으로 ‘https’ 프로토콜을 적용하고 편리한 방식의 그래프 API를 이용해 페이스북에 접근하는 방식을 제공한다. 그래프 API는 “소셜 그래프”라는 명칭에서 유래된 것으로 다음 항목을 가지고 있다.

항목	설명
노드(Node)	기본적으로 사용자, 사진, 페이지, 댓글과 같은 항목(item)을 포함한다
에지(Edge)	페이지의 사진, 사진의 댓글 등 각 항목간의 연결 링크
필드(Field)	페이지 정보, 해당 페이지 프로필(Profile)등 항목에 대한 정보

그래프 API는 HTTP 기반으로 설계되어 쉽게 이해할 수 있으며 웹 브라우저에서도 동작할 수 있는 장점을 가지고 있으나 보안성이 취약한 단점을 가지고 있다. 보안이 필요한 경우에는 OAuth 인증 방식을 사용하는 것을 권장하나 본 책의 범위를 넘어서는 관계로 여기서는 그래프 API의 엑세스 토큰을 전달하는 방식을 사용한다.

5.1 페이스북 그래프(Graph) API

그래프(Graph) API는 페이스북의 소셜 그래프에서 데이터를 가지고 오거나 게시하는 기본적인 방법을 제공하는 HHTP 기반의 API이다. 그래프 API는 모든 노드(Node)와 에지(Edge)에 관하여 HTTP GET 요청을 보내기만 하면 해당 데이터를 조회할 수 있다.

5.1.1 읽기

GET /[version info]/[Node|Edge Name]
Host: graph.facebook.com

일반적인 API 호출은 액세스 토큰(access token)을 사용하여 접근할 수 있으며, 노드나 에지의 특성에 따라 요청 토큰에 따른 권한이 필요하다. 예를 들어 “/me” 노드를 요청하는 경우에는 사용자에 대한 아이디(user_id) 또는 페이스북의 page_id를 반환하며, “/me/photos”를 요청하게 되는 경우 해당 사용자의 사진을 모두 가지고 올 수 있다. 반환의 형식은 아래와 같이 fieldname에 해당하는 키값과 그에 해당하는 field 값의 쌍으로 JSON 형식으로 반환한다.

{
	“fieldname” : {field-value},
	…
}

5.1.2 페이지 조회

페이스북은 시간의 흐름(timline)을 기준으로 작성된다. 일반적으로 사용자는 단순하게 단일 데이터를 요청하지 않고 여러 개의 데이터를 조회할 수 있으며, 이를 위하여 다음과 같은 페이징 기법을 제공한다.

1) 커서(cursor) 기반 페이지 조회

커서 기반 페이지는 일반적인 페이징 기법으로 이전페이지에 접근할 수 있는 커서값(before)과 다음 페이지(after)에 접근할 수 있는 커서값을 제공해준다. 커서값을 인자로 전달하는 경우 해당 페이지로 이동한다. 커서 페이지 메김을 하는 경우 다음과 같은 데이터가 JSON 형식으로 반환된다. 페이스북은 친절하게 이전 페이지와 다음페이지를 요청할 수 있는 키 값을 “previous”와 “next”로 제공해 준다.

커서의 값은 중간에 뉴스 피드가 삭제되거나 추가되는 경우 페이지 값이 변경될 수 있으므로 저장된 값으로 사용해서는 안된다. 응답되는 JSON의 형식은 다음과 같다.

{
  "data": [
     ... 획득한 데이터
  ],
  "paging": {
    "cursors": {
      "after": "MTAxNTExOTQ1MjAwNzI5NDE=",
      "before": "NDMyNzQyODI3OTQw"
    },
    "previous": "https://graph.facebook.com/me/albums?limit=25&before=NDMyNzQyODI3OTQw"
    "next": "https://graph.facebook.com/me/albums?limit=25&after=MTAxNTExOTQ1MjAwNzI5NDE="
  }
}

전달되는 인자는 다음과 같은 특성을 가진다.

인자	설명
before	반환된 데이터 페이지의 처음을 가리키는 커서
after	반환된 데이터의 끝을 가리키는 커서
limit	반환하는 데이터의 최대 개수. 최대 개수보다 데이터가 작게 수신된 경우 더 이상의 데이터가 없다고 판단할 수 있으나, 중간 뉴스 피드가 비공개 처리 된 경우 등이 있어 데이터의 반환이 적을 수 있으므로 반드시 “next”의 값이 없는 경우에 더 이상의 데이터가 없다고 판단하여야 한다
next	데이터의 다음 페이지를 반환하는 그래프 API URL. 해당 값이 없는 경우에는 더 이상 조회할 데이터가 없음을 의미한다
previous	데이터의 이전 페이지를 반환하는 그래프 API URL

2) 시간(time period) 기준 페이지 조회
시간 기준은 조회 시작 시간과 조회 종료 시간을 지정함으로써 데이터를 획득한다. 응답되는 데이터의 JSON 형식은 다음과 같다.

{
  "data": [
     ... 획득한 데이터
  ],
  "paging": {
    "previous": "https://graph.facebook.com/me/feed?limit=25&since=1364849754",
    "next": "https://graph.facebook.com/me/feed?limit=25&until=1364587774"
  }
}

전달되는 인자는 다음과 같은 특성을 가진다. 단 최대 since와 until의 값의 범위는 6개월 이내이어야 한다.

인자	설명
until	조회 종료 시간을 의미하는 Unix 타임스탬프 값
since	조회 시작 시간을 의미하는 Unix 타임스탬프 값
limit	반환하는 데이터의 최대 개수
next	데이터의 다음 페이지를 반환하는 그래프 API URL. 해당 값이 없는 경우에는 더 이상 조회할 데이터가 없음을 의미한다
previous	데이터의 이전 페이지를 반환하는 그래프 API URL

3) 오프셋(offset) 기반 페이지 조회
시간 순서등에 상관없이 특정 개수의 개체를 반환하고자 할 때 사용할 수 있다. 매뉴얼 상에는 에지(Edge)가 커서 또는 시간 기준 페이지 조회가 되지 않는 경우에만 사용 가능하다고 되어 있다.

5.2 페이스북 ID 가지고 오기

페이스북은 각자 계정을 만들게 되면 고유 URL을 부여한다. [그림 1]의 예에서 처럼 JTBC 뉴스의 접근 URL은 http://www.facebook.com/jtbcnews로 지정되어 있는 것을 확인할 수 있다. 여기에서 페이지 고유 URL은 “jtbcnews” 임이 확인 가능하다.

[그림 1] 페이스북 접근 URL

그러나 아쉽게도 페이스북 API는 고유 이름을 이용하여 접근할 수 있는 방법을 제공하지 않는다. 페이지의 접근을 위해서 페이스북에서는 고유의 숫자형식 ID(Numeric ID)를 사용하게 되므로 이를 위해 그래프 API를 이용하여 해당 페이지의 숫자 형식 ID를 가지고 와야 한다. 아래와 같이 [코드 1]을 작성한다

import sys
import urllib.request
import json

if __name__ == '__main__':
    # [CODE 1]
    page_name = "jtbcnews"
    app_id = "[App ID]"
    app_secret = "[App Secret Code]"
    access_token = app_id + "|" + app_secret

    # [CODE 2]
    # https://graph.facebook.com/v2.8/[page_id]/?access+token=[App_ID]|[Secret_Key]
    # 형식의 문자열을 만들어 낸다

    base = "https://graph.facebook.com/v2.8"
    node = "/" + page_name
    parameters = "/?access_token=%s" % access_token
    url = base + node + parameters

    # [CODE 3]
    req = urllib.request.Request(url)

    # [CODE 4]
    try:
        response = urllib.request.urlopen(req)
        if response.getcode() == 200:
            data = json.loads(response.read().decode('utf-8'))
            page_id = data['id']
            print ("%s Facebook Numeric ID : %s" % (page_name, page_id))
    except Exception as e:
        print (e)

해당 코드를 수행하면 [그림 2]와 같이 Numeric ID를 수신한 것을 확인할 수 있다.

[그림 2] Numeric ID 획득 결과

우리는 위와 같은 코드를 이용하여 “jtbcnews”에 접근할 수 있는 ID값을 얻게 되었다. 코드에 대해 자세히 살펴보면 다음과 같다.

# [CODE 1]
    page_name = "jtbcnews"
    app_id = "[App ID]"
    app_secret = "[App Secret Code]"
    access_token = app_id + "|" + app_secret

먼저 접근할 page의 ID와 할당받은 App ID, App Secret을 변수로 지정한 후 접근 인증을 얻기위한 Token을 생성한다. 페이스북에서는 다양한 형식의 인증방식을 제공해 준다. 그래프 API에서는 단순하게 앱 ID와 앱 시크릿을 구분자인 “|”를 이용하여 연속적인 파라미터로 전송함으로써 인증을 완료하는 편의성을 제공한다. 단, 보안성이 요구되는 프로그램에서는 이렇게 쿼리 파라미터로 데이터를 전송하는데 제약을 가질 수 있다.

[CODE 1]에서 [App ID]와 [App Secret_Code]는 페이스북 App을 생성하면서 부여 받은 앱 ID와 비밀키를 의미한다.

# [CODE 2]
    # https://graph.facebook.com/v2.8/[page_id]/?access_token=[App_ID]|[Secret_Key]
    # 형식의 문자열을 만들어 낸다

    base = "https://graph.facebook.com/v2.8"
    node = "/" + page_name
    parameters = "/?access_token=%s" % access_token
    url = base + node + parameters

본 책이 쓰여지는 시점에서 사용한 그래프 API의 버전은 2.8(2017년 2월 21일 현재)이며, 해당 베이스 URL 뒤에 Node와 파라미터를 부여하여 쿼리 문자열을 작성한다.

https://graph.facebook.com/v2.8/[page_name]/?access+token=[App_ID]|[App_Secret_Code]

기본적으로 페이스북을 통하여 해당 Numeric ID를 얻어가지고 오는 방법은 그래프 API URL 뒤에 질의하고자 하는 페이지 id와 억세스 토큰(access token)을 쿼리 파라미터(query partameters)로 전달하면 JSON 형태의 데이터로 응답 받게 된다.

# [CODE 3]
    req = urllib.request.Request(url)

“urllib.request” 모듈은 URL을 이용하여 고수준(high level)의 HTTP 클라이언트 인터페이스를 위한함수(function)와 클래스(class)제공하며 “Request” 클래스는 URL 요청을 하기 위한 방법을 제공한다. “Urllib.request.Request()” 생성자는 다음과 같은 방식으로 설정한다.

urllib.request.Request(url, data=None, headers={}, origin_req_host=None, unverifiable=False, method=None)

인자	설명
url	접근할 페이지 URL
data	서버로 전송할 부가적인 데이터를 지정한다. 전송할 데이터는 바이트열(bytes)이나, 전송할 파일, POST 데이터 등이 될 수 있으며 Header에서 지정하는 Content-Length와 Transfer-Encoding 속성에 의하여 전송할 데이터 양을 지정한다. POST 데이터의 경우에는 urllib.parse.urlencode() 함수를 이용하여 데이터 값을 인코딩한 후 전송하여야 한다
headers	헤더는 딕셔너리(dictionary) 형식을 가지며, add_header() 함수를 이용하여 키(key)값과 그에 해당하는 값(value)의 쌍을 가진다. 예를 들어 POST 형식의 데이터를 전송하게 되는 경우에는 Content-Type: application/x-www-form-relencoded가 지정되어야 한다(실제 이 값은 기본값이다)
origin_req_host	RFC 2965 기반의 요청한 호스트의 호스트 명 또는 IP 어드레스를 지정한다. 기본값은 http.cookies.requst_host(self) 값이다
unverifiable	해당 요청에 대하여 재 확인(검증)이 요청되는 경우에 지정한다. 기본값은 ”False”이다. 쿠키의 값 인증 등을 위해 사용한다
method	HTTP 요청의 방식을 지정한다. 기본값은 ‘GET’ 방식이다

# [CODE 4]
    try:
        response = urllib.request.urlopen(req)
        if response.getcode() == 200:
            data = json.loads(response.read().decode('utf-8'))
            print ("%s Facebook Numeric ID : %s" % (page_id, data['id']))
    except Exception as e:
        print (e)

“try… except” 구문은 일반적으로 어떠한 동작을 수행하면서 발생하는 오류를 처리하기 위한 블록이다. “try” 블록내의 처리중 시스템 오류가 발생하면 “except” 이하의 블록이 처리되며, “Exception”을 이용하여 해당 오류가 무엇인지 확인할 수 있다(본 책은 파이썬 프로그래밍 과정이 아니므로 ‘try…except’에 대하여 자세히 설명하지 아니한다. 좀더 자세한 사항은 파이썬 도움말을 참조하기 바란다)

urllib.request.Request()를 이용하여 생성한 req 객체를 urllib.request.urlopen()함수에 전달하여 지정한 URL에 해당하는 객체를 가지고 온다. 반환된 객체는 다음과 같은 메소드를 제공한다.

geturl()	응답한 서버의 URL을 포함하며, Redirect된 경우에는 Redirect 서버의 URL을 반환한다
info()	페이지의 헤더값과 같은 meta 정보를 가지고 온다
getcode()	서버의 HTTP 응답 코드를 반환한다
origin_req_host	RFC 2965 기반의 요청한 호스트의 호스트 명 또는 IP 어드레스를 지정한다. 기본값은 http.cookies.requst_host(self) 값이다
unverifiable	해당 요청에 대하여 재 확인(검증)이 요청되는 경우에 지정한다. 기본값은 ”False”이다. 쿠키의 값 인증 등을 위해 사용한다
method	HTTP 요청의 방식을 지정한다. 기본값은 ‘GET’ 방식이다

반환받은 response 객체의 서버 응답코드가 정상적인 경우(200 반환)에는 수신한 데이터에서 원하는 정보를 찾기 위한 작업을 수행한다.

반환되는 값은 바이트열(Bytes)로 구성되어 있으며, 이를 해석하기에 적절한 형태로 변환하여야 한다. 앞서 이야기 했듯이 수신된 데이터는 JSON 형태를 가지고 있기 때문에 일단 수신한 데이터를 “json” 모듈에 전달하기 위하여 ‘utf-8’ 형식으로 디코딩한 후 전달한다.

정상적으로 데이터를 수신하게 되면 data는 다음과 같은 JSON 속성을 가진다.

{“id”: “240263402699918”, “name”: “JTBC 뉴스”}

여기서 “Id”는 “jtbcnews”의 Nemeric ID를 의미하며, “name”은 해당페이지명을 의미한다. 우리는 코드를 통하여 “jtbcnews”의 Numeric ID를 얻었으며, 이를 페이지 아이디(Page ID)라고 부를 것이다. 이제 다음절에서는 페이지 아이디를 이용하여 페이지를 검색하고 데이터를 가지고 오는 방법에 대해 알아보도록 하겠다.

5.3 페이스북 포스트(/{post-id})) 가져오기

페이스북의 게시물들은 포스트(Post)를 이용하여 관리된다. 포스트는 공개된 페이지에 대하여 액세스 토큰(access token)을 이용하여 접근할 수 있으며, 페이지의 공개 범위 설정에 의하여 조회되는 데이터의 접근 정도가 결정된다.

GET /[version info]/{post-id} Host: graph.facebook.com

포스트를 통하여 요청하는 주요 데이터는 다음과 같다.

필드명	설명	반환 형식
id	포스트 ID	String
comments	댓글 정보	Object
created_time	포스트 초기 생성일자	Datetime
from	포스트한 사용자에 대한 프로필 정보	Profile
link	포스트에 삽입되어 있는 링크	String
message	포스트 메시지	String
name	링크의 이름	String
object_id	업로드한 사진 또는 동영상 ID	String
parent_id	해당 포스트의 부모 포스트	String
picture	포스트에 포함되어 있는 사진들의 링크	String
place	포스트를 작성한 위치 정보	Place
reactions	좋아요, 화나요 등에 대한 리엑션 정보	Obejct
shares	포스트를 공유한 숫자	Object
type	포스트의 객체 형식	enum{link, status, photo, video, offer}
updated_time	포스트가 최종 업데이트된 시간	Datetime

게시글을 가지고 오기 위하여 아래와 같이 코드를 작성한다.

# -*- coding: utf-8 -*-
# version: 3.5

import sys
import urllib.request
import json

if __name__ == '__main__':

    page_name = "jtbcnews"
    page_id = "240263402699918"
    app_id = "[App ID]"
    app_secret = "[App Secret Code]"

    # [CODE 1]
    from_date = "2017-01-01"
    to_date = "2017-01-31"
    num_statuses = "10"
    access_token = app_id + "|" + app_secret

    # [CODE 2]
    base = "https://graph.facebook.com/v2.8"
    node = "/%s/posts" % page_id
    fields = "/?fields=id,message,link,name,type,shares,reactions," + \
             "created_time,comments.limit(0).summary(true)" + \
             ".limit(0).summary(true)"
    duration = "&since=%s&until=%s" % (from_date, to_date)
    parameters = "&limit=%s&access_token=%s" % (num_statuses, access_token)
    url = base + node + fields + duration + parameters

    req = urllib.request.Request(url)

    try:
        response = urllib.request.urlopen(req)
        if response.getcode() == 200:
            data = json.loads(response.read().decode('utf-8'))
            print (data)

    except Exception as e:
        print (e)

코드를 수행하면 해당 다음과 같이 JSON 형태의 페이스북 포스트가 수신된다.

{
    "data":[
        {
            "comments":{
                "data":[
                ],
                "summary":{
                    "order":"ranked",
                    "total_count":12,
                    "can_comment":"False"
                }
            },
            "message":"즉 청와대가 최 씨의 국정개입 사건을 파 악하고도 \n은폐했다는 사실이 안 전 수석 입에서 나온 겁니다.",
            "type":"link",
            "shares":{
                "count":46
            },
            "reactions":{
                "data":[
                ],
                "summary":{
                    "viewer_reaction":"NONE",
                    "total_count":443
                }
            },
            "created_time":"2017-02-23T00:00:00+0000",
            "name":"안종범 \"재단 임원 인사에 최순실 개입, 알고도 숨겼다\"",
            "id":"240263402699918 _1328805163845731",
            "link":"http://news.jtbc.joins.com/article/article.aspx?new s_id=NB11427906&pDate=20170222"
        }
    ],
    "paging":{
        "next":"https://graph.facebook.co m/v2.8/240263402699918/posts?fields=...",
        "previous":"https://graph.facebook.com/v2.8/240263402699918/posts?fields=..."
    }
}

수신된 JSON 형식의 포스트의 실제 페이스북 화면은 [그림 3]과 같다.

[그림 3] JTBCNEWS(ID = 240263402699918) 포스트

코드에 대해 자세히 살펴보면 다음과 같다.

# [CODE 1] 기본 인자의 설정
    from_date = "2017-01-01"
    to_date = "2017-01-31"
    num_statuses = "10"
    access_token = app_id + "|" + app_secret

먼저 접근할 포스트의 기간 설정을 위하여 검색의 시작일과 종료일, 그리고 1회 조회 시 가져올 포스트의 개수를 지정한다. 정확하게 페이스북에서는 최대 한 페이지의 포스트 개수에 대하여 정의한 문서는 찾지 못하였지만 동시에 가지고 올 포스트의 개수가 커지면 서버 응답시간이 길어지게 되고, 성능 저하의 원인이 될 수 있으므로 적당한 수로 조정하는 것이 좋다.

# [CODE 2] 쿼리 파라미터의 작성
    base = "https://graph.facebook.com/v2.8"
    node = "/%s/posts" % page_id
    fields = "/?fields=id,message,link,name,type,shares,reactions," + \
             "created_time,comments.limit(0).summary(true)" + \
             ".limit(0).summary(true)"
    duration = "&since=%s&until=%s" % (from_date, to_date)
    parameters = "&limit=%s&access_token=%s" % (num_statuses, access_token)
    url = base + node + fields + duration + parameters

기본적으로 가지고 올 노드는 “jtbcnews’의 페이지 아이디로 지정한다(페이지 아이디를 얻는 방법은 5.2절에서 설명하였다). 가지고올 필드는 message, link, created_time, type, name, id, comments, shares, reaction으로 지정하고 검색 기간은 기본 인자 설정에서지정한 기간으로 설정한다.

comments와 reaction은 summary값을 요청하는 경우 FQL(Facebook Query Language)을 이용하는 방법을 공식문서에서 확인할 수 있는데 직접 쿼리 파라미터로 접근할 수 있는 방법을 스택오버플로우(Stack Overflow : http://stackoverflow.com/questions/17755753/how-to-get-likes-count-when-searching-facebook-graph-api-with-search-xxx)에서 답변으로 확인할 수 있다.

검색 기간은 기본적으로 페이스북에서는 유닉스 타임스탬프 또는 일반적인 “YYYY-MM-DD” 형식을 지원한다.

우리는 기본적인 코드를 이용하여 원하는 페이지로부터 POST를 가지고 오는 방법에 대하여 알아보았다. 이제 이를 더 확장하여 좋아요 등의 개수와 댓글의 개수를 확인하는 방법에 대하여 알아보고, 이를 JSON 형식으로 저장하고, 나중에 활용할 수 있도록 하자.

5.4 페이스북 포스트(/{post-id})) 저장

페이스북의 포스트들을 검색하여 JSON 파일로 저장하기 위하여 다음 코드를 작성한다.

# -*- coding: utf8 -*-
# version: 3.5

import sys
import urllib.request
import json
import datetime
import csv
import time

#[CODE 1]
def get_request_url(url):

    req = urllib.request.Request(url)

    try:
        response = urllib.request.urlopen(req)
        if response.getcode() == 200:
            print ("[%s] Url Request Success" % datetime.datetime.now())
            return response.read().decode('utf-8')
    except Exception as e:
        print(e)
        print("[%s] Error for URL : %s" % (datetime.datetime.now(), url))
        return None

#[CODE 2]
def getFacebookNumericID(page_id, access_token):

    base = "https://graph.facebook.com/v2.8"
    node = "/" + page_id
    parameters = "/?access_token=%s" % access_token
    url = base + node + parameters

    retData = get_request_url(url)

    if (retData == None):
        return None
    else:
        jsonData = json.loads(retData)
        return jsonData['id']

#[CODE 3]
def getFacebookPost(page_id, access_token, from_date, to_date, num_statuses):

    base = "https://graph.facebook.com/v2.8"
    node = "/%s/posts" % page_id
    fields = "/?fields=id,message,link,name,type,shares,reactions," + \
             "created_time,comments.limit(0).summary(true)" + \
             ".limit(0).summary(true)"
    duration = "&since=%s&until=%s" % (from_date, to_date)
    parameters = "&limit=%s&access_token=%s" % (num_statuses, access_token)
    url = base + node + fields + duration + parameters

    retData = get_request_url(url)

    if (retData == None):
        return None
    else:
        return json.loads(retData)


def getPostItem(post, key):
    try:
        if key in post.keys():
            return post[key]
        else:
            return ''
    except:
        return ''

def getPostTotalCount(post, key):
    try:
        if key in post.keys():
            return post[key]['summary']['total_count']
        else:
            return 0
    except:
        return 0

#[CODE 4]
def getPostData(post, access_token, jsonResult):

    #[CODE 4-1]
    post_id = getPostItem(post, 'id')
    post_message = getPostItem(post, 'message')
    post_name = getPostItem(post, 'name')
    post_link = getPostItem(post, 'link')
    post_type = getPostItem(post, 'type')

    post_num_reactions = getPostTotalCount(post, 'reactions')
    post_num_comment = getPostTotalCount(post, 'comments')
    post_num_shares = 0 if 'shares' not in post.keys() else post['shares']['count']

    #[CODE 4-2]
    post_created_time = getPostItem(post, 'created_time')
    post_created_time = datetime.datetime.strptime(post_created_time, '%Y-%m-%dT%H:%M:%S+0000')
    post_created_time = post_created_time + datetime.timedelta(hours=+9)
    post_created_time = post_created_time.strftime('%Y-%m-%d %H:%M:%S')

    #[CODE 4-3]
    reaction = getFacebookReaction(post_id, access_token) if post_created_time > '2016-02-24 00:00:00' else {}
    post_num_likes = getPostTotalCount(reaction, 'like')
    post_num_likes = post_num_reactions if post_created_time < '2016-02-24 00:00:00' else post_num_likes

    #[CODE 4-4]
    post_num_loves = getPostTotalCount(reaction, 'love')
    post_num_wows = getPostTotalCount(reaction, 'wow')
    post_num_hahas = getPostTotalCount(reaction, 'haha')
    post_num_sads = getPostTotalCount(reaction, 'sad')
    post_num_angrys = getPostTotalCount(reaction, 'angry')

    jsonResult.append({'post_id':post_id, 'message':post_message,
                    'name':post_name, 'link':post_link,
                    'created_time':post_created_time, 'num_reactions':post_num_reactions,
                    'num_comments':post_num_comment, 'num_shares':post_num_shares,
                    'num_likes':post_num_likes, 'num_loves':post_num_loves,
                    'num_wows':post_num_wows, 'num_hahas':post_num_hahas,
                    'num_sads':post_num_sads, 'num_angrys':post_num_angrys})


#[CODE 5]
def getFacebookReaction(post_id, access_token):

    base = "https://graph.facebook.com/v2.8"
    node = "/%s" % post_id
    reactions = "/?fields=" \
                "reactions.type(LIKE).limit(0).summary(total_count).as(like)" \
                ",reactions.type(LOVE).limit(0).summary(total_count).as(love)" \
                ",reactions.type(WOW).limit(0).summary(total_count).as(wow)" \
                ",reactions.type(HAHA).limit(0).summary(total_count).as(haha)" \
                ",reactions.type(SAD).limit(0).summary(total_count).as(sad)" \
                ",reactions.type(ANGRY).limit(0).summary(total_count).as(angry)"
    parameters = "&access_token=%s" % access_token
    url = base + node + reactions + parameters

    retData = get_request_url(url)

    if (retData == None):
        return None
    else:
        return json.loads(retData)

#[CODE 6]
def main():
    page_name = "jtbcnews"
    app_id = "App ID"
    app_secret = "App Secret Code"
    access_token = app_id + "|" + app_secret

    from_date = '2017-02-01'
    to_date = '2017-02-03'

    num_statuses = 10
    go_next = True
    jsonResult = []

    page_id = getFacebookNumericID(page_name, access_token)

    if (page_id == None):
        print ("[%s] %s is Invalid Page Name" % (datetime.datetime.now(), page_name))
        exit()

    print ("[%s] %s page id is %s" % (datetime.datetime.now(), page_name, page_id))

    #[CODE 6-1]
    jsonPost = getFacebookPost(page_id, access_token, from_date, to_date, num_statuses)

    if (jsonPost == None):
        print ("No DATA")
        exit()

    #[CODE 6-2]
    while (go_next):
        for post in jsonPost['data']:
            getPostData(post, access_token, jsonResult)

        if 'paging' in jsonPost.keys():
            jsonPost =  json.loads(get_request_url(jsonPost['paging']['next']))
        else:
            go_next = False

    #[CODE 6-3]
    with open('%s_facebook_%s_%s.json' % (page_name, from_date, to_date), 'w', encoding='utf8') as outfile:
        str_ = json.dumps(jsonResult,
                      indent=4, sort_keys=True,
                      ensure_ascii=False)
        outfile.write(str_)

    print ('%s_facebook_%s_%s.json SAVED' % (page_name, from_date, to_date))

if __name__ == '__main__':
    main()

[그림 4]는 코드를 수행하여 저장된 결과 값을 JSON 분석기를 이용하여 정상적으로 저장되었는지 확인한 모습이다.

[그림 4] 저장된 JSON 파일

이제 특정 포스트를 페이징 기법을 이용하여 선택한 기간 동안의 데이터를 가져오는 방법에 대하여 자세히 알아보도록 하겠다.

#[CODE 1] 특정 URL의 데이터를 얻어오기: get_request_url(url)
def get_request_url(url):

    req = urllib.request.Request(url)

    try:
        response = urllib.request.urlopen(req)
        if response.getcode() == 200:
            print ("[%s] Url Request Success" % datetime.datetime.now())
            return response.read().decode('utf-8')
    except Exception as e:
        print(e)
        print("[%s] Error for URL : %s" % (datetime.datetime.now(), url))
        return None

앞에서 작성했던 코드는 단순하게 main()으로만 구성되는 간단한 프로그램이었으나, 이번 절에서는 함수를 이용하여 코드를 좀더 명료하게 정리하였다. [코드 11]은 urllib.request를 이용하여 요청받은 데이터를 수신한다. 정상적으로 데이터를 수신한 경우 수신한 데이터를 ‘utf-8’ 형식으로 디코딩하여 반환하고 그렇지 않은 경우에는 ‘None’을 반환한다.

#[CODE 2] 페이스북 Page ID를 얻어오기
def getFacebookNumericID(page_id, access_token):

    base = "https://graph.facebook.com/v2.8"
    node = "/" + page_id
    parameters = "/?access_token=%s" % access_token
    url = base + node + parameters

    retData = get_request_url(url)

    if (retData == None):
        return None
    else:
        jsonData = json.loads(retData)
        return jsonData['id']
        return None

[CODE 2]는 5.2절에서 설명한 페이스북의 ‘page id’를 얻어오는 함수를 구성하였다. 정상적으로 데이터를 수신한 경우 ‘id’ 값을 반환하고 그렇지 않은 경우에는 ‘None’을 반환한다.

#[CODE 3] 페이스북 포스트 얻어오기
def getFacebookPost(page_id, access_token, from_date, to_date, num_statuses):

    base = "https://graph.facebook.com/v2.8"
    node = "/%s/posts" % page_id
    fields = "/?fields=id,message,link,name,type,shares,reactions," + \
             "created_time,comments.limit(0).summary(true)" + \
             ".limit(0).summary(true)"
    duration = "&since=%s&until=%s" % (from_date, to_date)
    parameters = "&limit=%s&access_token=%s" % (num_statuses, access_token)
    url = base + node + fields + duration + parameters

    retData = get_request_url(url)

    if (retData == None):
        return None
    else:
        return json.loads(retData)

[CODE 3]은 5.3절에서 설명한 기간별 포스트를 가져오는 함수이다. 정상적으로 데이터를 수신한 경우 JSON 형태의 값을 반환하고 그렇지 않은 경우에는 ‘None’을 반환한다.

def getPostItem(post, key):
    try:
        if key in post.keys():
            return post[key]
        else:
            return ''
    except:
        return ''

def getPostTotalCount(post, key):
    try:
        if key in post.keys():
            return post[key]['summary']['total_count']
        else:
            return 0
    except:
        return 0

#[CODE 4] 페이스북 포스트 세부 얻어오기
def getPostData(post, access_token, jsonResult):

    #[CODE 4-1]
    post_id = getPostItem(post, 'id')
    post_message = getPostItem(post, 'message')
    post_name = getPostItem(post, 'name')
    post_link = getPostItem(post, 'link')
    post_type = getPostItem(post, 'type')

    post_num_reactions = getPostTotalCount(post, 'reactions')
    post_num_comment = getPostTotalCount(post, 'comments')
    post_num_shares = 0 if 'shares' not in post.keys() else post['shares']['count']

    #[CODE 4-2]
    post_created_time = getPostItem(post, 'created_time')
    post_created_time = datetime.datetime.strptime(post_created_time, '%Y-%m-%dT%H:%M:%S+0000')
    post_created_time = post_created_time + datetime.timedelta(hours=+9)
    post_created_time = post_created_time.strftime('%Y-%m-%d %H:%M:%S')

    #[CODE 4-3]
    reaction = getFacebookReaction(post_id, access_token) if post_created_time > '2016-02-24 00:00:00' else {}
    post_num_likes = getPostTotalCount(reaction, 'like')
    post_num_likes = post_num_reactions if post_created_time < '2016-02-24 00:00:00' else post_num_likes

    #[CODE 4-4]
    post_num_loves = getPostTotalCount(reaction, 'love')
    post_num_wows = getPostTotalCount(reaction, 'wow')
    post_num_hahas = getPostTotalCount(reaction, 'haha')
    post_num_sads = getPostTotalCount(reaction, 'sad')
    post_num_angrys = getPostTotalCount(reaction, 'angry')

    jsonResult.append({'post_id':post_id, 'message':post_message,
                    'name':post_name, 'link':post_link,
                    'created_time':post_created_time, 'num_reactions':post_num_reactions,
                    'num_comments':post_num_comment, 'num_shares':post_num_shares,
                    'num_likes':post_num_likes, 'num_loves':post_num_loves,
                    'num_wows':post_num_wows, 'num_hahas':post_num_hahas,
                    'num_sads':post_num_sads, 'num_angrys':post_num_angrys})

[CODE 4]는 수신한 개별의 포스트 데이터에서 우리가 원하는 데이터를 JSON 형태로 저장하는 함수이다.

[CODE 4-1]은 JSON 아이템의 “name” 값과 그에 해당하는 “value”를 가져오기 위하여 getPostItem(post, key)라는 함수를 별도로 생성하였다. 우리가 포스트를 요청하며 전달했던 인자중에 레코드의 형태를 구성하지 아니하고 직접 가지고 올 수 있는 “name”들은 ‘id’, ‘message’, ‘name’, ‘link’, ‘type’, ‘created_time’ 이다.

[CODE 4-2]에서는 얻어온 ‘created_time’을 변환하는 식을 확인할 수 있다.

기본적으로 페이스북은 협정 세계시(UTC: Coordinated Universal Time) 형식을 사용한다. UTC는 그리니치 평균시(GMT: Greenwich Mean Tim)라고도 불리는데(실제로는 몇 초 차이가 난다) 우리가 사용하는 KST는 GMT(UTC)보다 9시간 빠른 시간을 가지므로 이에 맞게 데이터를 변환하여야 한다. 파이썬의 datetime.timedelta(hours=+9) 함수를 이용하여 수신한 데이터를 국내 시간으로 변환한다.

[CODE 4-3]은 페이스북의 좋아요 개수를 가져온다. 페이스북은 2016-02-24일을 기점으로 LIKE 이외에 감정을 나타내는 상태를 [그림 5]와 같이 6종류로 추가하였다.

[그림 5] 2015년 2월 추가된 이모티콘

이로 인해 [코드 15]와 같이 리액션을 해당 포스트 아이디를 이용하여 요청하고, 얻은 데이터를 바탕으로 하여 Like의 개수를 ‘2016-02-24 00:00:00’ 기준으로 비교하여 처리하여야 한다. 적용 이전의 데이터는 기존의 리액션의 개수가 Like의 개수와 동일하며, 이후 데이터의 경우에는 [CODE 5]를 이용하여 데이터를 가지고 온다. 리액션에 대한 필드 파라미터도 스택 오버플로우를 참고하였다.

#[CODE 5] 페이스북 Reaction 얻어오기
def getFacebookReaction(post_id, access_token):

    base = "https://graph.facebook.com/v2.8"
    node = "/%s" % post_id
    reactions = "/?fields=" \
                "reactions.type(LIKE).limit(0).summary(total_count).as(like)" \
                ",reactions.type(LOVE).limit(0).summary(total_count).as(love)" \
                ",reactions.type(WOW).limit(0).summary(total_count).as(wow)" \
                ",reactions.type(HAHA).limit(0).summary(total_count).as(haha)" \
                ",reactions.type(SAD).limit(0).summary(total_count).as(sad)" \
                ",reactions.type(ANGRY).limit(0).summary(total_count).as(angry)"
    parameters = "&access_token=%s" % access_token
    url = base + node + reactions + parameters

    retData = get_request_url(url)

    if (retData == None):
        return None
    else:
        return json.loads(retData)

해당 포스트의 리액션 JSON을 수신하면, 해당 reaction의 [‘summary’][‘total_count’]에 해당 값이 저장되어 있으며, 이를 편리하게 가져오기 위하여 getPostTotalCount(post, key) 함수를 구성하였다.

[CODE 4-4]는 나머지 리액션에 대한 값들을 가져오고, 이를 인자로 전달받은 jsonResult에 추가한다.

#[CODE 6] 페이스북 POST 얻어오기
def main():
    page_name = "jtbcnews"
    app_id = "App ID"
    app_secret = "App Secret Code"
    access_token = app_id + "|" + app_secret

    from_date = '2017-02-01'
    to_date = '2017-02-28'

    num_posts = 50
    go_next = True
    jsonResult = []

    page_id = getFacebookNumericID(page_name, access_token)

    if (page_id == None):
        print ("[%s] %s is Invalid Page Name" % (datetime.datetime.now(), page_name))
        exit()

    print ("[%s] %s page id is %s" % (datetime.datetime.now(), page_name, page_id))

    #[CODE 6-1]
    jsonPost = getFacebookPost(page_id, access_token, from_date, to_date, num_posts)

    if (jsonPost == None):
        print ("No DATA")
        exit()

    #[CODE 6-2]
    while (go_next):
        for post in jsonPost['data']:
            getPostData(post, access_token, jsonResult)

        if 'paging' in jsonPost.keys():
            jsonPost =  json.loads(get_request_url(jsonPost['paging']['next']))
        else:
            go_next = False

    #[CODE 6-3]
    with open('%s_facebook_%s_%s.json' % (page_name, from_date, to_date), 'w', encoding='utf8') as outfile:
        str_ = json.dumps(jsonResult,
                      indent=4, sort_keys=True,
                      ensure_ascii=False)
        outfile.write(str_)

    print ('%s_facebook_%s_%s.json SAVED' % (page_name, from_date, to_date))

[CODE 6]은 페이스북 포스트를 얻어오기 위한 main()함수이다. 먼저 [CODE 6-1]에서는 지정한 얻어온 ‘page_id’를 이용하여 해당 페이지를 요청한다. 이 때 검색한 데이터가 ‘num_posts’의 숫자보다 많은 경우에는 ‘paging’ 속성을 가지게 된다.

[CODE 6-2]에서는 수신한 JSON 데이터를 반복하면서 다음 페이지가 있는 경우에는 해당 URL을 얻어와 데이터를 요청하며 반복하다 더 이상의 “paging”의 “value”가 없으면 반복을 종료한다.

[CODE 6-3]은 앞에서 반복을 하며 수신한 포스트 들이 JSON 형태로 저장된 jsonResult를 json.dumps()를 이용하여 저장한다. 파이썬은 기본적으로 ASCII 형식의 인코딩을 사용한다. 우리가 코드에서 # -- coding: utf8 --을 선언한다고 하여 모든 값들이 ‘utf-8’ 형식을 가지는 것은 아니며 작성한 코드가 utf-8 형식을 사용한다고 선언하는 것이다. 당연히 코드내에서 사용한 변수명이나 상수값들은 utf-8 형식을 가지게 되지만, 외부로부터 수신한 데이터의 경우에는 UTF-8의 형식을 제공하지 않는 경우가 많다. 더군다나 한글 윈도우에서는 기본적으로 CP949 형식을 사용하므로 이에 대한 변환이 세심하게 요구된다.

4. 정부3.0 공공 데이터 포털 API 사용하기

Fri, 05 Jan 2018 04:01:00 +0000

4. 정부3.0 공공 데이터 포털 API 사용하기

2011년 정부는 ‘국가공공데이터포털(http://www.data.go.kr)’이란 국가 공공 정보 사이트를 구축하고 공공 정보 31만 건을 공개한 이후 각 부처가 경쟁적으로 데이터 공개를 시작하였다. 물론, 그 이전에도 데이터를 제공하는 정부 부처가 있었으나 포털(portal)의 형태로 한꺼번에 유관 부처의 공개 데이터를 찾아볼 수 있게 되어 데이터를 공부하거나 상업적으로 사용하는데 편의성을 제공한다.

공공 데이터는 특별한 제약 없이 사용할 수 있는데 초기 개발시에는 일일 데이터 조회 제한이 있는 “개발계정”을 활용하다가 서비스가 완성되면 “활용신청”을 통해 데이터 조회 제한 횟수를 증가시킬 수 있다(실제 필자는 활용신청을 해보지 않아 어느 정도까지 되는지는 관련 부처에 문의하기 바란다).

4.1 4.1 공공 데이터 포털 가입

공공정보를 활용하기 위해서는 먼저 공공 데이터 포털에 가입을 해야 한다. 포털 페이지(https://www.data.go.kr)를 방문하면 [그림 1]과 같이 각종 관심분야에 해당하는 데이터를 조회하고 다운로드 받을 수 있는 화면이 나타난다.

[그림 1] 공공 데이터 포털 초기 페이지

페이지 상단의 [회원가입]을 선택하여 [그림 2]와 같은 가입페이지로 이동한다.

[그림 2] 회원 가입 페이지

회원 가입은 “일반회원”과 “기관회원”으로 분리된다. “일반회원” 하단의 “가입하기”를 선택하면 [그림 3]과 같이 회원 가입 여부를 확인하는 창이 나타난다.

[그림 3] 회원가입 STEP 1

이름과 이메일 주소를 입력하고 [가입 확인] 버튼을 누르면 [그림 4]와 같이 회원 약관 동의 화면이 나타난다.

[그림 4] 회원 약관 및 개인정보 수집 동의

매번 사이트에 가입을 하면서 느끼는 거지만, 동의하지 않으면 사용할 수 없게 하는 서비스이면서 왜 자꾸 물어보는지 모르겠다. 체크 박스에 동의하고 [동의] 버튼을 누르면 [그림 5]와 같이 가입자 정보를 입력하는 화면이 나온다.

[그림 5] 가입자 기본 정보 입력

가입 등록 항목 중 “인증서 등록” 항목이 있는데 추후 로그인 시 인증서를 사용하고자 하는 경우에 사용할 인증서를 등록할 수 있다. 물론 아마 이 글을 읽는 독자중에 인증서를 등록하는 분은 없으리라 생각한다.

이메일을 입력한 후 인증하기 버튼을 누르면 입력한 이메일로 인증코드가 전달된다. 일반적으로 요즘은 이메일과 전화번호 문자메시지 인증을 동시에 하고 있는데, 이메일로만 끝나게 되어 있어서 나름 편안하게 만들어 놓았다.

필수 사항(* 표시 항목)을 입력한 후 [완료] 버튼을 누르면 가입이 완료되고 회원 가입이 완료되었다는 화면이 [그림 6]과 같이 회원 가입 완료 페이지가 나타난다.

[그림 6] 회원 가입 완료 페이지

이건 개인적인 느낌이지만 공공 데이터 포털의 경우 가입 절차가 이메일 인증 한번으로 끝나게 구성되어 정부에서 제공하는 서비스 포털이 아닌 것 같은 느낌이 든다. 기본적으로 깔아야 하는 프로그램이 수십개에 이르는 포털에 비하면 공공 데이터 포털은 개발자를 위한 사이트여서 그런지, 아니면 공공성을 강조하기 위해서인지 편리함을 느낀다. [로그인] 버튼을 누르면 [그림 37]과 같이 로그인 화면이 나타난다.

[그림 7] 공공 데이터 포털 로그인 화면

가입한 아이디와 비밀번호를 입력한 후 [로그인] 버튼을 누르면 비로서 공공 데이터 포털의 데이터를 마음대로 쓸 수 있는 권한을 얻게 된다. [그림 8]은 로그인 후 계정이 활성화 되어 상단에 [마이 페이지]가 나타난 것을 확인할 수 있다.

[그림 8] 로그인 후 “마이페이지” 활성화

우리는 공공 정보 데이터를 수집하여 Part 4.에서 상관 관계 분석을 해 보려고 한다. 상관분석을 위한 데이터 셋으로 외국인의 입국 숫자에 따른 관광지 입장 수를 사용하려고 한다. [그림 8] 상단에 위치한 검색창에 “출입국 관광 통계 서비스”를 입력한 후 검색하면 [그림 9]와 같이 검색 결과를 확인할 수 있다.

[그림 9] 출입국 관광 통계 서비스 검색 결과

검색 결과는 크게 3가지 분류로 나타난다. “파일 데이터”는 엑셀, HWP, CVS 등 파일 형식으로 저장되어 있는 데이터로 바로 다운로드 받아서 활용할 수 있다. 파이썬에서 엑셀 파일을 열고, 검색할 수 있으면 편리하게 사용할 수 있는 장점이 있지만, 과거 데이터인 경우가 많아 실시간성을 반영하기는 어렵다.

오픈 API는 각 기관의 서버에서 REST API를 이용하여 직접 데이터를 요청하고 수신할 수 있다. 결과값은 XML과 JSON 형태로 제공해 주므로 편리한 형식으로 사용하면 된다. 그러나 실제 오픈 API의 경우에도 실시간성을 반영하기 보다는 제공 기관이 주기별로 업데이트하는 데이터가 제공된다고 볼 수 있다.

만약 공공 데이터를 이용하여 웹 서비스등을 사용하려고 한다면 자체 데이터 베이스에 저장을 하고 주기적으로 데이터를 쿼리하거나, 배치 프로그램으로 만들어서 분기별로 데이터를 검색하는 것이 효율적일 것이다.

표준데이터는 공공데이터 개발 표준 데이터 속성정보를 따르며, 각 지자체나 단체에서 제공하는 데이터를 표준 형태로 재 가공한 데이터이다. 표준 속성을 따르기 때문에 REST의 End Point만 변경하면서 데이터를 가지고 오면 편리하게 프로그래밍할 수 있는 장점이 있다.

“오픈 API” 검색 결과를 선택하면 [그림 10]과 같이 자세한 정보를 확인할 수 있다.

[그림 10] 출입국 관광 통계 서비스 활용 신청

각 오픈 API는 제공 형식의 아이콘이 있는데 [XML]이라고 표시되어 있는 경우에는 거의 [JSON]형식도 함께 제공하는 것으로 보여진다. 또한 연관 데이터 셋은 자체적으로 지자체에서 제공하는 데이터이다. “출입국관광통계서비스” 우측의 [활용신청] 버튼을 클릭하면 [그림 11]과 같이 개발 계정 신청 창이 나타난다.

[그림 11] 개발 계정 신청

화면의 “기본정보” 사항에 보면 “심의여부”가 “즉시”라고 표기되어 있는 것을 확인할 수 있다. 심의여부가 “즉시”인 경우에는 신청과 동시에 사용이 가능한 데이터이다. 일부 데이터의 경우에는 심사가 필요한 경우가 있고, 관련 서류를 제출해야 하는 경우가 있다.

“시스템 유형”은 “일반”과 “서버구축”으로 분리된다. “일반”을 선택하는 경우에는 자체 데이터베이스에 저장을 하지 않는 경우이고 “서버구축”을 선택하는 경우에는 수신한 데이터를 자체 데이터베이스에 저장한다는 것을 의미한다.

우리는 출입국 관광 통계를 사용할 예정이므로 맨 하단의 “출입국관광통계”를 선택한 후 “저작권 표시”에 동의한(일반적으로 공공 데이터 포털의 데이터를 서비스에 사용하는 경우에는 자료의 출처를 서비스시에 밝혀야 한다) 후 [신청] 버튼을 누르면 [그림 12]와 같이 바로 승인이 이루어진 것이 확인할 수 있다.

[그림 12] 공공 정보 데이터 신청 및 활용 상태 확인

만약 심의가 필요한 경우에는 “반려”와 “보류”의 상태를 확인할 수 있으며, 크게 위법의 소지가 없는 경우에는 승인을 해주는 경향이다(실제 승인시 전화 한 통화 정도 하는 경우도 있고 나중에 잘 쓰고 있냐고, 어디에 쓰고 있냐고 물어보는 연락이 오곤 한다).

앞에서 “출입국관광통계서비스”와 같은 형식으로 검색 창에서 “관광자원통계서비스”를 검색하여 신청한다. [그림 13]은 두 개의 서비스 신청이 완료된 화면을 나타낸다.

[그림 13] 개발 계정 확인

서비스가 계정이 발급된 항목 중 “관광자원통계서비스”를 클릭하면 [그림 14]와 같이 개발 계정에 대한 접근 “End Point”와 “일일 트래픽” 제한 사항들을 확인할 수 있다.

[그림 14] 관광자원통계서비스 개발 계정 상세 정보

화면 하단의 [개발 가이드]를 클릭하면 전달 파라미터와 회신 인자에 대한 자세한 매뉴얼을 제공해 준다. 우리는 Part 2. 에서 파이썬을 이용하여 해당 데이터를 가지고 오는 방법에 대해 알아볼 떄 본 자료를 활용할 예정이다. 상단 오른쪽의 [일반 인증키 받기]를 클릭하면 [그림 15]와 같이 키가 발급되고 서비스에 접속할 수 있는 End Point와 키를 확인할 수 있다.

[그림 15] 일반 인증키의 발급

공공 데이터 포털을 관심있게 살펴보면 의외로 웹이나 모바일 서비스로 활용할 수 있는 자료들이 많이 있는 것을 발견할 수 있을 것이다. 검색창을 이용하면 다양한 데이터가 존재하고 있는 것을 확인할 수 있으니, 많이 활용하기를 바란다(실제로 검색을 해보면 파일의 다운로드 수와 활용 신청건수를 확인할 수 있다. 서비스 기획을 할 때 이 숫자를 유심히 관찰해 보는 것도 도움이 될 것 이라 생각된다.)

3. NAVER API 사용하기

Fri, 05 Jan 2018 04:01:00 +0000

3. 네이버(Naver) API 사용하기

이 블로그를 읽는 독자중에 네이버 아이디가 없는 사람은 아마 없을 것이므로 네이버 API를 활용하기 위한 과정에 대하여 설명하도록 하겠다. 먼저 개발자 계정을 얻기 위하여 네이버 개발자 페이지(http://developer.naver.com)로 이동한다.

[그림 1]은 네이버 개발자 페이지이다.

[그림 1] 네이버 개발자 페이지(http://developer.naver.com)

상단 메뉴의 [API 소개] -> [검색]을 선택하면 [그림 2]와 같이 네이버 검색 API 소개 페이지로 이동한다.

[그림 2] API 사용을 위한 애플리케이션 등록

하단으로 이동하여 [오픈 API 이용신청]을 선택하면 이용약관에 동의한 후 [확인] 버튼을 누르면 [그림 3]과 같이 API를 사용하기 위한 약관에 동의를 요청하는 화면이 나온다.

[그림 3] API 이용 약관 동의

하단으로 이동하여 이용약관에 동의하고 [확인]버튼을 누르면 [그림 4]와 같이 작성할 애플리케이션의 이름을 요청하는 화면이 나타난다.

[그림 4] 애플리케이션 등록(API 이용신청)

애플리케이션의 이름과 사용 API를 선택한다. 우리는 네이버 뉴스나 블로그의 기사를 검색할 목적으로 활용할 것이므로, [검색]을 선택한다(추후 관리페이지에서 다른 API를 추가할 수 있다). 사용 API를 선택하면 [그림 5]와 같이 해당 서비스를 제공할 도메인을 설정하도록 요구한다.

[그림 5] 비로그인 오픈 API 서비스 신청

본 사이트에서는 크롤러를 만들고, 수집한 데이터를 분석하여 서비스한다는 전제하에 [WEB 설정]을 선택하고, 웹 서비스 URL을 입력한다. 아직 서비스할 도메인이 지정되어 있지 않기 때문에 http://localhost를 지정한다. 입력을 완료한 후 [등록하기] 버튼을 누르면 [그림 6]과 같이 신규 애플리케이션이 등록된 것을 확인할 수 있다.

[그림 6] 신규 애플리케이션의 등록 완료

신규 애플리케이션을 위하여 ‘Client ID’와 ‘Client Secret’이 발급되었으며, ‘Client Secret’ 정보는 [보기] 버튼을 누르면 문자열로 변환되어 나타난다.

2. Twitter API 사용하기

Fri, 05 Jan 2018 03:01:00 +0000

2. 트위터(Twitter) API 사용하기

트위터(Twitter)는 미국 샌프란시스코 지역의 팟캐스트 업체인 오데오(Odeo, Inc.)의 에번 윌리엄스와 노아 글래스가 시작한 연구 프로젝트의 산출물이다. 기존의 단문 문자 서비스(SMS: Short Message Service)를 편리하게 사용하여 소규모 그룹내에서 소통하고자 하였으며 이를 위하여 SMS와 유사한 트윗(tweets)이라 불리우는 단문 메시지와 유사한 방식을 설계하였다.

트위터의 글은 블로그와 같이 장문의 형태를 허용하는 것이 아니라 미국의 SMS를 수용할 수 있도록 설계되어 최대 140자의 내용을 올릴 수 있다(실제 미국의 SMS는 160자를 지원하고 있지만, 트윗에서는 사용자의 아이디등을 입력하기 위하여 140자를 사용할 수 있다).

전송된 트윗은 사용자의 프로필 페이지에 표시되며 서로 연결된 사용자에게 전달된다. 전송방법으로는 RSS(Rich Site Summary: 뉴스나 블로그 사이트에서 활용하는 콘텐츠 방식으로 전문의 내용을 전송하는 것이 아니라 요약된 정보만을 제공하는 형식), 전용 클라이언트인 트윗덱(TweerDeck), 트위티(Tweetie)등이 다양하게 사용된다.

트윗이 업데이트 되는 경우에는 그 사용자를 따르는(팔로우: Follow) 다른 사용자에게 즉시 전송되어 관심사를 함께 공유할 수 있어 실시간 대화와 유사한 방식으로 활용되고 있다.

2.1 트위터 가입

트위터에 가입하기 위하여 트위터 홈페이지(https://twitter.com)에 접속하면 [그림 1]과 같이 초기 화면이 나타나고 오른쪽 상단에 [가입하기] 버튼이 활성화 되어 있다.

[그림 1] 트위터 사용자 가입 페이지

[가입하기] 버튼을 누르면 [그림 2]와 같이 간단한 신원 정보를 확인한다

[그림 2] 트위터 가입 정보 입력

이름, 휴대폰 또는 이메일 주소와 비밀번호를 입력한다. 트위터의 경우에는 사용자 계정을 활성하기 위하여 본인 인증을 이메일 또는 휴대전화 번호를 사용하므로 자신이 수신 받을 수 있는 정확한 정보를 입력하여야 한다. 정보를 입력한 후 [가입하기] 버튼을 누르면 [그림 3]과 같이 휴대전화 번호를 요청한다.

[그림 3] 휴대전화번호 입력

휴대 전화번호의 경우 계정에 대한 인증을 SMS를 이용하여 보안성을 조금더 확보할 수 있는 장점을 가지고 있으나, 트위터만 사용하게 되는 경우 개인 정보에 민감한 사용자는 건너뛰어도 상관없다. 그러나 앱을 등록하기 위해서는 트위터 계정에 휴대전화번호가 기입되어 있어야 한다. 만약 이 단계에서 입력하지 않은 경우에는 등록 후 개인 정보 설정에서 추가할 수 있다. [다음] 버튼을 누르는 경우에는 정확한 휴대전화 번호 형식을 입력하여야 하며, 입력하지 않는 경우에는 하단의 “건너뛰기” 링크를 클릭하면 [그림 4]와 같이 사용자 아이디를 선택하는 화면이 나타난다.

[그림 4] 트위터에서 사용할 사용자 아이디 입력

본인 인증을 위해 사용하는 이메일 주소 또는 휴대전화번호는 변경이 불가능하지만 사용자 아이디의 경우에는 나중에 중복되지 않는 사용자명이면 언제든지 변경할 수 있다. 중복되지 않는 아이디를 선택한 후 [다음]을 클릭하면 [그림 5]와 같이 기본 정보가 입력된 사용자 계정이 등록된다.

[그림 5] 트위터 가입 완료

재미있는 것은 영문으로 사용자명을 입력하였는데 트위터에서 한글로 변경하여 표시한다. [시작해볼까요?]를 클릭하면 관심사등을 기반으로 하여 추천 트위터나 팔로워(follower)등을 설정할 수 있는 기능을 제공하지만 개발자 계정 확보와는 상관없으므로 관심있는 독자는 추가 설정을 하기 바란다. 계정의 완전한 활성화를 위하여 가입시 입력한 메일을 확인하면 [그림 6]과 같이 활성화를 위한 링크가 포함된 메일이 수신된 것을 확인할 수 있다.

[그림 6] 트위터 가입 완료를 위한 계정 활성화 메일

수신한 메일의 [지금 확인하기] 버튼을 누르면 트위터의 모든 계정 설정이 완료되고 [그림 7]과같이 생성된 트위터의 메인 페이지로 이동한다.

[그림 7] 생성된 트위터 계정

이제 기본적인 트위터 계정이 생성되었으므로 개발자 계정을 얻도록 한다. 개발자 계정에 가입하고 신규 앱을 작성하면 트위터에서 제공해 주는 API를 사용할 수 있다.

2.2 트위터 앱 등록

트위터 앱 등록하기 위하여 트위터 개발자 페이지(https://dev.twitter.com/)로 이동하면 개발자 초기 화면이 [그림 8]과 같이 나타난다.

[그림 8] 트위터 개발자 홈페이지

상단의 메뉴중에 [My App]을 선택하면 [그림 9]와 같이 내가 등록한 앱을 관리할 수 있는 화면으로 이동한다.

[그림 9] 앱 관리 화면

현재 어떠한 트위터 앱도 등록하지 않은 상태이므로 화면 중간에 [Create New App]이라는 버튼만 보일 것이다. 이제 새로운 앱을 위하여 [Create New App]을 선택하면 [그림 10]과 같이 앱 등록 화면이 나타난다.

[그림 10] 트위터 앱 신규 등록 화면

신규 앱을 생성하기 위하여는 기본적으로 다음과 같은 사항을 입력하여야 한다.

항목	내용
Name	트위터 앱의 고유 이름(중복되지 않는 이름)
Description	앱의 간단한 설명(최소 10자 이상 200자 이하)
Website	개발한 정보를 가지고 있는 웹 사이트. 초기에는 URL 형식에 맞추어 입력하면 상관없다
Callback URL	OAuth 인증시 인증 결과를 반환 받을 URL. 우리는 웹 서비스가 아닌 클라이언트 프로그램을 제작하므로 입력하지 않아도 된다

개발자 동의 내용을 확인한 후 체크하고 [Create Your Twitter Application]을 선택하면 [그림 22]와 같이 신규 앱이 등록된 것을 확인할 수 있다.

[그림 11] 트위터 앱 등록 완료

정상적을 앱이 등록된 경우 앱의 커스터머 키(Customer Key)라고 불리는 ‘API Key’가 발급된다(발급 키의 내용은 각자 다르게 나타날 것이다). 실제 앱에서 트위터의 API를 사용하기 위해서는 ‘API Key’ 와 커스터머 시크릿(Customer Secret)이라 불리는 비밀번호인 ‘API Secret’키 의 쌍이 필요하다. ‘manage keys and access tokens’라는 ‘API Key’ 우측의 링크를 클릭하거나 상단 탭의 [Keys and Access Tokens]를 클릭하면 [그림 12]와 같은 키 관리 화면이 나타난다.

[그림 12] 앱의 ‘API Key’ 및 ‘API Secret’의 발급 확인

‘API Key’와 ‘API Secret’은 해당 앱이 API에 접근할 수 있는 중요한 키값으로 외부로 유출이 되었을 경우에는 악용될 수 있는 소지가 있다. 이에 트위터에서는 ‘API Key’와 ‘API Secret’을 재생성 할 수 있게 도와주며, 변경되는 경우 기존의 앱은 더 이상 트위터 API를 사용할 수 없게 된다.

트위터는 OAuth 인증 방식을 사용하기 때문에 기본적으로 트위터에 접근하기 위한 토큰 값을 요구한다. 일반적으로 웹(Web) 어플리케이션의 경우에는 Callback URL(돌아오는 URL?)을 지정하면, 인증 로그인 창을 띄운 후 정상적인 인증이 되어 있을 때 Callback URL 화면으로 자동 이동하게 된다. 그러나 클라이언트 어플리케이션의 경우에는 웹 페이지를 띄워 아이디, 비밀번호 등을 넣고 인증을 거쳐 Token을 가지고 오기에는 불편하기에 트위터에서는 Access Token 인증을 위한 ‘key’와 ‘secret’을 제공하여 준다. 하단의 [Create my access token]을 클릭하면 [그림 13]과 같이 토큰이 발급된 것을 확인할 수 있다.

[그림 13] 억세스 토큰(Access Token)의 발급

‘Access Token / Secret’ 역시 ‘API Key / Secret’과 같이 유출된 경우 재 발급이 가능하나, 가급적이면 관리에 신경 쓰는 것이 좋다. 이제 트위터를 검색하기 위한 기본적인 설정이 끝났다. 우리는 이번 절에서 트위터에 가입하고, 트위터 앱을 하나 등록한 후 트위터 API에 접근하기 위한 ‘API Key / Secret’ 및 ‘Access Token / Secret’을 발급받았다.

1. Facebook API 사용등록

Fri, 05 Jan 2018 02:01:00 +0000

1. Facebook API 사용등록

페이스북(Facebook)은 하버드 대학교의 학생이었던 마크 저커버그가 2003년에 페이스매시(Facemash)라는 이름으로 시작하여 2004년 2월 “더 페이스북(TheFaceBook)”이라는 이름으로 본격적인 서비스를 시작하였다. 서비스 초기에는 하버드 대학내의 학생들이 서로의 개인 정보와 글, 동영상 등을 상호 교류하는 인맥 서비스(Social Network Service)를 목적이였으며 스탠퍼드, 컬럼비아 및 예일 대학으로 서비스를 확대하고 그 이후 미국 전역의 대학으로 서비스가 확장되면서 현재 전세계적으로 가장 많이 사용하고 있는 서비스이다.

서비스 주요 기능으로는 뉴스피드, 타임라인 등이 있다.

1) 뉴스 피드(News Feed)

뉴스 피드는 사용자의 친구, 내가 읽은 기사중 ‘좋아요’를 선택한 페이지의 소식을 시간순으로 서비스 한다. 뉴스피드에 나타나는 소식의 중요도는 절대로 시간순이 아니라 페이스북에서 자체 개발한 알고리즘에 의하여 배치 순서가 결정되는데 이에 대한 기준은 기업 비밀로 관리되고 있다.

2) 타임 라인(Time Line)

사용자가 게시하는 사진, 글 및 동영상등을 실시간, 시간순으로 보여주는 서비스이다. 뉴스피드에 있는 대부분의 소식은 사용자의 친구들 또는 ‘좋아요’를 선택한 페이지 이지만 타임라인은 자신이 올린글을 서비스한다.

페이스북은 가입시에 성별, 생년월일 등을 반드시 입력하여야 하며, 이를 통해 개인 페이지가 만들어지게 되어 일정의 마이크로 블로그(micro blog)의 형식을 가지게 된다. 이제 페이스북에 가입하고 개발자 앱 ID를 생성하는 방법을 알아보자. 만약 페이스북의 계정을 가지고 있는 사용자라면 1.1절은 스킵하고 1.2로 이동하기 바란다.

1.1 페이스북 가입

페이스북은 개인 페이지를 생성하게 되므로 가입시 개인 정보를 입력하여야 한다. 먼저 페이스북 홈페이지(http://www.facebook.com)으로 이동하면 가입 페이지가 [그림 1]과 같이 나타난다.

[그림 1] 페이스북 사용자 가입 페이지

자신의 성과 이름, 휴대폰 번호 또는 이메일과 비밀번호, 생일과 성별을 입력하고 [계정 만들기] 버튼을 클릭하면 [그림 2]와 같이 사용자 이용약관 페이지가 나타난다.

[그림 2] 이용 약관 및 보안 코드 입력

이용약관 및 개인정보 처리 방지 지침에 대한 동의를 하고, 보안 확인 코드 문자열을 넣어준 후 하단의 [가입하기] 버튼을 클릭하면 보안코드 입력 페이지가 [그림 3]처럼 나타난다.

[그림 3] 보안 코드 입력

보안 코드를 입력하기 위하여 가입시 사용한 이메일을 확인한다. 만약 전화번호를 사용하였다면 인증 코드가 해당 전화번호 문자메시지로 발송된다

[그림 4] 보안 코드 수신 확인

이메일이나 문자로 수신한 보안코드를 [그림 3]의 입력창에 넣은 후 [계속] 버튼을 클릭하면 [그림 5]와 같이 정상적으로 등록된 것을 확인할 수 있다.

[그림 5] 페이스북 로그인 완료

이제 기본적으로 페이스북에 계정이 생성되었으므로 개발자 계정을 얻도록 한다. 개발자 계정이란 서비스를 제공하는 업체에서 서비스를 이용하여 편리한 제 3의 프로그램(3rd party solution)을 제작하는데 편리한 기능을 제공해 주는 API(Application Program Interface)를 사용할 수 있도록 허락하는 것이다.

개발자 계정을 얻기 위하여 페이스북 개발자 페이지(http://developer.facebook.com)을 접속하면 [그림 6]과 같이 개발자 페이지로 이동할 수 있다.

1.2 Facebook API 사용등록

[그림 6] 페이스북 개발자 페이지

이미 페이스북에 계정을 만들고 로그인을 하였으므로 브라우저에 쿠키가 남아 있어 자동으로 로그인된 상태임을 확인할 수 있다. [그림 6]의 하단에 보면 페이스북에서 제공해 주는 Facebook 로그인, Facebook에서 공유하기 등의 바로가기 메뉴 뿐만 아니라 제공해주는 모든 서비스를 확인할 수 있다.

우리의 목적은 페이스북의 내용을 크롤링(Crawling)하는 것이 목적이므로 새로운 앱(App)을 하나 등록하기로 한다. 화면 상단의 [내 앱] 부분을 클릭하면 다음과 같이 새로운 앱을 만들 수 있는 메뉴가 나타난다.

[그림 7] 새 앱 추가 선택하기

[새 앱 추가]를 선택하면 [그림 8]과 같이 “새 앱 ID 만들기” 창이 나타난다.

[그림 8] 새 앱 ID 만들기

표시이름은 앱의 고유 이름으로 다른 사람이 사용하지 않는 고유 이름이여야 한다. 카테고리중 마음에 드는 부분을 선택하고 [앱 ID 만들기]를 선택하면 [그림 9]와 같이 보안 코드를 입력하라는 창이 나타난다.

[그림 9] 보안 코드 입력

보안 코드를 입력한 후 [제출]버튼을 클릭하면 [그림 10]과 같이 사용할 제품에 대한 설정 페이지로 이동한다.

[그림 10] 사용할 App의 제품 설정 페이지

[그림 10]의 왼쪽 상단에 보면 입력한 App의 이름이 나타나면 정상적으로 서비스 생성이 완료된것이다(필자는 snsCrawler라고 App 표시 이름을 만들었다). 페이스북은 자신들이 서비스하는 거의 모든 내용에 대한 접근을 허용하는 서비스 API를 제공해 준다. 다양한 형태의 서비스가 있지만, 일단 화면 왼쪽 메뉴의 [대시보드]를 선택하면 [그림 11]과 같이 만들어진 앱의 기본 정보를 확인할 수 있다.

[그림 11] 새로운 앱(snsCrawler) 생성

생성된 앱의 ID와 시크릿 코드([보기] 버튼을 누르면 복사할 수 있는 텍스트 형태로 나타난다)는 제작할 크롤러에서 사용되게 되므로 기억하여야 하며, 다른 사람에게 노출될 경우 악용될 수 있기 때문에 잘 보관하여야 한다. 우리는 단순하게 페이지를 크롤링하기 때문에 별도의 제품을 추가할 필요는 없으며 기본 설정으로 페이스북에 접근할 권한을 획득하였다.

BigData & SNS

Fri, 05 Jan 2018 01:01:00 +0000

BIGDATA와 SNS(Social Network Service)

[그림 1] BIGDATA와 SNS

최근들어 4차 산업 혁명과 인공지능(AI, 딥러닝: Deep Learning), 빅 데이터(Big Data)라는 용어는 산업계 전반에서 너무 일반적이고 유행처럼 번지고 있다. 4차 산업혁명이라는 용어는 기존의 컴퓨터 중심의 산업혁명을 벗어나 수평적, 협업적 생태계를 구축하는 조금은 새로운 패러다임이라 할 수 있지만 인공지능은 90년대 후반 한차례의 유행이 있었고 빅데이터는 데이터마이닝(Data Mining)이라는 용어로 과거부터 존재해 오고 있었다.

사실 IT 업계에 종사하는 사람들은 신조어를 만들어 내는데 익숙하다. 과거의 그룹웨어가 인터넷 환경으로 바뀌면서 동일한 기능을 수행하는 인트라넷(Intranet)으로 변모하였고 모든 기업은 인트라넷과 홈페이지를 구축하지 않으면 사업에서 도퇴되고 후진(?)기업이라고 판단, 수 많은 돈을 투자하였다. 이로 인해 많은 거대 기업이 생기고 유행이 지남과 동시에 쇄락의 길을 걸었음을 모두 기억하고 있을 것이다.

마찬가지로 인공지능과 빅데이터라는 말도 이제 유행의 정점에 올라서 있는것 같고 잠시후 죽음의 골자기(Death Valley)를 향해 달려가게 될 것이다. 물론, 이 상황에서 승리하는 플레이어는 적어도 수에서 수십년간 시장 독식을 하는 지위를 차지하게 될 것이다(아마존과 구글이 그러했던것 처럼).

과거 MIS(Management Information System) 구축 시절부터 가장 핵심적으로 이야기하던 부분이 Data와 Information의 차이이다. Data는 자체적으로 큰 의미를 가지지 못한다. 물론 하나의 값이 중요한 고장이나 중요한 의미를 가질 수 있을지 모르겠지만 데이터는 단순한 하나의 숫자 또는 자료에 불과하다. 우리는 이러한 데이터를 가공하여 정보(Information)라는 의미를 가질수 있는 데이터(?)로 가공하고 이를 사용자에게 제공하는 것이 필요하다.

정보의 특성은 영속성을 가질 수 있는것과 그렇지 않은 것으로 분리된다. 영속성을 가지는 정보란 역사적 사실과 같이 변화지 않는 것이 될 것이다. 그러나 대부분의 정보는 시간이 지나면서 무의미하거나 존재의 가치가 희석되게 된다. 특히 요즘 대세인 SNS(Social Network Service)의 경우에는 그 정보가 한시적이며 휘발성을 가지고 있다(한때 유행이었던 등갈비집은 수많은 프렌차이즈가 난립하며 유행하였지만 한순간에 사라져버렸다. 그러한 맛집 정보는 유행에 따라 정보의 가치가 올라갔지만 가계의 폐업이나 유행이 지나감으로써 무의미한 정보가 된다).

Socail Network 사용 현황

[그림 2] BIGDATA와 SNS

전 세계적으로 많이 사용하고 있는 SNS 프로그램은 약 5개 정도로 [그림 2]와 같이 사용자 분포를 가지고 있다. 데이터를 수집하려고 하는 지역에 따라 어떤 프로그램이 사용되고 있는지 참고하기 바란다.

Socail Data Flow

[그림 3] SNS 데이터의 속성

SNS를 통하여 수집되는 데이터는 [그림 3]과 같은 속성을 가진다. 일반적으로 생성되는 데이터들은 단기(instant) 속성을 가지므로 유행이 민감한 정보등을 분석할 때 유효하게 사용할 수 있다. 또한 비슷한 경향을 가진 사람들끼리 팔로우(Follow) 하거나 좋아요(like)등을 누르게 되므로 유사성 분석을 통하여 추천(Recommendation) 서비스 등의 정보로 활용 가능하다.

데이터 수집(Crawling)과 처리

[그림 4] SNS 데이터의 수집과 처리

인터넷 상에 산재해있는 데이터를 수집하기 위하여 우리는 크롤러(Crawler)를 구성하게 되고, 수집한 정보는 데이터 베이스 또는 HDFS(Hadoop File System)에 저장하게 된다.

저장된 데이터는 검색의 효율성을 높이기 위하여 인덱싱(Indexing) 과정을 거치게 되고 , 이러한 데이터를 가공하여 축약된 정보DB(Mart DB)를 생성한다. 이후 이 정보를 이용하여 사용자에게 효율적으로 보여주기 위해 시각화(Visualizatino) 과정을 거쳐 인포그래픽(Infographic-정보를 포함한 그래픽)으로 최종적으로 생성해 내는 것이 빅데이터의 수집, 분석, 시각화 과정이다.

데이터 수집(Crawling) 규칙

인터넷 상에 존재하는 데이터는 누군가의 노력으로 생산되어진 저작권을 가지고 있는 자료로 취급되어야 한다. 초창기 인터넷 사용자는 “Internet is Free”라고 외치며 저작권에 대해 무관심하려는 의도를 보여왔다. 그러나 컨텐츠 생산자가 자유로운 사용을 허락하지 않는 이상 그 저작권은 생산자에게 귀속되며 우리는 이를 조심하게 사용하여야 한다.

일반적으로 저작권 법상 크롤링 또는 자료의 사용에 대해 허용하는 범위는

1) 단순 링크 : 사이트 대표 주소를 링크로 명기하고 클릭시 이동하는 형태 2) 직접 링크 : 특정 게시물을 링크하는 경우

이며 위반 사항으로는

1) 프레임 링크 : 저작물의 일부를 홈페이지에 프레임 형태로 넣어 마치 자신이 서비스하는 것처럼 보이는 행위 2) 임베드 링크 : 저잘물 전체를 홈페이에 표시하는 경우

등으로 둘 수 있다.

이러한 무분별한 인터넷 데이터의 사용을 금지하기 위하여 웹 규약에서는 해당 사이트의 크롤링 범위를 정의하는 “robots.txt” 파일을 서비스 웹 서비스의 root에 저장하도록 되어 있다(안타깝게도 많은 웹 개발자나 웹 디자이너가 robots.txt 파일이라는 것이 존재하는 지 모르고 있는것이 현실이다 -.-;;). 다음의 표는 robots.txt의 사용예를 나타낸다.

Site	Status
모두 허용	User-agent:* Allow: /
모두 차단	User-agent:* Disallow: /
다른 예	User-agent: googlebot #googlebot 크롤러만 적용 Disallow: /bbs/ #/bbs 디렉터리 접근 차단

실 예로 http://www.naver.com/robots.txt 에 웹 브리우저를 이용하여 접근해 보면 네이버의 크롤러 접근 규칙에 대해 확인이 가능하다.

[그림 5] SNS API

인터넷 환경이 급속하게 발전하면서 이제는 개인이 데이터를 만들어 내고 이를 공유하는 것이 보편화된 세상에 살고 있다. 이러한 기술의 발전중에 SaaS(Software as a Service)라는 용어가 있다. SaaS는 소프트웨어 및 관련 데이터가 중앙에 위치하고 사용자는 웹 브라우저등을 이용하여 접속하여 소프트웨어를 사용하는 서비스 모델을 이야기한다.

페이스북이나 트위터는 자신들이 서비스하는 여러 가지 기능을 SaaS의 개념으로 다른 사용자들이 활용할 수 있는 API(Application Programming Interface)를 제공해 준다. 우리는 이러한 API를 이용하여 SNS의 내용을 읽어 오거나, 다양한 형태의 데이터를 제공받을 수 있다. 과거에는 웹 페이지 또는 서비스의 내용을 가지고 오기 위하여 크롤러(Crawler)라는 것을 만들고 URL에 접근하여 데이터를 가지고 왔어야 하는데 이러한 수고를 덜어주고 간단하게 데이터를 가지고 올 수 있는 서비스를 제공한다.

7. 파이썬 패키지(Package) 설치

Thu, 28 Dec 2017 08:01:00 +0000

7. 패키지(Package) 설치

PIP란 파이썬으로 작성된 패키지 패키지(package: 특정 기능을 수행하기 위하여 만들어 놓은 모듈-라이브러리-) 소프트웨어를 설치, 관리하는 시스템이다. 여기서 패키지는 특정 기능을 수행하기 위한 함수들을 모아놓은 라이브러리(모듈)을 의미한다. 파이썬은 2.7.9와 3.4 버전 이상에서는 기본적으로 포함되어 있다.

만약 프로그램을 설치하는 도중에 pip를 설치하는 것에 동의하지 않았다면 수작업으로 pip 설치하여야 한다 (easy_install.exe 라는 프로그램이 Python 설치 디렉터리 밑에 /Scrips에 있을 것이다. easy_isntall pip 라고 하면 pip가 설치된다)

7.1 설치된 패키지 확인하기

‘pip’를 활용하기 위해서는 명령 프롬프트(도스창)를 사용한다. [그림 1]처럼 ‘cmd’ 명령을 이용하여 도스창을 띄운다.

[그림 1] 명령 프롬프트(도스창) 실행

도스창에서 ‘pip list’ 명령을 입력하면 [그림 2]와 같이 현재 설치되어 있는 패키지 리스트가 나타난다.

[그림 2] 설치된 패키지 확인: pip list

파이썬을 설치한 초기 상태에서는 [그림 2]와 같이 pip(7.1.2)와 setuptools(18.2)만이 설치되어 있으며 현재 설치되어 있는 PIP 모듈은 버전이 7.1.2이며, 9.0.1 버전으로 업그레이드가 가능하다고 친절하게 나타난다. PIP 버전이 낮은 경우 패키기 설치시 오류가 발생하는 경우가 많이 발생하므로 항상 최신 버전으로 업데이트 하는 것이 필요하다.

7.2 설치된 패키지 업데이트

[그림 2]에서 나타난 것처럼 PIP 버전을 업데이트 하기 위하여 ‘pip install –upgrade pip’ 명령을 실행한다.

[그림 3] PIP 버전 업데이트: pip install –upgrade pip

[그림 3]에서 설치가 완료되면 다시 PIP 버전을 확인하기 위하여 ‘pip list’를 실행하면 [그림 4]와 같이 업데이트 된 사항을 확인할 수 있다. PIP 버전이 업데이트 되면서 목록을 확인하는 방법이 변경되었다는 메시지가 출력된다. 기존형식으로 보기 위해서는 –format=legacy 형식을 인자로 전달하고, 변경된 형식은 –format=columns을 인자로 전달한다.

[그림 4] 업데이트 된 패키지의 확인

7.3 패키지 설치

새로운 패키지를 설치하기 위해서는 ‘pip install [패키지명]’을 이용한다. 예제로 데이터를 수신하기위해 많이 사용하는 ‘request’ 패키지를 설치하여 보자. 도스창에서 ‘pip install request’라고 입력한 후 실행하면 [그림 5]와 같이 설치가 된다. 설치된 버전을 확인하기 위하여 ‘pip list –format=columns’를 실행한다.

[그림 5] 패키지 설치의 예

7.4 .whl 파일의 설치

설치하여야 할 패키지가 PIP INSTALL을 이용하여 설치가 되지 않는 경우가 가끔 발생한다. 이 겨웅에는 해당 패키지 웹사이트에서 파이썬 버전에 맞는 .whl 파일을 다운로드 받은 후 다음과 같이 실행을 한다.

참고 : scipy-1.0.0-cp35-none-win32.whl 라는 .whl 파일이 있으면 cp35가 파이썬 3.5.X 버전이라는 의미이다

C:\>pip install [.whl 파일 경로] 또는
C:\>python –m pip install [.whl 파일 경로]

6. 파이썬 모듈(module)

Thu, 28 Dec 2017 07:01:00 +0000

6. 모듈(module)

앞장에서 배운 함수는 하나의 프로그램에서 사용하였지만 모듈은 미리 함수, 변수 등을 파일로 작성해 해 놓고 필요할 때 마다 포함시켜 사용하는 방식을 이야기한다. 실제로 우리는 파이썬 프로그래밍을 하면서 다른 사람들이 미리 만들어 놓은 모듈들을 많이 가져다 사용하게 되는데 사용하면서 미리 수고를 해 준 많은 개발자들에게 고마움을 조금이라도 느꼈으면 좋겠다. 다음과 같이 모듈을 작성하고 파일명을 my_module.py로 특정 위치에 저장하자(필자의 경우 c:\python_sample에다 저장하였다).

def sum(*args):
    result = 0
    for i in args:
        result = result + i
    return result

이제 명령 프롬프트를 실행해서 파일을 저장한 위치로 이동한 후 다음과 같이 테스트한다.

[그림 1] 모듈의 작성 및 활용

위의 예에서 작성한 모듈을 불러오기 위하여 ‘import’라는 명령어를 사용한다. 이때 불러올 모듈의 파일명 뒤 ‘.py’는 기입하지 않는다. 모듈이 불려지면 ‘모듈명.함수명’의 형태로 불러다 언제든지 사용이 가능하다. 모듈명이 긴 경우 별명을 붙여 사용할 수 있는데, 그 경우에는 ‘as’를 이용한다.

만약 특정 모듈의 특정한 함수만 사용하게 되는 경우에는 ‘from [모듈명] import [함수명]’의 형태로 사용하면 ‘[모듈명].’을 표기하지 않아도 된다.

6.1 모듈 name

모듈 파일은 ‘.py’ 확장자를 가지고 있으며, python 실행시 바로 호출될 수 있다. 다음과 같이 코드를 수정하고 my_module.py 이름으로 저장한다.

def sum(*args):
    result = 0
    for i in args:
        result = result + i
    return result

print (sum(1,2,3))

이제 명령 프롬프트를 실행해서 파일을 저장한 위치로 이동한 후 다음과 같이 테스트한다.

[그림 2] import 와 직접 실행의 차이

파이썬에서 특정 파일을 불러오는 경우에는 명령 프롬프트에서 ‘python [파일명]’과 같이 실행할 수 있다. 앞서 작성한 예의 경우에는 모듈 내부에 print()문으로 수행하는 것이 있다. 이 파일을 만약 모듈로 사용한다면 import시에 print()문이 실행되고 만다. 이러한 것을 막기 위하여 다음과 같이 코드를 수정한다.

def sum(*args):
    result = 0
    for i in args:
        result = result + i
    return result

if __name__ == "__main__":
    print (sum(1,2,3))

코드를 저장한 후 실행하여 보면 다음과 같다.

[그림 3] name == __main__의 활용

호출되는 모듈이 직접 실행이 되는 경우에는 ‘name’ 이 ‘main’되어 실행되지만 모듈로서 기능을 하게 되는 경우에는 다른 프로그램이 __main__이 되므로 모듈내의 print()문이 동작하지 않게 되는 것이다.

5. 파이썬 함수 (Functions)

Thu, 28 Dec 2017 06:01:00 +0000

5. 함수(function)

우리가 어떠한 일을 처리하다 보면 반복적으로 특정 작업을 해야 하는 경우가 있다. 가령 예를 들어 음료수 자판기에 동전을 넣은 후 음료수 종류(콜라, 사이다, 커피 등)를 선택하면 음료수 자판기는 해당 음료를 배출구를 통해 제공한다. 여기서 자판기는 동전이 들어가면 단순하게 지정한 음료수를 제공하는 기능을 항상 수행하고 어디에 가서라도 항상 자판기만 찾으면 음료수를 선택할 수 있다. 마찬가지로 함수란 특정한 어떠한 일을 수행하도록 만들어 놓은 기능(절차(procedure) 또는 루틴(routine))이라고 할 수 있다.

이미 앞에서 배운 print(), str()등이 함수로써 함수는 특정값을 전달하면 화면에 출력을 해준다든가(내부적으로는 어떤 처리를 하는지 모르겠지만 모니터에 출력을 해준다) 숫자를 문자로 변환해주는 기능을 한다. 이렇게 자주 사용하는 유용한 기능을 우리는 함수라고 하며 함수는 다음과 같은 구조로 구성한다.

>>> a = input()
def 함수명(인자1, 인자2, … , 인자n):
    수행할 명령 1
    수행할 명령 2
    …
    return 반환할 값 (반환할 값이 없으면 지정하지 않아도 된다)

앞에서 설명한 자판기의 예를 조금 억지스럽지만 다음과 같이 구성할 수 있을 것이다.

def 자판기(동전, 음료수 종류):
    음료수 종류를 찾는다
    음료수 가격이 입력한 동전과 같은지 확인한다
    return 음료수를 배출한다

자판기라는 함수는 인자값으로 동전과 음료수 종류를 받는다. 자판기 함수 블록에서는 먼저 음료수가 있는지 확인하고, 음료수 가격과 동전이 일치하는지 확인한 후 음료수를 반환한다. 이제 실질적인 예를 들어 보도록 하자.

>>> def sum(a, b):
	result = a + b
	return result

>>> a = 1
>>> b = 2
>>> ret = sum(a, b)
>>> print(ret)
3
>>> print(sum(4, 10))
14
>>>

위의 예는 sum()이라는 함수를 작성하고 두 개의 인자 a, b를 입력 받도록 하였다. 함수 블록에서는 전달받은 a와 b값을 더해서 result라는 변수에 저장하고 그 값을 반환한다. 실제 프로그램에서는 sum(a, b)와 같은 형식으로 변수를 인자로 전달하거나 sum(4, 10)과 같이 실제 값을 전달하여 합계값을 출력할 수 있는 것이 확인되었다. 즉, sum()이라는 함수를 만들어 놓고 우리는 어디에서나 호출하여 덧셈 연산을 할 수 있는 것이다.

5.1 화면 입력과 출력

함수의 구성 방법에 대해 좀더 자세하게 알아보자. 함수는 매개변수(arguments)를 이용하여 데이터를 전달 받고 처리한 값을 return을 이용하여 반환한다. 파이썬에서는 프로그래밍을 편하게 하기 위하여 매개변수 처리에 몇 가지 기능이 추가되어 있다.

1) 기본 인수값

다음의 예를 작성해 보자.

def display_msg(msg, times=1):
    print(msg * times)

display_msg("TEST")
display_msg("TEST", 5)

저장한 후 실행하여 보면 다음과 같이 나타날 것이다.

======== RESTART: c:/python_sample/test.py ========
TEST
TESTTESTTESTTESTTEST
>>>

위의 예에서 display_msg()함수는 msg와 times라는 인자를 가진다. 함수를 호출할때는 반드시 인자의 개수를 맞추어 주어야 하는데, 예제와 같이 인자의 기본값이 있는 경우에는 생략하여도 된다. 주의할 점은 기본값을 지정하는 인자들은 항상 뒤쪽에 기입하여야 한다. 즉, def func(x, y=1):의 형식이 아닌 def func(y=1, x):으로 함수를 작성하면 오류가 발생한다.

2) VarArgs 인자

함수를 구성할 때 전달하여야 하는 인자의 개수가 몇 개인지 정확하지 않은 경우가 있다. 이러한 경우 임의(Variable) 개수의 인자(Arguments)를 전달할 수 있다.

def sum(*args):
    result = 0
    for i in args:
        result = result + i
    return result

print(sum(1, 2))
print(sum(1, 2, 3, 4))

실행한 결과는 다음과 같다.

======== RESTART: c:/python_sample/test.py ========
3
10
>>>

5.2 지역(local)변수와 전역(global)변수

우리가 함수를 공부하면서 많이 혼동하는 부분이 지역 변수와 전역 변수이다. ‘지역’과 ‘전역’이라는 것은 단어 뜻에서도 유추할 수 있듯이 지역적으로만 사용되는 변수와 전체적으로 사용되는 변수라는 의미로써 지역변수는 함수 내에서만 사용이 되는 변수, 전역 변수는 프로그램 전체에서 사용하는 변수하고 이해하면 된다. 다음의 코드를 에디터에서 작성한 후 실행하여 본다.

def local():
    a = 3              #3-1번째 수행
    print("local a: " + str(a))


a = 10                 #1번째 수행
print(a)               #2번째 수행
local()                #3번째 수행
print(a)               #4번째 수행

실행한 결과는 다음과 같다.

======== RESTART: c:/python_sample/test.py ========
10
local a: 3
10
>>>

먼저 ‘a’ 라는 변수에 10을 넣고(함수는 호출이 시점에서 동작한다) 출력을 하면 10이 정상적으로 출력된다. 그리고 난 후 local()라는 함수를 호출하면 ‘a’라는 변수에 3을 대입한 후 출력한다. 그 후 print()문을 이용하여 ‘a’값을 출력하면 다시 10이 출력되는 것을 확인할 수 있다. 우리가 작성한 local()의 내부에서 사용한 ‘a’ 변수는 함수 내에서만 유효하고 함수의 동작을 마치면 없어진다. 즉, #1 에서 선언한 ‘a’ 변수와 #3-1의 ‘a’ 변수는 이름이 같지만 서로 다른 공간에 존재하는 것이다. 다음과 같이 코드를 수정하여 보자.

a = 1             #1번째 수행

def local():
    global a
    a = 3         # 4-1번째 수행
    print("global a:" + str(a))

a = 10            #2번째 수행
print(a)          #3번째 수행
local()           #4번째 수행
print(a)          #5번째 수행

위의 코드를 수행하면 다음과 같다.

======== RESTART: c:/python_sample/test.py ========
10
global a:3
3

차이점은 local() 함수에서 사용한 ‘a’ 변수 앞에 ‘global’이라 표시를 해 준 것이다. ‘global’ 선언을 하면 함수 외부에서 선언된 전역 변수를 직접 사용할 수 있다. 즉, #4-1에서 사용하는 ‘a’ 변수는 #1에서 선언한 변수와 동일한 것이다. 사실 프로그래밍에서는 global 변수의 사용을 권하지 않는다. 그 이유는 프로그램이 길어지면 어디에서 변수값을 바꾸는지 일일이 확인하기 힘들기 때문에 프로그램의 오류를 찾기가 힘들기 때문이다. 다음은 위의 코드를 지역변수로 사용하기 위해 return을 사용한 예를 보여준다.

a = 1               #1번째 수행

def local():
    a = 3           # 4-1번째 수행
    print("global a:" + str(a))
    return a

a = 10              #2번째 수행
print(a)            #3번째 수행
a = local()         #4번째 수행 (return으로 반환한 값을 a 변수에 대입)
print(a)            #5번째 수행

[그림 1] 지역 변수와 전역 변수

4. 파이썬 입력과 출력 (Input/Output)

Thu, 28 Dec 2017 05:01:00 +0000

4. 입력과 출력

앞서 프로그래밍은 “입력 » 처리 » 출력”의 과정을 거친다고 이야기하였다. 본 장에서는 데이터를 입력 받는 방법과 출력하는 방법에 대해 좀더 자세히 알아보도록 하겠다.

4.1 화면 입력과 출력

사용자가 키보드를 통하여 데이터를 입력하게 되는 경우 우리는 입력한 데이터를 받아 컴퓨터의 저장소(변수)에 저장하여야 한다. 파이썬에서는 키보드 입력을 위하여 input()함수를 제공한다.

>>> a = input()
안녕하세요
>>> print(a)
안녕하세요
>>> a = input()
123
>>> print(a)
123
>>> a + 10
Traceback (most recent call last):
  File "<pyshell#45>", line 1, in <module>
    a + 10
TypeError: Can't convert 'int' object to str implicitly
>>> a = int(input())
123
>>> a + 10
133
>>>

위의 예에서 “123”이라는 값을 입력하여 a 라는 변수에 저장하고 출력하는 경우에는 정상적으로 처리되지만 10을 더하는 경우에는 오류를 발생한다. 기본적으로 파이썬에서는 데이터 입력을 문자열로 취급하며, 만약 정수 또는 실수의 값을 변수에 저장하려면 int()라는 함수 또는 float()함수를 이용하여 형 변환(type casting)을 해 주어야 한다.

>>> a = input("이름을 입력하세요:")
이름을 입력하세요:홍길동
>>> print(a)
홍길동
>>>

만약 데이터를 입력받으면서 특정한 문구를 출력하고자 한다면 input()의 인자로 출력할 문자열을 함께 전달하면 출력 문자열뒤에 데이터를 입력할 수 있다.

데이터를 화면에 출력하기 위해 우리는 print()함수를 사용하였다. 화면에 출력할 시 포맷팅을 이용하는 방법에 대해서는 앞서 설명하였으므로 기타 편리한 기능을 몇 가지 알아보도록 하겠다.

>>> print("안녕하세요" + "홍길동입니다")
안녕하세요홍길동입니다
>>> print("안녕하세요" "홍길동입니다")
안녕하세요홍길동입니다
>>>

문자열과 문자열을 합치기 위하여 ‘+’ 연산자를 사용하지만 생략하는 경우에도 자동으로 인식한다.

>>> print("안녕하세요" + " " + "홍길동입니다")
안녕하세요 홍길동입니다
>>> print("안녕하세요", "홍길동입니다")
안녕하세요 홍길동입니다
>>>

띄어쓰기를 하기 위하여 두개의 문장에 “ “(공백) 문자를 추가하였으나 ‘,’를 이용하면 두개의 문자열 사이에 자동으로 띄어 쓰기를 지원한다.

>>> for i in range(4):
	print(i)

0
1
2
3
>>> for i in range(4):
	print(i, end=" ")


0 1 2 3

print()문을 수행하면 자동으로 줄바꿈(new line: \n)이 출력된다. 그러나 때로는 한줄에 데이터를 계속해서 출력해야 하는 경우가 있다. 이 경우 ‘end=’ 이후에 출력할 값 이후에 끝에 붙을 문자열을 넣어주면 자동 줄바꿈이 실행되지 않는다. 즉, print(i)는 print(i, end=”\n”)와 동일하다.

4.2 파일 입력과 출력

우리가 프로그래밍을 하게 되면 데이터를 저장된 데이터를 읽어와 어떤 처리를 하고 결과값을 파일로 저장해야 하는 경우가 많이 생긴다. 본 절에서는 파일 입출력(File Input/Output: File I/O)에 대해 알아보도록 하자.

1) 파일 생성

#파일 객체 = open(파일명, 파일 속성)
>>> f = open(“test.txt”, “w”)
>>> f.close()

파일을 생성하기 위해서는 파일명과 파일 속성을 인자로 하여 open()함수를 이용한다. 파일 속성은 다음과 같다.

파일 속성	설명
r	파일명에 해당하는 파일을 읽기 모드로 연다
w	파일명에 해당하는 파일을 생성한다. 만약 기존에 파일이 있다면 기존파일을 삭제하고 새로 만든다(기존 내용이 전부 사라진다)
a	기존에 있는 파일의 마지막부터 데이터를 추가한다

파일명은 경로를 포함할 수 있으며, 경로명을 주지 않고 파일명만 입력한 경우에는 실행 파일이 동작하는 디렉터리에 생성된다. open()함수는 파일 객체를 반환한다. 일정한 처리가 완료되면 close()함수를 이용하여 파일을 닫아 주어야 한다.

위의 예제에서는 ‘test.txt’파일을 작성하는 파일이 있는 디렉터리에 생성하고 파일객체를 닫았으므로 아무것도 기록되지 않은 ‘test.txt’ 파일이 생성될 것이다.

2) 파일 읽기

먼저 메모장을 열어 아주 간단한 파일을 생성하고 ‘C’ 디렉터리 하위에 ‘python_sample’이라는 디렉터리를 만들고 test.txt라고 저장을 한다.

[그림 1] 메모장에 샘플 파일 생성

[그림 2] c:/python/test.txt로 저장

파일이 저장되었으면 다음과 같이 에디터에서 작성한 후 저장하고, 실행한다.

f = open("c:/python_sample/test.txt", "r")
print(f.readline())
f.close()

F5키를 눌러 실행하면 다음과 같이 출력될 것이다.

======== RESTART: c:/python_sample/test.py ========
Python File I/O Test

>>>

readline()은 파일의 한줄을 읽어오는 함수이다. 우리가 test.txt 파일에 2줄의 문서를 작성했지만 한줄밖에 가지고 오지 못한다. 전체를 읽어오기 위해서 다음과 같이 프로그램을 수정해 보자.

f = open("c:/python_sample/test.txt", "r")
while True:
    line = f.readline()
    if not line:
        break
    print(line)
f.close()

실행한 결과는 다음과 같다.

======== RESTART: c:/python_sample/test.py ========
Python File I/O Test

파이썬 파일 입출력 시험
>>>

위의 프로그램은 test.txt 파일을 읽기 모드로 연 후 while 문을 이용하여 한 라인씩 읽어 오면서 처리를 하다가 데이터가 더 이상 없는 경우에 break를 이용하여 블록을 빠져 나온 후 파일 객체를 반환한다.

readline()은 파일의 한줄을 읽는 함수이지만 파일의 모든 줄을 읽어 오기 위하여 파이썬은 readlines() 함수를 제공한다. 다음과 같이 프로그램을 작성한 후 실행한다.

f = open("c:/python_sample/test.txt", "r")
lines = f.readlines()
for line in lines:
    print(line)
f.close()

실행한 결과는 다음과 같다.

======== RESTART: c:/python_sample/test.py ========
Python File I/O Test

파이썬 파일 입출력 시험
>>>

readlines()는 읽어온 모든 행을 리스트처럼 저장한다. read() 함수는 아예 파일을 하나의 객체로 가지고 오므로 전체 파일을 출력하는 경우에는 편리하다.

f = open("c:/python_sample/test.txt", "r")
lines = f.read()
print(lines)
f.close()

실행한 결과는 다음과 같다.

======== RESTART: c:/python_sample/test.py ========
Python File I/O Test
파이썬 파일 입출력 시험
>>>

readlines()와 read()의 출력 결과를 보면 한줄이 줄어 있는 것을 확인할 수 있다. 이는 print()함수가 라인별로 동작하면서 행바꿈이 일어나기 때문이다.

3) 파일 쓰기

다음과 같이 프로그램을 작성한 후 저장한다.

f = open("c:/python_sample/test.txt", 'w')
f.write("첫번째 줄입니다")
f.write("두번째 줄입니다")
f.close()

프로그램을 실행하면 다음과 같이 프롬프트만 나타날 것이다.

======== RESTART: c:/python_sample/test.py ========
>>>

탐색기를 이용하여 test.txt 파일을 열면 기존의 내용이 삭제되고 새로운 내용으로 만들어 진진 것 확인할 수 있을 것이다.

[그림 1] text.txt 파일

여기서 주의할 점은 두 개의 행이 붙어서 나왔다는 것이다. 파일을 쓸 때 줄바꿈을 하기 위해서는 “\n”을 입력하여야 한다.

f = open("c:/python_sample/test.txt", 'w')
f.write("첫번째 줄입니다")
f.write("\n")
f.write("두번째 줄입니다")
f.write("\n")
f.close()

실행한 후 다시 파일을 확인해 보면 정상적으로 줄바꿈이 된 것을 확인할 수 있다.

[그림 2] 이스케이프 문자인 “\n”을 이용한 줄바꿈 결과

4) 파일에 내용 추가

파일에 내용을 추가 하기 위하여 다음과 같이 코드를 작성한 후 저장한다.

f = open("c:/python_sample/test.txt", 'a')
f.write("추가한 줄입니다")
f.close()

실행한 후 저장된 test.txt 파일을 확인하면 이전 파일의 맨 마지막에 내용이 추가된 것을 확인할 수 있다.

[그림 3] 파일 열기 – 추가 모드

5) with 문과 함께 사용

지금까지 파일 객체를 생성하면 반듯이 파일 객체를 반환하는 close()함수를 사용하여야 했다. 이는 매우 번거로운 일이다. 이를 편하게 사용하기 위하여 파이썬에서는 with문과 함께 사용할 수 있다.

with open("c:/python_sample/test.txt", "r") as f:
    lines = f.read()
    print(lines)

with문과 함께 사용하는 파일 객체는 하위 블록에서 유효하다. 만약 블록을 벗어나게 되면 오류가 발생한다.

3. 파이썬 흐름 제어 (Flow Control)

Thu, 28 Dec 2017 04:01:00 +0000

3. 흐름 제어

프로그래밍은 입력, 처리, 출력의 과정을 거친다고 하였다. 우리는 앞서 데이터 처리를 위하여 한 라인씩 프로그래밍을 하고, 그 결과값을 확인하였다. 그러나 실제 프로그램에서는 조건이 맞는 경우에만 처리하거나 반복적으로 어떤 수행을 해야 하는 경우가 많이 발생한다. 이러한 과정을 수행하기 위하여 ‘흐름 제어’ 명령문을 사용하게 된다.

3.1 조건 판단

‘조건 판단’은 특정한 조건에 만족하면(조건이 True 이면) 어떠한 처리를 한다는 것을 의미한다. 다음의 예를 보자

시험점수가 60점 이상이면 합격이고 그렇지 않으면(미만)이면 실격이다.
--->>> IF(만약에) 시험점수가 60이상 이면(THEN) 합격이고 그렇지 않으면(ELSE) 실격이다

위의 예는 일반적으로 우리가 논리 판단하는 것을 컴퓨터 언어로 풀어 놓은 것이다. 우리는 영어에서 어떠한 가정을 할 때 ‘IF…’ 라는 식으로 문장을 만든다. 마찬가지로 컴퓨터에서도 ‘if’를 이용하여 조건식을 만들 수 있다. 다음은 앞의 예를 파이썬으로 구현한 것이다.

>>> score = 90
>>> if score >= 60:
	print("합격")
…   else:
	print("실격")

합격
>>> score = 59
>>> if score >= 60:
	print("합격")
…   else:
	print("실격")

실격
>>>

위의 예에서처럼 if 문은 다음과 같은 구조를 가진다.

if [조건식]:
    조건식에 맞는 처리 1
    조건식에 맞는 처리 2
    …
else:
    조건식에 맞지 않는 경우 처리 1
    조건식에 맞지 않는 경우 처리 2
    …

여기서 “조건식에 맞는 처리 1, 2, …” 을 if 블록(block)이라고 하고 “조건식에 맞지 않는 경우 처리 1, 2, …”를 else 블록이라고 하며 하나의 블록은 상위 처리문에서 4칸 들여 써서 작성해야 한다. else 블록의 경우에는 처리할 필요가 없는 경우에는 ‘else:’ 이하를 전부 사용하지 않으면 된다.

1) 조건식

위의 예에서 [조건식]이란 참과 거짓을 판단하기 위한 문장(statement)이다. 앞의 예제에서는 점수가(점수는 score라는 변수에 들어있다)가 60점 이상(>=: 크거나 같다)를 표시하기 위하여 “score >= 60”으로 표현한 것이다.

a. 비교 연산자

비교 연산자는 두 개의 값을 비교하는데 사용하는 연산자이다.

비교연산자	설명
X > Y	X가 Y보다 큰 경우 참(True)
X >= Y	X가 Y보다 크거나 같은 경우 참(True)
X < Y	X가 Y보다 작은 경우 참(True)
X <= Y	X가 Y보다 작거나 같은 경우 참(True)
X == Y	X가 Y와 같은 경우 참(True): 파이썬에 ‘=’은 대입 연산자(우측의 값을 오른쪽에 넣는다는 의미)로 사용되기 때문에 ‘=’를 두개 연속해서 사용한다
X != Y	X가 Y와 같지 않은 경우 참(True)

다음의 예를 확인해 보자.

>>> x = 20
>>> y = 10
>>> x > y
True
>>> x >= y
True
>>> x < y
False
>>> x <= y
False
>>> x == y
False
>>> x != y
True
>>> x = 10
>>> y = 10
>>> x > y
False
>>> x >= y
True
>>> x == y
True
>>> x != y
False

b. 논리 연산자

논리 연산자는 논리식으로 판단하기 위하여 사용하는 연산자이다.

논리연산자	설명
X and Y	X가 참이고 Y가 참인 경우에 참(True)이다
X or Y	X 또는 Y중 한가지 이상이 참인 경우에 참(True)이다
not X	X가 참(True)이면 거짓(False), 거짓(False)이면 참(True)이다

다음의 예를 확인해 보자.

>>> korean = 90
>>> math = 85
>>> (korean >= 90) and (math >= 90)
False
>>> (korean >= 90) or (math >= 90)
True
>>> not korean #korean 점수가 1이상이면 무조건 참이다. 만약 korean = 0 이라면 False
False

2) 다양한 비교: elif

우리가 조건을 비교하는 경우에는 단순하게 이분법적으로 판단할 수 없는 경우가 있다. 만약 시험 점수에 따라서 학점을 주는 프로그램을 작성한다면 다음과 같이 작성할 수 있을 것이다. 파이썬 편집창을 띄워 아래와 같이 작성한 후 저장하고, F5키를 눌러 실행하면 결과를 확인할 수 있다.

score = 91
if score >= 90:
    print("A")
else:
    if score >= 80:
        print("B")
    else:
        if score >= 70:
            print("C")
        else:
            print("D")

위의 예에서 만약 ‘score’ 변수의 값이 90 이상이면 ‘print(“A”)’ 블록이 실행되고 그렇지 않은 경우에는 ‘else’ 블록을 수행하는데 ‘else’ 블록 내부에서 또 조건문을 이용하여 80점 이상인지를 판단하도록 구성한 것이다. 이렇게 여러 조건을 한꺼번에 판단하기 위해 사용하는 구문이 ‘elif’이다.

if score >= 90:
    print("A")
elif score >= 80:
    print("B")
elif score >= 70:
    print("C")
else:
    print("D")

‘elif’를 사용하여 프로그램을 작성하면 훨씬 가독성이 높아진 것을 확인할 수 있다(기능상으로야 동일할지 모르겠으나, 나중에 프로그램을 수정하거나 잘못된 부분을 찾을 때 훨씬 쉽게 확인할 수 있다)

3) 간단한 if문의 작성

‘if’문 내부에서 단순하게 하나의 행만을 수행한다면 다음과 같이 줄여서 쓸 수 있다.

>>> if score >= 70: print("합격")
else: print("불합격")

합격

편리하기는 하지만 가독성 부분에서 그리 권장할 사항은 아니다.

3.2 반복 수행: while

우리는 프로그래밍을 하다 보면 반복적으로 어떤 처리를 해야 하는 경우가 있다. 가령 예를 들어 리스트에 있는 모든 값을 출력해야 한다면 우리가 배운식으로 처리를 하면 다음과 같다.

>>> a = ['A', 'B', 'C']
>>> a
['A', 'B', 'C']
>>> print (a[0])
A
>>> print (a[1])
B
>>> print (a[2])
C

위와 같이 프로그래밍을 한다면 리스트의 요소가 100개라고 하면 print문을 100번 써줘야 할 것이다. 이것은 무척이나 고달프고 고통스러운 것이다. 프로그래밍을 하다 보면 반복적으로 어떤 처리를 해야 하는 경우가 많이 발생하는데 이를 위해 미리 내장되어 있는 while문은 특정 블록을 반복하여 처리하는 기능을 제공한다. while문은 다음과 같은 구조를 가진다.

while [조건식]:
    처리할 문장 1
    처리할 문장 2
    …

다음의 예를 살펴보자.

>>> a = 1
>>> while a < 5:
	print(a)
	a = a + 1


1
2
3
4
>>>

먼저 ‘a’라는 변수를 만들고 정수값 1을 대입하였다. ‘while’문의 조건으로는 ‘a’의 값이 5보다 작은경우까지 하위 블록을 수행한다. 하위 블록은 먼저 ‘a’의 값을 출력하고 그 후에 ‘a’ 라는 변수에 ‘a’가 가지고 있는 값에 1을 더하여 다시 ‘a’에다 넣어준다. 즉, ‘a’의 값을 하나씩 증가시켜 주는 것이다. 다음의 그림을 확인하자.

[그림 1] a = a + 1의 동작 과정

프로그램에서는 대입연산자(=)를 기준으로 오른쪽의 연산을 수행한 후 왼쪽의 저장소에다 결과값을 입력한다고 하였다. 즉 오른쪽의 ‘a’는 ‘a’가 가지고 있는 변수의 값을 의미하고, 왼쪽의 ‘a’는 저장할 장소를 의미한다. ‘a = a + 1은 ‘a += 1’로 줄여 쓸 수 있다. ‘while’문이 동작하는 일련의 과정은 다음과 같다.

[그림 2] While 문의 수행 과정

1) while 문의 강제 종료: break

‘while’문의 경우에는 조건식이 만족하는 동안 계속 블록을 반복하여 수행한다. 그러나 경우에 따라서는 조건문을 사용할 수 없는 경우가 있다. 파이썬 IDLE의 편집기를 수행하여 아래의 코드를 작성하고, 저장한 후 실행하여 보자.

# while Test
goal = 55

while True:
    in_data = int(input("숫자를 입력하세요 : "))
    if in_data < goal:
        print("숫자가 작습니다")
    elif in_data > goal:
        print("숫자가 큽니다")
    else:
        print("일치합니다")
        break

print("종료합니다")

다음은 실행한 결과를 나타낸다.

======== RESTART: c:/python_sample/test.py ========
숫자를 입력하세요 : 1
숫자가 작습니다
숫자를 입력하세요 : 50
숫자가 작습니다
숫자를 입력하세요 : 70
숫자가 큽니다
숫자를 입력하세요 : 60
숫자가 큽니다
숫자를 입력하세요 : 56
숫자가 큽니다
숫자를 입력하세요 : 55
일치합니다
종료합니다
>>>

위의 예제는 계속 반복하면서 데이터를 입력 받아 특정한 값이 만족되면 프로그램을 종료하는것이다. ‘while’의 조건문을 보면 ‘True’라고 되어있는 것을 확인할 수 있다. 즉, while 블록은 항상 참(True)이기 때문에 무한이 블록을 반복하게 된다. 이런 경우 While을 종료시키는 방법은 ‘break’라는 명령어를 이용하여 가능하다. 즉, 데이터를 계속 입력 받으면서 ‘goal’의 숫자와 동일하게 되는 경우에는 ‘break’ 문을 이용하여 while 블록을 탈출할 수 있다.

예제에서 사용한 ‘in_data = int(input(“숫자를 입력하세요 : “))’문은 키보드로부터 데이터를 입력받아 정수형(int)로 변환하여 in_data에 저장하는 것이다. 나중에 입출력 부분에서 다시 한번 설명할 예정이니 단순하게 이해하고 넘어가기를 바란다.

2) while 문의 처음으로 이동: continue

break는 while 문의 종료를 강제적으로 지정하는 경우에 사용한다고 했다. continue의 경우에는 하위 블록을 수행하지 않고 다시 while 문의 처음으로 이동하기 위하여 사용한다. 다음의 예를 작성하여 보자.

while True:
    in_data = input("문자열을 입력하세요:")
    if len(in_data) < 3:
        print("문자열의 길이가 짧습니다")
        continue

    print("종료합니다")
    break
>>>

코드를 수행한 예는 다음과 같다

======== RESTART: c:/python_sample/test.py ========
문자열을 입력하세요:ab
문자열의 길이가 짧습니다
문자열을 입력하세요:abcd
종료합니다
>>>

위의 코드에서는 while문의 조건이 True로 되어 있어 무한반복을 한다. 문자열을 입력 받아서 그 길이가 3보다 작은 경우에는 “문자열의 길이가 짧습니다”를 출력하고 하위 코드를 수행하지 않고 While 문의 최 상단으로 이동한다. 만약 문자열의 길이가 3 이상이면 if 문은 수행이 되지 않고 “종료합니다”를 출력한 후 while 블록을 탈출한다. 다음은 이러한 프로그래밍의 과정을 순서도(flow chart)로 표시한 것이다.

[그림 2] While … continue 순서도

위의 예에서 만약 break 문이 없다면 while문은 무한 반복하게 될 것이다.

3.3 반복 수행: for

앞서 우리는 while을 이용하여 데이터를 반복적으로 처리하는 방법에 대하여 알아보았다. while 문 다음에 오는 조건식은 while 블록을 탈출하는 조건으로 사용되는데 이와 유사하게 반복적인 기능을 제공하는 for 구문이 있다. for의 구조는 다음과 같다.

for [변수] in 리스트(또는 튜플, 문자열):
    처리할 Block

>>> a = ['A', 'B', 'C']
>>> for i in a:
	print(i)

A
B
C
>>>

위의 예에서는 ‘a’ 리스트의 값을 순차적으로 ‘I’ 변수에 가져 오고, 이를 출력하는 것이다. for 구문은 while문과 다르게 리스트나 튜플 또는 문자열등을 이용하여 변수에다 하나씩 값을 가지고 올 수 있는 기능을 제공하기 때문에 유용하게 사용할 수 있다. 다음은 튜플을 이용하는 예이다.

>>> a = [('science', 100), ('math', 95), ('computer', 97)]
>>> for (subject, score) in a:
	print(subject + " : " + str(score))


science : 100
math : 95
computer : 97
>>>

튜플의 경우에는 각 요소(element)들이 2개의 값을 가지고 있으므로 in 을 이용하여 처음 아이템(item)을 subject변수에, 두번째 아이템을 score 변수에 가지고 와서 리스트 의 끝까지 반복하면서 출력하는 예이다.

1) range() 함수의 사용

for문과 함께 잘 사용하는 range() 함수는 시작과 끝의 값을 지정하여 주면, 연속된 숫자 객체를 만들어 준다.

>>> a =range(10)
>>> a
range(0, 10)
>>> a = range(2, 10)
>>> a
range(2, 10)
>>> for i in range(1, 5):
	print(i)


1
2
3
4

위의 예에서 보듯이 range(처음시작값, 마지막값)으로 입력하는 경우에는 숫자열은 처음 시작값부터 마지막값 - 1까지(미만으로 인식) 숫자 객체로 만들어짐을 알 수 있다. 다음의 예를 편집기에서 작성하여 저장한 후 실행하여 보자.

# test.py로 저장한 후 실행
score = [100, 55, 70, 35, 90]
for number in range(len(score)):
    if (score[number] >= 60):
        print("%d 학생 합격" % (number+1))
    else:
        print("%d 학생 불합격" % (number+1))

실행한 결과는 다음과 같다.

======== RESTART: c:/python_sample/test.py ========
1 학생 합격
2 학생 불합격
3 학생 합격
4 학생 불합격
5 학생 합격

위의 예는 range()함수를 이용하여 인덱스를 자동을 생성한 후 인덱스에 해당하는 요소값을 가지고 오는 예를 보여준다. range()함수의 인자가 하나인 경우 시작인덱스는 0부터 생성되고, len()함수를 이용하여 리스트의 개수를 얻어온다. 실제 얻어온 리스트의 개수는 5인데 range()를 이용하여 생성된 숫자 객체는 (0, 1, 2, 3, 4)가 되어 리스트 아이템의 인덱스만큼 반복할 수 있다.

2) continue와 break의 사용

for 문에서도 while과 마찬가지로 continue와 break를 사용할 수 있다.

2. 파이썬 변수(variable)와 파이썬 자료형(data type) 처리

Thu, 28 Dec 2017 03:01:00 +0000

2. 변수(variable)와 파이썬 자료형(data type) 처리

컴퓨터로 어떠한 일을 수행하려면 데이터를 입력 받아야 한다. 이러한 데이터는 숫자나 문자, 때로는 여러 개의 데이터 조합일 수 있다. 이렇게 입력 받은 데이터는 어딘가에 저장해 놓고 필요한 경우에 읽어 오거나 수정할 수 있어야 한다. 프로그래밍에 있어서 이렇게 데이터를 저장해 놓을 수 있는 공간(메모리의 일정 구역)을 할당하고 특별한 이름을 부여하는 과정을 “변수를 할당한다”라고 한다.

우리가 물건을 인터넷에 시키면 택배기사 아저씨가 정확하게 물건을 배달하여 줄 수 있는 것은 집주소를 물건 주문 시 기록하기 때문이다. 만약 집주소가 중복된다면 어떤 집으로 물건을 배달할지 혼동이 될 것이다. 마찬가지로 변수는 프로그램 내에서 중복된 이름으로 사용할 수 없다. 또한 한번 선언한 변수에는 말 그대로 ‘변하는 값’을 계속 입력할 수 있다. [그림 1]을 살펴 보도록 하자.

[그림 1] 변수의 생성과 값의 입력

[그림 1]과 같이 파이썬에서 변수를 생성하는 방법은 간단하게 하나의 이름을 지정하면 된다(C등의 프로그래밍언어에서는 변수를 생성하면서 어떤 데이터 형식-숫자, 문자, 문자열 등-을 입력할지 선언해야 하지만 파이썬은 단순하게 이름을 하나 선언하는 것으로 완료된다).

우리는 x라는 변수를 선언하고 ‘=’ 을 기입한 후 3이라는 값을 기입하였다. 여기서 ‘=’를 기준으로 오른쪽에 있는 값을 왼쪽으로 넣어준다는 이야기이다(여기서 ‘=’를 대입연산자라고 한다). 그 후에 다시 ‘X’에 ‘4’를 입력한 후 print() 함수를 사용하여 ‘X’의 값을 출력하면 ‘4’가 출력되는 것을 확인할 수 있다.

앞에서 주문한 물건을 받기 위해서 주소가 같으면 안된다고 이야기하였는데, 또 한가지 주의할 점은 파이썬에서 사용하는 예약어나 함수명을 변수로 사용해서는 안된다는 것이다. 만약 변수명을 print 라고 한다면 파이썬은 화면에 어떤 값을 출력하라는 것인지 아니면 변수로 어떤 값을 보관하고 있어야 하는 것인지 알 수 없기 때문이다.

2.1 숫자형

파이썬에서 사용하는 숫자(Number)형은 숫자의 형태로 이루어진 것으로 초등학교때 배운 정수, 소수 등을 가질 수 있다.

1) 정수(integer)

정수는 양의 정수(1, 2, …), 음의 정수(-1, -2, …) 와 0을 의미한다.

>>> a = 1
>>> a = 0
>>> a = -1

2) 실수(integer)

실수는 소수점을 포함하는 숫자를 의미한다.

>>> a = 1.1
>>> a = -1.1
>>> a = 1.2E10
>>> a = 1.2E-10

마지막에 표현된 ‘E’의 형태는 컴퓨터에서 사용하는 10의 지수방식을 의미한다 ‘1.2E10’은 1.2 x 10 = 10^10 을, ‘1.2E-10’은 1.2 x 10^-10 을 의미한다.

3) 8진수(octal) 및 16진수(hexadecimal)

8진수와 16진수는 컴퓨터에서 연산을 하기 편리하게 사용하기 위하여 사용하는 표현 방식으로 중학교(?)때 진법 변환을 기억해 보기 바란다. 8진수를 사용하기 위해는 0o(숫자 0, 알파벳 o) 또는 0O(숫자 0, 알파벳 O)를 숫자 앞에 붙여 주면 된다. 16진의 경우에는 0x(숫자 0, 알파벳 x)를 사용한다.

>>> a = 0o17
>>> a = 0x12EF

4) 수학 연산자(operator)

수식은 ‘2 + 3’ 과 같이 피 연산자(연산을 당하는 것: 2, 3)와 연산자(연산을 하는 것: +)로 나눌 수 있다. 연산자란 무언가를 계산할 때 어떠한 방식을 하라고 지시하는 것으로 대표적으로 사칙연산자(+, -, *, /)를 생각할 수 있다 – 컴퓨터에서 나누기 표시는 ‘/’를 사용한다-. 단순하게 프롬프트 상에서 다음과 같이 사칙연산을 할 수 있다.

>>> 2 + 3 #덧셈
5
>>> 3 – 2 #뺄셈
1
>>> 2 * 3 #곱셈
6
>>> 2 / 3 #나눗셈
0.6666666666666666
>>> 2 ** 3 #거듭제곱: 2를 3번 곱함
8
>>> 2 % 3 #나머지: 2을 3으로 나누면 몫은 0, 나머지는 2
2
>>> 3 % 2 #나머지: 3을 2로 나누면 몫은 1, 나머지는 1
1
>>> 2 // 3 #나눗셈 후 소수점 이하를 버림: 0.66666 에서 소수점 이하를 버림
0
>>> 3 // 2 #1.5에서 .5를 버림
1

2.2 문자열(String)

파이썬에서 사용하는 문자열은 하나의 문자(character) 또는 문자열(string)을 가질 수 있다.

1) 문자열의 구성

파이썬에서 문자열은 작은 따옴표(‘)의 쌍, 큰 따옴표(“)의 쌍과 큰 따옴표 또는 작은 따옴표 3개의 연속된 쌍으로 만들 수 있다.

>>> a = ‘HELLO’
>>> a = “HELLO”
>>> a = ‘’’HELLO’’’
>>> a = “””HELLO”””

문자열을 만드는데 여러 가지 방식을 만든 이유는 파이썬이 다양한 언어의 문자열을 지원하기 위해서 이다. 영어중에 생략된 글자나 숫자, 또는 소유격을 나타내기 위해서 사용하는 작은따옴표(어퍼스트로피: apostrophe)를 생각해 보면 쉽게 알 수 있다.

>>> a = 'she's gone' #작은따옴표 쌍이 맞지 않는다
SyntaxError: invalid syntax
>>> a = "she's gone" #문자열을 큰 따옴표 쌍으로 만들어 주니 혼동이 없음
>>> print(a)
she's gone
>>> a = "he said that "she is gone"” #큰따옴표의 쌍은 맞으나 문자열을 어떻게 끊어야 하는지 알 수 없음
SyntaxError: invalid syntax
>>> a = 'he said that "she is gone"' #작은 따옴표쌍으로 문자열을 만들고 내부에서 큰따옴표를 사용
>>> print(a)
he said that "she is gone"
>>> a = 'he said that "she's gone"' #작은 따옴표의 쌍이 맞지 않음
SyntaxError: invalid syntax
>>> #문자열 내부에 사용하는 큰 따옴표와 작은 따옴표 앞에 \를 입력하면 인식
>>> a = 'he said that "she\'s gone"'
>>> print(a)
he said that "she's gone"
>>> a = "he said that \"she\'s gone\""
>>> print(a)
he said that "she's gone"

2) 이스케이프(escape) 문자

파이썬뿐만 아니라 여러 프로그래밍 언어는 이스케이프 문자를 지원한다. 이스케이프 문자란 미리 정의해놓은 문자로 특정 기능을 수행한다. 이스케이프 문자는 여러 가지가 있으나 주로 사용하는 것은 다음과 같다.

이스케이프 문자	기능	예제
\n	줄 바꿈	»> print (“HI\nHELLO”) HI HELLO
\t	탭	»> print (“HI\nHELLO”) HI HELLO
\	\ 문자	»> print (“HI\HELLO”) HI\HELLO
\’	‘ 출력
\”	“ 출력

3) 여러줄의 문자열

변수에 문자열을 입력하다 보면 여러줄의 문자열을 작성할 경우가 있다. 이러한 경우에는 한줄에 문자열을 다 입력하여도 되지만, 가독성이 떨어지게 되므로 다음과 같이 처리할 수 있다(예제를 만들고 보니 참 저렴한 영어다…).

>>> a = "HI\nMY NAME IS MARK\nNICE TO MEET YOU"
>>> print(a)
HI
MY NAME IS MARK
NICE TO MEET YOU
>>> a = '''
HI
MY NAME IS MARK
NICE TO MEET YOU
'''
>>> print(a)

HI
MY NAME IS MARK
NICE TO MEET YOU

>>> a = """
HI
MY NAME IS MARK
NICE TO MEET YOU
"""
>>> print(a)

HI
MY NAME IS MARK
NICE TO MEET YOU

4) 문자열 연산자(operator)

문자열의 경우에는 더하기와 곱하기 연산자를 사용할 수 있다.

>>> "HI" + "HELLO" #두개의 문자열을 붙여서 출력한다
'HIHELLO'
>>> "HI"*3 # 문자열을 3번 반복한다
'HIHIHI'
>>> "*"*10
'**********'

5) 문자열 처리

나중에 조금 복잡한 프로그래밍을 하다 보면 문자열에서 특정한 위치의 문자가 무엇인지 확인하거나 특정 부분의 문자열을 잘라내는 처리를 해야 하는 경우가 있다. 이러한 문자열을 처리하는 방법을 알기 위하여 인덱스(index)라는 개념에 대해 이해를 하여야 한다.

[그림 2] 변수의 생성과 값의 입력

문자열은 0을 시작으로 하는 고유의 길이를 가진다. 위 문장은 총 15개의 문자를 가지고 있으며 각 문자는 고유의 인덱스(index) 번호를 가진다. 즉 ‘I’는 문자열의 8번쨰이며, ‘S’는 문자열의 9번째이다. 음의 인덱스는 문자의 뒤쪽부터 계산되며, 맨 마지막 글자는 ‘-1’의 인덱스를 가진다(실제 문자열의 맨 마지막에는 null 이라는 문자가 하나 더 있기 때문에 그렇다).

>>> a = "MY NAME IS MARK"
>>> a[8]
'I'
>>> a[9]
'S'
>>> a[-7]
'I'
>>> a[-6]
'S'

문자열을 처리하는데 필요한 또 하나의 개념은 슬라이스(slice)이다. 슬라이스는 영어 뜻에서 의미하듯이 하나의 조각을 의미한다. 다음의 예를 확인해 보자.

>>> a[0:2]
'MY'
>>> a[8:10]
'IS'
>>> a[8:9]
'I'
>>> a[11:]
'MARK'
>>> a = "2017-06-25"
>>> year = a[0:4]
>>> month = a[5:7]
>>> day = a[8:]
>>> print(year)
2017
>>> print(month)
06
>>> print(day)
25

슬라이스를 이용하여 특정 문자열을 추출하는 경우에는 변수명[인덱스시작번호:인덱스마지막번호+1]로 처리한다. 만약 인덱스의 마지막을 입력하지 않으면 문자의 마지막을 의미한다.

6) 문자열 포맷팅(formatting)

문자열을 생성하고 출력하는 경우에 단순하게 여러 문자을 합치는 것이 아니라 특정한 값을 포함하고 싶은 경우가 있다. 이런 경우에 사용하는 함수가 format()이다.

>>> age = 20
>>> name = "Mark"
>>> print (name + " is " + str(age) + " years old")
Mark is 20 years old
>>> print ("{0} is {1} years old".format(name, age))
Mark is 20 years old
>>> print("%s is %d years old" % (name, age))
Mark is 20 years old

위의 예에서 ‘%s’와 같은 형식을 포맷팅 코드라고 한다. 파이썬에서 사용하는 포맷팅코드는 다음과 같다. (주의: 포맷팅 코드를 사용하면서 ‘%’를 사용해야 하는 경우에는 ‘%%’로 입력해야 파이썬 인터프리터가 혼동하지 않는다)

포맷팅코드	설명
%s	문자열(string): 모든 변수(정수, 실수 등)는 %s를 이용하여 출력할 수 있다
%d	정수
%c	문자(character)
%f	실수: ‘%5.7f’와 같은 형식을 사용할 경우에는 정수부분은 5자리(모자라면 공백으로 채운다)로 표시하고 소수점은 7자리까지 표현한다
%o	8진수
%x	16진수

7) 문자열 관련 함수(function)

파이썬에서는 문자열 처리를 위하여 미리 만들어 놓은 여러 개의 함수가 있다.

a. 특정 문자 개수: count()

>>> a = "My Name is Mark"
>>> a.count('M')
2
>>> a.count('My')
1

b. 문자 길이: len()

>>> a = "My Name is Mark"
>>> len(a)
15

c. 특정 글자의 위치: find()

>>> a = "My Name is Mark"
>>> a.find('i')
8
>>> a.find('I') #대소문자를 구별한다
-1
>>> a.find('M') #가장 먼저 찾은 인덱스를 반환한다
0
>>> a.find('m')
5
>>> a.find('is') #찾은 문자열의 맨 처음 인덱스를 반환한다
8

d. 소문자 -> 대문자: upper()

>>> a = "My Name is Mark"
>>> a.upper()
'MY NAME IS MARK'

e. 대문자 -> 소문자: lower()

>>> a = "My Name is Mark"
>>> a.lower()
'my name is mark'

f. 공백 삭제: lstrip(), rstrip(), strip()

>>> a = "     My Name is Mark     "
>>> a.lstrip()
'My Name is Mark     '
>>> a.rstrip()
'     My Name is Mark'
>>> a.strip()
'My Name is Mark'

g. 문자열 치환: replace()

>>> a  = "My name is Mark"
>>> a.replace('Mark', 'James')
'My name is James

h. 숫자 -> 문자 변환: str()

>>> a = 10
>>> print(10)
10
>>> print(str(10))
10
>>> age = 20
>>> name = "Mark"
>>> print (name + " is " + age + " years old")
Traceback (most recent call last):
  File "<pyshell#45>", line 1, in <module>
    print (name + " is " + age + " years old")
TypeError: Can't convert 'int' object to str implicitly
>>> print (name + " is " + str(age) + " years old")
Mark is 20 years old

위에서 age라는 변수를 print() 함수에서 사용하면 오류가 발생한다. 문자열을 구성하기 위하여 ‘+’ 연산자를 사용하였는데 정수형 변수가 나오니 인터프리터는 합산을 해야 하는지 문자열을 결합해야 하는지 확정할 수 없기 때문이다.

i. 문자열 분리: split()

>>> a = "My Name is Mark"
>>> a.split()
['My', 'Name', 'is', 'Mark']
>>> a = "2017-06-25"
>>> a.split('-')
['2017', '06', '25']

split() 함수는 인자를 아무것도 넣어주지 않으면 공백(space)을 기준으로 나누어 주며, 특정 문자를 기준으로 나눌 수 있다. 결과값을 보면 [‘2017’, ‘06’, ‘25’] 과 같이 출력되는데 이러한 형식을 리스트라고 한다. 리스트에 대해서는 다음 절에서 설명하도록 하겠다.

2.3 리스트(list) 자료형

리스트 자료형은 데이터들의 집합을 하나의 변수로 다루기 위하여 사용한다. 리스트는 C나 C++ 언어에서 사용하는 어레이(array)와 비슷한 개념이지만 차이점은 C에서는 동일한 데이터만을 하나의 집합으로 관리할 수 있으나(정수형 어레이는 정수의 값들만으로 구성할 수 있다) 파이썬에서는 다양한 데이터를 하나의 리스트로 관리할 수 있다.

>>> score = [100, 90, 95]
>>> score
[100, 90, 95]
>>> score[0]
100
>>> score[1]
90
>>> score[2]
95
>>> score[3]
Traceback (most recent call last):
  File "<pyshell#67>", line 1, in <module>
    score[3]
IndexError: list index out of range

리스트는 ‘[‘과 ‘]’의 쌍으로 구성되며, 각각의 요소(element)는 ‘,’를 이용하여 분리한다. 위의 예는 ‘score’라는 변수에 국어, 영어, 수학 점수를 입력한 예이다. 한 사람의 국영수 점수를 위와 같이 리스트로 관리하면 각 과목의 인덱스(위치)만 알고 있으면 하나의 데이터 집합으로 관리할 수 있다. 만약 영희와 철수의 시험점수를 관리하고 싶다면 어떻게 구성하면 가능할까? 다음의 예를 보자

>>> score = [[100, 90, 95], [70, 80, 90]]
>>> score
[[100, 90, 95], [70, 80, 90]]
>>> score[0]
[100, 90, 95]
>>> score[1]
[70, 80, 90]
>>> score[0][0]
100
>>> score[0][1]
90

리스트의 각 요소는 다양한 자료형이 입력될 수 있다고 하였다. 위의 예는 리스트의 요소로 리스트를 가지고 있는 형태로 score[0]를 영희, score[1]을 철수라고 하면 하나의 리스트 변수에 학생의 점수를 전부 관리할 수 있는 편의성을 제공한다.

1) 리스트 관련 함수(function)

파이썬에서 문자열은 작은 따옴표(‘)의 쌍, 큰 따옴표(“)의 쌍과 큰 따옴표 또는 작은 따옴표 3개의 연속된 쌍으로 만들 수 있다.

a. 추가 및 삭제: append(), insert(), pop(), del()

>>> a = [10, 20, 30, 40]
>>> a.append(50)
>>> a
[10, 20, 30, 40, 50]
>>> a.insert(1, 15)
>>> a
[10, 15, 20, 30, 40, 50]
>>> a.pop()
50
>>> a
[10, 15, 20, 30, 40]
>>> a.pop(1)
15
>>> a
[10, 20, 30, 40]
>>> del a[1]
>>> a
[10, 30, 40]

append() 함수는 리스트의 맨 마지막에 데이터를 추가할 수 있으며 insert() 함수는 특정 인덱스에 데이터를 추가할 수 있다. pop()의 경우에는 인자를 전달하지 않으면 맨 마지막 값을 삭제하고, 인덱스 값을 인자로 전달하면 해당 인덱스의 값을 삭제한다.

b. 값의 변환

>>> a = [10, 20, 30, 40]
>>> a[1]
20
>>> a[1] = 25
>>> a
[10, 25, 30, 40]

특정 인덱스의 값을 대입연산자(=)를 이용하여 변경할 수 있다.

c. 개수: count()

>>> a = ['A+', 'A0', 'A+', 'F']
>>> a.count('A+')
2
>>> a.count('F')
1
>>> a.count('B+')
0

d. 정렬: sort()

>>> a = ['A+', 'A0', 'A+', 'F']
>>> a.sort()
>>> a
['A+', 'A+', 'A0', 'F']

e. 뒤집기: reverse()

>>> a = [30, 20, 40, 15]
>>> a.reverse()
>>> a
[15, 40, 20, 30]

reverse() 함수는 단순하게 리스트의 인덱스를 역순으로 만들어주는 역할을 하며, 내부적으로 정렬을 수행하지는 않는다.

f. 삭제 및 생성: clear(), list()

>>> a = ['A+', 'A0', 'A+', 'F']
>>> a.clear()
[]
>>> type(a)
<class 'list'>
>>> b = list()
>>> type(b)
<class 'list'>

type() 함수는 변수의 자료형을 반환하는 함수이다. 초기에 빈 리스트를 생성하기 위해서는 list() 함수를 사용할 수 있다.

2) 리스트 연산자(operator)

리스트 연산자는 문자열과 같이 ‘+’와 ‘*’ 연산자를 사용할 수 있다.

>>> a = [10, 20, 30]
>>> b = [40, 50]
>>> a+b
[10, 20, 30, 40, 50]
>>> a*2
[10, 20, 30, 10, 20, 30]

2.4 튜플(tuple) 자료형

튜플형은 리스트와 비슷하지만 내부에 있는 데이터를 삭제하거나 추가할 수 없는 상수와 같은 개념으로 사용한다.

>>> a = (10, 20, 30)
>>> a
(10, 20, 30)
>>> a.append(40)
Traceback (most recent call last):
  File "<pyshell#130>", line 1, in <module>
    a.append(40)
AttributeError: 'tuple' object has no attribute 'append'
>>> a[1] = 25
Traceback (most recent call last):
  File "<pyshell#141>", line 1, in <module>
    a[1] = 25
TypeError: 'tuple' object does not support item assignment
>>> del a(1)
SyntaxError: can't delete function call
>>> a[1]
20
>>> a[1:]
(20, 30)

2.5 딕셔너리(Dictionary) 자료형

리스트나 튜플의 경우에는 데이터의 값을 가지고 오기 위하여 인덱스(index)를 이용하였다. 그러나 이러한 경우에는 인덱스 번호에 어떤 데이터를 저장하였는지 정확하게 알 수 있어야 하며, 프로그램에서 데이터의 가독성이 떨어지는 문제점을 가진다.

이러한 부분을 해결하기 위하여 도입된 딕셔너리(사전) 자료형은 키(key)와 값(value)의 쌍을 가진다.

>>> score = {'korean':100, 'english':90, 'math':95}
>>> score
{'math': 95, 'korean': 100, 'english': 90}
>>> score['english']
90
>>> score['english'] = 95
>>> score
{'math': 95, 'korean': 100, 'english': 95}
>>> score['science'] = 90
>>> score
{'math': 95, 'korean': 100, 'science': 90, 'english': 95}
>>> del score['math']
>>> score
{'korean': 100, 'science': 90, 'english': 95}
>>> del score['music']
Traceback (most recent call last):
  File "<pyshell#159>", line 1, in <module>
    del score['music']
KeyError: ‘music'

딕셔너리형은 인덱스 대신 위의 예와 같이 키값을 이용하여 데이터값을 조회할 수 있는 장점을 가진다. 리스트에서는 입력한 순서대로 데이터가 유지되나 딕셔너리형에서는 파이썬에서 자체적으로 순서를 정렬하는 차이점을 가지고 있다. 주의할점은 키값은 고유값으로 중복될 수 없는 값이다. 만약 키값이 중복된다면 파이썬에서는 어떤 데이터를 반환할지 결정할 수 없기 때문이다.

딕셔너리의 키값이 존재하는 경우에는 해당 키값의 데이터를 변경하게 되고, 키값이 없는 경우에는 새로운 쌍을 추가한다. 딕셔너리의 키값을 지정하여 데이터를 삭제할 수 있으며, 키값이 존재하지 않는 경우에는 삭제시에 오류를 발생한다.

1) 딕셔너리 함수(fuction)

딕셔너리를 처리하기 위한 함수는 다음과 같다.

a. Key 객체 반환: keys()

>>> score = {'korean':100, 'english':90, 'math':95}
>>> score.keys()
dict_keys(['math', 'korean', 'english'])
>> list(score.keys())
['math', 'korean', 'english']

keys() 함수는 딕셔너리의 키값들의 객체(object)를 반환한다. 파이썬 2.X 버전에서는 리스트를 반환하였으나 메모리 낭비를 없애기 위하여 객체형으로 반환을 하는 것으로 변경되었다. 리스트형으로 반환한다. append()등의 함수를 사용하기 위해서는 list() 함수를 이용하여 데이터를 변환할 수 있다.

b. Value 객체 반환: values()

>>> score = {'korean':100, 'english':90, 'math':95}
>>> score.values()
dict_values([95, 100, 90])
>>> list(score.values())
[95, 100, 90]

c. Key, Value 쌍 객체 반환: items()

>>> score = {'korean':100, 'english':90, 'math':95}
>>> score.items()
dict_items([('math', 95), ('korean', 100), ('english', 90)])
>>> list(score.items())
[('math', 95), ('korean', 100), ('english', 90)]

d. 삭제: clear()

>>> score = {'korean':100, 'english':90, 'math':95}
>>> score.clear()
>>> score
{}

e. 데이터 가져오기: get()

>>> score = {'korean':100, 'english':90, 'math':95}
>>> score.get('korean')
100
>>> score['korean']
100
>>> score.get('science')
>>>
>>> score.get('science', 'NONE')
'NONE'

get() 함수는 score[‘key값’]과 동일한 기능을 한다. score[‘key값’]의 경우에는 키가 없을 경우 오류가 발생하지만 get()함수는 아무런 값도 반환하지 않는다. 또한 키값이 없는 경우에는 특정한 값을 반환하도록 인자를 추가할 수 있다.

f. 키값 유무 확인: in

>>> score = {'korean':100, 'english':90, 'math':95}
>>> 'korean' in score
True
>>> 'science' in score
False

앞서서 키값이 없는 값을 조회하는 경우에는 오류를 발생한는 것을 확인하였다. 이러한 것을 막기 위하여 딕셔너리 내부에 키값이 존재하는지 확인하기 위해 ‘in’을 사용한다. ‘True’는 ‘참’을 의미하며, ‘False’는 거짓을 의미한다.

2.6 집합(set) 자료형

집합 자료형은 기존의 프로그래밍언어에서는 보기 힘들었던 자료형으로 데이터를 집합으로 취급하여 집합연산(교집합, 합집합 등)을 할 수 있는 장점이 있다. 집합 자료형은 순서가 없이 존재하기 때문에 리스트나 튜플의 인덱스를 이용하여 데이터를 조회하거나 딕셔너리의 키값을 이용하는 방법이 불가능하기 때문에 리스트나 튜플로 변경하여 사용하여야 한다.

>>> a = set([10, 20, 30])
>>> a
{10, 20, 30}
>>> b = set("PYTHON")
>>> b
{'P', 'T', 'O', 'H', 'Y', 'N'}

집합 자료형은 리스트 또는 문자열을 데이터로 입력받아 키값이 없는 딕셔너리 형태의 데이터를 반환한다. 또한 집합 자료형은 순서가 없이 존재하기 때문에 리스트나 튜플의 인덱스를 이용하여 데이터를 조회하거나 딕셔너리의 키값을 이용하는 방법이 불가능하기 때문에 리스트나 튜플로 변경하여 사용하여야 한다.

1) 집합 연산

집합 자료형은 수학시간에 배운 교집합, 합집합, 차집합 연산을 할 수 있다.

a. 교집합(intersection)

>>> a = set([10, 20, 30])
>>> b = set([30, 40, 50])
>>> a & b
{30}
>>> a.intersection(b)
{30}

b. 합집합(union)

>>> a = set([10, 20, 30])
>>> b = set([30, 40, 50])
>>> a | b
{50, 20, 40, 10, 30}
>>> a.union(b)
{50, 20, 40, 10, 30}

합집합은 중복된 값은 하나만 반환한다.

c. 차집합(difference)

>>> a = set([10, 20, 30])
>>> b = set([30, 40, 50])
>>> a - b
{10, 20}
>>> a.difference(b)
{10, 20}

2) 집합 함수(function)

집합 자료형은 데이터를 조작하기 위하여 다양한 함수를 제공한다.

a. 값 추가하기: add(), update()

a = set([10, 20, 30])
>>> a
{10, 20, 30}
>>> a.add(40)
>>> a
{40, 10, 20, 30}
>>> a.update([50, 60, 70])
>>> a
{70, 40, 10, 50, 20, 60, 30}

b. 값 삭제: remove()

>>> a = set([10, 20, 30])
>>> a
{10, 20, 30}
>>> a.remove(20)
>>> a
{10, 30}

2.7 참(True)/거짓(False) 자료형

참과 거짓은 특정 변수에 값이 비어 있거나 조건 비교를 하기 위하여 사용한다.

값	True or False
“abc”	True
“”	False
[10, 20, 30]	True
[]	False
1	True
0	False
None	False (파이썬에는 None 이라는 데이터 값이 존재한다. 단순하게 값이 없다고 생각하면 된다)

활용 방법은 다음장의 흐름제어 부분에서 설명하도록 한다.

여행의 기록

Thu, 28 Dec 2017 02:01:00 +0000

승준(Eric)군과 서연(Jennifer)양의 여행 기록을 남기려 합니다.

COMMING SOON…

1. 파이썬을 시작하기 전에 알아둘 사항

Thu, 28 Dec 2017 02:01:00 +0000

파이썬 프로그래밍

프로그래밍이란 크게 세가지 절차를 거친다. 데이터를 입력 받고, 입력받은 데이터를 여러 과정을 거쳐 처리하고, 처리된 데이터를 출력하는 과정이다. 입력의 방식은 단순하게 키보드, 파일등이 될 수 있으며, 처리과정은 우리가 일상생활에서 어떠한 일을 처리하기 위한 계산(연산), 반복, 조건등이 반복되게 되며, 그 결과값이 화면이나 프린터등을 이용하여 출력하게 된는 과정을 컴퓨터 언어로 구현하는 것을 의미한다. 파이썬 설치에서 언급한 것처럼 파이썬은 기존의 프로그래밍언어의 복잡성을 최소화 하여 최대한 단순하게 설계된 언어로써 상대적으로 배우기 쉬운 문법체계를 가지고 있다.

파이썬 프로그래밍을 하기 위하여 파이썬을 설치하였다면, 옵션중 ‘tcl/tk IDLE’을 설정하여 파이썬 통합개발환경(Integrated Development Environment)을 설치할 수 있는 것을 알 수 있다. 편집기는 단순하게 IDLE 뿐만 아니라 메모장, Notepad++, PyCharm, Visual Studio 등 다양한 편집기를 사용할 수 있으며, 편의에 따라 편집기는 선택하면 된다. 본 과정에서는 파이썬 IDLE를 사용하도록 하겠다.

1. 시작하기 전에 알아둘 사항

1.1 파이썬 IDLE 사용법

먼저 [그림 1]처럼 파이썬 메뉴에서 IDLE를 실행한다.

[그림 1] Python 3.5 메뉴

css 파이썬 IDLE를 실행시키면 [그림 2]와 같이 파이썬 IDLE가 실행된다.

[그림 2] 파이썬 IDLE 환경

파이썬 IDLE는 크게 2가지 부분으로 구성된다. 한 부분은 쉘(Shell)이라고 부르는 파이썬이 실행되는 창과 편집기(Editor) 창으로 구성된다. 파이썬 쉘에 나타나는 ‘»>’ 모양을 프롬프트(prompt)고 한다. 쉘 프롬프트에 [그림 3]과 같이 입력한다.

[그림 3] 문자열 출력

우리는 print 라는 출력함수를 이용하여 “파이썬 시작”이라는 문자열을 화면에 출력해 보았다(문자열의 처리 등은 후에 설명할 것이니 너무 걱정하지 말자). 여기서 엔터를 치자마자 화면에 “파이썬 시작” 이라는 글자가 화면에 출력되었는데 파이썬 쉘에서는 엔터를 치면 바로 파이썬 인터프리터가 바로 그 명령을 수행하는 구조로 되어 있다. 우리는 필요에 따라서 데이터를 입력받고, 처리하고 출력하는 과정을 프로그래밍해야 하는데 이렇게 엔터를 입력할 때 마다 바로 바로 처리가 되게 되면 문제가 발생한다. 이를 위해서 파이썬 프로그램 파일을 작성하고 이를 한꺼번에 처리하기 위한 방법이 필요하다.

[그림 4] 파이썬 파일의 생성

[그림 4]와 같이 상단의 [File] » [New File]을 선택하면 [그림 5]와 같이 편집기 창이 나타난다.

[그림 5] 파이썬 프로그램 편집기

편집창에 [그림 5]와 같이 입력한 후 [File]의 [Save]를 선택하면 [그림 6]과 같이 저장 대화상자가 나타난다. PC의 특정 위치에 저장할 파일명을 입력한 후 [저장]버튼을 누른다.

[그림 6] 작성된 파일의 저장 대화 상자

저장이 완료된 후 [그림 7]과 같이 메뉴의 [Run] » [Run Module]을 선택한다.

[그림 7] 작성한 프로그램의 실행

에러가 없이 정상적으로 입력되었다면 [그림 8]과 같이 파이썬 쉘에 결과값이 나타날 것이다.

[그림 8] 저장된 파일에서 파이썬의 실행 결과 출력

[그림 8]에서 보듯이 파이썬 쉘에서는 저장된 위치의 파일을 실행시키고, 그 결과값을 화면에 출력하였다.

1.2 기본 규칙

파이썬 프로그래밍에 있어서는 몇 가지 규칙이 존재한다.

1) 한줄에 하나의 명령어 입력이 원칙

일반적으로 하나의 명령은 한줄에 기입한다. 만약 두개의 명령을 한줄에 쓰게 되는 경우에는 ; 기호를 이용하여 분리한다. 한 행에 여러 개의 명령어를 입력할 수 있지만 이런 방식은 나중에 프로그램을 분석할 때 혼돈이 생기므로 가급적 사용하지 않는 것이 좋다.

>>> a = 1
>>> b = 2
>>> print (a+b)
3
>>> c=3;d=4;print(c+4)
7
>>>

2) 들여쓰기

파이썬에서는 공백(space)이 상당히 중요한 역할을 한다. 다음의 예에서는 프롬프트 뒤에 스페이스바를 이용하여 공백을 하나 입력한 후 print 함수를 입력한 예이다.

>>>  print ("공백")
SyntaxError: unexpected indent
>>>

친절하게 파이썬에서는 들여쓰기(indentation)이 잘못되었다고 오류를 출력한다. 하나의 명령어에 하위로 따라오는 명령어 - 이렇게 구성되는 것을 블록(block)이라고 한다 - 는뒤에 반복문 또는 제어문에서 설명할 것이다. 블록을 구성할 때는 하위 명령어들은 반듯이 [Tab]키를 이용하여 들여쓰거나 스페이스바를 이용하여 4칸을 들여써야 한다.

3) 주석(Comment)

주석(comment)은 프로그래밍 명령과는 상관없이 프로그램을 작성하면서 설명을 기입할 때 사용한다. 프로그램은 작성후 다른 사람이 코드를 볼 수 있으며, 필요에 따라 유지보수가 필요한 경우가 발생하는데 이때 주석을 표기해 놓으면 많은 도움이 된다. 주석은 # 표시 뒤에 기록한다.

>>> print("파이썬 시작") #주석
파이썬 시작
>>> #주석표시가 된 부분은 파이썬 인터프리터에서 해석하지 않는다
>>> print(“파이썬 시작”)
파이썬 시작

4) 함수(function)

우리가 중학교때 배운 함수를 기억하자. ‘y = 3x + 1’이라는 함수가 있다고 생각해 보자. 우리는 x에 특정값을 입력하면 y의 값을 얻을 수 있다(x=3, y=10). 동일한 개념으로 프로그래밍에서 함수(function)는 어떤 값을 입력하면 특정한 값을 반환하는 역할을 한다. 프로그램에서 모든것을 다 스스로 처리하려면 프로그래밍은 너무 어렵고 고통스러운 작업일 것이다. 이런 불편함을 해소하기 위해서 파이썬에서는 많이 쓰는 기능들을 함수로 미리 만들어 놓고 제공한다. 앞에서 print()라는 것이 함수로써 문자열을 입력하면 화면에 출력하는 것을 보면 쉽게 이해가 갈 것이다.

시작하기 - PYTHON 설치

Thu, 28 Dec 2017 01:01:00 +0000

파이썬(Python)은 프로그래머인 귀도 반 로섬(Guido van Rossum)이 1991년도에 발표한 프로그래밍 언어로, 플랫폼 독립적이며 인터프리터(Interpreter)식, 객체지향적(object oriented), 동적 타이핑(dynamically typed) 대화형 언어이다. 파이썬이라는 이름은 귀도가 좋아하는 코미디 〈Monty Python’s Flying Circus: 몬티 파이썬의 날으는 써커스〉에서 따온 것이라고 한다. 파이썬은 고대 그리스 신화에 나오는 큰 뱀을 의미하며, 이 때문에 파이썬의 로고로 뱀 모양을 사용하고 있다.

파이썬은 비영리로 운영되는 ‘파이썬 소프트웨어 재단’이 관리하는 개방형, 공동체 기반 개발 모델을 가지고 있으며 무료로 누구나 다운로드 받아 사용 가능하다.

파이썬을 다운로드 받기 위하여 공식 홈페이지인 https://www.python.org 로 이동하면 [그림 1]과 같이 메인 홈페이지를 만날 수 있다.

[그림 1] 파이썬 메인 홈페이지

파이썬 메인 홈페이지의 [Downloads]메뉴를 클릭하면 [그림 2]와 같은 화면이 나타난다.

[그림 2] 파이썬 다운로드 메뉴

2017년 6월 10일 현재 파이썬은 3.6.1 버전과 2.7.13 버전이 출시되어 있다. 일반적으로 프로그래밍언어는 하나의 형태가 계속 버전업 되는 형태인데 파이썬의 경우에는 2.X 와 3.X 버전이 있다. 3.X 버전에서는 모든 변수가 객체의 형식으로 처리된다는 점과 유니코드(Unicode)를 지원하는 것이 2.X 와의 차이라고 할 수 있다(2.X 와 3.X는 지원하는 모듈과 문법적인 변경이 있으므로 주의하여야 한다). 공식적으로 파이썬 2.X 버전은 2.7.X 버전을 기준으로 제품의 개발이 종료되었으며, 3.X 버전이 계속 업데이트 되고 있는 상황이므로 모든 코드는 3.X를 기준으로 설명한다.

[그림 2]의 [All Releases]를 선택하면 현재까지 릴리즈된 모든 버전을 확인할 수 있다. 본 과정에서는 파이썬 3.5.1을 기준으로 사용하였으므로 [그림 3]에서 3.5.1 버전을 찾아 다운로드를 클릭한다.

[그림 3] 파이썬 다운로드(모든 버전중 3.5.1 선택)

3.5.1 버전을 선택하여 [Download]를 클릭하면 [그림 4]와 같이 파이썬 3.5.1 버전의 특성 및 다운로드 페이지가 나타난다.

[그림 4] OS 별 설치 파일 선택 및 다운로드

자신이 사용하는 OS의 버전 및 프로세서 종류에 맞는 파일을 선택한 후 다운로드 하여 PC에 저장한다(본 과정에서는 마이크로소프트 윈도우 운영체제를 기본으로 한다).

[그림 5] 파이썬 3.5.1 설치 파일

[그림 5]와 같이 탐색기에서 다운로드 받은 디렉터리로 이동하여 실행파일을 실행시키면 [그림 6]과 같이 설치화면이 나타난다.

[그림 6] 파이썬 설치 1

파이썬 설치 파일은 기본설정으로 설치하기 위한(Install Now)와 사용자 설치(Customize installation)를 지원한다. ‘Add Python 3.5 to PATH’ 항목에 체크를 하면 윈도우 경로(PATH) 파일에 파이썬 설치 디렉터리를 추가하여 도스창(Windows Command)의 어느 경로에서든 파이썬을 실행할 수 있도록 지원한다. 해당 항목에 체크(PATH를 추가하지 않는 경우에는 파이썬 기능을 사용하기 위하여 해당 패스로 항상 이동해야 하는 번거로움이 발생할 수 있다)를 한 후 [Customize instllation]을 클릭하면 [그림 7]과 같은 창이 나타난다.

[그림 7] 파이썬 개발환경 옵션 선택

[그림 7]은 파이썬 기본 프로그램에 추가적으로 설치가 가능한 옵션을 선택하는 창이다. 선택할 수 있는 옵션의 각 기능은 다음과 같다.

항목	내용
Documentation	파이썬 관련 문서 설치
pip	파이썬 추가 패키지(라이브러리)를 손쉽게 설치할 수 있도록 지원
tcl/tk and IDLE	파이썬 GUI(Graphic User Interface) 표준 라이브러리인 Tkinter의 설치 및 파이썬 통합개발환경(IDLE: Integrated DeveLopment Environment) 설치
Python test suite	파이썬 단위 모듈 테스트를 지원하는 프레임워크(Framework)

필요한 기능을 선택한 후 (pip 와 IDLE는 필수적으로 선택하는 것이 정신건강에 좋다) [Next]버튼을 누르면 [그림 8]과 같이 추가 옵션을 선택하는 창이 나타난다.

[그림 8] 파이썬 설치 추가 옵션

필요한 추가 옵션을 선택한 후 설치 경로를 지정한 후 [Install] 버튼을 누르면 [그림 9]와 같이 설치가 진행된다.

[그림 9] 파이썬의 설치

설치가 완료되면 [그림 10]과 같이 완료 메시지가 나타난다.

[그림 10] 파이썬 설치 완료

[그림 10]과 같이 설치가 완료되었으면 [그림 11]과 같이 [시작]  [모든 프로그램]  [Python 3.5] 메뉴가 생성되고 지정한 파일이 생성된 것을 확인할 수 있다.

[그림 11] Python 3.5 메뉴

설치가 완료되었으면 ‘Python 3.5(64-bit)’ 또는 ‘IDLE(Python 3.5 64-bit)’를 선택하여 파이썬 개발환경을 실행시킬 수 있다. [그림 12]는 ‘Python 3.5(64-bit)’를 실행시킨 것이며 [그림 13]은 ‘IDLE(Python 3.5 64-bit)’를 실행시킨 것이다. IDLE를 사용하게 되는 경우에는 프로그램 파일의 저장, 불러오기 등의 통합환경을 제공하므로 훨씬 편하게 사용할 수 있다.

[그림 12] Python 3.5 인터프리터(쉘) 실행

[그림 13] Python IDLE 인터프리터(쉘) 실행

인터프리터는 파이썬 쉘(Python Shell)이라고 하며, ‘»>’는 프롬프트(prompt)라고 한다. 이로써 파이썬 개발 환경의 설치가 마무리 되었다.

블로그를 시작하며

Wed, 27 Dec 2017 14:55:39 +0000

워드프레스를 사용하면서 코드를 표시하기가 불편해서 Github와 jekyll를 이용하기로 하였습니다. 이 블로그는 아빠의 입장에서 제 아이들과 함께 컴퓨터 공부를 하면서 정리한 자료들이 기록될 예정입니다.

Mark Lee (이원하)

스마트 컨트랙트(Smart Contarct) 개발환경 구축 (Geth)

스마트 컨트랙트(Smart Contarct) 개발환경 구축 (Geth)

1. Go Ethereum

1.1 사설 이더리움의 설치

1.1.1 Geth 클라이언트 계좌 생성 및 조회

1.1.2 사설 네트워크(Private Network)의 제네시스 블록 정의

1.1.3 사설 이더리움 네트워크 실행

1.1.4 Geth 콘솔의 활용

블록체인과 이더리움이란?

블록체인과 이더리움이란?

1. 블록체인이란?

1.1 블록(Block)

1.2 체인(Chain)의 구성 및 역할

1.3 Nonce 값의 계산 - 작업 증명(POW: Proof Of Work)

1.4. 블록체인의 위변조 방지

1.5 거래내역의 전파 및 충돌해소

2. 이더리움

2.1 스마트 컨트랙트

2.2 가스(Gas) 비용

3. 블록체인을 이용한 서비스

6. 지도 시각화 – Folium

6. 지도 시각화 - 포리움(Folium)의 설치 및 활용

6.1 Folium 설치 및 객체 생성

6.2 다른 유형의 맵 호출

6.3 마커(Marker)와 팝업(Popup)의 설정

6.4 JSON 활용 데이터

6.5 네이버 주소 API를 이용하여 지도에 표시

5. 히트맵(Heatmap) – seaborn, numpy

5. 히트맵(Heatmap) – seaborn, numpy

4. 데이터 기반 추천서비스 - 상관관계분석, pandas

4. 데이터 기반 추천: 데이터 상관 관계 분석

4.1 상관분석과 상관계수

4.2 데이터 테이블 생성: pandas 패키지

4.2.1 Series

4.2.2 DataFrame

4.3 공공데이터를 이용한 상관분석

3. 다빈도 명사추출 시각화 - KoNLPy, matplotlib, PyTagCloud

3. 명사 추출 및 빈도 분석

2. 그래프를 그리자 - matplotlib

2. 그래프를 그리자 : matplotlib

2.1 기본 그래프 그리기

2.2 복수개의 시리즈 그리기

2.3 한글 처리

2.4 한 화면에 여러개 그래프 그리기

2.5 그래프에 문자 삽입

1. 빈도 분석 - KoNLPy 설치하기(문장 형태소 분석)

1. 빈도 분석: 문장 형태소 분석 - KoNLPy

1.1 코엔엘파이(KoNLPy)의 설치 및 활용?

11. 웹 페이지 크롤링

11. 일반적인 웹 페이지 크롤링

11.1 이상한 나라의 엘리스 맛있는 스프: BeautifulSoup

10. 공공 정보 데이터 수집하기

10. 공공 정보 데이터 수집하기

10.1 전국 유료 관광지 입장객 정보

10.2 파이썬 그래프 모듈: matplotlib

10.3 출입국 관광 통계 서비스

9. 네이버 지도 API(주소, 좌표변환) 활용

9. 네이버 지도 API(주소, 좌표변환) 활용

8. 네이버 데이터 수집하기

8. 네이버(NAVER) 데이터 수집하기

8.1 검색 API의 활용

7. 트위터 스트립(Stream) 수집하기

7. 트윗(Tweet) 스트림 가지고 오기

6. 트위터 데이터 수집하기

6. Twitter 데이터 수집

6.1 OAuth란?

6.1.1 OAuth 1.0a 인증 과정

6.1.2 OAuth 2.0의 탄생

6.2 트윗(Tweet) 가지고 오기

5. Facebook 데이터 수집

5. Facebook 데이터 수집

5.1 페이스북 그래프(Graph) API

5.1.1 읽기

5.1.2 페이지 조회

5.2 페이스북 ID 가지고 오기

5.3 페이스북 포스트(/{post-id})) 가져오기

5.4 페이스북 포스트(/{post-id})) 저장

4. 정부3.0 공공 데이터 포털 API 사용하기

4. 정부3.0 공공 데이터 포털 API 사용하기