[업비트 WS] 1분, 20분 등락율 실시간 확인하기

 

import pyupbit
import uuid
import json
import asyncio
import websockets
import time

def get_all_ticker():
    krw_ticker = pyupbit.get_tickers(fiat="KRW")
    print('krw_ticker :',krw_ticker)
    return krw_ticker

async def upbit_ticker():
    All_ticker = get_all_ticker()
    price_dict = {}
    start_prices = {}
    historical_prices = {}

    t = time.strftime("%M")

    while True:
        try:
            async with websockets.connect('wss://api.upbit.com/websocket/v1', ping_interval=None, ping_timeout=30,
                                          max_queue=10000) as websocket:
                subscribe_fmt = [
                    {'ticket': str(uuid.uuid4())[:6]},
                    {
                        'type': 'ticker',
                        'codes': All_ticker,
                        'isOnlyRealtime': True
                    },
                ]
                subscribe_data = json.dumps(subscribe_fmt)
                await websocket.send(subscribe_data)

                while True:
                    try:
                        data = json.loads(await websocket.recv())
                        ticker = data['code']

                        trade_price = data.get('trade_price', None)
                        if trade_price is not None:
                            price_dict[ticker] = trade_price

                        if t != time.strftime("%M"):
                            if start_prices:
                                increase_list = []
                                for tk, current_price in price_dict.items():
                                    if tk in start_prices and start_prices[tk] != 0:
                                        increase_rate = (current_price - start_prices[tk]) / start_prices[tk]
                                        increase_list.append((tk, increase_rate))

                                increase_list.sort(key=lambda x: x[1], reverse=True)
                                print(f"\n----- {time.strftime('%H:%M')} -----\n[1분 동안 가장 많이 상승한 종목 Top 5]")
                                for i, (tk, rate) in enumerate(increase_list[:5], start=1):
                                    print(f"{i}위: {tk:<12}, 상승률: {rate * 100:.2f}%")
                            else:
                                print("처음 측정 중이므로 비교 데이터가 없습니다.")


                            for tk, p in price_dict.items():
                                if tk not in historical_prices:
                                    historical_prices[tk] = []
                                historical_prices[tk].append(p)
                                if len(historical_prices[tk]) > 20:
                                    historical_prices[tk].pop(0)

                            increase_list_20min = []
                            for tk, prices in historical_prices.items():
                                if len(prices) > 1 and prices[0] != 0:
                                    twenty_min_increase = (prices[-1] - prices[0]) / prices[0]
                                    increase_list_20min.append((tk, twenty_min_increase))

                            if increase_list_20min:
                                increase_list_20min.sort(key=lambda x: x[1], reverse=True)
                                print("\n20분간 가장 많이 상승한 상위 5개 종목:")
                                for i, (tk, rate) in enumerate(increase_list_20min[:5], start=1):
                                    print(f"{i}위: {tk:<12}, 상승률: {rate * 100:.2f}%")
                            else:
                                print("20분 비교를 위한 충분한 데이터가 없습니다.")

                            start_prices = price_dict.copy()
                            t = time.strftime("%M")

                    except asyncio.CancelledError:
                        print("upbit_ticker 작업이 취소되었습니다.")
                        raise
                    except Exception as e:
                        print(f"upbit_ticker 예외가 발생했습니다: {e}")
                        raise

        except asyncio.CancelledError:
            print("upbit_ticker 작업이 취소되었습니다.")
            raise
        except Exception as e:
            print(f"upbit_ticker 웹소켓 연결 예외가 발생했습니다: {e}")
            raise
        finally:
            print("upbit_ticker 웹소켓 연결을 종료합니다.")

async def main():
    tasks = [
        asyncio.create_task(upbit_ticker())
    ]
    try:
        await asyncio.gather(*tasks)
    except asyncio.CancelledError:
        print("메인 작업이 취소되었습니다.")
        for task in tasks:
            task.cancel()
        await asyncio.gather(*tasks, return_exceptions=True)
    except Exception as e:
        print(f"메인 함수에서 예외가 발생했습니다: {e}")
    finally:
        print("메인 함수의 작업이 종료되었습니다.")

if __name__ == '__main__':
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        print("프로그램을 종료합니다.")

 

사용하시려면 터미널에서 라이브러리를 설치해야 합니다.

pip install pyupbit

 

 

출력 결과

처음 측정 중이므로 비교 데이터가 없습니다.
20분 비교를 위한 충분한 데이터가 없습니다.

----- 21:54 -----
[1분 동안 가장 많이 상승한 종목 Top 5]
1위: KRW-AKT     , 상승률: 0.48%
2위: KRW-UNI     , 상승률: 0.45%
3위: KRW-ATH     , 상승률: 0.43%
4위: KRW-PEPE    , 상승률: 0.28%
5위: KRW-AQT     , 상승률: 0.28%

20분간 가장 많이 상승한 상위 5개 종목:
1위: KRW-AKT     , 상승률: 0.48%
2위: KRW-UNI     , 상승률: 0.45%
3위: KRW-ATH     , 상승률: 0.43%
4위: KRW-PEPE    , 상승률: 0.28%
5위: KRW-AQT     , 상승률: 0.28%

----- 21:55 -----
[1분 동안 가장 많이 상승한 종목 Top 5]
1위: KRW-MBL     , 상승률: 0.45%
2위: KRW-STRAX   , 상승률: 0.27%
3위: KRW-DOGE    , 상승률: 0.23%
4위: KRW-TT      , 상승률: 0.21%
5위: KRW-ATOM    , 상승률: 0.21%

20분간 가장 많이 상승한 상위 5개 종목:
1위: KRW-UNI     , 상승률: 0.64%
2위: KRW-MBL     , 상승률: 0.45%
3위: KRW-AKT     , 상승률: 0.44%
4위: KRW-ATH     , 상승률: 0.43%
5위: KRW-PEPE    , 상승률: 0.28%

 

20분 상승 순위는 바이낸스와 마찬가지로

코드를 실행한지 20분이 지나기 전까지는

코드를 실행한 시간을 기준으로의 상승률이 됩니다.

(첫 1분은 1분 상승률과 동일하게 나옵니다)

 

바이낸스와 달리 티커를 가져올 떄 당시 가격도 가져오지 못하기에

코드를 실행한 첫 1분은 기준이 될 첫 가격을 업데이트 하느라

순위는 2분이 되는 시간부터 출력하게 됩니다.