金融领域入门学习完全指南：从基础到实战

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 现值计算
def present_value(future_value, rate, periods):
    """
    计算现值
    future_value: 终值
    rate: 利率
    periods: 期数
    """
    return future_value / (1 + rate) ** periods

# 终值计算
def future_value(present_value, rate, periods):
    """
    计算终值
    present_value: 现值
    rate: 利率
    periods: 期数
    """
    return present_value * (1 + rate) ** periods

# 示例
pv = present_value(1000, 0.05, 5)  # 5年后1000元的现值
fv = future_value(1000, 0.05, 5)    # 1000元5年后的终值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 简单的量化选股策略
import pandas as pd
import numpy as np

def select_stocks(data, pe_threshold=20, roe_threshold=0.15):
    """
    基于PE和ROE选股
    data: 股票数据
    pe_threshold: PE阈值
    roe_threshold: ROE阈值
    """
    # 筛选低PE、高ROE的股票
    selected = data[
        (data['PE'] < pe_threshold) &
        (data['ROE'] > roe_threshold)
    ]
    return selected

# 示例
stocks = pd.DataFrame({
    'code': ['000001', '000002', '000003'],
    'PE': [15, 25, 18],
    'ROE': [0.20, 0.12, 0.18]
})

selected = select_stocks(stocks)
print(selected)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

def bond_price(face_value, coupon_rate, market_rate, years):
    """
    计算债券价格
    face_value: 面值
    coupon_rate: 票面利率
    market_rate: 市场利率
    years: 期限
    """
    coupon = face_value * coupon_rate
    price = 0

    # 计算各期现金流现值
    for i in range(1, years + 1):
        price += coupon / (1 + market_rate) ** i

    # 加上本金现值
    price += face_value / (1 + market_rate) ** years

    return price

# 示例
price = bond_price(1000, 0.05, 0.06, 5)
print(f"债券价格: {price:.2f}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 基金定投计算
def dollar_cost_averaging(monthly_investment, months, avg_price):
    """
    定投计算
    monthly_investment: 每月投资金额
    months: 投资月数
    avg_price: 平均价格
    """
    total_investment = monthly_investment * months
    total_shares = total_investment / avg_price
    return total_shares, total_investment

# 示例
shares, investment = dollar_cost_averaging(1000, 12, 1.5)
print(f"总份额: {shares:.2f}, 总投资: {investment}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 简单的期权定价（Black-Scholes模型简化版）
import math
from scipy.stats import norm

def black_scholes(S, K, T, r, sigma, option_type='call'):
    """
    Black-Scholes期权定价
    S: 当前价格
    K: 行权价
    T: 到期时间（年）
    r: 无风险利率
    sigma: 波动率
    option_type: 'call'或'put'
    """
    d1 = (math.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * math.sqrt(T))
    d2 = d1 - sigma * math.sqrt(T)

    if option_type == 'call':
        price = S * norm.cdf(d1) - K * math.exp(-r * T) * norm.cdf(d2)
    else:
        price = K * math.exp(-r * T) * norm.cdf(-d2) - S * norm.cdf(-d1)

    return price

# 示例
call_price = black_scholes(100, 105, 0.25, 0.05, 0.2, 'call')
print(f"看涨期权价格: {call_price:.2f}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 理财目标规划
def financial_planning(target_amount, current_amount, annual_return, years):
    """
    计算需要每月投资金额
    target_amount: 目标金额
    current_amount: 当前金额
    annual_return: 年化收益率
    years: 投资年限
    """
    monthly_return = annual_return / 12
    months = years * 12

    # 计算每月需要投资金额
    future_value_current = current_amount * (1 + monthly_return) ** months
    needed = target_amount - future_value_current

    if needed <= 0:
        return 0

    # 计算每月投资金额（年金终值公式）
    monthly_investment = needed * monthly_return / ((1 + monthly_return) ** months - 1)

    return monthly_investment

# 示例
monthly = financial_planning(1000000, 100000, 0.08, 10)
print(f"每月需要投资: {monthly:.2f}元")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# 移动平均策略
import pandas as pd
import numpy as np

def moving_average_strategy(data, short_window=5, long_window=20):
    """
    移动平均策略
    data: 价格数据
    short_window: 短期均线
    long_window: 长期均线
    """
    data['MA_short'] = data['close'].rolling(window=short_window).mean()
    data['MA_long'] = data['close'].rolling(window=long_window).mean()

    # 生成交易信号
    data['signal'] = 0
    data.loc[data['MA_short'] > data['MA_long'], 'signal'] = 1  # 买入
    data.loc[data['MA_short'] < data['MA_long'], 'signal'] = -1  # 卖出

    return data

# 示例
price_data = pd.DataFrame({
    'date': pd.date_range('2024-01-01', periods=100),
    'close': np.random.randn(100).cumsum() + 100
})

result = moving_average_strategy(price_data)
print(result[['close', 'MA_short', 'MA_long', 'signal']].tail())

1
2
3
4
5
6
7
8
9

# 使用tushare获取股票数据
import tushare as ts

# 初始化（需要token）
# ts.set_token('your_token')
# pro = ts.pro_api()

# 获取股票数据
# df = pro.daily(ts_code='000001.SZ', start_date='20240101', end_date='20241201')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# 计算技术指标
def calculate_indicators(data):
    """
    计算技术指标
    """
    # RSI
    delta = data['close'].diff()
    gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
    loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
    rs = gain / loss
    data['RSI'] = 100 - (100 / (1 + rs))

    # MACD
    exp1 = data['close'].ewm(span=12).mean()
    exp2 = data['close'].ewm(span=26).mean()
    data['MACD'] = exp1 - exp2
    data['Signal'] = data['MACD'].ewm(span=9).mean()

    return data

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 计算VaR
def calculate_var(returns, confidence_level=0.95):
    """
    计算VaR
    returns: 收益率序列
    confidence_level: 置信水平
    """
    var = np.percentile(returns, (1 - confidence_level) * 100)
    return abs(var)

# 示例
returns = np.random.normal(0.001, 0.02, 1000)
var_95 = calculate_var(returns, 0.95)
print(f"95% VaR: {var_95:.4f}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 计算最大回撤
def max_drawdown(prices):
    """
    计算最大回撤
    prices: 价格序列
    """
    cumulative = (1 + prices).cumprod()
    running_max = cumulative.expanding().max()
    drawdown = (cumulative - running_max) / running_max
    return drawdown.min()

# 示例
prices = np.random.randn(100).cumsum()
max_dd = max_drawdown(prices)
print(f"最大回撤: {max_dd:.4f}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

# 投资组合优化
from scipy.optimize import minimize

def portfolio_optimization(returns, target_return=None):
    """
    投资组合优化
    returns: 各资产收益率
    target_return: 目标收益率
    """
    n_assets = len(returns.columns)

    # 计算协方差矩阵
    cov_matrix = returns.cov()
    mean_returns = returns.mean()

    def portfolio_variance(weights):
        return np.dot(weights.T, np.dot(cov_matrix, weights))

    # 约束条件
    constraints = [{'type': 'eq', 'fun': lambda x: np.sum(x) - 1}]

    # 如果有目标收益
    if target_return:
        constraints.append({
            'type': 'eq',
            'fun': lambda x: np.dot(mean_returns, x) - target_return
        })

    # 边界条件
    bounds = tuple((0, 1) for _ in range(n_assets))

    # 初始权重
    initial_weights = np.array([1/n_assets] * n_assets)

    # 优化
    result = minimize(
        portfolio_variance,
        initial_weights,
        method='SLSQP',
        bounds=bounds,
        constraints=constraints
    )

    return result.x

# 示例
# 假设有3只股票
returns = pd.DataFrame({
    'stock1': np.random.normal(0.001, 0.02, 100),
    'stock2': np.random.normal(0.0015, 0.025, 100),
    'stock3': np.random.normal(0.0008, 0.018, 100)
})

optimal_weights = portfolio_optimization(returns)
print(f"最优权重: {optimal_weights}")