def get_market_timing(self, ticker):
try:
ma_score = 0
df = pybithumb.get_candlestick(ticker)
ma3 = df.close.rolling(3).mean()
ma5 = df.close.rolling(5).mean()
ma10 = df.close.rolling(10).mean()
ma20 = df.close.rolling(20).mean()
yesterday = df.iloc[-2]
close_price = yesterday['close']
if close_price > ma3[-2]:
ma_score += 1
if close_price > ma5[-2]:
ma_score += 1
if close_price > ma10[-2]:
ma_score += 1
if close_price > ma20[-2]:
ma_score += 1
result_score = round(ma_score / 4, 2)
return result_score
except Exception as e:
print(e)
return 0.0
def get_noise(_ticker):
noise = 0
df = pybithumb.get_candlestick(_ticker)
for num in range(2, 22):
noise += 1 - abs(
df.iloc[num * -1]['open'] - df.iloc[num * -1]['close']) / (
df.iloc[num * -1]['high'] - df.iloc[num * -1]['low'])
return round(noise / 20, 1)
def get_volatility(self, ticker):
df = pybithumb.get_candlestick(ticker)
yesterday = df.iloc[-2]
today_open = yesterday['close'] # 오늘은 어제의 종가 = 오늘의 시가
yesterday_high = yesterday['high'] # 어제의 고가
yesterday_low = yesterday['low'] # 어제의 저가
volatility = ((yesterday_high - yesterday_low) / today_open) * 100
return round(volatility)
def get_candlestick(self, ticker, interval, retry_cnt):
try:
if os.path.isfile("data/" + str(ticker) + "/" + str(ticker) +
"_candlestick_" + str(interval) + ".xlsx"):
print("data/" + str(ticker) + "/" + str(ticker) +
"_candlestick_" + str(interval) + ".xlsx - is exist!!")
else:
pybithumb.get_candlestick(
ticker, "KRW",
interval).to_excel("data/" + str(ticker) + "/" +
str(ticker) + "_candlestick_" +
str(interval) + ".xlsx")
except:
print("Retry " + str(retry_cnt) + " of " + str(ticker) +
"_candlestick_" + str(interval))
retry_cnt = retry_cnt + 1
if retry_cnt < 300:
self.get_candlestick(ticker, interval, retry_cnt)
else:
print("Parsing skipped... " + str(retry_cnt) + " of " +
str(ticker) + "_candlestick_" + str(interval))
def get_market_infos(self, ticker):
df = pybithumb.get_candlestick(ticker)
ma5 = df['close'].rolling(window=5).mean()
last_ma5 = ma5[-2]
price = pybithumb.get_current_price(ticker)
state = None
if price > last_ma5:
state = '상승장'
else:
state = '하락장'
return price, last_ma5, state
def get_ohlcv(self, ticker):
cache = self.cache
if not ticker:
ticker = "BTC"
d = cache.get(CACHE_get_candlestick)
if d:
return d # jsonify(json.loads(d))
else:
df = pybithumb.get_candlestick(ticker, chart_intervals="24h")
df = df.reset_index()
data = df.to_json() # no need to conver json dumps
cache.setex(CACHE_get_candlestick, CACHE_get_candlestick_TIME,
data)
return data
async def __subscribe_updater(self, ticker): # ✅
tickers = self.get_tickers()
if ticker not in tickers:
return None
df_tech = pybithumb.get_candlestick(ticker, chart_intervals="24h")
# df_tech["SMA_5"] = df_tech["close"].rolling(5).mean().shift(1)
# df_tech["SMA_2"] = df_tech["close"].rolling(2).mean().shift(1)
for i in [3, 5, 10, 20]:
df_tech[f"SMA_{i}"] = df_tech["close"].rolling(i).mean().shift(1)
df_tech["MMT"] = ((df_tech["high"] - df_tech["low"]) / 2).shift(1)
df_tech["MMT_TARGET"] = df_tech["open"] + df_tech["MMT"]
# df_tech["BULL_5"] = df_tech["close"] / df_tech["SMA_5"]
df_tech = df_tech.reset_index()
return df_tech
def get_ohlv(ticker, ms, ml):
df = Bithumb.get_candlestick(ticker, chart_intervals="12h")
df['fluctuation'] = df['open'] / df['open'].shift(1) * 100 - 100
df['transaction'] = df['volume'].shift(1) / df['volume'].shift(
2) * 100 - 100
# df = df[['close']].copy()
df['ma_s'] = df['close'].rolling(ms).mean().shift(1)
df['ma_l'] = df['close'].rolling(ml).mean().shift(1)
cond = (df['ma_s'] > df['ma_l'])
df['status'] = np.where(cond, 1, 0)
return df
def get_marget_info(self, ticker):
# 빗썸 서버에서 가상화폐에 대한 데이터를 가져옵니다.
df = pybithumb.get_candlestick(ticker)
# 종가에 대해 5일 간격의 이동평균을 구합니다.
mean_average = df['close'].rolling(5).mean()
# 전날의 이동평균값을 가져옵니다.
last_mean_average = mean_average[-2]
price = pybithumb.get_current_price(ticker)
if price > last_mean_average:
state = "상승장"
else:
state = "하락장"
return price, last_mean_average, state
def get_target_price(self, ticker):
def get_noise(_ticker):
noise = 0
df = pybithumb.get_candlestick(_ticker)
for num in range(2, 22):
noise += 1 - abs(
df.iloc[num * -1]['open'] - df.iloc[num * -1]['close']) / (
df.iloc[num * -1]['high'] - df.iloc[num * -1]['low'])
return round(noise / 20, 1)
df = pybithumb.get_candlestick(ticker)
yesterday = df.iloc[-2]
today_open = yesterday['close'] # 오늘은 어제의 종가 = 오늘의 시가
yesterday_high = yesterday['high'] # 어제의 고가
yesterday_low = yesterday['low'] # 어제의 저가
_range = yesterday_high - yesterday_low
k = get_noise(ticker)
target = today_open + _range * k
return target
def get_ohlv(ticker, ms, ml):
df = Bithumb.get_candlestick(ticker, chart_intervals="12h")
df = df[['close']].copy()
df['ma_s'] = df['close'].rolling(ms).mean().shift(1)
df['ma_l'] = df['close'].rolling(ml).mean().shift(1)
cond = (df['ma_s'] > df['ma_l'])
df['status'] = np.where(cond, 1, 0)
if (df['status'][-2] == 0) & (df['status'][-1] == 1):
print('지금이니', df['ma_s'][-1])
return "지금이니", df['ma_s'][-1]
elif (df['status'][-2] == 1) & (df['status'][-1] == 0):
print('팔아!', df['ma_s'][-1])
return "팔아!", df['ma_s'][-1]
elif (df['status'][-2] == 1) & (df['status'][-1] == 1):
print('홀딩해', df['ma_s'][-1])
return "홀딩해", df['ma_s'][-1]
elif (df['status'][-2] == 0) & (df['status'][-1] == 0):
print('도망쳐', df['ma_s'][-1])
return "도망쳐", df['ma_s'][-1]
def get_market_info(self, ticker):
try:
self.mutex.lock()
df = pybithumb.get_candlestick(ticker)
mean_average = df['close'].rolling(5).mean()
price = pybithumb.get_current_price(ticker)
last_mean_average = mean_average[-2]
if price > last_mean_average:
state = "상승장"
else:
state = "하락장"
self.mutex.unlock()
return [price, last_mean_average, state]
except:
print("get_marget_info error")
self.mutex.unlock()
return [None, None, None]
def get_target_price():
global target_price
try:
df = pybithumb.get_candlestick("BTC")
yesterday = df.iloc[-2]
today_open = yesterday['close'] # 오늘 시가 = 전날 종가
yesterday_high = yesterday['high'] # 전날 고가
yesterday_low = yesterday['low'] # 전날 저가
target_price = today_open + (yesterday_high - yesterday_low
) * 0.5 # 목표가 = 오늘 시가 + (전날 변동폭)* 0.5
now = time.localtime()
print(
"목표가 갱신 시각:", "%04d/%02d/%02d %02d:%02d:%02d" %
(now.tm_year, now.tm_mon, now.tm_mday, now.tm_hour, now.tm_min,
now.tm_sec))
except:
print("목표가 갱신 실패")
sell_bitcoin() # 매도 시도, 변동성 돌파전략에 의해, 당일 구매한 코인이 있다면 자정에 매도한다.
def get_ror(k):
"""
:param k: 변동폭
:return: 수익률
"""
df = pybithumb.get_candlestick("BTC") # 비트코인 일봉 데이터
df = df['2020']
df["ma5"] = df['close'].rolling(5).mean().shift(1) # 5일간 이동평균 컬럼 추가
df['range'] = (df['high'] - df['low']) * k # 변동폭, range 컬럼 추가
df['target'] = df['open'] + df['range'].shift(
1) # shift 메서드는 컬럼 값의 행을 내려준다.,, 목표가 계산
df['isBull'] = df['open'] > df['ma5'] # 상승장여부 컬럼
# 백테스팅을 위한 데이터 준비완료!
# 변동성 돌파와 상승장 전략과 일치하면, 그날은 매수를 한 날이고, 수익률은 종가(매도가)/목표가(매수가)이다.
# 매수를 하지 않았다면 수익률은 원금 그대로 1이다.
df['ror'] = np.where((df['high'] > df['target']) & (df['isBull']),
(df['close'] / df['target']), 1)
# cumprod는 해당 열의 값을 모두 곱하여 반환한다. 즉, 해당 기간동안의 수익률을 나타낸다.
ror = df['ror'].cumprod()[-2]
return ror
def get_yesterday_btc_ma5():
df = pybithumb.get_candlestick("BTC")
close = df['close']
ma5 = close.rolling(5).mean()
return ma5[-2]
def get_hpr(ticker):
time.sleep(0.1)
try:
bene = 1.33 #익절조건 예상 : 1.3
cross = 0.0012 #십자가조건 예상 : 0.003
stop_loss = 0.021 #손절조건 예상 : 0.03
jang_plus = 0.027 #장대양봉조건 예상 : 0.05
jang_minus = 0.022 #장대음봉조건 예상 : 0.05
real_buy_price = 1 #실제로 구매했을때 가격 저장용, 초기화
wallet_bull = False #지갑상태 초기화
df = pybithumb.get_candlestick(
ticker) #가상화폐의 open,high,low,close,volume 가져옴, 함수 수정으로 단위 변경 가능
#df = df['2020'] #기간 설정 가능
df['ma5_yes'] = df['close'].rolling(window=5).mean().shift(
1) #1일전 5일 평균(종가기준)
df['ma5_yes2'] = df['close'].rolling(window=5).mean().shift(
2) #2일전 5일 평균
df['ma5_yes3'] = df['close'].rolling(window=5).mean().shift(
3) # 3일전 5일 평균
df['ma20_yes'] = df['close'].rolling(window=20).mean().shift(
1) #1일전 20일 평균(종가기준)
df['ma20_yes2'] = df['close'].rolling(window=20).mean().shift(
2) #2일전 20일 평균
#거래량 평균값 저장
df['volume_aver'] = 0 #총 거래량 초기화
df['vr'] = df['volume'].rolling(window=len(df)).mean() #총 거래량 평균
vr = df['vr'].iloc[len(df) - 1] #총 거래량 평균 값 지정
for i in range(0, len(df)):
df['volume_aver'].iloc[i] = vr
#평균 거래량*2배 가 넘을때 True, 아니면 False
df['bull_volume_2over'] = np.where(
df['volume'].shift(1) > 2 * df['volume_aver'], True, False)
#장대양봉, 장대음봉(k)
df['jang_dae_p'] = df['close'].shift(1) - df['open'].shift(
1) > df['open'].shift(1) * jang_plus
df['jang_dae_m'] = np.where(
((df['close'].shift(1) - df['open'].shift(1)) < 0) &
(abs(df['close'].shift(1) - df['open'].shift(1)) >
df['open'].shift(1) * jang_minus), True, False)
#손절 장대음봉(k)
df['jang_dae_m_stop'] = np.where(
((df['close'] - df['open']) < 0) &
(abs(df['close'] - df['open']) > df['open'] * stop_loss), True,
False)
#장대양봉, 장대음봉 + 평균 2배 거래량
df['jang_dae_plus'] = np.where(
df['bull_volume_2over'] & df['jang_dae_p'], True, False)
df['jang_dae_minus'] = np.where(
df['bull_volume_2over'] & df['jang_dae_m'], True, False)
df['wallet_bull'] = wallet_bull # 지갑상태 초기화
df['real_buy_price'] = real_buy_price #실제 구매 가격 초기화
#골든크로스 조건
df['buy_bull_yes'] = df['ma5_yes'] > df[
'ma20_yes'] #어제 5일평균 > 어제 20일평균
df['buy_bull_yes2'] = df['ma5_yes2'] < df[
'ma20_yes2'] #2일전 5일평균 < 2일전 20일평균
# 5일평균 아래로 볼록
df['convex_down'] = np.where((df['ma5_yes'] > df['ma5_yes2']) &
(df['ma5_yes2'] < df['ma5_yes3']), True,
False)
#5일평균 위로 볼록
df['convex_up'] = np.where((df['ma5_yes'] < df['ma5_yes2']) &
(df['ma5_yes2'] > df['ma5_yes3']), True,
False)
#5일평균 상승장
df['up_market'] = np.where((df['ma5_yes'] > df['ma5_yes2']) &
(df['ma5_yes2'] > df['ma5_yes3']), True,
False) ##현재 사용 X
# 데드 크로스 일때 상태 표시
df['dead_cross'] = np.where((df['ma5_yes'] < df['ma20_yes']) &
(df['ma5_yes2'] > df['ma20_yes2']), True,
False)
#십자가조건일때(k)
df['sell_bull_cross'] = abs(df['close'].shift(1) - df['open'].shift(1)
) < df['open'].shift(1) * cross
# 골든 크로스, 장대양봉, 아래로 볼록 일때 시가로 구매(구매조건은 여기에 추가)
df['buy_price'] = np.where((df['buy_bull_yes'] & df['buy_bull_yes2'])
| df['jang_dae_plus'] | df['convex_down'],
df['open'], 1)
# 골든 크로스, 장대양봉, 아래로 볼록 일때 상태 표시(구매조건은 여기에 추가)
df['buy_state'] = np.where((df['buy_bull_yes'] & df['buy_bull_yes2'])
| df['jang_dae_plus'] | df['convex_down'],
True, False)
# 십자가, 데드크로스, 장대음봉, 위로 볼록 일때 시가로 판매(판매조건은 여기에 추가)
df['sell_price'] = np.where(
df['sell_bull_cross'] | df['dead_cross'] | df['jang_dae_minus']
| df['convex_up'], df['open'], 1)
# 십자가, 데드크로스, 장대음봉, 위로 볼록 일때 판매 상태 표시(판매조건은 여기에 추가)
df['sell_state'] = np.where(
df['sell_bull_cross'] | df['dead_cross'] | df['jang_dae_minus']
| df['convex_up'], True, False)
#손절, 익절, 구매, 판매 실행(지갑상태 영향 받음)
for i in range(0, len(df)):
# 손절 : 장대음봉(거래량 상관X)이면 시가의 1-stop_loss(기존 sell_price, sell_state에 덮어씌움)
if df['jang_dae_m_stop'].iloc[i]:
df['sell_price'].iloc[i] = df['open'].iloc[i] * (1 - stop_loss)
df['sell_state'].iloc[i] = True
# 실제로 구매 할때 df['wallet_bull']에 True입력, 실제로 판매 했을때 False입력(지갑상태 영향 받음)
if (i < len(df) - 1):
if not (df['wallet_bull'].iloc[i]) and df['buy_state'].iloc[i]:
wallet_bull = True
if df['wallet_bull'].iloc[i] and df['sell_state'].iloc[i]:
wallet_bull = False
df['wallet_bull'].iloc[i + 1] = wallet_bull
#실제로 구매 했을때 df['real_buy_price']에 구매가격 저장
if not (df['wallet_bull'].iloc[i]) and df['buy_state'].iloc[i]:
real_buy_price = df['buy_price'].iloc[i]
df['real_buy_price'].iloc[i] = real_buy_price
#익절 : 현재가가 구매가격*bene배가 넘었을때(기존 sell_price, sell_state에 덮어씌움)
if (i < len(df) - 1) and df['wallet_bull'].iloc[i] and (
df['real_buy_price'].iloc[i] * bene < df['high'].iloc[i]):
df['sell_price'].iloc[i] = df['real_buy_price'].iloc[i] * bene
df['sell_state'].iloc[i] = True
wallet_bull = False
df['wallet_bull'].iloc[i + 1] = wallet_bull
fee = 0.995 #수수료
#실제로 판매 했을때 수익률 계산
df['ror'] = np.where(df['sell_state'] & df['wallet_bull'],
df['sell_price'] * fee / df['real_buy_price'], 1)
df['hpr'] = df['ror'].cumprod() #총 수익률 계산
#df.to_excel("btc.xlsx") #앞의 내용을 엑셀에 저장, candlestick과 사용할 경우 오류
return df['hpr'][-2] #총 수익률 반환
except Exception as e: # 모든 예외의 에러 메시지를 출력할 때는 Exception을 사용
print('예외가 발생했습니다.', e)
# 원화 코인 분배
total_krw = bithumb.get_balance(ticker)[2]
for ticker in major_ticker:
krw_by_coin[ticker] = total_krw / len(major_ticker)
if krw_by_coin[ticker] > 1000:
wallet_bull[ticker] = True
else:
wallet_bull[ticker] = False
# print(wallet_bull)
# print(krw_by_coin)
# 딕셔너리 초기화(실행시 한번)
for ticker in major_ticker:
df = pybithumb.get_candlestick(ticker)
current_price[ticker] = pybithumb.get_current_price(ticker)
real_buy_current[ticker] = 0
beneath[ticker] = False
stop_loss[ticker] = False
# 각종 이동평균(실행시 한번)
yes_ma5 = get_yesterday_ma5(-2)
yes2_ma5 = get_yesterday_ma5(-3)
yes3_ma5 = get_yesterday_ma5(-4)
yes_ma20 = get_yesterday_ma20(-2)
yes2_ma20 = get_yesterday_ma20(-3)
# 오늘 시가, 어제 시가, 종가, 거래량, 년 평균 거래량(실행시 한번)
to_open = get_today_open()
yes_open = get_yesterday_open()
def run(self):
print("시작")
# num=-2 : yesterday
# num=-3 : yesterday2
# num=-4 : yesterday3
def get_yesterday_ma5(num):
close = df['close']
ma = close.rolling(window=5).mean()
return ma[num]
# num=-2 : yesterday
# num=-3 : yesterday2
def get_yesterday_ma20(num):
close = df['close']
ma = close.rolling(window=20).mean()
return ma[num]
# 오늘 시가 함수
def get_today_open():
open_to = df['open']
return open_to[-1]
# 1일전 시가 함수
def get_yesterday_open():
open_yes = df['open']
return open_yes[-2]
# 1일전 종가 함수
def get_yesterday_close():
close = df['close']
return close[-2]
# 30일 평균 거래량 함수
def get_aver_volume():
volume_aver_30 = df['volume'].rolling(window=30).mean()
return volume_aver_30[-2]
# 오늘 거래량 함수
def get_to_volume():
volume = df['volume']
return volume[-1]
# 구매 함수(시장가)
def buy_crypto_currency(ticker):
orderbook = pybithumb.get_orderbook(ticker)
buy_price[ticker] = orderbook['asks'][0]['price']
buy_unit = krw_by_coin[ticker] / float(buy_price[ticker])
order_buy = bithumb.buy_market_order(ticker, buy_unit)
print(order_buy)
# print(buy_price[ticker], buy_unit) # 테스트용, 실사용시 위 2줄 사용
# 구매후 지갑상태, 가격 갱신
wallet_bull[ticker] = False
krw_by_coin[
ticker] = krw_by_coin[ticker] - buy_unit * buy_price[ticker]
data[ticker] = "구매", buy_price[ticker], now, -1
return buy_price[ticker]
# 판매 함수(시장가)
def sell_crypto_currency(ticker):
sell_unit = bithumb.get_balance(ticker)[0]
orderbook = pybithumb.get_orderbook(ticker)
sell_price[ticker] = orderbook['bids'][0]['price']
order_sell = bithumb.sell_market_order(ticker, sell_unit)
print(order_sell)
# print(sell_unit, sell_price[ticker]) # 테스트용, 실사용시 위 2줄 사용
# 판매후 지갑상태, 가격 갱신
wallet_bull[ticker] = True
krw_by_coin[
ticker] = krw_by_coin[ticker] + sell_unit * sell_price[ticker]
if krw_by_coin[ticker] <= 1000:
wallet_bull[ticker] = False
ror[ticker] = sell_price[ticker] * 0.995 / buy_price[ticker]
hpr[ticker] = hpr[ticker] * ror[ticker]
data[ticker] = "판매", sell_price[ticker], now, hpr[ticker]
return sell_price[ticker]
# 초기화, 초기 설정(실행시 한번)
now = datetime.datetime.now()
mid = datetime.datetime(now.year, now.month,
now.day) + datetime.timedelta(1)
count = 0
data = {}
current_price = {}
real_buy_current = {}
wallet_bull = {}
beneath = {}
stop_loss = {}
golden_cross = {}
convex_down = {}
dead_cross = {}
convex_up = {}
cross = {}
jang_dae_plus = {}
jang_dae_minus = {}
jang_dae_plus_volume = {}
jang_dae_minus_volume = {}
unit_c = {}
krw_by_coin = {}
buy_price = {}
sell_price = {}
ror = {}
hpr = {}
for ticker in major_ticker:
ror[ticker] = 1
hpr[ticker] = 1
# 원화 코인 분배
total_krw = bithumb.get_balance("BTC")[2]
for ticker in major_ticker:
krw_by_coin[ticker] = total_krw / len(major_ticker)
if krw_by_coin[ticker] > 1000:
wallet_bull[ticker] = True
else:
wallet_bull[ticker] = False
# 딕셔너리 초기화(실행시 한번)
for ticker in major_ticker:
df = pybithumb.get_candlestick(ticker)
current_price[ticker] = pybithumb.get_current_price(ticker)
real_buy_current[ticker] = current_price[ticker]
beneath[ticker] = False
stop_loss[ticker] = False
# 각종 이동평균(실행시 한번)
yes_ma5 = get_yesterday_ma5(-2)
yes2_ma5 = get_yesterday_ma5(-3)
yes3_ma5 = get_yesterday_ma5(-4)
yes_ma20 = get_yesterday_ma20(-2)
yes2_ma20 = get_yesterday_ma20(-3)
# 오늘 시가, 어제 시가, 종가, 거래량, 년 평균 거래량(실행시 한번)
to_open = get_today_open()
yes_open = get_yesterday_open()
yes_close = get_yesterday_close()
volume_aver = get_aver_volume()
to_volume = get_to_volume()
# 골든크로스, 아래로 볼록(실행시 한번)
golden_cross[ticker] = (yes2_ma5 < yes2_ma20) and (yes_ma5 >
yes_ma20)
convex_down[ticker] = (yes3_ma5 > yes2_ma5) and (yes2_ma5 <
yes_ma5)
# 데드크로스, 위로 볼록, 십자가(실행시 한번)
dead_cross[ticker] = (yes2_ma5 > yes2_ma20) and (yes_ma5 <
yes_ma20)
convex_up[ticker] = (yes3_ma5 < yes2_ma5) and (yes2_ma5 > yes_ma5)
cross[ticker] = abs(yes_close - yes_open) < yes_open * cross_cnst
# 장대양봉, 장대음봉(실행시 한번)
jang_dae_plus[ticker] = abs(current_price[ticker] -
to_open) > to_open * jang_plus_cnst
jang_dae_minus[ticker] = (to_open > current_price[ticker]) and (
abs(to_open - current_price[ticker]) >
to_open * jang_minus_cnst)
# 장대양봉 + 거래량, 장대음봉+거래량(실행시 한번)
jang_dae_plus_volume[ticker] = jang_dae_plus[ticker] and (
to_volume > volume_aver * 2)
jang_dae_minus_volume[ticker] = jang_dae_minus[ticker] and (
to_volume > volume_aver * 2)
time.sleep(0.1)
while True:
for ticker in major_ticker:
try:
# 현재가 받아옴(실시간)
current_price[ticker] = pybithumb.get_current_price(ticker)
# 현재시간(실시간)
now = datetime.datetime.now()
# 차트 받아옴(실시간)
df = pybithumb.get_candlestick(ticker)
# 계산(실시간)
to_open = get_today_open()
volume_aver = get_aver_volume()
to_volume = get_to_volume()
# 자정이 넘어가면 정보 최신화, 조건 만족시 구매 or 판매(하루 한번)
if mid < now < mid + datetime.timedelta(seconds=20):
# 차트 받아옴(하루 한번)
df = pybithumb.get_candlestick(ticker)
# 각종 이동평균(하루 한번)
yes_ma5 = get_yesterday_ma5(-2)
yes2_ma5 = get_yesterday_ma5(-3)
yes3_ma5 = get_yesterday_ma5(-4)
yes_ma20 = get_yesterday_ma20(-2)
yes2_ma20 = get_yesterday_ma20(-3)
# 오늘 시가, 어제 시가, 종가, 거래량, 년 평균 거래량(하루 한번)
to_open = get_today_open()
yes_open = get_yesterday_open()
yes_close = get_yesterday_close()
volume_aver = get_aver_volume()
to_volume = get_to_volume()
# 골든크로스, 아래로 볼록(하루 한번)
golden_cross[ticker] = (yes2_ma5 < yes2_ma20) and (
yes_ma5 > yes_ma20)
convex_down[ticker] = (yes3_ma5 > yes2_ma5) and (
yes2_ma5 < yes_ma5)
# 데드크로스, 위로 볼록, 십자가(하루 한번)
dead_cross[ticker] = (yes2_ma5 > yes2_ma20) and (
yes_ma5 < yes_ma20)
convex_up[ticker] = (yes3_ma5 <
yes2_ma5) and (yes2_ma5 > yes_ma5)
cross[ticker] = abs(yes_close -
yes_open) < yes_open * cross_cnst
# 골든크로스, 아래로 볼록 구매(하루 한번)
if wallet_bull[ticker] and (golden_cross[ticker]
or convex_down[ticker]):
real_buy_current[ticker] = buy_crypto_currency(
ticker)
print(ticker, real_buy_current[ticker],
"골든크로스, 아래로 볼록 구매")
print(now)
# 판매 가능한지 수량 판별(하루 한번)
unit = bithumb.get_balance(ticker)
if unit[0] * current_price[ticker] <= 1000:
unit_c[ticker] = False
else:
unit_c[ticker] = True
# 데드크로스, 위로볼록, 십자가 판매(하루 한번)
if unit_c[ticker] and (dead_cross[ticker]
or convex_up[ticker]
or cross[ticker]):
sell_crypto_currency(ticker)
real_sell_current = pybithumb.get_current_price(
ticker)
print(ticker, real_sell_current,
"데드크로스 ,위로볼록 ,십자가 판매")
print(now)
# 자정 업데이트(하루 한번)
mid = datetime.datetime(
now.year, now.month,
now.day) + datetime.timedelta(1)
# 장대양봉, 장대음봉(실시간)
jang_dae_plus[ticker] = abs(current_price[ticker] - to_open
) > to_open * jang_plus_cnst
jang_dae_minus[ticker] = (
to_open > current_price[ticker]) and (
abs(to_open - current_price[ticker]) >
to_open * jang_minus_cnst)
# 장대양봉 + 거래량, 장대음봉+거래량(실시간)
jang_dae_plus_volume[ticker] = jang_dae_plus[ticker] and (
to_volume > volume_aver * 2)
jang_dae_minus_volume[ticker] = jang_dae_minus[
ticker] and (to_volume > volume_aver * 2)
# 장대양봉 구매(실시간)
if wallet_bull[ticker] and jang_dae_plus_volume[ticker]:
real_buy_current[ticker] = buy_crypto_currency(ticker)
print(ticker, real_buy_current[ticker], "장대양봉 구매")
print(now)
# 익절(실시간)
if current_price[
ticker] >= real_buy_current[ticker] * bene_cnst:
beneath[ticker] = True
else:
beneath[ticker] = False
# 손절(실시간)
if current_price[ticker] <= real_buy_current[ticker] * (
1 - stop_loss_cnst):
stop_loss[ticker] = True
else:
stop_loss[ticker] = False
# 판매 가능한지 수량 판별(실시간)
unit = bithumb.get_balance(ticker)
if unit[0] * current_price[ticker] <= 1000:
unit_c[ticker] = False
else:
unit_c[ticker] = True
# 장대음봉, 익절, 손절 판매(실시간)
if unit_c[ticker] and (jang_dae_minus_volume[ticker]
or beneath[ticker]
or stop_loss[ticker]):
real_sell_current = sell_crypto_currency(ticker)
print(ticker, real_sell_current, "장대음봉, 익절, 손절 판매")
print(now)
except Exception as e: # 모든 예외의 에러 메시지를 출력할 때는 Exception 을 사용
print('예외가 발생했습니다.', e)
# 코인별 시간차
time.sleep(0.1)
self.finished.emit(data)
self.msleep(500)
# 모든 코인 실행 뒤 시간차
time.sleep(0.3)
count = count + 1
print(count)