Portfolio Analysis #1

(Description)

 

I am a student of B.com H Financial Markets (BSE) and in my academics, I’ve been taught how to invest in stock markets and analysis. I’m a third-year student and by the time I have a good knowledge of stocks and Mutual funds.

Me and one of my friends have decided to invest some of our funds in the market but we don’t want an existing portfolio to invest in instead, we want to create our own portfolio and do the same, for we have decided that I will do all the analysis stuff and he will allocate the funds. I am using Python for the analysis part.
How I did the analysis and stock selection will be described in this document.

 

 

 

 

 I have to create my own portfolio so for that I have to select some stocks and I’m going to select only large cap stocks because large cap stocks are stable and mature investments, large cap stocks have lower volatility, greater analyst coverage, and perhaps a steady dividend stream.

 

I have selected stocks from two sectors i.e., Banking and Computer software Sector.

 

 

Stocks in my portfolio & their tickers

 

1.      State Bank of India: SBIN

2.      Kotak Mahindra Bank Ltd: KOTAKBANK

3.      ICICI Bank: ICICIBANK

4.      HDFC Bank: HDFC

5.      Axis Bank: AXISBANK

6.      Tata Consultancy Service Ltd: TCS

7.      Mphasis Ltd: MPHASIS

8.      Infosys Ltd: INFY

 

 

 

Importing Libraries

 

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

import datetime

from pandas_datareader import data as web

from functools import reduce

 

 

 

 

 

 

Getting Historical Stock Data from Yahoo Finance

 

stocks      = {'HDFC.NS':'HDFC', 'TCS.NS':'TCS', 'INFY.NS' : 'INFY',  'ICICIBANK.NS': 'ICICI', 'SBIN.NS':'STATEBANKOFINDIA','AXISBANK.NS':'AXIS' ,  'KOTAKBANK.NS' : 'KOTAK', 'HCLTECH.NS' : 'HCL', 'MPHASIS.NS' : 'MPHASIS'}

instruments = {**stocks}

tickers     = list(instruments.keys())



start = datetime.datetime(2015,1,1)

end   = datetime.datetime(2020,1,1)

 

instruments_data = {}

for ticker, instrument in instruments.items():

    instruments_data[ticker] = web.DataReader(ticker, data_source = 'yahoo', start = start, end = end)

 

 

For my analysis, I am taking historical data for the last 6 years, from 2015 to 2021.

My analysis will be based on the performance of the stock for the last 6 years.

 

 

for ticker, instrument in instruments.items():

    instruments_data[ticker] = instruments_data[ticker]["Adj Close"]

 

 

 

tr_days_per_year = data_df['HDFC.NS'].groupby([data_df['HDFC.NS'].index.year]).agg('count')

tr_days_per_year = pd.DataFrame([tr_days_per_year], index = ["All instruments (merged)"])

 

 

data = list(instruments_data.values())

data_df = reduce(lambda x, y: pd.merge(x, y, left_index=True, right_index=True, how='outer'), data).dropna()

data_df.columns = tickers

 

 

data_df

 

 



Now I have all my stocks with their historical Adjusted Close prices Date wise, I can now visualize the price of these stocks using Matplotlib.

 

fig, ax = plt.subplots(figsize=(12,8))

data_df.plot(ax = plt.gca(),grid = True)

ax.set_title('Adjusted Close for all instruments')

ax.set_facecolor((0.95, 0.95, 0.99))

ax.grid(c = (0.75, 0.75, 0.99))

plt.show()

 



 

 

 

RISK & RETURN ANALYSIS

 

 Return on an Instrument represents a combination of dividends (in stocks) and changes in the price (capital gain or lose)

 

 

 






 We will use log returns. From the formula, we can see that the sum of the log differences can be interpreted as the total change over the period summed.

 

log_returns = data_df.pct_change()

 

 

log_returns.plot(grid = True, figsize = (15,10)).axhline(y = 0, color = "black", lw = 2)

plt.show

 

 



 

 

The above Log Return shows that Returns are quite stable for most of the instruments.

 

 

Now we will calculate Annual Percentage Rate (APR)

 

APR = log_returns.groupby([log_returns.index.year]).agg('sum')

APR_avg = APR.mean()

pd.DataFrame(APR_avg, columns=['Average APR']).T

 

 



 


 

Now we will calculate the Average Percentage Yield (APY)

 

N = np.array(tr_days_per_year.T)

N_total = np.sum(N)

APY = (1  + APR / N )**N - 1

APY_avg = (1  + APR_avg /N_total  )**N_total - 1

 

 

pd.DataFrame(APY_avg, columns = ['Average APY']).T

 

 



 

 



 

 

 

RISK CALCULATION

 

 Standard Deviation (Annualized)

 

STD = log_returns.groupby([log_returns.index.year]).agg('std') * np.sqrt(252)

STD_avg = STD.mean()

 

pd.DataFrame(STD_avg, columns = ['Average STD']).T

 



Variance (Annualized)

 

VAR = STD **2

VAR_avg = VAR.mean()

 

pd.DataFrame(VAR_avg, columns = ['Average VAR']).T

 



Average Annualized Variance for all 6 years



RISK VS RETURN

 

# configuration - generate different colors & sizes

c = [y + x for y, x in zip(APY_avg, STD_avg)]

c = list(map(lambda x : x /max(c), c))

s = list(map(lambda x : x * 600, c))

# plot

fig, ax = plt.subplots(figsize = (16,12))

ax.set_title(r"Risk ($\sigma$) vs Return ($APY$) of all  instruments")

ax.set_facecolor((0.95, 0.95, 0.99))

ax.grid(c = (0.75, 0.75, 0.99))

ax.set_xlabel(r"Standard Deviation $\sigma$")

ax.set_ylabel(r"Annualized Percetaneg Yield $APY$ or $R_{effective}$")

ax.scatter(STD_avg, APY_avg, s = s , c = c , cmap = "Blues", alpha = 0.4, edgecolors="grey", linewidth=2)

ax.axhline(y = 0.0,xmin = 0 ,xmax = 5,c = "blue",linewidth = 1.5,zorder = 0,  linestyle = 'dashed')

ax.axvline(x = 0.0,ymin = 0 ,ymax = 40,c = "blue",linewidth = 1.5,zorder = 0,  linestyle = 'dashed')

for idx, instr in enumerate(list(STD.columns)):

    ax.annotate(instr, (STD_avg[idx] + 0.01, APY_avg[idx]))

 

plt.show()

 



 

For Risk VS Return I have taken the Average Percentage Yield and Standard Deviation and the result shows that the stocks I’ve selected are on average risk and return ratio.
Only the stock SBIN is on low scale of risk VS return.
HDFC & MPHASIS are little to high on the scale but they are no threat, they will generate a good interest in future.

 

Now I know which stock to invest in and which to not, I can easily alter my portfolio and start investing.

Thank For Reading. 

Comments

Post a Comment

Popular posts from this blog

Net Present Value (NPV) On Python Using Numpy

Image
Net present value (NPV) is the difference between the present value of cash inflows and the present  value  of cash outflows over a period of time.   NPV is used in  capital budgeting  and investment planning. The NPV Rule is:- If  NPV > 0  Then the project is Accepted  If  NPV < 0 Then the project is Rejected The formula for calculating NPV is - = net present value = net cash flow at time t = discount rate = time of the cash flow This is how NPV is calculated manually with the generic formula, now we are going to use NumPy for calculating the NPV of a project. Here is an example. The initial investment is $100. The cash inflows in the next five years are $50, $60, $70, $100, and $20, starting from year one. If the discount rate is 11.2%, what is the project's NPV value?  #import Numpy  import  numpy  as  np #Put/define values in the cashflows & Interestrate. CF0 =...
Read more

Commodity Channel Index ( CCI ) Using Python

Image
The CCI compares the  current price  to an  average price  over a period of time. The indicator fluctuates above or below zero, moving into positive or negative territory. While most values, approximately 75%, fall between -100 and +100, about 25% of the values fall outside this range, indicating a lot of weakness or strength in the price movement. CCI is calculated with the following formula: (Typical Price - Simple Moving Average) / (0.015 x Mean Deviation) When the CCI is above +100, this means the price is well above the average price as measured by the indicator. When the indicator is below -100, the price is well below the average price. A basic CCI strategy is used to track the CCI for movement above +100, which generates  buy signals , and movements below -100, which generates  sell  or  short  trade signals. Investors may only want to take the buy signals, exit when the sell signals occur, and then re-invest when the buy signal...
Read more

SMA Trading Strategy Using Python

Image
This strategy works on the basic logic that whenever the 30 Day Simple Moving Average is greater than the closing price of the stock it gives a Buy signal and whenever the 30 Day SMA is smaller than the closing price then it gives a sell signal. This way we get a clear understanding of when to place a buy order and when to exit our position. I've built this strategy using python and here is the program and logic for the strategy. #import libraries import  pandas  as  pd import  numpy  as  np import  matplotlib.pyplot  as  plt plt.style.use ( 'fivethirtyeight' ) #Load data from  google.colab  import  files files.upload () #Store the data df = pd.read_csv ( 'HDFC.NS.csv' ) #set date as index df = df.set_index ( pd.DatetimeIndex ( df [ 'Date' ] .values )) #show data df #visualize the close price plt.figure ( figsize= ( 16 , 8 )) plt.title ( 'Close Pri...
Read more