Python 快速迭代行并返回单元格满足阈值的列名

我有一个带有numic值的熊猫数据帧。如何迭代行并返回单元格值满足阈值的列名（在本例中为.05）

熊猫数据帧是10K行和700列。理想情况下，我想要一本字典，如下所示

MWE 顺从的 期望输出

---

这可以通过产品实现：

thresh = .05
df.ge(thresh).dot(df.columns+',').str.rstrip(",").str.split(",").to_dict()

---

使用：

输出：

{'Dog': ['A', 'E', 'F'], 
'Cat': ['A', 'D', 'E', 'F', 'G'], 
'Pig': ['B', 'C', 'D', 'E', 'G'], 
'Horse': ['A', 'B', 'C'], 
'Fish': ['A', 'E'], 
'Chicken': ['C', 'F', 'G'], 
'Squid': ['C', 'F'], 
'Cheetah': ['D', 'E', 'F', 'G']}

# @anky's answer
In [49]: %timeit df_bench.ge(thresh).dot(df_bench.columns+',').str.rstrip(",").s
    ...: tr.split(",").to_dict()                                                
1.36 s ± 50.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

# @My answer
In [50]: %%timeit 
    ...: m = df_bench.ge(0.05).values 
    ...: out = {k: df_bench.columns[m[i]].tolist() for i, k in enumerate(df_benc
    ...: h.index)} 
    ...:  
    ...:                                                                        
167 ms ± 3.27 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

# @Amit's answer
In [51]: %timeit df_bench.apply(lambda x: list(x[x>=0.05].index), axis = 1).to_d
    ...: ict()                                                                  

4.08 s ± 2.31 s per loop (mean ± std. dev. of 7 runs, 1 loop each)

---

您可以在这里使用dict理解和布尔索引

m = df.ge(0.05).values
out = {k: df.columns[m[i]].tolist() for i, k in enumerate(df.index)}

{'Dog': ['A', 'E', 'F'],
 'Cat': ['A', 'D', 'E', 'F', 'G'],
 'Pig': ['B', 'C', 'D', 'E', 'G'],
 'Horse': ['A', 'B', 'C'],
 'Fish': ['A', 'E'],
 'Chicken': ['C', 'F', 'G'],
 'Squid': ['C', 'F'],
 'Cheetah': ['D', 'E', 'F', 'G']}

时间结果： 基准测试设置

np.random.seed(0)
vals = np.random.rand(10_000, 700)
df_bench = pd.DataFrame(vals)
df_bench.columns = df_bench.columns.astype(str)

输出：

{'Dog': ['A', 'E', 'F'], 
'Cat': ['A', 'D', 'E', 'F', 'G'], 
'Pig': ['B', 'C', 'D', 'E', 'G'], 
'Horse': ['A', 'B', 'C'], 
'Fish': ['A', 'E'], 
'Chicken': ['C', 'F', 'G'], 
'Squid': ['C', 'F'], 
'Cheetah': ['D', 'E', 'F', 'G']}

# @anky's answer
In [49]: %timeit df_bench.ge(thresh).dot(df_bench.columns+',').str.rstrip(",").s
    ...: tr.split(",").to_dict()                                                
1.36 s ± 50.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

# @My answer
In [50]: %%timeit 
    ...: m = df_bench.ge(0.05).values 
    ...: out = {k: df_bench.columns[m[i]].tolist() for i, k in enumerate(df_benc
    ...: h.index)} 
    ...:  
    ...:                                                                        
167 ms ± 3.27 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

# @Amit's answer
In [51]: %timeit df_bench.apply(lambda x: list(x[x>=0.05].index), axis = 1).to_d
    ...: ict()                                                                  

4.08 s ± 2.31 s per loop (mean ± std. dev. of 7 runs, 1 loop each)

---

经过平等性测试，所有的解决方案都给出了相同的结果。

两个答案都很好。对于我的用例来说，这个更快+1@anky添加了timeit结果。我想这个解决方案的瓶颈是

.str

函数，我想它们没有矢量化。令我惊讶的是，简单的听写理解速度更快

.dot

的使用非常巧妙str是矢量化的，但由于string func很慢，并且是在str python之上构建的，所以它们只比vanilla慢。：）两个答案都很好。对于我的用例+1是，dot产品1更快。熊猫通常很慢。独一无二（：很好，很好！简单的听写理解效果更好。

.apply

通常很糟糕，我只是不想看到我的答案。@AmitVikramSingh虽然情况并非总是如此，但通常避免了轴1上的

df.apply

。

df.apply

轴0上的比轴1上的好。我想我的解决方案是快速的r，因为它只使用布尔索引，这是一个非常快速和简单的操作，

df.ge

是矢量化操作。@AmitVikramSingh简单地说，如果你的代码可读性和速度一样快。不在乎。优先级可读性，第二速度，如果它不致命you@anky完全同意。

m = df.ge(0.05).values
out = {k: df.columns[m[i]].tolist() for i, k in enumerate(df.index)}

{'Dog': ['A', 'E', 'F'],
 'Cat': ['A', 'D', 'E', 'F', 'G'],
 'Pig': ['B', 'C', 'D', 'E', 'G'],
 'Horse': ['A', 'B', 'C'],
 'Fish': ['A', 'E'],
 'Chicken': ['C', 'F', 'G'],
 'Squid': ['C', 'F'],
 'Cheetah': ['D', 'E', 'F', 'G']}

np.random.seed(0)
vals = np.random.rand(10_000, 700)
df_bench = pd.DataFrame(vals)
df_bench.columns = df_bench.columns.astype(str)

# @anky's answer
In [49]: %timeit df_bench.ge(thresh).dot(df_bench.columns+',').str.rstrip(",").s
    ...: tr.split(",").to_dict()                                                
1.36 s ± 50.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

# @My answer
In [50]: %%timeit 
    ...: m = df_bench.ge(0.05).values 
    ...: out = {k: df_bench.columns[m[i]].tolist() for i, k in enumerate(df_benc
    ...: h.index)} 
    ...:  
    ...:                                                                        
167 ms ± 3.27 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

# @Amit's answer
In [51]: %timeit df_bench.apply(lambda x: list(x[x>=0.05].index), axis = 1).to_d
    ...: ict()                                                                  

4.08 s ± 2.31 s per loop (mean ± std. dev. of 7 runs, 1 loop each)