Ishigami's questions

我有一个熊猫数据框，看起来像

data = {
'Date': ['2024-07-14','2024-07-14','2024-07-14','2024-07-14','2024-07-14','2024-03-14','2024-03-14','2024-03-14','2024-02-14','2024-02-10','2024-02-10','2024-02-10','2024-04-13','2024-04-13','2023-02-11','2023-02-11','2023-02-11','2011-10-11','2011-05-02','2011-05-02'],
'Test_Number': [5,4,3,2,1,3,2,1,4,3,2,1,2,1,3,2,1,1,2,1],
'Student_ID': [2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1],
'Place': [3,5,7,3,1,9,6,3,7,8,2,1,3,4,2,1,5,6,2,7]
}
df = pd.DataFrame(data)

我想使用以下方法创建三个新列“student_rec_1”、“student_rec_2”、“student_rec_3”：

对于每个 Student_ID，student_rec_1 等于该学生在最近的最后一次考试中的成绩，如果不存在则等于 np.nan。

类似地，student_rec_2 等于该学生在最近一次日期的倒数第二次考试中的成绩，如果不存在则等于 np.nan，

student_rec_3 等于该学生在最近日期的倒数第三次考试中的排名，如果不存在则等于 np.nan。因此，期望的结果如下

data_new = {
'Date': ['2024-07-14','2024-07-14','2024-07-14','2024-07-14','2024-07-14','2024-03-14','2024-03-14','2024-03-14','2024-02-14','2024-02-10','2024-02-10','2024-02-10','2024-04-13','2024-04-13','2023-02-11','2023-02-11','2023-02-11','2011-10-11','2011-05-02','2011-05-02'],
'Test_Number': [5,4,3,2,1,3,2,1,4,3,2,1,2,1,3,2,1,1,2,1],
'Student_ID': [2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1],
'Place': [3,5,7,3,1,9,6,3,7,8,2,1,3,4,2,1,5,6,2,7],
'student_rec_1': [9,9,9,9,9,7,7,7,8,np.nan,np.nan,np.nan,2,2,6,6,6,2,np.nan,np.nan],
'student_rec_2': [6,6,6,6,6,8,8,8,2,np.nan,np.nan,np.nan,1,1,2,2,2,7,np.nan,np.nan],
'student_rec_3': [3,3,3,3,3,2,2,2,1,np.nan,np.nan,np.nan,5,5,7,7,7,np.nan,np.nan,np.nan]
}
df_new = pd.DataFrame(data_new)

这就是我尝试过的：

df['日期'] = pd.to_datetime(df['日期'])

df = df.sort_values(['日期', '测试编号'], 升序=[False, False])

def get_last_n_records(group，n):返回group['Place'].shift(-n)

df['student_rec_1'] = df.groupby('学生ID').apply(get_last_n_records, 1).reset_index(level=0, drop=True) df['student_rec_2'] = df.groupby('学生ID').apply(get_last_n_records, 2).reset_index(level=0, drop=True) df['student_rec_3'] = df.groupby('学生ID').apply(get_last_n_records, 3).reset_index(level=0, drop=True)

但它只是改变了每个学生的位置，并没有考虑到“最后一天”的因素，而且无论如何都会改变位置。

我有一个如下数据框：

ID   f_1   f_2   f_3
1    1     0     1
2    0     1     1
3    1     1     0
4    1     0     1
5    0     1     1   

我完全不知道如何开始。而且我的原始数据框相当大（约 1M 行），因此非常希望有一种快速的方法。

我想生成一个新列Result，记录f其中包含 1 的一对，即

ID   f_1   f_2   f_3   Result
1    1     0     1     1_3
2    0     1     1     2_3
3    1     1     0     1_2
4    1     0     1     1_3
5    0     1     1     2_3

我有一个 Pandas 数据框，用于记录不同班级学生的考试表现，它如下所示：

Class_ID   Class_size   Student_Number   IQ   Hours   Score   Place
1          3            1                101  10      98      1
1          3            2                99   19      80      3
1          3            3                130  3       95      2
2          5            1                93   5       50      5
2          5            2                103  9       88      3
2          5            3                112  12      99      2
2          5            4                200  10      100     1
2          5            5                90   19      78      4
3          2            1                100  12      84      2
3          2            2                102  13      88      1

我想使用Student_Numberascolumns和Class_ID, Class_sizeas将上述长格式转换为宽格式index，最后一列Top是该班第一名的学生，因此期望的结果如下：

Class_ID Class_size IQ_1 IQ_2 IQ_3 IQ_4 IQ_5 Hours_1 Hours_2 Hours_3 Hours_4 Hours_5 Score_1 Score_2 Score_3 Score_4 Score_5 Top
1        1          101  99   130  NaN  NaN  10      19      3       NaN     NaN     98      80      95      NaN     NaN     1
2        5          93   103  112  200  90   5       9       12      10      19      50      88      99      100     78      4
3        2          100  102  NaN  NaN  NaN  12      13      NaN     NaN     NaN     84      88      NaN     NaN     NaN     2

以下是我尝试过的：

out = df.pivot_table(index=['Class_ID', 'Class_size'],
                     columns='Student_Number',
                     values=['IQ', 'Hours', 'Score'])
out.columns = [f'{x}_{y}' for x,y in out.columns]
out_dummy = out.reset_index()
df_wide = out_dummy

但是，我不知道如何创建最后一列Top。此外，上面的代码似乎相当慢，而且由于我的原始数据框非常大（约 300,000 行），我想问一下有没有更快的方法可以做到这一点。提前谢谢您。

我有一个如下所示的 Pandas DataFrame：

ID  result
1   [.1,.5]
2   [.4,-.2,-.3,.1,0]
3   [0,.1,.6]

如何将这一列列表分成两列？

期望结果：

ID  result_1 result_2 result_3 result_4 result_5
1   .1       .5       NaN      NaN      NaN
2   .4       -.2      -.3      .1       0
3   0        .1       .6       NaN      NaN

我深入研究了一下，发现了这一点：将 Pandas 列表列拆分为多列

但这似乎只适用于具有恒定数量元素的列表。

提前致谢。

我有一个 Pandas 数据框，看起来像

df = pd.DataFrame([['John', 'A', '1/1/2017', '10'],
                   ['John', 'A', '2/2/2017', '15'],
                   ['John', 'A', '2/2/2017', '20'],
                   ['John', 'A', '3/3/2017', '30'],
                   ['Sue', 'B', '1/1/2017', '10'],
                   ['Sue', 'B', '2/2/2017', '15'],
                   ['Sue', 'B', '3/2/2017', '20'],
                   ['Sue', 'B', '3/3/2017', '7'],
                   ['Sue', 'B', '4/4/2017', '20']],
                  columns=['Customer', 'Group', 'Deposit_Date', 'DPD'])

我想创建一个名为 的新行PreviousMean。此列是该客户今年迄今为止的 DPD 平均值。即包括所有 DPD，但不包括与当前存款日期匹配的行。如果不存在以前的记录，则为空或 0。

因此期望的结果如下

  Customer  Group  Deposit_Date  DPD  PreviousMean
0     John      A    2017-01-01   10           NaN
1     John      A    2017-02-02   15          10.0
2     John      A    2017-02-02   20          10.0
3     John      A    2017-03-03   30          15.0
4      Sue      B    2017-01-01   10           NaN
5      Sue      B    2017-02-02   15          10.0
6      Sue      B    2017-03-02   20          12.5
7      Sue      B    2017-03-03    7          15.0
8      Sue      B    2017-04-04   20          13.0

在网站和互联网上进行一些研究后，找到了一个解决方案：

df['PreviousMean'] = df.apply(
    lambda x: df[(df.Customer == x.Customer) & 
                 (df.Group == x.Group) & 
                 (df.Deposit_Date < x.Deposit_Date)].DPD.mean(), 
axis=1)

并且运行良好。但是，我的实际数据框要大得多（约 100 万行），上面的代码运行非常慢。

我之前问过类似的问题：Pandas groupby transform mean with date before current row for huge huge dataframe

但这次 groupby 是在两列上进行的，因此解决方案不起作用，我没能尝试将其推广。有没有更好的方法？谢谢

我有一个 Pandas 数据框，看起来像

df = pd.DataFrame([['John', '1/1/2017','10'],
                   ['John', '2/2/2017','15'],
                   ['John', '2/2/2017','20'],
                   ['John', '3/3/2017','30'],
                   ['Sue', '1/1/2017','10'],
                   ['Sue', '2/2/2017','15'],
                   ['Sue', '3/2/2017','20'],
                   ['Sue', '3/3/2017','7'],
                   ['Sue', '4/4/2017','20']],
                   columns=['Customer', 'Deposit_Date','DPD'])

我想创建一个名为 的新行PreviousMean。此列是该客户今年迄今为止的 DPD 平均值。即包括所有 DPD，但不包括与当前存款日期匹配的行。如果不存在以前的记录，则为空或 0。

因此期望的结果如下

  Customer Deposit_Date  DPD  PreviousMean
0     John   2017-01-01   10           NaN
1     John   2017-02-02   15          10.0
2     John   2017-02-02   20          10.0
3     John   2017-03-03   30          15.0
4      Sue   2017-01-01   10           NaN
5      Sue   2017-02-02   15          10.0
6      Sue   2017-03-02   20          12.5
7      Sue   2017-03-03    7          15.0
8      Sue   2017-04-04   20          13.0

在网站和互联网上进行一些研究后，找到了一个解决方案：

df['PreviousMean'] = df.apply(
    lambda x: df[(df.Customer == x.Customer) & (df.Deposit_Date < x.Deposit_Date)].DPD.mean(), 
axis=1)

并且运行良好。但是，我的实际数据帧要大得多（约 100 万行），上面的代码运行非常慢。有没有更好的方法？谢谢

我有一个以 NumPy 数组为元素的列表，如下所示：

[array([ 0.2, -2.3,  5.3]),
 array([-1.6, -1.7,  0.3]),
 array([ 2.4, -0.2, -3.0]),
 array([-4.1, -2.3, -2.7])]

我想将其转换为 3 个列表，每个列表包含来自上述列表列的元素。因此，期望的结果如下

list1 = [0.2, -1.6, 2.4, -4.1]
list2 = [-2.3, -1.7, -0.2, -2.3]
list3 = [5.3, 0.3, -3.0, -2.7]

我不确定这是否更适合数学 stackexchange 或 stack overflow，但由于数学证明对我来说看起来没问题，我怀疑问题出在代码上，因此我将它发布在这里：

第一个公式（公式 1）根据定义是直接的：

下面是我针对公式 1 编写的代码：

import scipy.integrate as integrate
from scipy.integrate import nquad
from scipy.stats import norm
import math

def normalcdf(x):
    return (1+math.erf(x/math.sqrt(2)))/2

def normalpdf(x): 
    return math.exp(-x*x/2)/math.sqrt(2*math.pi)

def integrand12345(x1,x2,x3,x4,x5,theta1,theta2,theta3,theta4,theta5):
  return normalpdf(x1 - theta1) * normalpdf(x2 - theta2) * normalpdf(x3 - theta3) * normalpdf(x4 - theta4) * normalpdf(x5 - theta5)

def range_x1(theta1,theta2,theta3,theta4,theta5):
  return [-np.inf, np.inf]

def range_x2(x1,theta1,theta2,theta3,theta4,theta5):
  return [x1, np.inf]

def range_x3(x2,x1,theta1,theta2,theta3,theta4,theta5):
  return [x2, np.inf] 

def range_x4(x3,x2,x1,theta1,theta2,theta3,theta4,theta5):
  return [x3, np.inf] 

def range_x5(x4,x3,x2,x1,theta1,theta2,theta3,theta4,theta5):
  return [x4, np.inf]

def pi_12345(theta1,theta2,theta3,theta4,theta5):
  return (nquad(integrand12345, [range_x5, range_x4, range_x3, range_x2, range_x1], args=(theta1,theta2,theta3,theta4,theta5)))[0]

第二个公式（公式 2）使用双重积分： 这是公式 2 的代码：

def integrandforpi_12(x1, x2, t1, t2, *theta): 
  prod = 1
  for ti in theta:
    prod = prod * (1 - normalcdf(x2 - ti))
  return prod * normalpdf(x1 - t1) * normalpdf(x2 - t2)

def range_x1(t1, t2, *theta):
  return [-np.inf, np.inf]

def range_x2(x1, t1, t2, *theta):
  return [x1, np.inf]

def pi_12(t1, t2, *theta):
  return (nquad(integrandforpi_12, [range_x2, range_x1], args=(t1, t2, *theta)))[0]

我的第三个公式（公式 3）基于贝叶斯定理：

我对公式 3 的代码是：

def integrandforpi_i(xi, ti, *theta):
  prod = 1
  for t in theta:
    prod = prod * (1 - normalcdf(xi - t))
  return prod * normalpdf(xi - ti)

def pi_i(ti, *theta):
  return integrate.quad(integrandforpi_i, -np.inf, np.inf, args=(ti, *theta))[0]

因此 pi_i 计算 X_i 在 theta_i 中最小的概率。

但是，当我使用 3 个不同的公式运行我的代码时，它们都给出了不同的答案，我不知道为什么。我不确定我的公式推导是否存在缺陷，或者我的代码是否存在错误。任何帮助都将不胜感激。

以下是一个例子：

t1,t2,t3,t4,t5 = 0.83720022,0.61704171,1.21121701,0,1.52334078

p12345 = pi_12345(t1,t2,t3,t4,t5)
p12354 = pi_12345(t1,t2,t3,t5,t4)
p12435 = pi_12345(t1,t2,t4,t3,t5)
p12453 = pi_12345(t1,t2,t4,t5,t3)
p12534 = pi_12345(t1,t2,t5,t3,t4)
p12543 = pi_12345(t1,t2,t5,t4,t3)

print('p12345=',p12345)
print('p12354=',p12354)
print('p12435=',p12435)
print('p12453=',p12453)
print('p12534=',p12534)
print('p12543=',p12543)

print('formula 1 gives', p12345+p12354+p12435+p12453+p12534+p12543)

print('formula 2 gives', pi_12(t1,t2,t3,t4,t5))

print('formula 3 gives', pi_i(t2,t3,t4,t5) * pi_i(t1,t2,t3,t4,t5))

输出为

p12345= 0.0027679276698449086
p12354= 0.008209750140618218
p12435= 0.0016182955786153714
p12453= 0.001921206801273682
p12534= 0.009675713474375739
p12543= 0.003904872716765966
formula 1 gives 0.028097766381493885
formula 2 gives 0.21897431741874426
formula 3 gives 0.0418669679120933

备注：公式 1 非常慢，在我那台破旧的笔记本电脑上运行大约需要 3 个小时。公式 2 和 3 是即时的。

我有一个 pandas 数据框，看起来像

Race_ID   Date           Student_ID      Rank  
1         1/1/2023       1               100-20     
1         1/1/2023       2               40-10       
2         11/9/2022      3               100-5     
3         17/4/2022      5               100-0     
3         17/4/2022      2               4-0     
4         1/3/2022       1               10-5        

其中 的数据类型Rank是字符串。我想提取数字并对Rank它们求和，所以期望的结果如下：

Race_ID   Date           Student_ID      Rank      New_column
1         1/1/2023       1               100-20    80 
1         1/1/2023       2               40-10     30  
2         11/9/2022      3               100-5     95
3         17/4/2022      5               100-0     100
3         17/4/2022      2               4-0       4
4         1/3/2022       1               10-5      5 

我有一个 Pandas 数据框，看起来像

Race_ID   Date           Student_ID      Rank  
1         1/1/2023       1               3     
1         1/1/2023       2               8     
1         1/1/2023       3               0     
1         1/1/2023       4               4     
2         11/9/2022      1               2     
2         11/9/2022      2               3     
2         11/9/2022      3               9     
3         17/4/2022      5               0     
3         17/4/2022      2               1     
3         17/4/2022      3               2     
3         17/4/2022      4               5     
4         1/3/2022       1               6     
4         1/3/2022       2               2     
5         1/1/2021       1               0     
5         1/1/2021       2               3     
5         1/1/2021       3               1     

我想添加一个新列，它是groupby大于 0min>0的最小值，所以期望的结果看起来像RankRace_ID

Race_ID   Date           Student_ID      Rank  min>0  
1         1/1/2023       1               3     3
1         1/1/2023       2               8     3
1         1/1/2023       3               0     3
1         1/1/2023       4               4     3
2         11/9/2022      1               2     2
2         11/9/2022      2               3     2
2         11/9/2022      3               9     2
3         17/4/2022      5               0     1
3         17/4/2022      2               1     1
3         17/4/2022      3               2     1
3         17/4/2022      4               5     1
4         1/3/2022       1               6     2
4         1/3/2022       2               2     2
5         1/1/2021       1               0     1
5         1/1/2021       2               3     1
5         1/1/2021       3               1     1

我知道groupby，transform('min')但我不知道如何包含条件 >0。

我有一个来自wiki 的panads 数据框

Outlook  Temperature    Humidity    Wind    Play
Sunny    Hot            High        False   No
Sunny    Hot            High        True    No
Overcast Hot            High        False   Yes
Rainy    Mild           High        False   Yes
Rainy    Cool           Normal      False   Yes
Rainy    Cool           Normal      True    No
Overcast Cool           Normal      True    Yes
Sunny    Mild           High        False   No
Sunny    Cool           Normal      False   Yes
Rainy    Mild           Normal      False   Yes
Sunny    Mild           Normal      False   Yes
Overcast Mild           High        True    Yes
Overcast Hot            Normal      False   Yes
Rainy    Mild           High        True    No

我想看看是否是outlook/ sunny/ overcast，rainy他们要玩多少次，然后计算每个结果的香农熵，所以期望的结果看起来像

Outlook     Yes No  Count of each group Entropy
sunny       2   3   5                   0.971
overcast    4   0   4                   0.000
rainy       3   2   5                   0.971

其中Entropy由公式给出 -((yes/count)log_2(yes/count) + (no/count)log_2(no/count))

例如，熵为sunny-((2/5)log_2(2/5)+(3/5)log_2(3/5))=0.971

我有一个数据框df，如下所示：

Race_ID   Date           Student_ID      Rank  Student_Name 
1         1/1/2023       1               3     Ryan
1         1/1/2023       NaN             2     Mary
1         1/1/2023       3               1     Tony
1         1/1/2023       4               4     Chris
2         11/9/2022      1               2     Ryan
2         11/9/2022      NaN             3     Mary
2         11/9/2022      3               1     Tony
3         17/4/2022      5               4     Josh
3         17/4/2022      NaN             1     Mary
3         17/4/2022      3               2     Tony
3         17/4/2022      4               3     Chris
4         1/3/2022       1               1     Ryan
4         1/3/2022       NaN             2     Mary
5         1/1/2021       1               2     Ryan
5         1/1/2021       NaN             3     Mary
5         1/1/2021       3               1     Tony

Mary 的 Student_ID 丢失。不过我有另一个数据框studentList，看起来像

Studnet_ID   Student_Name
1            Ryan
2            Mary
3            Tony
4            Chris
5            Josh
6            David
7            Evan

我想用它来填写NaN中Student_ID的列df。有什么快速的方法可以做到吗？谢谢。