꿀맛은개뿔: 8월 2021

2021년 8월 27일 금요일

주식 벡테스트[2021년8월23일~8월28]

상세 그래프를 보려면 html 파일확인 에서 확인할수있습니다.

------------------------------23일

파일경로 :2021-08-23Stock_Record

026890 손익가:-53470

035080 손익가:7233.0

102460 손익가:153864

220630 손익가:-13043

241520 손익가:-21484

323410 손익가:85669

(94) 총손익!!!:158769.0

------------------------------24일

파일경로 :2021-08-24Stock_Record

005880 손익가:4772

006910 손익가:3048

009270 손익가:2355

014190 손익가:3109

021080 손익가:6372.0

027830 손익가:3591

033160 손익가:19289.0

035080 손익가:8620

037270 손익가:11021

047820 손익가:1174.0

064260 손익가:5479

089140 손익가:-16355

089890 손익가:9157.0

148150 손익가:23882

205470 손익가:15872

(85) 총손익!!!:101386.0

------------------------------25일

파일경로 :2021-08-25Stock_Record

025750 손익가:1512

035080 손익가:9991.0

052220 손익가:1725.0

064260 손익가:4371.0

064550 손익가:151479.0

148150 손익가:11013.0

950130 손익가:25340.0

(95) 총손익!!!:205431.0

------------------------------26일

파일경로 :2021-08-26Stock_Record

002720 손익가:6643

015860 손익가:7236

(83) 총손익!!!:13879

------------------------------27일

파일경로 :2021-08-27Stock_Record

009520 손익가:10925.0

041930 손익가:20760

104480 손익가:13339.0

(100) 총손익!!!:45024.0

------------------------------28일

100개의 종목으로 28일 하루거래 테스트

009520 손익가:10925.0

041930 손익가:20760

104480 손익가:13339.0

(100) 총손익!!!:45024.0

ananconda python ta-lib install(py37_32)

C:\Users\사용자\anaconda3 에다가

TA_Lib-0.4.21-cp37-cp37m-win32.whl 다운받아서

아나콘다 프롬프트 키고 해당 경로에서 설치하면 된다!

pip install TA_Lib-0.4.21-cp37-cp37m-win32.whl

2021년 8월 21일 토요일

주식 벡테스트 [8월20일 기준]

5분봉 데이터로 백테스트 진행하였습니다.

각각 20일 기준으로 수집했습니다.(8월4일 11시55분~8월20일 3시30분)

분봉이기 때문에 실시간이랑 다를 수 있으므로 가장 최악의 경우로 테스트 진행

매수: 고가에서 매수

매도: 저가에서 매도

수수료율은 키움 실거래계좌 기준

조건검색은 2가지로 진행했습니다.

1.거래량상위

2.시윤주식

매매방식

1.하나의 종목당 10만원 투자

2.-tsar,dmi 사용

20일 당일거래 수익율

거래량상위버전

그래프

138250

078890

038880

026890

시윤주식버전

그래프

000250

002290

018620

모든기간 계산시 수익율

1.거래량상위

2.시윤주식

python calculation Psar

def 계산psar(self,barsdata, iaf=0.02, maxaf=0.2):
    length = len(barsdata)
    first_index = 0
    high = list(barsdata['high'])
    low = list(barsdata['low'])
    close = list(barsdata['y'])
    psar = close[0:len(close)]
    bull = True
    af = iaf

    hp = high[first_index]
    lp = low[first_index]


    for i in range(first_index+2, length):
        if bull:
            psar[i] = psar[i - 1] + af * (hp - psar[i - 1])
        else:
            psar[i] = psar[i - 1] + af * (lp - psar[i - 1])
        reverse = False
        if bull:
            if low[i] < psar[i]:
                bull = False
                reverse = True
                psar[i] = hp
                lp = low[i]
                af = iaf
        else:
            if high[i] > psar[i]:
                bull = True
                reverse = True
                psar[i] = lp
                hp = high[i]
                af = iaf
        if not reverse:
            if bull:
                if high[i] > hp:
                    hp = high[i]
                    af = min(af + iaf, maxaf)
                if low[i - 1] < psar[i]:
                    psar[i] = low[i - 1]
                if low[i - 2] < psar[i]:
                    psar[i] = low[i - 2]
            else:
                if low[i] < lp:
                    lp = low[i]
                    af = min(af + iaf, maxaf)
                if high[i - 1] > psar[i]:
                    psar[i] = high[i - 1]
                if high[i - 2] > psar[i]:
                    psar[i] = high[i - 2]


    barsdata["psar"] = psar

def 실시간계산psar(self,barsdata, iaf=0.02, maxaf=0.2):

    length = len(barsdata)
    first_index = len(barsdata)-2
    high = list(barsdata['high'])
    low = list(barsdata['low'])

    bull = True
    af = iaf

    hp = high[first_index]
    lp = low[first_index]

    for i in range(first_index + 2, length):
        if bull:
            barsdata["psar"].iloc[i] = barsdata["psar"].iloc[i - 1] + af * (hp - barsdata["psar"].iloc[i - 1])
        else:
            barsdata["psar"].iloc[i] = barsdata["psar"].iloc[i - 1] + af * (lp - barsdata["psar"].iloc[i - 1])
        reverse = False
        if bull:
            if low[i] < barsdata["psar"].iloc[i]:
                bull = False
                reverse = True
                barsdata["psar"].iloc[i] = hp
                lp = low[i]
                af = iaf
        else:
            if high[i] > barsdata["psar"].iloc[i]:
                bull = True
                reverse = True
                barsdata["psar"].iloc[i] = lp
                hp = high[i]
                af = iaf
        if not reverse:
            if bull:
                if high[i] > hp:
                    hp = high[i]
                    af = min(af + iaf, maxaf)
                if low[i - 1] < barsdata["psar"].iloc[i]:
                    barsdata["psar"].iloc[i] = low[i - 1]
                if low[i - 2] < barsdata["psar"].iloc[i]:
                    barsdata["psar"].iloc[i] = low[i - 2]
            else:
                if low[i] < lp:
                    lp = low[i]
                    af = min(af + iaf, maxaf)
                if high[i - 1] > barsdata["psar"].iloc[i]:
                    barsdata["psar"].iloc[i] = high[i - 1]
                if high[i - 2] > barsdata["psar"].iloc[i]:
                    barsdata["psar"].iloc[i] = high[i - 2]

2021년 8월 18일 수요일

python calculate DMI(원본)

def cal_dmi(self,data, n=14,n_ADX=14):
    i = 0
    UpI = [0]
    DoI = [0]

    data["UpI"]=0
    data["DoI"]=0

    while i + 1 <= data.index[-1] :
        UpMove = data.loc[i + 1, "high"] - data.loc[i, "high"]
        DoMove = data.loc[i, "low"] - data.loc[i+1, "low"]
        if UpMove > DoMove and UpMove > 0 :
            UpD = UpMove
        else :
            UpD = 0
        data["UpI"].iloc[i] = UpD
        # UpI.append(UpD)

        if DoMove > UpMove and DoMove > 0 :
            DoD = DoMove
        else :
            DoD = 0

        # DoI.append(DoD)
        data["DoI"].iloc[i] = DoD
        i = i + 1

    i = 0
    TR_l = [0]
    data["TR_l"]=0
    while i < data.index[-1]:
        TR = max(data.loc[i + 1, 'high'], data.loc[i, 'y']) - min(data.loc[i + 1, 'low'], data.loc[i, 'y'])
        # TR_l.append(TR)
        data["TR_l"].iloc[i]=TR
        i = i + 1


    TR_s = pd.Series(TR_l)
    # ATR = pd.Series(TR_s.ewm(span=n, min_periods=1).mean())
    ATR = pd.Series(data["TR_l"].ewm(span=n, min_periods=1).mean())
    # UpI = pd.Series(UpI)
    # DoI = pd.Series(DoI)
    # PosDI = pd.Series(UpI.ewm(span=n, min_periods=1).mean() / ATR)
    # NegDI = pd.Series(DoI.ewm(span=n, min_periods=1).mean() / ATR)

    PosDI = pd.Series(data["UpI"].ewm(span=n, min_periods=1).mean() / ATR)
    NegDI = pd.Series(data["DoI"].ewm(span=n, min_periods=1).mean() / ATR)

    ADX = pd.Series((abs(PosDI - NegDI) / (PosDI + NegDI)).ewm(span=n_ADX, min_periods=1).mean(), name='ADX_' + str(n) + '_' + str(n_ADX))
    data["DIMinus"] =round(NegDI*100,2)
    data["DIPlus"] = round(PosDI*100,2)
    data["ADX"] =round(ADX*100,2)

######실시간용과 전체용

def 계산DMI(self,data, n=14,n_ADX=14):


    data["UpI"]=0
    data["DoI"]=0
    data["TR_l"]=0

    # first_index = 803

    # print("111:[%s] 222:[%s]"%(data.index[-1],len(data)-1))

    # i = first_index
    i=0

    while i + 1 <= len(data)-1:
        # UpMove = data.loc[i+1 , "high"] - data.loc[i, "high"]
        # DoMove = data.loc[i, "low"] - data.loc[i+1, "low"]
        # print("i:[%s][%s]"%(i,data["ds"].iloc[i]))
        UpMove = data["high"].iloc[i + 1] - data["high"].iloc[i]
        DoMove = data["low"].iloc[i] - data["low"].iloc[i + 1]

        if UpMove > DoMove and UpMove > 0 :
            UpD = UpMove
        else :
            UpD = 0

        data["UpI"].iloc[i+1] = UpD

        if DoMove > UpMove and DoMove > 0 :
            DoD = DoMove
        else :
            DoD = 0

        data["DoI"].iloc[i+1] = DoD
        i = i + 1

    i = 0

    while i < len(data)-1:
        TR = max(data["high"].iloc[i + 1], data["y"].iloc[i]) - min(data["low"].iloc[i + 1], data["y"].iloc[i])
        data["TR_l"].iloc[i+1]=TR
        i = i + 1

    ATR = pd.Series(data["TR_l"].ewm(span=n, min_periods=1).mean())
    PosDI = pd.Series(data["UpI"].ewm(span=n, min_periods=1).mean() / ATR)
    NegDI = pd.Series(data["DoI"].ewm(span=n, min_periods=1).mean() / ATR)
    ADX = pd.Series((abs(PosDI - NegDI) / (PosDI + NegDI)).ewm(span=n_ADX, min_periods=1).mean(), name='ADX_' + str(n) + '_' + str(n_ADX))

    data["DIMinus"] =round(NegDI*100,2)
    data["DIPlus"] = round(PosDI*100,2)
    data["ADX"] =round(ADX*100,2)












def 실시간dmi(self,code,n=14,n_ADX=14):


    i = len(self.실시간차트용데이터[code])-5

    while i + 1 <= len(self.실시간차트용데이터[code]) - 1:
        UpMove = self.실시간차트용데이터[code]["high"].iloc[i + 1] - self.실시간차트용데이터[code]["high"].iloc[i]
        DoMove = self.실시간차트용데이터[code]["low"].iloc[i] - self.실시간차트용데이터[code]["low"].iloc[i + 1]

        if UpMove > DoMove and UpMove > 0:
            UpD = UpMove
        else:
            UpD = 0

        # self.실시간차트용데이터[code]["UpI"].iloc[i + 1] = UpD

        if DoMove > UpMove and DoMove > 0:
            DoD = DoMove
        else:
            DoD = 0

        # self.실시간차트용데이터[code]["DoI"].iloc[i + 1] = DoD
        ##마지막값만 변경
        if i+1 == len(self.실시간차트용데이터[code]) - 1:
            print("여기안타나??? [%s %s ]"%(self.실시간차트용데이터[code]["ds"].iloc[i+1],i))
            print("UpD:[%s]"%UpD)
            print("Dod:[%s]"%DoD)
            print("UpMove DoMove:[%s,%s]"%(UpMove,DoMove))
            self.실시간차트용데이터[code]["UpI"].iloc[i+1] = UpD
            self.실시간차트용데이터[code]["DoI"].iloc[i+1] = DoD

        i = i + 1

    i = len(self.실시간차트용데이터[code])-5

    while i < len(self.실시간차트용데이터[code]) - 1:
        TR = max(self.실시간차트용데이터[code]["high"].iloc[i + 1], self.실시간차트용데이터[code]["y"].iloc[i]) - min(self.실시간차트용데이터[code]["low"].iloc[i + 1], self.실시간차트용데이터[code]["y"].iloc[i])
        if i==len(self.실시간차트용데이터[code])-2:
            self.실시간차트용데이터[code]["TR_l"].iloc[i+1] = TR
        i = i + 1

    ATR = pd.Series(self.실시간차트용데이터[code]["TR_l"].ewm(span=n, min_periods=1).mean())
    PosDI = pd.Series(self.실시간차트용데이터[code]["UpI"].ewm(span=n, min_periods=1).mean() / ATR)
    NegDI = pd.Series(self.실시간차트용데이터[code]["DoI"].ewm(span=n, min_periods=1).mean() / ATR)
    print("NegDI%s"%NegDI.tail(5))
    print()
    ADX = pd.Series((abs(PosDI - NegDI) / (PosDI + NegDI)).ewm(span=n_ADX, min_periods=1).mean(),
                    name='ADX_' + str(n) + '_' + str(n_ADX))

    self.실시간차트용데이터[code]["DIMinus"].iloc[len(self.실시간차트용데이터[code]) - 1] = round(NegDI.iloc[len(NegDI) - 1] * 100, 2)
    self.실시간차트용데이터[code]["DIPlus"].iloc[len(self.실시간차트용데이터[code]) - 1] = round(PosDI.iloc[len(PosDI) - 1] * 100, 2)
    self.실시간차트용데이터[code]["ADX"].iloc[len(self.실시간차트용데이터[code]) - 1] = round(ADX.iloc[len(ADX) - 1] * 100, 2)

꿀맛은개뿔