admin Hướng Nghiệp Dữ Liệu

def calculate_return_rate(initial_value, final_value):
    return ((final_value - initial_value) / initial_value) * 100

import numpy as np

def calculate_risk(returns):
    return np.std(returns) * np.sqrt(252)  # Annualized volatility

def calculate_sharpe_ratio(returns, risk_free_rate):
    excess_returns = returns - risk_free_rate
    return np.mean(excess_returns) / np.std(excess_returns) * np.sqrt(252)

def optimize_portfolio(returns, cov_matrix):
    num_assets = len(returns)
    weights = np.random.random(num_assets)
    weights = weights / np.sum(weights)
    return weights

import matplotlib.pyplot as plt

def plot_risk_return(risks, returns, labels):
    plt.scatter(risks, returns)
    for i, label in enumerate(labels):
        plt.annotate(label, (risks[i], returns[i]))
    plt.xlabel('Risk (Volatility)')
    plt.ylabel('Expected Return')
    plt.title('Risk-Return Profile')
    plt.show()

def plot_portfolio_value(portfolio_values, dates):
    plt.plot(dates, portfolio_values)
    plt.xlabel('Date')
    plt.ylabel('Portfolio Value')
    plt.title('Portfolio Performance Over Time')
    plt.show()

def calculate_stop_loss(entry_price, risk_percentage):
    return entry_price * (1 - risk_percentage/100)

def calculate_position_size(account_value, risk_per_trade, stop_loss_pips):
    risk_amount = account_value * (risk_per_trade/100)
    position_size = risk_amount / stop_loss_pips
    return position_size

class Car:
    def __init__(self, brand, model, year):
        self.brand = brand
        self.model = model
        self.year = year
    
    def start_engine(self):
        return f"{self.brand} {self.model} đang khởi động"

my_car = Car("Toyota", "Camry", 2023)
print(my_car.start_engine())  # Output: Toyota Camry đang khởi động

class BankAccount:
    def __init__(self):
        self.__balance = 0  # private attribute
    
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
    
    def get_balance(self):
        return self.__balance

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return f"{self.name} sủa: Gâu gâu!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} kêu: Meo meo!"

def animal_sound(animal):
    print(animal.speak())

dog = Dog("Rex")
cat = Cat("Tom")

animal_sound(dog)  # Output: Rex sủa: Gâu gâu!
animal_sound(cat)  # Output: Tom kêu: Meo meo!

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def calculate_area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def calculate_area(self):
        return 3.14 * self.radius ** 2

import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.optimize import minimize

# Định nghĩa danh mục đầu tư
portfolio = {
    'AAPL': 0.3,  # Apple
    'MSFT': 0.3,  # Microsoft
    'GOOGL': 0.2, # Google
    'AMZN': 0.2   # Amazon
}

# Lấy dữ liệu lịch sử
data = pd.DataFrame()
for ticker in portfolio.keys():
    stock = yf.Ticker(ticker)
    hist = stock.history(period='1y')
    data[ticker] = hist['Close']

# Tính toán lợi nhuận hàng ngày
returns = data.pct_change()

# Hiển thị dữ liệu
print("Dữ liệu giá đóng cửa:")
print(data.head())
print("\nLợi nhuận hàng ngày:")
print(returns.head())

# Lợi nhuận trung bình hàng năm
annual_returns = returns.mean() * 252

# Độ lệch chuẩn (rủi ro)
volatility = returns.std() * np.sqrt(252)

# Tỷ lệ Sharpe (giả sử lãi suất phi rủi ro là 0.02)
risk_free_rate = 0.02
sharpe_ratio = (annual_returns - risk_free_rate) / volatility

# Tạo bảng tổng hợp
performance = pd.DataFrame({
    'Lợi nhuận hàng năm': annual_returns,
    'Độ biến động': volatility,
    'Tỷ lệ Sharpe': sharpe_ratio
})

# Hiển thị kết quả
print("\nPhân tích hiệu suất:")
print(performance)

# Vẽ biểu đồ so sánh
plt.figure(figsize=(12, 6))
performance['Lợi nhuận hàng năm'].plot(kind='bar')
plt.title('Lợi nhuận hàng năm của các tài sản')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# Ma trận tương quan
correlation_matrix = returns.corr()

# Vẽ biểu đồ nhiệt
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', center=0)
plt.title('Ma trận tương quan giữa các tài sản')
plt.tight_layout()
plt.show()

# Vẽ biểu đồ phân tán
sns.pairplot(returns)
plt.suptitle('Phân tích phân tán giữa các tài sản', y=1.02)
plt.show()

def portfolio_volatility(weights, returns):
    return np.sqrt(np.dot(weights.T, np.dot(returns.cov() * 252, weights)))

def negative_sharpe(weights, returns, risk_free_rate):
    returns_array = returns.mean() * 252
    volatility = portfolio_volatility(weights, returns)
    return -(returns_array.dot(weights) - risk_free_rate) / volatility

# Tối ưu hóa danh mục
n_assets = len(portfolio)
constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
bounds = tuple((0, 1) for _ in range(n_assets))
initial_weights = np.array([1/n_assets] * n_assets)

optimal_weights = minimize(
    negative_sharpe,
    initial_weights,
    args=(returns, risk_free_rate),
    method='SLSQP',
    bounds=bounds,
    constraints=constraints
)

# Hiển thị kết quả tối ưu
print("\nPhân bổ tài sản tối ưu:")
for ticker, weight in zip(portfolio.keys(), optimal_weights.x):
    print(f"{ticker}: {weight:.2%}")

# Vẽ biểu đồ phân bổ
plt.figure(figsize=(10, 6))
plt.pie(optimal_weights.x, labels=portfolio.keys(), autopct='%1.1f%%')
plt.title('Phân bổ tài sản tối ưu')
plt.show()

# Value at Risk (VaR)
def calculate_var(returns, weights, confidence_level=0.95):
    portfolio_returns = returns.dot(weights)
    return np.percentile(portfolio_returns, (1 - confidence_level) * 100)

# Expected Shortfall (ES)
def calculate_es(returns, weights, confidence_level=0.95):
    portfolio_returns = returns.dot(weights)
    var = calculate_var(returns, weights, confidence_level)
    return portfolio_returns[portfolio_returns <= var].mean()

# Tính toán các chỉ số rủi ro
var_95 = calculate_var(returns, optimal_weights.x)
es_95 = calculate_es(returns, optimal_weights.x)

print(f"\nValue at Risk (95%): {var_95:.2%}")
print(f"Expected Shortfall (95%): {es_95:.2%}")

# Vẽ biểu đồ phân phối lợi nhuận
portfolio_returns = returns.dot(optimal_weights.x)
plt.figure(figsize=(10, 6))
sns.histplot(portfolio_returns, kde=True)
plt.axvline(var_95, color='r', linestyle='--', label=f'VaR (95%): {var_95:.2%}')
plt.axvline(es_95, color='g', linestyle='--', label=f'ES (95%): {es_95:.2%}')
plt.title('Phân phối lợi nhuận danh mục')
plt.xlabel('Lợi nhuận')
plt.ylabel('Tần suất')
plt.legend()
plt.show()

# Biểu đồ hiệu suất tích lũy
cumulative_returns = (1 + returns).cumprod()
plt.figure(figsize=(12, 6))
for column in cumulative_returns.columns:
    plt.plot(cumulative_returns.index, cumulative_returns[column], label=column)
plt.title('Hiệu suất tích lũy của danh mục')
plt.xlabel('Ngày')
plt.ylabel('Hiệu suất tích lũy')
plt.legend()
plt.grid(True)
plt.show()

# Biểu đồ phân bổ tài sản
plt.figure(figsize=(10, 6))
plt.pie(optimal_weights.x, labels=portfolio.keys(), autopct='%1.1f%%')
plt.title('Phân bổ tài sản tối ưu')
plt.show()

# Biểu đồ so sánh hiệu suất
plt.figure(figsize=(12, 6))
performance['Lợi nhuận hàng năm'].plot(kind='bar')
plt.title('So sánh lợi nhuận hàng năm')
plt.xlabel('Tài sản')
plt.ylabel('Lợi nhuận hàng năm')
plt.xticks(rotation=45)
plt.grid(True)
plt.show()

from statsmodels.tsa.stattools import adfuller

def adf_test(series):
    """
    Thực hiện kiểm định ADF để kiểm tra tính dừng
    
    Tham số:
    - series: Chuỗi giá cần kiểm tra
    
    Trả về:
    - Kết quả kiểm định và giải thích
    """
    result = adfuller(series, autolag='AIC')
    print(f'ADF Statistic: {result[0]:.6f}')
    print(f'p-value: {result[1]:.6f}')
    
    # Phân tích kết quả
    if result[1] <= 0.05:
        print("Kết quả: Loại bỏ giả thuyết null - Chuỗi có tiềm năng Mean Reversion")
    else:
        print("Kết quả: Không thể loại bỏ giả thuyết null - Chuỗi có thể không phù hợp cho Mean Reversion")
    
    return result

# Ví dụ sử dụng
import yfinance as yf
import pandas as pd

# Lấy dữ liệu
ticker = 'AAPL'
data = yf.download(ticker, start='2020-01-01', end='2023-01-01')

# Kiểm tra tính dừng của giá
adf_test(data['Close'])

# Kiểm tra tính dừng của lợi nhuận (thường có nhiều khả năng dừng hơn)
returns = data['Close'].pct_change().dropna()
adf_test(returns)

def hurst_exponent(time_series, max_lag=100):
    """
    Tính chỉ số Hurst
    
    Tham số:
    - time_series: Chuỗi thời gian cần phân tích
    - max_lag: Độ trễ tối đa để tính toán
    
    Trả về:
    - Giá trị ước lượng của chỉ số Hurst
    """
    lags = range(2, max_lag)
    tau = [np.sqrt(np.std(np.subtract(time_series[lag:], time_series[:-lag]))) for lag in lags]
    poly = np.polyfit(np.log(lags), np.log(tau), 1)
    return poly[0] / 2.0

# Ví dụ sử dụng
import numpy as np

hurst = hurst_exponent(data['Close'].values)
print(f"Chỉ số Hurst: {hurst:.4f}")

if hurst < 0.45:
    print("Chuỗi có đặc tính Mean Reversion mạnh")
elif hurst < 0.55:
    print("Chuỗi gần với random walk")
else:
    print("Chuỗi có đặc tính xu hướng (momentum)")

def calculate_half_life(series):
    """
    Tính half-life của quá trình Mean Reversion
    
    Tham số:
    - series: Chuỗi giá
    
    Trả về:
    - Half-life (bán kỳ), đơn vị là khoảng thời gian của chuỗi
    """
    # Tạo chuỗi lag-1
    lagged_series = series.shift(1).dropna()
    delta_series = series[1:] - lagged_series
    
    # Thực hiện hồi quy y = φx + ε để tính hệ số φ
    X = lagged_series.values.reshape(-1, 1)
    y = delta_series.values
    
    from sklearn.linear_model import LinearRegression
    model = LinearRegression()
    model.fit(X, y)
    
    phi = model.coef_[0]
    half_life = -np.log(2) / phi if phi < 0 else float('inf')
    
    return half_life

# Ví dụ sử dụng
price_series = pd.Series(data['Close'])
half_life = calculate_half_life(price_series)
print(f"Half-life của quá trình Mean Reversion: {half_life:.2f} ngày")

def bollinger_bands_strategy(data, window=20, num_std=2):
    """
    Tạo tín hiệu giao dịch dựa trên Bollinger Bands
    
    Tham số:
    - data: DataFrame chứa dữ liệu OHLC
    - window: Kích thước cửa sổ cho MA
    - num_std: Số độ lệch chuẩn cho bands
    
    Trả về:
    - DataFrame với các bands và tín hiệu
    """
    # Tạo một bản sao
    df = data.copy()
    
    # Tính MA và độ lệch chuẩn
    df['MA'] = df['Close'].rolling(window=window).mean()
    df['STD'] = df['Close'].rolling(window=window).std()
    
    # Tính Bollinger Bands
    df['Upper_Band'] = df['MA'] + (df['STD'] * num_std)
    df['Lower_Band'] = df['MA'] - (df['STD'] * num_std)
    
    # Tạo tín hiệu
    df['Signal'] = 0  # 0: không có tín hiệu, 1: mua, -1: bán
    df.loc[df['Close'] < df['Lower_Band'], 'Signal'] = 1
    df.loc[df['Close'] > df['Upper_Band'], 'Signal'] = -1
    
    return df

# Ví dụ sử dụng
df_with_signals = bollinger_bands_strategy(data)

# Trực quan hóa
import matplotlib.pyplot as plt

plt.figure(figsize=(12, 6))
plt.plot(df_with_signals.index, df_with_signals['Close'], label='Close Price')
plt.plot(df_with_signals.index, df_with_signals['MA'], label='Moving Average', alpha=0.5)
plt.plot(df_with_signals.index, df_with_signals['Upper_Band'], label='Upper Band', linestyle='--')
plt.plot(df_with_signals.index, df_with_signals['Lower_Band'], label='Lower Band', linestyle='--')

# Đánh dấu tín hiệu mua/bán
buy_signals = df_with_signals[df_with_signals['Signal'] == 1]
sell_signals = df_with_signals[df_with_signals['Signal'] == -1]

plt.scatter(buy_signals.index, buy_signals['Close'], marker='^', color='g', s=100, label='Buy Signal')
plt.scatter(sell_signals.index, sell_signals['Close'], marker='v', color='r', s=100, label='Sell Signal')

plt.title(f'{ticker} Bollinger Bands Strategy')
plt.xlabel('Date')
plt.ylabel('Price')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()

def rsi_strategy(data, window=14, overbought=70, oversold=30):
    """
    Tạo tín hiệu giao dịch dựa trên RSI
    
    Tham số:
    - data: DataFrame chứa dữ liệu OHLC
    - window: Kích thước cửa sổ cho RSI
    - overbought: Ngưỡng quá mua
    - oversold: Ngưỡng quá bán
    
    Trả về:
    - DataFrame với RSI và tín hiệu
    """
    # Tạo một bản sao
    df = data.copy()
    
    # Tính thay đổi giá
    delta = df['Close'].diff()
    
    # Tách gains và losses
    gains = delta.where(delta > 0, 0)
    losses = -delta.where(delta < 0, 0)
    
    # Tính avg gains và losses
    avg_gains = gains.rolling(window=window).mean()
    avg_losses = losses.rolling(window=window).mean()
    
    # Tính RS và RSI
    rs = avg_gains / avg_losses
    df['RSI'] = 100 - (100 / (1 + rs))
    
    # Tạo tín hiệu
    df['Signal'] = 0
    df.loc[df['RSI'] < oversold, 'Signal'] = 1  # Tín hiệu mua khi RSI < 30
    df.loc[df['RSI'] > overbought, 'Signal'] = -1  # Tín hiệu bán khi RSI > 70
    
    return df

# Ví dụ sử dụng
df_with_rsi = rsi_strategy(data)

# Trực quan hóa
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8), gridspec_kw={'height_ratios': [3, 1]})

# Biểu đồ giá
ax1.plot(df_with_rsi.index, df_with_rsi['Close'], label='Close Price')
buy_signals = df_with_rsi[df_with_rsi['Signal'] == 1]
sell_signals = df_with_rsi[df_with_rsi['Signal'] == -1]
ax1.scatter(buy_signals.index, buy_signals['Close'], marker='^', color='g', s=100, label='Buy Signal')
ax1.scatter(sell_signals.index, sell_signals['Close'], marker='v', color='r', s=100, label='Sell Signal')
ax1.set_title(f'{ticker} RSI Strategy')
ax1.set_ylabel('Price')
ax1.legend()
ax1.grid(True)

# Biểu đồ RSI
ax2.plot(df_with_rsi.index, df_with_rsi['RSI'], color='purple', label='RSI')
ax2.axhline(y=70, color='r', linestyle='--', label='Overbought (70)')
ax2.axhline(y=30, color='g', linestyle='--', label='Oversold (30)')
ax2.fill_between(df_with_rsi.index, y1=70, y2=100, color='red', alpha=0.1)
ax2.fill_between(df_with_rsi.index, y1=0, y2=30, color='green', alpha=0.1)
ax2.set_ylabel('RSI')
ax2.set_xlabel('Date')
ax2.legend()
ax2.grid(True)

plt.tight_layout()
plt.show()

def pairs_trading_strategy(stock1_data, stock2_data, window=30, z_threshold=2):
    """
    Chiến lược giao dịch cặp
    
    Tham số:
    - stock1_data: DataFrame cho cổ phiếu 1
    - stock2_data: DataFrame cho cổ phiếu 2
    - window: Cửa sổ cho việc tính Z-score
    - z_threshold: Ngưỡng Z-score để kích hoạt giao dịch
    
    Trả về:
    - DataFrame với tín hiệu giao dịch
    """
    # Kết hợp dữ liệu
    pairs = pd.DataFrame({
        'stock1': stock1_data['Close'],
        'stock2': stock2_data['Close']
    })
    
    # Tính tỷ lệ giá giữa hai cổ phiếu
    pairs['ratio'] = pairs['stock1'] / pairs['stock2']
    
    # Tính Z-score
    pairs['ratio_mean'] = pairs['ratio'].rolling(window=window).mean()
    pairs['ratio_std'] = pairs['ratio'].rolling(window=window).std()
    pairs['z_score'] = (pairs['ratio'] - pairs['ratio_mean']) / pairs['ratio_std']
    
    # Tạo tín hiệu
    pairs['signal'] = 0
    # Khi Z-score > ngưỡng: Bán stock1, mua stock2
    pairs.loc[pairs['z_score'] > z_threshold, 'signal'] = -1
    # Khi Z-score < -ngưỡng: Mua stock1, bán stock2
    pairs.loc[pairs['z_score'] < -z_threshold, 'signal'] = 1
    # Khi Z-score trở lại gần 0, đóng vị thế
    pairs.loc[abs(pairs['z_score']) < 0.5, 'signal'] = 0
    
    return pairs

# Ví dụ sử dụng
stock1_ticker = 'KO'  # Coca-Cola
stock2_ticker = 'PEP'  # PepsiCo

stock1_data = yf.download(stock1_ticker, start='2020-01-01', end='2023-01-01')
stock2_data = yf.download(stock2_ticker, start='2020-01-01', end='2023-01-01')

pairs_result = pairs_trading_strategy(stock1_data, stock2_data)

# Trực quan hóa
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10), gridspec_kw={'height_ratios': [2, 1]})

# Biểu đồ giá
ax1.plot(pairs_result.index, pairs_result['stock1'], label=stock1_ticker)
ax1.plot(pairs_result.index, pairs_result['stock2'], label=stock2_ticker)
ax1.set_title(f'Pairs Trading: {stock1_ticker} vs {stock2_ticker}')
ax1.set_ylabel('Price')
ax1.legend()
ax1.grid(True)

# Biểu đồ Z-score
ax2.plot(pairs_result.index, pairs_result['z_score'], color='purple', label='Z-score')
ax2.axhline(y=2, color='r', linestyle='--')
ax2.axhline(y=-2, color='g', linestyle='--')
ax2.axhline(y=0, color='k', linestyle='-')
ax2.fill_between(pairs_result.index, y1=2, y2=4, color='red', alpha=0.1)
ax2.fill_between(pairs_result.index, y1=-4, y2=-2, color='green', alpha=0.1)
ax2.set_ylabel('Z-score')
ax2.set_xlabel('Date')
ax2.grid(True)

# Đánh dấu tín hiệu
buy_signals = pairs_result[pairs_result['signal'] == 1]
sell_signals = pairs_result[pairs_result['signal'] == -1]
ax2.scatter(buy_signals.index, buy_signals['z_score'], marker='^', color='g', s=100)
ax2.scatter(sell_signals.index, sell_signals['z_score'], marker='v', color='r', s=100)

plt.tight_layout()
plt.show()

def apply_stop_loss(signals, price_data, stop_loss_pct=0.05):
    """
    Áp dụng stop-loss cho tín hiệu giao dịch
    
    Tham số:
    - signals: DataFrame chứa tín hiệu
    - price_data: DataFrame chứa dữ liệu giá
    - stop_loss_pct: Phần trăm stop-loss (0.05 = 5%)
    
    Trả về:
    - DataFrame với tín hiệu đã điều chỉnh
    """
    # Tạo bản sao
    result = signals.copy()
    
    # Thêm cột để theo dõi vị thế và giá vào lệnh
    result['Position'] = 0
    result['Entry_Price'] = 0
    
    # Duyệt qua từng ngày
    for i in range(1, len(result)):
        prev_pos = result.iloc[i-1]['Position']
        curr_signal = result.iloc[i]['Signal']
        curr_price = price_data.iloc[i]['Close']
        
        if prev_pos == 0 and curr_signal != 0:
            # Mở vị thế mới
            result.iloc[i, result.columns.get_loc('Position')] = curr_signal
            result.iloc[i, result.columns.get_loc('Entry_Price')] = curr_price
        elif prev_pos != 0:
            entry_price = result.iloc[i-1]['Entry_Price']
            
            # Kiểm tra stop-loss
            if prev_pos == 1 and curr_price < entry_price * (1 - stop_loss_pct):
                # Kích hoạt stop-loss cho vị thế mua
                result.iloc[i, result.columns.get_loc('Position')] = 0
                result.iloc[i, result.columns.get_loc('Entry_Price')] = 0
            elif prev_pos == -1 and curr_price > entry_price * (1 + stop_loss_pct):
                # Kích hoạt stop-loss cho vị thế bán
                result.iloc[i, result.columns.get_loc('Position')] = 0
                result.iloc[i, result.columns.get_loc('Entry_Price')] = 0
            else:
                # Giữ vị thế hiện tại
                result.iloc[i, result.columns.get_loc('Position')] = prev_pos
                result.iloc[i, result.columns.get_loc('Entry_Price')] = entry_price
    
    return result

def calculate_position_size(z_score, max_position_size, max_z_score=3):
    """
    Tính kích thước vị thế dựa trên Z-score
    
    Tham số:
    - z_score: Z-score hiện tại
    - max_position_size: Kích thước vị thế tối đa
    - max_z_score: Z-score tối đa được xem xét
    
    Trả về:
    - Kích thước vị thế
    """
    # Giới hạn Z-score
    capped_z_score = min(abs(z_score), max_z_score)
    
    # Tính kích thước vị thế tỷ lệ với Z-score
    position_size = (capped_z_score / max_z_score) * max_position_size
    
    # Xác định hướng (mua/bán)
    if z_score < 0:
        return position_size  # Mua
    else:
        return -position_size  # Bán

def apply_time_exit(signals, max_holding_days=10):
    """
    Áp dụng exit dựa trên thời gian
    
    Tham số:
    - signals: DataFrame chứa tín hiệu và vị thế
    - max_holding_days: Số ngày tối đa giữ vị thế
    
    Trả về:
    - DataFrame với vị thế đã điều chỉnh
    """
    # Tạo bản sao
    result = signals.copy()
    
    # Thêm cột đếm thời gian giữ vị thế
    result['Holding_Days'] = 0
    
    # Duyệt qua từng ngày
    for i in range(1, len(result)):
        prev_pos = result.iloc[i-1]['Position']
        curr_pos = result.iloc[i]['Position']
        
        if curr_pos == 0:
            # Không có vị thế
            result.iloc[i, result.columns.get_loc('Holding_Days')] = 0
        elif curr_pos == prev_pos:
            # Giữ vị thế hiện tại
            holding_days = result.iloc[i-1]['Holding_Days'] + 1
            result.iloc[i, result.columns.get_loc('Holding_Days')] = holding_days
            
            # Kiểm tra thời gian tối đa
            if holding_days >= max_holding_days:
                # Đóng vị thế
                result.iloc[i, result.columns.get_loc('Position')] = 0
                result.iloc[i, result.columns.get_loc('Holding_Days')] = 0
        else:
            # Vị thế mới
            result.iloc[i, result.columns.get_loc('Holding_Days')] = 1
    
    return result