How to Calculate Expected Return and Beta with Python: Stock Analysis with Python

After wrapping up my previous post on calculating the Sharpe ratio with Python, the first thing that came to mind was to explore expected return and beta. While I enjoy the potential rewards of taking on financial risk, I also have a fixed income, which means I need to be extra cautious when adding new stocks to my portfolio.

That said, technical analysis is far from the ultimate truth in financial decision-making. Still, I enjoy coding these financial analysis tools in Python because they’re both fun and insightful. Plus, with the rise of AI-powered tools, even fundamental analysis is becoming easier to handle with AI agents. I’ll definitely try my luck there. Fortune favors the brave, haha.

This blog isn’t just about financial tools and code. The last two posts happened to be two things I love: Python and stock market investing. If I were passionate about fishing instead, I’d probably find a way to code something for that. I know it’s possible!

Expected return is an excellent metric for weighing investment options. When I estimate a higher return from an asset, I consider giving it more weight in my portfolio. Simple, right? After all, if you want to win games, you need to outscore your opponent /s. The same logic applies to beta, too. Sure, there’s advice like “buy the market in the long run,” but as Keynes put it, “in the long run, we are all dead.” (Okay, look. Studying economics was hard, I have to mention Keynes one way or another. Thanks).

One important thing to remember is that historical data doesn’t guarantee future results. External factors can unexpectedly alter the direction and severity of an investment’s performance. Let’s not fall into the trap of the Gambler’s Fallacy (a topic I’ll tackle in a future post, because why not).

What Is Beta, and Why Is It Important?

Beta is a measure of a stock's volatility in relation to the overall market. In simple terms, beta tells you how much a stock's price tends to move when the market moves.

Beta > 1: The stock is more volatile than the market. If the market goes up by 1%, this stock might go up by more than 1%. High beta stocks offer high returns but come with higher risks.
Beta = 1: The stock moves in line with the market.
Beta < 1: The stock is less volatile than the market, making it a safer choice.
Beta < 0: This is rare, but it means the stock moves in the opposite direction of the market.

Why is beta important? Because it’s a core component of risk assessment. It’s not just about knowing how much a stock moves but understanding how it moves in relation to the market. This is critical for portfolio diversification and risk management.

Calculating Expected Return and Beta with Python I’ll share the full code at the bottom, but first, let’s take a look at the pseudocode first. This approach calculates both the expected return and beta of a stock based on historical data. I’ll try to be as verbose as possible at this time.

Pseudocode

Input the following details:
- Stock ticker symbol (e.g., AAPL for Apple).
- Start and end dates for historical data.
- Risk-free return rate (e.g., 0.04 for 4%).
- Market index ticker symbol (e.g., ^GSPC for the S&P 500).
Fetch historical price data:
- Use yfinance to retrieve closing prices for both the stock and the market index.
Calculate daily returns:
- Compute the percentage change in closing prices for both datasets.
Metrics to calculate:
- Expected Return:
  - Formula: Average daily return × Number of trading days in a year (252).
- Beta:
  - Formula: Covariance of stock and market returns / Variance of market returns.
- Volatility:
  - Formula: Standard deviation of daily returns × Square root of trading days.
- Sharpe Ratio:
  - Formula: (Expected Return - Risk-Free Rate) / Volatility.
Analyze results:
- Evaluate the calculated beta to understand the stock’s sensitivity to market movements.
- Use expected return and Sharpe Ratio to assess potential performance and risk-adjusted returns.
Output the insights:
- Display metrics in a structured format, highlighting key findings like beta, expected return, and Sharpe Ratio.

Why Use Python for This?

There is a short answer to that: I don’t have to find, export, and mingle with the raw stock data, yfinance handles that for me. The rest is basic statistical calculations that can be easily done via Python. Shorter answer: it is easy to do that way. Even shorter: it is fun. In the end, all the statistical mumbo jumbo boils down to this:

data = yf.download([ticker, market_ticker], start=start_date, end=end_date)['Close']
stock = data[ticker].dropna()
market = data[market_ticker].dropna()

stock_returns = stock.pct_change().dropna()
market_returns = market.pct_change().dropna()

expected_return = stock_returns.mean() * TRADING_DAYS_PER_YEAR
beta = stock_returns.cov(market_returns) / market_returns.var()
stock_volatility = stock_returns.std() * np.sqrt(TRADING_DAYS_PER_YEAR)
sharpe_ratio = (expected_return - rf_rate) / stock_volatility

Let’s Run this code for AAPL

Enter stock ticker symbol: AAPL
Enter start date in YYYY-MM-DD: 2024-01-01
Enter end date in YYYY-MM-DD: 2025-01-01
Enter risk-free return rate (e.g., 0.04 for 4%): 0.042
Enter market ticker symbol (e.g., ^GSPC): ^GSPC

Above inputs will output this:

RETURN AND RISK METRICS:
Expected annual return: 33.05%
Annual volatility: 22.42%
Sharpe ratio: 1.29 (higher than 1 suggests good risk-adjusted returns)

DETAILED ANALYSIS:
The stock has shown very strong historical performance with an impressive expected annual return of 33.1%.
This comes with a moderate volatility of 22.4%, suggesting typical market-level price fluctuations.

MARKET SENSITIVITY (BETA) ANALYSIS:
Beta coefficient: 0.95

This stock shows moderate market sensitivity. When the market moves 1%, the stock typically moves 0.95% in the same direction. This indicates:
- More muted reactions to market movements
- Generally more stable performance
- Potentially suitable for balanced portfolios

Potential Improvements

As I said, I tried to upgrade my project with other financial tools I’m using in real life. So, improvements are always welcomed into projects like this. I’m thinking to add things such as:

Visualization of returns distribution
Getting the output in a separate file
Better error handling as it is non-existent
Maybe AI to write all that “insights” part?

Let me know if this works for you!

Cheers, Berkem

Try It Out

import yfinance as yf
import numpy as np
from datetime import datetime


TRADING_DAYS_PER_YEAR = 252


def validate_date(date_str: str) -> bool:
   try:
       datetime.strptime(date_str, '%Y-%m-%d')
       return True
   except ValueError:
       return False


def analyze_expected_return(ret: float, vol: float, sharpe: float) -> str:
   analysis = f"RETURN AND RISK METRICS:\n"
   analysis += f"Expected annual return: {ret*100:.2f}%\n"
   analysis += f"Annual volatility: {vol*100:.2f}%\n"
   analysis += f"Sharpe ratio: {sharpe:.2f} "
   analysis += f"(higher than 1 suggests good risk-adjusted returns)\n\n"
   analysis += "DETAILED ANALYSIS:\n"
  
   if ret > 0.15:
       analysis += "The stock has shown very strong historical performance with an impressive "
       analysis += f"expected annual return of {ret*100:.1f}%. "
   elif ret > 0.08:
       analysis += "The stock has demonstrated solid historical performance with a reasonable "
       analysis += f"expected annual return of {ret*100:.1f}%. "
   else:
       analysis += "The stock has shown relatively modest historical performance with an "
       analysis += f"expected annual return of {ret*100:.1f}%. "
  
   if vol > 0.25:
       analysis += f"\nHowever, note the high volatility of {vol*100:.1f}%, "
       analysis += "which indicates significant price fluctuations and higher risk."
   elif vol > 0.15:
       analysis += f"\nThis comes with a moderate volatility of {vol*100:.1f}%, "
       analysis += "suggesting typical market-level price fluctuations."
   else:
       analysis += f"\nNotably, the low volatility of {vol*100:.1f}% "
       analysis += "suggests more stable price movements."
   return analysis


def analyze_beta(beta: float) -> str:
   analysis = f"MARKET SENSITIVITY (BETA) ANALYSIS:\n"
   analysis += f"Beta coefficient: {beta:.2f}\n\n"
   if beta > 1.5:
       analysis += "This stock shows very high market sensitivity. "
       analysis += f"When the market moves 1%, the stock typically moves {beta:.2f}% in the same direction. "
       analysis += "This magnified response to market movements indicates:\n"
       analysis += "- Higher potential returns in up markets\n"
       analysis += "- Greater potential losses in down markets\n"
       analysis += "- Generally suitable for investors with high risk tolerance"
   elif beta > 1:
       analysis += "This stock shows above-average market sensitivity. "
       analysis += f"When the market moves 1%, the stock typically moves {beta:.2f}% in the same direction. "
       analysis += "This means:\n"
       analysis += "- The stock tends to outperform in rising markets\n"
       analysis += "- It may underperform in falling markets\n"
       analysis += "- Suitable for investors comfortable with market-plus risk"
   elif beta > 0.5:
       analysis += "This stock shows moderate market sensitivity. "
       analysis += f"When the market moves 1%, the stock typically moves {beta:.2f}% in the same direction. "
       analysis += "This indicates:\n"
       analysis += "- More muted reactions to market movements\n"
       analysis += "- Generally more stable performance\n"
       analysis += "- Potentially suitable for balanced portfolios"
   else:
       analysis += "This stock shows low market sensitivity. "
       analysis += f"When the market moves 1%, the stock typically moves only {beta:.2f}% in the same direction. "
       analysis += "This suggests:\n"
       analysis += "- Strong defensive characteristics\n"
       analysis += "- Potential hedge against market volatility\n"
       analysis += "- May be suitable for risk-averse investors"
   return analysis


def analyze_stock(
   ticker: str,
   start_date: str,
   end_date: str,
   rf_rate: float,
   market_ticker: str
) -> dict:
   data = yf.download([ticker, market_ticker], start=start_date, end=end_date)['Close']
   stock = data[ticker].dropna()
   market = data[market_ticker].dropna()
  
   stock_returns = stock.pct_change().dropna()
   market_returns = market.pct_change().dropna()
  
   expected_return = stock_returns.mean() * TRADING_DAYS_PER_YEAR
   beta = stock_returns.cov(market_returns) / market_returns.var()
   stock_volatility = stock_returns.std() * np.sqrt(TRADING_DAYS_PER_YEAR)
   sharpe_ratio = (expected_return - rf_rate) / stock_volatility


   return {
       "expected_return": expected_return,
       "volatility": stock_volatility,
       "beta": beta,
       "sharpe_ratio": sharpe_ratio,
       "return_analysis": analyze_expected_return(expected_return, stock_volatility, sharpe_ratio),
       "beta_analysis": analyze_beta(beta),
   }


# inputs
ticker = input("Enter stock ticker symbol: ")
start_date = input("Enter start date in YYYY-MM-DD: ")
while not validate_date(start_date):
   start_date = input("Invalid date. Enter start date in YYYY-MM-DD: ")


end_date = input("Enter end date in YYYY-MM-DD: ")
while not validate_date(end_date):
   end_date = input("Invalid date. Enter end date in YYYY-MM-DD: ")


rf_rate = float(input("Enter risk-free return rate (e.g., 0.04 for 4%): "))
market_ticker = input("Enter market ticker symbol (e.g., ^GSPC): ")


analysis = analyze_stock(ticker, start_date, end_date, rf_rate, market_ticker)
print(analysis["return_analysis"])
print("\n" + analysis["beta_analysis"])