A Python-Based Approach to Deriving Normal, Up, and Down Beta Using LSEG Data Library

This article and sample code demonstrate how to use the LSEG Data Library for Python to calculate Normal Beta, Beta Up, and Beta Down for any company and index on any given date, following the methodology outlined in the Company Beta Types – Historical Workspace Excel template.

This methodology incorporates different parameters for each type of Beta, including the calculation range and the periodicity of the data.

• Normal Beta measures a security’s volatility relative to the overall market.
• Beta Up measures a security’s volatility relative to the market, but only on days when the benchmark’s return is positive.
• Beta Down measures a security’s volatility relative to the market, but only on days when the benchmark’s return is negative.

Formula

Calculation

The following steps are used to calculate the Company Beta Types - Historical.

Python Code

The sample code imports and uses the following Python libraries:

• lseg.data: Provides high‑level APIs for accessing market data—such as prices, fundamentals, and news—from LSEG platforms (for example, the Data Platform and Workspace).
• lseg.data.content.historical_pricing: Exposes the historical pricing endpoint, which enables access to time‑series price data (such as OHLC, closing prices, and volume) for instruments identified by symbols or identifiers like RICs
• NumPy: Supports numerical computing with arrays and vectorized mathematical operations.
• Pandas: Provides Series and DataFrame structures for working with tabular and time‑series data, making it well suited for pricing data analysis, resampling, joins, and rolling calculations.

Then, the code calls the ld.open_session() method to establish a connection to the Workspace desktop session.

Step 1: Price series of the Stock and Index

The function defined for this step accepts the following parameters:

• ric (str): The stock RIC.
• index (str): The index RIC.
• interval (str): An interval string for filtering historical pricing events, such as P1D (daily), P1W (weekly), and P1M (monthly)ใ
• end (str): The end-date string for querying events, formatted as YYYY‑MM‑DD.
• datapoints (int): A maximum number of rows to return.

It will return a data frame.

This function uses the historical_pricing endpoint to retrieve historical close pricings for both the stock and the index. It then merges the results into a single DataFrame and returns it to the caller.

Example

The function can be called like this:

The output is:

91 rows × 2 columns

Step 2: Calculation of return from the stock and index

The function defined for this step takes the data frame produced in the first step as input. It uses the close prices from that data frame to calculate the returns for both the stock and the index, and then returns a new data frame to the caller.

Example

The function can be called like this:

The output is:

90 rows × 2 columns

Step 3: Exclusion of values that are not negative or positive from the index return series

The function defined for this step accepts the data frame produced in the second step, along with the calculation method to be applied.

• input_df (pd.DataFrame): The data frame generated from the second step.
• beta (str): The calculation method used to compute the beta value. Valid options include '', 'up', or 'down'.

If the calculation method is 'up', all zero and negative index returns are replaced with NaN.

If the calculation method is 'down', all zero and positive index returns are replaced with NaN.

If the calculation method is the normal mode (''), a copy of the input data frame is returned unchanged.

Examples

The function can be called like this:

Normal Beta

Beta Up

Beta Down

The output is:

90 rows × 2 columns

Step 4: Series of negative or positive Index Return

The function defined for this step takes the data frame produced in the third step, removes all unavailable data, and returns the cleaned data frame to the caller.

Example

The function can be called like this:

The output is:

90 rows × 2 columns

Step 5: Calculation of BETA's value

The function defined for this step uses the data frame produced in the fourth step to calculate a beta value.

It applies the numpy.polyfit function to estimate the relationship between stock returns and index returns—a common approach for computing beta in finance. The function passes the stock returns as the first argument (the x-coordinates of the sample points), the index returns as the second argument (the y-coordinates), and 1 as the third argument to indicate a first‑degree polynomial fit.

The function then returns the first value produced by numpy.polyfit, which corresponds to the slope of the fitted line.

Example

The function can be called like this:

The output is:

np.float64(0.5307264916476)

Usage

To use these functions, you must define a list of parameters used to calculate beta values. Each entry includes the following properties:

• Name: The name of Beta value
• Periodicity: An interval string for filtering historical pricing events, such as P1D (daily), P1W (weekly), and P1M (monthly)
• Data Points: A maximum number of rows to return
• Rule of % Available: A percentage number of data points to be available for calculation
• Calculation Method: The calculation method used to compute the beta value. Valid options include '', 'up', or 'down'

The following code defines 11 rules used to calculate beta values.

The output is:

Next, define a function that iterates through all entries in the list and calculates the beta values for each one. The function accepts the following parameters:

• input_df (pd.DataFrame): The data frame containing the rules for calculating beta values.
• ric (str): The stock RIC.
• index (str): The index RIC.
• end (str): The end-date string for querying events, formatted as YYYY‑MM‑DD.

This function invokes the methods defined in Steps 1 through 5 and returns a data frame containing the resulting beta values.

Example

The function can be called like this:

The output is:

Summary

The article provides a step‑by‑step translation of the Workspace Excel formulas used in the Company Beta Types – Historical Excel template into Python code. Its primary goal is to demonstrate how to compute three key beta measures—Normal Beta, Beta Up, and Beta Down—for any selected company and benchmark index on any specified date.

To achieve this, the article leverages the LSEG Data Library for Python, which serves as the data‑access layer for retrieving historical closing prices for both the target stock and its corresponding index. Once the historical price series is obtained, the workflow proceeds by transforming the prices into return series, typically using daily percentage changes or log returns, depending on the analytical convention.

After constructing the return series for both the stock and the index, the article explains how to apply the same logic embedded in the Excel template to compute the different beta types. Normal Beta is derived from the covariance of stock and index returns relative to the variance of index returns. Beta Up and Beta Down are calculated using return subsets filtered on whether index returns are positive or negative, respectively—mirroring the conditional calculations performed in the Workspace Excel template.

By walking through each stage of the process—from data retrieval to return transformation to beta estimation—the article not only replicates the Excel workflow but also illustrates how these computations can be automated, reproduced, and scaled in Python for broader analytical applications.