Python：如何循环代码，以便它从csv文件中一个接一个地提取列？

我需要帮助的问题是：如何循环代码，以便它一个接一个地从csv文件中提取列？我的excel文件中，r和m目前各有一列（单元格数相等）。我希望代码以与当前相同的方式执行计算，然后跳转到csv m和r中的第二列并执行相同的计算-我需要能够对所有列重复此过程（我在两个文件中都有大约1300列）。你能告诉我怎么做吗

代码

import math
import numpy

"""
Note - for some of the metrics the absolute value is returns. This is because if the risk (loss) is higher we want to
discount the expected excess return from the portfolio by a higher amount. Therefore risk should be positive.
"""


def vol(returns):
    # Return the standard deviation of returns
    return numpy.std(returns)


def beta(returns, market):
    # Create a matrix of [returns, market]
    m = numpy.matrix([returns, market])
    # Return the covariance of m divided by the standard deviation of the market returns
    return numpy.cov(m)[0][1] / numpy.std(market)


def lpm(returns, threshold, order):
    # This method returns a lower partial moment of the returns
    # Create an array he same length as returns containing the minimum return threshold
    threshold_array = numpy.empty(len(returns))
    threshold_array.fill(threshold)
    # Calculate the difference between the threshold and the returns
    diff = threshold_array - returns
    # Set the minimum of each to 0
    diff = diff.clip(min=0)
    # Return the sum of the different to the power of order
    return numpy.sum(diff ** order) / len(returns)


def hpm(returns, threshold, order):
    # This method returns a higher partial moment of the returns
    # Create an array he same length as returns containing the minimum return threshold
    threshold_array = numpy.empty(len(returns))
    threshold_array.fill(threshold)
    # Calculate the difference between the returns and the threshold
    diff = returns - threshold_array
    # Set the minimum of each to 0
    diff = diff.clip(min=0)
    # Return the sum of the different to the power of order
    return numpy.sum(diff ** order) / len(returns)


def var(returns, alpha):
    # This method calculates the historical simulation var of the returns
    sorted_returns = numpy.sort(returns)
    # Calculate the index associated with alpha
    index = int(alpha * len(sorted_returns))
    # VaR should be positive
    return abs(sorted_returns[index])


def cvar(returns, alpha):
    # This method calculates the condition VaR of the returns
    sorted_returns = numpy.sort(returns)
    # Calculate the index associated with alpha
    index = int(alpha * len(sorted_returns))
    # Calculate the total VaR beyond alpha
    sum_var = sorted_returns[0]
    for i in range(1, index):
        sum_var += sorted_returns[i]
    # Return the average VaR
    # CVaR should be positive
    return abs(sum_var / index)


def prices(returns, base):
    # Converts returns into prices
    s = [base]
    for i in range(len(returns)):
        s.append(base * (1 + returns[i]))
    return numpy.array(s)


def dd(returns, tau):
    # Returns the draw-down given time period tau
    values = prices(returns, 100)
    pos = len(values) - 1
    pre = pos - tau
    drawdown = float('+inf')
    # Find the maximum drawdown given tau
    while pre >= 0:
        dd_i = (values[pos] / values[pre]) - 1
        if dd_i < drawdown:
            drawdown = dd_i
        pos, pre = pos - 1, pre - 1
    # Drawdown should be positive
    return abs(drawdown)


def max_dd(returns):
    # Returns the maximum draw-down for any tau in (0, T) where T is the length of the return series
    max_drawdown = float('-inf')
    for i in range(0, len(returns)):
        drawdown_i = dd(returns, i)
        if drawdown_i > max_drawdown:
            max_drawdown = drawdown_i
    # Max draw-down should be positive
    return abs(max_drawdown)


def average_dd(returns, periods):
    # Returns the average maximum drawdown over n periods
    drawdowns = []
    for i in range(0, len(returns)):
        drawdown_i = dd(returns, i)
        drawdowns.append(drawdown_i)
    drawdowns = sorted(drawdowns)
    total_dd = abs(drawdowns[0])
    for i in range(1, periods):
        total_dd += abs(drawdowns[i])
    return total_dd / periods


def average_dd_squared(returns, periods):
    # Returns the average maximum drawdown squared over n periods
    drawdowns = []
    for i in range(0, len(returns)):
        drawdown_i = math.pow(dd(returns, i), 2.0)
        drawdowns.append(drawdown_i)
    drawdowns = sorted(drawdowns)
    total_dd = abs(drawdowns[0])
    for i in range(1, periods):
        total_dd += abs(drawdowns[i])
    return total_dd / periods


def treynor_ratio(er, returns, market, rf):
    return (er - rf) / beta(returns, market)


def sharpe_ratio(er, returns, rf):
    return (er - rf) / vol(returns)


def information_ratio(returns, benchmark):
    diff = returns - benchmark
    return numpy.mean(diff) / vol(diff)


def modigliani_ratio(er, returns, benchmark, rf):
    np_rf = numpy.empty(len(returns))
    np_rf.fill(rf)
    rdiff = returns - np_rf
    bdiff = benchmark - np_rf
    return (er - rf) * (vol(rdiff) / vol(bdiff)) + rf


def excess_var(er, returns, rf, alpha):
    return (er - rf) / var(returns, alpha)


def conditional_sharpe_ratio(er, returns, rf, alpha):
    return (er - rf) / cvar(returns, alpha)


def omega_ratio(er, returns, rf, target=0):
    return (er - rf) / lpm(returns, target, 1)


def sortino_ratio(er, returns, rf, target=0):
    return (er - rf) / math.sqrt(lpm(returns, target, 2))


def kappa_three_ratio(er, returns, rf, target=0):
    return (er - rf) / math.pow(lpm(returns, target, 3), float(1/3))


def gain_loss_ratio(returns, target=0):
    return hpm(returns, target, 1) / lpm(returns, target, 1)


def upside_potential_ratio(returns, target=0):
    return hpm(returns, target, 1) / math.sqrt(lpm(returns, target, 2))


def calmar_ratio(er, returns, rf):
    return (er - rf) / max_dd(returns)


def sterling_ration(er, returns, rf, periods):
    return (er - rf) / average_dd(returns, periods)


def burke_ratio(er, returns, rf, periods):
    return (er - rf) / math.sqrt(average_dd_squared(returns, periods))


def test_risk_metrics(r, m):
    print("vol =", vol(r))
    print("beta =", beta(r, m))
    print("hpm(0.0)_1 =", hpm(r, 0.0, 1))
    print("lpm(0.0)_1 =", lpm(r, 0.0, 1))
    print("VaR(0.05) =", var(r, 0.05))
    print("CVaR(0.05) =", cvar(r, 0.05))
    print("Drawdown(5) =", dd(r, 5))
    print("Max Drawdown =", max_dd(r))


def test_risk_adjusted_metrics(r, m):
    # Returns from the portfolio (r) and market (m)
    # Expected return
    e = numpy.mean(r)
    # Risk free rate
    f = 0.06
    # Risk-adjusted return based on Volatility
    print("Treynor Ratio =", treynor_ratio(e, r, m, f))
    print("Sharpe Ratio =", sharpe_ratio(e, r, f))
    print("Information Ratio =", information_r
          atio(r, m))
    # Risk-adjusted return based on Value at Risk
    print("Excess VaR =", excess_var(e, r, f, 0.05))
    print("Conditional Sharpe Ratio =", conditional_sharpe_ratio(e, r, f, 0.05))
    # Risk-adjusted return based on Lower Partial Moments
    print("Omega Ratio =", omega_ratio(e, r, f))
    print("Sortino Ratio =", sortino_ratio(e, r, f))
    print("Kappa 3 Ratio =", kappa_three_ratio(e, r, f))
    print("Gain Loss Ratio =", gain_loss_ratio(r))
    print("Upside Potential Ratio =", upside_potential_ratio(r))
    # Risk-adjusted return based on Drawdown risk
    print("Calmar Ratio =", calmar_ratio(e, r, f))
    print("Sterling Ratio =", sterling_ration(e, r, f, 5))
    print("Burke Ratio =", burke_ratio(e, r, f, 5))


if __name__ == "__main__":
    import csv

    # load r
    with open(r'C:\Users\Lenovo\Documents\r.csv') as csvfile:  # change your filename here
        r = numpy.array([float(x[0]) for x in csv.reader(csvfile)])

    # load m
    with open(r'C:\Users\Lenovo\Documents\m.csv') as csvfile:  # change your filename here
        m = numpy.array([float(x[0]) for x in csv.reader(csvfile)])

    test_risk_metrics(r, m)
    test_risk_adjusted_metrics(r, m)

导入数学
进口numpy
"""
注意-对于某些指标，绝对值是回报。这是因为如果风险（损失）更高，我们希望
将投资组合的预期超额回报折现更高的金额。因此，风险应为正。
"""
def vol（返回值）：
#返回返回的标准偏差
返回numpy.std（返回）
def测试版（退货、市场）：
#创建[回报、市场]矩阵
m=numpy.矩阵（[收益，市场]）
#收益m的协方差除以市场收益的标准差
返回numpy.cov（m）[0][1]/numpy.std（市场）
def lpm（退货、阈值、订单）：
#此方法返回较低的返回部分矩
#创建一个与包含最小返回阈值的返回相同长度的数组
threshold_array=numpy.empty（len（返回））
阈值\数组填充（阈值）
#计算阈值和返回值之间的差值
diff=阈值_数组-返回
#将每个值的最小值设置为0
差异=差异剪辑（最小值=0）
#将差分之和返回到顺序幂
退货金额（差异**订单）/len（退货）
def hpm（退货、阈值、订单）：
#此方法返回更高的返回偏矩
#创建一个与包含最小返回阈值的返回相同长度的数组
threshold_array=numpy.empty（len（返回））
阈值\数组填充（阈值）
#计算收益和阈值之间的差异
diff=返回-阈值\u数组
#将每个值的最小值设置为0
差异=差异剪辑（最小值=0）
#将差分之和返回到顺序幂
退货金额（差异**订单）/len（退货）
def变量（返回值，alpha）：
#此方法计算收益的历史模拟var
排序返回=numpy.sort（返回）
#计算与alpha关联的索引
索引=int（alpha*len（已排序的返回））
#VaR应该是正的
返回abs（已排序的_返回[索引]）
def cvar（返回，α）：
#此方法计算收益的条件变量
排序返回=numpy.sort（返回）
#计算与alpha关联的索引
索引=int（alpha*len（已排序的返回））
#计算alpha之外的总VaR
sum\u var=sorted\u返回[0]
对于范围（1，索引）中的i：
sum_var+=排序的_返回[i]
#返回平均VaR
#CVaR应为正值
返回资产负债表（总价值/指数）
def价格（退货、基本价格）：
#将收益转换为价格
s=[基础]
对于范围内的i（len（返回））：
s、 追加（基*（1+返回[i]））
返回numpy.array（个）
def dd（返回，tau）：
#返回给定时间段tau的提取
值=价格（返回值，100）
位置=长度（值）-1
pre=pos-tau
下降=浮动（“+inf”）
#求给定tau的最大降深
当pre>=0时：
dd_i=（值[pos]/值[pre]）-1
如果dd_i<水位下降：
水位下降=dd_i
位置，前置=位置-1，前置-1
#缩编应为正值
返回abs（下降）
def max_dd（返回值）：
#返回（0，T）中任何tau的最大下拉，其中T是返回序列的长度
最大提取=浮动（'-inf'）
对于范围（0，len（返回））中的i：
提款i=dd（收益，i）
如果水位下降>最大水位下降：
最大水位下降=水位下降
#最大压降应为正值
返回abs（最大缩进）
def平均值（返回、期间）：
#返回n个期间内的平均最大压降
提款=[]
对于范围（0，len（返回））中的i：
提款i=dd（收益，i）
提取。追加（提取i）
提取=已排序（提取）
总额=资产负债表（提取[0]）
对于范围内的i（1，周期）：
总额=资产负债表（提取[i]）
返回总日/期间数
def average_dd_squared（收益、期间）：
#返回n个期间内的平均最大压降平方
提款=[]
对于范围（0，len（返回））中的i：
压降i=数学功率（dd（返回，i），2.0）
提取。追加（提取i）
提取=已排序（提取）
总额=资产负债表（提取[0]）
对于范围内的i（1，周期）：
总额=资产负债表（提取[i]）
返回总日/期间数
def treynor_比率（er、收益、市场、rf）：
回报率（er-rf）/beta（回报率，市场）
def夏普比值（er、回波、rf）：
退货（er-rf）/vol（退货）
def信息_比率（回报、基准）：
diff=回报-基准
返回数值平均值（差异）/体积（差异）
def modigliani_比率（er、回报、基准、rf）：
np_rf=numpy.empty（len（返回））
np_射频填充（射频）
rdiff=返回值-np\U rf
bdiff=基准-np_rf
返回（er-rf）*（音量（rdiff）/音量（bdiff））+rf
def超额值（er、返回、rf、α）：
收益率（er-rf）/var（收益率，α）
def条件夏普比率（er、返回、rf、alpha）：
返回（er-rf）/cvar（返回，α）
def omega_比率（er、返回、rf、目标=0）：
返回（er-rf）/lpm（返回，目标，1）
def sortino_比率（er、返回、rf、目标=0）：
返回（er-rf）/数学sqrt（lpm（返回，目标，2））
def卡帕三比（er、返回、rf、目标=0）：
返回（er-rf）/数学功率（lpm（返回，目标，3），浮动（1/3））
def增益损耗比（返回，目标=0）：
返回hpm（返回，目标，1）/
# Loop over columns
for i in range(r.shape[1]):
    test_risk_metrics(r[:,i],m[:,i])
    test_risk_adjusted_metrics(r[:,i],m[:,i])

1.22,3.33,3.24,0.32,0.13
2.42,35.43,2.43,87.77,0.98,0.32,32.43,9.56,74.32,2.32
8.78,0.23,64.61,7.23,8.77,76.77

4.23,7.56,98.65,4.87,9.32
3.34,9.45,0.32,86.44,9.45,3.53,0.65,0.43,1.43,65.54
3.34,89.54,8.43,7.54,83.2,8.43

if __name__ == "__main__":
    with open(r'C:\path\to\r_values.csv') as r_file, \
         open(r'C:\path\to\m_values.csv') as m_file:
        for r, m in zip(r_file, m_file):
            # since our lines are separated by commas, we use `split` function
            # we also cast our values as float
            r = numpy.array([float(x) for x in r.split(',')])
            m = numpy.array([float(x) for x in m.split(',')])

            # diagnostic check
            print(r)  # comment out
            print(m)  # comment out

            # pass to `test_risk_metrics` and `test_risk_adjusted_metrics`
            test_risk_metrics(r, m)
            test_risk_adjusted_metrics(r, m)

[1.22 3.33 3.24 0.32 0.13]
[ 4.23  7.56 98.65  4.87  9.32]
vol = 1.3866996790942157
beta = 0.9980359303098474
hpm(0.0)_1 = 1.6480000000000001
lpm(0.0)_1 = 0.0
VaR(0.05) = 0.13
test.py:68: RuntimeWarning: divide by zero encountered in double_scalars
  return abs(sum_var / index)
CVaR(0.05) = inf
Drawdown(5) = 0.1299999999999999
Max Drawdown = 0.7390300230946882
Treynor Ratio = 1.591125080543938
Sharpe Ratio = 1.145165044703315
Information Ratio = -0.6443354312329719
Excess VaR = 12.215384615384616
Conditional Sharpe Ratio = 0.0
test.py:162: RuntimeWarning: divide by zero encountered in double_scalars
  return (er - rf) / lpm(returns, target, 1)
Omega Ratio = inf
test.py:166: RuntimeWarning: divide by zero encountered in double_scalars
  return (er - rf) / math.sqrt(lpm(returns, target, 2))
Sortino Ratio = inf
test.py:170: RuntimeWarning: divide by zero encountered in double_scalars
  return (er - rf) / math.pow(lpm(returns, target, 3), float(1/3))
Kappa 3 Ratio = inf
test.py:174: RuntimeWarning: divide by zero encountered in double_scalars
  return hpm(returns, target, 1) / lpm(returns, target, 1)
Gain Loss Ratio = inf
test.py:178: RuntimeWarning: divide by zero encountered in double_scalars
  return hpm(returns, target, 1) / math.sqrt(lpm(returns, target, 2))
Upside Potential Ratio = inf
Calmar Ratio = 2.1487625
Sterling Ratio = 2.993751401271527
Burke Ratio = 2.647015918149671
[ 2.42 35.43  2.43 87.77  0.98  0.32 32.43  9.56 74.32  2.32]
[ 3.34  9.45  0.32 86.44  9.45  3.53  0.65  0.43  1.43 65.54]
vol = 30.812687581579116
beta = 14.103506402406339
hpm(0.0)_1 = 24.798
lpm(0.0)_1 = 0.0
VaR(0.05) = 0.32
CVaR(0.05) = inf
Drawdown(5) = 0.6140350877192983
Max Drawdown = 0.9851301115241635
Treynor Ratio = 1.7540318906636725
Sharpe Ratio = 0.8028510961435648
Information Ratio = 0.20592426973227423
Excess VaR = 77.30624999999999
Conditional Sharpe Ratio = 0.0
Omega Ratio = inf
Sortino Ratio = inf
Kappa 3 Ratio = inf
Gain Loss Ratio = inf
Upside Potential Ratio = inf
Calmar Ratio = 25.111403773584907
Sterling Ratio = 78.07671376290729
Burke Ratio = 50.392183664218216
[ 8.78  0.23 64.61  7.23  8.77 76.77]
[ 3.34 89.54  8.43  7.54 83.2   8.43]
vol = 30.714112074998287
beta = -18.831320000339733
hpm(0.0)_1 = 27.731666666666666
lpm(0.0)_1 = 0.0
VaR(0.05) = 0.23
CVaR(0.05) = inf
Drawdown(5) = 6.9519427402863
Max Drawdown = 6.9519427402863
Treynor Ratio = -1.4694491233842049
Sharpe Ratio = 0.9009430778626281
Information Ratio = -0.09563177846201822
Excess VaR = 120.31159420289855
Conditional Sharpe Ratio = 0.0
Omega Ratio = inf
Sortino Ratio = inf
Kappa 3 Ratio = inf
Gain Loss Ratio = inf
Upside Potential Ratio = inf
Calmar Ratio = 3.9804221209001316
Sterling Ratio = 73.39338628531124
Burke Ratio = 50.28169156965575