Python 如何将一列中的每个单元格与列中的特定值进行比较？

我有一个这样的数据帧，我想实现这一点：

如果A的符号与B的符号相同，则获得一个新的列C=min（3，| A |）； 如果A的符号与B的符号不同，C=min（3，B）； 如果A和B的值为零，C=A

Type subType  A       B     C     
 X    a       -1      4     3   
 X    a       5       9     3
 X    a       5       9     3
 X    b       1       4     1   
 X    b       3       5    ...
 X    b       5       0
 Y    a       -1      1         
 Y    a       3       2  
 Y    a       -5      3
 Y    b       1       4        
 Y    b       3       5 
 Y    b       5      -2

我试过：

if df["A"] * df["B"] > 0:
    df["C"] = (3, abs(df["A"]).min(axis=1)

它给了我一个错误，似乎我无法直接将值“3”与列进行比较，有什么建议吗

跟进：如果公式更复杂，比如

C=A+min（3，| A |）*B

？

df['C']=[min（abs（A），3）如果A*B>0 else min（B，3）如果A*B<0 else A，B在zip中（df.A，df.B）]
df['C'] = [min(abs(a), 3) if a*b > 0 else min(b, 3) if a*b < 0 else a for a,b in zip(df.A, df.B)]

因为如果A和B的值为零，则意味着使用最小值（3，abs（0））始终

0

解决方案应简化为和：

编辑：如果需要pandas/numpy中的更多条件，可以使用多个

np。其中
函数：

您可以尝试以下方法：

df[“C”]=np.其中（df[“A”]*df[“B”]>0，min（3，abs（df[“A”]）.min（），
np.where（df[“A”]*df[“B”]你能发布你的预期输出数据帧吗？嗨，谢谢你的回答，只是一个后续问题，如果公式是
C=A+min（3，| A |）*B
而不是最小值本身呢？我怀疑我不能再使用
np.where
了吗？有什么想法吗？@Cecilia-没问题，只需更改
np.minimum（3，df.A.abs（））
to
df.A+np.minimum（3，df.A.abs（））*df.B
谢谢，只是想知道if语句是否会变成类似于
if-sign（A）=sign（B），D=A+min（3，| A |）*B；if-sign（A）=sign（C），D=C+min（3，| A |）*B，else:D=A
类似这样的东西，我还能用
np where（）
？很抱歉，如果我有太多的后续问题，只是想进一步了解这个函数，如果您能给我一些提示，那就太好了：）@Cecilia-以秒为单位给我，但需要在这里
#compare signs
m = np.sign(df["A"]) == np.sign(df["B"])
#alternative
#m = (df["A"] * df["B"]) >= 0
df['C'] = np.where(m, np.minimum(3, df.A.abs()), np.minimum(3, df.B))
print (df)
   Type subType  A  B  C
0     X       a -1  4  3
1     X       a  5  9  3
2     X       a  5  9  3
3     X       b  1  4  1
4     X       b  3  5  3
5     X       b  5  0  0
6     Y       a -1  1  1
7     Y       a  3  2  3
8     Y       a -5  3  3
9     Y       b  1  4  1
10    Y       b  3  5  3
11    Y       b  5 -2 -2

m1 = np.sign(df.A) == np.sign(df.B)
m2 = np.sign(df.A) == np.sign(df.C)

s1 = df.A + np.minimum(3, df.A.abs()) * df.B
s2 = df.C + np.minimum(3, df.A.abs()) * df.B

df['D'] = np.select([m1, m2], [s1, s2], default=df.A)
print (df)
   Type subType  A  B  C   D
0     X       a -1  4  3  -1
1     X       a  5  9  3  32
2     X       a  5  9  3  32
3     X       b  1  4  1   5
4     X       b  3  5  3  18
5     X       b  5  0  0   5
6     Y       a -1  1  1  -1
7     Y       a  3  2  3   9
8     Y       a -5  3  3  -5
9     Y       b  1  4  1   5
10    Y       b  3  5  3  18
11    Y       b  5 -2 -2   5

df['C'] = np.where(df.A.mul(df.B).gt(0), df.A.abs().clip(upper=3), 
                   np.where(df.A.mul(df.B).lt(0), df.B.clip(upper=3), df.A)
                  )


    Type    subType A   B   C
0   X       a       -1  4   3
1   X       a       5   9   3
2   X       a       5   9   3
3   X       b       1   4   1
4   X       b       3   5   3
5   X       b       5   0   5
6   Y       a      -1   1   1
7   Y       a       3   2   3
8   Y       a      -5   3   3
9   Y       b       1   4   1
10  Y       b       3   5   3
11  Y       b       5  -2  -2