Python Pandas Fisher Exact Test 2x2

I have a pandas dataframe with four columns:

import pandas as pd
import numpy as np

arr = {
       "A" :[75.3,85.2,90.1,80.4,70.9],
       "B" :[80.6,90.2,85.7,70.8,95.1],
       "C" :[85.2,95.6,80.8,90.4,75.1],
       "D" :[90.3,85.5,80.0,70.5,95.2]
              }

df = pd.DataFrame(arr)

I want to run the 2x2 fisher exact test on every row and save the p value on a new column. In other words, I want to run the 2x2 fisher exact test on the array below

pvalue = [[df["A"][i], df["B"][i]], [df["C"][i], df["D"][i]]]

for all i between 0 and 5, and save the list as another column in the dataframe.

There is a function in "scipy.stats" called "fisher_exact()" which will output the odd value and p value of the 2x2 array. I have the following code right now which works:

import scipy.stats as stats
pvalue = []

for i in df.index.values:
    a = df["A"][i]
    b = df["B"][i]
    c = df["C"][i]
    d = df["D"][i]
    
    data = [[a,b],[c,d]]
    
    odd_value, p_value = stats.fisher_exact(data)
    pvalue.append(p_value)
    
df["p_value"] = np.array(pvalue)

However, for larger arrays, this takes a while. Is there a way to run this test using numpy vector operations? Is there a better function than scipy.stats.fisher_exact() to use here?

from scipy.stats import fisher_exact
import numpy as np

np.array([fisher_exact(i)[1] for i in df.values.reshape(-1,2,2)])

array([1.        , 0.45814062, 0.82723738, 0.6484196 , 0.82550328])

You could also run:

np.apply_along_axis(lambda x:fisher_exact(x.reshape(-1,2)), 1, df.values) 
array([[0.99264706, 1.        ],
       [0.84502924, 0.45814062],
       [1.05882353, 0.82723738],
       [0.88888889, 0.6484196 ],
       [0.93333333, 0.82550328]])

Where the second column ie [:, 1] is the p_values and the first column is the odd ratios

Another option that you could use is the fast-fisher library.

When running fast_fisher_exact_compatibility instead of fisher_exact, we can yield the following:

import pandas as pd
import numpy as np
from fast_fisher import fast_fisher_exact_compatibility

>>> arr = {
>>>        "A" :[75.3,85.2,90.1,80.4,70.9],
>>>        "B" :[80.6,90.2,85.7,70.8,95.1],
>>>        "C" :[85.2,95.6,80.8,90.4,75.1],
>>>        "D" :[90.3,85.5,80.0,70.5,95.2]
>>>               }

>>> df = pd.DataFrame(arr)

>>> for i in df.index.values:
>>>     a = df["A"][i]
>>>     b = df["B"][i]
>>>     c = df["C"][i]
>>>     d = df["D"][i]
    
>>>     data = [[a,b],[c,d]]
>>>     odds_f, pval_f = fast_fisher_exact_compatibility(data)

>>> pval_f
0.825503275434932

You could use this as a starting point and see whether performance improves when running on larger arrays.