量化交易基础（二）

# 交易示例
number_of_shares = 100
trade_id = 15432
days_to_expiry = 30
print(f"Trade ID {trade_id}: Bought {number_of_shares} shares.")
print(f"Type of 'number_of_shares': {type(number_of_shares)}")

# 金融指标示例
stock_price = 149.95
interest_rate = 0.0525  # 5.25% 的利率
daily_return = -0.015   # -1.5% 的日收益率
print(f"Current stock price: ${stock_price}")
print(f"Type of 'stock_price': {type(stock_price)}")

#浮点精度问题
val = 0.35 + 0.1
print(val)  # 输出: 0.44999999999999996


#使用Decimal模块
from decimal import Decimal
# 使用 Decimal 进行精确的金融计算
fee_1 = Decimal('0.35')
fee_2 = Decimal('0.10')
total_fee = fee_1 + fee_2
print(f"Total fee with Decimal: {total_fee}")  # 输出: 0.45

# 资产标识符示例
ticker = 'aapl'
currency_pair = 'EURUSD'
sector = 'Information Technology'
# 使用字符串方法标准化数据
standardized_ticker = ticker.upper()  # 常见做法
print(f"Standardized Ticker: {standardized_ticker}")
# F-字符串可用于创建格式化报告
trade_confirmation = f"Executed trade for 100 shares of {standardized_ticker}"
print(trade_confirmation)

# 交易系统中的标志示例
is_market_open = True
has_sufficient_capital = True
is_trade_profitable = (151.25 - stock_price) > 0  # 这个表达式会计算为布尔值
# 布尔值控制决策
if is_market_open and has_sufficient_capital:
    print("System is ready to place a trade.")
else:
    print("System is offline or capital is insufficient.")
print(f"Is the trade profitable? {is_trade_profitable}")


#**列表 (list)**：可变、有序的元素序列，用于存储历史价格时间序列或交易记录集合：
# 一周的股票收盘价示例
aapl_prices_list = [150.10, 151.20, 150.85, 152.50, 152.30]
aapl_prices_list.append(153.10)  # 列表是可变的，可以添加元素
print(f"Price on the first day: {aapl_prices_list[0]}")
print(f"Updated price list: {aapl_prices_list}")

#**元组 (tuple)**：不可变、有序的序列。在金融中，许多记录一旦创建就应永久保存：
# 已完成的交易记录示例
trade_record = ('AAPL', 152.50, 100, '2023-10-27T10:00:00Z')
# 尝试修改它会引发错误，确保数据完整性
# trade_record[1] = 152.60  # 这会引起 TypeError
print(f"Immutable Trade Record: {trade_record}")

# 简单股票投资组合示例
portfolio = {'AAPL': 100, 'GOOG': 50, 'MSFT': 75}
# 访问持仓
print(f"Shares of GOOG held: {portfolio['GOOG']}")
# 添加新持仓
portfolio['AMZN'] = 25
print(f"Updated Portfolio: {portfolio}")
# 更新现有持仓
portfolio['AAPL'] += 50  # 又买了 50 股
print(f"Final shares of AAPL: {portfolio['AAPL']}")

# 管理观察清单示例
watchlist_1 = {'AAPL', 'MSFT', 'GOOG', 'AMZN'}
watchlist_2 = {'AAPL', 'NVDA', 'TSLA', 'MSFT'}
# 查找两个观察清单中的共同股票（交集）
common_stocks = watchlist_1.intersection(watchlist_2)
print(f"Common Stocks: {common_stocks}")
# 查找两个观察清单中的所有唯一股票（并集）
all_stocks = watchlist_1.union(watchlist_2)
print(f"All Unique Stocks: {all_stocks}")

# 简化的价格数据示例
prices = [5, 6, 7, 7, 6, 9, 8, 9, 9, 7, 6, 6]
# 本例中使用简化的"当前"移动平均线
# 实际场景中，这些会基于完整历史计算
short_term_sma = sum(prices[-3:]) / 3  # 3 天 SMA
long_term_sma = sum(prices[-7:]) / 7   # 7 天 SMA
print(f"Short-term SMA: {short_term_sma:.2f}")
print(f"Long-term SMA: {long_term_sma:.2f}")
# 使用条件语句实现交易逻辑
if short_term_sma > long_term_sma:
    print("Signal: BUY")
    print("Reason: Short-term momentum is positive.")
elif short_term_sma < long_term_sma:
    print("Signal: SELL")
    print("Reason: Short-term momentum is negative.")
else:
    print("Signal: HOLD")
    print("Reason: No clear trend divergence.")
    
tickers = ['AAPL', 'MSFT', 'GOOG', 'AMZN']
print("Processing trades for the following tickers:")
for ticker in tickers:
    # 实际应用中，这里会调用数据获取函数
    print(f" -> Fetching latest price for {ticker}...")
    # 模拟一些处理过程
    print(f" -> Analyzing {ticker} for trading opportunities.")
    
portfolio = {'AAPL': 150, 'NVDA': 50, 'TSLA': 75}
# 假设我们已将最新价格获取到另一个字典中
current_prices = {'AAPL': 171.50, 'NVDA': 460.18, 'TSLA': 256.49}
total_portfolio_value = 0.0
print("\nCalculating portfolio value:")
for ticker, shares in portfolio.items():
    price = current_prices[ticker]
    position_value = shares * price
    total_portfolio_value += position_value
    print(f" Position: {ticker}, Shares: {shares}, Value: ${position_value:,.2f}")
print(f"\nTotal Portfolio Market Value: ${total_portfolio_value:,.2f}")

import random
# 简化的风险值示例
# 实际中，这会是复杂计算，如投资组合标准差
asset_risks = {'Bonds': 0.05, 'BlueChipStock': 0.15, 'TechStock': 0.25, 'Crypto': 0.40}
asset_list = list(asset_risks.keys())
max_portfolio_risk = 0.50
current_portfolio_risk = 0.0
portfolio_composition = []
print(f"\nBuilding portfolio with max risk target of {max_portfolio_risk:.2f}:")
# 只要风险低于最大值就继续添加资产
while current_portfolio_risk < max_portfolio_risk:
    # 随机选择要添加的资产
    asset_to_add = random.choice(asset_list)
    asset_risk_value = asset_risks[asset_to_add]
    # 检查添加此资产是否会超过最大风险
    if current_portfolio_risk + asset_risk_value > max_portfolio_risk:
        print(f"Cannot add {asset_to_add} (risk {asset_risk_value:.2f}), would exceed max risk.")
        break  # break 语句立即退出循环
    # 添加资产并更新风险
    portfolio_composition.append(asset_to_add)
    current_portfolio_risk += asset_risk_value
    print(f" Added {asset_to_add}. Current portfolio risk: {current_portfolio_risk:.2f}")
print(f"\nFinal Portfolio Composition: {portfolio_composition}")
print(f"Final Portfolio Risk: {current_portfolio_risk:.2f}")


def function_name(parameter1, parameter2):
    """
    这是文档字符串。它解释函数的功能。
    专业代码必须有良好的文档字符串。
    """
    # 执行操作的代码块
    result = parameter1 + parameter2
    return result
    
import math
def calculate_annualized_volatility(prices_list):
    """
    从日价格列表计算股票的年化波动率。
    
    参数:
    prices_list (list): 表示日价格的浮点数或整数列表
    
    返回:
    float: 年化波动率
    """
    # 步骤 1: 计算日收益率
    daily_returns = []
    for i in range(1, len(prices_list)):
        # (今日价格 / 昨日价格) - 1
        daily_return = (prices_list[i] / prices_list[i-1]) - 1
        daily_returns.append(daily_return)
    
    if not daily_returns:
        return 0.0
    
    # 步骤 2: 计算收益率的标准差
    # 首先，计算平均收益率
    mean_return = sum(daily_returns) / len(daily_returns)
    # 然后，计算方差
    variance = sum([(r - mean_return) ** 2 for r in daily_returns]) / len(daily_returns)
    std_dev = math.sqrt(variance)
    
    # 步骤 3: 将波动率年化
    trading_days = 252
    annualized_volatility = std_dev * math.sqrt(trading_days)
    
    return annualized_volatility

# --- 使用函数 ---
aapl_prices = [150.1, 151.2, 150.8, 152.5, 152.3, 153.1, 155.0, 154.5]
volatility = calculate_annualized_volatility(aapl_prices)
print(f"Calculated Annualized Volatility: {volatility:.2%}")

# 导入整个模块
import math
print(math.sqrt(25))  # 使用 module_name.function_name 调用函数

# 从模块导入特定函数
from math import sqrt
print(sqrt(25))  # 直接按名称调用函数

# 量化社区通用约定是使用别名
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt


###
#创建模块文件：在项目目录中创建名为 financial_metrics.py 的新文件。

#向模块添加函数：

###

import math

def calculate_annualized_volatility(prices_list):
    """
    从日价格列表计算股票的年化波动率。
    ... (与前面相同的文档字符串)...
    """
    #... (与前面相同的函数代码)...
    return annualized_volatility

def calculate_simple_return(start_price, end_price):
    """计算一段时间内的简单收益率。"""
    return (end_price / start_price) - 1
    
#导入和使用自定义模块：
# 导入自定义模块
import financial_metrics

# 使用模块中的函数
aapl_prices = [150.1, 151.2, 150.8, 152.5, 152.3, 153.1, 155.0, 154.5]
vol = financial_metrics.calculate_annualized_volatility(aapl_prices)
ret = financial_metrics.calculate_simple_return(aapl_prices[0], aapl_prices[-1])
print(f"Using our custom module:")
print(f" Annualized Volatility: {vol:.2%}")
print(f" Total Return: {ret:.2%}")