对于循环，有些符号存在，但有些符号不存在

Question

我遇到了一个新手的棘手问题

我有一些数据（pettm等级20、roa等级20、roe等级20、npttm等级20、mkt等级20和定位符号）：

pettm_rank_20   
         signal
002610.CS   -1
000002.CS   1

roa_rank_20
        signal
603719.CS   -1
000001.CS   1

roe_rank_20
        signal
300751.CS   -1
002610.CS   1

npttm_rank_20
        signal
300751.CS   -1
002610.CS   1

mkt_rank_20
        signal
000001.CS   -1
002610.CS   1

located_symbols
['000001.CS', '000002.CS', '300724.CS', '300751.CS', '002610.CS', '603719.CS']

问题是在pettm_秩_20中，只有两项定位的_符号

for symbol in located_symbols:
    alphaReturn = {}
    alphaReturns = 5 + (pettm_rank_20.loc[symbol]*2.5 + roa_rank_20.loc[symbol]*3 + 
                                roe_rank_20.loc[symbol]*1.1 +
                                npttm_rank_20.loc[symbol]*1.7 +
                                mkt_rank_20[symbol]*3.3)
    alphaReturn[symbol] = alphaReturns

错误显而易见：

KeyError: 'the label [000001.CS] is not in the [index]'

我如何解决这个逻辑问题，对不起，我的编程能力不好，我想其他人可能也有同样的问题，所以我把它贴在这里，如果可能需要的话

根据Ieo，我创建了大型dic：

total
         signal_mkt signal_npttm signal_pettm signal_roa signal_roe
002610.CS       NaN       NaN            -1.0        NaN        NaN
000002.CS   NaN NaN 1.0  NaN                                    NaN
603719.CS   NaN NaN NaN -1.0    NaN
000001.CS   NaN NaN NaN 1.0 NaN
300751.CS   NaN NaN NaN NaN -1.0
002610.CS   NaN NaN NaN NaN 1.0
300751.CS   NaN -1.0    NaN NaN NaN
002610.CS   NaN 1.0 NaN NaN NaN
000001.CS   -1.0    NaN NaN NaN NaN
002610.CS   1.0 NaN NaN NaN NaN

问题是：

total['signal_mkt']['000001.CS']
000001.CS    NaN
000001.CS   -1.0
Name: signal_mkt, dtype: float64

我只需要-1而不是NaN，有办法解决吗？我想其他人可能也有同样的问题，想找到一个优雅的方式吗

我的方式有点傻：

total['signal_mkt']['000001.CS'][total['signal_mkt']['000001.CS'].notna()]
000001.CS   -1.0
Name: signal_mkt, dtype: float64

Answer 1

您应该学习python中的词典。您在编辑中添加的不是词典，而是表格。字典是键值对的集合。你给我一把钥匙，然后告诉我这把钥匙的值

您的定位符号数组应作为字典的键

symbol_dict = {
        "002610.CS": -1
        "000002.CS": 1
        "603719.CS": -1
        "000001.CS": 1
        "300751.CS": -1
        "002610.CS": 1
        "300751.CS": -1
        "002610.CS": 1
        "000001.CS": -1
        "002610.CS": 1
}

然后，当您想要访问特定符号（例如002610.CS）的值时，您可以-symbol_dict['002610.CS']。如果字典中不存在密钥，则返回密钥错误

如果不确定字典中是否存在键，可以通过以下方式访问字典-symbol_dict.get('non_existent_key', 'default_value') 这不会返回错误。如果字典中不存在键，它将返回默认值

located_symbols = ['000001.CS', '000002.CS', '300724.CS', '300751.CS', '002610.CS', '603719.CS']

factor_dict = {
        "002610.CS": 2.5
        "000002.CS": 2.5
        "603719.CS": 3
        "000001.CS": 3
        "300751.CS": 1.1
        "002610.CS": 1.1
        "300751.CS": 1.7
        "002610.CS": 1.7
        "000001.CS": 3.3
        "002610.CS": 3.3
}

for each in located_symbols:
    alphaReturn = {}
    alphaReturns = 5 + symbol_dict.get(each, 0) * factor_dict.get(each, 0) # usong 0 as default
    alphaReturn[each] = alphaReturns

我不确定我所做的计算是否符合你的要求。但显示了使用可能存在或不存在的键访问字典的方法

如果您使用pandas（假设您在问题中给出了很多表），pandas本身就有一种将表转换为字典的方法

您还可以像这样创建嵌套字典-

symbol_dict = {
        "002610.CS": {
         "value": -1,
         "factor": 2.5
         },
        "000002.CS": {
         "value": 1,
         "factor": 2.5
        }
        "603719.CS": {
         "value": -1,
         "factor": 3
        }
        "000001.CS": {
         "value": 1,
         "factor": 3
        }
        "300751.CS": {
         "value": -1,
         "factor": 1.1
        }
        "002610.CS": {
         "value": 1,
         "factor": 1.1
        }
        "300751.CS": {
         "value": -1,
         "factor": 1.7
        }
        "002610.CS": {
         "value": 1,
         "factor": 1.7
        }
        "000001.CS": {
         "value": -1,
         "factor": 3.3
        }
        "002610.CS": {
         "value": 1,
         "factor": 3.3
        }
}

然后，您的代码变为-

for each in located_symbols:
    alphaReturn = {}
    if each in symbol_dict.keys():  # Check if key exists in dictionary else do nothing
      alphaReturns = 5 + symbol_dict[each]['value'] * symbol_dict[each]['factor']
      alphaReturn[each] = alphaReturns

Answer 2

for symbol in located_symbols:
    try:
        a = a[symbol].loc['signal_pettm'][a[symbol].loc['signal_pettm'].notna()].values.item()
    except:
        a = 0
    try:
        b = a[symbol].loc['signal_roe'][a[symbol].loc['signal_roe'].notna()].values.item()
    except:
        b = 0
    try:
        c = a[symbol].loc['signal_roa'][a[symbol].loc['signal_roa'].notna()].values.item()
    except:
        c = 0
    try:
        d = a[symbol].loc['signal_npttm'][a[symbol].loc['signal_npttm'].notna()].values.item()
    except:
        d = 0
    try:
        e = a[symbol].loc['signal_mkt'][a[symbol].loc['signal_mkt'].notna()].values.item()
    except:
        e = 0
    
    alphaReturns = intercept+a*coe_list[0]+b*coe_list[1]+c*coe_list[2]+d*coe_list[3]+e*coe_list[4]
    alphaReturn[symbol] = (alphaReturns)```
my solution to this is too urgly, as using too many try and except, but this is only way I figured out...