def All_stock():
df = stock.get_market_ohlcv_by_ticker('20210217', market='KOSPI')
list_of_index = [item for item in df.index]
ticker = sorted(list_of_index) #종목코드 오름차순
ticker_name = [stock.get_market_ticker_name(i) for i in ticker] # 종목명 오름차순
return ticker, ticker_name
async def fluctuation_stock_list(qDate: Optional[str] = None):
date = getRecentDay()
if qDate:
date = qDate
df = stock.get_market_ohlcv_by_ticker(date)
result = []
df_index = df.index
df_arr = df._series
start_price = df_arr.get('시가').values.tolist()
highest_price = df_arr.get('고가').values.tolist()
lowest_price = df_arr.get('저가').values.tolist()
end_price = df_arr.get('종가').values.tolist()
volume = df_arr.get('거래량').values.tolist()
transaction_price = df_arr.get('거래대금').values.tolist()
fluctuation_rate = df_arr.get('등락률').values.tolist()
for i, index in enumerate(df_index):
result.append({
'ticker': index,
'start_price': start_price[i],
'highest_price': highest_price[i],
'lowest_price': lowest_price[i],
'end_price': end_price[i],
'volume': volume[i],
'transaction_price': transaction_price[i],
'fluctuation_rate': fluctuation_rate[i]
})
return {
'data': result,
}
def update_stockData(): # TODO: tail 제거
'''
라벨링이 되지 않은 상태로 업데이트되므로, 대신 update_stockData_with_labels()를 사용하세요.
'''
# pd_가 붙은 것은 pd.timestamp, 붙지 않은 것은 'YYYY-MM-DD' 형식의 str
pd_lastSavedDate = tail(open('resources/ohlcv/950200.csv'), 1)
pd_lastSavedDate = pd_lastSavedDate[1][:10]
pd_lastSavedDate = pd.to_datetime(pd_lastSavedDate)
pd_destDate = pd.Timestamp.now()
pd_destDate = pd.to_datetime(pd_destDate.date())
# 데이터를 갱신할 날짜 범위
pd_last_p1 = pd_lastSavedDate + pd.Timedelta(days=1)
pd_dateRange = pd.date_range(pd_last_p1, pd_destDate)
for pd_date in pd_dateRange:
df_update = get_market_ohlcv_by_ticker(pd_date)
if not len(df_update): # 장이 열리지 않은 날이면 skip
continue
df_update = df_update.reset_index()
for stock_ in df_update.iloc:
stock_code = stock_['종목코드']
filename = f'resources/ohlcv/{stock_code}.csv'
str_date = str(pd_date.date())
if (isfile(filename)):
with open(filename, 'a', encoding='UTF-8') as f:
f.write(
f"{str_date},{stock_['시가']},{stock_['고가']},{stock_['저가']},{stock_['종가']},{stock_['거래량']}\n")
else:
new_stock = get_market_ohlcv_by_date(
"20120101", pd_date, stock_code)
new_stock.to_csv(filename, encoding='UTF-8')
sleep(1)
def test_ohlcv_for_a_day(self):
df = stock.get_market_ohlcv_by_ticker("20210122")
# 시가 고가 저가 종가 거래량 거래대금 등락률
# 티커
# 095570 4190 4245 4160 4210 216835 910274405 0.839844
# 006840 25750 29550 25600 29100 727088 20462325950 12.570312
# 027410 5020 5250 4955 5220 1547629 7990770515 4.191406
# 282330 156500 156500 151500 152000 62510 9555364000 -2.560547
temp = df.iloc[0:5, 0] == np.array([4190, 25750, 5020, 156500, 5720])
self.assertEqual(temp.sum(), 5)
temp = df.index[0:5] == np.array(["095570", "006840", "027410", "282330", "138930"])
self.assertEqual(temp.sum(), 5)
def test_io(self):
df = stock.get_market_ohlcv_by_ticker("20180212")
self.assertIsInstance(df.index[0], str)
self.assertIsInstance(df['종목명'].iloc[0], str)
self.assertIsInstance(df['시가'].iloc[0], np.int32)
self.assertIsInstance(df['고가'].iloc[0], np.int32)
self.assertIsInstance(df['저가'].iloc[0], np.int32)
self.assertIsInstance(df['종가'].iloc[0], np.int32)
self.assertIsInstance(df['거래량'].iloc[0], np.int64)
self.assertIsInstance(df['시가총액'].iloc[0], np.int64)
self.assertIsInstance(df['거래대금'].iloc[0], np.int64)
self.assertIsInstance(df['시총비중'].iloc[0], np.float16)
self.assertIsInstance(df['상장주식수'].iloc[0], np.int32)
def test_ohlcv_for_a_day_in_kosdaq(self):
df = stock.get_market_ohlcv_by_ticker("20210122", "KOSDAQ")
# 시가 고가 저가 종가 거래량 거래대금 등락률
# 티커
# 060310 2265 2290 2225 2255 275425 619653305 -0.219971
# 054620 7210 7250 7030 7120 124636 883893780 -1.110352
# 265520 25850 25850 25200 25400 196384 4994644750 -0.779785
# 211270 10250 10950 10050 10350 1664154 17351956900 1.469727
# 035760 165200 166900 162600 163800 179018 29574003100 0.429932
temp = df.iloc[0:5, 0] == np.array([2265, 7210, 25850, 10250, 165200])
self.assertEqual(temp.sum(), 5)
temp = df.index[0:5] == np.array(["060310", "054620", "265520", "211270", "035760"])
self.assertEqual(temp.sum(), 5)
def get_latest_market_ohlcv(today=None, market="ALL"):
if today == None:
today = datetime.datetime.today().strftime("%Y%m%d")
if DEBUG == True: print(get_latest_market_ohlcv.__name__, today)
today_datetime = datetime.datetime.strptime(today, "%Y%m%d")
for i in range(0, RETRY_COUNT):
latest_date = (today_datetime - datetime.timedelta(i)).strftime("%Y%m%d")
if DEBUG: print(latest_date)
result = stock.get_market_ohlcv_by_ticker(latest_date, market)
if result.empty == False:
return result
if DEBUG: print("fail")
return None
def analyzeData(self, anal_type='a', res_tablename='dart2019', std_date='20201116', today='20210305', dept_rate=None):
'''
anal_type
a: 기업분석 > 기준가
b: 가치분석 < 기업가치
c: 영업이익 2년 연속 상승
d: 부채비율 100% 이하
e: 최소 주당가치분석 < 최대 주당기업가치
g: 현재가 추가 데이터
orgin: 원래 데이터
'''
years = ['2017', '2018', '2019', '2020']
if self.is_maria == False:
self._setMaria()
df = self.maria.showData('select * from {}'.format(res_tablename))
if anal_type == 'a':
std_date = std_date
df1 = stock.get_market_ohlcv_by_ticker(std_date)['종가']
df2 = stock.get_market_ohlcv_by_ticker(std_date, market='KOSDAQ')['종가']
df3 = stock.get_market_ohlcv_by_ticker(std_date, market='KONEX')['종가']
price_df = pd.concat([df1, df2, df3]).reset_index(drop=False).rename(columns={'티커': '종목코드', '종가': '기준가격'})
a_df = pd.merge(df[['종목코드', '주당가치분석']], price_df, on=['종목코드'])
a_df = a_df[a_df['주당가치분석'] > a_df['기준가격']][['종목코드', '기준가격']]
return pd.merge(a_df, df, on=['종목코드']).reset_index(drop=True)
elif anal_type == 'b':
return df[df['주당기업가치'] > df['주당가치분석']].reset_index(drop=True)
elif anal_type == 'c':
c_df = pd.DataFrame()
c_df['종목코드'] = df['종목코드']
c_df['{}영업이익성장률'.format(years[1])] = ((df['영업이익{}'.format(years[1])] - df['영업이익{}'.format(years[0])]) / df['영업이익{}'.format(years[0])])*100
c_df['{}영업이익성장률'.format(years[2])] = ((df['영업이익2019'] - df['영업이익{}'.format(years[1])]) / df['영업이익{}'.format(years[1])])*100
c_df = c_df[c_df['{}영업이익성장률'.format(years[1])] > 0]
c_df = c_df[c_df['{}영업이익성장률'.format(years[2])] > 0]
return pd.merge(c_df[['종목코드', '{}영업이익성장률'.format(years[1]), '{}영업이익성장률'.format(years[2])]], df, on=['종목코드']).reset_index(drop=True)
elif anal_type == 'd':
d_df = df[['종목코드', '자본총계{}'.format(years[3]), '부채총계{}'.format(years[3])]]
d_df['부채비율'] = (d_df['부채총계{}'.format(years[3])] / d_df['자본총계{}'.format(years[3])]) * 100
d_df = d_df[d_df['부채비율'] <= dept_rate][['종목코드', '부채비율']]
d_df = d_df[d_df['부채비율'] >= 0]
return pd.merge(d_df, df, on=['종목코드']).reset_index(drop=True)
elif anal_type == 'e':
df[df['본질가치'] > df['주당기업가치']].reset_index(drop=True)
elif anal_type == 'g':
df1 = stock.get_market_ohlcv_by_ticker(today)['종가']
df2 = stock.get_market_ohlcv_by_ticker(today, market='KOSDAQ')['종가']
df3 = stock.get_market_ohlcv_by_ticker(today, market='KONEX')['종가']
price_df = pd.concat([df1, df2, df3]).reset_index(drop=False).rename(columns={'티커': '종목코드', '종가': '최신가격'})
g_df = pd.merge(df[['종목코드', '주당가치분석']], price_df, on=['종목코드'])[['종목코드', '최신가격']]
return pd.merge(g_df, df, on=['종목코드']).reset_index(drop=True)
elif anal_type == 'orgin':
return df
def getMarketOhlcvByTicker(self, date=None, market="ALL"):
if date == None:
return None
# NOTE: 백업 데이터 존재 여부 확인.
if not os.path.isdir(self.dirMarketOhlcv):
os.makedirs(self.dirMarketOhlcv)
filePath = self.dirMarketOhlcv + \
'/marketOhlcv_%s_%s.bin' % (market, date)
if os.path.isfile(filePath):
# NOTE: file 이 있고, corpName 에 해당하는 데이터 있는지 확인.
with open(filePath, 'rb') as f:
marketOhlcv = pickle.load(f)
return marketOhlcv
rawOhlcvList = None
try:
rawOhlcvList = stock.get_market_ohlcv_by_ticker(date, market)
except:
print("[param] date 를 확인해주세요.")
print(
"[위 사항이 아니라면] [KRX API update 가 필요합니다] stock.get_market_ohlcv_by_ticker")
exit()
# NOTE: rawOhlcvList 데이터는 pandas.DataFrame 인데, DaraFrame 전체가 empty 면 rawOhlcvList.empty 는 True 를 리턴 함.
# [refer] https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.empty.html
if rawOhlcvList.empty == True:
return None
resOhlcv = dict()
desc = "get ohlcv"
for ticker in tqdm(rawOhlcvList.index, desc):
corpName = stock.get_market_ticker_name(ticker)
tmpDict = dict()
for column in rawOhlcvList.columns:
tmpDict[column] = str(rawOhlcvList.loc[ticker][column])
resOhlcv[corpName] = tmpDict
# NOTE: 데이터 백업.
with open(filePath, 'wb') as f:
pickle.dump(resOhlcv, f)
return resOhlcv
def computeData(self, fnguide_tablename, signal_tablename, mh_tablename, jb_tablename, dg_tablename, res_tablename):
self._setMaria()
data = {}
std_date = '20201116'
today = '20210305'
res_tablename = res_tablename+std_date
years = ['2017', '2018', '2019', '2020']
for y in years:
data['fnguide{}'.format(y)] = self.maria.showData('select * from {}{}'.format(fnguide_tablename, y))
for y in years[:-1]:
data['new_signal{}'.format(y)] = self.maria.showData('select * from {}{}'.format(signal_tablename, y))
data['dart_mh'] = self.maria.showData('select * from {}'.format(mh_tablename))
data['dart_jb'] = self.maria.showData('select * from {}'.format(jb_tablename))
# 사업보고서가 발표 된다면 사용하지 않음
data['dart_dg_3q'] = self.maria.showData('select * from {}'.format(dg_tablename))
####################################
df = data['fnguide{}'.format(years[3])][['종목코드', '자산', '부채', '자본', '기말현금및현금성자산', '매출액', '영업이익발표기준', '당기순이익', 'GB']]
df = df.rename(columns={'자산': '자산총계{}'.format(years[3]), '부채': '부채총계{}'.format(years[3]), '자본': '자본총계{}'.format(years[3]), '기말현금및현금성자산': '현금성자산', '매출액': '매출액{}'.format(years[3]), '영업이익발표기준': '영업이익{}'.format(years[3]), '당기순이익': '당기순이익{}'.format(years[3])})
tmp = data['fnguide{}'.format(years[0])][['종목코드', '당기순이익', '영업이익발표기준', '자산']]
tmp = tmp.rename(columns={'당기순이익': '당기순이익{}'.format(years[0]), '영업이익발표기준': '영업이익{}'.format(years[0]),'자산': '자산총계{}'.format(years[0])})
df = pd.merge(df, tmp, on=['종목코드'])
tmp = data['fnguide{}'.format(years[1])][['종목코드', '당기순이익', '영업이익발표기준', '자본', '자산', '부채', '유동자산', '유동부채', '매출액']]
tmp = tmp.rename(columns={'당기순이익': '당기순이익{}'.format(years[1]), '영업이익발표기준': '영업이익{}'.format(years[1]), '자본': '자본총계{}'.format(years[1]), '자산': '자산총계{}'.format(years[1]), '부채': '부채총계{}'.format(years[1]), '유동자산': '유동자산{}'.format(years[1]), '유동부채': '유동부채{}'.format(years[1]), '매출액': '매출액{}'.format(years[1])})
df = pd.merge(df, tmp, on=['종목코드'])
tmp = data['fnguide{}'.format(years[2])][['종목코드', '당기순이익', '영업이익발표기준', '자본', '자산', '부채', '유동자산', '유동부채', '매출액']]
tmp = tmp.rename(columns={'당기순이익': '당기순이익{}'.format(years[2]), '영업이익발표기준': '영업이익{}'.format(years[2]), '자본': '자본총계{}'.format(years[2]), '자산': '자산총계{}'.format(years[2]), '부채': '부채총계{}'.format(years[2]), '유동자산': '유동자산{}'.format(years[2]), '유동부채': '유동부채{}'.format(years[2]), '매출액': '매출액{}'.format(years[2])})
df = pd.merge(df, tmp, on=['종목코드'])
# 사업보고서가 발표 된다면 해당년도로 사용
tmp = data['new_signal{}'.format(years[2])][['종목코드', '단기차입금', '장기차입금']]
df = pd.merge(df, tmp, on=['종목코드'])
tmp = data['dart_mh'][['종목코드', 'mh{}'.format(years[2])]]
tmp = tmp.rename(columns={'mh{}'.format(years[2]): '무형자산'})
df = pd.merge(df, tmp, on=['종목코드'])
tmp = data['dart_jb'][['종목코드', 'jb{}'.format(years[2])]]
tmp = tmp.rename(columns={'jb{}'.format(years[2]): '자본금'})
df = pd.merge(df, tmp, on=['종목코드'])
#############################################
df_An = df[df['GB'] == '12']
df_3q = df[df['GB'] == '09'].rename(columns={'당기순이익{}'.format(years[3]): '당기순이익{}_3Q'.format(years[3])})
tmp = data['dart_dg_3q'][['종목코드', 'dg{}_3Q'.format(years[1]), 'dg{}_3Q'.format(years[2])]]
tmp = tmp.rename(columns={'dg{}_3Q'.format(years[1]): '당기순이익{}_3Q'.format(years[1]), 'dg{}_3Q'.format(years[2]): '당기순이익{}_3Q'.format(years[2])})
df_3q = pd.merge(df_3q, tmp, on=['종목코드'])
tmp = df_3q[['종목코드', '당기순이익{}_3Q'.format(years[1]), '당기순이익{}_3Q'.format(years[2]), '당기순이익{}_3Q'.format(years[3])]]
tmp['rate{}'.format(years[2])] = (tmp['당기순이익{}_3Q'.format(years[2])] - tmp['당기순이익{}_3Q'.format(years[1])]) / tmp['당기순이익{}_3Q'.format(years[1])]
tmp['rate{}'.format(years[3])] = (tmp['당기순이익{}_3Q'.format(years[3])] - tmp['당기순이익{}_3Q'.format(years[2])]) / tmp['당기순이익{}_3Q'.format(years[2])]
tmp['당기순이익{}'.format(years[3])] = tmp['당기순이익{}_3Q'.format(years[2])] * (1 + (tmp['rate{}'.format(years[2])] + tmp['rate{}'.format(years[3])]) / 2)
df_3q = pd.merge(df_3q, tmp[['종목코드', '당기순이익{}'.format(years[3])]], on=['종목코드'])
df_3q = df_3q[list(df_An.columns)]
df = pd.concat([df_An, df_3q])
stock_amount_dates = ['20190329', '20200327', std_date]
for y in stock_amount_dates:
data['stock_amount_{}'.format(y)] = stock.get_market_cap_by_ticker(y)[['상장주식수', '시가총액']]
tmp = data['stock_amount_{}'.format(stock_amount_dates[0])].reset_index(drop=False)
tmp.columns = ['종목코드', '상장주식수{}'.format(years[1]), '시가총액{}'.format(years[1])]
tmp['상장주식수{}'.format(years[1])] = tmp['상장주식수{}'.format(years[1])] / 100000000
tmp['시가총액{}'.format(years[1])] = tmp['시가총액{}'.format(years[1])] / 100000000
df = pd.merge(df, tmp, on=['종목코드'])
tmp = data['stock_amount_{}'.format(stock_amount_dates[1])].reset_index(drop=False)
tmp.columns = ['종목코드', '상장주식수{}'.format(years[2]), '시가총액{}'.format(years[2])]
tmp['상장주식수{}'.format(years[2])] = tmp['상장주식수{}'.format(years[2])] / 100000000
tmp['시가총액{}'.format(years[2])] = tmp['시가총액{}'.format(years[2])] / 100000000
df = pd.merge(df, tmp, on=['종목코드'])
tmp = data['stock_amount_{}'.format(stock_amount_dates[2])].reset_index(drop=False)
tmp.columns = ['종목코드', '상장주식수{}'.format(years[3]), '시가총액{}'.format(years[3])]
tmp['상장주식수{}'.format(years[3])] = tmp['상장주식수{}'.format(years[3])] / 100000000
tmp['시가총액{}'.format(years[3])] = tmp['시가총액{}'.format(years[3])] / 100000000
#df = pd.merge(df, tmp, on=['종목코드'])
df = pd.merge(df, tmp[['종목코드', '시가총액{}'.format(years[3])]], on=['종목코드'])
tmp = self.maria.showData('select * from stocks_202103')
tmp['상장주식수{}'.format(years[3])] = (tmp['보통주'] + tmp['우선주']) / 100000000
df = pd.merge(df, tmp[['종목코드', '상장주식수{}'.format(years[3])]], on=['종목코드'])
for y in years[1:]:
df['EPS{}'.format(y)] = df['당기순이익{}'.format(y)] / df['상장주식수{}'.format(y)]
df1 = pd.DataFrame(stock.get_market_ohlcv_by_ticker(std_date)['종가'])
df1['Size'] = [0] * df1.shape[0]
df2 = pd.DataFrame(stock.get_market_ohlcv_by_ticker(std_date, market='KOSDAQ')['종가'])
df2['Size'] = [1] * df2.shape[0]
df3 = pd.DataFrame(stock.get_market_ohlcv_by_ticker(std_date, market='KONEX')['종가'])
df3['Size'] = [2] * df3.shape[0]
price = pd.concat([df1, df2, df3])
price = price.reset_index(drop=False).rename(columns={'티커': '종목코드', '종가': '주식가격'})
df = pd.merge(df, price, on='종목코드')
df['순자산가치'] = (df['자본총계{}'.format(years[3])] - df['무형자산']) / df['상장주식수{}'.format(years[3])]
df['순손익가치'] = ((df['EPS{}'.format(years[1])] + df['EPS{}'.format(years[2])]*2 + df['EPS{}'.format(years[3])]*3)/6)*10
df['본질가치'] = (df['순자산가치'] + (df['순손익가치']*1.5))/2.5
df['보충적가치'] = (df['순손익가치']*2 + df['순자산가치']*3) / 5
df['주당기업가치'] = (df['상장주식수{}'.format(years[3])]*df['주식가격']+df['단기차입금']+df['장기차입금']-df['현금성자산'])/df['상장주식수{}'.format(years[3])]
df['주당가치분석'] = (df['본질가치'] + df['주당기업가치']) / 2
cols = list(df.columns)
cols.remove('GB')
df = df[cols]
print(df.columns)
print(len(list(df.columns)))
self.maria.createTable(res_tablename, list(df.columns), ['VARCHAR(20)'] + ['FLOAT']*len(cols))
for i in range(df.shape[0]):
try:
self.maria.insertData(res_tablename, tuple(list(df.iloc[i])))
self.maria.commitDB()
except:
continue
from pykrx import stock
import time
df = stock.get_market_ohlcv_by_ticker("20200831")
print(df.tail())
def test_ohlcv_for_a_day_on_holiday2(self):
df0 = stock.get_market_ohlcv_by_ticker("20210123",
alternative=True) # Saturday
df1 = stock.get_market_ohlcv_by_ticker("20210122") # Friday
self.assertTrue((df0 == df1).all(axis=None))
def update_stockData_with_labels(start_date=None):
'''
pykrx를 이용하여 증시 데이터를 업데이트합니다.
- start_date 갱신이 필요한 시점으로, 미입력 시 마지막으로 장 마감한 날짜부터 갱신됩니다.
장 마감 이전에 업데이트했을 경우 마지막 날짜의 데이터는 실제와 다를 수 있습니다.
형식은 'YYYYMMDD' 또는 Datetime
'''
sys_print = stdout.write # stack print method
# 장 마감 시간이 지나지 않으면 오늘의 결과를, 지나면 다음 날의 결과를 예측함
pd_destDate = pd.to_datetime(pd.Timestamp.now() - pd.Timedelta(hours=15.5))
pd_destDate = pd.to_datetime(pd_destDate.date())
if start_date is None:
# TODO: 상장된 종목 리스트 갱신, 충분한 양의 데이터가 쌓인 종목만 선별
with open('resources/stock_market_data/900140.csv', 'r') as file:
standard = file.readlines()
standard = standard[-2].split(
",") # 장 마감 전 업데이트했을 가능성을 고려하여 어제를 갱신 대상에 포함시킴
pd_startDate = pd.to_datetime(standard[1])
else:
pd_startDate = pd.to_datetime(start_date)
sys_print("증시 데이터 로드를 시작합니다.\n")
pd_dateRange = pd.date_range(pd_startDate, pd_destDate)
df_update_all = pd.DataFrame()
for pd_date in pd_dateRange:
# pd_date 날짜의 한국거래소 시장 데이터를 불러옵니다.
df_update = get_market_ohlcv_by_ticker(pd_date)
if df_update.거래량.sum() == 0:
sys_print(f"{str(pd_date)} 에는 증시 데이터가 없습니다.\n")
continue
df_update = df_update.reset_index()
df_update = df_update[df_update.시가 >
0] # 거래정지된 종목은 종가를 제외한 column이 0으로 채워짐
df_update['date'] = pd_date
df_update_all = df_update_all.append(df_update)
# 너무 많은 요청 시 IP block을 방지하기 위한 sleep
timeSleep = 1 + 2 * random()
sys_print(f"{str(pd_date)} 의 증시 데이터를 로드했습니다 --- {timeSleep:.2f}초 대기\n")
sleep(timeSleep)
df_update_all.rename(columns={'티커': '종목코드'},
inplace=True) # TODO: 리소스 자체의 column명을 변경
sys_print("필요한 증시 데이터 로드 완료.\n")
for stock_code in stock_list['종목코드'].iloc:
filename = f'resources/stock_market_data/{stock_code}.csv'
try:
update_target = pd.read_csv(filename,
parse_dates=['date'],
index_col=[0])
except FileNotFoundError:
continue
try:
while pd_startDate <= update_target.date.iloc[-1]:
update_target = update_target.drop(len(update_target) - 1)
except IndexError:
pass # start_date보다 상장일이 더 최신
start = len(update_target)
update_obj = df_update_all[df_update_all['종목코드'] == stock_code]
update_obj = update_obj[['date', '시가', '고가', '저가', '종가', '거래량']]
update_obj.columns = ['date', 'open', 'high', 'low', 'close', 'volume']
update_target = update_target.append(update_obj)
update_target = update_target.reset_index(drop=True)
for i in range(start, len(update_target)):
update_target.pattern1.values[i] = labellingD0(
update_target.iloc[i])
lastline = {
'date': pd.to_datetime(pd_destDate + pd.Timedelta(days=1)),
'open': -1,
'high': -1,
'low': -1,
'close': -1,
'volume': -1,
'pattern1': "XXX"
}
update_target = update_target.append(lastline, ignore_index=True)
update_target.to_csv(filename)
sys_print(f"{stock_code} 갱신 완료\n")
def test_ohlcv_for_a_day_on_holiday(self):
df = stock.get_market_ohlcv_by_ticker("20210123") # Saturday
self.assertIsInstance(df, pd.DataFrame)
temp = df[df.columns[1:]]
self.assertTrue((temp == 0).all(axis=None))
import pandas as pd
from pykrx import stock
# 종가 추가하기
df1 =pd.read_excel("s-rim-all.xlsx", index_col=0, usecols=["cd", "nm", "gb", "자기자본", "ROE", "유통주식수"])
df2 = stock.get_market_ohlcv_by_ticker("20200420")
종가 = df2["종가"]
종가.index = 'A' + 종가.index
df1['종가'] = 종가
# 현재가 추가하기
df3 = stock.get_market_ohlcv_by_ticker("20201106")
현재가 = df3['종가']
현재가.index = 'A' + 현재가.index
df1['현재가'] = 현재가
# 요구수익률 필터링
K = 7.89
조건 = df1['ROE'] >= K
df = df1[조건].copy()
df["초과이익"] = df["자기자본"] * (df["ROE"] - K) * 0.01
# 기업가치
W = 1.0
df["기업가치0"] = df["자기자본"] + df["초과이익"] * (W / (1 + K * 0.01 - W))
W = 0.9
df["기업가치1"] = df["자기자본"] + df["초과이익"] * (W / (1 + K * 0.01 - W))
W = 0.8
df["기업가치2"] = df["자기자본"] + df["초과이익"] * (W / (1 + K * 0.01 - W))
W = 0.7
df["기업가치3"] = df["자기자본"] + df["초과이익"] * (W / (1 + K * 0.01 - W))
# https://github.com/sharebook-kr/pykrx
from pykrx import stock
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from sklearn import datasets
df = stock.get_market_ohlcv_by_ticker("20210319",
market="KOSPI") # Kospi의 해당날자 주가정보 뽑기
df = df.sort_values(by=['거래량'], axis=0, ascending=False) #해당 컬럼의 내림차순으로 정렬
print(df)
# 만들고싶은거:
# 3거래일의 거래량 상위 10프로를 비교하여 증감을 확인
# OBV 계산식도입하여 판단하기 On Balance Volume
# (1) If 오늘 주식 종가 > 전날의 주식 종가, 이전까지의 거래량 합산에 오늘 거래량을 합함
# (2) If 오늘 주식 종가 < 전날의 주식 종가, 이전까지의 거래량 합산에 오늘 거래량을 뺌
# # # 이거만 바꾸면 상관도 나오는 거!
# X = df.거래량.values
# Y = df.등락률.values
# # 1. 산점도로 육안으로 일단 확인
# plt.scatter(X, Y)
# plt.show()
# # 2. 공분산(covariance) : 2개의 변수의 상관도를 나타내는 값
# cov_value = (np.sum(X*Y)-len(X)*np.mean(X)*np.mean(Y))/len(X)
# print('공분산:', cov_value) # 2.14... ? 양수의 의미는 상승시 상승
# # 3. 상관계수(correlation coeffect) : 공분산을 0~1 사이로 표준화시킨 값 (0 상관없음, 0.3~0.7 뚜렷한 상관, 0.8 이상 절대적인 상관)
