Numpy 对几乎相同的代码给出不同的结果？

Question

def match_score(vendor, company):
return max(fuzz.ratio(vendor, company), fuzz.partial_ratio(vendor, company), fuzz.token_sort_ratio(vendor, company))

注：fuzz来自导入fuzzywuzzy库

========================

vendor = 'RED DEER TELUS STORE'

当我尝试这段代码时：

df['Vendor']=vendor
df['Score'] = np.array(match_score(tuple(df['Vendor']), tuple(df['Company'])))

我明白了

然而，当我尝试几乎相同的代码时，我得到了不同的 'Score'?

df['Score'] = np.array(match_score(vendor, tuple(df['Company'])))

我在 #2 中的逻辑是供应商在整个列中都是相同的，因此无需将其放入元组中。我可以将其作为字符串提供并加快处理速度。

谁能解释为什么传递每个单元格中的 vendor = 'RED DEER TELUS STORE' 的整个列会产生与仅将 'RED DEER TELUS STORE' 作为字符串传递给函数不同的结果？谢谢！

Answer 1

tuple 对比 tolist:

In [166]: x=np.arange(10000)                                                    
In [167]: timeit tuple(x)                                                       
1.14 ms ± 26.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
In [168]: timeit list(x)                                                        
1.12 ms ± 2.01 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
In [169]: timeit x.tolist()                                                     
296 µs ± 9.98 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

或系列

In [170]: ds = pd.Series(x)                                                     
In [171]: timeit tuple(ds)                                                      
1.22 ms ± 1.57 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
In [172]: timeit list(ds)                                                       
1.23 ms ± 1.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
In [173]: timeit ds.to_list()                                                   
394 µs ± 22.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

具有一系列字符串值（对象数据类型）：

In [184]: ds = pd.Series(['' for _ in range(1000)])                             
In [185]: ds[:] = vendor                                                        
In [186]: timeit tuple(ds)                                                      
104 µs ± 1.11 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
In [187]: timeit ds.to_list()                                                   
27.2 µs ± 179 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

至于为什么传递 Series/tuple 与传递字符串之间存在差异，我认为您需要更详细地检查 fuzz code/docs。甚至可以用小例子测试函数。我没有安装 fuzz，所以无法探索你的那部分计算。

您甚至可能想要组成一些字符串列表（或元组），并用它们进行试验。我认为这不是 numpy/pandas 问题。这是学习正确使用 fuzz 的问题。

Numpy 对几乎相同的代码给出不同的结果？

Numpy gives different results for almost identical code?

python

numpy

pandas

fuzzywuzzy