def fundamentals(tickers, begin="2020-05-26", end="2020-06-26",):
format_header = '{:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>10} {:>10}'
format_numbers = '{:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>10.2e} {:>10.2E}'
print(format_header.format('ticker', 'P/E', 'EARNSH', 'BK/PR', 'DY', 'DR', 'VAR', 'PEG', 'PS', 'PCI', 'VOLPR', 'CM',))
for ticker in tickers:
yf = YF(ticker)
try:
pe = get_number_for_None(get_number_for_None(yf.get_pe_ratio()))
prices = yf.get_historical_price_data(begin, end, "daily")[ticker]['prices']
stat_pr = calc_statistics(prices)
var_pr = get_number_for_None(100 * stat_pr[1] / stat_pr[0])
volume = get_number_for_None(stat_pr[4])
es = get_number_for_None(yf.get_earnings_per_share())
sh = get_number_for_None(yf.get_num_shares_outstanding(price_type='current'))
''' "pegRatio" "priceToBook" "heldPercentInstitutions" '''
statistics = yf.get_key_statistics_data()[ticker]
summary = yf.get_summary_data()[ticker]
peg = get_number_for_None(statistics["pegRatio"])
PCI = get_number_for_None(statistics["heldPercentInstitutions"])
bv = yf.get_key_statistics_data()[ticker]['bookValue']
pr = yf.get_current_price()
if pr is not None and bv is not None:
pr_bv = get_number_for_None(pr/bv)
else:
pr_bv = '-99.99'
f_s = yf.get_financial_stmts('annual', 'income')['incomeStatementHistory'][ticker][0]
f_s_key = list(f_s.keys())[0]
totalRevenue = f_s[f_s_key]['totalRevenue']
outstanding = statistics["sharesOutstanding"]
rev_per_share = totalRevenue / outstanding
if pr is not None and es is not None:
p_s = get_number_for_None(rev_per_share/float(es))
else:
p_s = '99'
dy = get_number_for_None(yf.get_dividend_yield())
dr = get_number_for_None(yf.get_dividend_rate())
volume10days = summary['averageVolume10days']
marketCap = summary['marketCap']
# float(volume)*pr
# float(sh)*pr)
print(format_numbers.format(ticker, pe, es, pr_bv, dy, dr, var_pr, peg, p_s, PCI, volume10days, marketCap))
except Exception as e:
print(ticker, e)
def getMarketData():
tickers = 'AAPL'
financials = YahooFinancials(tickers)
# company_stock_price = financials.get_stock_price_data() #gets stock price information
historical_stock_prices_data = financials.get_historical_price_data(
'2015-11-21', '2020-11-21',
'daily') #gets historical daily stock price of company
# get_Div_data(historical_stock_prices_data[tickers])
get_stock_price_data(historical_stock_prices_data[tickers])
# company_balance_sheet_data_qt = financials.get_financial_stmts('quarterly', 'balance') #get balance sheet
# company_income_statement_data_qt = financials.get_financial_stmts('quarterly', 'income') #get income statement
company_key_statistics_data = financials.get_key_statistics_data(
) #includes profit margins, forward eps, yearly change etc.
# get_forward_pe(company_key_statistics_data[tickers])
# get_trailing_eps(company_key_statistics_data[tickers])
# get_foward_eps(company_key_statistics_data[tickers])
# get_ytdReturn(company_key_statistics_data[tickers])
company_earnings_data = financials.get_stock_earnings_data(
) #historical eps only for 1 year span
# get_earnings_data(company_earnings_data[tickers])
company_dividend_yield = financials.get_dividend_yield(
) #current dividends yield
company_dividend = financials.get_dividend_rate() #current dividends rate
company_avg_div_yield_1year = financials.get_annual_avg_div_yield(
) #average 1 year div yield
company_avg_div_yield_5year = financials.get_five_yr_avg_div_yield(
) #average 5 year div yield
company_eps = financials.get_earnings_per_share() #current eps
company_pe = financials.get_pe_ratio() #current pe ratio
company_beta = financials.get_beta() #current beta
company_current_stock_price = financials.get_current_price(
) #current stock price
company_revenue = financials.get_total_revenue() #current company revenue
company_operating_income = financials.get_operating_income(
) #current company operating income
company_net_income = financials.get_net_income() #current net income
company_yearly_high = financials.get_yearly_high() #get yearly high
company_yearly_low = financials.get_yearly_low() #get yearly low
company_moving_50 = financials.get_50day_moving_avg(
) #50 day moving average of stock
company_moving_200 = financials.get_200day_moving_avg(
) #200 day moving average of stock
def balance_sheet_provider(comp_name, comp_code):
yahoo_finance_object = YahooFinancials(comp_code)
balance_sheet_raw = yahoo_finance_object.get_financial_stmts(
'annual', 'balance')
income_statement_raw = yahoo_finance_object.get_financial_stmts(
'annual', 'income')
e_p_s = None
pe_rat = None
try:
e_p_s = yahoo_finance_object.get_earnings_per_share()
pe_rat = yahoo_finance_object.get_pe_ratio()
except KeyError:
pass
balance_sheet = balance_sheet_raw["balanceSheetHistory"][comp_code]
income_statement = income_statement_raw["incomeStatementHistory"][
comp_code]
company_data_provider_object = StockDataExtractor(comp_code, comp_name,
balance_sheet,
income_statement, e_p_s,
pe_rat)
'''
balance_sheet_raw = {"balanceSheetHistory": {"KO":
[{"2017-12-31": {"intangibleAssets": 7235000000,
"capitalSurplus": 15864000000,
"totalLiab": 68919000000,
"totalStockholderEquity": 17072000000,
"minorityInterest": 1905000000,
"otherCurrentLiab": 2169000000,
"totalAssets": 87896000000,
"commonStock": 1760000000,
"otherCurrentAssets": 7993000000,
"retainedEarnings": 60430000000,
"otherLiab": 10504000000,
"goodWill": 9401000000,
"treasuryStock": -60982000000,
"otherAssets": 3231000000,
"cash": 6006000000,
"totalCurrentLiabilities": 27194000000,
"deferredLongTermAssetCharges": 331000000,
"shortLongTermDebt": 47754000000,
"otherStockholderEquity": -10305000000,
"propertyPlantEquipment": 8203000000,
"totalCurrentAssets": 36545000000,
"longTermInvestments": 23281000000,
"netTangibleAssets": 436000000,
"shortTermInvestments": 14669000000,
"netReceivables": 3667000000,
"longTermDebt": 31221000000,
"inventory": 2655000000,
"accountsPayable": 2288000000}},
{"2016-12-31": {"intangibleAssets": 10499000000,
"capitalSurplus": 14993000000,
"totalLiab": 64050000000,
"totalStockholderEquity": 23062000000,
"minorityInterest": 158000000,
"otherCurrentLiab": 1936000000,
"totalAssets": 87270000000,
"commonStock": 1760000000,
"otherCurrentAssets": 3592000000,
"retainedEarnings": 65502000000,
"otherLiab": 7786000000,
"goodWill": 10629000000,
"treasuryStock": -59193000000,
"otherAssets": 2928000000,
"cash": 8555000000,
"totalCurrentLiabilities": 26532000000,
"deferredLongTermAssetCharges": 326000000,
"shortLongTermDebt": 45801000000,
"otherStockholderEquity": -11205000000,
"propertyPlantEquipment": 10635000000,
"totalCurrentAssets": 34010000000,
"longTermInvestments": 18569000000,
"netTangibleAssets": 1934000000,
"shortTermInvestments": 13646000000,
"netReceivables": 3856000000,
"longTermDebt": 29732000000,
"inventory": 2675000000,
"accountsPayable": 2682000000}},
{"2015-12-31": {"intangibleAssets": 12843000000,
"capitalSurplus": 14016000000,
"totalLiab": 64232000000,
"totalStockholderEquity": 25554000000,
"minorityInterest": 210000000,
"otherCurrentLiab": 2333000000,
"totalAssets": 89996000000,
"commonStock": 1760000000,
"otherCurrentAssets": 4748000000,
"retainedEarnings": 65018000000,
"otherLiab": 8760000000,
"goodWill": 11289000000,
"treasuryStock": -55240000000,
"otherAssets": 3030000000,
"cash": 7309000000,
"totalCurrentLiabilities": 26929000000,
"deferredLongTermAssetCharges": 360000000,
"shortLongTermDebt": 44401000000,
"otherStockholderEquity": -10174000000,
"propertyPlantEquipment": 12571000000,
"totalCurrentAssets": 33395000000,
"longTermInvestments": 16868000000,
"netTangibleAssets": 1422000000,
"shortTermInvestments": 12591000000,
"netReceivables": 4466000000,
"longTermDebt": 19100000000,
"inventory": 3100000000,
"accountsPayable": 2089000000}}]}}
income_statement_raw = {"incomeStatementHistory": {"KO":
[{"2017-12-31": {"researchDevelopment": None,
"effectOfAccountingCharges": None,
"incomeBeforeTax": 6742000000,
"minorityInterest": 1905000000,
"netIncome": 1248000000,
"sellingGeneralAdministrative": 14653000000,
"grossProfit": 22154000000,
"ebit": 7583000000,
"operatingIncome": 7501000000,
"otherOperatingExpenses": None,
"interestExpense": 841000000,
"extraordinaryItems": None,
"nonRecurring": None,
"otherItems": None,
"incomeTaxExpense": 5560000000,
"totalRevenue": 35410000000,
"totalOperatingExpenses": 0,
"costOfRevenue": 13256000000,
"totalOtherIncomeExpenseNet": -989000000,
"discontinuedOperations": 101000000,
"netIncomeFromContinuingOps": 1182000000,
"netIncomeApplicableToCommonShares": 1248000000}},
{"2016-12-31": {"researchDevelopment": None,
"effectOfAccountingCharges": None,
"incomeBeforeTax": 8136000000,
"minorityInterest": 158000000,
"netIncome": 6527000000,
"sellingGeneralAdministrative": 16772000000,
"grossProfit": 25398000000,
"ebit": 8869000000,
"operatingIncome": 8626000000,
"otherOperatingExpenses": None,
"interestExpense": 733000000,
"extraordinaryItems": None,
"nonRecurring": None,
"otherItems": None,
"incomeTaxExpense": 1586000000,
"totalRevenue": 41863000000,
"totalOperatingExpenses": 0,
"costOfRevenue": 16465000000,
"totalOtherIncomeExpenseNet": -592000000,
"discontinuedOperations": 101000000,
"netIncomeFromContinuingOps": 6550000000,
"netIncomeApplicableToCommonShares": 6527000000}},
{"2015-12-31": {"researchDevelopment": None,
"effectOfAccountingCharges": None,
"incomeBeforeTax": 9605000000,
"minorityInterest": 210000000,
"netIncome": 7351000000,
"sellingGeneralAdministrative": 18084000000,
"grossProfit": 26812000000,
"ebit": 10461000000,
"operatingIncome": 8728000000,
"otherOperatingExpenses": None,
"interestExpense": 856000000,
"extraordinaryItems": None,
"nonRecurring": None,
"otherItems": None,
"incomeTaxExpense": 2239000000,
"totalRevenue": 44294000000,
"totalOperatingExpenses": 0,
"costOfRevenue": 17482000000,
"totalOtherIncomeExpenseNet": 1244000000,
"discontinuedOperations": 101000000,
"netIncomeFromContinuingOps": 7366000000,
"netIncomeApplicableToCommonShares": 7351000000}}]}}
'''
comp_ratio_data_dict = json.dumps(
company_data_provider_object.return_data_for_stock())
return comp_ratio_data_dict
class Company(object):
def __init__(self, ticker):
self.ticker = ticker.upper()
self.financials = YahooFinancials(ticker)
self.timeframe = 'annual'
self.balance_sheet = None
self.income_statement = None
self.cash_flow_statement = None
self.key_statistics = None
self.historical_eps = None
self.price_data = None
self.new_corporate_tax_rate = 0.21
self.old_corporate_tax_rate = 0.35
self.risk_free_ror = 0.025
self.market_ror = 0.098
def __set_balance_sheet(self):
if str(type(self.balance_sheet)) == "<class 'NoneType'>":
try:
self.balance_sheet = self.financials.get_financial_stmts(
self.timeframe,
'balance')['balanceSheetHistory'][self.ticker]
self.balance_sheet = self.__clean_statement_timestamp(
self.balance_sheet)
except:
return None
def __set_income_statement(self):
if str(type(self.income_statement)) == "<class 'NoneType'>":
try:
self.income_statement = self.financials.get_financial_stmts(
self.timeframe,
'income')['incomeStatementHistory'][self.ticker]
self.income_statement = self.__clean_statement_timestamp(
self.income_statement)
except:
return None
def __set_cash_flow_statement(self):
if str(type(self.cash_flow_statement)) == "<class 'NoneType'>":
try:
self.cash_flow_statement = self.financials.get_financial_stmts(
self.timeframe,
'cash')['cashflowStatementHistory'][self.ticker]
self.cash_flow_statement = self.__clean_statement_timestamp(
self.cash_flow_statement)
except:
return None
def __set_key_statistics(self):
if str(type(self.key_statistics)) == "<class 'NoneType'>":
try:
self.key_statistics = self.financials.get_key_statistics_data()
except:
return None
def __set_historical_eps(self):
if str(type(self.historical_eps)) == "<class 'NoneType'>":
url = 'https://www.nasdaq.com/earnings/report/{}'.format(
self.ticker)
page = requests.get(url)
if page.status_code == 200:
soup = BeautifulSoup(page.text, 'html.parser')
eps_list = []
td = soup.find_all('td')
counter = 0
for i in td[2::5]:
try:
test = float(i.get_text())
counter += 1
except:
break
for i in range(counter * 5):
eps_list.append(list(soup.find_all('td'))[i].get_text())
self.historical_eps = pd.DataFrame({
'textdate':
eps_list[0::5],
'timestamp':
eps_list[1::5],
'eps':
eps_list[2::5],
'consensus_eps':
eps_list[3::5],
'surprise':
eps_list[4::5]
})
self.historical_eps = self.historical_eps.iloc[::-1]
self.historical_eps.reset_index(inplace=True, drop=True)
else:
return None
def __set_price_data(self):
if str(type(self.price_data)) == "<class 'NoneType'>":
try:
self.price_data = pd.DataFrame(
self.financials.get_historical_price_data(
'1800-01-01',
str(datetime.now())[:10],
'daily')[self.ticker]['prices'])
except:
pass
def __clean_statement_timestamp(self, statement):
for i in statement:
for j in i.keys():
i[j[:4]] = i.pop(j)
return statement
def __get_specific_year(self, statement, year):
for i in statement:
if str(list(i.keys())[0]) == str(year):
return i['{}'.format(year)]
def __json_to_dataframe(self, data):
columns = []
for i in data:
for j in i.keys():
columns.append(j)
df = pd.DataFrame(data[0])
for i in range(len(columns)):
df[columns[i]] = pd.DataFrame(data[i])
df = df[df.columns[::-1]]
return df
def set_risk_free_ror(self, risk_free_ror):
self.risk_free_ror = risk_free_ror
def set_market_ror(self, market_ror):
self.market_ror = market_ror
def check_risk_free_ror(self):
return self.risk_free_ror
def check_market_ror(self):
return self.market_ror
def check_old_corporate_tax_rate(self):
return self.old_corporate_tax_rate
def check_new_corporate_tax_rate(self):
return self.new_corporate_tax_rate
def get_balance_sheet(self):
self.__set_balance_sheet()
df = self.__json_to_dataframe(self.balance_sheet)
return df
def get_income_statement(self):
self.__set_income_statement()
df = self.__json_to_dataframe(self.income_statement)
return df
def get_cash_flow_statement(self):
self.__set_cash_flow_statement()
df = self.__json_to_dataframe(self.cash_flow_statement)
return df
def get_key_statistics(self):
self.__set_key_statistics()
ser = pd.Series(self.key_statistics[self.ticker])
return ser
def get_historical_eps(self):
self.__set_historical_eps()
return self.historical_eps
def get_price_data(self):
self.__set_price_data()
return self.price_data
def check_ticker(self):
return self.ticker
def revenue(self, year):
self.__set_income_statement()
try:
return self.__get_specific_year(self.income_statement,
year)['totalRevenue']
except:
return None
def total_expenses(self, year):
self.__set_income_statement()
self.__set_cash_flow_statement()
try:
operating_expenses = self.__get_specific_year(
self.income_statement, year)['totalOperatingExpenses']
interest = self.__get_specific_year(self.income_statement,
year)['interestExpense']
tax = self.__get_specific_year(self.income_statement,
year)['incomeTaxExpense']
depreciation = self.__get_specific_year(self.cash_flow_statement,
year)['depreciation']
return abs(operating_expenses) + abs(interest) + abs(tax) + abs(
depreciation)
except:
return None
def operating_expenses(self, year):
self.__set_income_statement()
try:
return self.__get_specific_year(self.income_statement,
year)['totalOperatingExpenses']
except:
return None
def outstanding_shares(self):
self.__set_key_statistics()
try:
return self.get_key_statistics()['sharesOutstanding']
except:
return None
def share_price(self):
self.__set_price_data()
try:
return float(self.price_data[-1:]['close'])
except:
return None
def market_value(self):
try:
return self.share_price() * self.outstanding_shares()
except:
return None
def liquid_assets(self, year):
self.__set_balance_sheet()
try:
return self.__get_specific_year(
self.balance_sheet, year)['cash'] + self.__get_specific_year(
self.balance_sheet, year)['shortTermInvestments']
except:
return None
def total_debt(self, year):
self.__set_balance_sheet()
try:
return self.__get_specific_year(
self.balance_sheet,
year)['shortLongTermDebt'] + self.__get_specific_year(
self.balance_sheet, year)['longTermDebt']
except:
return None
def tax(self, year):
self.__set_income_statement()
try:
return abs(
self.__get_specific_year(self.income_statement,
year)['incomeTaxExpense'])
except:
return None
def interest(self, year):
self.__set_income_statement()
try:
return self.__get_specific_year(self.income_statement,
year)['interestExpense']
except:
return None
def depreciation(self, year):
self.__set_cash_flow_statement()
try:
return self.__get_specific_year(self.cash_flow_statement,
year)['depreciation']
except:
return None
def cost_of_revenue(self, year):
self.__set_income_statement()
try:
return self.__get_specific_year(self.income_statement,
year)['costOfRevenue']
except:
return None
def total_receivables(self, year):
self.__set_balance_sheet()
try:
return self.__get_specific_year(self.balance_sheet,
year)['netReceivables']
except:
return None
def total_liabilities(self, year):
self.__set_balance_sheet()
try:
return self.__get_specific_year(self.balance_sheet,
year)['totalLiab']
except:
return None
def total_assets(self, year):
self.__set_balance_sheet()
try:
return self.__get_specific_year(self.balance_sheet,
year)['totalAssets']
except:
return None
def total_capital(self, year):
self.__set_balance_sheet()
try:
return self.__get_specific_year(
self.balance_sheet,
year)['totalStockholderEquity'] + self.total_debt(year)
except:
return None
def total_equity(self, year):
try:
return self.total_assets(year) - self.total_liabilities(year)
except:
return None
def capital_expenditures(self, year):
self.__set_cash_flow_statement()
try:
return self.__get_specific_year(self.cash_flow_statement,
year)['capitalExpenditures']
except:
return None
def net_income(self, year):
self.__set_income_statement()
try:
return self.__get_specific_year(self.income_statement,
year)['netIncome']
except:
return None
def gross_profit(self, year):
self.__set_income_statement()
try:
return self.__get_specific_year(self.income_statement,
year)['grossProfit']
except:
return None
def earnings_per_share(self):
try:
return self.financials.get_earnings_per_share()
except:
return None
def pe_ratio(self):
try:
return self.financials.get_pe_ratio()
except:
return None
def enterprise_value(self):
try:
return self.get_key_statistics()['enterpriseValue']
except:
return None
def ebit(self, year):
self.__set_income_statement()
try:
return self.__get_specific_year(self.income_statement,
year)['ebit']
except:
return None
def ebitda(self, year):
try:
temp_net_income = abs(self.net_income(year))
temp_tax = abs(self.tax(year))
temp_interest = abs(self.interest(year))
temp_depreciation = abs(self.depreciation(year))
return temp_net_income + temp_tax + temp_interest + temp_depreciation
except:
return None
def quick_ratio(self, year):
try:
temp_liquid_assets = abs(self.liquid_assets(year))
temp_receivables = abs(self.total_receivables(year))
temp_liabilities = abs(self.total_liabilities(year))
return (temp_liquid_assets + temp_receivables) / temp_liabilities
except:
return None
def income_continuing_operations_margin(self, year):
try:
temp_ebit = self.ebit(year)
temp_revenue = abs(self.revenue(year))
return temp_ebit / temp_revenue
except:
return None
def net_margin(self, year):
try:
temp_net_income = self.net_income(year)
temp_revenue = self.revenue(year)
return temp_net_income / temp_revenue
except:
return None
def return_on_assets(self, year):
try:
ending_year = year
beginning_year = year - 1
temp_net_income = self.net_income(year)
beginning_total_assets = abs(self.total_assets(beginning_year))
ending_total_assets = abs(self.total_assets(ending_year))
return temp_net_income / (
(beginning_total_assets + ending_total_assets) / 2)
except:
return None
def return_on_capital(self, year):
try:
ending_year = year
beginning_year = year - 1
if ending_year >= 2018:
temp_ebit = self.ebit(year)
temp_tax_rate = self.new_corporate_tax_rate
beginning_total_capital = abs(
self.total_capital(beginning_year))
ending_total_capital = abs(self.total_capital(ending_year))
return (temp_ebit * (1 - temp_tax_rate)) / (
(beginning_total_capital + ending_total_capital) / 2)
elif ending_year < 2018:
temp_ebit = self.ebit(year)
temp_tax_rate = self.old_corporate_tax_rate
beginning_total_capital = abs(
self.total_capital(beginning_year))
ending_total_capital = abs(self.total_capital(ending_year))
return (temp_ebit * (1 - temp_tax_rate)) / (
(beginning_total_capital + ending_total_capital) / 2)
except:
return None
def return_on_equity(self, year):
try:
temp_ebit = self.ebit(year)
temp_total_equity = abs(self.total_equity(year))
return temp_ebit / temp_total_equity
except:
return None
def cash_flow_operations(self, year):
try:
temp_revenue = abs(self.revenue(year))
temp_operating_expenses = abs(self.operating_expenses(year))
return temp_revenue - temp_operating_expenses
except:
return None
def free_cash_flow(self, year):
try:
if year >= 2018:
temp_cfo = self.cash_flow_operations(year)
temp_interest = self.interest(year)
temp_tax_rate = self.new_corporate_tax_rate
temp_capex = self.capital_expenditures(year)
return temp_cfo + (temp_interest *
(1 - temp_tax_rate)) - temp_capex
elif year < 2018:
temp_cfo = self.cash_flow_operations(year)
temp_interest = self.interest(year)
temp_tax_rate = self.old_corporate_tax_rate
temp_capex = self.capital_expenditures(year)
return temp_cfo + (temp_interest *
(1 - temp_tax_rate)) - temp_capex
except:
return None
def beta(self):
try:
return self.financials.get_beta()
except:
return None
def cost_of_equity(self):
try:
return self.risk_free_ror + (
self.beta() * (self.market_ror - self.risk_free_ror))
except:
return None
def gross_profit_margin(self, year):
try:
return (self.revenue(year) -
self.cost_of_revenue(year)) / self.revenue(year)
except:
return None
def operating_profit_margin(self, year):
try:
return self.ebit(year) / self.revenue(year)
except:
return None
def net_profit_margin(self, year):
try:
return self.net_income(year) / self.revenue(year)
except:
return None
def short_ratio(self):
try:
return self.get_key_statistics()['shortRatio']
except:
return None
company = 'AAPL'
yahoo_financials = YahooFinancials(company)
data = yahoo_financials.get_financial_stmts('annual', 'income')
print(f'{data} \n\n') # uncoment to see how data is structured
# Organizing Data.
# Note to self: You will use this data to evaluate if the company is an OPM Addict
annual_statements = data["incomeStatementHistory"][
company] #a list containing dictionaries
print(f'4 YEARS OF INCOME STATEMETS FOR {company}\n')
for index in range(
len(annual_statements)): #looping over each yearly statement
for date in annual_statements[
index]: # this loops over each key in my dictionary
print(date)
for accounting_item, value in annual_statements[index][date].items(
): #loops over each of the accounting item of the Financial Statement (each item is the key of a dictionary)
print(f"\t {accounting_item}: {value}")
print('')
'''
Note to self: If you know the market cap of a company and you know its share
price, then figuring out the number of outstanding shares is easy. Just take
the market capitalization figure and divide it by the share price. The result
is the number of shares on which the market capitalization number was based.
'''
# TO DO: fork API and see if you can edit code to get EPS yearly for 10 years
print(yahoo_financials.get_earnings_per_share())