์์ ์ ์ฃผ์๋ ํด๋ณด๊ณ ์ฝ์ธ๋ ํด๋ดค์๋๋ฐ, ์ ๋ณด๋ ์์ด ์ฌ๋์ ๋จธ๋ฆฌ๋ก ์๊ฐํ๊ณ ์์ผ๋ก ๊ฑฐ๋ํ๋ค๋ณด๋ ๊ฒฐ๊ณผ์ ์ผ๋ก ์๋๊ฒ ๋ ์ปธ๋ ๊ฒ ๊ฐ๋ค. ์ด๋๋ณด๋ฉด ์์ฌ์ด ์๊ธฐ๊ณ , ์ํด๋ณด๋ฉด ์ธ์ ๊ฐ ์ค๋ฅด๊ฒ ์ง๋ ์๊ฐ์ผ๋ก๋ ๋ชป ๋ฒ๊ฒ ๋ค๊ณ ๋๊ผ์๊ณ ์ ์์๋ค.
๋ค์ ์ฝ์ธํ์ด ์ฌ๋ผ์ค๋ฉด์ ๋ด์ ๋๋ ค๋ฒ๋ฆฌ๋ฉด ๋ด๊ฐ ์ค์ ํ ์กฐ๊ฑด ์์์ ์์ ํ๊ฒ ์์ต์ ์ฐฝ์ถํ ์ ์์ง ์์๊นํด์ ๊ฐ๋จํ ์๋๋งค๋งค ํ๋ก๊ทธ๋จ์ ๋ง๋ค์์๊ณ , ๋ฐฑํ ์คํ ์ ํตํด ๊ฒฐ๊ณผ๋ฅผ ๋ฐ์ ธ๋ณด๊ณ ๋ง์์ผ๋ก ํ ์คํธ๊ธฐ๊ฐ์ ๊ฐ์ก์๋ค.
์ผ๋จ, ์ฃผ์ํ์ ์ ๋ณด๋ ๋ง์ด์๊ณ , ์ด๋ฏธ ์ฌ๋ฌ ์๊ณ ๋ฆฌ์ฆ๊ณผ ์ ๋ต, ์ ๋ณด๋ค๊ณผ ์ธ๊ณต์ง๋ฅ ๋ชจ๋ธ์ ํตํด ํ๋ก๊ทธ๋จ์ด ๋ง์๊ธฐ์ ์๊ฐํ์ง ์์๊ณ , ์ฝ์ธํ๋ฒ ํด๋ณด๋ ์ฃผ์๋ณด๋จ ์ฝ์ธ์ด ์ฌ๋ฐ์์๋ค. ์ฝ์ธํ์ 24์๊ฐ ๋์๊ฐ๊ธฐ์ ์ฌ๋ฌ ์กฐ๊ฑด ๋ฐ์ ธ์ ์๋๋งค๋งค ํ๋ก๊ทธ๋จ ๋๋ ค๋ฒ๋ฆฌ๊ธฐ์ ์ข์ ๊ฒ ๊ฐ๋ค๊ณ ์๊ฐํด์ ์ ์ํ์๋ค.
์ฒ์ ์ ์ํ ํ๋ก๊ทธ๋จ์ ์ง์ง ๊ฐ๋จํ๊ฒ ํ๋ฃจ๋์ ์๊ฐํ ๊ฒ์ผ๋ก ๋๋ ธ์๋ค.
์ ๋นํธ์์ ๊ฐ์ ธ์จ api๋ก ์ด์ ์ข ๊ฐ์ ํ์ฌ ์ข ๊ฐ, ๊ฑฐ๋๋ ๋ฑ์ ๋ฐ์ ธ์ ๊ธ๋ฑํ ๊ฒ ๊ฐ์ ์ฝ์ธ์ ์ฐพ๊ณ , ์ฐพ์๋ค๋ฉด ์ฌ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์์๋ค.
์ด๋ ๊ฒ ๋ชจ๋ ์ข ๋ชฉ์ ๊ฒ์ํ๋ฉด์ ์กฐ๊ฑด์ ๋ฐ์ ธ๋ณด๊ณ , ๋ฐ๊ฒฌํ๋ฉด ์ฌ๊ณ , ์ฌ๋ผ๊ฐ๋ค๊ฐ 0.5% ๋จ์ด์ง๋ฉด ๋ค์ ํ๋ ํ๋ก๊ทธ๋จ์ด์๋ค.
์ด๋ฐ์์ผ๋ก ํ ์คํธ๊ฒฐ๊ณผ ๊ด์ฐฎ์ ๊ฒ ๊ฐ์์ ๋๋ ค๋๊ณ ์๊ณ ์ผ์ด๋ฌ๋๋ฐ 10000์ > 8000์(-20%) ๋๋ ค๋ฐํ๊ณ ๋ค ๋ฏ์ด ๊ณ ์ณค๋ค.
์ด์ ๋ชจ๋ธ๋ค์ ๊ฑฐ์ 20๋ถ์ ํ๋ฒ๊ผด๋ก ์ฌ๊ณ ํ๊ณ ๋ฅผ ๋ฐ๋ณตํ๋ฉด์ ์์๋ฃ์ ์ํด๋ฅผ ๋ดค์๋๋ฐ, ํ์ฌ๋ ํ๋ฃจ์ ๋ช๋ฒ๋ง ๊ฑฐ๋๋ฅผ ํ๋ ๋ด์ ์ ์ํ์๋ค.
์ผ๋จ ์ ์ผ ์ด์ฐฝ๊ธฐ ๋ชจ๋ธ๋ง ์ฌ๋ฆด ๊ฒ์ด๋ค. ์ด ๋๋ ์ง์ง ๊ฐ๋จํ ์กฐ๊ฑด๋ง ์ถ๊ฐํ ๊ฒ์ด๋ผ ์์ต์ ๊ธฐ๋ํ๊ธด ์ด๋ ต๋ค.
import time
import pyupbit
import datetime
import pandas
import json
import random
access = "-"
secret = "-"
# ๋ก๊ทธ์ธ
upbit = pyupbit.Upbit(access, secret)
print("๊ฐ์ฅฌ์")
coinArray = pyupbit.get_tickers(fiat="KRW")
coinArray = random.shuffle(coinArray)
count = 0
ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๊ฐ์ ธ์ค๊ณ , ์ ๋นํธ api๋ฅผ ์ ๊ณต๋ฐ์์ ๋ก๊ทธ์ธ์ ํ๊ณ , ๋ชจ๋ ์ฝ์ธ ์ข ๋ชฉ์ ๊ฐ์ ธ์์ ๋๋ค์ผ๋ก ๋ฐฐ์ด์ ๋ฃ์๋ค.
def search() :
global count
try :
count +=1
coinArray = pyupbit.get_tickers(fiat="KRW")
coinArray = list(reversed(coinArray))
for i in coinArray :
#1๋ถ๋ด #200
df = pyupbit.get_ohlcv(i, "minute1")
#n/2๋ถ ์ ์ข
๊ฐ
ssClose = int(df.iloc[-10]['close'])
#n๋ถ ์ ์ข
๊ฐ
firstClose = int(df.iloc[-5]['close'])
#n๋ถ ์ ๊ฑฐ๋๋
firstVolume =int(df.iloc[-5]['volume'])
#n๋ถ ์ ๊ฑฐ๋๋
sVolume =int(df.iloc[-3]['volume'])
#n/2๋ถ ์ ์ข
๊ฐ
sClose = int(df.iloc[-3]['close'])
#ํ์ฌ ์ข
๊ฐ
curClose = int(df.iloc[-1]['close'])
#ํ์ฌ ๊ฑฐ๋๋
curVolume = int(df.iloc[-1]['volume'])
Price = pyupbit.get_current_price(i)
print()
print("*** "+ i + " ***")
print('์ฒ์ ์ข
๊ฐ/๊ฑฐ๋๋' + str(firstClose) + '/' + str(firstVolume))
print('ํ์ฌ ์ข
๊ฐ/๊ฑฐ๋๋' + str(curClose) + '/' + str(curVolume))
if (firstClose < int(Price) and sClose < int(Price) and ssClose*1.01 < int(Price) and firstVolume * 1.5 < curVolume and sVolume *2 < curVolume) :
print("!!!!!!!๊ธ๋ฑ์ฝ์ธ!!!!!!!!")
return i
break
except :
print("๋ค์์กฐํํฉ๋๋ค. {} ํ ๋ฐ๋ณต์ค".format(count))
time.sleep(2)
search()
๋จํ๋ก ๋ฎ์ ์์ต๋ง ๋นผ๊ฐ๋ ค๊ณ ์ค์ ํ ์กฐ๊ฑด์ด๋ค. ๋ฌผ๋ก ์ด๊ฒ๋ง ๋ฐ์ก๋ค๊ฐ ์ํด๋ณด๊ณ ๋ค๋ฏ์ด๊ณ ์ณค๋ค.
๊ฐ ์ฝ์ธ๋ง๋ค ์ ๋ณด๋ฅผ ๊ฐ์ ธ์์ 1๋ถ๋ด์ผ๋ก ์ข ๊ฐ์ ๊ฑฐ๋๋์ ๋ฐ์ ธ์ ์กฐ๊ฑด์ ๋ง์ผ๋ฉด ๊ธ๋ฑ์ฝ์ธ์ด๋ผ ํ๋จํ๊ณ , ๋ชป์ฐพ๋๋ค๋ฉด ๋ค์ ์ฒ์๋ถํฐ ์ฐพ๊ฒ ๋ง๋ค์์๋ค.
while True:
try:
i = search() #๊ธ๋ฑ์ฝ์ธ ๊ฒฐ์
krw = upbit.get_balance("KRW")
upbit.buy_market_order(i, krw*0.9995)
print("<<<< " + str(i) + " ๊ตฌ๋งค์๋ฃ >>>>")
# ๊ฒฐ์ ๊ธ์ก
firstPrice = pyupbit.get_current_price(i)
print("๊ตฌ๋งค๊ธ์ก : " + str(firstPrice))
while True :
df1 = pyupbit.get_ohlcv(i, "minute1")
#n๋ถ ์ ์ข
๊ฐ
firstClose = int(df1.iloc[-3]['close'])
#n๋ถ ์ ์ข
๊ฐ
firstClose2 = int(df1.iloc[-5]['close'])
#ํ์ฌ ์ข
๊ฐ
curClose = int(df1.iloc[-1]['close'])
curPrice = pyupbit.get_current_price(i)
# ์ต๊ทผ 5๋ถ ์ , 3๋ถ ์ ๋ ๋ค 0.5%์ด์ ํ๋ฝํ์๋ or ๊ตฌ๋งค๊ฐ๊ฒฉ์์ 0.7% ์ํด๋ดค์๋
if (firstClose*0.995 > int(curPrice) and firstClose2*0.995 > int(curPrice)) or firstPrice *0.993 > curPrice:
useCoin = upbit.get_balance(i)
upbit.sell_market_order(i, useCoin)
print("<<<< " + str(i) + " ํ๋งค์๋ฃ >>>>")
time.sleep(5)
print("ํ์ฌ ๋ณด์ KRW : " + str(upbit.get_balance("KRW")))
break
else : time.sleep(5)
print('ํ๋งค์ฝ์ธ ํ์ฌ๊ฐ : ' + str(pyupbit.get_current_price(i)))
time.sleep(10)
except Exception as e:
print(e)
time.sleep(1)
๋ณด๋ฉด ์๊ฒ ์ง๋ง, ์ง์ง ๊ฐ๋จํ ์๋๋งค๋งค ํ๋ก๊ทธ๋จ์ด๋ผ ์ฝ๋๊ฐ 100์ค๊ฐ๋ ๋ฐ์ ๋์ง์๋๋ค. ๋ฌผ๋ก ์ง๊ธ์ ๋ช๋ฐฐ๋ฐ์๋ค..
๊ฒฐ์ ๋๋ฉด ๊ทธ ์ฝ์ธ์ ๊ตฌ๋งคํ๊ณ , ๊ทธ ์ฝ์ธ์ ๋ํ ์ ๋ณด๋ง ์กฐํํ๋ฉด์ ์กฐ๊ฑด ๋ ๋๊น์ง ๊ธฐ๋ค๋ ธ๋ค๊ฐ ์กฐ๊ฑด์ด ๋๋ฉด ๋ค์ ํ๊ณ ์ฒ์๋ถํฐ ๋ค์ ์์ํ๋ ํ๋ก๊ทธ๋จ์ด์๋ค.
์ฒ์ ์๊ฐํ ๋ฐฉ๋ฒ์ ๊ตฌ๋งค๋์ด ๋ง๊ณ ๊ฐ๊ฒฉ์ด ์ฌ๋ผ๊ฐ๋ค๋ฉด ํ์นํด์, ์ญ ํ๊ณ ์ฌ๋ผ๊ฐ๋ค๊ฐ, ๊ฐ์๊ธฐ ์ด๋์ ๋ ๋จ์ด์ง๋ฉด ๋ฐ๋ก ํ์๋ฒ๋ฆฌ๋ ๋จํ๋ฅผ ์ํ ์ฝ๋์๋๋ฐ, ์ค์ ๋ฐฑํ ์คํ ์ด๋ ๊ฒฐ๊ณผ๋ฅผ ๋ดค์ ๋์๋ ๊ธ ์ฌ๋ผ๊ฐ๊ธธ๋ ์ฌ๊ณ , ์ฌ์๋ง์ ๋จ์ด์ง๋ฉด ๋ฐ๋ก ํ์๋ฒ๋ ค์ ์ฌ๋ฌ ์์ ํ๋ค๊ฐ ๊ทธ๋ฅ ๋ฒ๋ฆฐ ์ฝ๋์ด๋ค.
์์ ์ฝ๋๋ ๊ทธ๋ฅ ์ด๋ค ์์ผ๋ก ์ ์์ ์์ํ๋ฉด ๋๋์ง์ ๋ํ ์ฝ๋์ด๊ณ , ๋ฐ๋ผํ๋ค๊ฐ ์ํด๋ง ๋ณผ ๊ฒ์ด๋ค.
์ฌ๋ฌ ์ ๋ต๋ค์ ์๊ฐํด๋ด๊ฑฐ๋, ์ ๋ณด๋ฅผ ๋ฐ์์ ์ด๋ฅผ ์ ์ฉ์ํค๊ณ ๋๋ฆฌ๋ฉด ๋ ๊ฒ์ด๋ค.
๊ทธ๋๋ ๊ฐ๋จํ ์๋๋งค๋งค ํ๋ก๊ทธ๋จ์ ์ ์ํ ์ ์๊ณ , ์๋ฒ๊ฐ์ ๊ฑธ๋ก 24์๊ฐ ๋๋ฆด ์ ์๋ค๋ ์ ์ด ์ข๋ค.
๋ค๋ง, ๊ฐ๋จํ ์๋ก ์์ข์ ๋ณ์ ์ํฉ๋ค์ ๋ํด ์ฒ๋ฆฌํ ์ ์๊ธฐ์ ์ํด๋ฅผ ๋ณผ ๊ฒ์ด๋ค.
์์ ์ฑ์๋ ๋ชจ๋ธ์ ๊ตฌํํด์ ์ ์ฉํ๋ฉด ์ข์ ๊ฒ์ด๋ค.
ํ์ฌ ๋๋ ์ฌ๋ฌ ๋ชจ๋ธ๋ค์ ์ ์ํ๊ณ ํ ์คํธํด๋ณด๋ฉด์ ์ฐพ๋ ์ค์ด๊ณ , ๊ทธ๋๋ง ์ด๋ณด์์ค์์ ์์น์ฅ์ด๋ ํ๋ฝ์ฅ์ด๋ ์์ต๋ฅ ์ ๋นํ ๋์ค๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค๊ณ ์๋ ๊ฒ ๊ฐ์์ ๊ธฐ๋ถ์ด ์ข๋ค.
๋์ค์ LSTM์ผ๋ก ๋ฅ๋ฌ๋๋ชจ๋ธ ๋๋ ค์ ์ ๋ณด๋ฐ๊ณ ์ด๋ฅผ ์ ์ฉํด์ ๋ง๋ค์ด ๋ณผ๋ คํ๋ค.
์ฉ๋๋ฒ์ด ํด์ผ๊ฒ ๋ค๋ ์ผ๋ง๊ฐ์ง๋ ์ค.