python3：如何计算由3分组的10个因子每个因子有15个值的所有变化

如何解决python3：如何计算由3分组的10个因子每个因子有15个值的所有变化

请您帮我计算以3为一组的10个因子（每个因子有15个值）的所有变化。

我们有10个因素。 每个因子有15个值。例如。 1,2,3,4,5,6 ... 15

第三个三重因子（例如factor1，factor2，factor3）的所有可能组合为：

    XWPFHeaderFooterPolicy policy = document.getHeaderFooterPolicy();
    if (policy == null)
      policy = document.createHeaderFooterPolicy();

    XWPFHeaderFooter footer = policy.createFooter(XWPFHeaderFooterPolicy.DEFAULT);

    XWPFParagraph p = footer.createParagraph();
    p.createRun().setText("My First Footer");

    XWPFTable t = footer.createTable(1,3);
    XWPFTableRow r = t.getRow(0);
    r.createCell().setText("Uno");
    r.createCell().setText("Dos");
    r.createCell().setText("Tres");

应针对10个因素中的所有可能的三胞胎进行计算：

15 (factor1 combination values) x 15 (factor2 combination values) x 15 (factor3 combination values) = 3 375

因此，我们有3个因子的59 049个组合x其值的3 375个组合= 1.99亿条记录

理想的输出：

    3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 = 59 049 possible combinations of 3 factors
 (except duplicates like factor1,factor1,factor2)

感谢您每次提示如何达到目标。

解决方法

问题的关键：“重复项除外”组合的数量is simply a binomial coefficient，并且实例可以由itertools.product()或pandas.MultiIndex.from_product()（{{3 }}）。

因此，（因数1，因数2，因数3）的确切数目为binom(10,3) =120，而不是3**10=59,049。因此，总行数为120*3375=405,000。

解决方案：

我将所有数字参数化只是为了使数学逻辑清晰。此外，通过相应地重新计算comb_facs，此解决方案可以应用于变化数量的值。

import pandas as pd
import numpy as np
import itertools
from scipy.special import comb

# data and parameters
n_cols = 10
k_cols = 3  # binomial coeff. (n k)
n_vals = 15  # 15 vals
dic = {}
for i in range(1,n_cols+1):
    dic[f"f{i}"] = np.array([j for j in range(1,1+n_vals)],dtype=object)
df = pd.DataFrame(dic)

# preallocate the output arrays: factors and values
comb_cols = comb(n_cols,k_cols)  # binom(10,3) = 120
comb_facs = int(n_vals ** k_cols)  # NOTE: must recalculate if number of values are not constant
total_len = int(comb_cols * comb_facs)
factors = np.zeros((total_len,k_cols),dtype=object)
values = np.zeros((total_len,dtype=int)

# the actual iteration
for i,tup in enumerate(itertools.combinations(df.columns,k_cols)):

    # 1. Cartesian product of (facA,facB,facC).
    #    can also use list(itertools.product())
    vals = pd.MultiIndex.from_product(
        [df[tup[i]].values for i in range(k_cols)]  # df.f1,df.f2,df.f3
    )
    arr_vals = pd.DataFrame(index=vals).reset_index().values
    # 2. Populate factor names and values into output arrays
    factors[i * comb_facs:(i + 1) * comb_facs,:] = tup  # broadcasting
    values[i * comb_facs:(i + 1) * comb_facs,:] = arr_vals

# result
pd.concat([pd.DataFrame(factors,columns=["1p fac","2p fac","3p fac"]),pd.DataFrame(values,columns=["1p val","2p val","3p val"])],axis=1)

Out[41]: 
       1p fac 2p fac 3p fac  1p val  2p val  3p val
0          f1     f2     f3       1       1       1
1          f1     f2     f3       1       1       2
2          f1     f2     f3       1       1       3
3          f1     f2     f3       1       1       4
4          f1     f2     f3       1       1       5
       ...    ...    ...     ...     ...     ...
404995     f8     f9    f10      15      15      11
404996     f8     f9    f10      15      15      12
404997     f8     f9    f10      15      15      13
404998     f8     f9    f10      15      15      14
404999     f8     f9    f10      15      15      15
[405000 rows x 6 columns]