Value Drivers & Financial Data Analytics with Python

3.2 How yfinance Works with Indian Stocks

yfinance is a Python wrapper around Yahoo Finance's API. It lets you download historical price data, financial statements, dividend history, and corporate actions — all into pandas DataFrames. For Indian stocks, the critical detail is the ticker suffix:

The .NS suffix is generally preferred because NSE data on Yahoo Finance tends to be more complete and liquid. Here is the basic pattern for creating a Ticker object and fetching data:

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

# Create a Ticker object for an Indian stock
ticker = yf.Ticker("RELIANCE.NS")

# Get basic company info
info = ticker.info
print(f"Company: {info.get('longName')}")
print(f"Sector: {info.get('sector')}")
print(f"Market Cap: {info.get('marketCap'):,} INR")
print(f"P/E Ratio: {info.get('trailingPE')}")

# Fetch historical price data — last 5 years
hist = ticker.history(period="5y")
print(hist.head())
# Columns: Open, High, Low, Close, Volume, Dividends, Stock Splits

3.3 Fetching Financial Statements Programmatically

yfinance provides three properties that return the financial statements as pandas DataFrames. Each has a transposed structure: columns are fiscal years, and rows are line items.

3.3.1 The Income Statement

# Fetch annual income statement
income_stmt = ticker.financials  # or ticker.income_stmt
print(income_stmt.columns)      # Fiscal year-end dates
print(income_stmt.index[:10])   # First 10 line items

# Key line items we care about:
# Total Revenue, Cost of Revenue, Gross Profit,
# Operating Income (EBIT), Net Income, EBITDA

The income statement is the starting point for computing revenue growth, margins, and operating profitability. Each column is a fiscal year, and the years run left to right (most recent on the left).

3.3.2 The Balance Sheet

# Fetch annual balance sheet
balance_sheet = ticker.balance_sheet
print(balance_sheet.columns)

# Key line items:
# Total Assets, Total Debt, Cash and Cash Equivalents,
# Total Equity, Current Assets, Current Liabilities,
# Accounts Receivable, Inventory, Accounts Payable

The balance sheet gives us invested capital, net debt, working capital components, and book value of equity.

3.3.3 The Cash Flow Statement

# Fetch annual cash flow statement
cash_flow = ticker.cashflow
print(cash_flow.columns)

# Key line items:
# Operating Cash Flow, Capital Expenditure,
# Free Cash Flow, Dividends Paid,
# Issuance/Repayment of Debt, Repurchase of Stock

The cash flow statement provides operating cash flow, capex, and free cash flow — the raw ingredients for DCF valuation.

import yfinance as yf
ticker = yf.Ticker("ASIANPAINT.NS")
income_stmt = ticker.financials

# 1. What is the shape of the DataFrame?
print(income_stmt.shape)

# 2. What are the column labels (fiscal year-end dates)?
print(list(income_stmt.columns))

# 3. How many line items (rows) are there?
print(len(income_stmt))

# 4. What are the first 5 line items?
print(list(income_stmt.index[:5]))

# 5. Does the line item 'Total Revenue' exist?
print('Total Revenue' in income_stmt.index)

3.4 Computing Key Value Drivers from the Data

With the raw financial data in pandas DataFrames, we can now compute the value drivers we identified in Chapter 1. The goal is to write clean, reusable functions that work for any company.

3.4.1 Revenue Growth Rate

def compute_revenue_growth(income_stmt):
    """Compute year-over-year revenue growth rates."""
    revenue = income_stmt.loc['Total Revenue']  # or 'Revenue'
    # Revenue is a Series with fiscal years as index
    growth_rates = revenue.pct_change(periods=-1) * 100
    # pct_change(periods=-1) computes (this_year - last_year) / last_year
    # Negative periods because columns go newest → oldest
    return growth_rates.dropna()

revenue_growth = compute_revenue_growth(income_stmt)
print("Revenue Growth Rates (%):")
print(revenue_growth)

3.4.2 Profit Margins

def compute_margins(income_stmt):
    """Compute gross, operating, and net margins."""
    revenue = income_stmt.loc['Total Revenue']
    gross_profit = income_stmt.loc['Gross Profit']
    ebit = income_stmt.loc['Operating Income']  # or 'EBIT'
    net_income = income_stmt.loc['Net Income']

    margins = pd.DataFrame({
        'Gross Margin (%)': (gross_profit / revenue) * 100,
        'Operating Margin (%)': (ebit / revenue) * 100,
        'Net Margin (%)': (net_income / revenue) * 100
    })
    return margins.round(2)

margins = compute_margins(income_stmt)
print(margins)

def compute_net_margin(income_stmt):
    # Revenue = income_stmt.loc['Total Revenue']
    # Net income line may be 'Net Income' or 'Net Income Common Stockholders'
    # Return net margin as a Series
    ...

3.4.3 Return on Invested Capital (ROIC)

ROIC is the most important value driver. We compute it as NOPAT divided by Invested Capital. For a preliminary calculation from yfinance data:

def compute_roic(income_stmt, balance_sheet):
    """Compute preliminary ROIC from financial statement data."""
    ebit = income_stmt.loc['Operating Income']
    # Estimate tax rate — yfinance sometimes has this, otherwise use 25%
    tax_rate = 0.25

    nopat = ebit * (1 - tax_rate)

    # Invested Capital = Total Equity + Total Debt - Cash
    total_equity = balance_sheet.loc['Total Equity Gross Minority Interest']
    total_debt = balance_sheet.loc['Total Debt']
    cash = balance_sheet.loc['Cash And Cash Equivalents']

    invested_capital = total_equity + total_debt - cash

    roic = (nopat / invested_capital) * 100
    return roic.round(2)

roic = compute_roic(income_stmt, balance_sheet)
print("ROIC (%):")
print(roic)

3.4.4 Efficiency Ratios

def compute_efficiency_ratios(income_stmt, balance_sheet):
    """Compute asset turnover and working capital ratios."""
    revenue = income_stmt.loc['Total Revenue']
    total_assets = balance_sheet.loc['Total Assets']
    receivables = balance_sheet.loc.get('Accounts Receivable', None)
    inventory = balance_sheet.loc.get('Inventory', None)
    payables = balance_sheet.loc.get('Accounts Payable', None)

    ratios = pd.DataFrame({
        'Asset Turnover': (revenue / total_assets).round(2),
    })

    if receivables is not None:
        ratios['Receivable Turnover'] = (revenue / receivables).round(2)
        ratios['Days Receivable'] = (365 / ratios['Receivable Turnover']).round(0)

    if inventory is not None:
        ratios['Inventory Turnover'] = (revenue / inventory).round(2)
        ratios['Days Inventory'] = (365 / ratios['Inventory Turnover']).round(0)

    return ratios

efficiency = compute_efficiency_ratios(income_stmt, balance_sheet)
print(efficiency)

3.4.5 Leverage Ratios

def compute_leverage_ratios(balance_sheet):
    """Compute debt ratios."""
    total_debt = balance_sheet.loc['Total Debt']
    total_equity = balance_sheet.loc['Total Equity Gross Minority Interest']
    total_assets = balance_sheet.loc['Total Assets']

    ratios = pd.DataFrame({
        'Debt-to-Equity': (total_debt / total_equity).round(2),
        'Debt-to-Assets': (total_debt / total_assets).round(2),
    })
    return ratios

leverage = compute_leverage_ratios(balance_sheet)
print(leverage)

3.4.6 Free Cash Flow Yield

def compute_fcf_yield(cash_flow, market_cap):
    """Compute Free Cash Flow Yield."""
    operating_cf = cash_flow.loc['Operating Cash Flow']
    capex = cash_flow.loc['Capital Expenditure']  # Usually negative
    free_cash_flow = operating_cf + capex  # capex is negative, so this subtracts

    fcf_yield = (free_cash_flow / market_cap) * 100
    return fcf_yield.round(2)

# market_cap from ticker.info['marketCap'] for the most recent year
fcf_yield = compute_fcf_yield(cash_flow, info['marketCap'])
print("FCF Yield (%):")
print(fcf_yield)

3.5 The Complete Value Driver Pipeline

Now we combine everything into a single, reusable function. Given a ticker symbol, it returns a comprehensive DataFrame of value drivers across all available fiscal years.

def fetch_and_analyze(ticker_symbol):
    """
    Fetch financial data for an Indian company and compute
    all key value drivers.

    Parameters
    ----------
    ticker_symbol : str
        Yahoo Finance ticker (e.g., 'RELIANCE.NS', 'TCS.NS')

    Returns
    -------
    dict containing DataFrames of growth, margins, ROIC,
    efficiency, leverage, and FCF yield.
    """
    ticker = yf.Ticker(ticker_symbol)
    info = ticker.info

    # --- Fetch Statements ---
    is_df    = ticker.financials       # Income Statement
    bs_df    = ticker.balance_sheet    # Balance Sheet
    cf_df    = ticker.cashflow         # Cash Flow Statement
    mkt_cap  = info.get('marketCap', None)

    # --- Compute Value Drivers ---
    results = {}

    # Revenue & Earnings Growth
    if 'Total Revenue' in is_df.index:
        rev = is_df.loc['Total Revenue']
        results['Revenue Growth (%)'] = rev.pct_change(periods=-1) * 100
        results['Revenue (Cr)'] = rev / 1e7  # Convert to crores

    if 'Net Income' in is_df.index:
        ni = is_df.loc['Net Income']
        results['Net Income Growth (%)'] = ni.pct_change(periods=-1) * 100

    # Margins
    if 'Total Revenue' in is_df.index and 'Gross Profit' in is_df.index:
        results['Gross Margin (%)'] = (is_df.loc['Gross Profit'] / is_df.loc['Total Revenue']) * 100

    if 'Total Revenue' in is_df.index and 'Operating Income' in is_df.index:
        results['Operating Margin (%)'] = (is_df.loc['Operating Income'] / is_df.loc['Total Revenue']) * 100

    if 'Total Revenue' in is_df.index and 'Net Income' in is_df.index:
        results['Net Margin (%)'] = (is_df.loc['Net Income'] / is_df.loc['Total Revenue']) * 100

    # ROIC (preliminary)
    if all(x in is_df.index for x in ['Operating Income']) and \
       all(x in bs_df.index for x in ['Total Equity Gross Minority Interest', 'Total Debt', 'Cash And Cash Equivalents']):
        ebit = is_df.loc['Operating Income']
        nopat = ebit * 0.75  # assuming 25% tax
        ic = bs_df.loc['Total Equity Gross Minority Interest'] + bs_df.loc['Total Debt'] - bs_df.loc['Cash And Cash Equivalents']
        results['ROIC (%)'] = (nopat / ic) * 100

    # Efficiency
    if 'Total Revenue' in is_df.index and 'Total Assets' in bs_df.index:
        results['Asset Turnover'] = is_df.loc['Total Revenue'] / bs_df.loc['Total Assets']

    # Leverage
    if 'Total Debt' in bs_df.index and 'Total Equity Gross Minority Interest' in bs_df.index:
        results['Debt-to-Equity'] = bs_df.loc['Total Debt'] / bs_df.loc['Total Equity Gross Minority Interest']

    # FCF Yield
    if mkt_cap and 'Operating Cash Flow' in cf_df.index and 'Capital Expenditure' in cf_df.index:
        fcf = cf_df.loc['Operating Cash Flow'] + cf_df.loc['Capital Expenditure']
        results['FCF Yield (%)'] = (fcf / mkt_cap) * 100

    # --- Compile into a single DataFrame ---
    drivers_df = pd.DataFrame(results).T  # Transpose: metrics as rows, years as columns
    drivers_df = drivers_df.round(2)
    drivers_df = drivers_df.sort_index(axis=1)  # Sort years chronologically

    return {
        'drivers': drivers_df,
        'info': info,
        'income_stmt': is_df,
        'balance_sheet': bs_df,
        'cash_flow': cf_df
    }

# --- Usage ---
result = fetch_and_analyze("TCS.NS")
print("=== Value Drivers for TCS ===")
print(result['drivers'])
print(f"\nCompany: {result['info'].get('longName')}")
print(f"Sector: {result['info'].get('sector')}")
print(f"Market Cap: {result['info'].get('marketCap'):,} INR")

# Intended: compute revenue growth for each fiscal year
revenue = income_stmt.loc['Total Revenue']
growth = revenue.pct_change()  # default periods=1 — but columns are newest-first!

print("Revenue Growth Rates:")
print(growth)

3.6 Multi-Company Value Driver Comparison

One of the most powerful applications of programmatic analysis is comparing value drivers across multiple companies simultaneously. The following function fetches data for a list of tickers and produces a comparison table for the most recent year:

def compare_companies(tickers, labels=None):
    """
    Fetch and compare value drivers across multiple companies
    for the most recent fiscal year.

    Parameters
    ----------
    tickers : list of str
        Yahoo Finance tickers
    labels : list of str, optional
        Display names (defaults to ticker symbols)

    Returns
    -------
    DataFrame with companies as columns and value drivers as rows
    """
    if labels is None:
        labels = [t.replace('.NS', '').replace('.BO', '') for t in tickers]

    all_drivers = {}

    for ticker, label in zip(tickers, labels):
        try:
            result = fetch_and_analyze(ticker)
            # Get the most recent year column
            latest_year = result['drivers'].columns[0]
            all_drivers[label] = result['drivers'][latest_year]
            print(f"✓ {label} — data fetched")
        except Exception as e:
            print(f"✗ {label} — error: {e}")

    comparison = pd.DataFrame(all_drivers)
    return comparison

# --- Compare top Indian IT companies ---
it_companies = {
    'TCS.NS':       'TCS',
    'INFY.NS':      'Infosys',
    'WIPRO.NS':     'Wipro',
    'HCLTECH.NS':   'HCL Tech',
    'TECHM.NS':     'Tech Mahindra'
}

comparison = compare_companies(
    list(it_companies.keys()),
    list(it_companies.values())
)
print("\n=== IT Sector Value Driver Comparison (Latest Year) ===")
print(comparison)

banks = {
    'HDFCBANK.NS': 'HDFC Bank',
    'ICICIBANK.NS': 'ICICI Bank',
    'SBIN.NS': 'SBI',
    'KOTAKBANK.NS': 'Kotak',
    'AXISBANK.NS': 'Axis'
}

3.7 Visualizing Value Drivers with matplotlib and seaborn

Numbers in tables are precise; charts reveal patterns. Let us create visualizations that make value driver trends immediately obvious.

3.7.1 Trend Charts for a Single Company

import matplotlib.pyplot as plt
import seaborn as sns

sns.set_style("darkgrid")
plt.rcParams['figure.figsize'] = (12, 5)

def plot_value_drivers_trend(result, company_name):
    """Plot revenue growth, margins, and ROIC over time."""
    drivers = result['drivers']

    fig, axes = plt.subplots(1, 3, figsize=(16, 5))

    # Revenue & Net Income Growth
    ax = axes[0]
    growth_metrics = ['Revenue Growth (%)', 'Net Income Growth (%)']
    for metric in growth_metrics:
        if metric in drivers.index:
            ax.plot(drivers.columns, drivers.loc[metric], marker='o', label=metric)
    ax.set_title(f'{company_name}: Growth Trends')
    ax.legend()
    ax.axhline(y=0, color='red', linestyle='--', alpha=0.5)
    ax.tick_params(axis='x', rotation=45)

    # Margins
    ax = axes[1]
    margin_metrics = ['Gross Margin (%)', 'Operating Margin (%)', 'Net Margin (%)']
    for metric in margin_metrics:
        if metric in drivers.index:
            ax.plot(drivers.columns, drivers.loc[metric], marker='s', label=metric)
    ax.set_title('Margin Trends')
    ax.legend()
    ax.tick_params(axis='x', rotation=45)

    # ROIC
    ax = axes[2]
    if 'ROIC (%)' in drivers.index:
        ax.bar(range(len(drivers.columns)), drivers.loc['ROIC (%)'],
               color=['#6c8cff' if v > 15 else '#e0556a' for v in drivers.loc['ROIC (%)']])
        ax.set_xticks(range(len(drivers.columns)))
        ax.set_xticklabels([str(d).split('-')[0] for d in drivers.columns], rotation=45)
        ax.set_title('ROIC (%) — Green = >15%')
        ax.axhline(y=15, color='green', linestyle='--', alpha=0.7, label='15% threshold')
        ax.legend()

    plt.tight_layout()
    plt.show()

# Usage
result = fetch_and_analyze("ASIANPAINT.NS")
plot_value_drivers_trend(result, "Asian Paints")

3.7.2 Sector Comparison Heatmap

def plot_sector_heatmap(comparison_df):
    """Create a heatmap comparing value drivers across companies."""
    plt.figure(figsize=(14, 6))
    sns.heatmap(comparison_df, annot=True, fmt='.1f', cmap='RdYlGn',
                center=0, linewidths=0.5, cbar_kws={'label': 'Value'})
    plt.title('Sector Value Driver Comparison')
    plt.tight_layout()
    plt.show()

# plot_sector_heatmap(comparison)

3.8 Handling Common Data Issues with Indian Stocks

Real-world financial data is messy. Here are the most common issues you will encounter when fetching Indian company data and how to handle them:

# This sometimes raises a KeyError!
revenue = income_stmt.loc['Total Revenue']
net_income = income_stmt.loc['Net Income']
net_margin = (net_income / revenue) * 100
print(net_margin)