Python Research Code.py

# -*- coding: utf-8 -*-
""" Automatically generated by Colab.

# Install Module
"""

!pip install yfinance pandas openpyxl

"""# Pengambilan Data

## List Saham
"""

import pandas as pd
daftar_sahamperiode = pd.read_excel('Daftar Saham IDXESGL.xlsx', sheet_name='Daftar Saham Konsisten')
ticker_sahamperiode1 = daftar_sahamperiode['Ticker P1'].dropna().tolist()
ticker_sahamperiode2 = daftar_sahamperiode['Ticker P2'].dropna().tolist()
print("Jumlah saham Periode 1", len(ticker_sahamperiode1))
print(ticker_sahamperiode1)
print("Jumlah saham Periode 2", len(ticker_sahamperiode2))
print(ticker_sahamperiode2)

"""## Mengambil Data Saham"""

def Scraping_Saham(tickers, start_date, end_date):
  import yfinance
  data_saham = yfinance.download(tickers, start_date, end_date, auto_adjust=True)
  data_saham = data_saham.dropna()
  closing_prices = data_saham['Close']
  return closing_prices

Ticker_market = ('^JKSE')
data_marketperiode1 = Scraping_Saham(Ticker_market, '2024-08-23', '2025-02-24')
data_sahamperiode1 = Scraping_Saham(ticker_sahamperiode1, '2024-08-23', '2025-02-24')
data_periode1 = pd.concat([data_marketperiode1, data_sahamperiode1], axis=1)
data_periode1

data_marketperiode2 = Scraping_Saham(Ticker_market, '2025-02-24', '2025-08-25')
data_sahamperiode2 = Scraping_Saham(ticker_sahamperiode2, '2025-02-24', '2025-08-25')
data_periode2 = pd.concat([data_marketperiode2, data_sahamperiode2], axis=1)
data_periode2

with pd.ExcelWriter('Data Saham Periode 1 dan 2.xlsx') as writer:
    data_periode1.to_excel(writer, sheet_name='Periode 1')
    data_periode2.to_excel(writer, sheet_name='Periode 2')
print("Data saved to 'Data Saham Periode 1 dan 2.xlsx'")

import matplotlib.pyplot as plt

combined_data = pd.concat([data_periode1, data_periode2], axis=0)

plt.figure(figsize=(14, 6))
plt.plot(combined_data.index, combined_data['^JKSE'], color='red')
plt.axvline(pd.to_datetime('2025-02-24'), color='black', linestyle='--')

plt.title('Daily IHSG Price')
plt.xlabel('Tanggal')
plt.ylabel('Harga Penutupan')
plt.legend()
plt.grid(True)
plt.show()



"""## Menyimpan Bunga Bebas Risiko"""

sukubunga_periode1 = pd.read_excel('Suku Bunga BI.xlsx', sheet_name='Agt 24 - Feb 25')
data_sukubunga_harian1 = sukubunga_periode1['Suku Bunga']/233
risk_freeperiode1 = data_sukubunga_harian1.mean()
risk_freeperiode1

sukubunga_periode2 = pd.read_excel('Suku Bunga BI.xlsx', sheet_name='Feb 25 - Agt 25')
data_sukubunga_harian2 = sukubunga_periode2['Suku Bunga']/233
risk_freeperiode2 = data_sukubunga_harian2.mean()
risk_freeperiode2

"""# Return

## Return Saham

---
"""

def returns(data):
  import numpy as np
  return_harian = np.log(data / data.shift(1))
  return return_harian

data_returnperiode1 = returns(data_periode1).dropna()
data_returnperiode1

data_returnperiode2 = returns(data_periode2).dropna()
data_returnperiode2

"""## Statistik Saham

"""

def statsaham(data, market_ticker):
    expected_returns = data.mean()
    st_dev = data.std()
    variance = st_dev**2
    cov_matrix = data.cov()
    covariance = cov_matrix[market_ticker]
    stats_df = pd.DataFrame({'Expected Return': expected_returns, 'St. Deviation': st_dev, 'Variance': variance, 'Covariance': covariance})
    return stats_df

stat_periode1 = statsaham(data_returnperiode1, Ticker_market)
stat_periode1

stat_periode2 = statsaham(data_returnperiode2, Ticker_market)
stat_periode2

"""## Pemilihan Saham Positif"""

def return_positif(data_return, market_ticker):
  saham_return_positif = data_return.loc[:, data_return.mean() > 0]
  if market_ticker not in saham_return_positif.columns:
    data_positif = pd.concat([data_return[market_ticker], saham_return_positif], axis=1)
  else:
    data_positif = saham_return_positif
  return data_positif

datapositif_periode1 = return_positif(data_returnperiode1, Ticker_market)
print('Saham Positif Periode 1 Sebanyak', len(datapositif_periode1.columns)-1, 'Saham')
print(list(datapositif_periode1))

datapositif_periode2 = return_positif(data_returnperiode2, Ticker_market)
print('Saham Positif Periode 2 Sebanyak', len(datapositif_periode2.columns)-1, 'Saham')
print(list(datapositif_periode2))

"""# Parameter Market"""

def parametermarket(stat_data, data_positif, market_ticker):
    stat_positif = stat_data.loc[data_positif.columns]
    market_variance = stat_data.loc[market_ticker, 'Variance']
    expected_market_return = stat_data.loc[market_ticker, 'Expected Return']
    beta_saham = stat_positif['Covariance'] / market_variance
    alpha_saham = stat_positif['Expected Return'] - (beta_saham * (expected_market_return))
    residual_variance = stat_positif['Variance'] - (beta_saham**2 * market_variance)

    parameter_df = pd.DataFrame({'Beta': beta_saham, 'Alpha': alpha_saham, 'Residual Variance': residual_variance})
    return parameter_df.drop(market_ticker)

parameter_periode1 = parametermarket(stat_periode1, datapositif_periode1, Ticker_market)
parameter_periode1

parameter_periode2 = parametermarket(stat_periode2, datapositif_periode2, Ticker_market)
parameter_periode2

"""# Single Index Model

## Parameter
"""

def simparameter(data_positif, risk_free, parameter_market, market_ticker):
  ERB_saham = (data_positif.mean() - risk_free) / parameter_market['Beta']
  A_saham = ((data_positif.mean() - risk_free) * parameter_market['Beta']) / parameter_market['Residual Variance']
  B_saham = parameter_market['Beta']**2 / parameter_market['Residual Variance']
  Cutoff_saham = (data_positif[market_ticker].var() * A_saham) / (1 + (data_positif[market_ticker].var() * B_saham))
  Max_cutoff = max(Cutoff_saham)
  proporsi_saham = ((ERB_saham - Max_cutoff) * (parameter_market['Beta'] / parameter_market['Residual Variance']))

  sim_df = pd.DataFrame({'ERB': ERB_saham, 'Nilai A': A_saham, 'Nilai B': B_saham, 'Cut Off': Cutoff_saham, 'Proporsi Saham': proporsi_saham})
  return sim_df.drop(market_ticker)

sim_periode1 = simparameter(datapositif_periode1, risk_freeperiode1, parameter_periode1, Ticker_market)
sim_periode1

sim_periode2 = simparameter(datapositif_periode2, risk_freeperiode2, parameter_periode2, Ticker_market)
sim_periode2

"""## Pemilihan Kandidat"""

def kandidatSIM(parameter_sim):
  pemilihan_kandidatSIM = []
  for saham in parameter_sim['ERB'].index:
    if parameter_sim['ERB'][saham] > max(parameter_sim['Cut Off']):
      pemilihan_kandidatSIM.append(saham)
  return pemilihan_kandidatSIM

kandidatSIM_periode1 = kandidatSIM(sim_periode1)
print('Saham Kandidat SIM Periode 1 Sebanyak', len(kandidatSIM_periode1), 'Saham')
print(kandidatSIM_periode1)

kandidatSIM_periode2 = kandidatSIM(sim_periode2)
print('Saham Kandidat SIM Periode 2 Sebanyak', len(kandidatSIM_periode2), 'Saham')
print(kandidatSIM_periode2)

"""# Pembentukan Kombinasi Saham

"""

import itertools
def kombinasi(kandidat):
  kombinasi = []
  for i in range(2, len(kandidat) + 1):
      for combo in itertools.combinations(kandidat, i):
          kombinasi.append(combo)
  return kombinasi

kombinasiSIM_periode1 = kombinasi(kandidatSIM_periode1)
kombinasiSIM_periode1

kombinasiSIM_periode2 = kombinasi(kandidatSIM_periode2)
kombinasiSIM_periode2

"""# Portofolio

## Bobot
"""

def Bobot_SIM(kombinasi_saham, proporsi_saham):
  Nilai_Bobot = {}
  for kombinasi in kombinasi_saham:
    total_proportion = sum(proporsi_saham[saham] for saham in kombinasi)
    Bobot = {saham: proporsi_saham[saham] / total_proportion for saham in kombinasi}
    Nilai_Bobot[kombinasi] = Bobot
  return Nilai_Bobot

Bobot1_PortofolioSIM = Bobot_SIM(kombinasiSIM_periode1, sim_periode1['Proporsi Saham'])
Bobot1_PortofolioSIM_list = [{'Combination': k, 'Weights': {stock: float(weight) for stock, weight in v.items()}} for k, v in Bobot1_PortofolioSIM.items()]
display(pd.DataFrame(Bobot1_PortofolioSIM_list))

Bobot2_PortofolioSIM = Bobot_SIM(kombinasiSIM_periode2, sim_periode2['Proporsi Saham'])
Bobot2_PortofolioSIM_list = [{'Combination': k, 'Weights': {stock: float(weight) for stock, weight in v.items()}} for k, v in Bobot2_PortofolioSIM.items()]
display(pd.DataFrame(Bobot2_PortofolioSIM_list))

"""## Expected Return"""

def ER_PortofolioSIM(bobot, parametermarket, stat_data):
    result_list = []
    expected_market_return = stat_data.loc[Ticker_market, 'Expected Return']

    for kombinasi_name, bobot_dict in bobot.items():
        alpha_port = 0
        beta_port = 0
        for saham, bobot_value in bobot_dict.items():
            alpha_port += bobot_value * parametermarket.loc[saham, 'Alpha']
            beta_port += bobot_value * parametermarket.loc[saham, 'Beta']

        er_port = alpha_port + (beta_port * expected_market_return)

        result_list.append({
            'Kombinasi': kombinasi_name,
            'ER Portofolio': er_port
        })

    return pd.DataFrame(result_list)

expected_return_PortofolioSIM1 = ER_PortofolioSIM(Bobot1_PortofolioSIM, parameter_periode1, stat_periode1)
expected_return_PortofolioSIM1

expected_return_PortofolioSIM2 = ER_PortofolioSIM(Bobot2_PortofolioSIM, parameter_periode2, stat_periode2)
expected_return_PortofolioSIM2

"""## Risiko"""

import pandas as pd
def Risk_PortofolioSIM(bobot, parametermarket, stat_data):
    results_list = []
    market_variance = stat_data.loc[Ticker_market, 'Variance']

    for kombinasi_name, bobot_dict in bobot.items():
        beta_port = 0
        resvar_port = 0
        for saham, bobot_value in bobot_dict.items():
            beta_port += (bobot_value * parametermarket.loc[saham, 'Beta'])
            resvar_port += (bobot_value**2 * parametermarket.loc[saham, 'Residual Variance'])

        risikovar = (beta_port**2) * market_variance + resvar_port
        risiko = risikovar**0.5

        results_list.append({
            'Kombinasi': kombinasi_name,
            'Risikovar_Port': risikovar,
            'Risiko_Port': risiko
        })

    return pd.DataFrame(results_list)

Risiko_PortofolioSIM1 = Risk_PortofolioSIM(Bobot1_PortofolioSIM, parameter_periode1, stat_periode1)
Risiko_PortofolioSIM1

Risiko_PortofolioSIM2 = Risk_PortofolioSIM(Bobot2_PortofolioSIM, parameter_periode2, stat_periode2)
Risiko_PortofolioSIM2

"""## Indeks Sharpe Portofolio Biasa"""

def Indeks_Sharpe(ER_Portofolio, Risiko_Portofolio, risk_free):
  sharpe = (ER_Portofolio['ER Portofolio'] - risk_free) / Risiko_Portofolio['Risiko_Port']
  df_sharpe = pd.DataFrame({'Kombinasi': ER_Portofolio['Kombinasi'], 'Sharpe Ratio': sharpe})
  return df_sharpe

Sharpe_PortofolioSIM1 = Indeks_Sharpe(expected_return_PortofolioSIM1, Risiko_PortofolioSIM1, risk_freeperiode1)
pd.DataFrame(Sharpe_PortofolioSIM1)

Sharpe_PortofolioSIM2 = Indeks_Sharpe(expected_return_PortofolioSIM2, Risiko_PortofolioSIM2, risk_freeperiode2)
pd.DataFrame(Sharpe_PortofolioSIM2)

"""# Value at Risk Adjusted Sharpe

## Excess Return
"""

import numpy as np
import pandas as pd

def excess_return_portfolio(bobot_portofolio, data_return, risk_free):
    excess_return_data = {}

    for portfolio_data in bobot_portofolio:
        kombinasi_tickers = portfolio_data['Combination']
        weights = portfolio_data['Weights']
        stock_excess_returns = data_return[list(kombinasi_tickers)] - risk_free
        weighted_excess_return = stock_excess_returns.dropna().dot(pd.Series(weights))
        column_name = str(kombinasi_tickers)
        excess_return_data[column_name] = weighted_excess_return

    excess_return_portfolios_df = pd.DataFrame(excess_return_data)

    return excess_return_portfolios_df

Excess1 = excess_return_portfolio(Bobot1_PortofolioSIM_list, data_returnperiode1, risk_freeperiode1)
display(Excess1)

Excess2 = excess_return_portfolio(Bobot2_PortofolioSIM_list, data_returnperiode2, risk_freeperiode2)
display(Excess2)

"""## Stats Excess Return"""

import pandas as pd

def excessreturn_stat(excess_returns):
    stats_list = []
    for combination, excess_returns in excess_returns.items():
        mean_excess_return = excess_returns.mean()
        std_dev_excess_return = excess_returns.std()
        skewness_excess_return = excess_returns.skew()
        kurtosis_excess_return = excess_returns.kurtosis()

        stats_list.append({
            'Combination': combination,
            'Mean Excess Return': mean_excess_return,
            'Excess Return Std Dev': std_dev_excess_return,
            'Excess Return Skewness': skewness_excess_return,
            'Excess Return Kurtosis': kurtosis_excess_return
        })

    return pd.DataFrame(stats_list)

excess_return_stats1 = excessreturn_stat(Excess1)
display(excess_return_stats1)

excess_return_stats2 = excessreturn_stat(Excess2)
display(excess_return_stats2)

"""## VaRSR"""

import numpy as np
import math
from scipy.stats import norm
import pandas as pd

def VaRSR(excessreturn_stats, excessreturn, confidence_level):
    z_score = norm.ppf(confidence_level)
    n = len (excessreturn)
    estimated_sharpe = excessreturn_stats['Mean Excess Return'] / excessreturn_stats['Excess Return Std Dev']
    sharpe_squared = estimated_sharpe**2
    sharpe_squared_term = sharpe_squared / 2
    sharpe_skewness_term = estimated_sharpe * excessreturn_stats['Excess Return Skewness']
    sharpe_kurtosis_term = sharpe_squared * ((excessreturn_stats['Excess Return Kurtosis'] - 3) / 4)

    std_dev_sharpe = ((1 / (n - 1)) * (1 + sharpe_squared_term - sharpe_skewness_term + sharpe_kurtosis_term)) ** (1/2)
    var_adjusted_sharpe = estimated_sharpe - z_score * std_dev_sharpe

    var_adjusted_sharpe_data = pd.DataFrame({
        'Combination': excessreturn_stats['Combination'],
        'Estimated Sharpe': estimated_sharpe,
        'Std Dev Sharpe': std_dev_sharpe,
        'VaRSR': var_adjusted_sharpe
    })

    return var_adjusted_sharpe_data

var_adjusted_sharpe_stats1 = VaRSR (excess_return_stats1, Excess1, 0.95)
display(var_adjusted_sharpe_stats1)

var_adjusted_sharpe_stats2 = VaRSR (excess_return_stats2, Excess2, 0.95)
display(var_adjusted_sharpe_stats2)

"""# Kesimpulan

## Data Hasil Akhir
"""

HasilakhirP1 = pd.concat([expected_return_PortofolioSIM1, Risiko_PortofolioSIM1 ['Risiko_Port'], Sharpe_PortofolioSIM1['Sharpe Ratio'], var_adjusted_sharpe_stats1['VaRSR']], axis=1)
display(HasilakhirP1)

HasilakhirP2 = pd.concat([expected_return_PortofolioSIM2, Risiko_PortofolioSIM2['Risiko_Port'], Sharpe_PortofolioSIM2['Sharpe Ratio'], var_adjusted_sharpe_stats2['VaRSR']], axis=1)
display(HasilakhirP2)

def save_to_excel(dataframes, file_name):
  with pd.ExcelWriter(file_name) as writer:
    for sheet_name, df in dataframes.items():
      df.to_excel(writer, sheet_name=sheet_name)
  print(f"Data saved to '{file_name}'")

dataframes_to_save = {
  'Stock Data Period 1': data_periode1,
  'Stock Data Period 2': data_periode2,
  'Return Period 1': data_returnperiode1,
  'Return Period 2': data_returnperiode2,
  'Statistics Period 1': stat_periode1,
  'Statistics Period 2': stat_periode2,
  'Parameter Market Period 1': parameter_periode1,
  'Parameter Market Period 2': parameter_periode2,
  'Parameter SIM Period 1': sim_periode1,
  'Parameter SIM Period 2': sim_periode2,
  'Portfolio Weight SIM Period 1': pd.DataFrame(Bobot1_PortofolioSIM_list),
  'Portfolio Weight SIM Period 2': pd.DataFrame(Bobot2_PortofolioSIM_list),
  'Expected Return Portfolio SIM Period 1': expected_return_PortofolioSIM1,
  'Expected Return Portfolio SIM Period 2': expected_return_PortofolioSIM2,
  'Risiko Portofolio SIM Period 1': Risiko_PortofolioSIM1,
  'Risiko Portofolio SIM Period 2': Risiko_PortofolioSIM2,
  'Indeks Sharpe SIM Period 1': Sharpe_PortofolioSIM1,
  'Indeks Sharpe SIM Period 2': Sharpe_PortofolioSIM2,
  'Excess Return SIM Period 1': Excess1,
  'Excess Return SIM Period 2': Excess2,
  'Statistics Excess Return SIM Period 1': excess_return_stats1,
  'Statistics Excess Return SIM Period 2': excess_return_stats2,
  'VaRSR SIM Period 1': var_adjusted_sharpe_stats1,
  'VaRSR SIM Period 2': var_adjusted_sharpe_stats2,
  'Final Result Period 1': HasilakhirP1,
  'Final Result Period 2': HasilakhirP2
}

save_to_excel(dataframes_to_save, 'Portfolio Analysis Result.xlsx')

"""## Scatterplot"""

import matplotlib
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import numpy as np
import pandas as pd

def plot_portfolio_scatter(data, metrics=['Sharpe Ratio', 'VaRSR'], main_title = 'Scatterplot'):
    fig, axes = plt.subplots(1, 2, figsize=(12, 5))
    data['Num Stocks'] = data['Kombinasi'].apply(len)
    markers = ['o', 's', '^', 'v', 'D', 'P', 'X', '*', '<', '>']

    unique_num_stocks = sorted(data['Num Stocks'].unique())
    marker_map = {n: markers[i % len(markers)] for i, n in enumerate(unique_num_stocks)}

    stock_handles = []
    stock_labels = []
    added_labels = set()

    for i, color_by in enumerate(metrics):
        ax = axes[i]
        color_data = data[color_by]
        cmap = matplotlib.colors.LinearSegmentedColormap.from_list("", ['gold', 'orange', 'coral', 'tomato', 'saddlebrown'])
        norm_color = plt.Normalize(color_data.min(), color_data.max())
        first_scatter = None
        for j, num in enumerate(unique_num_stocks):
            subset = data[data['Num Stocks'] == num]
            label = f'{num}' if i == 0 and f'{num}' not in added_labels else None

            scatter = ax.scatter(subset['Risiko_Port'], subset['ER Portofolio'],
                                 c=subset[color_by], cmap=cmap, norm=norm_color, s=35,
                                 marker=marker_map.get(num, 'o'), alpha=1, label=label)

            if first_scatter is None:
                first_scatter = scatter
            if i == 0 and f'{num}' not in added_labels:
                 h, l = ax.get_legend_handles_labels()
                 for handle, current_label in zip(h, l):
                     if current_label == f'{num}':
                         stock_handles.append(handle)
                         stock_labels.append(current_label)
                         added_labels.add(current_label)
                         break


        if not data.empty:
            max_p = data.loc[color_data.idxmax()]
            metric_name = color_by
            print(f"Highest Portfolio Performance by {metric_name}:", max_p[['Kombinasi' if 'Kombinasi' in max_p.index else 'Kombinasi', color_by, 'Kombinasi']].to_dict())

            ax.scatter(max_p['Risiko_Port'], max_p['ER Portofolio'],
                        c='lime', s=125, marker='*',
                        edgecolors='black', linewidth=1, zorder=3)

            ax.text(0.5, -0.25, f"★ Optimal Portfolio: {', '.join(max_p['Kombinasi'])}\n{metric_name}: {max_p[color_by]:.5f}",
                    horizontalalignment='center', verticalalignment='center', transform=ax.transAxes,
                    fontsize=9, bbox=dict(boxstyle='round,pad=0.3', fc='white', alpha=0.5))


        cbar = fig.colorbar(first_scatter, ax=ax)
        cbar.set_label(color_by)

        ax.set_xlabel("Portfolio's Risk")
        ax.set_ylabel("Portfolio's Expected Return")
        ax.set_title(f'Color By: {color_by}')
        ax.grid(True, linestyle='--', alpha=0.5)

    fig.legend(stock_handles, stock_labels,
               title='Portfolio Size',
               loc='upper center',
               bbox_to_anchor=(0.5, 1.02),
               ncol=len(stock_handles),
               fancybox=True,
               shadow=True)


    fig.suptitle(main_title, fontsize=14, y=1.08)
    plt.tight_layout(rect=[0, 0.05, 1, 0.98])
    plt.show()

import matplotlib.pyplot as plt

plt.figure(figsize=(6, 3))
plt.scatter(HasilakhirP1['Risiko_Port'], HasilakhirP1['ER Portofolio'])
plt.xlabel('Portfolio Risk')
plt.ylabel('Expected Return')
plt.title('Portfolio Risk vs. Expected Return (Periode 1)')
plt.grid(True)
plt.show()

plot_portfolio_scatter(HasilakhirP1, main_title = "Portfolio's Expected Return vs. Risk (pre-Danantara Period)")

import matplotlib.pyplot as plt

plt.figure(figsize=(6, 3))
plt.scatter((HasilakhirP2['Risiko_Port']), HasilakhirP2['ER Portofolio'])
plt.xlabel('Portfolio Risk')
plt.ylabel('Expected Return')
plt.title('Portfolio Risk vs. Expected Return (Periode 2)')
plt.grid(True)
plt.show()

plot_portfolio_scatter(HasilakhirP2, main_title= "Portfolio's Expected Return vs. Risk (post-Danantara Period)")

HasilakhirP1['Periode'] = 'Periode 1'
HasilakhirP2['Periode'] = 'Periode 2'

if 'Num Stocks' not in HasilakhirP1.columns:
    HasilakhirP1['Num Stocks'] = HasilakhirP1['Kombinasi'].apply(lambda x: len(eval(x)) if isinstance(x, str) else len(x))

if 'Num Stocks' not in HasilakhirP2.columns:
    HasilakhirP2['Num Stocks'] = HasilakhirP2['Kombinasi'].apply(lambda x: len(eval(x)) if isinstance(x, str) else len(x))

averageP1 = HasilakhirP1.groupby('Num Stocks')[['ER Portofolio', 'Risiko_Port', 'Sharpe Ratio', 'VaRSR']].mean()
averageP1

averageP2 = HasilakhirP2.groupby('Num Stocks')[['ER Portofolio', 'Risiko_Port', 'Sharpe Ratio', 'VaRSR']].mean()
averageP2



import matplotlib.pyplot as plt

plt.figure(figsize=(10, 6))

# Plot the average Sharpe Index and VaRSR against the number of stocks
plt.plot(averageP1.index, averageP1['Sharpe Ratio'], marker='o', label='Average Sharpe Ratio')
plt.plot(averageP1.index, averageP1['VaRSR'], marker='o', label='Average VaRSR')

plt.xlabel('Portfolio Size')
plt.ylabel('Average')
plt.title('Average Indeks Sharpe and VaRSR by Portfolio Size (Periode 1)')
plt.grid(True)
plt.legend()
plt.show()

import matplotlib.pyplot as plt

plt.figure(figsize=(10, 6))

# Plot the average Sharpe Index and VaRSR against the number of stocks
plt.plot(averageP2.index, averageP2['Sharpe Ratio'], marker='o', label='Average Sharpe Ratio')
plt.plot(averageP2.index, averageP2['VaRSR'], marker='o', label='Average VaRSR')

plt.xlabel('Portfolio Size')
plt.ylabel('Average')
plt.title('Average Indeks Sharpe and VaRSR by Portfolio Size (Periode 2)')
plt.grid(True)
plt.legend()
plt.show()