def test_ohlcv_query(self):
# 1 business day
df = stock.get_market_ohlcv_by_date("20180208", "20180208", "066570")
self.assertTrue(len(df) == 1)
# one more business days
df = stock.get_market_ohlcv_by_date("20180101", "20180208", "066570")
self.assertIsNotNone(df)
# None for holiday
df = stock.get_market_ohlcv_by_date("20190209", "20190209", "066570")
self.assertTrue(df.empty)
def updateFile(self):
df = pd.read_csv(
"data/chart_data/" + self.stock_code + ".csv",
names=["date", "open", "high", "low", "close", "volume"],
header=None)
try:
dt = datetime.strptime(df.date.iloc[-1], '%Y-%m-%d %H:%M:%S')
except:
dt = datetime.strptime(df.date.iloc[-1], '%Y-%m-%d')
Ndt = dt + timedelta(days=1)
lastday = Ndt.strftime("%Y%m%d")
today = datetime.today().strftime("%Y%m%d")
if int(lastday) < int(datetime.today().strftime("%Y%m%d")):
df2 = stock.get_market_ohlcv_by_date(lastday, today,
self.stock_code)
df2 = df2.reset_index()
df2.rename(columns={
"날짜": "date",
"시가": "open",
"고가": "high",
"저가": "low",
"종가": "close",
"거래량": "volume"
},
inplace=True)
df_new = pd.concat([df, df2], ignore_index=True)
df_new.to_csv('./data/chart_data/{}.csv'.format(self.stock_code),
sep=',',
index=False,
header=False)
print("\n\n{}.csv File Update Complete!".format(self.stock_code))
def get_dataframe_from_previous(self, days=1):
interval = timedelta(days)
previous = self.today - interval
previous_str = previous.strftime("%Y%m%d")
dataframe = stock.get_market_ohlcv_by_date(previous_str,
self.today_str, self.code)
return dataframe
def getBasicKOSPI(self, listKOSPI: list):
logger.info("GetStockInfo - getBasicKOSPI")
for stockID in listKOSPI:
for _ in range(CONF.TOTAL_RETRY_FOR_FETCH_FAIL):
try:
startDay = self.setTimeFormat(CF.getStartFetchingDate(datetime.now()), haveSeparator=False)
endDay = self.setTimeFormat(datetime.today(), haveSeparator=False)
logger.info(f"GetStockInfo - getBasicKOSPI; startDay : {startDay}, endDay : {endDay}")
tmpData = stock.get_market_ohlcv_by_date(
fromdate=startDay,
todate=endDay,
ticker=stockID,
name_display=False
)
if not tmpData.empty:
self.infoBasicKOSPI[stockID] = tmpData
break
except:pass
time.sleep(CONF.SLEEP_SECONDS_BETWEEN_RQ)
else:
logger.critical(f"GetStockInfo - getBasicKOSPI; Empty Dataframe, ticker : {stockID}")
logger.info(f"GetStockInfo - getBasicKOSPI; getBasic Total data length : {len(self.infoBasicKOSPI)}")
def pykrx_scratch(date_Start, date_End):
print("Reading Daily Chart ... {} - {}".format(date_Start, date_End))
# create main folder
if not os.path.exists(Krx_Char_folder_path):
os.mkdir(Krx_Char_folder_path)
# ticker scratch
for ticker in stock.get_market_ticker_list(market="ALL"):
stock_name = stock.get_market_ticker_name(ticker)
stock_folder_name = stock_name + '_' + ticker
#print(stock_name, ticker)
df = stock.get_market_ohlcv_by_date(date_Start, date_End, ticker)
df = df.reset_index()
#print(len(df))
df.insert(5, '종가2', df['종가'])
# folder check
if not os.path.exists(Krx_Char_folder_path + '/' + stock_name):
os.mkdir(Krx_Char_folder_path + '/' + stock_name)
df.to_csv(Krx_Char_folder_path + '/' + stock_name + '/' + ticker +
'.csv',
sep=',',
na_rep='0',
index=False,
header=False)
print('{} Daily chart is written! ==== ticker is : {}'.format(
stock_name, ticker))
print('Scratching daily chart is done!')
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 _collect_one_daily_info(self, info_type, itemcode_info):
itemcode, itemname, market = itemcode_info
table_name = f"{info_type}_{itemcode}_{market}"
start_date, end_date = self._get_date_filter(table_name)
df = pd.DataFrame()
if info_type == 'daily_items_info':
df = stock.get_market_ohlcv_by_date(start_date.format('YYYYMMDD'),
end_date.format('YYYYMMDD'),
itemcode).rename(
columns={
'시가': 'open',
'고가': 'high',
'저가': 'low',
'종가': 'close',
'거래량': 'volume'
})
elif info_type == 'daily_items_indicator_info':
df = self._get_daily_items_indicator_info(
itemcode_info, start_date.format('YYYYMMDD'),
end_date.format('YYYYMMDD'))
if df.empty:
raise Exception(f"업데이트할 내용이 없어서 SKIP ({table_name})")
df = df.reset_index().rename(columns={'날짜': 'date'})
df.insert(loc=0, column='itemname', value=itemname)
df['date'] = pd.to_datetime(df['date'], format='%Y%m%d')
start_date = df['date'].min().strftime('%Y-%m-%d')
self.bigquery_worker.delete_duplicated_rows(table_name, start_date)
func = self.bigquery_worker.save_daily_item_info if info_type == 'daily_items_info' \
else self.bigquery_worker.save_daily_item_indicator_info
func(itemcode_info, df, bigquery.WriteDisposition.WRITE_APPEND)
def get_market_price(nowDate, companies, codes):
Prices, Volumes=[],[]
for i in range(len(companies)):
df = stock.get_market_ohlcv_by_date(nowDate,nowDate,codes[i])
L=list(df.iloc[0])
Prices.append(L[3])
Volumes.append(L[4])
return Prices, Volumes
def dataset_loaderKR(stock_name, start, end, train_ratio=0.7):
dataset = stock.get_market_ohlcv_by_date("".join(start.split('-')),
"".join(end.split('-')),
stock_name.split('.KR')[0])
dataset['Close'] = dataset['종가']
date_split = str(dataset.index[int(train_ratio * len(dataset))])
return dataset[:date_split], dataset[date_split:], date_split
def Daily_Crawling(start_date: str, end_date: str, code: str):
# 위 순서대로
df_market_cap = stock.get_market_cap_by_date(start_date, end_date, code)
df_ohlcv = stock.get_market_ohlcv_by_date(start_date, end_date, code)
df_fundamental = stock.get_market_fundamental_by_date(
start_date, end_date, code)
df = pd.concat([df_market_cap.iloc[:, 0], df_ohlcv, df_fundamental],
axis=1)
return df
def makeNewFile(self):
df = stock.get_market_ohlcv_by_date("19990101", "20201231",
self.stock_code)
df = df.reset_index()
df.to_csv('./data/chart_data/{}.csv'.format(self.stock_code),
sep=',',
index=False,
header=False)
print("\n\n{}.csv File Generation Complete!".format(self.stock_code))
def test_ohlcv_format(self):
target = "20180208"
df = stock.get_market_ohlcv_by_date(target, target, "066570")
self.assertEqual(type(df.index[0]), pandas.Timestamp)
self.assertEqual(type(df['시가'].iloc[0]), np.int32)
self.assertEqual(type(df['고가'].iloc[0]), np.int32)
self.assertEqual(type(df['저가'].iloc[0]), np.int32)
self.assertEqual(type(df['종가'].iloc[0]), np.int32)
self.assertEqual(type(df['거래량'].iloc[0]), np.int32)
def download_data(cls, save_dir='./data/kospi'):
save_dir = path.join(utils.get_original_cwd(), save_dir)
os.makedirs(save_dir, exist_ok=True)
codes, names = cls.metadata()
for code in codes:
df = stock.get_market_ohlcv_by_date('19000101', '20300101', code)
df.to_csv(path.join(save_dir, f'{names[code]}_{code}.csv'))
time.sleep(1)
def get_SAMSUNG_dataframe():
start_date = '2020-09-01'
end_date = '2021-03-01'
# investing.com 양식, ex) dd/mm/yyyy
start_date_ = start_date[8:] + '/' + start_date[5:7] + '/' + start_date[:4]
end_date_ = end_date[8:] + '/' + end_date[5:7] + '/' + end_date[:4]
# krx 양식 ex) yyyymmdd
start_date__ = start_date[0:4] + start_date[5:7] + start_date[8:10]
end_date__ = end_date[0:4] + end_date[5:7] + end_date[8:10]
model_samsung = pd.DataFrame()
# S&P 500
snp_500_ = yf.download("^GSPC", start=start_date, end=end_date)
snp_500_.columns = [
'snp_500_Open', 'snp_500_High', 'snp_500_Low', 'snp_500_Close',
'snp_500_Adj Close', 'snp_500_Volume'
]
snp_500_ = snp_500_.drop([
'snp_500_Open', 'snp_500_High', 'snp_500_Low', 'snp_500_Adj Close',
'snp_500_Volume'
],
axis=1)
# 삼성 차트 데이터
sam_ = stock.get_market_ohlcv_by_date(start_date__, end_date__, "005930")
sam_.columns = ['Open', 'High', 'Low', 'Close', 'Volume']
model_samsung = sam_.copy()
# SOX 지수 엔비디아(8.9%), 텍사스인스트루먼트(8.6%), 퀄컴(7.7%), 인텔(7.4%) 반도체장비기업 18.52%
SOXX = yf.download("SOXX", start=start_date, end=end_date)
SOXX.columns = [
'SOXX_Open', 'SOXX_High', 'SOXX_Low', 'SOXX_Close', 'SOXX_Adj Close',
'SOXX_Volume'
]
SOXX = SOXX.drop([
'SOXX_Open', 'SOXX_High', 'SOXX_Low', 'SOXX_Adj Close', 'SOXX_Volume'
],
axis=1)
model_samsung['SNP500'] = snp_500_
model_samsung['SOXX'] = SOXX
model_samsung = model_samsung.dropna() # 결측치가 있는 행 제거
maxClose = model_samsung['Close'].max()
maxSNP500 = model_samsung['SNP500'].max()
maxSOXX = model_samsung['SOXX'].max()
model_samsung["rev_Close"] = maxClose - model_samsung['Close']
model_samsung["rev_SNP500"] = maxSNP500 - model_samsung['SNP500']
model_samsung["rev_SOXX"] = maxSOXX - model_samsung['SOXX']
# 차트 비교분석을 위한 정규화
min_max_scaler = MinMaxScaler()
fitted = min_max_scaler.fit(model_samsung)
output = min_max_scaler.transform(model_samsung)
output = pd.DataFrame(output,
columns=model_samsung.columns,
index=list(model_samsung.index.values))
return output, model_samsung
def test_io_for_n_day(self):
df = stock.get_market_ohlcv_by_date("20200701", "20200717", "005930")
self.assertIsNotNone(df)
self.assertIsInstance(df.index[0], pandas.Timestamp)
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.int32)
def get_stock_df(start_date, end_date, stock_code):
stock_df = stock.get_market_ohlcv_by_date(start_date, end_date, stock_code)
stock_df.reset_index(inplace=True)
stock_df["종목코드"] = stock_code
stock_df.drop(['시가', '고가', '저가', '거래량'], axis=1, inplace=True)
stock_df = stock_df[["종목코드", "날짜", "종가"]]
stock_df.columns = ["stock_code", "stock_date", "close_price"]
return stock_df
def test_not_empty_result(self):
df = stock.get_market_ohlcv_by_date("20190225", "20190228", "000660")
self.assertNotEqual(df.empty, True)
df = stock.get_market_price_change_by_ticker("20180301", "20180320")
self.assertNotEqual(df.empty, True)
df = stock.get_market_fundamental_by_ticker("20180305", "KOSPI")
self.assertNotEqual(df.empty, True)
df = stock.get_market_fundamental_by_date("20180301", "20180320",
'005930')
self.assertNotEqual(df.empty, True)
def test_ohlcv_simple_call(self):
df = stock.get_market_ohlcv_by_date("20210118", "20210126", "005930")
# 시가 고가 저가 종가 거래량
# 날짜
# 2021-01-18 86600 87300 84100 85000 43227951
# 2021-01-19 84500 88000 83600 87000 39895044
# 2021-01-20 89000 89000 86500 87200 25211127
# 2021-01-21 87500 88600 86500 88100 25318011
# 2021-01-22 89000 89700 86800 86800 30861661
temp = df.iloc[0:5, 0] == np.array([86600, 84500, 89000, 87500, 89000])
self.assertEqual(temp.sum(), 5)
self.assertIsInstance(df.index , pd.core.indexes.datetimes.DatetimeIndex)
self.assertIsInstance(df.index[0], pd._libs.tslibs.timestamps.Timestamp)
self.assertTrue(df.index[0] < df.index[-1])
def make_band_data(option):
# st.write(option)
#오늘날짜까지
now = datetime.now()
today = '%s%s%s' % (now.year, now.month, now.day)
fun_df = stock.get_market_fundamental_by_date("20080101", today, option,
"m")
#Price 추가 => 이것의 문제는 수정주가가 아님
# fun_df['Close'] = fun_df['PER'] * fun_df['EPS']
#Price 수정 주가로 변경
p_df = stock.get_market_ohlcv_by_date("20080101", today, option, "m")
fun_df['Close'] = p_df['종가']
#PER Max/Min/half/3/1
e_max = round(fun_df['PER'].max(), 1)
if (e_max >= 30.00):
e_max = 30.00
e_min = round(fun_df['PER'].min(), 1)
e_half = round((e_max + e_min) / 2, 1)
e_3 = round((e_max - e_half) / 2 + e_half, 1)
e_1 = round((e_half - e_min) / 2 + e_min, 1)
#가격 데이터 만들기
fun_df[str(e_max) + "X"] = (fun_df['EPS'] * e_max).round(2)
fun_df[str(e_3) + "X"] = (fun_df['EPS'] * e_3).round(2)
fun_df[str(e_half) + "X"] = (fun_df['EPS'] * e_half).round(2)
fun_df[str(e_1) + "X"] = (fun_df['EPS'] * e_1).round(2)
fun_df[str(e_min) + "X"] = (fun_df['EPS'] * e_min).round(2)
#PBR Max/Min/half/3/1
b_max = round(fun_df['PBR'].max(), 1)
if (b_max >= 20.00):
b_max = 20.00
b_min = round(fun_df['PBR'].min(), 1)
b_half = round((b_max + b_min) / 2, 1)
b_3 = round((b_max - b_half) / 2 + b_half, 1)
b_1 = round((b_half - b_min) / 2 + b_min, 1)
#가격 데이터 만들기
fun_df[str(b_max) + "X"] = fun_df['BPS'] * b_max
fun_df[str(b_3) + "X"] = (fun_df['BPS'] * b_3).round(2)
fun_df[str(b_half) + "X"] = (fun_df['BPS'] * b_half).round(2)
fun_df[str(b_1) + "X"] = (fun_df['BPS'] * b_1).round(2)
fun_df[str(b_min) + "bX"] = (fun_df['BPS'] * b_min).round(2)
fun_df.round(decimals=2)
return fun_df
def generate_train_data(self, n, left_date, right_date, train_len,
result_len, code_list):
x_list = []
y_closing_list = []
y_highest_list = []
while True:
if len(x_list) == n:
break
duration = (datetime.strptime(right_date, '%Y%m%d') -
datetime.strptime(left_date, '%Y%m%d')).days
rand_offset = random.randrange(0, duration)
start_date = datetime.strptime(
left_date, '%Y%m%d') + dt.timedelta(days=rand_offset)
end_date = (start_date + dt.timedelta(
days=(train_len + result_len) * 2)).strftime("%Y%m%d")
start_date = start_date.strftime("%Y%m%d")
rand_code = code_list[random.randrange(0, len(code_list))]
price_data = st.get_market_ohlcv_by_date(start_date, end_date,
rand_code)
if len(price_data['종가']) < train_len + result_len:
continue
closing_price_norm = price_data['종가'] / np.max(
price_data['종가'][:train_len])
highest_price_norm = price_data['고가'] / np.max(
price_data['종가'][:train_len])
train_data = closing_price_norm[:train_len]
raw_closing_data = closing_price_norm[train_len:train_len +
result_len]
raw_highest_data = highest_price_norm[train_len:train_len +
result_len]
x_list.append(train_data)
y_closing_list.append(raw_closing_data)
y_highest_list.append(raw_highest_data)
x_list = np.array(x_list)
y_closing_list = np.array(y_closing_list)
y_highest_list = np.array(y_highest_list)
return x_list, y_closing_list, y_highest_list
def test_not_empty_result(self):
df = stock.get_market_ohlcv_by_date("20190225", "20190228", "000660")
self.assertFalse(df.empty)
df = stock.get_market_cap_by_date("20190101", "20190131", "005930")
self.assertFalse(df.empty)
df = stock.get_market_cap_by_ticker("20200625")
self.assertFalse(df.empty)
df = stock.get_market_price_change_by_ticker("20180301", "20180320")
self.assertFalse(df.empty)
df = stock.get_market_fundamental_by_ticker("20180305", "KOSPI")
self.assertFalse(df.empty)
df = stock.get_market_fundamental_by_date("20180301", "20180320", '005930')
self.assertFalse(df.empty)
def get_top_volume_by_date(Date, ticker_list, top=500):
'''
파라미터: Date > "YYYYmmdd" 문자열 형식, 개장일 날짜로 보장되어야 함
ticker_list > 종목 코드(문자열 형식) 리스트
top(default=500) > 거래량 상위로부터 top개 까지 반환
date 날짜에 ticker_list 안 모든 종목에 대하여
거래량 상위 top개 종목코드 리스트 형태로 반환
'''
volumes = []
for ticker in ticker_list:
vol = stock.get_market_ohlcv_by_date(Date, Date, ticker)
if (len(vol.index) > 0):
volumes.append((ticker, vol['거래량'][0]))
volumes.sort(key=lambda x: -x[1])
return list(x[0] for x in volumes[0:top])
def insertQuotes(stockCode, startDate, endDate, source='yahoo'):
df = stock.get_market_ohlcv_by_date(startDate, endDate, stockCode)
dfMarketCap = stock.get_market_cap_by_date(startDate, endDate, stockCode)
df['stock_code'] = stockCode
df['date'] = df.index
df['market_cap'] = dfMarketCap['시가총액']
df['num_stocks'] = dfMarketCap['상장주식수']
df = df.rename(columns={
'고가': 'high',
'저가': 'low',
'시가': 'open',
'종가': 'close',
'거래량': 'volume'
})
df = df[[
'stock_code', 'date', 'open', 'high', 'low', 'close', 'volume',
'market_cap', 'num_stocks'
]]
with sl.connect(config.dbName) as con:
df.to_sql('QUOTES', con, if_exists='replace', index=False)
def get_n_ATR(Date, n, tickercode):
'''
파라미터: n > n ATR 의 n 입력. 정수 형태
date > 조회할 날짜 "YYYYmmdd" 문자열 형태로 입력
개장일으로 보장되어야 함
tickercode > 조회할 종목 코드 문자열 형태로 입력
diff_today_hl= 오늘 고가-저가
diff_yester_today_ch= 전일 종가-오늘 고가
diff_yester_today_cl= 전일 종가-오늘 저가
입력한 종목에 대하여 date 로 부터 n ATR 반환
n+1 일의 데이터가 없으면 -1 반환
'''
nday = get_ndays_ago_from_date(Date, n)
OHLCV = stock.get_market_ohlcv_by_date(nday, Date, tickercode)
if (len(OHLCV.index) != n + 1):
return -1
ATR = 0
for i in range(n, 0, -1):
ohlcv = OHLCV.iloc[i]
prev_c = OHLCV.iloc[i - 1]['종가']
diff_today_hl = abs(ohlcv['고가'] - ohlcv['저가'])
diff_yester_today_ch = abs(prev_c - ohlcv['고가'])
diff_yester_today_cl = abs(prev_c - ohlcv['저가'])
TR = max(diff_today_hl, diff_yester_today_ch)
TR = max(TR, diff_yester_today_cl)
ATR += TR
ATR = ATR / n
return (ATR)
from pykrx import stock
samsung_df = stock.get_market_ohlcv_by_date("20180101", "20190531", "005930")
lge_df = stock.get_market_ohlcv_by_date("20180101", "20190531", "066570")
print(samsung_df.head())
print(lge_df.head())
def get_stock_by_day(code, start_date):
start_date_no_bar = collect_data.bar_remover(start_date)
start_date = start_date
# end_date는 오늘 날짜로 고정
today = datetime.datetime.today().strftime(
'%Y%m%d') # krx는 YYYYMMDD 형식, 야후는 YYYY-MM-DD 형식
stock_df = stock.get_market_ohlcv_by_date(
start_date_no_bar, today, code, adjusted=True) # 시가 고가 저가 종가 거래량
stock_df2 = stock.get_market_fundamental_by_date(
start_date_no_bar, today, code) # DIV BPS PER EPS PBR
today_pdr = datetime.datetime.today().strftime('%Y-%m-%d')
gold = pdr.get_data_yahoo('GC=F', start=start_date,
end=today_pdr)[['Adj Close', 'Volume']] # 금값
gold.columns = ['Adj Close_gold', 'Volume_gold']
nikkei = pdr.DataReader('^N225',
'yahoo',
start=start_date,
end=today_pdr)[['Adj Close',
'Volume']] # 일본 지수
nikkei.columns = ['Adj Close_nikkei', 'Volume_nikkei']
crude_oil = pdr.get_data_yahoo('CL=F', start=start_date,
end=today_pdr)[['Adj Close',
'Volume']] # 유가
crude_oil.columns = ['Adj Close_oil', 'Volume_oil']
change = pd.Series(
pdr.get_data_yahoo('KRW=X', start=start_date,
end=today_pdr)['Adj Close']) # 환율
# 데이터 leftjoin
data = pd.concat([stock_df, stock_df2], axis=1)
data = pd.merge(data,
gold,
how='left',
left_index=True,
right_index=True)
data = pd.merge(data,
nikkei,
how='left',
left_index=True,
right_index=True)
data = pd.merge(data,
crude_oil,
how='left',
left_index=True,
right_index=True)
data = pd.merge(data,
change,
how='left',
left_index=True,
right_index=True)
data.columns = [
'시가', '고가', '저가', '종가', '거래량', 'DIV', 'BPS', 'PER', 'EPS', 'PBR',
'Adj Close_gold', 'Volume_gold', 'Adj Close_nikkei',
'Volume_nikkei', 'Adj Close_oil', 'Volume_oil', 'Adj Close_change'
]
# 기존에 사용했던 가장 최근의 값으로 채우는 방법 이거 쓰면 거의 다날라감
data = data.fillna(method="pad")
# 주가 자체의 값이 아니라 등락율을 구하기로 해서 다음날과 비교해서 올라가면 1 아니면 0 마지막날은 그대로
for i in range(len(data['종가'])):
if i == 0:
continue
elif i > 0 and i < (len(data['종가']) - 1):
if data['종가'][i] < data['종가'][(i + 1)]:
data['종가'][i] = 1
else:
data['종가'][i] = 0
else:
pass
return data
def getTimeseriesData(self, analyezdData):
from_date = '20200331'
to_date = '20210226'
from_date_str = '{}-{}-{}'.format(from_date[:4], from_date[4:6], from_date[6:])
to_date_str = '{}-{}-{}'.format(to_date[:4], to_date[4:6], to_date[6:])
price = []
rate = []
price.append(['날짜']+list(stock.get_market_ohlcv_by_date(from_date, to_date, "005930").index.astype('str')))
rate.append(['날짜']+list(stock.get_market_ohlcv_by_date(from_date, to_date, "005930").index.astype('str')))
for i in range(analyezdData.shape[0]):
df = stock.get_market_ohlcv_by_date(from_date, to_date, analyezdData['종목코드'][i])
df['rate'] = ((np.array(df['종가']) - df['종가'][from_date_str]) / df['종가'][from_date_str])*100
price.append([analyezdData['종목코드'][i]]+list(stock.get_market_ohlcv_by_date(from_date, to_date, analyezdData['종목코드'][i])['종가']))
rate.append([analyezdData['종목코드'][i]]+list(df['rate']))
# 코스피 종목수 934
df = fdr.DataReader('KS11', from_date, to_date)
df['rate'] = ((np.array(df['Close']) - df['Close'][from_date_str]) / df['Close'][from_date_str])*100
price.append(['KOSPI']+list(df['Close']))
rate.append(['KOSPI']+list(df['rate']))
# 코스닥 종목수 1,471
df = fdr.DataReader('KQ11', from_date, to_date)
df['rate'] = ((np.array(df['Close']) - df['Close'][from_date_str]) / df['Close'][from_date_str])*100
price.append(['KOSDAQ']+list(df['Close']))
rate.append(['KOSDAQ']+list(df['rate']))
price = pd.DataFrame(price[1:], columns=price[0])
rate = pd.DataFrame(rate[1:], columns=rate[0])
# 지표평균
mean_list = []
for c in rate.columns[1:]:
kospi = rate[rate['날짜']=='KOSPI'][c].iloc[0]
kosdaq = rate[rate['날짜']=='KOSDAQ'][c].iloc[0]
mean_list.append((kospi*934 + kosdaq*1471)/2405) # kospi, kosdaq, 지표평균은 빼고
rate = rate.append(pd.Series(['KOS_MEAN']+mean_list, index=rate.columns), ignore_index=True)
# 종목평균
mean_list = []
for c in rate.columns[1:]:
mean_list.append(rate[c][:-3].mean()) # kospi, kosdaq, 지표평균은 빼고
rate = rate.append(pd.Series(['CODE_MEAN']+mean_list, index=rate.columns), ignore_index=True)
count_list = []
tmp = rate.iloc[:-4] # kospi, kosdaq, 지표평균, 종목평균은 빼고
for c in rate.columns[1:]:
count_list.append(tmp[tmp[c] > rate[rate[rate.columns[0]]=='KOS_MEAN'][c].iloc[0]].shape[0])
count_list = list(np.array(count_list) / (rate.shape[0] - 4))
rate = rate.append(pd.Series(['COUNT']+count_list, index=rate.columns), ignore_index=True)
compare = rate.iloc[-5:]
compare = pd.DataFrame(compare.transpose()).reset_index(drop=False)
compare.columns = compare.iloc[0]
compare = compare.iloc[1:]
return [price, rate, compare]
from pykrx import stock
from cx_Oracle import connect
import os
LOCATION = r"D:\instantclient_19_6"
os.environ["PATH"] = LOCATION + ";" + os.environ["PATH"]
#https://github.com/sharebook-kr/pykrx
#https://jsideas.net/daily_to_weekly/
con = connect("hoijoo/[email protected]:1521/xe")
cur = con.cursor()
tickers = stock.get_market_ticker_list()
print(tickers)
for i in tickers:
s = stock.get_market_ohlcv_by_date("20201008", "20201012", i, "d", True)
stockcode = i
print("=======")
print(i)
# print(s)
endPrice = str(s['종가']).split("\n")
startPrice = str(s['시가']).split("\n")
highPrice = str(s['고가']).split("\n")
lowPrice = str(s['저가']).split("\n")
amount = str(s['거래량']).split("\n")
for i in range(1, (len(endPrice) - 1)):
date = str(s.index[i-1]).split(" ")
print(date[0])
endPrice1 = endPrice[i].split(" ")
startPrice1 = startPrice[i].split(" ")
def test_io_for_month(self):
df = stock.get_market_ohlcv_by_date("20200101", "20200630", "005930",
"m")
self.assertIsNotNone(df)
self.assertEqual(len(df), 6)
def test_ohlcv_for_a_day(self):
df = stock.get_market_ohlcv_by_date("20210118", "20210118", "005930")
self.assertIsInstance(df, pd.DataFrame)
self.assertEqual(len(df), 1)
