Python

오픈소스 비즈니스 컨설팅
이동: 둘러보기, 검색

오브젝트 지향 프로그래밍, 구조화 프로그래밍, 관점 중심 프로그래밍 및 함수 프로그래밍을 지원하는 프로그램 언어인 Python을 정리 한다.


설치 가이드

Python 배포판

Python 설치

Python 최신 버전은 3.0.1이나 Apache HTTP Server 2.2와 연동을 위해 Python 2.5 버전을 설치 한다.


  • 다운로드 받은 파일을 실행한 후 "Install for all users"를 선택 한다.

설치 시작

  • Python 설치 디렉토리를 설정 한다.

폴더 설정

  • 설치할 모듈을 선택 하는 화면으로 그냥 "Next" 버튼을 선택 하여 설치를 완료 한다.

모듈 선택

  • Python 설치 후 사용하기 위해서 필요한 환경을 설정한다.
  • PYTHON_HOME=c:/app/Python
  • PATH=c:/app/Python (기존 PATH에 추가)

환경 설정

  1. 바탕화면의 "내 컴퓨터"에서 오른 마우스를 클릭한 후 "속성"을 선택한다.
  2. "고급" 탭에서 하단에 있는 "환경 변수" 버튼을 누른다.
  3. 위에 명시한 환경 변수를 추가 또는 수정한다.


  • 환경 설정이 정상적으로 되었는지 확인하기 위해 도스창에서 다음 명령을 사용하여 Python의 버전을 확인한다.
python -V

Setuptools 설치

파이선용 패키지 설치 자동화 툴인 setuptools를 설치 한다.

  • 다운로드 사이트에서 MS Windows Installer인 "setuptools-0.6c9.win32-py2.5.exe" 파일을 다운로드 한다.


  • 다운로드 받은 프로그램을 관리자 권한으로 실행한 후 "다음(N)" 버튼을 선택 한다.

설치 시작

  • Python이 설치된 디렉토리와 설치할 디렉토리를 확인 한다.

설치 폴더

  • "다음(N)" 버튼을 선택하여 설치를 완료 한다.

설치 완료

  • setuptools는 아래 디렉토리에 설치가 된다.
$PYTHON_HOME/Lib/site-packages/setuptools
$PYTHON_HOME/Scripts/    #--- 실행 프로그램은 여기에 설치가 된다.


  • Python용 setuptools 설치 후 사용하기 위해서 필요한 환경을 설정한다.
  • PYTHONPATH=c:/app/Python/Lib;c:/app/Python/DLLs;c:/app/Python/Lib/lib-tk;c:/app/Python/Lib/site-packages
  • PATH=c:/app/Python/Scripts (기존 PATH에 추가)

환경 설정

  1. 바탕화면의 "내 컴퓨터"에서 오른 마우스를 클릭한 후 "속성"을 선택한다.
  2. "고급" 탭에서 하단에 있는 "환경 변수" 버튼을 누른다.
  3. 위에 명시한 환경 변수를 추가 또는 수정한다.


  • Setuptools을 사용한 python용 추가 모듈 설치 방법
  • 추가 모듈은 도스창에서 다음 명령으로 쉽게 설치할 수 있다.
  • 설치된 python 버전에 맞는 추가 모듈이 자동으로 설치 된다.
easy_install 모듈명


Python 추가 모듈 설치

Apache Python Module 설치

  • Apache Python Module 설치


  • 다운로드 받은 파일을 관리자 권한으로 실행하여 "다음(N)" 버튼만 눌러 주면 설치가 된다.
  • 설치된 Apache HTTP Server의 홈 디렉토리를 물어보면 해당 디렉토리를 선택하면 된다.
$PYTHON_HOME/Lib/site-packages/mod_python   #--- 폴더가 생성 된다.
$APACHE_HOME/modules/mod_python.so                #--- 파일이 생성 된다.


  • Python sys.path에는 다음과 같은 값이 설정 된다.
C:/WINDOWS/system32/python25.zip
C:/app/Python/Lib
C:/app/Python/DLLs
C:/app/Python/Lib/lib-tk
C:/app/Apache
C:/app/Apache/bin
C:/app/Python
C:/app/Python/lib/site-packages


  • $APACHE_HOME/conf/httpd.conf에서 Python 사용을 위한 환경 설정
  • mode_python은 기본적으로 세가지 handler를 제공 한다.
  • testhandler : 테스트용으로 Python으로 전달된 값을 웹페이지에 표시 한다.
  • publisher : CGI 방식으로 Python을 실행 한다. (~.py)
  • psp : PSP (Python Server Page) 방식으로 Python을 실행 한다. (~.psp)
LoadModule cgi_module modules/mod_python.so #--- 추가

<Directory "C:/www">                         
   #--- 폴더별로 아래 설정을 다르게 가질 수 있다.
   Options Indexes FollowSymLinks ExecCGI  #--- CGI를 위해 ExecCGI 추가 

  ###--- Test Hanldler를 사용하여 Python 정보와 요청 정보 등을 확인
  ###--- http://localhost/pythoninfo.py
#    PythonHandler mod_python.testhandler
#    PythonDebug On

  ###--- CGI 방식으로 Python 파일(~.py) 실행
  ###--- http://localhost/pythoninfo.py/handler
#    PythonHandler mod_python.publisher
#    PythonDebug On

  ###--- PSP (Python Server Page) 방식으로 Python 파일(~.psp) 실행
  ###--- http://localhost/pythoninfo.psp
  PythonHandler mod_python.psp
  PythonDebug On
</Directory>

<IfModule dir_module>                       #--- index.cgi index.psp index.py 추가
   DirectoryIndex index.html index.cgi index.psp index.py
</IfModule> 

<IfModule mime_module>
   AddHandler mod_python .py .psp          #--- 추가
</IfModule>


  • Python에서 한글 설정

  • CGI 방식으로 python 동작 확인 방법
  • httpd.conf에서 mod_python.publisher를 사용하도록 설정하고 Apache를 재기동 한다.
  • c:/www/pythoninfo.py (UTF-8 형태로 저장)를 아래와 같이 생성한다.
  • http://localhost/pythoninfo.py 를 호출 한다.
# -*- coding: utf-8 -*-
from mod_python import apache

def handler(req):
   req.content_type = 'text/html'
   
   req.write("\n")
    req.write("\n")
    req.write("    \n")
    req.write("    Python 정보\n")
    req.write("\n")
    req.write("\n")
    req.write("\n")
    req.write("Python Info (파이썬 정보)!\n")
    req.write("\n")
    req.write("\n")



  • PSP (Python Server Page) 방식으로 python 동작 확인
  • httpd.conf에서 mod_python.psp를 사용하도록 설정하고 Apache를 재기동 한다.
  • c:/www/pythoninfo.psp (UTF-8 형태로 저장)를 아래와 같이 생성한다.
  • http://localhost/pythoninfo.psp 를 호출 한다.
 
    
    Python 정보
 
 
 
 Python Info (파이썬 정보)!


MySQL for Python 설치

  • MySQL과 연동할 필요가 있을 경우에만 설치 한다.




  • 다운로드 받은 파일을 실행하여 "다음(N)" 버튼만 눌러 주면 아래 폴더에 설치가 된다.
$PYTHON_HOME/Lib/site-packages/MySQLdb

Python 설치

CentOS에서 Python 설치

yum install python python-*
python -V

Windows에서 Python 설치

Python 문법

Python 기초

  • 파일의 문자셋 설정
# -*- coding: utf-8 -*-
  • 코드 블록
  •  :와 들여쓰기로 표시
~:
   ~
  • 주석
#!/user/bin/python
# _*_ coding: cp949 _*_
# ~
  • 한 라인에서 여러 문장을 실행
~; ~; ~
  • _ : 인터프리터 모드에서 최종 실행된 결과가 저장되는 변수명

자료형

  • str(type(~)) : 자료형의 이름을 표시
  • Python에서 변수는 Call by Reference 값을 가짐, 즉 값을 저장하는 것이 아니라 값이 저장된 곳의 주소를 가짐
import copy
b = a[:]    : a의 값이 복제되어 다른 주소에 저장된 후 b에 할당됨
b = copy.deepcopy(a)

b = a
b = copy.copy(a)
숫자
  • int, float, complex (복소수)
  • int 상수 : 0b~. 2진수, 0o~. 8진수, 0x~. 16진수
  • int를 진수로 표시된 숫자로 변환 : bin(78), oct(78), hex(78)
  • x = 3 - 5i
  • x.real : 실수부
  • x.imag : 허수부
  • x.conjugate()
format(숫자, ",.2f")
format(숫자, "6,.2f")
문자
  • string : "~", '~'
  • str[0] : 0. str 문자열의 첫번째 문자, 단 수정시에는 사용할 수 없음
  • str[-1] : -1. str 문자열에서 마지막 문자
  • str[1:4] : str 문자열에서 인덱스가 1에서 4까지의 문자
  • len(str) : 문자열의 길이
  • ~.encode('utf-8')
  • ord('s') : 문자의 유니코드 값, chr(115) : 유니코드에 해당하는 문자
"""
Hear Text
"""
  • str1 + str2 : 문자열 합치기
  • str.split['x'] : 문자열을 쪼개어 List에 저장 한다.
  • str(~) : 숫자를 string 형으로 변환
  • ~.rjust(3) : 주어진 인수의 길이로 오른쪽 정렬 합니다.
  • ~.zfill(3) : 주어진 인수의 길이로 왼쪽에 0을 채워 표시 합니다.
  • format
  • {~:~n} : n. 크기, >. 오른쪽 정렬, < 왼쪽 정렬, ^. 가운데 정렬
  • = 부호 표시, +. Plus 부호, -. 마이너스 분호,
  • b. 이진수, d. 십진수, o. 8진수, x. 16진수, c. 문자열
  • e. 지수, f. 실수, %. 퍼센트 ({~:.3f} : 소숫점 세자리까지 표시)
"{0}~{1}".format(~, ~)
"{aaa}~{bbb}".format(aaa=~, bbb=~)

dic = {"item": "apple", "color": "red"}
"{0[item]}" ~ {0[color]}".format(dic)
"{item}" ~ {color]}".format(**dic)

"{~.~}.format(**vars())
"{0:$>5}".format(~) : 전체 길이 5, 빈공간을 채우는 문자는 $
논리
  • bool : True, False
Array
  • Array, 배열
from array import array
tmpArray = array('i')   #--- https://docs.python.org/3/library/array.html
  • ~[n] : 0, 1, 2, ...
  • -1. 맨 마지막 항목
  • 0:2 : 0, 1, 2 항목 배열
List
  • 생성자 : list(), []
  • List : [~, ~, ~], 0. 첫번째 항목
  • len(~) : List의 크기
  • ~.append(val) : 항목 추가
  • ~.extend(valList) : List 추가
  • ~.insert(pos, val) : pos 번째 위치에 x 추가
  • ~.remove(val) : val 값을 갖는 항목 삭제
  • ~pop([pos]) : pos 위치에 있는 항목 삭제, 위치 생략시 맨 마지막 항목 삭제
  • del ~[pos] : pos 위치에 있는 항목 삭제
  • ~.index(val) : val 값을 갖는 항목의 위치 반환
  • ~.count(val) : val 값이 나타나는 횟수 반환
  • ~.sort() : 정렬
  • ~.reverse() : 전체 항목의 순서를 거꾸로 조정
zip(~, ~, ~) : 여러개의 배열을 같은 인덱스 순으로 합침
Set
  • Set, 집합, { }
  • len(~)
  • add(~), remove(~), discard(~), pop(~), clear()
  • a.union(b) : 합집합
  • a.intersection(b) : 교집합
~ = {~, ~, ~}
~ = set('문자열')

for name, value in ~.items():
 ~
x in s
x not in s
Dictionary
  • 생성자 : dict(), {}
  • Dictionary
  • ~.items(), ~.keys(), ~.values() : Tuple로 반환
  • ~['~'] = ~
  • del ~['~']
~ = dict(a=1, b=3, c=5)
~ = {'a': 1, 'b':3, 'c': 5}
Tuple
  • 생성자 : tuple(), (~, ~, ~)
  • Tuple : 변수들의 모임, ( ), 읽기 전용
~ = ~, ~, ~
~ = (~, ~, ~)
~[pos] : Tuple에서 pos 위치의 변수, 0, 1, 2, ...
특수
  • None : 값이 없음
if ~ is None:

조건문/반복문

  • 블럭의 시작은 :로 표시하고 블럭의 내용은 Identation (들여쓰기)로 구분 합니다.
  • 아무것도 실행하지 않는 코드
pass
  • if 문
if ~:
   ~
elif ~:
   ~
else:
   ~
  • while 문
while ~:
   ~
  • for 문
for ~ in ~:
   ~
   break
   continue
else:                     #--- while 또는 for 문이 정상적으로 종료 되었을 경우 실행됨
   ~
  • 표현식
[표현식 for ~ in ~ if ~]
표현식 for ~ in ~ if ~
  • range(3) : 0, 1, 2
  • range(5, 8) : 5, 6, 7, 8
  • range(0, 10, 3) : 0, 3, 6, 9
  • 리스트 내장 : [~ for ~ in ~ if ~]
  • map 함수 : map(맵_함수, ~)
def 맵_함수(val):
   return ~                       #--- val을 가공한 값을 반환
  • 필터 함수 : filter(필터_함수, ~)
def 필터_함수(val):
   return ~                       #--- True, False
  • zip(~, ~) : 변수들의 값을 Tuple 형태로 묶어서 이터레이터 형태로 반환

For for List

msgs = [1, 2, 3, 4, 5]
for value in msgs:
    print(value)
msgs = [1, 2, 3, 4, 5]
for idx in range(len(msgs)):
    print(msgs[idx])
msgs = [1, 2, 3, 4, 5]
for idx in range(len(msgs)):
    print(msgs[len(msgs) - idx - 1])
msgs = [1, 2, 3, 4, 5]
for idx, val in enumerate(msgs):
    print(idx, val)

For for Set

msgs = {1, 2, 3, 4, 5}
for value in list(msgs):
    print(value)

For for Dictionary

msgs = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
for key, value in msgs.items():
    print(key, value)

for key in msgs.keys():
    print(key, msgs[key])

Class

  • Class 선언과 사용
class ~:
   """
   클래스 설명
   """

   __var = 0                         #--- Private 변수

   def __init__(self, value):        #--- 생성자
       pass

   def __del__(self):                #--- 소멸자
       pass

   @staticmethod
   def funcStatic():                 #--- Static Method, ClassName.funcStatic()
       pass

   def funcName(self):               #--- Class Method, instance.funcName()
       self.~

~ = className()
~.funcName()                          #--- Instance를 암묵적으로 parameter로 전달됨
~.__class__.~                         #--- Class의 변수나 함수를 참조 합니다.
  • isinstance(인스턴스, 클래스)
  • issubclass(하위클래스, 상위클래스)
  • 연산자 중복 (a를 기준으로)
  • __add__(self, ~) : a + b
  • __sub__(self, ~) : -
  • __mul__(self, ~) : *
  • __truediv__(self, ~) : /
  • __floordiv__(self, ~) : //
  • __mod__(self, ~) : %
  • __divmod__(self, ~) : divmod(a, b)
  • __pow__(self, ~) : a ** b
  • __lshift__(self, ~) : <<
  • __rshift__(self, ~) : >>
  • __and__(self, ~) : &
  • __xor__(self, ~) : ^
  • __or__(self, ~) : |
  • __abs__(self) : abs(a)
  • __pos__(self) : +a
  • __neg__(self) : -a
  • __invert__(self) : ~a
  • __lt__, __le__, __eq__, __ne__, __ge__, __gt__
  • 연산자 위치 변경, r 추가 : __radd__(self, ~) : b + a
  • 확장된 연산자 중복, i 추가 : __iadd__(self, other) : a += b
  • __len__(self) : len(a)
  • __contain__(self, item) : item in a
  • __getitem__(self, key) : a[key]
  • __setitem__(self, key, value) : a[key] = value
  • __delitem__(self, key) : del a[key]
  • Class 상속.
class ~(parentClass):
   super().__init__()                         #--- parent class의 함수 호출
   super(parentClass, self).__init__()        #--- parent class의 함수 호출
   parentClass.__init__(self, ~)              #--- child class에서 parent class의 함수 호출

class ~ (parentA, parentB):                   #--- 다중 상속
    #--- 생성자 호출 순서 : parentB.__init__() > parentA.__init__() > self.__init__()
  • issubclass(childClass, parentClass)
  • object : 모든 class의 최상위 parent class

함수

  • 함수도 변수처럼 다른 변수에 할당 가능
  • dir(__builtins__) : 내장 함수의 목록
  • 함수 설명
  • help(함수명) : 함수 설명 보기
함수명.__doc__ = "~"

def ~(~):
   """
   여기에 함수 설명 기술
   """
  • 함수의 정의
  • locals()
  • vars()
  • globals() : 생성된 함수의 객체를 표시
def ~(~, ~ = ~):
   global ~                 #--- global 변수를 함수내에서 사용하도록 설정
   ~
   yield ~                  #--- 함수를 끝내지 않고 값을 전달
                            #--- 다시 함수가 호출되면 이후에 실행된 yield에서 전달한 값을 전달
   return ~

def ~(~, ~):
   pass                     #--- 아무런 동작도 하지 않는 코드

def ~(*args):                #--- Tuple 형으로 값을 전달

def ~(**args):               #--- Dictionary 형으로 값을 전달, ~(~ = ~, ~ = ~) 방식으로 호출
  • Generators: Iterator를 만들때 사용
def ~():
    yield ~                  #--- 함수를 끝내지 않고 값을 전달

def generator_a():
   yield ~
   raise StopIteration()
  • Iterator
class iterrator_a: 
   def __init__(self, n):
       self.n = n
       
   def __iter__(self):
       self.idx = -1
       return self
   
   def __next__(self):
       self.idx += 1
       if self.idx >= self.n:
           raise StopIteration()
       
       return self.idx
  • iter(~) 함수
x = iter(~)
~ = next(~)

iter1 = filter(함수, 리스트)
iter2 = map(함수, 리스트)
  • 함수 호출
~(~, ~)
~(~ = ~, ~ = ~)

Lambda

lambda 인자: 구문
~ = lambda ~, ~: ~           #--- 변수에 직접 함수를 정의하여 저장

패키지

  • 폴더에 __init__.py 파일을 생성할 것

모듈

모듈의 위치

-   $PATHON_HOME/lib/
    $PATHON_HOME/lib/python2.7/site-packages/

-   $PYTHONPATH

-   sys.path.append('~')
    imp.reload(~)


  • 파일 확장자
  • ~.py : Python 파일
  • ~.pyc : 컴파일된 byte cod
  • 모듈 추가
  • $PATHON_HOME/lLib/ 폴더에서 import할 파일을 찾습니다.
  • PYTHONPATH 환경 변수에 등록된 path에 import할 파일을 찾습니다.
import package.file as ~
from package.file import class, function, ...

import ~                              #--- 모듈 파일 삽입, ~.py
import ~.~.~ as ~                     #--- 모듈을 as 뒤에 나오는 이름으로 import 합니다. 
~.funcName()

from ~ import funcName                #--- 모듈 파일에서 method 삽입
from ~ import *                       #--- __로 시작하는 변수, 함수를 제외하고 import
funcName()

moduleName.~
  • sys.path를 사용한 import path 관리
import sys
sys.path.append('~')
sys.path.remove('~')
  • 코드 수정시 동적으로 import
import imp
imp.reload(moduleName)                #--- 수정된 모듈을 다시 로드 한다.
  • Python 파일을 직접 실행
python ~.py

if __name__ == '__main__':
 pass                             #--- 직접 실행시 __name__에 __main__이 저장됨
else:
 pass                             #--- import시 __name__에 모듈 이름이 저장됨
  • 패키지
  • 폴더의 계층 구조로 package 생성, ~.~.~
  • 각 폴더마다 패키지를 초기화하는 __init__.py 파일이 존재함
import ~.~ as ~

참고 문헌

with문

 with atomic.ActionTimer(self, key):
    return self.clients("ceilometer").meters.list(q=query, limit=limit)


with문 시작시 ActionTimer class의 __enter__(self) 함수를 호출하고 with문 종료시 __exit__(type, value, traceback) 함수를 호출함


오류 처리

  • BaseEception
  • Exception : __str__ 함수를 구현할 것
  • 사용자 정의 예외
class ~(Exception):
  def __init__(self, value):
      self.value = value
  • try catch 문
try:
  ~
except ~ as ~:
  ~
except (~, ~, ~):
  ~
except Exception as e:
  print(e.args[0])
except:
  ~
else:
  ~
finally:
  ~
  • 예외 발생
raise                                 #--- 예외를 상위로 전달
raise Exception
raise Exception(~)

assert 조건식, 관련_데이터            #--- AssertionError 발생, __debug__ 값이 true인 경우에만 실행됨
eval(~)                               #--- 문자열을 실행

기타 문법

  • import fibo : fibo.py 포함
  • from fibo import ~
  • sys.path, PYTHONPATH

Python 입출력

전역 변수

표준 입출력

  • 표준 입력 : sys.stdin
~ = input(~)
  • 표준 출력 : sys.stdout
#--- sep. 구분자, end. 끝라인, file. 출력 파일
print(~)

sys.stdout.write('~')
  • 표준 오류 : sys.stderr

CLI Argument

graph_file = sys.argv[1]
task_fr = sys.argv[2]
task_to = sys.argv[3]
step = int(sys.argv[4])


브라우저 입출력

Cookie 입출력

세션 입출력

데이터베이스 입출력

파일 입출력

  • 파일 입력
finp = open('~.txt')
for line in finp.readlines():
   print line
finp.close()

f.read()
#--- readline(), readlines()
#--- seek(~), tell()
~ = pickle.load(finp)                     #--- 저장된 개체 읽기, rb 모드
f.close()
  • 파일 출력
  • mode : r, w, a, +, b, t
fout = open('~.txt', 'w')
fout.write('~')
pickle.dump(~, fout)                      #--- 개체 저장, wb 모드
fout.close()

메일 입출력

numpy

import numpy as np

pandas Series

import pandas as pd
from pandas import Series, DataFrame

data = [100, 200, 300, 400, 500]
index = ['20180701', '20180702', '20180703', '20180704', '20180705']

series = Series(data, index)
print(series)

for idx in series.index:                               #--- series.values
    print(idx, series[idx])

pandas DataFrame

DataFrame 생성

import pandas as pd
from pandas import Series, DataFrame

df = DataFrame(None)                                   #--- 비어 있는 DataFrame 생성

#--- 데이터로 DataFrame 생성
col_1 = [ 100,  200,  300,  400,  500]
col_2 = [ 600,  700,  800,  900, 1000]
col_3 = [1100, 1200, 1300, 1400, 1500]
col_4 = [1600, 1700, 1800, 1900, 2000]
col_5 = [2100, 2200, 2300, 2400, 2500]
cols = ['open', 'high', 'low', 'close', 'other']
index = ['20180701', '20180702', '20180703', '20180704', '20180705']

data = {
    cols[0]: col_1,
    cols[1]: col_2,
    cols[2]: col_3,
    cols[3]: col_4,
    cols[4]: col_5
}
df = DataFrame(data, columns=cols, index=index)

#--- 데이터베이스에서 DataFrame 가져오기
df = pd.read_sql(query, self.MainWindow.con, index_col=None)      #--- Table에서 읽기
df.index = range(df.shape[0])                                     #--- 행 번호 재지정
columns = ['stock', 'close', 'volume', 'amount', 'date', 'open', 'high', 'low']
df.columns = columns                                              #--- 열 이름 재지정

DataFrame 기본 정보

df.shape                                               #--- shape[0]. 행수, shape[1]. 열수
df.index                                               #--- 행 인덱스
df.columns                                             #--- 열 이름
np.nan                                                 #--- 비어 있는 값을 지정할 때 사용
df'f현재가', 'f저가' = df'f현재가', 'f저가'.astype(float) #--- 열의 유형 변경
dataset.index = range(dataset.shape[0])                #--- 번호 인덱스 재지정
 
#--- 행 지정
df.loc['20180701']                                     #--- Series
df.loc[ ['20180701']]                                  #--- DataFrame

df.iloc[0]                                             #--- Series
df.iloc[0:2]                                           #--- DataFrame

df.ix['20180701']                                      #--- Series (Deprecated)
df.ix[2]                                               #--- Series (Deprecated)
df.ix[0:2]                                             #--- DataFrame (Deprecated)
 
#--- 열 지정
df.loc[:, 'open']                                      #--- Series
df.loc[:, ['open', 'close']]                           #--- DataFrame
df.iloc[:, 0]                                          #--- Series
df.iloc[:, 0:2]                                        #--- DataFrame

df['open']                                             #--- Series
df[ ['open', 'high']]                                  #--- DataFrame

#--- 행 우선 항목 지정
df.loc[ ['20180701'], ['open']]                        #--- DataFrame
df.loc[ ['20180701']][ ['open']]                       #--- DataFrame
df.loc[ ['20180701']]['open']                          #--- Series
df.loc['20180701'][ ['open']]                          #--- Series

df.ix['20180701']['open']                              #--- 값
df.ix[:, 'open']                                       #--- Series

#--- 열 우선 항목 지정
df['open']['20180701']                                 #--- 값

#--- 부분 DataFrame 생성
dataset = dataset[(dataset['f일자'] >= '20100101') & (dataset['f일자'] <= '20181231')]

val_mask = np.random.choice(전체_크기, 추출할_크기)
x_val   = x_train.loc[val_mask]
x_train = x_train.drop(val_mask)

DataFrame 연산

#--- DataFrame 합치기
dataset = pd.concat([dataset, datasetTA[idx]])         #--- 행이 추가됨

#--- 행 추가/수정/삭제
df.ix[행] = [~, ~, ~, ~]                               
df4 = df1.append({'c1':2, 'c2':2, 'c3': 3})

df = df.drop('행')                                     #--- 행 삭제 
df = df.dropna()                                       #--- 비어 있는 값을 포함한 행을 삭제
 
#--- 열 추가/수정/삭제
dataset.loc[:, 'price'] = Series({'행1': '값1', '행2': '값2'})    #--- 열 추가

dataset[column_name_new] = np.nan                                 #--- np.nan으로 초기화한 열 생성
dataset[column_name_new] = np.zeros(len(dataset))                 #--- 0으로 초기화한 열 생성
dataset[column_name_new][idx:] = dataset[column_name][:-1 * idx]

df = df.drop('열', axis=1)                             #--- 열 삭제

#--- 행 계산
dataset['profit'] = dataset['price_sale'] - dataset['price_purchase']
dataset['close_ma{}'.format(5)] = dataset['close'].rolling(5).mean()    #--- 이동 평균 계산
dataset[column_name_new][idx:] = dataset[column_name][:-1 * idx]
dataset.loc[1:, column_name_new] = (dataset['open'][1:].values - dataset['close'][:-1].values) / dataset['close'][:-1].values
dataset[column_name_new] = (dataset['high'].values - dataset['close'].values) / dataset['close'].values

Python과 Java 연동

  • JPype 설치
#!/usr/bin/env python
import jpype
import os.path

classpath = os.path.join(os.path.abspath('~'), 'bin')
jpype.startJVM(jpype.getDefaultJVMPath(), '-Djava.class.path=%s' % (classpath)

javaPackage = jpype.JPackage('~').~              #--- ~.~ package
javaClass = javaPackage.~
jc = javaClass()

jpype.shutdownJVM()
  • 참고 문헌

PSP 언어

Testcase

참고 문헌

사용자 가이드

외부 프로그램 실행

# -*- coding: utf-8 -*-
import os, re, sys, urllib
import subprocess

if __name__ == '__main__':
   results = []
#   p = subprocess.Popen('/bin/cat /nas/output/service001.out',stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
   p = subprocess.Popen('/bin/cat /nas/output/service001.out',stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False)
   strInp = ""
   strOut = p.communicate(input + "\n")[0]
   lines = strOut.split("\n")
   for line in lines:
       vals = line.split("\t")
#       results.append({'line':line})
       results.append({'acnt_no':vals[0], "cnt":vals[1]})

관리자 가이드

Database 연동

참고 문헌