주식분석도구 업그레이드 - 보유주식검토, 상태바 추가

 

사람은 전혀 이성적이지 않다. 특히 투자의 세계에서는 감정으로 인해 잘못된 판단을 할 수 있다.

 

주식투자분석도구를 만든 이유도 이처럼 불완전한 내 자신을 못 믿기 때문에 뭔가 기계적인 투자수단이 필요해서이다.

 

내가 산 주가를 계속 보고 있으면 감정에 영향을 많이 받는다. 그래서 되도록 MTS를 열지 않으려고 한다. 대신 내가 산 주식의 상황은 알아야 하기에 배당률을 기준으로 내가 산 주식의 상태를 표시했다.

 

좀 더 직관적으로 보기 위해 주식마다 각 단계별로 Comment를 표시했다.

 

그리고 qt desinger에서 메인위젯을 QMainDialog 에서 QMainWindow로 바꿨다. 이제 창을 숨기기 할 수 있다.

 

항상 생각하지만 나는 전문 프로그래머가 아니다. 프로그래밍에 재능도 없다. 다만, 일반 보통 사람보다 조금 더 잘 할 뿐이고, 활용능력은 비교적 뛰어나다. 이 툴 또한 일종의 '클루지'다. 

 

전문 투자자들 보다 못하지만, 일반 투자자 보다는 비교적 조금 더 지식과 경험이 있다. 이 또한 나에게 큰 장점이다.

 

이 두가지 장점을 합치면 꽤 괜찮은 장점이 된다.  그래서 그런 방향으로 계속 나 스스로를 발전해 가고 있다.

 

import sys
from PyQt5.QtWidgets import *
from PyQt5 import uic
from pykrx import stock
from datetime import datetime, timedelta
import matplotlib.pyplot as plt
import pandas as pd
from pandas_datareader import data as pdr
import time
import numpy as np
import sqlite3
import random
 
ui = '주식분석도구.ui'
 
class MainWindow(QMainWindow):
    def __init__(self):
        QMainWindow.__init__(self, None)
        uic.loadUi(ui, self)
 
        self.btn.clicked.connect(self.input_data)
        self.btn_ex_kospi.clicked.connect(self.kospi_ex)
        self.btn_div.clicked.connect(self.filtered_by_div)
        self.btn_diff_tr.clicked.connect(self.diff_tr_kospi)
        self.btn_dns.clicked.connect(self.dns)
        self.btn_my_div.clicked.connect(self.my_div)
 
    def input_data(self):
 
        end = str(datetime.today()).split('-')
        end = end[0] + end[1] + end[2][:2]  # 날짜를 'yyyymmdd' str 형태로 변환
        print(end)
 
        # 이름을 받아서 code 입력
        def code_by_name(name, date):
            codes = stock.get_market_ticker_list(date, market='ALL')
 
            li_code = []
            for code in codes:
                company = stock.get_market_ticker_name(code)
                li_code.append(company)
 
            dic_code = dict(zip(li_code, codes))
 
            if name in dic_code:
                code = dic_code[name]
                return code
 
        name = self.le_name.text()
        code = code_by_name(name, end)
        self.textEdit.clear()
        self.lbl_code.setText(code)
 
        if not self.le_start.text(): #le_start 가 비었으면
            start = int(end[:4])-10 #10년 전부터 시작
            start = str(start) + '0101'
        else:
            start = self.le_start.text() #아니면 원하는 날짜에 시작
 
        df_f = stock.get_market_fundamental(start[:4] + '1230', end, code, freq='y')  # BPS, PER, PBR, EPS, DIV, DPS
        df_f = df_f['DPS']
 
        # 년도별 배당금 표시하기
        dps_li = []
        try:
            for y in range(int(start[:4]), int(end[:4]) + 1):
                day = stock.get_nearest_business_day_in_a_week(str(y) + '0530')
                df_f = stock.get_market_fundamental_by_ticker(date=day, market='ALL')  # BPS, PER, PBR, EPS, DIV, DPS
                df_f = df_f.loc[code]  # 원하는 종목의 코드에 해당하는 데이터만 필터
                print(df_f)
                dps = int(df_f['DPS'])  # 배당금을 dps 변수에 저장
                dps_li.append([y - 1, dps])  # 년도와 배당금을 리스트로 저장(년도는 전년도로 저장)
 
        except:
            pass
        print(dps_li)
 
        for data in dps_li:
            exist = self.textEdit.toPlainText()
            self.textEdit.setText(exist + '연도 : ' + str(data[0]) + ' / 배당금 : ' + str(format(data[1], ",")) + '\n')
 
        # 주가, 배당수익률 비교 그래프
        df_f = stock.get_market_fundamental(start, end, code, freq='d')  # BPS, PER, PBR, EPS, DIV, DPS
        name = stock.get_market_ticker_name(code)
        df_f = df_f['DIV']
 
        df_p = stock.get_market_ohlcv(start, end, code)
        df_p = df_p['종가']
 
        df_t = pd.merge(df_p, df_f, left_index=True, right_index=True)
        df_t.columns = ['price', 'DIV']
        p_max = str(format(df_t['price'].max(),","))
        p_min = str(format(df_t['price'].min(),","))
        d_max = str(round(df_t['DIV'].max(), 3))
        d_min = str(round(df_t['DIV'].min(), 3))
        price = str(format(df_t['price'].iloc[-1],","))
        div = str(round(df_t['DIV'].iloc[-1], 3))
 
        self.lbl_pmax.setText(p_max)
        self.lbl_pmin.setText(p_min)
        self.lbl_dmax.setText(d_max)
        self.lbl_dmin.setText(d_min)
        self.lbl_price.setText(price)
        self.lbl_div.setText(div)
        self.le_start.setText(start)
 
        plt.rcParams['figure.figsize'] = (16, 9)
 
        fig, ax1 = plt.subplots()
        ax1.set_xlabel('Date')
        ax1.set_ylabel('price')
        ax1.plot(df_t.index, df_t['price'], color='red', label='Price')
        ax1.legend(loc='upper left')
 
        ax2 = ax1.twinx()
        ax2.set_ylabel('DIV')
        ax2.plot(df_t.index, df_t['DIV'], color='blue', label='DIV')
        ax2.legend(loc='upper right')
        plt.title(name)
        plt.show()
 
    def kospi_ex(self):
        ex = pdr.get_data_yahoo('USDKRW=X', '2000-01-04')  # 환율데이터 가져오기
        kospi = pdr.get_data_yahoo('^KS11', '2000-01-04')  # KOSPI 데이터 가져오기
 
        df = pd.DataFrame({'KOSPI': kospi['Adj Close'], 'Exchange': ex['Adj Close']})
        df.dropna(inplace=True)
 
        plt.rcParams['figure.figsize'] = (16, 9)
 
        fig, ax1 = plt.subplots()
        ax1.set_xlabel('DATE')
        ax1.set_ylabel('KOSPI')
        ax1.plot(df.index, df['KOSPI'], color='red', label='KOSPI INDEX')
        ax1.legend(loc='upper right')
 
        ax2 = ax1.twinx()
        ax2.set_ylabel('Exchange Rate')
        ax2.plot(df.index, df['Exchange'], color='blue', label='Exchange Rate')
        ax2.legend(loc='lower right')
 
        plt.title('Exchange Rate VS KOSPI Index')
 
        exchange = round(df['Exchange'][-1], 2)
        kospi_index = round(df['KOSPI'][-1], 2)
        date = df.index[-1]
 
        self.lbl_date.setText(str(date))
        self.lbl_kospi.setText(str(kospi_index))
        self.lbl_ex.setText(str(exchange))
 
        plt.show()
 
    # 배당수익률을 기준으로 종목 선정하기
    def filtered_by_div(self):
 
        con = sqlite3.connect('krx_data.db')
 
        # 오늘날짜 기준으로 아직 받지않은 Data를 DB에 다운로드 받기
        # 영업일을 List로 가져오기
        def make_date_list(start, end):
            start = datetime.strptime(start, '%Y%m%d')
            end = datetime.strptime(end, '%Y%m%d')
            dates = [(start + timedelta(days=i)).strftime('%Y%m%d') for i in range((end - start).days + 1)]
            b_dates = []
            for d in dates:
                b_day = stock.get_nearest_business_day_in_a_week(d)
                if not b_day in b_dates:
                    b_dates.append(b_day)
                    s = random.randint(1, 3)
                    time.sleep(s)
 
            return b_dates
 
        # Data를 다운로드 받기
        def data_download(date):
            codes = stock.get_market_ticker_list(date, market='ALL')  # code list 만들기
            corp = []  # Code와 Name을 저장할 List
            for code in codes:
                name = stock.get_market_ticker_name(code)  # 종목 이름 가져오기
                corp.append([code, name])  # Code와 이름으로 리스트를 만들기
            df1 = pd.DataFrame(data=corp, columns=['code', '종목명'])  # code와 종목명을 데이터프레임으로 만들기
            df1.index = df1['code']  # index를 코드로 만들기
 
            df_f = stock.get_market_fundamental_by_ticker(date=date,
                                                          market='ALL')  # BPS, PER, PBR, EPS, DIV, DPS 가져와서 데이터 프레임 만들기
            df_c = stock.get_market_cap_by_ticker(date=date, market='ALL')  # 종가, 시가총액, 거래량, 거래대금, 상장주식수 가져오기
 
            time.sleep(1)
 
            df = pd.merge(df1, df_c, left_index=True, right_index=True)  # 종목명, 종가, 시가총액, 거래량, 거래대금, 상장주식수
            df = pd.merge(df, df_f, left_index=True, right_index=True)  # 위에 df + PER, PBR...
            # column은 '종목명', '종가', '시가총액', '거래량', '거래대금', '상장주식수', 'BPS', 'PER', 'PBR', 'EPS', 'DIV', 'DPS'
 
            df['일자'] = np.array([date] * len(df))
            df = df.set_index('일자')
 
            return df
 
        # DB에서 마지막 행 구하기
        db_last_df = pd.read_sql("SELECT 일자, code, 종목명, DIV, DPS FROM fundamental ORDER BY ROWID DESC LIMIT 1", con)
        db_last_date = db_last_df['일자'].iloc[0]  # 마지막 행에서 날짜 구하기
        db_last_date = datetime.strptime(db_last_date, '%Y%m%d')
        start_date = (db_last_date + timedelta(days=1)).strftime('%Y%m%d')
 
        # 오늘날짜 구하기
        today = datetime.today().strftime('%Y%m%d')
        end_date = stock.get_nearest_business_day_in_a_week(today, prev=True)
 
        # 데이터 받아서 데이터프레임으로 합치고, DB에 저장
        if start_date < end_date:
            try:
                dates = make_date_list(start_date, end_date)
                print(dates)
                for n, date in enumerate(dates):
                    print(date)
                    if n == 0:
                        t_df = data_download(date)
                    else:
                        t_df = pd.concat([t_df, data_download(date)])
                    time.sleep(1)  # 혹시나 차단될 수 있으니깐
                print(t_df)
                con = sqlite3.connect("krx_data.db")
                t_df.to_sql('fundamental', con, if_exists='append')
            except:
                pass
 
        # 과거 10년간의 Dataframe 구하기
        def filter_by_period(today, ticker):
            start = str(int(today[:4]) - 10) + today[-4:]
            end = str(today)
            df = pd.read_sql("SELECT 일자, code, 종목명, DIV, DPS FROM fundamental WHERE code = '" + ticker + "'" +
                             " AND 일자 >= " + start + " AND 일자 < " + end, con)
            return df
 
        div = self.le_div.text()
 
        today_df = pd.read_sql("SELECT 일자 FROM fundamental ORDER BY ROWID DESC LIMIT 1", con)
        # DB에서 마지막 행 구하기
        today = today_df['일자'].iloc[0]  # 마지막 행에서 날짜 구하기
        today_df = pd.read_sql("SELECT 일자, code, 종목명, DIV, DPS, EPS FROM fundamental WHERE 일자 = "
                               + today + " AND EPS > 0" + " AND DPS > 0 AND DIV > " +
                               str(div), con)
 
        # 오늘 날짜 기준으로 Data를 분석하기
        to_see_codes = []
        count = 0
        for code in today_df['code']:
            try:
                print(len(today_df['code']) - count)
                t_df = today_df[today_df['code'] == code]
                name = t_df['종목명'].iloc[0]
                t_div = t_df['DIV'].iloc[0]  # 기준일자의 DIV
 
                df = filter_by_period(today, code)
                m = int(len(df['DPS']) / 2)
                if df['DPS'].iloc[0] <= df['DPS'].iloc[-1] and df['DPS'].iloc[0] != 0 and \
                        df['DPS'].iloc[m] <= df['DPS'].iloc[-1]:
                    if df['DIV'].max() * 0.9 < t_div:
                        to_see_codes.append([today, code, name, t_div])
            except:
                pass
            count += 1
 
        total_df = pd.DataFrame(data=to_see_codes, columns=['기준일', 'Code', '종목명', '배당률'])
        print(total_df)
        for i in range(len(total_df)):
            print(i)
            exist = self.te_div.toPlainText()
            self.te_div.setText(exist + '기준일 : ' + str(total_df['기준일'].iloc[i]) +
                                ' / CODE : ' + str(total_df['Code'].iloc[i]) +
                                ' / 종목명 : ' + str(total_df['종목명'].iloc[i]) +
                                ' / 배당률 : ' + str(round(total_df['배당률'].iloc[i], 2)) + '\n')
 
        total_df.to_excel('배당률로 선별한 종목 DIV ' + str(div) + '이상' + today + '.xlsx')
 
    # 장단기 미국채권 금리차와 코스피지수 비교
    def diff_tr_kospi(self):
        kospi = pdr.get_data_yahoo('^KS11', '2000-01-04')
        irx = pdr.get_data_yahoo('^IRX', '2000-01-04')  # 미국 3개월물 국채금리
        tnx = pdr.get_data_yahoo('^TNX', '2000-01-04')  # 미국 10년물 국채금리
 
        df = pd.DataFrame({'KOSPI': kospi['Adj Close'], '3MT': irx['Adj Close'], '10YT': tnx['Adj Close']})
        df['10YT-3MT'] = df['10YT'] - df['3MT']
        df = df[['KOSPI', '10YT-3MT']]
        df.dropna(inplace=True)
 
        self.lbl_kospi_index.setText(str('{:0,.2f}'.format(int(df['KOSPI'].iloc[-1]))))  # 최근 코스피지수
        self.lbl_diff_tr.setText(str(round(df['10YT-3MT'].iloc[-1], 2)))  # 최근 미국채권 장단기금리 차
        minus_df = df[df['10YT-3MT'] < 0]  # 금리가 역전된 최근 일자의 데이터 프레임
        self.lbl_diff_rate.setText(str('{0:,.2f}'.format(minus_df['10YT-3MT'].iloc[-1]))) # 최근 마이너스 금리차
        self.lbl_diff_date.setText(datetime.strftime(minus_df.index[-1], '%Y%m%d'))  # 최근 금리차 역전된 날짜
 
        plt.rcParams['figure.figsize'] = (16, 9)
 
        fig, ax1 = plt.subplots()
        ax1.set_xlabel('DATE')
        ax1.set_ylabel('KOSPI')
        ax1.plot(df.index, df['KOSPI'], color='red', label='KOSPI INDEX')
        ax1.legend(loc='upper right')
 
        ax2 = ax1.twinx()
        ax2.set_ylabel('10YT-3MT')
        ax2.plot(df.index, df['10YT-3MT'], color='blue', label='10Y - 3M Treasury')
        ax2.legend(loc='lower right')
 
        plt.title('USA 10Year-3Month Treasury VS KOSPI')
 
        plt.show()
 
    # DOW, NASDAQ, S&P500 지수 보여주기
    def dns(self):
        dow = pdr.get_data_yahoo('^DJI', '2000-01-04')
        snp = pdr.get_data_yahoo('^GSPC', '2000-01-04')
        nasdaq = pdr.get_data_yahoo('^IXIC', '2000-01-04')
 
        df = pd.DataFrame({'DOW': dow['Adj Close'], 'S&P500': snp['Adj Close'], 'NASDAQ': nasdaq['Adj Close']})
 
        self.lbl_dow.setText(str('{:0,.2f}'.format(df['DOW'].iloc[-1])))
        self.lbl_snp.setText(str('{:0,.2f}'.format(df['S&P500'].iloc[-1])))
        self.lbl_nasdaq.setText(str('{:0,.2f}'.format(df['NASDAQ'].iloc[-1])))
 
        plt.rcParams['figure.figsize'] = (16, 9)
 
        fig, ax1 = plt.subplots()
        ax1.set_xlabel('DATE')
        ax1.set_ylabel('DOW, NASDAQ')
        ax1.plot(df.index, df['DOW'], color='red', label='DOW')
        ax1.plot(df.index, df['NASDAQ'], color='blue', label='NASDAQ')
        ax1.legend(loc='upper left')
 
        ax2 = ax1.twinx()
        ax2.set_ylabel('S&P500')
        ax2.plot(df.index, df['S&P500'], color='black', label='S&P500')
        ax2.legend(loc='center right')
 
        plt.title('DOW & NASDAQ & S&P500')
 
        plt.show()
 
    # 보유주식 검토
    def my_div(self):
        today = datetime.today()
        today = datetime.strftime(today, '%Y%m%d')  # 오늘일자를 str으로
        start = str(int(today[:4]) - 10) + today[-4:]  # 10년전 날짜
 
        self.lbl_my_today.setText(today)
 
        codes = ['009150', '044450', '005090', '130580', '003540', '029780', '214320']
 
        i = 1
        for code in codes:
 
            name = stock.get_market_ticker_name(code)
            df = stock.get_market_fundamental(start, today, code, freq='d')
            div_max = round(df['DIV'].max(), 2)
            div_base = round(div_max * 0.9, 2)
            div_today = round(df['DIV'].iloc[-1], 2)
            div_min = round(df['DIV'].min(), 2)
            div_min_base = round(div_min * 1.1, 2)
 
            # 매수, 매도, 보유 판단하기
            if div_max <= div_today:
                comment = '  (적극매수)   '
            elif div_base <= div_today:
                comment = '  (매수시작)   '
            elif div_base * 0.8 < div_today:
                comment = '  (매수관심)   '
            elif div_min * 0.7 > div_today:
                comment = '  (매도관심)   '
            elif div_min * 0.8 > div_today:
                comment = ' (1차 매도시작) '
            elif div_min_base >= div_today:
                comment = ' (2차 매도시작) '
            elif div_min >= div_today:
                comment = '   (적극매도)   '
            else:
                comment = '  (No Action) '
 
            # TextEdit에 표시
            exist = self.te_my_div.toPlainText()
            self.te_my_div.setText(exist + '[' + code + '  ' + name + ']  ' + comment + '   <<오늘 DIV : ' +
                                   str(div_today) + '>>  /  Max : ' + str(div_max) + '  /  90% Max : ' +
                                   str(div_base) + '  /  Min : ' + str(div_min) + '  /  110% Min : ' +
                                   str(div_min_base) + '\n')
 
            self.prb.setValue(int(i / len(codes) * 100))  # 진행 상태바 표시
 
            i += 1
 
if __name__ == '__main__':
    app = QApplication(sys.argv)
    Window = MainWindow()
    Window.show()
    app.exec_()