How Python Is Used in Finance: Real Wall Street Use Cases

import yfinance as yf
import pandas as pd
import matplotlib.pyplot as plt

# Download stock data
ticker = yf.Ticker("AAPL")
df = ticker.history(period="2y")  # 2 years of daily data

print(df.head())
print(f"\nDate range: {df.index[0].date()} to {df.index[-1].date()}")
print(f"Total trading days: {len(df)}")
print(f"\nPrice stats:\n{df['Close'].describe()}")

pip install yfinance

def compare_stocks(tickers: list[str], period: str = "1y") -> pd.DataFrame:
    data = {}
    for ticker in tickers:
        stock = yf.Ticker(ticker)
        hist = stock.history(period=period)
        data[ticker] = hist["Close"]
    
    df = pd.DataFrame(data)
    
    # Normalize to 100 (percentage returns from start)
    normalized = df / df.iloc[0] * 100
    
    return normalized

# Compare tech giants
comparison = compare_stocks(["AAPL", "GOOGL", "MSFT", "AMZN"])

plt.figure(figsize=(12, 6))
for col in comparison.columns:
    plt.plot(comparison.index, comparison[col], label=col)

plt.title("Stock Performance (Normalized to 100)")
plt.ylabel("Relative Performance")
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

import numpy as np

# Get stock data
aapl = yf.Ticker("AAPL").history(period="2y")

# Daily returns
aapl["Daily_Return"] = aapl["Close"].pct_change()

# Cumulative returns
aapl["Cumulative_Return"] = (1 + aapl["Daily_Return"]).cumprod() - 1

# Summary statistics
print("Return Statistics:")
print(f"  Average daily return: {aapl['Daily_Return'].mean():.4%}")
print(f"  Daily volatility:     {aapl['Daily_Return'].std():.4%}")
print(f"  Annualized return:    {aapl['Daily_Return'].mean() * 252:.2%}")
print(f"  Annualized volatility:{aapl['Daily_Return'].std() * np.sqrt(252):.2%}")
print(f"  Total return:         {aapl['Cumulative_Return'].iloc[-1]:.2%}")

def sharpe_ratio(returns: pd.Series, risk_free_rate: float = 0.05) -> float:
    """
    Annualized Sharpe ratio.
    risk_free_rate: annual rate (default 5%)
    """
    daily_rf = risk_free_rate / 252
    excess_returns = returns - daily_rf
    return (excess_returns.mean() / excess_returns.std()) * np.sqrt(252)

sharpe = sharpe_ratio(aapl["Daily_Return"].dropna())
print(f"AAPL Sharpe Ratio (2 years): {sharpe:.2f}")

def max_drawdown(prices: pd.Series) -> float:
    """Maximum peak-to-trough decline."""
    cumulative = (1 + prices.pct_change()).cumprod()
    rolling_max = cumulative.cummax()
    drawdown = (cumulative - rolling_max) / rolling_max
    return drawdown.min()

mdd = max_drawdown(aapl["Close"])
print(f"Maximum Drawdown: {mdd:.2%}")

import yfinance as yf
import pandas as pd
import numpy as np

def analyze_portfolio(tickers: list[str], weights: list[float], period: str = "1y") -> dict:
    """Analyze a stock portfolio's performance and risk."""
    
    assert abs(sum(weights) - 1.0) < 1e-9, "Weights must sum to 1"
    
    # Download data
    prices = {}
    for ticker in tickers:
        stock = yf.Ticker(ticker)
        prices[ticker] = stock.history(period=period)["Close"]
    
    price_df = pd.DataFrame(prices).dropna()
    returns = price_df.pct_change().dropna()
    
    # Portfolio returns
    portfolio_returns = (returns * weights).sum(axis=1)
    
    # Metrics
    metrics = {
        "annual_return": portfolio_returns.mean() * 252,
        "annual_volatility": portfolio_returns.std() * np.sqrt(252),
        "sharpe_ratio": sharpe_ratio(portfolio_returns),
        "max_drawdown": max_drawdown(price_df.iloc[:, 0]),  # Simplified
        "total_return": (1 + portfolio_returns).prod() - 1,
    }
    
    # Individual stock contributions
    individual = {}
    for ticker, weight in zip(tickers, weights):
        stock_return = returns[ticker].mean() * 252
        individual[ticker] = {
            "weight": weight,
            "annual_return": stock_return,
            "contribution": weight * stock_return,
        }
    
    return {"portfolio": metrics, "individual": individual}


# Example portfolio
portfolio = analyze_portfolio(
    tickers=["AAPL", "MSFT", "GOOGL", "AMZN", "NVDA"],
    weights=[0.25, 0.25, 0.20, 0.15, 0.15],
    period="1y"
)

print("Portfolio Metrics:")
for metric, value in portfolio["portfolio"].items():
    print(f"  {metric:25}: {value:.2%}")

def sma_strategy(ticker: str, short_window: int = 20, long_window: int = 50) -> pd.DataFrame:
    """
    Simple Moving Average crossover strategy.
    Buy when short SMA crosses above long SMA.
    Sell when short SMA crosses below long SMA.
    """
    data = yf.Ticker(ticker).history(period="2y")[["Close"]].copy()
    
    data["SMA_short"] = data["Close"].rolling(window=short_window).mean()
    data["SMA_long"] = data["Close"].rolling(window=long_window).mean()
    
    # Signal: 1 = long, 0 = flat
    data["Signal"] = 0
    data.loc[data["SMA_short"] > data["SMA_long"], "Signal"] = 1
    
    # Position changes
    data["Position"] = data["Signal"].diff()
    
    # Strategy returns
    data["Market_Return"] = data["Close"].pct_change()
    data["Strategy_Return"] = data["Market_Return"] * data["Signal"].shift(1)
    
    # Cumulative
    data["Cumulative_Market"] = (1 + data["Market_Return"]).cumprod()
    data["Cumulative_Strategy"] = (1 + data["Strategy_Return"]).cumprod()
    
    return data

results = sma_strategy("AAPL")
final = results.dropna()

print("SMA Strategy Results for AAPL:")
print(f"Buy & Hold Return:     {final['Cumulative_Market'].iloc[-1] - 1:.2%}")
print(f"Strategy Return:       {final['Cumulative_Strategy'].iloc[-1] - 1:.2%}")

import numpy as np
from scipy.stats import norm

def black_scholes(S, K, T, r, sigma, option_type="call") -> float:
    """
    Black-Scholes option pricing formula.
    S: current stock price
    K: strike price
    T: time to expiration (years)
    r: risk-free interest rate
    sigma: volatility (annualized)
    """
    d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)
    
    if option_type == "call":
        price = S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
    else:  # put
        price = K * np.exp(-r * T) * norm.cdf(-d2) - S * norm.cdf(-d1)
    
    return price

# Example: Apple call option
price = black_scholes(
    S=180,      # Current stock price $180
    K=185,      # Strike price $185
    T=30/365,   # 30 days to expiration
    r=0.05,     # 5% risk-free rate
    sigma=0.25, # 25% implied volatility
    option_type="call"
)
print(f"Call option price: ${price:.2f}")