679 lines
31 KiB
Python
679 lines
31 KiB
Python
import math
|
|
from datetime import datetime
|
|
import pandas as pd
|
|
from stockpredictor.analysis.Common import Common
|
|
from stockpredictor.analysis.Stochastic import Stochastic
|
|
from stockpredictor.analysis.RSI import RSI
|
|
from stockpredictor.analysis.MACD import MACD
|
|
from stockpredictor.analysis.IchimokuCloud import IchimokuCloud
|
|
|
|
class BuySellChecker:
|
|
|
|
common = None
|
|
stochastic = None
|
|
rsi = None
|
|
ichimokuCloud = None
|
|
|
|
def __init__(self):
|
|
self.common = Common()
|
|
self.stochastic = Stochastic()
|
|
self.rsi = RSI()
|
|
self.macd = MACD()
|
|
self.ichimokuCloud = IchimokuCloud()
|
|
|
|
return
|
|
|
|
def getPriceAndWeight1(self, data, i):
|
|
buy, weight, sell = -1, -1, -1
|
|
|
|
START_TIME_INDEX = 0
|
|
for c in range(370, len(data.index)):
|
|
if data.index[c].strftime("%H:%M:%S") == "09:01:00":
|
|
START_TIME_INDEX = c
|
|
break
|
|
|
|
if i >= START_TIME_INDEX:
|
|
################
|
|
### sell 분석 ###
|
|
################
|
|
# 1. 볼린져밴드 상단이 최고와 종가 사이 아래에 있는 경우 매도한다.
|
|
#if (data["high"][i] - data["close"][i]) / 2 + data["close"][i] > data["upper"][i]:
|
|
# sell = data["high"][i]
|
|
|
|
# 2. slow_k가 90이 넘으면 매도한다.
|
|
if data["slow_k"][i] > 90:
|
|
sell = data["high"][i]
|
|
|
|
#if data["slow_k"][i] >= 85:
|
|
# if data["slow_d"][i-1] < data["slow_k"][i-1] and data["slow_k"][i] < data["slow_d"][i]:
|
|
# sell = data["high"][i]
|
|
|
|
# 3. 2시 이후에는 최고가가 볼린져밴드 상단 위에 있으면 매도한다.
|
|
if i > 300 and data["high"][i] > data["upper"][i]:
|
|
sell = data["high"][i]
|
|
|
|
##########################
|
|
### buy 분석 ###
|
|
##########################
|
|
if data["low"][i] < data["lower"][i] + 5 and data["open"][i] <= data["close"][i]:
|
|
if data["slow_k"][i-1] < 30 and data["slow_k"][i] < 30:
|
|
if data["slow_k"][i-1] < data["slow_k"][i]:
|
|
buy = data["low"][i]
|
|
|
|
if data["rsi"][i] < 25:
|
|
if data["rsi"][i - 2] < data["rsis"][i - 2] and data["rsi"][i - 1] < data["rsis"][i - 1] and data["rsis"][i] < data["rsi"][i]:
|
|
if data["close"][i] < data["avg5"][i]:
|
|
buy = data["close"][i]
|
|
else:
|
|
buy = data["low"][i]
|
|
weight = 1
|
|
|
|
#############################
|
|
### STOCHASTIC weight 분석 ###
|
|
#############################
|
|
if data["slow_k"][i] in (0, 1, 2, 3):
|
|
weight = 1
|
|
if data["slow_k"][i] in (4, 5, 6, 7, 8):
|
|
weight = 1
|
|
elif data["slow_k"][i] in (9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20):
|
|
weight = 1
|
|
elif data["slow_k"][i] in (21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35):
|
|
weight = 1
|
|
|
|
return buy, weight, sell
|
|
|
|
def getPriceAndWeight2(self, data, i):
|
|
buy, weight, sell = -1, -1, -1
|
|
|
|
START_TIME_INDEX = 0
|
|
for c in range(370, len(data.index)):
|
|
if data.index[c].strftime("%H:%M:%S") == "09:01:00":
|
|
START_TIME_INDEX = c
|
|
break
|
|
|
|
if i >= START_TIME_INDEX:
|
|
################
|
|
### sell 분석 ###
|
|
################
|
|
# 1. 볼린져밴드 상단이 최고와 종가 사이 아래에 있는 경우 매도한다.
|
|
if (data["high"][i] - data["close"][i]) / 2 + data["close"][i] > data["upper"][i]:
|
|
sell = data["high"][i]
|
|
|
|
if data["slow_k"][i] >= 85:
|
|
if data["slow_d"][i - 1] < data["slow_k"][i - 1] and data["slow_k"][i] < data["slow_d"][i]:
|
|
sell = data["high"][i]
|
|
|
|
# 3. 2시 이후에는 최고가가 볼린져밴드 상단 위에 있으면 매도한다.
|
|
if i > 300 and data["high"][i] > data["upper"][i]:
|
|
sell = data["high"][i]
|
|
|
|
##########################
|
|
### STOCHASTIC buy 분석 ###
|
|
##########################
|
|
if i < 40:
|
|
pre_slow = data["slow_k"][i - 1] / data["slow_d"][i - 1] - 1
|
|
now_slow = data["slow_k"][i] / data["slow_d"][i] - 1
|
|
if pre_slow < 0 and 0 < now_slow:
|
|
if data["slow_k"][i] <= 35:
|
|
if (data["close"][i] - data["lower"][i]) / (data["upper"][i] - data["lower"][i]) < 0.35:
|
|
if data["slow_k"][i - 1] < data["slow_d"][i - 1] and data["slow_d"][i] < data["slow_k"][i]:
|
|
if data['avg10'][i] < data['avg5'][i]:
|
|
if data["open"][i] < data["close"][i]:
|
|
buy = data["close"][i]
|
|
else:
|
|
buy = data["low"][i]
|
|
else:
|
|
pre_slow = data["slow_k"][i - 1] / data["slow_d"][i - 1] - 1
|
|
now_slow = data["slow_k"][i] / data["slow_d"][i] - 1
|
|
if pre_slow < 0 and pre_slow < now_slow and -0.15 < now_slow:
|
|
if data["slow_k"][i] <= 30:
|
|
if (data["close"][i] - data["lower"][i]) / (data["upper"][i] - data["lower"][i]) < 0.35:
|
|
if data["slow_k"][i - 1] < data["slow_d"][i - 1] and data["slow_d"][i] < data["slow_k"][i]:
|
|
if data['avg10'][i] < data['avg5'][i]:
|
|
if data["close"][i] < data["avg5"][i]:
|
|
buy = data["close"][i]
|
|
else:
|
|
buy = data["low"][i]
|
|
|
|
#############################
|
|
### STOCHASTIC weight 분석 ###
|
|
#############################
|
|
if data["slow_k"][i] in (0, 1, 2, 3):
|
|
weight = 1
|
|
if data["slow_k"][i] in (4, 5, 6, 7, 8):
|
|
weight = 1
|
|
elif data["slow_k"][i] in (9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20):
|
|
weight = 1
|
|
elif data["slow_k"][i] in (21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35):
|
|
weight = 1
|
|
|
|
return buy, weight, sell
|
|
|
|
def getBuyCheck(self, data, i, buy, weight):
|
|
if data['close'][i]<data['avg3'][i]<data['avg5'][i]<data['avg10'][i]<data['avg20'][i]<data['avg30'][i]:
|
|
buy, weight, sell = -1, -1, -1
|
|
return buy, weight
|
|
|
|
# 곱버스에 해당함
|
|
def getBuyPriceAndWeight1(self, data, i):
|
|
buy, weight = -1, -1
|
|
|
|
START_TIME_INDEX = 0
|
|
for c in range(370, len(data.index)):
|
|
if data.index[c].strftime("%H:%M:%S") == "09:01:00":
|
|
START_TIME_INDEX = c
|
|
break
|
|
|
|
if i >= START_TIME_INDEX:
|
|
# 매수 분석
|
|
|
|
# 장 초기 (시작 3분 이내) 양봉 2개에 3분차에 장대 양봉이면 매수.
|
|
if i < 381 + 4:
|
|
if data["open"][i] == data["low"][i] and data["close"][i] == data["high"][i]:
|
|
if data["close"][i-2] <= data["open"][i-1]:
|
|
if data["open"][i-2] < data["close"][i-2] and data["open"][i-1] < data["close"][i-1]:
|
|
buy = data["high"][i]
|
|
weight = 1
|
|
return self.getBuyCheck(data, i, buy, weight)
|
|
|
|
# 장 초기 (시작 7분 이내), 볼린져 하단에서 시작하여 이병선을 모두 상승하여 마감한 경우 low 값에서 매수한다.
|
|
if i < 381 + 8:
|
|
if data["open"][i] == data["low"][i] and data["close"][i] == data["high"][i]:
|
|
if data["close"][i] > max(data["avg3"][i], data["avg5"][i], data["avg10"][i], data["avg20"][i], data["avg30"][i]):
|
|
buy = data["low"][i]
|
|
weight = 2
|
|
return self.getBuyCheck(data, i, buy, weight)
|
|
|
|
# 만약 30원 이상 장대 양봉이 나온 경우, 다음이나 다다음 중간 값에서 매수를 한다.
|
|
if (data["close"][i] - data["low"][i]) >= 30:
|
|
middle = int((data["close"][i] + data["low"][i])/2)
|
|
buy = middle
|
|
weight = 1
|
|
return self.getBuyCheck(data, i, buy, weight)
|
|
|
|
|
|
# 이동선을 이용한 매매
|
|
# 3분선과 10분선이 30분 이상 내려오다가 3분선이 10분선을 넘어 서는 순간 매수
|
|
if int(data["avg3"][i]) > int(data["avg10"][i]):
|
|
valid = True
|
|
same_count = 0
|
|
for c in range(1, 30):
|
|
if int(data["avg3"][i-c]) == int(data["avg10"][i-c]):
|
|
same_count += 1
|
|
if int(data["avg3"][i-c]) > int(data["avg10"][i-c]):
|
|
valid = False
|
|
break
|
|
if valid and same_count < 2:
|
|
buy = data["close"][i] - 5
|
|
weight = 1
|
|
return self.getBuyCheck(data, i, buy, weight)
|
|
|
|
|
|
# 이동선을 이용한 매매
|
|
# 3분선과 5분선이 10분 이상 내려오다가 3분선이 5분선을 넘어 서는 순간 매수
|
|
if int(data["avg3"][i]) > int(data["avg5"][i]):
|
|
valid = True
|
|
same_count = 0
|
|
for c in range(1, 11):
|
|
if int(data["avg3"][i-c]) == int(data["avg5"][i-c]):
|
|
same_count += 1
|
|
if int(data["avg3"][i-c]) > int(data["avg5"][i-c]):
|
|
valid = False
|
|
break
|
|
if valid and same_count < 2:
|
|
if data['macd'][i] < -5:
|
|
buy = data["close"][i] - 5
|
|
weight = 1
|
|
return self.getBuyCheck(data, i, buy, weight)
|
|
|
|
# 다이버젼스
|
|
# slow_k가 20 이하에서 이전 최저점의 slow_k보다 지금 최저점의 slow_k가 더 높은 경우
|
|
if data["slow_k"][i] < 20:
|
|
if data["close"][i] > data["close"][i - 1]:
|
|
p_slow_k = 100
|
|
p_close = 0
|
|
top = False
|
|
for c in range(1, 60):
|
|
if not top and data["close"][i-c] > min(data["open"][i-c], data["close"][i-c]):
|
|
top = True
|
|
if top and data["close"][i-c] > min(data["open"][i-c], data["close"][i-c]):
|
|
p_slow_k = data["slow_k"][i-c]
|
|
p_close = data["close"][i-c]
|
|
break
|
|
if data["close"][i] < p_close and data["slow_k"][i] > p_slow_k:
|
|
buy = data["close"][i]
|
|
weight = 1
|
|
return self.getBuyCheck(data, i, buy, weight)
|
|
|
|
|
|
# 이동선을 이용한 매매
|
|
# 3분선이 10분선에 돌파 후 지지하는지 확인하고 slow_k < 40일 때 매수함
|
|
|
|
# 현재 단계:
|
|
# - avg3[i]이 avg10[i]보다 커야함
|
|
# - avg3[i]가 avg3[i-1]보다 커야함
|
|
if data['avg10'][i] < data['avg3'][i] and data['avg3'][i-1] < data['avg3'][i] and abs(data['avg10'][i] - data['avg3'][i]) > 2:
|
|
# 첫 이전 단계:
|
|
# - avg3[i-1]과 avg10[i-1]의 abs가 3이내여야 함
|
|
if abs(data['avg3'][i-1] - data['avg10'][i-1]) < 3 and data['avg3'][i-1] < data['avg3'][i-2]:
|
|
index1 = -1
|
|
valid = False
|
|
for j in range(2, 20):
|
|
# 두 번째 이전 단계:
|
|
# - avg3[i-2]가 avg10[i-2]보다 커야 함
|
|
# - avg3[i-2]가 avg3[i-3]보다 작아야함
|
|
if data['avg10'][i-j] < data['avg3'][i-j] and data['avg3'][i-j] > data['avg3'][i-j-1]:
|
|
index1 = j
|
|
break
|
|
for j in range(index1 + 1, 20):
|
|
# 세 번째 이전 단계:
|
|
# - avg3[i-3]가 avg3[i-4]보다 커야 함
|
|
if data['avg3'][i-j] > data['avg3'][i-j-1]:
|
|
valid = True
|
|
index1 = j
|
|
else:
|
|
break
|
|
# 마지막 체크:
|
|
# 만약 avg[3]이 avg[10]보다 작다면 매수함
|
|
if valid:
|
|
if data['avg3'][i-index1-1] < data['avg10'][i-index1-1]:
|
|
if data["slow_k"][i] < 40:
|
|
buy = data["close"][i]
|
|
weight = 2
|
|
return self.getBuyCheck(data, i, buy, weight)
|
|
|
|
|
|
# 10분 이상 10분 선 아래 3분선이 있다가 10분선 위로 올라 올때 장대장봉임
|
|
# 해당 기간 clsoe 값이 10분 선 아래 있을 때,
|
|
if data["avg10"][i] < data["avg3"][i] and data["low"][i] == data["open"][i] < data["close"][i] == data["high"][i]:
|
|
if (data["avg3"][i-1] <= data["avg10"][i-1]) and ((data["avg10"][i-1] and data["avg3"][i-1]) < data["close"][i-1]):
|
|
valid = True
|
|
for c in range(2, 11):
|
|
if data["avg10"][i-c] < data["avg3"][i-c] or data["avg10"][i-c] < data["close"][i-c]:
|
|
valid = False
|
|
break
|
|
if valid:
|
|
buy = int((data["open"][i] + data["close"][i])/2)
|
|
weight = 1
|
|
return self.getBuyCheck(data, i, buy, weight)
|
|
|
|
|
|
# 이동선을 이용한 매매
|
|
# 20분선이 30분선에 돌파 후 지지하는지 확인하고 해당 시점이 양봉이면 매수함
|
|
if data['avg20'][i] > data['avg30'][i]:
|
|
diff1 = data['avg20'][i] - data['avg30'][i]
|
|
diff2 = data['avg20'][i-1] - data['avg30'][i-1]
|
|
diff3 = data['avg20'][i-2] - data['avg30'][i-2]
|
|
diff4 = data['avg20'][i-3] - data['avg30'][i-3]
|
|
diff5 = data['avg20'][i-4] - data['avg30'][i-4]
|
|
if 0 < diff3 < diff2 < diff1:
|
|
if data['high'][i-2] <= data['high'][i-1] <= data['high'][i]:
|
|
if data['open'][i - 2] <= data['close'][i - 2] and data['open'][i-1] <= data['close'][i-1] and data['open'][i] <= data['close'][i]:
|
|
if diff5 < diff4 < 0:
|
|
if data["rsi"][i] < 30:
|
|
buy = (data["open"][i]+data["close"][i])/2
|
|
weight = 1
|
|
return self.getBuyCheck(data, i, buy, weight)
|
|
|
|
|
|
# macd를 이용한 매수
|
|
if data.index[i].strftime("%H:%M") < "10:00":
|
|
if data["macd"][i] < -15 and data["macd"][i-1] < min(data["macd"][i-7], data["macd"][i-6], data["macd"][i-5], data["macd"][i-4], data["macd"][i-3], data["macd"][i-2], data["macd"][i]):
|
|
buy = (data["open"][i]+data["close"][i])/2
|
|
weight = 1
|
|
return buy, weight
|
|
|
|
# slow_k를 이용한 매수
|
|
if data.index[i].strftime("%H:%M") < "09:20":
|
|
if data["slow_k"][i] < 10 and data["slow_k"][i-1] < min(data["slow_k"][i-4], data["slow_k"][i-3], data["slow_k"][i-2], data["slow_k"][i]):
|
|
buy = (data["open"][i]+data["close"][i])/2
|
|
weight = 1
|
|
return buy, weight
|
|
else:
|
|
if data["slow_k"][i] < 10 and data["slow_k"][i-1] < min(data["slow_k"][i-7], data["slow_k"][i-6], data["slow_k"][i-5], data["slow_k"][i-4], data["slow_k"][i-3], data["slow_k"][i-2], data["slow_k"][i]):
|
|
buy = (data["open"][i]+data["close"][i])/2
|
|
weight = 1
|
|
return self.getBuyCheck(data, i, buy, weight)
|
|
|
|
# 볼린저 밴드가 하락에서 상승으로 전환할 때,
|
|
# 지금 양봉 close가 upper를 돌파했다. (이전 거래량 보다 많음)
|
|
# 20분 이내로 양봉 close가 upper를 돌파 한 것이 있어야 한다.
|
|
# 지금 양봉의 close가 이전 양봉의 close보다 높아야 한다.
|
|
# 이 사이에 종가가 20분봉 위에 있어야 한다.
|
|
if data.index[i].strftime("%H:%M") > "09:15":
|
|
if (data['open'][i] < data['close'][i]==data['high'][i]) and (data['upper'][i] < data['close'][i]) and (data['volume'][i-1] < data['volume'][i]):
|
|
if data['open'][i-1] < data['close'][i-1] and data['open'][i-2] < data['close'][i-2]:
|
|
if data['close'][i-1] < data['upper'][i-1] and data['close'][i-2] < data['upper'][i-2] and data['close'][i-2] < data['upper'][i-2]:
|
|
index = -1
|
|
for c in range(6, 21):
|
|
if data['open'][i-c] < data['close'][i-c] and data['upper'][i-c] < data['close'][i-c]:
|
|
index = c
|
|
break
|
|
if index != -1:
|
|
valid = True
|
|
for c in range(2, index+1):
|
|
if data['open'][i-c] < data['avg20'][i-c] and data['close'][i-c] < data['avg20'][i-c]:
|
|
valid = False
|
|
break
|
|
if valid:
|
|
buy = data["close"][i]
|
|
weight = 1
|
|
return self.getBuyCheck(data, i, buy, weight)
|
|
|
|
return buy, weight
|
|
|
|
|
|
def getSellPriceAndWeight1(self, data, i):
|
|
sell, weight = -1, -1
|
|
|
|
START_TIME_INDEX = 0
|
|
for c in range(370, len(data.index)):
|
|
if data.index[c].strftime("%H:%M:%S") == "09:01:00":
|
|
START_TIME_INDEX = c
|
|
break
|
|
|
|
if i >= START_TIME_INDEX:
|
|
# 매도 분석
|
|
|
|
# 3분 선이 40분 전부터 게속 20분선 위에 있다가 아래로 내려오면 매도함
|
|
if data["avg3"][i] < data["avg20"][i]:
|
|
valid = True
|
|
for c in range(1, 41):
|
|
if data["avg3"][i-c] < data["avg20"][i-c]:
|
|
valid = False
|
|
break
|
|
if valid:
|
|
sell = int((data["open"][i] + data["close"][i])/2)
|
|
return sell, weight
|
|
|
|
# 3분 선이 60분 전부터 게속 30분선 위에 있다가 아래로 내려오면 매도함
|
|
if data["avg3"][i] < data["avg30"][i]:
|
|
valid = True
|
|
for c in range(1, 61):
|
|
if data["avg3"][i-c] < data["avg30"][i-c]:
|
|
valid = False
|
|
break
|
|
if valid:
|
|
sell = int((data["open"][i] + data["close"][i])/2)
|
|
return sell, weight
|
|
|
|
# 5분 선이 20분 전부터 게속 10분선 위에 있다가 아래로 내려오면 매도함
|
|
if data["avg5"][i] < data["avg10"][i]:
|
|
valid = True
|
|
for c in range(1, 21):
|
|
if data["avg5"][i-c] < data["avg10"][i-c]:
|
|
valid = False
|
|
break
|
|
if valid:
|
|
sell = int((data["open"][i] + data["close"][i])/2)
|
|
return sell, weight
|
|
|
|
|
|
# rsi와 rsis가 75이상에서 slow_k가 slow_d 아래롸 내려온 경우
|
|
if data["rsi"][i] >= 70 and data["rsis"][i] >= 70:
|
|
if data["rsi"][i-1] > data["rsis"][i-1] and data["rsi"][i] < data["rsis"][i]:
|
|
sell = int((data["open"][i] + data["close"][i]) / 2)
|
|
return sell, weight
|
|
|
|
# slow_k와 slow_d가 90이상에서 slow_k가 slow_d 아래롸 내려온 경우
|
|
if data["slow_k"][i] >= 90 and data["slow_d"][i] >= 90:
|
|
if data["slow_k"][i-1] > data["slow_d"][i-1] and data["slow_k"][i] < data["slow_d"][i]:
|
|
sell = int((data["open"][i] + data["close"][i]) / 2)
|
|
|
|
if data.index[i].strftime("%H:%M") < "12:00" and data['rsis'][i] < 70:
|
|
return -1, -1
|
|
|
|
return sell, weight
|
|
|
|
return sell, weight
|
|
|
|
|
|
|
|
|
|
# 레버리지에 해당함
|
|
def getBuyPriceAndWeight2(self, data, i):
|
|
buy, weight = -1, -1
|
|
|
|
START_TIME_INDEX = 0
|
|
for c in range(370, len(data.index)):
|
|
if data.index[c].strftime("%H:%M:%S") == "09:01:00":
|
|
START_TIME_INDEX = c
|
|
break
|
|
|
|
if i >= START_TIME_INDEX + 60:
|
|
# 매수 분석
|
|
|
|
# 이동선을 이용한 매매
|
|
# 3분선과 10분선이 20분 이상 내려오다가 3분선이 10분선을 넘어 서는 순간 매수
|
|
if int(data["avg3"][i]) > int(data["avg10"][i]):
|
|
if data["slow_k"][i] < 10:
|
|
valid = True
|
|
same_count = 0
|
|
for c in range(1, 21):
|
|
if int(data["avg3"][i-c]) == int(data["avg10"][i-c]):
|
|
same_count += 1
|
|
if int(data["avg3"][i-c]) > int(data["avg10"][i-c]):
|
|
valid = False
|
|
break
|
|
if valid and same_count < 2:
|
|
buy = data["close"][i] - 5
|
|
weight = 1
|
|
return self.getBuyCheck(data, i, buy, weight)
|
|
|
|
# slow_k를 이용한 매수
|
|
if data["slow_k"][i-2] < 5 and data["slow_k"][i-1] < 5 and data["slow_k"][i] < 7:
|
|
if data["slow_k"][i-2] < data["slow_k"][i] < data["slow_k"][i-1]:
|
|
buy = (data["open"][i]+data["close"][i])/2
|
|
weight = 1
|
|
return buy, weight
|
|
|
|
|
|
# macd를 이용한 매수
|
|
if data["macd"][i-2] < -45 and data["macd"][i-1] < -45 and data["macd"][i] < -45:
|
|
if data["macd"][i-1] < min (data["macd"][i-2], data["macd"][i]):
|
|
buy = (data["open"][i]+data["close"][i])/2
|
|
weight = 1
|
|
return self.getBuyCheck(data, i, buy, weight)
|
|
|
|
|
|
# slow_k를 이용한 매수
|
|
if data["slow_k"][i-2] < 15 and data["slow_k"][i-1] < 12 and data["slow_k"][i] < 12:
|
|
if data["slow_k"][i-2] < data["slow_k"][i] < data["slow_k"][i-1]:
|
|
if data["macd"][i - 1] < -25:
|
|
buy = (data["open"][i]+data["close"][i])/2
|
|
weight = 1
|
|
return self.getBuyCheck(data, i, buy, weight)
|
|
|
|
|
|
|
|
return buy, weight
|
|
|
|
|
|
def getSellPriceAndWeight2(self, data, i):
|
|
sell, weight = -1, -1
|
|
|
|
START_TIME_INDEX = 0
|
|
for c in range(370, len(data.index)):
|
|
if data.index[c].strftime("%H:%M:%S") == "09:01:00":
|
|
START_TIME_INDEX = c
|
|
break
|
|
|
|
if i >= START_TIME_INDEX:
|
|
# 매도 분석
|
|
|
|
#4분전에 upper 돌파 후 4음봉이면 매도
|
|
if data["open"][i-3] > data["upper"][i-3]:
|
|
if data["open"][i - 2] > data["close"][i - 2]:
|
|
if data["open"][i - 1] > data["close"][i - 1]:
|
|
if data["open"][i] > data["close"][i]:
|
|
sell = int((data["open"][i] + data["close"][i]) / 2)
|
|
return sell, weight
|
|
|
|
# 3분 선이 15분 전부터 게속 5분선 위에 있다가 아래로 내려오면 매도함
|
|
if data["avg3"][i] <= data["avg5"][i]:
|
|
valid = True
|
|
for c in range(1, 16):
|
|
if data["avg3"][i-c] < data["avg5"][i-c] and abs(data["avg3"][i-c] - data["avg5"][i-c]) > 5:
|
|
valid = False
|
|
break
|
|
if valid:
|
|
sell = int((data["open"][i] + data["close"][i])/2)
|
|
return sell, weight
|
|
|
|
# 3분 선이 40분 전부터 게속 20분선 위에 있다가 아래로 내려오면 매도함
|
|
if data["avg3"][i] < data["avg20"][i]:
|
|
valid = True
|
|
for c in range(1, 41):
|
|
if data["avg3"][i-c] < data["avg20"][i-c]:
|
|
valid = False
|
|
break
|
|
if valid:
|
|
sell = int((data["open"][i] + data["close"][i])/2)
|
|
return sell, weight
|
|
|
|
# 3분 선이 60분 전부터 게속 30분선 위에 있다가 아래로 내려오면 매도함
|
|
if data["avg3"][i] < data["avg30"][i]:
|
|
valid = True
|
|
for c in range(1, 61):
|
|
if data["avg3"][i-c] < data["avg30"][i-c]:
|
|
valid = False
|
|
break
|
|
if valid:
|
|
sell = int((data["open"][i] + data["close"][i])/2)
|
|
return sell, weight
|
|
|
|
# 5분 선이 20분 전부터 게속 10분선 위에 있다가 아래로 내려오면 매도함
|
|
if data["avg5"][i] < data["avg10"][i]:
|
|
valid = True
|
|
for c in range(1, 21):
|
|
if data["avg5"][i-c] < data["avg10"][i-c]:
|
|
valid = False
|
|
break
|
|
if valid:
|
|
sell = int((data["open"][i] + data["close"][i])/2)
|
|
return sell, weight
|
|
|
|
|
|
# rsi와 rsis가 75이상에서 slow_k가 slow_d 아래롸 내려온 경우
|
|
if data["rsi"][i] >= 70 and data["rsis"][i] >= 70:
|
|
if data["rsi"][i-1] > data["rsis"][i-1] and data["rsi"][i] < data["rsis"][i]:
|
|
sell = int((data["open"][i] + data["close"][i]) / 2)
|
|
return sell, weight
|
|
|
|
# slow_k와 slow_d가 90이상에서 slow_k가 slow_d 아래롸 내려온 경우
|
|
if data["slow_k"][i] >= 90 and data["slow_d"][i] >= 90:
|
|
if data["slow_k"][i-1] > data["slow_d"][i-1] and data["slow_k"][i] < data["slow_d"][i]:
|
|
sell = int((data["open"][i] + data["close"][i]) / 2)
|
|
|
|
if data.index[i].strftime("%H:%M") < "12:00" and data['rsis'][i] < 70:
|
|
return -1, -1
|
|
|
|
return sell, weight
|
|
|
|
return sell, weight
|
|
|
|
def analyze(self, result):
|
|
open = result["open"]
|
|
close = result["close"]
|
|
high = result["high"]
|
|
low = result["low"]
|
|
vol = result["vol"]
|
|
|
|
close_df = pd.DataFrame(close)
|
|
avg3_list = close_df.rolling(window=3).mean().fillna(close[0]).values.tolist()
|
|
avg3 = [item[0] for item in avg3_list]
|
|
avg5_list = close_df.rolling(window=5).mean().fillna(close[0]).values.tolist()
|
|
avg5 = [item[0] for item in avg5_list]
|
|
avg10_list = close_df.rolling(window=10).mean().fillna(close[0]).values.tolist()
|
|
avg10 = [item[0] for item in avg10_list]
|
|
avg20_list = close_df.rolling(window=20).mean().fillna(close[0]).values.tolist()
|
|
avg20 = [item[0] for item in avg20_list]
|
|
avg30_list = close_df.rolling(window=30).mean().fillna(close[0]).values.tolist()
|
|
avg30 = [item[0] for item in avg30_list]
|
|
avg60_list = close_df.rolling(window=60).mean().fillna(close[0]).values.tolist()
|
|
avg60 = [item[0] for item in avg60_list]
|
|
|
|
df = pd.DataFrame(close)
|
|
max20 = df.rolling(window=20).mean()
|
|
stddev20 = df.rolling(window=20).std()
|
|
upper_df = max20 + (stddev20 * 2) # 상단 볼린저 밴드
|
|
lower_df = max20 - (stddev20 * 2) # 하단 볼린저 밴드
|
|
|
|
upper, lower = [], []
|
|
for i in range(len(upper_df)):
|
|
if i < 10:
|
|
upper.append(upper_df.values[0][0])
|
|
lower.append(lower_df.values[0][0])
|
|
else:
|
|
upper.append(upper_df.values[i][0])
|
|
lower.append(lower_df.values[i][0])
|
|
|
|
point_temp = result["time"]
|
|
|
|
STOCK = []
|
|
for i in range(len(open)):
|
|
STOCK.append({'volume': vol[i], 'close': close[i], 'open': open[i], 'high': high[i], 'low': low[i],
|
|
'avg3': avg3[i], 'avg5': avg5[i],'avg10': avg10[i],'avg20': avg20[i],'avg30': avg30[i],'avg60': avg60[i]})
|
|
|
|
# stochastic 계산
|
|
stochastic_df = self.stochastic.apply(STOCK, n=30, m=5, t=5)
|
|
stochastic_df = stochastic_df.fillna(100)
|
|
fast_k = stochastic_df['fast_k'].values.tolist()
|
|
slow_k = stochastic_df['slow_k'].values.tolist()
|
|
slow_d = stochastic_df['slow_d'].values.tolist()
|
|
|
|
# macd 계산
|
|
macd_df = self.macd.apply(STOCK, short=12, long=26, t=9)
|
|
macd_df = macd_df.fillna(100)
|
|
macd = macd_df['macd'].values.tolist()
|
|
macds = macd_df['macds'].values.tolist()
|
|
macdo = macd_df['macdo'].values.tolist()
|
|
|
|
# rsi 계산
|
|
rsi_df = self.rsi.apply(STOCK, period=30, window=5)
|
|
rsi_df = rsi_df.fillna(100)
|
|
rsi = rsi_df['rsi'].values.tolist()
|
|
rsis = rsi_df['rsis'].values.tolist()
|
|
|
|
# ichimokuCloud 계산
|
|
# ichimokuCloud_df = self.ichimokuCloud.apply(STOCK, c=9, b=26, l=52)
|
|
# ichimokuCloud_df = rsi_df.fillna(100)
|
|
# changeLine = rsi_df['changeLine'].values.tolist()
|
|
# baseLine = rsi_df['baseLine'].values.tolist()
|
|
# leadingSpan1 = rsi_df['leadingSpan1'].values.tolist()
|
|
# leadingSpan2 = rsi_df['leadingSpan2'].values.tolist()
|
|
|
|
temp = {"date": point_temp,
|
|
"open": open, "high": high, "low": low, "close": close, "volume": vol, "upper": upper, "lower": lower,
|
|
"avg3": avg3, "avg5": avg5, "avg10": avg10, "avg20": avg20, "avg30": avg30, "avg60": avg60,
|
|
"macd": macd, "macds": macds, "macdo": macdo,
|
|
"fast_k": fast_k, "slow_k": slow_k, "slow_d": slow_d,
|
|
"rsi": rsi, "rsis": rsis}
|
|
data = pd.DataFrame(temp)
|
|
df_final_time = pd.DatetimeIndex(point_temp)
|
|
data.index = df_final_time
|
|
|
|
return data
|
|
|
|
def checkTransaction(self, data, stock_code):
|
|
size = len(data["close"])
|
|
|
|
bsLine = {}
|
|
bsLine['buy'] = [-1 for i in range(size)]
|
|
bsLine['weight'] = [-1 for i in range(size)]
|
|
bsLine['sell'] = [-1 for i in range(size)]
|
|
|
|
for i in range(size):
|
|
if stock_code == "252670":
|
|
sell, weight = self.getSellPriceAndWeight1(data, i)
|
|
buy, weight = self.getBuyPriceAndWeight1(data, i)
|
|
else:
|
|
sell, weight = self.getSellPriceAndWeight2(data, i)
|
|
buy, weight = self.getBuyPriceAndWeight2(data, i)
|
|
|
|
bsLine['buy'][i] = buy
|
|
bsLine['weight'][i] = weight
|
|
bsLine['sell'][i] = sell
|
|
|
|
return bsLine
|