컴퓨터/Python
upbit class
풍경소리^^
2021. 5. 24. 00:39
import time
import pyupbit
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
pd.options.display.float_format = "{:.1f}".format # 지수형태를 소수이하 1자리 설정
t = 0.5
class Df_day:
def __init__(self,code):
self.df_day = pyupbit.get_ohlcv(ticker="KRW-"+code, interval="day")
# KRW- 으로 시작하는 krw_tickers 추출
tickers = pyupbit.get_tickers(fiat="KRW") # 마켓 KRW,BTC,USDT
krw_tickers = []
for i in tickers:
krw_tickers.append(i[i.find("-")+1:])
# for i in krw_tickers:
# globals()['{}'.format(i)] = Df_day(i) # 정답
# print(krw_tickers)
# ['BTC', 'ETH', 'NEO', 'MTL', 'LTC', 'XRP', 'ETC', 'OMG', 'SNT', 'WAVES',
df_day_BTC = Df_day("BTC").df_day
df_day_ETH = Df_day("ETH").df_day
df_day_NEO = Df_day("NEO").df_day
df_day_MTL = Df_day("MTL").df_day
df_day_LTC = Df_day("LTC").df_day
df_day_XRP = Df_day("XRP").df_day
df_day_ETC = Df_day("ETC").df_day
df_day_OMG = Df_day("OMG").df_day
df_day_SNT = Df_day("SNT").df_day
df_day_WAVES = Df_day("WAVES").df_day
time.sleep(t)
# 'XEM', 'QTUM', 'LSK', 'STEEM', 'XLM', 'ARDR', 'KMD', 'ARK', 'STORJ', 'GRS',
df_day_XEM = Df_day("XEM").df_day
df_day_QTUM = Df_day("QTUM").df_day
df_day_LSK = Df_day("LSK").df_day
df_day_STEEM = Df_day("STEEM").df_day
df_day_XLM = Df_day("XLM").df_day
df_day_ARDR = Df_day("ARDR").df_day
df_day_KMD = Df_day("KMD").df_day
df_day_ARK = Df_day("ARK").df_day
df_day_STORJ = Df_day("STORJ").df_day
df_day_GRS = Df_day("GRS").df_day
time.sleep(t)
# 'REP', 'EMC2', 'ADA', 'SBD', 'POWR', 'BTG', 'ICX', 'EOS', 'TRX', 'SC',
df_day_REP = Df_day("REP").df_day
df_day_EMC2 = Df_day("EMC2").df_day
df_day_ADA = Df_day("ADA").df_day
df_day_SBD = Df_day("SBD").df_day
df_day_POWR = Df_day("POWR").df_day
df_day_BTG = Df_day("BTG").df_day
df_day_ICX = Df_day("ICX").df_day
df_day_EOS = Df_day("EOS").df_day
df_day_TRX = Df_day("TRX").df_day
df_day_SC = Df_day("SC").df_day
time.sleep(t)
# 'IGNIS', 'ONT', 'ZIL', 'POLY', 'ZRX', 'LOOM', 'BCH', 'ADX', 'BAT', 'IOST',
df_day_IGNIS = Df_day("IGNIS").df_day
df_day_ONT = Df_day("ONT").df_day
df_day_ZIL = Df_day("ZIL").df_day
df_day_POLY = Df_day("POLY").df_day
df_day_ZRX = Df_day("ZRX").df_day
df_day_LOOM = Df_day("LOOM").df_day
df_day_BCH = Df_day("BCH").df_day
df_day_ADX = Df_day("ADX").df_day
df_day_BAT = Df_day("BAT").df_day
df_day_IOST = Df_day("IOST").df_day
time.sleep(t)
# 'DMT', 'RFR', 'CVC', 'IQ', 'IOTA', 'MFT', 'ONG', 'GAS', 'UPP', 'ELF',
df_day_DMT = Df_day("DMT").df_day
df_day_RFR = Df_day("RFR").df_day
df_day_CVC = Df_day("CVC").df_day
df_day_IQ = Df_day("IQ").df_day
df_day_IOTA = Df_day("IOTA").df_day
df_day_MFT = Df_day("MFT").df_day
df_day_ONG = Df_day("ONG").df_day
df_day_GAS = Df_day("GAS").df_day
df_day_UPP = Df_day("UPP").df_day
df_day_ELF = Df_day("ELF").df_day
time.sleep(t)
# 'KNC', 'BSV', 'THETA', 'EDR', 'QKC', 'BTT', 'MOC', 'ENJ', 'TFUEL', 'MANA',
df_day_KNC = Df_day("KNC").df_day
df_day_BSV = Df_day("BSV").df_day
df_day_THETA = Df_day("THETA").df_day
df_day_EDR = Df_day("EDR").df_day
df_day_QKC = Df_day("QKC").df_day
df_day_BTT = Df_day("BTT").df_day
df_day_MOC = Df_day("MOC").df_day
df_day_ENJ = Df_day("ENJ").df_day
df_day_TFUEL = Df_day("TFUEL").df_day
df_day_MANA = Df_day("MANA").df_day
time.sleep(t)
# 'ANKR', 'AERGO', 'ATOM', 'TT', 'CRE', 'SOLVE', 'MBL', 'TSHP', 'WAXP', 'HBAR',
df_day_ANKR = Df_day("ANKR").df_day
df_day_AERGO = Df_day("AERGO").df_day
df_day_ATOM = Df_day("ATOM").df_day
df_day_TT = Df_day("TT").df_day
df_day_CRE = Df_day("CRE").df_day
df_day_SOLVE = Df_day("SOLVE").df_day
df_day_MBL = Df_day("MBL").df_day
df_day_TSHP = Df_day("TSHP").df_day
df_day_WAXP = Df_day("WAXP").df_day
df_day_HBAR = Df_day("HBAR").df_day
time.sleep(t)
# 'MED', 'MLK', 'STPT', 'ORBS', 'VET', 'CHZ', 'PXL', 'STMX', 'DKA', 'HIVE',
df_day_MED = Df_day("MED").df_day
df_day_MLK = Df_day("MLK").df_day
df_day_STPT = Df_day("STPT").df_day
df_day_ORBS = Df_day("ORBS").df_day
df_day_VET = Df_day("VET").df_day
df_day_CHZ = Df_day("CHZ").df_day
df_day_PXL = Df_day("PXL").df_day
df_day_STMX = Df_day("STMX").df_day
df_day_DKA = Df_day("DKA").df_day
df_day_HIVE = Df_day("HIVE").df_day
time.sleep(t)
# 'KAVA', 'AHT', 'LINK', 'XTZ', 'BORA', 'JST', 'CRO', 'TON', 'SXP', 'LAMB',
df_day_KAVA = Df_day("KAVA").df_day
df_day_AHT = Df_day("AHT").df_day
df_day_LINK = Df_day("LINK").df_day
df_day_XTZ = Df_day("XTZ").df_day
df_day_BORA = Df_day("BORA").df_day
df_day_JST = Df_day("JST").df_day
df_day_CRO = Df_day("CRO").df_day
df_day_TON = Df_day("TON").df_day
df_day_SXP = Df_day("SXP").df_day
df_day_LAMB = Df_day("LAMB").df_day
time.sleep(t)
# 'HUNT', 'MARO', 'PLA', 'DOT', 'SRM', 'MVL', 'PCI', 'STRAX', 'AQT', 'BCHA',
df_day_HUNT = Df_day("HUNT").df_day
df_day_MARO = Df_day("MARO").df_day
df_day_PLA = Df_day("PLA").df_day
df_day_DOT = Df_day("DOT").df_day
df_day_SRM = Df_day("SRM").df_day
df_day_MVL = Df_day("MVL").df_day
df_day_PCI = Df_day("PCI").df_day
df_day_STRAX = Df_day("STRAX").df_day
df_day_AQT = Df_day("AQT").df_day
df_day_BCHA = Df_day("BCHA").df_day
time.sleep(t)
# 'GLM', 'QTCON', 'SSX', 'META', 'OBSR', 'FCT2', 'LBC', 'CBK', 'SAND', 'HUM',
df_day_GLM = Df_day("GLM").df_day
df_day_QTCON = Df_day("QTCON").df_day
df_day_SSX = Df_day("SSX").df_day
df_day_META = Df_day("META").df_day
df_day_OBSR = Df_day("OBSR").df_day
df_day_FCT2 = Df_day("FCT2").df_day
df_day_LBC = Df_day("LBC").df_day
df_day_CBK = Df_day("CBK").df_day
df_day_SAND = Df_day("SAND").df_day
df_day_HUM = Df_day("HUM").df_day
time.sleep(t)
# 'DOGE', 'STRK', 'PUNDIX', 'FLOW', 'DAWN', 'AXS', 'STX']
df_day_DOGE = Df_day("DOGE").df_day
df_day_STRK = Df_day("STRK").df_day
df_day_PUNDIX = Df_day("PUNDIX").df_day
df_day_FLOW = Df_day("FLOW").df_day
df_day_DAWN = Df_day("DAWN").df_day
df_day_AXS = Df_day("AXS").df_day
df_day_STX = Df_day("STX").df_day
time.sleep(t)
# print(df_day_STX)
# dataframe 의 마지막행에서 시가
# print(df_day.iloc[-1])
# ['BTC', 'ETH', 'NEO', 'MTL', 'LTC', 'XRP', 'ETC', 'OMG', 'SNT', 'WAVES', 1
day_open_BTC = df_day_BTC.iloc[-1]["open"]
day_open_ETH = df_day_ETH.iloc[-1]["open"]
day_open_NEO = df_day_NEO.iloc[-1]["open"]
day_open_MTL = df_day_MTL.iloc[-1]["open"]
day_open_LTC = df_day_LTC.iloc[-1]["open"]
day_open_XRP = df_day_XRP.iloc[-1]["open"]
day_open_ETC = df_day_ETC.iloc[-1]["open"]
day_open_OMG = df_day_OMG.iloc[-1]["open"]
day_open_SNT = df_day_SNT.iloc[-1]["open"]
day_open_BTC = df_day_BTC.iloc[-1]["open"]
day_open_WAVES = df_day_WAVES.iloc[-1]["open"]
time.sleep(t)
# 'XEM', 'QTUM', 'LSK', 'STEEM', 'XLM', 'ARDR', 'KMD', 'ARK', 'STORJ', 'GRS', 2
day_open_XEM = df_day_XEM.iloc[-1]["open"]
day_open_QTUM = df_day_QTUM.iloc[-1]["open"]
day_open_LSK = df_day_LSK.iloc[-1]["open"]
day_open_STEEM = df_day_STEEM.iloc[-1]["open"]
day_open_XLM = df_day_XLM.iloc[-1]["open"]
day_open_ARDR = df_day_ARDR.iloc[-1]["open"]
day_open_KMD = df_day_KMD.iloc[-1]["open"]
day_open_ARK = df_day_ARK.iloc[-1]["open"]
day_open_STORJ = df_day_STORJ.iloc[-1]["open"]
day_open_GRS = df_day_GRS.iloc[-1]["open"]
time.sleep(t)
# 'REP', 'EMC2', 'ADA', 'SBD', 'POWR', 'BTG', 'ICX', 'EOS', 'TRX', 'SC', 3
day_open_REP = df_day_REP.iloc[-1]["open"]
day_open_EMC2 = df_day_EMC2.iloc[-1]["open"]
day_open_ADA = df_day_ADA.iloc[-1]["open"]
day_open_SBD = df_day_SBD.iloc[-1]["open"]
day_open_POWR = df_day_POWR.iloc[-1]["open"]
day_open_BTG = df_day_BTG.iloc[-1]["open"]
day_open_ICX = df_day_ICX.iloc[-1]["open"]
day_open_EOS = df_day_EOS.iloc[-1]["open"]
day_open_TRX = df_day_TRX.iloc[-1]["open"]
day_open_SC = df_day_SC.iloc[-1]["open"]
time.sleep(t)
# 'IGNIS', 'ONT', 'ZIL', 'POLY', 'ZRX', 'LOOM', 'BCH', 'ADX', 'BAT', 'IOST', 4
day_open_IGNIS = df_day_IGNIS.iloc[-1]["open"]
day_open_ONT = df_day_ONT.iloc[-1]["open"]
day_open_ZIL = df_day_ZIL.iloc[-1]["open"]
day_open_POLY = df_day_POLY.iloc[-1]["open"]
day_open_ZRX = df_day_ZRX.iloc[-1]["open"]
day_open_LOOM = df_day_LOOM.iloc[-1]["open"]
day_open_BCH = df_day_BCH.iloc[-1]["open"]
day_open_ADX = df_day_ADX.iloc[-1]["open"]
day_open_BAT = df_day_BAT.iloc[-1]["open"]
day_open_IOST = df_day_IOST.iloc[-1]["open"]
time.sleep(t)
# 'DMT', 'RFR', 'CVC', 'IQ', 'IOTA', 'MFT', 'ONG', 'GAS', 'UPP', 'ELF', 5
day_open_DMT = df_day_DMT.iloc[-1]["open"]
day_open_RFR = df_day_RFR.iloc[-1]["open"]
day_open_CVC = df_day_CVC.iloc[-1]["open"]
day_open_IQ = df_day_IQ.iloc[-1]["open"]
day_open_IOTA = df_day_IOTA.iloc[-1]["open"]
day_open_MFT = df_day_MFT.iloc[-1]["open"]
day_open_ONG = df_day_ONG.iloc[-1]["open"]
day_open_GAS = df_day_GAS.iloc[-1]["open"]
day_open_UPP = df_day_UPP.iloc[-1]["open"]
day_open_ELF = df_day_ELF.iloc[-1]["open"]
time.sleep(t)
# 'KNC', 'BSV', 'THETA', 'EDR', 'QKC', 'BTT', 'MOC', 'ENJ', 'TFUEL', 'MANA', 6
day_open_KNC = df_day_KNC.iloc[-1]["open"]
day_open_BSV = df_day_BSV.iloc[-1]["open"]
day_open_THETA = df_day_THETA.iloc[-1]["open"]
day_open_EDR = df_day_EDR.iloc[-1]["open"]
day_open_QKC = df_day_QKC .iloc[-1]["open"]
day_open_BTT = df_day_BTT.iloc[-1]["open"]
day_open_MOC = df_day_MOC.iloc[-1]["open"]
day_open_ENJ = df_day_ENJ.iloc[-1]["open"]
day_open_TFUEL = df_day_TFUEL.iloc[-1]["open"]
day_open_MANA = df_day_MANA.iloc[-1]["open"]
time.sleep(t)
# 'ANKR', 'AERGO', 'ATOM', 'TT', 'CRE', 'SOLVE', 'MBL', 'TSHP', 'WAXP', 'HBAR', 7
day_open_ANKR = df_day_ANKR.iloc[-1]["open"]
day_open_AERGO = df_day_AERGO.iloc[-1]["open"]
day_open_ATOM = df_day_ATOM.iloc[-1]["open"]
day_open_TT = df_day_TT.iloc[-1]["open"]
day_open_CRE = df_day_CRE.iloc[-1]["open"]
day_open_SOLVE = df_day_SOLVE.iloc[-1]["open"]
day_open_MBL = df_day_MBL.iloc[-1]["open"]
day_open_TSHP = df_day_TSHP.iloc[-1]["open"]
day_open_WAXP = df_day_WAXP.iloc[-1]["open"]
day_open_HBAR = df_day_HBAR.iloc[-1]["open"]
time.sleep(t)
# 'MED', 'MLK', 'STPT', 'ORBS', 'VET', 'CHZ', 'PXL', 'STMX', 'DKA', 'HIVE', 8
day_open_MED = df_day_MED.iloc[-1]["open"]
day_open_MLK = df_day_MLK.iloc[-1]["open"]
day_open_STPT = df_day_STPT.iloc[-1]["open"]
day_open_ORBS = df_day_ORBS.iloc[-1]["open"]
day_open_VET = df_day_VET.iloc[-1]["open"]
day_open_CHZ = df_day_CHZ.iloc[-1]["open"]
day_open_PXL = df_day_PXL.iloc[-1]["open"]
day_open_STMX = df_day_STMX.iloc[-1]["open"]
day_open_DKA = df_day_DKA.iloc[-1]["open"]
day_open_HIVE = df_day_HIVE.iloc[-1]["open"]
time.sleep(t)
# 'KAVA', 'AHT', 'LINK', 'XTZ', 'BORA', 'JST', 'CRO', 'TON', 'SXP', 'LAMB', 9
day_open_KAVA = df_day_KAVA.iloc[-1]["open"]
day_open_AHT = df_day_AHT.iloc[-1]["open"]
day_open_LINK = df_day_LINK.iloc[-1]["open"]
day_open_XTZ = df_day_XTZ.iloc[-1]["open"]
day_open_BORA = df_day_BORA.iloc[-1]["open"]
day_open_JST = df_day_JST.iloc[-1]["open"]
day_open_CRO = df_day_CRO.iloc[-1]["open"]
day_open_TON = df_day_TON.iloc[-1]["open"]
day_open_SXP = df_day_SXP.iloc[-1]["open"]
day_open_LAMB = df_day_LAMB.iloc[-1]["open"]
time.sleep(t)
# 'HUNT', 'MARO', 'PLA', 'DOT', 'SRM', 'MVL', 'PCI', 'STRAX', 'AQT', 'BCHA', 10
day_open_HUNT = df_day_HUNT.iloc[-1]["open"]
day_open_MARO = df_day_MARO.iloc[-1]["open"]
day_open_PLA = df_day_PLA.iloc[-1]["open"]
day_open_DOT = df_day_DOT.iloc[-1]["open"]
day_open_SRM = df_day_SRM.iloc[-1]["open"]
day_open_MVL = df_day_MVL.iloc[-1]["open"]
day_open_PCI = df_day_PCI.iloc[-1]["open"]
day_open_STRAX = df_day_STRAX.iloc[-1]["open"]
day_open_AQT = df_day_AQT.iloc[-1]["open"]
day_open_BCHA = df_day_BCHA.iloc[-1]["open"]
time.sleep(t)
# 'GLM', 'QTCON', 'SSX', 'META', 'OBSR', 'FCT2', 'LBC', 'CBK', 'SAND', 'HUM', 11
day_open_GLM = df_day_GLM.iloc[-1]["open"]
day_open_QTCON = df_day_QTCON.iloc[-1]["open"]
day_open_SSX = df_day_SSX.iloc[-1]["open"]
day_open_META = df_day_META.iloc[-1]["open"]
day_open_OBSR = df_day_OBSR.iloc[-1]["open"]
day_open_FCT2 = df_day_FCT2.iloc[-1]["open"]
day_open_LBC = df_day_LBC.iloc[-1]["open"]
day_open_CBK = df_day_CBK.iloc[-1]["open"]
day_open_SAND = df_day_SAND.iloc[-1]["open"]
day_open_HUM = df_day_HUM.iloc[-1]["open"]
time.sleep(t)
# 'DOGE', 'STRK', 'PUNDIX', 'FLOW', 'DAWN', 'AXS', 'STX'] 12
day_open_DOGE = df_day_DOGE.iloc[-1]["open"]
day_open_STRK = df_day_STRK.iloc[-1]["open"]
day_open_PUNDIX = df_day_PUNDIX.iloc[-1]["open"]
day_open_FLOW = df_day_FLOW.iloc[-1]["open"]
day_open_DAWN = df_day_DAWN.iloc[-1]["open"]
day_open_AXS = df_day_AXS.iloc[-1]["open"]
day_open_STX = df_day_STX.iloc[-1]["open"]
time.sleep(t)
# print(day_open_BTC)
# df_minute1 = pyupbit.get_ohlcv(ticker="krw-btc", interval="minute1")
# 파이썬 실시간 그래프 그리기
fig = plt.figure()
ax = plt.axes()
x = 0
while True:
plt.clf()
# x = x + 0.1
x = x + 1
# (현재가-시가)/시가*100
# ['BTC', 'ETH', 'NEO', 'MTL', 'LTC', 'XRP', 'ETC', 'OMG', 'SNT', 'WAVES', 1
df = pyupbit.get_ohlcv("KRW-BTC", "minute1", 60)
df_list = np.array(df["close"].tolist())
BTC = [(df_list[i] - day_open_BTC) / day_open_BTC * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-ETH", "minute1", 60)
df_list = np.array(df["close"].tolist())
ETH = [(df_list[i] - day_open_ETH) / day_open_ETH * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-NEO", "minute1", 60)
df_list = np.array(df["close"].tolist())
NEO = [(df_list[i] - day_open_NEO) / day_open_NEO * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-MTL", "minute1", 60)
df_list = np.array(df["close"].tolist())
MTL = [(df_list[i] - day_open_MTL) / day_open_MTL * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-LTC", "minute1", 60)
df_list = np.array(df["close"].tolist())
LTC = [(df_list[i] - day_open_LTC) / day_open_LTC * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-XRP", "minute1", 60)
df_list = np.array(df["close"].tolist())
XRP = [(df_list[i] - day_open_XRP) / day_open_XRP * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-ETC", "minute1", 60)
df_list = np.array(df["close"].tolist())
ETC = [(df_list[i] - day_open_ETC) / day_open_ETC * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-OMG", "minute1", 60)
df_list = np.array(df["close"].tolist())
OMG = [(df_list[i] - day_open_OMG) / day_open_OMG * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-SNT", "minute1", 60)
df_list = np.array(df["close"].tolist())
SNT = [(df_list[i] - day_open_SNT) / day_open_SNT * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-WAVES", "minute1", 60)
df_list = np.array(df["close"].tolist())
WAVES = [(df_list[i] - day_open_WAVES) / day_open_WAVES * 100 for i in range(len(df_list))]
time.sleep(1)
# 'XEM', 'QTUM', 'LSK', 'STEEM', 'XLM', 'ARDR', 'KMD', 'ARK', 'STORJ', 'GRS', 2
df = pyupbit.get_ohlcv("KRW-XEM", "minute1", 60)
df_list = np.array(df["close"].tolist())
XEM = [(df_list[i] - day_open_XEM) / day_open_XEM * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-QTUM", "minute1", 60)
df_list = np.array(df["close"].tolist())
QTUM = [(df_list[i] - day_open_QTUM) / day_open_QTUM * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-LSK", "minute1", 60)
df_list = np.array(df["close"].tolist())
LSK = [(df_list[i] - day_open_LSK) / day_open_LSK * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-STEEM", "minute1", 60)
df_list = np.array(df["close"].tolist())
STEEM = [(df_list[i] - day_open_STEEM) / day_open_STEEM * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-XLM", "minute1", 60)
df_list = np.array(df["close"].tolist())
XLM = [(df_list[i] - day_open_XLM) / day_open_XLM * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-ARDR", "minute1", 60)
df_list = np.array(df["close"].tolist())
ARDR = [(df_list[i] - day_open_ARDR) / day_open_ARDR * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-KMD", "minute1", 60)
df_list = np.array(df["close"].tolist())
KMD = [(df_list[i] - day_open_KMD) / day_open_KMD * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-ARK", "minute1", 60)
df_list = np.array(df["close"].tolist())
ARK = [(df_list[i] - day_open_ARK) / day_open_ARK * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-STORJ", "minute1", 60)
df_list = np.array(df["close"].tolist())
STORJ = [(df_list[i] - day_open_STORJ) / day_open_STORJ * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-GRS", "minute1", 60)
df_list = np.array(df["close"].tolist())
GRS = [(df_list[i] - day_open_GRS) / day_open_GRS * 100 for i in range(len(df_list))]
time.sleep(t)
# 'REP', 'EMC2', 'ADA', 'SBD', 'POWR', 'BTG', 'ICX', 'EOS', 'TRX', 'SC', 3
df = pyupbit.get_ohlcv("KRW-REP", "minute1", 60)
df_list = np.array(df["close"].tolist())
REP = [(df_list[i] - day_open_REP) / day_open_REP * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-EMC2", "minute1", 60)
df_list = np.array(df["close"].tolist())
EMC2 = [(df_list[i] - day_open_EMC2) / day_open_EMC2 * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-ADA", "minute1", 60)
df_list = np.array(df["close"].tolist())
ADA = [(df_list[i] - day_open_ADA) / day_open_ADA * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-SBD", "minute1", 60)
df_list = np.array(df["close"].tolist())
SBD = [(df_list[i] - day_open_SBD) / day_open_SBD * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-POWR", "minute1", 60)
df_list = np.array(df["close"].tolist())
POWR = [(df_list[i] - day_open_POWR) / day_open_POWR * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-BTG", "minute1", 60)
df_list = np.array(df["close"].tolist())
BTG = [(df_list[i] - day_open_BTG) / day_open_BTG * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-ICX", "minute1", 60)
df_list = np.array(df["close"].tolist())
ICX = [(df_list[i] - day_open_ICX) / day_open_ICX * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-EOS", "minute1", 60)
df_list = np.array(df["close"].tolist())
EOS = [(df_list[i] - day_open_EOS) / day_open_EOS * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-TRX", "minute1", 60)
df_list = np.array(df["close"].tolist())
TRX = [(df_list[i] - day_open_TRX) / day_open_TRX * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-SC", "minute1", 60)
df_list = np.array(df["close"].tolist())
SC = [(df_list[i] - day_open_SC) / day_open_SC * 100 for i in range(len(df_list))]
time.sleep(t)
# 'IGNIS', 'ONT', 'ZIL', 'POLY', 'ZRX', 'LOOM', 'BCH', 'ADX', 'BAT', 'IOST', 4
df = pyupbit.get_ohlcv("KRW-IGNIS", "minute1", 60)
df_list = np.array(df["close"].tolist())
IGNIS = [(df_list[i] - day_open_IGNIS) / day_open_IGNIS * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-ONT", "minute1", 60)
df_list = np.array(df["close"].tolist())
ONT = [(df_list[i] - day_open_ONT) / day_open_ONT * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-ZIL", "minute1", 60)
df_list = np.array(df["close"].tolist())
ZIL = [(df_list[i] - day_open_ZIL) / day_open_ZIL * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-POLY", "minute1", 60)
df_list = np.array(df["close"].tolist())
POLY = [(df_list[i] - day_open_POLY) / day_open_POLY * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-ZRX", "minute1", 60)
df_list = np.array(df["close"].tolist())
ZRX = [(df_list[i] - day_open_ZRX) / day_open_ZRX * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-LOOM", "minute1", 60)
df_list = np.array(df["close"].tolist())
LOOM = [(df_list[i] - day_open_LOOM) / day_open_LOOM * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-BCH", "minute1", 60)
df_list = np.array(df["close"].tolist())
BCH = [(df_list[i] - day_open_BCH) / day_open_BCH * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-ADX", "minute1", 60)
df_list = np.array(df["close"].tolist())
ADX = [(df_list[i] - day_open_ADX) / day_open_ADX * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-BAT", "minute1", 60)
df_list = np.array(df["close"].tolist())
BAT = [(df_list[i] - day_open_BAT) / day_open_BAT * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-IOST", "minute1", 60)
df_list = np.array(df["close"].tolist())
IOST = [(df_list[i] - day_open_IOST) / day_open_IOST * 100 for i in range(len(df_list))]
time.sleep(t)
# 'DMT', 'RFR', 'CVC', 'IQ', 'IOTA', 'MFT', 'ONG', 'GAS', 'UPP', 'ELF', 5
df = pyupbit.get_ohlcv("KRW-DMT", "minute1", 60)
df_list = np.array(df["close"].tolist())
DMT = [(df_list[i] - day_open_DMT) / day_open_DMT * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-RFR", "minute1", 60)
df_list = np.array(df["close"].tolist())
RFR = [(df_list[i] - day_open_RFR) / day_open_RFR * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-CVC", "minute1", 60)
df_list = np.array(df["close"].tolist())
CVC = [(df_list[i] - day_open_CVC) / day_open_CVC * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-IQ", "minute1", 60)
df_list = np.array(df["close"].tolist())
IQ = [(df_list[i] - day_open_IQ) / day_open_IQ * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-IOTA", "minute1", 60)
df_list = np.array(df["close"].tolist())
IOTA = [(df_list[i] - day_open_IOTA) / day_open_IOTA * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-MFT", "minute1", 60)
df_list = np.array(df["close"].tolist())
MFT = [(df_list[i] - day_open_MFT) / day_open_MFT * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-ONG", "minute1", 60)
df_list = np.array(df["close"].tolist())
ONG = [(df_list[i] - day_open_ONG) / day_open_ONG * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-GAS", "minute1", 60)
df_list = np.array(df["close"].tolist())
GAS = [(df_list[i] - day_open_GAS) / day_open_GAS * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-UPP", "minute1", 60)
df_list = np.array(df["close"].tolist())
UPP = [(df_list[i] - day_open_UPP) / day_open_UPP * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-ELF", "minute1", 60)
df_list = np.array(df["close"].tolist())
ELF = [(df_list[i] - day_open_ELF) / day_open_ELF * 100 for i in range(len(df_list))]
time.sleep(t)
# 'KNC', 'BSV', 'THETA', 'EDR', 'QKC', 'BTT', 'MOC', 'ENJ', 'TFUEL', 'MANA', 6
df = pyupbit.get_ohlcv("KRW-KNC", "minute1", 60)
df_list = np.array(df["close"].tolist())
KNC = [(df_list[i] - day_open_KNC) / day_open_KNC * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-BSV", "minute1", 60)
df_list = np.array(df["close"].tolist())
BSV = [(df_list[i] - day_open_BSV) / day_open_BSV * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-THETA", "minute1", 60)
df_list = np.array(df["close"].tolist())
THETA = [(df_list[i] - day_open_THETA) / day_open_THETA * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-EDR", "minute1", 60)
df_list = np.array(df["close"].tolist())
EDR = [(df_list[i] - day_open_EDR) / day_open_EDR * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-QKC", "minute1", 60)
df_list = np.array(df["close"].tolist())
QKC = [(df_list[i] - day_open_QKC) / day_open_QKC * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-BTT", "minute1", 60)
df_list = np.array(df["close"].tolist())
BTT = [(df_list[i] - day_open_BTT) / day_open_BTT * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-MOC", "minute1", 60)
df_list = np.array(df["close"].tolist())
MOC = [(df_list[i] - day_open_MOC) / day_open_MOC * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-ENJ", "minute1", 60)
df_list = np.array(df["close"].tolist())
ENJ = [(df_list[i] - day_open_ENJ) / day_open_ENJ * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-TFUEL", "minute1", 60)
df_list = np.array(df["close"].tolist())
TFUEL = [(df_list[i] - day_open_TFUEL) / day_open_TFUEL * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-MANA", "minute1", 60)
df_list = np.array(df["close"].tolist())
MANA = [(df_list[i] - day_open_MANA) / day_open_MANA * 100 for i in range(len(df_list))]
time.sleep(t)
# 'ANKR', 'AERGO', 'ATOM', 'TT', 'CRE', 'SOLVE', 'MBL', 'TSHP', 'WAXP', 'HBAR', 7
df = pyupbit.get_ohlcv("KRW-ANKR", "minute1", 60)
df_list = np.array(df["close"].tolist())
ANKR = [(df_list[i] - day_open_ANKR) / day_open_ANKR * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-AERGO", "minute1", 60)
df_list = np.array(df["close"].tolist())
AERGO = [(df_list[i] - day_open_AERGO) / day_open_AERGO * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-ATOM", "minute1", 60)
df_list = np.array(df["close"].tolist())
ATOM = [(df_list[i] - day_open_ATOM) / day_open_ATOM * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-TT", "minute1", 60)
df_list = np.array(df["close"].tolist())
TT = [(df_list[i] - day_open_TT) / day_open_TT * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-CRE", "minute1", 60)
df_list = np.array(df["close"].tolist())
CRE = [(df_list[i] - day_open_CRE) / day_open_CRE * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-SOLVE", "minute1", 60)
df_list = np.array(df["close"].tolist())
SOLVE = [(df_list[i] - day_open_SOLVE) / day_open_SOLVE * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-MBL", "minute1", 60)
df_list = np.array(df["close"].tolist())
MBL = [(df_list[i] - day_open_MBL) / day_open_MBL * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-TSHP", "minute1", 60)
df_list = np.array(df["close"].tolist())
TSHP = [(df_list[i] - day_open_TSHP) / day_open_TSHP * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-WAXP", "minute1", 60)
df_list = np.array(df["close"].tolist())
WAXP = [(df_list[i] - day_open_WAXP) / day_open_WAXP * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-HBAR", "minute1", 60)
df_list = np.array(df["close"].tolist())
HBAR = [(df_list[i] - day_open_HBAR) / day_open_HBAR * 100 for i in range(len(df_list))]
time.sleep(t)
# 'MED', 'MLK', 'STPT', 'ORBS', 'VET', 'CHZ', 'PXL', 'STMX', 'DKA', 'HIVE', 8
df = pyupbit.get_ohlcv("KRW-MED", "minute1", 60)
df_list = np.array(df["close"].tolist())
MED = [(df_list[i] - day_open_MED) / day_open_MED * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-MLK", "minute1", 60)
df_list = np.array(df["close"].tolist())
MLK = [(df_list[i] - day_open_MLK) / day_open_MLK * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-STPT", "minute1", 60)
df_list = np.array(df["close"].tolist())
STPT = [(df_list[i] - day_open_STPT) / day_open_STPT * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-ORBS", "minute1", 60)
df_list = np.array(df["close"].tolist())
ORBS = [(df_list[i] - day_open_ORBS) / day_open_ORBS * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-VET", "minute1", 60)
df_list = np.array(df["close"].tolist())
VET = [(df_list[i] - day_open_VET) / day_open_VET * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-CHZ", "minute1", 60)
df_list = np.array(df["close"].tolist())
CHZ = [(df_list[i] - day_open_CHZ) / day_open_CHZ * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-PXL", "minute1", 60)
df_list = np.array(df["close"].tolist())
PXL = [(df_list[i] - day_open_PXL) / day_open_PXL * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-STMX", "minute1", 60)
df_list = np.array(df["close"].tolist())
STMX = [(df_list[i] - day_open_STMX) / day_open_STMX * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-DKA", "minute1", 60)
df_list = np.array(df["close"].tolist())
DKA = [(df_list[i] - day_open_DKA) / day_open_DKA * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-HIVE", "minute1", 60)
df_list = np.array(df["close"].tolist())
HIVE = [(df_list[i] - day_open_HIVE) / day_open_HIVE * 100 for i in range(len(df_list))]
time.sleep(t)
# 'KAVA', 'AHT', 'LINK', 'XTZ', 'BORA', 'JST', 'CRO', 'TON', 'SXP', 'LAMB', 9
df = pyupbit.get_ohlcv("KRW-KAVA", "minute1", 60)
df_list = np.array(df["close"].tolist())
KAVA = [(df_list[i] - day_open_KAVA) / day_open_KAVA * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-AHT", "minute1", 60)
df_list = np.array(df["close"].tolist())
AHT = [(df_list[i] - day_open_AHT) / day_open_AHT * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-LINK", "minute1", 60)
df_list = np.array(df["close"].tolist())
LINK = [(df_list[i] - day_open_LINK) / day_open_LINK * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-XTZ", "minute1", 60)
df_list = np.array(df["close"].tolist())
XTZ = [(df_list[i] - day_open_XTZ) / day_open_XTZ * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-BORA", "minute1", 60)
df_list = np.array(df["close"].tolist())
BORA = [(df_list[i] - day_open_BORA) / day_open_BORA * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-JST", "minute1", 60)
df_list = np.array(df["close"].tolist())
JST = [(df_list[i] - day_open_JST) / day_open_JST * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-CRO", "minute1", 60)
df_list = np.array(df["close"].tolist())
CRO = [(df_list[i] - day_open_CRO) / day_open_CRO * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-TON", "minute1", 60)
df_list = np.array(df["close"].tolist())
TON = [(df_list[i] - day_open_TON) / day_open_TON * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-SXP", "minute1", 60)
df_list = np.array(df["close"].tolist())
SXP = [(df_list[i] - day_open_SXP) / day_open_SXP * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-LAMB", "minute1", 60)
df_list = np.array(df["close"].tolist())
LAMB = [(df_list[i] - day_open_LAMB) / day_open_LAMB * 100 for i in range(len(df_list))]
time.sleep(t)
# 'HUNT', 'MARO', 'PLA', 'DOT', 'SRM', 'MVL', 'PCI', 'STRAX', 'AQT', 'BCHA', 10
df = pyupbit.get_ohlcv("KRW-HUNT", "minute1", 60)
df_list = np.array(df["close"].tolist())
HUNT = [(df_list[i] - day_open_HUNT) / day_open_HUNT * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-MARO", "minute1", 60)
df_list = np.array(df["close"].tolist())
MARO = [(df_list[i] - day_open_MARO) / day_open_MARO * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-PLA", "minute1", 60)
df_list = np.array(df["close"].tolist())
PLA = [(df_list[i] - day_open_PLA) / day_open_PLA * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-DOT", "minute1", 60)
df_list = np.array(df["close"].tolist())
DOT = [(df_list[i] - day_open_DOT) / day_open_DOT * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-SRM", "minute1", 60)
df_list = np.array(df["close"].tolist())
SRM = [(df_list[i] - day_open_SRM) / day_open_SRM * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-MVL", "minute1", 60)
df_list = np.array(df["close"].tolist())
MVL = [(df_list[i] - day_open_MVL) / day_open_MVL * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-PCI", "minute1", 60)
df_list = np.array(df["close"].tolist())
PCI = [(df_list[i] - day_open_PCI) / day_open_PCI * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-STRAX", "minute1", 60)
df_list = np.array(df["close"].tolist())
STRAX = [(df_list[i] - day_open_STRAX) / day_open_STRAX * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-AQT", "minute1", 60)
df_list = np.array(df["close"].tolist())
AQT = [(df_list[i] - day_open_AQT) / day_open_AQT * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-BCHA", "minute1", 60)
df_list = np.array(df["close"].tolist())
BCHA = [(df_list[i] - day_open_BCHA) / day_open_BCHA * 100 for i in range(len(df_list))]
time.sleep(t)
# 'GLM', 'QTCON', 'SSX', 'META', 'OBSR', 'FCT2', 'LBC', 'CBK', 'SAND', 'HUM', 11
df = pyupbit.get_ohlcv("KRW-GLM", "minute1", 60)
df_list = np.array(df["close"].tolist())
GLM = [(df_list[i] - day_open_GLM) / day_open_GLM * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-QTCON", "minute1", 60)
df_list = np.array(df["close"].tolist())
QTCON = [(df_list[i] - day_open_QTCON) / day_open_QTCON * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-SSX", "minute1", 60)
df_list = np.array(df["close"].tolist())
SSX = [(df_list[i] - day_open_SSX) / day_open_SSX * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-META", "minute1", 60)
df_list = np.array(df["close"].tolist())
META = [(df_list[i] - day_open_META) / day_open_META * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-OBSR", "minute1", 60)
df_list = np.array(df["close"].tolist())
OBSR = [(df_list[i] - day_open_OBSR) / day_open_OBSR * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-FCT2", "minute1", 60)
df_list = np.array(df["close"].tolist())
FCT2 = [(df_list[i] - day_open_FCT2) / day_open_FCT2 * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-LBC", "minute1", 60)
df_list = np.array(df["close"].tolist())
LBC = [(df_list[i] - day_open_LBC) / day_open_LBC * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-CBK", "minute1", 60)
df_list = np.array(df["close"].tolist())
CBK = [(df_list[i] - day_open_CBK) / day_open_CBK * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-SAND", "minute1", 60)
df_list = np.array(df["close"].tolist())
SAND = [(df_list[i] - day_open_SAND) / day_open_SAND * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-HUM", "minute1", 60)
df_list = np.array(df["close"].tolist())
HUM = [(df_list[i] - day_open_HUM) / day_open_HUM * 100 for i in range(len(df_list))]
time.sleep(t)
# 'DOGE', 'STRK', 'PUNDIX', 'FLOW', 'DAWN', 'AXS', 'STX'] 12
df = pyupbit.get_ohlcv("KRW-DOGE", "minute1", 60)
df_list = np.array(df["close"].tolist())
DOGE = [(df_list[i] - day_open_DOGE) / day_open_DOGE * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-STRK", "minute1", 60)
df_list = np.array(df["close"].tolist())
STRK = [(df_list[i] - day_open_STRK) / day_open_STRK * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-PUNDIX", "minute1", 60)
df_list = np.array(df["close"].tolist())
PUNDIX = [(df_list[i] - day_open_PUNDIX) / day_open_PUNDIX * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-FLOW", "minute1", 60)
df_list = np.array(df["close"].tolist())
FLOW = [(df_list[i] - day_open_FLOW) / day_open_FLOW * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-DAWN", "minute1", 60)
df_list = np.array(df["close"].tolist())
DAWN = [(df_list[i] - day_open_DAWN) / day_open_DAWN * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-AXS", "minute1", 60)
df_list = np.array(df["close"].tolist())
AXS = [(df_list[i] - day_open_AXS) / day_open_AXS * 100 for i in range(len(df_list))]
df = pyupbit.get_ohlcv("KRW-STX", "minute1", 60)
df_list = np.array(df["close"].tolist())
STX = [(df_list[i] - day_open_STX) / day_open_STX * 100 for i in range(len(df_list))]
# 'REP', 'EMC2', 'ADA', 'SBD', 'POWR', 'BTG', 'ICX', 'EOS', 'TRX', 'SC', 3
# try:
# df = pyupbit.get_ohlcv("KRW-BTC", "minute1", 60)
# df_list = np.array(df["close"].tolist())
# except TypeError as e:
# pass
# else:
# BTC = [(df_list[i]-day_open_BTC)/day_open_BTC * 100 for i in range(len(df_list))]
#
# try:
# df = pyupbit.get_ohlcv("KRW-ETH", "minute1", 60)
# df_list = np.array(df["close"].tolist())
# except TypeError as e:
# pass
# else:
# ETH = [(df_list[i]-day_open_ETH)/day_open_ETH * 100 for i in range(len(df_list))]
#
# try:
# df = pyupbit.get_ohlcv("KRW-ARK", "minute1", 60)
# df_list = np.array(df["close"].tolist())
# except TypeError as e:
# pass
# else:
# ARK = [(df_list[i] - day_open_ARK) / day_open_ARK * 100 for i in range(len(df_list))]
#
# try:
# df = pyupbit.get_ohlcv("KRW-MTL", "minute1", 60)
# df_list = np.array(df["close"].tolist())
# except TypeError as e:
# pass
# else:
# MTL = [(df_list[i] - day_open_MTL) / day_open_MTL * 100 for i in range(len(df_list))]
#
# try:
# df = pyupbit.get_ohlcv("KRW-ADA", "minute1", 60)
# df_list = np.array(df["close"].tolist())
# except TypeError as e:
# pass
# else:
# ADA = [(df_list[i] - day_open_ADA) / day_open_ADA * 100 for i in range(len(df_list))]
#
# try:
# df = pyupbit.get_ohlcv("KRW-XRP", "minute1", 60)
# df_list = np.array(df["close"].tolist())
# except TypeError as e:
# pass
# else:
# XRP = [(df_list[i] - day_open_XRP) / day_open_XRP * 100 for i in range(len(df_list))]
#
# try:
# df = pyupbit.get_ohlcv("KRW-ETC", "minute1", 60)
# df_list = np.array(df["close"].tolist())
# except TypeError as e:
# pass
# else:
# ETC = [(df_list[i] - day_open_ETC) / day_open_ETC * 100 for i in range(len(df_list))]
# try:
# df = pyupbit.get_ohlcv("KRW-EOS", "minute1", 60)
# df_list = np.array(df["close"].tolist())
# except TypeError as e:
# pass
# else:
# EOS = [(df_list[i] - day_open_EOS) / day_open_EOS * 100 for i in range(len(df_list))]
#
# try:
# df = pyupbit.get_ohlcv("KRW-AQT", "minute1", 60)
# df_list = np.array(df["close"].tolist())
# except TypeError as e:
# pass
# else:
# AQT = [(df_list[i] - day_open_AQT) / day_open_AQT * 100 for i in range(len(df_list))]
#
# try:
# df = pyupbit.get_ohlcv("KRW-AERGO", "minute1", 60)
# df_list = np.array(df["close"].tolist())
# except TypeError as e:
# pass
# else:
# AERGO = [(df_list[i] - day_open_AERGO) / day_open_AERGO * 100 for i in range(len(df_list))]
#
# try:
# df = pyupbit.get_ohlcv("KRW-XEM", "minute1", 60)
# df_list = np.array(df["close"].tolist())
# except TypeError as e:
# pass
# else:
# XEM = [(df_list[i] - day_open_XEM) / day_open_XEM * 100 for i in range(len(df_list))]
#
# try:
# df = pyupbit.get_ohlcv("KRW-DOGE", "minute1", 60)
# df_list = np.array(df["close"].tolist())
# except TypeError as e:
# pass
# else:
# DOGE = [(df_list[i] - day_open_DOGE) / day_open_DOGE * 100 for i in range(len(df_list))]
#
# try:
# df = pyupbit.get_ohlcv("KRW-SBD", "minute1", 60)
# df_list = np.array(df["close"].tolist())
# except TypeError as e:
# pass
# else:
# SBD = [(df_list[i] - day_open_SBD) / day_open_SBD * 100 for i in range(len(df_list))]
# # SBD.append((pyupbit.get_current_price("KRW-SBD") - day_open_SBD) / day_open_SBD * 100)
# for i in krw_tickers:
# try:
# plt.plot(i)
# except NameError as e:
# pass
r = 2 # ==============================================================================
m = -5 # =============================================================================
# ['BTC', 'ETH', 'NEO', 'MTL', 'LTC', 'XRP', 'ETC', 'OMG', 'SNT', 'WAVES', 1
plt.plot(BTC) if (BTC[-1] - BTC[m])>r else ""
plt.plot(ETH) if (ETH[-1] - ETH[m])>r else ""
plt.plot(NEO) if (NEO[-1] - NEO[m])>r else ""
plt.plot(MTL) if (MTL[-1] - MTL[m])>r else ""
plt.plot(LTC) if (LTC[-1] - LTC[m])>r else ""
plt.plot(XRP) if (XRP[-1] - XRP[m])>r else ""
plt.plot(ETC) if (ETC[-1] - ETC[m])>r else ""
plt.plot(OMG) if (OMG[-1] - OMG[m])>r else ""
plt.plot(SNT) if (SNT[-1] - SNT[m])>r else ""
plt.plot(WAVES) if (WAVES[-1] - WAVES[m])>r else ""
# 'XEM', 'QTUM', 'LSK', 'STEEM', 'XLM', 'ARDR', 'KMD', 'ARK', 'STORJ', 'GRS', 2
plt.plot(XEM) if (XEM[-1] - XEM[m])>r else ""
plt.plot(QTUM) if (QTUM[-1] - QTUM[m])>r else ""
plt.plot(LSK) if (LSK[-1] - LSK[m])>r else ""
plt.plot(STEEM) if (STEEM[-1] - STEEM[m])>r else ""
plt.plot(XLM) if (XLM[-1] - XLM[m])>r else ""
plt.plot(ARDR) if (ARDR[-1] - ARDR[m])>r else ""
plt.plot(KMD) if (KMD[-1] - KMD[m])>r else ""
plt.plot(ARK) if (ARK[-1] - ARK[m])>r else ""
plt.plot(STORJ) if (STORJ[-1] - STORJ[m])>r else ""
plt.plot(GRS) if (GRS[-1] - GRS[m])>r else ""
# 'REP', 'EMC2', 'ADA', 'SBD', 'POWR', 'BTG', 'ICX', 'EOS', 'TRX', 'SC', 3
plt.plot(REP) if (REP[-1] - REP[m])>r else ""
plt.plot(EMC2) if (EMC2[-1] - EMC2[m])>r else ""
plt.plot(ADA) if (ADA[-1] - ADA[m])>r else ""
plt.plot(SBD) if (SBD[-1] - SBD[m])>r else ""
plt.plot(POWR) if (POWR[-1] - POWR[m])>r else ""
plt.plot(BTG) if (BTG[-1] - BTG[m])>r else ""
plt.plot(ICX) if (ICX[-1] - ICX[m])>r else ""
plt.plot(EOS) if (EOS[-1] - EOS[m])>r else ""
plt.plot(TRX) if (TRX[-1] - TRX[m])>r else ""
plt.plot(SC) if (SC[-1] - SC[m])>r else ""
# 'IGNIS', 'ONT', 'ZIL', 'POLY', 'ZRX', 'LOOM', 'BCH', 'ADX', 'BAT', 'IOST', 4
plt.plot(IGNIS) if (IGNIS[-1] - IGNIS[m])>r else ""
plt.plot(ONT) if (ONT[-1] - ONT[m])>r else ""
plt.plot(ZIL) if (ZIL[-1] - ZIL[m])>r else ""
plt.plot(POLY) if (POLY[-1] - POLY[m])>r else ""
plt.plot(ZRX) if (ZRX[-1] - ZRX[m])>r else ""
plt.plot(LOOM) if (LOOM[-1] - LOOM[m])>r else ""
plt.plot(BCH) if (BCH[-1] - BCH[m])>r else ""
plt.plot(ADX) if (ADX[-1] - ADX[m])>r else ""
plt.plot(BAT) if (BAT[-1] - BAT[m])>r else ""
plt.plot(IOST) if (IOST[-1] - IOST[m])>r else ""
# 'DMT', 'RFR', 'CVC', 'IQ', 'IOTA', 'MFT', 'ONG', 'GAS', 'UPP', 'ELF', 5
plt.plot(DMT) if (DMT[-1] - DMT[m])>r else ""
plt.plot(RFR) if (RFR[-1] - RFR[m])>r else ""
plt.plot(CVC) if (CVC[-1] - CVC[m])>r else ""
plt.plot(IQ) if (IQ[-1] - IQ[m])>r else ""
plt.plot(IOTA) if (IOTA[-1] - IOTA[m])>r else ""
plt.plot(MFT) if (MFT[-1] - MFT[m])>r else ""
plt.plot(ONG) if (ONG[-1] - ONG[m])>r else ""
plt.plot(GAS) if (GAS[-1] - GAS[m])>r else ""
plt.plot(UPP) if (UPP[-1] - UPP[m])>r else ""
plt.plot(ELF) if (ELF[-1] - ELF[m])>r else ""
# 'KNC', 'BSV', 'THETA', 'EDR', 'QKC', 'BTT', 'MOC', 'ENJ', 'TFUEL', 'MANA', 6
plt.plot(KNC) if (KNC[-1] - KNC[m])>r else ""
plt.plot(BSV) if (BSV[-1] - BSV[m])>r else ""
plt.plot(THETA) if (THETA[-1] - THETA[m])>r else ""
plt.plot(EDR) if (EDR[-1] - EDR[m])>r else ""
plt.plot(QKC) if (QKC[-1] - QKC[m])>r else ""
plt.plot(BTT) if (BTT[-1] - BTT[m])>r else ""
plt.plot(MOC) if (MOC[-1] - MOC[m])>r else ""
plt.plot(ENJ) if (ENJ[-1] - ENJ[m])>r else ""
plt.plot(TFUEL) if (TFUEL[-1] - TFUEL[m])>r else ""
plt.plot(MANA) if (MANA[-1] - MANA[m])>r else ""
# 'ANKR', 'AERGO', 'ATOM', 'TT', 'CRE', 'SOLVE', 'MBL', 'TSHP', 'WAXP', 'HBAR', 7
plt.plot(ANKR) if (ANKR[-1] - ANKR[m])>r else ""
plt.plot(AERGO) if (AERGO[-1] - AERGO[m])>r else ""
plt.plot(ATOM) if (ATOM[-1] - ATOM[m])>r else ""
plt.plot(TT) if (TT[-1] - TT[m])>r else ""
plt.plot(CRE) if (CRE[-1] - CRE[m])>r else ""
plt.plot(SOLVE) if (SOLVE[-1] - SOLVE[m])>r else ""
plt.plot(MBL) if (MBL[-1] - MBL[m])>r else ""
plt.plot(TSHP) if (TSHP[-1] - TSHP[m])>r else ""
plt.plot(WAXP) if (WAXP[-1] - WAXP[m])>r else ""
plt.plot(HBAR) if (HBAR[-1] - HBAR[m])>r else ""
# 'MED', 'MLK', 'STPT', 'ORBS', 'VET', 'CHZ', 'PXL', 'STMX', 'DKA', 'HIVE', 8
plt.plot(MED) if (MED[-1] - MED[m])>r else ""
plt.plot(MLK) if (MLK[-1] - MLK[m])>r else ""
plt.plot(STPT) if (STPT[-1] - STPT[m])>r else ""
plt.plot(ORBS) if (ORBS[-1] - ORBS[m])>r else ""
plt.plot(VET) if (VET[-1] - VET[m])>r else ""
plt.plot(CHZ) if (CHZ[-1] - CHZ[m])>r else ""
plt.plot(PXL) if (PXL[-1] - PXL[m])>r else ""
plt.plot(STMX) if (STMX[-1] - STMX[m])>r else ""
plt.plot(DKA) if (DKA[-1] - DKA[m])>r else ""
plt.plot(HIVE) if (HIVE[-1] - HIVE[m])>r else ""
# 'KAVA', 'AHT', 'LINK', 'XTZ', 'BORA', 'JST', 'CRO', 'TON', 'SXP', 'LAMB', 9
plt.plot(KAVA) if (KAVA[-1] - KAVA[m])>r else ""
plt.plot(AHT) if (AHT[-1] - AHT[m])>r else ""
plt.plot(LINK) if (LINK[-1] - LINK[m])>r else ""
plt.plot(XTZ) if (XTZ[-1] - XTZ[m])>r else ""
plt.plot(BORA) if (BORA[-1] - BORA[m])>r else ""
plt.plot(JST) if (JST[-1] - JST[m])>r else ""
plt.plot(CRO) if (CRO[-1] - CRO[m])>r else ""
plt.plot(TON) if (TON[-1] - TON[m])>r else ""
plt.plot(SXP) if (SXP[-1] - SXP[m])>r else ""
plt.plot(LAMB) if (LAMB[-1] - LAMB[m])>r else ""
# 'HUNT', 'MARO', 'PLA', 'DOT', 'SRM', 'MVL', 'PCI', 'STRAX', 'AQT', 'BCHA', 10
plt.plot(HUNT) if (HUNT[-1] - HUNT[m])>r else ""
plt.plot(MARO) if (MARO[-1] - MARO[m])>r else ""
plt.plot(PLA) if (PLA[-1] - PLA[m])>r else ""
plt.plot(DOT) if (DOT[-1] - DOT[m])>r else ""
plt.plot(SRM) if (SRM[-1] - SRM[m])>r else ""
plt.plot(MVL) if (MVL[-1] - MVL[m])>r else ""
plt.plot(PCI) if (PCI[-1] - PCI[m])>r else ""
plt.plot(STRAX) if (STRAX[-1] - STRAX[m])>r else ""
plt.plot(BCHA) if (BCHA[-1] - BCHA[m])>r else ""
# 'GLM', 'QTCON', 'SSX', 'META', 'OBSR', 'FCT2', 'LBC', 'CBK', 'SAND', 'HUM', 11
plt.plot(GLM) if (GLM[-1] - GLM[m])>r else ""
plt.plot(QTCON) if (QTCON[-1] - QTCON[m])>r else ""
plt.plot(SSX) if (SSX[-1] - SSX[m])>r else ""
plt.plot(META) if (META[-1] - META[m])>r else ""
plt.plot(OBSR) if (OBSR[-1] - OBSR[m])>r else ""
plt.plot(FCT2) if (FCT2[-1] - FCT2[m])>r else ""
plt.plot(LBC) if (LBC[-1] - LBC[m])>r else ""
plt.plot(CBK) if (CBK[-1] - CBK[m])>r else ""
plt.plot(SAND) if (SAND[-1] - SAND[m])>r else ""
plt.plot(HUM) if (HUM[-1] - HUM[m])>r else ""
# 'DOGE', 'STRK', 'PUNDIX', 'FLOW', 'DAWN', 'AXS', 'STX'] 12
plt.plot(DOGE) if (DOGE[-1] - DOGE[m])>r else ""
plt.plot(STRK) if (STRK[-1] - STRK[m])>r else ""
plt.plot(PUNDIX) if (PUNDIX[-1] - PUNDIX[m])>r else ""
plt.plot(FLOW) if (FLOW[-1] - FLOW[m])>r else ""
plt.plot(DAWN) if (DAWN[-1] - DAWN[m])>r else ""
plt.plot(AXS) if (AXS[-1] - AXS[m])>r else ""
plt.plot(STX) if (STX[-1] - STX[m])>r else ""
# try:
# plt.plot(BTC)
# except NameError as e:
# pass
#
# try:
# plt.plot(ETH)
# except NameError as e:
# pass
#
# try:
# plt.plot(ARK)
# except NameError as e:
# pass
#
# try:
# plt.plot(MTL)
# except NameError as e:
# pass
#
# try:
# plt.plot(ADA)
# except NameError as e:
# pass
#
# try:
# plt.plot(XRP)
# except NameError as e:
# pass
#
# try:
# plt.plot(ETC)
# except NameError as e:
# pass
#
# try:
# plt.plot(EOS)
# except NameError as e:
# pass
#
# try:
# plt.plot(AQT)
# except NameError as e:
# pass
#
# try:
# plt.plot(AERGO)
# except NameError as e:
# pass
#
# try:
# plt.plot(XEM)
# except NameError as e:
# pass
#
# try:
# plt.plot(DOGE)
# except NameError as e:
# pass
#
# try:
# plt.plot(SBD)
# except NameError as e:
# pass
# for i in krw_tickers:
# try:
# plt.text(60, i[-1], i)
# except NameError as e:
# pass
# plt.text(60, i[-1], i)
# ['BTC', 'ETH', 'NEO', 'MTL', 'LTC', 'XRP', 'ETC', 'OMG', 'SNT', 'WAVES', 1
# plt.text(60, BTC[-1], f'BTC {(BTC[-1] - BTC[m]) if (BTC[-1] - BTC[m])>r else ""}')
# f'BTC {(BTC[-1] - BTC[m]):.2f}' if (BTC[-1] - BTC[m])>r else ""
plt.text(60, BTC[-1], f'BTC {(BTC[-1] - BTC[m]):.2f}' if (BTC[-1] - BTC[m])>r else "")
plt.text(60, ETH[-1], f'ETH {(ETH[-1] - ETH[m]):.2f}' if (ETH[-1] - ETH[m])>r else "")
plt.text(60, NEO[-1], f'NEO {(NEO[-1] - NEO[m]):.2f}' if (NEO[-1] - NEO[m])>r else "")
plt.text(60, MTL[-1], f'MTL {(MTL[-1] - MTL[m]):.2f}' if (MTL[-1] - MTL[m])>r else "")
plt.text(60, LTC[-1], f'LTC {(LTC[-1] - LTC[m]):.2f}' if (LTC[-1] - LTC[m])>r else "")
plt.text(60, XRP[-1], f'XRP {(XRP[-1] - XRP[m]):.2f}' if (XRP[-1] - XRP[m])>r else "")
plt.text(60, ETC[-1], f'ETC {(ETC[-1] - ETC[m]):.2f}' if (ETC[-1] - ETC[m])>r else "")
plt.text(60, OMG[-1], f'OMG {(OMG[-1] - OMG[m]):.2f}' if (OMG[-1] - OMG[m])>r else "")
plt.text(60, SNT[-1], f'SNT {(SNT[-1] - SNT[m]):.2f}' if (SNT[-1] - SNT[m])>r else "")
plt.text(60, WAVES[-1], f'WAVES {(WAVES[-1] - WAVES[m]):.2f}' if (WAVES[-1] - WAVES[m])>r else "")
# 'XEM', 'QTUM', 'LSK', 'STEEM', 'XLM', 'ARDR', 'KMD', 'ARK', 'STORJ', 'GRS', 2
plt.text(60, XEM[-1], f'XEM {(XEM[-1] - XEM[m]):.2f}' if (XEM[-1] - XEM[m])>r else "")
plt.text(60, QTUM[-1], f'QTUM {(QTUM[-1] - QTUM[m]):.2f}' if (QTUM[-1] - QTUM[m])>r else "")
plt.text(60, LSK[-1], f'LSK {(LSK[-1] - LSK[m]):.2f}' if (LSK[-1] - LSK[m])>r else "")
plt.text(60, STEEM[-1], f'STEEM {(STEEM[-1] - STEEM[m]):.2f}' if (STEEM[-1] - STEEM[m])>r else "")
plt.text(60, XLM[-1], f'XLM {(XLM[-1] - XLM[m]):.2f}' if (XLM[-1] - XLM[m])>r else "")
plt.text(60, ARDR[-1], f'ARDR {(ARDR[-1] - ARDR[m]):.2f}' if (ARDR[-1] - ARDR[m])>r else "")
plt.text(60, KMD[-1], f'KMD {(KMD[-1] - KMD[m]):.2f}' if (KMD[-1] - KMD[m])>r else "")
plt.text(60, ARK[-1], f'ARK {(ARK[-1] - ARK[m]):.2f}' if (ARK[-1] - ARK[m])>r else "")
plt.text(60, STORJ[-1], f'STORJ {(STORJ[-1] - STORJ[m]):.2f}' if (STORJ[-1] - STORJ[m])>r else "")
plt.text(60, GRS[-1], f'GRS {(GRS[-1] - GRS[m]):.2f}' if (GRS[-1] - GRS[m])>r else "")
# 'REP', 'EMC2', 'ADA', 'SBD', 'POWR', 'BTG', 'ICX', 'EOS', 'TRX', 'SC', 3
plt.text(60, REP[-1], f'REP {(REP[-1] - REP[m]):.2f}' if (REP[-1] - REP[m])>r else "")
plt.text(60, EMC2[-1], f'EMC2 {(EMC2[-1] - EMC2[m]):.2f}' if (EMC2[-1] - EMC2[m])>r else "")
plt.text(60, ADA[-1], f'ADA {(ADA[-1] - ADA[m]):.2f}' if (ADA[-1] - ADA[m])>r else "")
plt.text(60, SBD[-1], f'SBD {(SBD[-1] - BTC[m]):.2f}' if (SBD[-1] - BTC[m])>r else "")
plt.text(60, POWR[-1], f'POWR {(POWR[-1] - POWR[m]):.2f}' if (POWR[-1] - POWR[m])>r else "")
plt.text(60, ICX[-1], f'ICX {(ICX[-1] - ICX[m]):.2f}' if (ICX[-1] - ICX[m])>r else "")
plt.text(60, EOS[-1], f'EOS {(EOS[-1] - EOS[m]):.2f}' if (EOS[-1] - EOS[m])>r else "")
plt.text(60, TRX[-1], f'TRX {(TRX[-1] - TRX[m]):.2f}' if (TRX[-1] - TRX[m])>r else "")
plt.text(60, SC[-1], f'SC {(SC[-1] - SC[m]):.2f}' if (SC[-1] - SC[m])>r else "")
# 'IGNIS', 'ONT', 'ZIL', 'POLY', 'ZRX', 'LOOM', 'BCH', 'ADX', 'BAT', 'IOST', 4
plt.text(60, IGNIS[-1], f'IGNIS {(IGNIS[-1] - IGNIS[m]):.2f}' if (IGNIS[-1] - IGNIS[m])>r else "")
plt.text(60, ONT[-1], f'ONT {(ONT[-1] - ONT[m]):.2f}' if (ONT[-1] - ONT[m])>r else "")
plt.text(60, ZIL[-1], f'ZIL {(ZIL[-1] - ZIL[m]):.2f}' if (ZIL[-1] - ZIL[m])>r else "")
plt.text(60, POLY[-1], f'POLY {(POLY[-1] - POLY[m]):.2f}' if (POLY[-1] - POLY[m])>r else "")
plt.text(60, ZRX[-1], f'ZRX {(ZRX[-1] - ZRX[m]):.2f}' if (ZRX[-1] - ZRX[m])>r else "")
plt.text(60, LOOM[-1], f'LOOM {(LOOM[-1] - LOOM[m]):.2f}' if (LOOM[-1] - LOOM[m])>r else "")
plt.text(60, BCH[-1], f'BCH {(BCH[-1] - BCH[m]):.2f}' if (BCH[-1] - BCH[m])>r else "")
plt.text(60, ADX[-1], f'ADX {(ADX[-1] - ADX[m]):.2f}' if (ADX[-1] - ADX[m])>r else "")
plt.text(60, BAT[-1], f'BAT {(BAT[-1] - BAT[m]):.2f}' if (BAT[-1] - BAT[m])>r else "")
plt.text(60, IOST[-1], f'IOST {(IOST[-1] - IOST[m]):.2f}' if (IOST[-1] - IOST[m])>r else "")
# 'DMT', 'RFR', 'CVC', 'IQ', 'IOTA', 'MFT', 'ONG', 'GAS', 'UPP', 'ELF', 5
plt.text(60, DMT[-1], f'DMT {(DMT[-1] - DMT[m]):.2f}' if (DMT[-1] - DMT[m])>r else "")
plt.text(60, RFR[-1], f'RFR {(RFR[-1] - RFR[m]):.2f}' if (RFR[-1] - RFR[m])>r else "")
plt.text(60, CVC[-1], f'CVC {(CVC[-1] - CVC[m]):.2f}' if (CVC[-1] - CVC[m])>r else "")
plt.text(60, IQ[-1], f'IQ {(IQ[-1] - IQ[m]):.2f}' if (IQ[-1] - IQ[m])>r else "")
plt.text(60, IOTA[-1], f'IOTA {(IOTA[-1] - IOTA[m]):.2f}' if (IOTA[-1] - IOTA[m])>r else "")
plt.text(60, MFT[-1], f'MFT {(MFT[-1] - MFT[m]):.2f}' if (MFT[-1] - MFT[m])>r else "")
plt.text(60, ONG[-1], f'ONG {(ONG[-1] - ONG[m]):.2f}' if (ONG[-1] - ONG[m])>r else "")
plt.text(60, GAS[-1], f'GAS {(GAS[-1] - GAS[m]):.2f}' if (GAS[-1] - GAS[m])>r else "")
plt.text(60, UPP[-1], f'UPP {(UPP[-1] - UPP[m]):.2f}' if (UPP[-1] - UPP[m])>r else "")
plt.text(60, ELF[-1], f'ELF {(ELF[-1] - ELF[m]):.2f}' if (ELF[-1] - ELF[m])>r else "")
# 'KNC', 'BSV', 'THETA', 'EDR', 'QKC', 'BTT', 'MOC', 'ENJ', 'TFUEL', 'MANA', 6
plt.text(60, KNC[-1], f'KNC {(KNC[-1] - KNC[m]):.2f}' if (KNC[-1] - KNC[m])>r else "")
plt.text(60, BSV[-1], f'BSV {(BSV[-1] - BSV[m]):.2f}' if (BSV[-1] - BSV[m])>r else "")
plt.text(60, THETA[-1], f'THETA {(THETA[-1] - THETA[m]):.2f}' if (THETA[-1] - THETA[m])>r else "")
plt.text(60, EDR[-1], f'EDR {(EDR[-1] - EDR[m]):.2f}' if (EDR[-1] - EDR[m])>r else "")
plt.text(60, QKC[-1], f'QKC {(QKC[-1] - QKC[m]):.2f}' if (QKC[-1] - QKC[m])>r else "")
plt.text(60, BTT[-1], f'BTT {(BTT[-1] - BTT[m]):.2f}' if (BTT[-1] - BTT[m])>r else "")
plt.text(60, MOC[-1],f'MOC {(MOC[-1] - MOC[m]):.2f}' if (MOC[-1] - MOC[m])>r else "")
plt.text(60, ENJ[-1], f'ENJ {(ENJ[-1] - ENJ[m]):.2f}' if (ENJ[-1] - ENJ[m])>r else "")
plt.text(60, TFUEL[-1], f'TFUEL {(TFUEL[-1] - TFUEL[m]):.2f}' if (TFUEL[-1] - TFUEL[m])>r else "")
plt.text(60, MANA[-1], f'MANA {(MANA[-1] - MANA[m]):.2f}' if (MANA[-1] - MANA[m])>r else "")
# 'ANKR', 'AERGO', 'ATOM', 'TT', 'CRE', 'SOLVE', 'MBL', 'TSHP', 'WAXP', 'HBAR', 7
plt.text(60, ANKR[-1], f'ANKR {(ANKR[-1] - ANKR[m]):.2f}' if (ANKR[-1] - ANKR[m])>r else "")
plt.text(60, AERGO[-1], f'AERGO {(AERGO[-1] - AERGO[m]):.2f}' if (AERGO[-1] - AERGO[m])>r else "")
plt.text(60, ATOM[-1], f'ATOM {(ATOM[-1] - ATOM[m]):.2f}' if (ATOM[-1] - ATOM[m])>r else "")
plt.text(60, TT[-1], f'TT {(TT[-1] - TT[m]):.2f}' if (TT[-1] - TT[m])>r else "")
plt.text(60, CRE[-1], f'CRE {(CRE[-1] - CRE[m]):.2f}' if (CRE[-1] - CRE[m])>r else "")
plt.text(60, SOLVE[-1], f'SOLVE {(SOLVE[-1] - SOLVE[m]):.2f}' if (SOLVE[-1] - SOLVE[m])>r else "")
plt.text(60, MBL[-1], f'MBL {(MBL[-1] - ELF[m]):.2f}' if (MBL[-1] - MBL[m])>r else "")
plt.text(60, TSHP[-1], f'TSHP {(TSHP[-1] - TSHP[m]):.2f}' if (TSHP[-1] - TSHP[m])>r else "")
plt.text(60, WAXP[-1], f'WAXP {(WAXP[-1] - WAXP[m]):.2f}' if (WAXP[-1] - WAXP[m])>r else "")
plt.text(60, HBAR[-1], f'HBAR {(HBAR[-1] - HBAR[m]):.2f}' if (HBAR[-1] - HBAR[m])>r else "")
# 'MED', 'MLK', 'STPT', 'ORBS', 'VET', 'CHZ', 'PXL', 'STMX', 'DKA', 'HIVE', 8
plt.text(60, MED[-1], f'MED {(MED[-1] - MED[m]):.2f}' if (MED[-1] - MED[m])>r else "")
plt.text(60, MLK[-1], f'MLK {(MLK[-1] - MLK[m]):.2f}' if (MLK[-1] - MLK[m])>r else "")
plt.text(60, STPT[-1], f'STPT {(STPT[-1] - STPT[m]):.2f}' if (STPT[-1] - STPT[m])>r else "")
plt.text(60, ORBS[-1], f'ORBS {(ORBS[-1] - ORBS[m]):.2f}' if (ORBS[-1] - ORBS[m])>r else "")
plt.text(60, VET[-1], f'VET {(VET[-1] - VET[m]):.2f}' if (VET[-1] - VET[m])>r else "")
plt.text(60, CHZ[-1], f'CHZ {(CHZ[-1] - CHZ[m]):.2f}' if (CHZ[-1] - CHZ[m])>r else "")
plt.text(60, PXL[-1], f'PXL {(PXL[-1] - PXL[m]):.2f}' if (PXL[-1] - PXL[m])>r else "")
plt.text(60, STMX[-1], f'STMX {(STMX[-1] - STMX[m]):.2f}' if (STMX[-1] - STMX[m])>r else "")
plt.text(60, DKA[-1], f'DKA {(DKA[-1] - DKA[m]):.2f}' if (DKA[-1] - DKA[m])>r else "")
plt.text(60, HIVE[-1], f'HIVE {(HIVE[-1] - HIVE[m]):.2f}' if (HIVE[-1] - HIVE[m])>r else "")
# 'KAVA', 'AHT', 'LINK', 'XTZ', 'BORA', 'JST', 'CRO', 'TON', 'SXP', 'LAMB', 9
plt.text(60, KAVA[-1], f'KAVA {(KAVA[-1] - KAVA[m]):.2f}' if (KAVA[-1] - KAVA[m])>r else "")
plt.text(60, AHT[-1], f'AHT {(AHT[-1] - AHT[m]):.2f}' if (AHT[-1] - AHT[m])>r else "")
plt.text(60, LINK[-1], f'LINK {(LINK[-1] - LINK[m]):.2f}' if (LINK[-1] - LINK[m])>r else "")
plt.text(60, XTZ[-1], f'XTZ {(XTZ[-1] - XTZ[m]):.2f}' if (XTZ[-1] - XTZ[m])>r else "")
plt.text(60, BORA[-1], f'BORA {(BORA[-1] - BORA[m]):.2f}' if (BORA[-1] - BORA[m])>r else "")
plt.text(60, JST[-1], f'JST {(JST[-1] - JST[m]):.2f}' if (JST[-1] - JST[m])>r else "")
plt.text(60, TON[-1], f'TON {(TON[-1] - TON[m]):.2f}' if (TON[-1] - TON[m])>r else "")
plt.text(60, SXP[-1], f'SXP {(SXP[-1] - SXP[m]):.2f}' if (SXP[-1] - SXP[m])>r else "")
plt.text(60, LAMB[-1], f'LAMB {(LAMB[-1] - LAMB[m]):.2f}' if (LAMB[-1] - LAMB[m])>r else "")
# 'HUNT', 'MARO', 'PLA', 'DOT', 'SRM', 'MVL', 'PCI', 'STRAX', 'AQT', 'BCHA', 10
plt.text(60, HUNT[-1], f'HUNT {(HUNT[-1] - HUNT[m]):.2f}' if (HUNT[-1] - HUNT[m])>r else "")
plt.text(60, MARO[-1], f'MARO {(MARO[-1] - MARO[m]):.2f}' if (MARO[-1] - MARO[m])>r else "")
plt.text(60, PLA[-1], f'PLA {(PLA[-1] - PLA[m]):.2f}' if (PLA[-1] - PLA[m])>r else "")
plt.text(60, DOT[-1], f'DOT {(DOT[-1] - DOT[m]):.2f}' if (DOT[-1] - DOT[m])>r else "")
plt.text(60, SRM[-1], f'SRM {(SRM[-1] - SRM[m]):.2f}' if (SRM[-1] - SRM[m])>r else "")
plt.text(60, MVL[-1], f'MVL {(MVL[-1] - MVL[m]):.2f}' if (MVL[-1] - MVL[m])>r else "")
plt.text(60, PCI[-1], f'PCI {(PCI[-1] - PCI[m]):.2f}' if (PCI[-1] - PCI[m])>r else "")
plt.text(60, STRAX[-1], f'STRAX {(STRAX[-1] - STRAX[m]):.2f}' if (STRAX[-1] - STRAX[m])>r else "")
plt.text(60, AQT[-1], f'AQT {(AQT[-1] - AQT[m]):.2f}' if (AQT[-1] - AQT[m])>r else "")
plt.text(60, BCHA[-1], f'BCHA {(BCHA[-1] - BCHA[m]):.2f}' if (BCHA[-1] - BCHA[m])>r else "")
# 'GLM', 'QTCON', 'SSX', 'META', 'OBSR', 'FCT2', 'LBC', 'CBK', 'SAND', 'HUM', 11
plt.text(60, GLM[-1], f'GLM {(GLM[-1] - GLM[m]):.2f}' if (GLM[-1] - GLM[m])>r else "")
plt.text(60, QTCON[-1], f'QTCON {(QTCON[-1] - QTCON[m]):.2f}' if (QTCON[-1] - QTCON[m])>r else "")
plt.text(60, SSX[-1], f'SSX {(SSX[-1] - SSX[m]):.2f}' if (SSX[-1] - SSX[m])>r else "")
plt.text(60, META[-1], f'META {(META[-1] - META[m]):.2f}' if (META[-1] - META[m])>r else "")
plt.text(60, OBSR[-1], f'OBSR {(OBSR[-1] - OBSR[m]):.2f}' if (OBSR[-1] - OBSR[m])>r else "")
plt.text(60, FCT2[-1], f'FCT2 {(FCT2[-1] - FCT2[m]):.2f}' if (FCT2[-1] - FCT2[m])>r else "")
plt.text(60, LBC[-1], f'LBC {(LBC[-1] - LBC[m]):.2f}' if (LBC[-1] - LBC[m])>r else "")
plt.text(60, CBK[-1], f'CBK {(CBK[-1] - CBK[m]):.2f}' if (CBK[-1] - CBK[m])>r else "")
plt.text(60, SAND[-1], f'SAND {(SAND[-1] - SAND[m]):.2f}' if (SAND[-1] - SAND[m])>r else "")
plt.text(60, HUM[-1], f'HUM {(HUM[-1] - HUM[m]):.2f}' if (HUM[-1] - HUM[m])>r else "")
# 'DOGE', 'STRK', 'PUNDIX', 'FLOW', 'DAWN', 'AXS', 'STX'] 12
plt.text(60, DOGE[-1], f'DOGE {(DOGE[-1] - DOGE[m]):.2f}' if (DOGE[-1] - DOGE[m])>r else "")
plt.text(60, STRK[-1], f'STRK {(STRK[-1] - STRK[m]):.2f}' if (STRK[-1] - STRK[m])>r else "")
plt.text(60, PUNDIX[-1], f'PUNDIX {(PUNDIX[-1] - PUNDIX[m]):.2f}' if (PUNDIX[-1] - PUNDIX[m])>r else "")
plt.text(60, FLOW[-1], f'FLOW {(FLOW[-1] - FLOW[m]):.2f}' if (FLOW[-1] - FLOW[m])>r else "")
plt.text(60, DAWN[-1], f'DAWN {(DAWN[-1] - DAWN[m]):.2f}' if (DAWN[-1] - DAWN[m])>r else "")
plt.text(60, AXS[-1], f'AXS {(AXS[-1] - AXS[m]):.2f}' if (AXS[-1] - AXS[m])>r else "")
plt.text(60, STX[-1], f'STX {(STX[-1] - STX[m]):.2f}' if (STX[-1] - STX[m])>r else "")
# try:
# plt.text(60, BTC[-1], 'BTC')
# except NameError as e:
# pass
#
# try:
# plt.text(60, ETH[-1], 'ETH')
# except NameError as e:
# pass
#
# try:
# plt.text(60, ARK[-1], 'ARK')
# except NameError as e:
# pass
#
# try:
# plt.text(60, MTL[-1], 'MTL')
# except NameError as e:
# pass
#
# try:
# plt.text(60, ADA[-1], 'ADA')
# except NameError as e:
# pass
#
# try:
# plt.text(60, XRP[-1], 'XRP')
# except NameError as e:
# pass
#
# try:
# plt.text(60, ETC[-1], 'ETC')
# except NameError as e:
# pass
#
# try:
# plt.text(60, EOS[-1], 'EOS')
# except NameError as e:
# pass
#
# try:
# plt.text(60, AQT[-1], 'AQT')
# except NameError as e:
# pass
#
# try:
# plt.text(60, AERGO[-1], 'AERGO')
# except NameError as e:
# pass
#
# try:
# plt.text(60, XEM[-1], 'XEM')
# except NameError as e:
# pass
#
# try:
# plt.text(60, DOGE[-1], 'DOGE')
# except NameError as e:
# pass
#
# try:
# plt.text(60, SBD[-1], 'SBD')
# except NameError as e:
# pass
# ['BTC', 'ETH', 'NEO', 'MTL', 'LTC', 'XRP', 'ETC', 'OMG', 'SNT', 'WAVES', 1
# 'XEM', 'QTUM', 'LSK', 'STEEM', 'XLM', 'ARDR', 'KMD', 'ARK', 'STORJ', 'GRS', 2
# 'REP', 'EMC2', 'ADA', 'SBD', 'POWR', 'BTG', 'ICX', 'EOS', 'TRX', 'SC', 3
# 'IGNIS', 'ONT', 'ZIL', 'POLY', 'ZRX', 'LOOM', 'BCH', 'ADX', 'BAT', 'IOST', 4
# 'DMT', 'RFR', 'CVC', 'IQ', 'IOTA', 'MFT', 'ONG', 'GAS', 'UPP', 'ELF', 5
# 'KNC', 'BSV', 'THETA', 'EDR', 'QKC', 'BTT', 'MOC', 'ENJ', 'TFUEL', 'MANA', 6
# 'ANKR', 'AERGO', 'ATOM', 'TT', 'CRE', 'SOLVE', 'MBL', 'TSHP', 'WAXP', 'HBAR', 7
# 'MED', 'MLK', 'STPT', 'ORBS', 'VET', 'CHZ', 'PXL', 'STMX', 'DKA', 'HIVE', 8
# 'KAVA', 'AHT', 'LINK', 'XTZ', 'BORA', 'JST', 'CRO', 'TON', 'SXP', 'LAMB', 9
# 'HUNT', 'MARO', 'PLA', 'DOT', 'SRM', 'MVL', 'PCI', 'STRAX', 'AQT', 'BCHA', 10
# 'GLM', 'QTCON', 'SSX', 'META', 'OBSR', 'FCT2', 'LBC', 'CBK', 'SAND', 'HUM', 11
# 'DOGE', 'STRK', 'PUNDIX', 'FLOW', 'DAWN', 'AXS', 'STX'] 12
#========================
# plt.legend(['BTC '+str(BTC[-1]-BTC[-5]),
# 'ETH '+str(ETH[-1]-ETH[-5]),
# 'ARK '+str(ARK[-1]-ARK[-5]),
# 'MTL '+str(MTL[-1]-MTL[-5]),
# 'ADA '+str(ADA[-1]-ADA[-5]),
# 'XRP '+str(XRP[-1]-XRP[-5]),
# 'ETC '+str(ETC[-1]-ETC[-5]),
# 'EOS '+str(EOS[-1]-EOS[-5]),
# 'AQT '+str(AQT[-1]-AQT[-5]),
# 'AERGO '+str(AERGO[-1]-AERGO[-5]),
# 'XEM '+str(XEM[-1]-XEM[-5]),
# 'DOGE '+str(DOGE[-1]-DOGE[-5]),
# 'SBD '+str(SBD[-1]-SBD[-5])])
# plt.legend(['BTC', 'ETH', 'NEO', 'MTL', 'LTC', 'XRP', 'ETC', 'OMG', 'SNT', 'WAVES',
# 'XEM', 'QTUM', 'LSK', 'STEEM', 'XLM', 'ARDR', 'KMD', 'ARK', 'STORJ', 'GRS',
# 'REP', 'EMC2', 'ADA', 'SBD', 'POWR', 'BTG', 'ICX', 'EOS', 'TRX', 'SC',
# 'IGNIS', 'ONT', 'ZIL', 'POLY', 'ZRX', 'LOOM', 'BCH', 'ADX', 'BAT', 'IOST',
# 'DMT', 'RFR', 'CVC', 'IQ', 'IOTA', 'MFT', 'ONG', 'GAS', 'UPP', 'ELF',
# 'KNC', 'BSV', 'THETA', 'EDR', 'QKC', 'BTT', 'MOC', 'ENJ', 'TFUEL', 'MANA',
# 'ANKR', 'AERGO', 'ATOM', 'TT', 'CRE', 'SOLVE', 'MBL', 'TSHP', 'WAXP', 'HBAR',
# 'MED', 'MLK', 'STPT', 'ORBS', 'VET', 'CHZ', 'PXL', 'STMX', 'DKA', 'HIVE',
# 'KAVA', 'AHT', 'LINK', 'XTZ', 'BORA', 'JST', 'CRO', 'TON', 'SXP', 'LAMB',
# 'HUNT', 'MARO', 'PLA', 'DOT', 'SRM', 'MVL', 'PCI', 'STRAX', 'AQT', 'BCHA',
# 'GLM', 'QTCON', 'SSX', 'META', 'OBSR', 'FCT2', 'LBC', 'CBK', 'SAND', 'HUM',
# 'DOGE', 'STRK', 'PUNDIX', 'FLOW', 'DAWN', 'AXS', 'STX'], loc='upper left')
# plt.legend(krw_tickers,loc='upper left')
# plt.legend(loc='upper left')
# f'I am {num:{".2f" if ppl else ""}}'
# dog if animal is dog else cat
# print(f'MARO {(MARO[-1] - MARO[0]):.2f}' if (MARO[-1] - MARO[0])>0 else "공백")
plt.legend([f'BTC {(BTC[-1] - BTC[m]):.2f}' if (BTC[-1] - BTC[m])>r else "",
f'ETH {(ETH[-1] - ETH[m]):.2f}' if (ETH[-1] - ETH[m])>r else "",
f'NEO {(NEO[-1] - NEO[m]):.2f}' if (NEO[-1] - NEO[m])>r else "",
f'MTL {(MTL[-1] - MTL[m]):.2f}' if (MTL[-1] - MTL[m])>r else "",
f'LTC {(LTC[-1] - LTC[m]):.2f}' if (LTC[-1] - LTC[m])>r else "",
f'XRP {(XRP[-1] - XRP[m]):.2f}' if (XRP[-1] - XRP[m])>r else "",
f'ETC {(ETC[-1] - ETC[m]):.2f}' if (ETC[-1] - ETC[m])>r else "",
f'OMG {(OMG[-1] - OMG[m]):.2f}' if (OMG[-1] - OMG[m])>r else "",
f'SNT {(SNT[-1] - SNT[m]):.2f}' if (SNT[-1] - SNT[m])>r else "",
f'WAVES{(WAVES[-1] - WAVES[m]):.2f}' if (WAVES[-1] - WAVES[m])>r else "",
f'XEM {(XEM[-1] - XEM[m]):.2f}' if (XEM[-1] - XEM[m])>r else "",
f'QTUM {(QTUM[-1] - QTUM[m]):.2f}' if (QTUM[-1] - QTUM[m])>r else "",
f'LSK {(LSK[-1] - LSK[m]):.2f}' if (LSK[-1] - LSK[m])>r else "",
f'STEEM {(STEEM[-1] - STEEM[m]):.2f}' if (STEEM[-1] - STEEM[m])>r else "",
f'XLM {(XLM[-1] - XLM[m]):.2f}' if (XLM[-1] - XLM[m])>r else "",
f'ARDR {(ARDR[-1] - ARDR[m]):.2f}' if (ARDR[-1] - ARDR[m])>r else "",
f'KMD {(KMD[-1] - KMD[m]):.2f}' if (KMD[-1] - KMD[m])>r else "",
f'ARK {(ARK[-1] - ARK[m]):.2f}' if (ARK[-1] - ARK[m])>r else "",
f'STORJ {(STORJ[-1] - STORJ[m]):.2f}' if (STORJ[-1] - STORJ[m])>r else "",
f'GRS {(GRS[-1] - GRS[m]):.2f}' if (GRS[-1] - GRS[m])>r else "",
f'REP {(REP[-1] - REP[m]):.2f}' if (REP[-1] - REP[m])>r else "",
f'EMC2 {(EMC2[-1] - EMC2[m]):.2f}' if (EMC2[-1] - EMC2[m])>r else "",
f'ADA {(ADA[-1] - ADA[m]):.2f}' if (ADA[-1] - ADA[m])>r else "",
f'SBD {(SBD[-1] - SBD[m]):.2f}' if (SBD[-1] - SBD[m])>r else "",
f'POWR {(POWR[-1] - POWR[m]):.2f}' if (POWR[-1] - POWR[m])>r else "",
f'BTG {(BTG[-1] - BTG[m]):.2f}' if (BTG[-1] - BTG[m])>r else "",
f'ICX {(ICX[-1] - ICX[m]):.2f}' if (ICX[-1] - ICX[m])>r else "",
f'EOS {(EOS[-1] - EOS[m]):.2f}' if (EOS[-1] - EOS[m])>r else "",
f'TRX {(TRX[-1] - TRX[m]):.2f}' if (TRX[-1] - TRX[m])>r else "",
f'SC {(SC[-1] - SC[m]):.2f}' if (SC[-1] - SC[m])>r else "",
f'IGNIS {(IGNIS[-1] - IGNIS[m]):.2f}' if (IGNIS[-1] - IGNIS[m])>r else "",
f'ONT {(ONT[-1] - ONT[m]):.2f}' if (ONT[-1] - ONT[m])>r else "",
f'ZIL {(ZIL[-1] - ZIL[m]):.2f}' if (ZIL[-1] - ZIL[m])>r else "",
f'POLY {(POLY[-1] - POLY[m]):.2f}' if (POLY[-1] - POLY[m])>r else "",
f'ZRX {(ZRX[-1] - ZRX[m]):.2f}' if (ZRX[-1] - ZRX[m])>r else "",
f'LOOM {(LOOM[-1] - LOOM[m]):.2f}' if (LOOM[-1] - LOOM[m])>r else "",
f'BCH {(BCH[-1] - BCH[m]):.2f}' if (BCH[-1] - BCH[m])>r else "",
f'ADX {(ADX[-1] - ADX[m]):.2f}' if (ADX[-1] - ADX[m])>r else "",
f'BAT {(BAT[-1] - BAT[m]):.2f}' if (BAT[-1] - BAT[m])>r else "",
f'IOST {(IOST[-1] - IOST[m]):.2f}' if (IOST[-1] - IOST[m])>r else "",
f'DMT {(DMT[-1] - DMT[m]):.2f}' if (DMT[-1] - DMT[m])>r else "",
f'RFR {(RFR[-1] - RFR[m]):.2f}' if (RFR[-1] - RFR[m])>r else "",
f'CVC {(CVC[-1] - CVC[m]):.2f}' if (CVC[-1] - CVC[m])>r else "",
f'IQ {(IQ[-1] - IQ[m]):.2f}' if (IQ[-1] - IQ[m])>r else "",
f'IOTA {(IOTA[-1] - IOTA[m]):.2f}' if (IOTA[-1] - IOTA[m])>r else "",
f'MFT {(MFT[-1] - MFT[m]):.2f}' if (MFT[-1] - MFT[m])>r else "",
f'ONG {(ONG[-1] - ONG[m]):.2f}' if (ONG[-1] - ONG[m])>r else "",
f'GAS {(GAS[-1] - GAS[m]):.2f}' if (GAS[-1] - GAS[m])>r else "",
f'UPP {(UPP[-1] - UPP[m]):.2f}' if (UPP[-1] - UPP[m])>r else "",
f'ELF {(ELF[-1] - ELF[m]):.2f}' if (ELF[-1] - ELF[m])>r else "",
f'KNC {(KNC[-1] - KNC[m]):.2f}' if (KNC[-1] - KNC[m])>r else "",
f'BSV {(BSV[-1] - BSV[m]):.2f}' if (BSV[-1] - BSV[m])>r else "",
f'THETA {(THETA[-1] - THETA[m]):.2f}' if (THETA[-1] - THETA[m])>r else "",
f'EDR {(EDR[-1] - EDR[m]):.2f}' if (EDR[-1] - EDR[m])>r else "",
f'QKC {(QKC[-1] - QKC[m]):.2f}' if (QKC[-1] - QKC[m])>r else "",
f'BTT {(BTT[-1] - BTT[m]):.2f}' if (BTT[-1] - BTT[m])>r else "",
f'MOC {(MOC[-1] - MOC[m]):.2f}' if (MOC[-1] - MOC[m])>r else "",
f'ENJ {(ENJ[-1] - ENJ[m]):.2f}' if (ENJ[-1] - ENJ[m])>r else "",
f'TFUEL {(TFUEL[-1] - TFUEL[m]):.2f}' if (TFUEL[-1] - TFUEL[m])>r else "",
f'MANA {(MANA[-1] - MANA[m]):.2f}' if (MANA[-1] - MANA[m])>r else "",
f'ANKR {(ANKR[-1] - ANKR[m]):.2f}' if (ANKR[-1] - ANKR[m])>r else "",
f'AERGO {(AERGO[-1] - AERGO[m]):.2f}' if (AERGO[-1] - AERGO[m])>r else "",
f'ATOM {(ATOM[-1] - ATOM[m]):.2f}' if (ATOM[-1] - ATOM[m])>r else "",
f'TT {(TT[-1] - TT[m]):.2f}' if (TT[-1] - TT[m])>r else "",
f'CRE {(CRE[-1] - CRE[m]):.2f}' if (CRE[-1] - CRE[m])>r else "",
f'SOLVE {(SOLVE[-1] - SOLVE[m]):.2f}' if (SOLVE[-1] - SOLVE[m])>r else "",
f'MBL {(MBL[-1] - MBL[m]):.2f}' if (MBL[-1] - MBL[m])>r else "",
f'TSHP {(TSHP[-1] - TSHP[m]):.2f}' if (TSHP[-1] - TSHP[m])>r else "",
f'WAXP {(WAXP[-1] - WAXP[m]):.2f}' if (WAXP[-1] - WAXP[m])>r else "",
f'HBAR {(HBAR[-1] - HBAR[m]):.2f}' if (HBAR[-1] - HBAR[m])>r else "",
f'MED {(MED[-1] - MED[m]):.2f}' if (MED[-1] - MED[m])>r else "",
f'MLK {(MLK[-1] - MLK[m]):.2f}' if (MLK[-1] - MLK[m])>r else "",
f'STPT {(STPT[-1] - STPT[m]):.2f}' if (STPT[-1] - STPT[m])>r else "",
f'ORBS {(ORBS[-1] - ORBS[m]):.2f}' if (ORBS[-1] - ORBS[m])>r else "",
f'VET {(VET[-1] - VET[m]):.2f}' if (VET[-1] - VET[m])>r else "",
f'CHZ {(CHZ[-1] - CHZ[m]):.2f}' if (CHZ[-1] - CHZ[m])>r else "",
f'PXL {(PXL[-1] - PXL[m]):.2f}' if (PXL[-1] - PXL[m])>r else "",
f'STMX {(STMX[-1] - STMX[m]):.2f}' if (STMX[-1] - STMX[m])>r else "",
f'DKA {(DKA[-1] - DKA[m]):.2f}' if (DKA[-1] - DKA[m])>r else "",
f'HIVE {(HIVE[-1] - HIVE[m]):.2f}' if (HIVE[-1] - HIVE[m])>r else "",
f'KAVA {(KAVA[-1] - KAVA[m]):.2f}' if (KAVA[-1] - KAVA[m])>r else "",
f'AHT {(AHT[-1] - AHT[m]):.2f}' if (AHT[-1] - AHT[m])>r else "",
f'LINK {(LINK[-1] - LINK[m]):.2f}' if (LINK[-1] - LINK[m])>r else "",
f'XTZ {(XTZ[-1] - XTZ[m]):.2f}' if (XTZ[-1] - XTZ[m])>r else "",
f'BORA {(BORA[-1] - BORA[m]):.2f}' if (BORA[-1] - BORA[m])>r else "",
f'JST {(JST[-1] - JST[m]):.2f}' if (JST[-1] - JST[m])>r else "",
f'CRO {(CRO[-1] - CRO[m]):.2f}' if (CRO[-1] - CRO[m])>r else "",
f'TON {(TON[-1] - TON[m]):.2f}' if (TON[-1] - TON[m])>r else "",
f'SXP {(SXP[-1] - SXP[m]):.2f}' if (SXP[-1] - SXP[m])>r else "",
f'LAMB {(LAMB[-1] - LAMB[m]):.2f}' if (LAMB[-1] - LAMB[m])>r else "",
f'HUNT {(HUNT[-1] - HUNT[m]):.2f}' if (HUNT[-1] - HUNT[m])>r else "",
f'MARO {(MARO[-1] - MARO[m]):.2f}' if (MARO[-1] - MARO[m])>r else "",
f'PLA {(PLA[-1] - PLA[m]):.2f}' if (PLA[-1] - PLA[m])>r else "",
f'DOT {(DOT[-1] - DOT[m]):.2f}' if (DOT[-1] - DOT[m])>r else "",
f'SRM {(SRM[-1] - SRM[m]):.2f}' if (SRM[-1] - SRM[m])>r else "",
f'MVL {(MVL[-1] - MVL[m]):.2f}' if (MVL[-1] - MVL[m])>r else "",
f'PCI {(PCI[-1] - PCI[m]):.2f}' if (PCI[-1] - PCI[m])>r else "",
f'STRAX {(STRAX[-1] - STRAX[m]):.2f}' if (STRAX[-1] - STRAX[m])>r else "",
f'AQT {(AQT[-1] - AQT[m]):.2f}' if (AQT[-1] - AQT[m])>r else "",
f'BCHA {(BCHA[-1] - BCHA[m]):.2f}' if (BCHA[-1] - BCHA[m])>r else "",
f'GLM {(GLM[-1] - GLM[m]):.2f}' if (GLM[-1] - GLM[m])>r else "",
f'QTCON {(QTCON[-1] - QTCON[m]):.2f}' if (QTCON[-1] - QTCON[m])>r else "",
f'SSX {(SSX[-1] - SSX[m]):.2f}' if (SSX[-1] - SSX[m])>r else "",
f'META {(META[-1] - META[m]):.2f}' if (META[-1] - META[m])>r else "",
f'OBSR {(OBSR[-1] - OBSR[m]):.2f}' if (OBSR[-1] - OBSR[m])>r else "",
f'FCT2 {(FCT2[-1] - FCT2[m]):.2f}' if (FCT2[-1] - FCT2[m])>r else "",
f'LBC {(LBC[-1] - LBC[m]):.2f}' if (LBC[-1] - LBC[m])>r else "",
f'CBK {(CBK[-1] - CBK[m]):.2f}' if (CBK[-1] - CBK[m])>r else "",
f'SAND {(SAND[-1] - SAND[m]):.2f}' if (SAND[-1] - SAND[m])>r else "",
f'HUM {(HUM[-1] - HUM[m]):.2f}' if (HUM[-1] - HUM[m])>r else "",
f'DOGE {(DOGE[-1] - DOGE[m]):.2f}' if (DOGE[-1] - DOGE[m])>r else "",
f'STRK {(STRK[-1] - STRK[m]):.2f}' if (STRK[-1] - STRK[m])>r else "",
f'PUNDIX {(PUNDIX[-1] - PUNDIX[m]):.2f}' if (PUNDIX[-1] - PUNDIX[m])>r else "",
f'FLOW {(FLOW[-1] - FLOW[m]):.2f}' if (FLOW[-1] - FLOW[m])>r else "",
f'DAWN {(DAWN[-1] - DAWN[m]):.2f}' if (DAWN[-1] - DAWN[m])>r else "",
f'AXS {(AXS[-1] - AXS[m]):.2f}' if (AXS[-1] - AXS[m])>r else "",
f'STX {(STX[-1] - STX[m]):.2f}' if (STX[-1] - STX[m])>r else ""], loc='upper left', ncol=3, fontsize=6)
# plt.legend(loc='best', ncol=2, fontsize=14, frameon=True, shadow=True)
# f'ETH {(ETH[-1] - ETH[-5]):.2f}',
# f'ARK {(ARK[-1] - ARK[-5]):.2f}',
# f'MTL {(MTL[-1] - MTL[-5]):.2f}',
# f'ADA {(ADA[-1] - ADA[-5]):.2f}',
# f'XRP {(XRP[-1] - XRP[-5]):.2f}',
# f'ETC {(ETC[-1] - ETC[-5]):.2f}',
# f'EOS {(EOS[-1] - EOS[-5]):.2f}',
# f'AQT {(AQT[-1] - AQT[-5]):.2f}',
# f'AERGO {(AERGO[-1] - AERGO[-5]):.2f}',
# f'XEM {(XEM[-1] - XEM[-5]):.2f}',
# f'DOGE {(DOGE[-1] - DOGE[-5]):.2f}',
# f'SBD {(SBD[-1] - SBD[-5]):.2f}'])
plt.grid()
# plt.grid(which="major",alpha=0.6)
# plt.grid(which="minor",alpha=0.3)
# plt.grid(True, axis='y')
# print(y)
# plt.scatter(x, y)
# # print(x,y)
# # plt.plot(x, y)
# plt.pause(1)
plt.pause(60)
time.sleep(60)
plt.show()