Python Data Classes: A Comprehensive Guide

Amit Kumar Jha

1 Introduction
Data classes in Python simplify class definitions by automatically generating special methods. This document covers the syntax and
features of data classes, with a focus on finance-related examples and concepts such as encapsulation, inheritance, and polymorphism.

2 Defining Data Classes

To define a data class, you use the @dataclass decorator from the dataclasses module. Data classes are a convenient way to
bundle data and related functionality together.

2.1 Syntax
1 from dataclasses import dataclass
2
3 @dataclass
4 class ClassName:
5 attribute1: type
6 attribute2: type

2.1.1 Analogy
Think of data classes as a template for a form you fill out in a job application. The form has fields for your name, age, and address,
just as a data class has fields for its attributes. The @dataclass decorator is like having a pre-filled form that automatically handles
your personal details (__init__), displaying them (__repr__), and checking if two forms are the same (__eq__).

2.1.2 Tip
To remember the syntax, think of it as filling out a simple template:
• Import the dataclass decorator.
• Use @dataclass above your class definition.

• List your attributes with their types.

2.1.3 Short Trick

For quick reference, remember the acronym DATA:
• Decorator: @dataclass
• Attributes: Define your fields

• Types: Specify data types

• Automatically: Methods like __init__, __repr__, __eq__ are auto-generated

3 Example: Bond Valuation

Consider a simple example for bond valuation where we define a data class to represent a bond and calculate its price based on
coupon payments and face value.

1
 3.1 Data Class Definition
1 from dataclasses import dataclass
2
3 @dataclass
4 class Bond:
5 face_value: float
6 coupon_rate: float
7 years_to_maturity: int
8 market_rate: float
9
10 def price(self) -> float:
11 coupon_payment = self.face_value * self.coupon_rate
12 present_value_coupons = sum(
13 coupon_payment / (1 + self.market_rate) ** t
14 for t in range(1, self.years_to_maturity + 1)
15 )
16 present_value_face_value = self.face_value / (1 + self.market_rate) ** self.years_to_maturity
17 return present_value_coupons + present_value_face_value

4 Data Class Functions

4.1 Encapsulation
Data classes provide a way to encapsulate data and ensure that fields are protected. This is done using the frozen=True parameter
to make instances immutable.
1 @dataclass(frozen=True)
2 class ImmutableBond:
3 face_value: float
4 coupon_rate: float
5 years_to_maturity: int
6 market_rate: float

4.1.1 Analogy
Encapsulation in data classes is like locking a file drawer. Once it’s locked (frozen=True), no one can change the contents inside.
This ensures that the data remains consistent and unaltered.

4.1.2 Tip
Use frozen=True when you want to ensure the integrity of your data by preventing modifications after creation.

4.1.3 Short Trick

Think of LOCK for encapsulation:
• Lock the object with frozen=True
• Objects remain unmodified
• Consistent data
• Keep it safe

4.2 Inheritance
Data classes can inherit from other data classes, allowing for extension and customization of class behavior.

1 @dataclass
2 class Bond:
3 face_value: float
4 coupon_rate: float
5 years_to_maturity: int
6 market_rate: float
7
8 @dataclass
9 class CallableBond(Bond):
10 call_price: float
11 call_date: int
12
13 def call_value(self) -> float:
14 return min(self.price(), self.call_price)

2
 4.2.1 Analogy
Inheritance in data classes is like a specialized job title that extends a general job role. For example, a ”Manager” can be extended
to a ”Senior Manager,” who has all the responsibilities of a Manager plus additional ones. Similarly, CallableBond extends Bond
with extra features.

4.2.2 Tip
When designing classes with inheritance, keep the base class focused on common features and use derived classes for specialized
behaviors.

4.2.3 Short Trick

Remember BASE+EXTEND:

• Base class for common features

• Add specific details in the derived class
• Specialize with additional methods or attributes

• Extend functionality

4.3 Polymorphism
Data classes support polymorphism, where a method in a base class can be overridden in a derived class.

1 @dataclass
2 class Bond:
3 face_value: float
4 coupon_rate: float
5 years_to_maturity: int
6 market_rate: float
7
8 def price(self) -> float:
9 # Base implementation
10 pass
11
12 @dataclass
13 class ZeroCouponBond(Bond):
14 def price(self) -> float:
15 return self.face_value / (1 + self.market_rate) ** self.years_to_maturity

4.3.1 Analogy
Polymorphism is like having different ways to calculate a bonus in different departments. Each department (derived class) has its
own method to compute bonuses, even though they all follow the same general principle.

4.3.2 Tip
Use polymorphism to handle variations in method behavior while keeping a consistent interface. This is especially useful when
dealing with different types of objects that share common functionality.

4.3.3 Short Trick

Think VARIANTS for polymorphism:

• Vary method implementations

• Allowing different behaviors
• Reusing the same interface

• Integrate with consistency

• Achieve flexibility
• Never change the core interface
• Tailor methods as needed

• Share the overall concept

3
 5 Best Practices
• Use data classes for simple data containers.
• Avoid complex logic in data classes; use methods or separate classes for that.
• Use inheritance to extend functionality but avoid deep inheritance hierarchies.
• Employ encapsulation to maintain data integrity.

6 Full Example: Option Pricing with Data Classes

This section presents a comprehensive example of using data classes for option pricing, incorporating the concepts of inheritance,
encapsulation, and polymorphism.

6.1 Code Structure

Here’s the complete Python code for our option pricing example:

1 from dataclasses import dataclass, field

2 from abc import ABC, abstractmethod
3 import math
4
5 @dataclass
6 class FinancialInstrument(ABC):
7 """
8 Abstract base class for financial instruments.
9 Demonstrates the use of inheritance and abstract methods.
10 """
11 symbol: str
12 current_price: float
13
14 @abstractmethod
15 def calculate_value(self) -> float:
16 pass
17
18 @dataclass
19 class Option(FinancialInstrument):
20 """
21 Base class for options, inheriting from FinancialInstrument.
22 Demonstrates inheritance and encapsulation of common option attributes.
23 """
24 strike_price: float
25 time_to_expiry: float
26 risk_free_rate: float
27 volatility: float
28
29 # Encapsulation: Using a default factory for implied volatility
30 implied_volatility: float = field(default=0.0, init=False)
31
32 def set_implied_volatility(self, value: float) -> None:
33 """Setter method for implied volatility, demonstrating encapsulation."""
34 if value < 0:
35 raise ValueError("Implied volatility cannot be negative")
36 self.implied_volatility = value
37
38 @dataclass
39 class EuropeanCallOption(Option):
40 """
41 European Call Option class, inheriting from Option.
42 Demonstrates polymorphism by implementing the calculate_value method.
43 """
44 def calculate_value(self) -> float:
45 """
46 Calculates the option value using the Black-Scholes formula.
47 Demonstrates polymorphism by overriding the abstract method.
48 """
49 d1 = (math.log(self.current_price / self.strike_price) +
50 (self.risk_free_rate + 0.5 * self.volatility ** 2) * self.time_to_expiry) / \
51 (self.volatility * math.sqrt(self.time_to_expiry))
52 d2 = d1 - self.volatility * math.sqrt(self.time_to_expiry)
53
54 call_value = self.current_price * self.normal_cdf(d1) - \
55 self.strike_price * math.exp(-self.risk_free_rate * self.time_to_expiry) * self.normal_cdf(d2)
56 return call_value
57
58 @staticmethod

4
 59 def normal_cdf(x: float) -> float:
60 """Helper method to calculate the cumulative distribution function of the standard normal distribution."""
61 return (1.0 + math.erf(x / math.sqrt(2.0))) / 2.0
62
63 @dataclass
64 class EuropeanPutOption(Option):
65 """
66 European Put Option class, inheriting from Option.
67 Further demonstrates polymorphism with a different implementation of calculate_value.
68 """
69 def calculate_value(self) -> float:
70 """
71 Calculates the put option value using put-call parity.
72 Another example of polymorphism.
73 """
74 call_option = EuropeanCallOption(
75 self.symbol, self.current_price, self.strike_price,
76 self.time_to_expiry, self.risk_free_rate, self.volatility
77 )
78 call_value = call_option.calculate_value()
79 put_value = call_value + self.strike_price * math.exp(-self.risk_free_rate * self.time_to_expiry) -
,→ self.current_price
80 return put_value
81
82 @dataclass(frozen=True)
83 class OptionPortfolio:
84 """
85 A class to represent a portfolio of options.
86 Demonstrates the use of a frozen dataclass for immutability.
87 """
88 options: tuple[Option, ...]
89
90 def total_value(self) -> float:
91 """Calculates the total value of the portfolio."""
92 return sum(option.calculate_value() for option in self.options)
93
94 # Example usage
95 if __name__ == "__main__":
96 # Creating instances of options
97 call_option = EuropeanCallOption("AAPL", 100, 110, 1, 0.05, 0.2)
98 put_option = EuropeanPutOption("AAPL", 100, 90, 1, 0.05, 0.2)
99
100 # Demonstrating encapsulation
101 call_option.set_implied_volatility(0.22)
102
103 # Calculating and printing option values (demonstrating polymorphism)
104 print(f"Call Option Value: { call_option.calculate_value():.2f}")
105 print(f"Put Option Value: { put_option.calculate_value():.2f}")
106
107 # Creating an immutable portfolio
108 portfolio = OptionPortfolio((call_option, put_option))
109 print(f"Total Portfolio Value: { portfolio.total_value():.2f}")
110
111 # Attempting to modify the frozen OptionPortfolio (this will raise an error)
112 try:
113 portfolio.options = (call_option,)
114 except AttributeError as e:
115 print(f"Error: { e}")

6.2 Key Concepts Demonstrated

6.2.1 Inheritance
The code demonstrates inheritance through the class hierarchy:
• FinancialInstrument is the abstract base class.
• Option inherits from FinancialInstrument.
• EuropeanCallOption and EuropeanPutOption inherit from Option.

6.2.2 Encapsulation
Encapsulation is shown in the Option class:
• The implied_volatility attribute is initialized with a default value and not settable through the constructor.
• A setter method set_implied_volatility is provided to control access to this attribute.

5
6.2.3 Polymorphism
Polymorphism is demonstrated through the calculate_value method:
• It’s an abstract method in FinancialInstrument.
• EuropeanCallOption implements it using the Black-Scholes formula.

• EuropeanPutOption implements it using put-call parity.

6.2.4 Immutability
The OptionPortfolio class is defined as immutable:
• It uses @dataclass(frozen=True) to prevent modifications after creation.
• Attempts to modify the portfolio will raise an AttributeError.

6.3 Benefits of Using Data Classes

• Code Readability: The class structure is clear and concise.
• Automatic Method Generation: __init__, __repr__, and __eq__ methods are automatically created.
• Type Hinting: Attributes are defined with their types, improving code clarity and enabling better IDE support.

• Immutability: The frozen=True parameter allows for creating immutable data structures.

6.4 Conclusion
This example demonstrates how data classes can be effectively used in financial modeling, providing a clean and intuitive way to
represent complex financial instruments and their behaviors.

• Thank You !!