Think like the best software engineer and give e the code for :
Download your data from either Python or R
.

Make sure you adhere to the professional standards. ETFs & Historical Returns

1
)

Question

Think like the best software engineer and give e the code for :
Download your data from either Python or R
.
 
 ﻿Make sure you adhere to the professional standards. ETFs & Historical Returns

1
)
 ﻿Calculate the average & median 
(
daily
,
 ﻿weekly, monthly, yearly
)
 ﻿net return 
(
not log return or gross return
)
 
 ﻿for the following GIC Sector ETFs between 
1
/
1
/
2
0
1
5
 ﻿and 
1
/
1
/
2
0
2
5
:

(
Download as much data as available and cite your data source
)
 
1
1
 ﻿GIC Sectors 
(
1
1
 ﻿Separate Indexes
/
ETFs
)
 ﻿XLC Communication ServicesXLY 
{
XLV was a typo
}
 ﻿Consumer DiscretionaryXLP Consumer StaplesXLE EnergyXLF FinancialsXLV Health CareXLI IndustriesXLB MaterialsXLRE Real EstateXLK TechnologyXLU Utilities We will assume 
2
5
2
 ﻿trading days in a year,
2
1
 ﻿trading days in a month, and
 
Use a rolling window to calculate the

(
daily
,
 ﻿weekly, monthly, yearly
)
 ﻿net returns For example, for yearly return, the calculation doesn
’
t have to be between Jan 
1
,
 
2
0
1
0
 ﻿and Jan 
1
,
 
2
0
1
1
.
 
 ﻿Use a rolling window of 
2
5
2
 ﻿to calculate the net returns 
(
i
.
e
.
,
 ﻿you should have more than 
1
0
 ﻿observations of yearly returns over a 
1
0
-
y

VIPSolutions · Accepted Answer

# GIC Sector ETFs Analysis, 2015–2025

This analysis uses **Python** and adheres to professional standards.  
**Data Source:** [Yahoo Finance](https://finance.yahoo.com/) (via `yfinance` library)  
**ETFs**:  
- XLC (Communication Services)  
- XLY (Consumer Discretionary)  
- XLP (Consumer Staples)  
- XLE (Energy)  
- XLF (Financials)  
- XLV (Health Care)  
- XLI (Industrials)  
- XLB (Materials)  
- XLRE (Real Estate)  
- XLK (Technology)  
- XLU (Utilities)

> **Note:** Replace any ETF ticker if not available on Yahoo Finance.  
>  
> **Assumptions:**  
> - 252 trading days/year  
> - 21 trading days/month  
> - Constant risk-free rate for Sharpe ratio: 4% per year (.04/252 per day)

---

## 1. Download Data

```python
import yfinance as yf
import pandas as pd
from datetime import datetime

tickers = ["XLC", "XLY", "XLP", "XLE", "XLF", "XLV", "XLI", "XLB", "XLRE", "XLK", "XLU"]
start = "2015-01-01"
end = "2025-01-01"

data = yf.download(tickers, start=start, end=end)['Adj Close']
data.to_csv("gic_sector_etfs.csv")  # Save for reproducibility
```
*Data source: Yahoo Finance, via yfinance. Data includes adjusted close prices.*  
*If a ticker is missing, check for launch date or substitute with a relevant ETF.*

---

## 2. Calculate Net Returns (Rolling Windows)

```python
import numpy as np

# Calculate net returns
daily_ret = data.pct_change().dropna()
weekly_ret = data.pct_change(5).dropna()
monthly_ret = data.pct_change(21).dropna()
yearly_ret = data.pct_change(252).dropna()

def get_stats(ret):
    return pd.DataFrame({
        'mean': ret.mean(),
        'median': ret.median()
    })

daily_stats = get_stats(daily_ret)
weekly_stats = get_stats(weekly_ret)
monthly_stats = get_stats(monthly_ret)
yearly_stats = get_stats(yearly_ret)

print("Daily stats:\n", daily_stats)
print("Weekly stats:\n", weekly_stats)
print("Monthly stats:\n", monthly_stats)
print("Yearly stats:\n", yearly_stats)
```

---

## 3. Decade & N-Year CAGR

```python
# Decade CAGR function
def CAGR(series, years):
    return ((series[-1] / series[]) ** (1 / years)) - 1

years = (data.index[-1] - data.index[]).days / 365.25
n = 5  # Example: 5-year CAGR

results = {}
for ticker in tickers:
    results[ticker] = {
        'decade_CAGR': CAGR(data[ticker].dropna(), 10),
        f'{n}_year_CAGR': CAGR(data[ticker].dropna()[-int(n*252):], n)
    }
print(pd.DataFrame(results))
```

---

## 4. Price Series Plot

```python
import matplotlib.pyplot as plt

plt.figure(figsize=(14, 7))
for ticker in tickers:
    plt.plot(data[ticker], label=ticker)
plt.legend()
plt.title('GIC Sector ETFs: Adjusted Close Prices (2015-2025)')
plt.xlabel('Date')
plt.ylabel('Price ($)')
plt.tight_layout()
plt.savefig("etf_price_series.png", dpi=200)
```
*Image: Line plot of adjusted close prices for all 11 sector ETFs from 2015 to 2025.*  
**Alt text:** Line plot showing 11 sector ETF price series from 2015 to 2025.

---

## 5. Scatterplot: Avg Daily Return vs. Volatility

```python
mean_daily = daily_ret.mean()
vol_daily = daily_ret.std()

plt.figure(figsize=(8, 6))
plt.scatter(mean_daily, vol_daily)
for t in tickers:
    plt.annotate(t, (mean_daily[t], vol_daily[t]))
plt.xlabel('Average Daily Return')
plt.ylabel('Daily Return Volatility')
plt.title('Risk/Return: Sector ETFs (2015–2025)')
plt.grid(True)
plt.tight_layout()
plt.savefig("risk_return_scatter.png", dpi=200)
```
**Alt text:** Scatterplot of average daily return vs volatility for 11 sector ETFs.

**Comment:**  
- Sectors with higher volatility tend to offer higher returns (risk/return trade-off).
- Utility and Staples likely cluster as low-risk, low-return; Tech and Energy as higher-risk, higher-return.

---

## 6. Correlation Matrix

```python
import seaborn as sns

corr = daily_ret.corr()
plt.figure(figsize=(10,8))
sns.heatmap(corr, annot=True, cmap='coolwarm', fmt=".2f")
plt.title("Correlation Matrix: Daily Returns (2015–2025)")
plt.tight_layout()
plt.savefig("correlation_matrix.png", dpi=200)
```
**Alt text:** Heatmap of correlation matrix between daily ETF returns.

**Analysis:**  
- Strong correlations between cyclical sectors (e.g., XLF/XLI).
- Defensive sectors (e.g., XLU, XLP) may show lower correlation with others.

---

## 7. Value at Risk (VaR) and Conditional VaR (CVaR)

```python
def var_cvar(ret, alpha=.01):
    VaR = ret.quantile(alpha)
    CVaR = ret[ret  : right tail; < : left tail.
- Kurtosis > : fat tails.

---

## 9. Sharpe Ratios (Stat 686)

Assume constant risk-free rate $ r_f = .04/252 $ per day.

```python
rf_daily = .04 / 252
def sharpe(ret, rf=rf_daily):
    excess = ret - rf
    return excess.mean() / excess.std()

sharpe_daily = daily_ret.apply(sharpe)
sharpe_weekly = weekly_ret.apply(lambda x: sharpe(x, rf_daily*5))
sharpe_monthly = monthly_ret.apply(lambda x: sharpe(x, rf_daily*21))
sharpe_yearly = yearly_ret.apply(lambda x: sharpe(x, rf_daily*252))

sharpe_ratios = pd.DataFrame({
    'Daily': sharpe_daily,
    'Weekly': sharpe_weekly,
    'Monthly': sharpe_monthly,
    '

VIPSolutions · Answer

```python
# GIC Sector ETFs Analysis, 2015–2025

# Import Necessary Libraries
import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import scipy.stats as stats
from datetime import datetime

# Define Constants
tickers = ["XLC", "XLY", "XLP", "XLE", "XLF", "XLV", "XLI", "XLB", "XLRE", "XLK", "XLU"]
start = "2015-01-01"
end = "2025-01-01"
rf_daily = 0.04 / 252  # Risk-free rate

# 1. Download Data
data = yf.download(tickers, start=start, end=end)['Adj Close']
data.to_csv("gic_sector_etfs.csv")  # Save for reproducibility

# 2. Calculate Net Returns (Rolling Windows)
daily_ret = data.pct_change().dropna()
weekly_ret = data.pct_change(5).dropna()
monthly_ret = data.pct_change(21).dropna()
yearly_ret = data.pct_change(252).dropna()

def get_stats(ret):
    return pd.DataFrame({
        'mean': ret.mean(),
        'median': ret.median()
    })

# Calculate stats
daily_stats = get_stats(daily_ret)
weekly_stats = get_stats(weekly_ret)
monthly_stats = get_stats(monthly_ret)
yearly_stats = get_stats(yearly_ret)

print("Daily stats:
", daily_stats)
print("Weekly stats:
", weekly_stats)
print("Monthly stats:
", monthly_stats)
print("Yearly stats:
", yearly_stats)

# 3. Decade & N-Year CAGR
def CAGR(series, years):
    return ((series[-1] / series[0]) ** (1 / years)) - 1

n = 5  # Example: 5-year CAGR
results = {}
for ticker in tickers:
    results[ticker] = {
        'decade_CAGR': CAGR(data[ticker].dropna(), 10),
        f'{n}_year_CAGR': CAGR(data[ticker].dropna()[-int(n*252):], n)
    }
print(pd.DataFrame(results))

# 4. Price Series Plot
plt.figure(figsize=(14, 7))
for ticker in tickers:
    plt.plot(data[ticker], label=ticker)
plt.legend()
plt.title('GIC Sector ETFs: Adjusted Close Prices (2015-2025)')
plt.xlabel('Date')
plt.ylabel('Price ($)')
plt.tight_layout()
plt.savefig("etf_price_series.png", dpi=200)

# 5. Scatterplot: Avg Daily Return vs. Volatility
mean_daily = daily_ret.mean()
vol_daily = daily_ret.std()

plt.figure(figsize=(8, 6))
plt.scatter(mean_daily, vol_daily)
for t in tickers:
    plt.annotate(t, (mean_daily[t], vol_daily[t]))
plt.xlabel('Average Daily Return')
plt.ylabel('Daily Return Volatility')
plt.title('Risk/Return: Sector ETFs (2015–2025)')
plt.grid(True)
plt.tight_layout()
plt.savefig("risk_return_scatter.png", dpi=200)

# 6. Correlation Matrix
corr = daily_ret.corr()
plt.figure(figsize=(10,8))
sns.heatmap(corr, annot=True, cmap='coolwarm', fmt=".2f")
plt.title("Correlation Matrix: Daily Returns (2015–2025)")
plt.tight_layout()
plt.savefig("correlation_matrix.png", dpi=200)

# 7. Value at Risk (VaR) and Conditional VaR (CVaR)
def var_cvar(ret, alpha=.01):
    VaR = ret.quantile(alpha)
    CVaR = ret[ret

VIPSolutions · Answer

# Summary of GIC Sector ETFs Analysis (2015–2025)

This Python script performs a comprehensive analysis of 11 GIC Sector ETFs over a 10-year period, from January 1, 2015, to January 1, 2025. The analysis includes the following key components:

## 1. Data Acquisition
- Downloaded adjusted close prices for the ETFs using the `yfinance` library.
- Saved the data to a CSV file for reproducibility.

## 2. Net Returns Calculation
- Calculated daily, weekly, monthly, and yearly net returns using percentage change.
- Computed average and median returns for each period.

## 3. CAGR Calculation
- Calculated the Compound Annual Growth Rate (CAGR) for both a decade and a specified N-year period (e.g., 5 years).

## 4. Price Series Visualization
- Created a line plot displaying the adjusted close prices for all ETFs.

## 5. Risk/Return Analysis
- Generated a scatterplot to visualize the relationship between average daily returns and daily return volatility for all ETFs.

## 6. Correlation Analysis
- Constructed a correlation matrix of daily returns to assess relationships between sectors.

## 7. Value at Risk (VaR) and Conditional VaR (CVaR)
- Calculated VaR and CVaR at 1% and 5% significance levels for each ETF.

## 8. Robust Statistical Analysis
- Performed a statistical analysis on the return series of a chosen ETF (e.g., XLK).
- Included tests for normality and descriptive statistics (mean, standard deviation, skewness, kurtosis).
- Plotted the distribution of returns using a histogram and Kernel Density Estimate (KDE).

## 9. Sharpe Ratio Calculation
- Calculated Sharpe ratios for daily, weekly, monthly, yearly, and 10-year periods to assess risk-adjusted returns.

## 10. Maximum Drawdown Analysis
- Evaluated the maximum drawdown from an equally weighted portfolio of the ETFs, visualizing the drawdown over time.

## Outputs
- The script generates various plots and saves them as PNG files.
- Displays results and statistics in the console for review.
- All calculations and visualizations are performed in a structured manner adhering to professional standards.

### Dependencies
Ensure the installation of the following libraries:
- `yfinance`
- `pandas`
- `numpy`
- `matplotlib`
- `seaborn`
- `scipy`

By running the script, users can gain insights into the performance, risk, and characteristics of the GIC Sector ETFs over the specified period.

✨ VIPSolutions

Question:

Final Answer:

Question:

Final Answer:

Question:

Final Answer:

📢 Instructions:

Study Help, Fast Answers

✨ VIPSolutions

Question:

Final Answer:

Question:

Final Answer:

Question:

Final Answer:

📢 Instructions:

Related Answers

Study Help, Fast Answers