Python 将范围在0到1之间的列乘以100（单位为）

给定一个数据帧：

 df = pd.DataFrame({'A':[1, 2, 3, 4, 5], 
                    'B': [0.1, 0.2, 0.3, 0.4, 0.5], 
                    'C': [11, 12, 13, 14, 15]})

   A    B   C
0  1  0.1  11
1  2  0.2  12
2  3  0.3  13
3  4  0.4  14
4  5  0.5  15

对于值的范围在0和1之间的所有列，我想将这些列中的所有值乘以一个常量（比如，100）。我不知道哪些列的值在0到1之间，并且有100多列

   A    B   C
0  1   10  11
1  2   20  12
2  3   30  13
3  4   40  14
4  5   50  15

我尝试使用.min（）和.max（）并将它们与所需的范围进行比较，以返回每列的真/假值

(df.min() >= 0) & (df.max() <= 1)

A    False
B     True
C    False

（df.min（）>=0）和（df.max（）使用
.all（）
检查所有值是否在范围内，如果为真，则将它们相乘-

In [1877]: paste
for col in df.columns:
        if (0<df[col]).all() and (df[col]<1).all():
                df[col] = df[col] * 100

## -- End pasted text --

In [1878]: df
Out[1878]: 
   A   B   C
0  1  10  11
1  2  20  12
2  3  30  13
3  4  40  14
4  5  50  15

[1877]中的
：粘贴
对于df.列中的列：
如果（0使用
.all（）
检查所有值是否在范围内，如果为真，则将它们相乘-

In [1877]: paste
for col in df.columns:
        if (0<df[col]).all() and (df[col]<1).all():
                df[col] = df[col] * 100

## -- End pasted text --

In [1878]: df
Out[1878]: 
   A   B   C
0  1  10  11
1  2  20  12
2  3  30  13
3  4  40  14
4  5  50  15

[1877]中的
：粘贴
对于df.列中的列：
如果（0使用
.all（）
检查所有值是否在范围内，如果为真，则将它们相乘-

In [1877]: paste
for col in df.columns:
        if (0<df[col]).all() and (df[col]<1).all():
                df[col] = df[col] * 100

## -- End pasted text --

In [1878]: df
Out[1878]: 
   A   B   C
0  1  10  11
1  2  20  12
2  3  30  13
3  4  40  14
4  5  50  15

[1877]中的
：粘贴
对于df.列中的列：
如果（0使用
.all（）
检查所有值是否在范围内，如果为真，则将它们相乘-

In [1877]: paste
for col in df.columns:
        if (0<df[col]).all() and (df[col]<1).all():
                df[col] = df[col] * 100

## -- End pasted text --

In [1878]: df
Out[1878]: 
   A   B   C
0  1  10  11
1  2  20  12
2  3  30  13
3  4  40  14
4  5  50  15

[1877]中的
：粘贴
对于df.列中的列：
如果（0是这样的话

to_multiply = [col for col in df if 1 >= min(df[col]) >= 0 and 1 >= max(df[col]) >= 0]

df[to_multiply] = df[to_multiply] * 100

像这样的

to_multiply = [col for col in df if 1 >= min(df[col]) >= 0 and 1 >= max(df[col]) >= 0]

df[to_multiply] = df[to_multiply] * 100

像这样的

to_multiply = [col for col in df if 1 >= min(df[col]) >= 0 and 1 >= max(df[col]) >= 0]

df[to_multiply] = df[to_multiply] * 100

像这样的

to_multiply = [col for col in df if 1 >= min(df[col]) >= 0 and 1 >= max(df[col]) >= 0]

df[to_multiply] = df[to_multiply] * 100

我们可以构造一个布尔掩码，测试df中的值是否大于（）0且小于（）1，然后调用并传递
axis=0
，以生成一个布尔掩码来过滤列，然后将该列中的所有值乘以100：

In [58]:

df[df.columns[np.all(df.gt(0) & df.lt(1),axis=0)]] *= 100
df
Out[58]:
   A   B   C
0  1  10  11
1  2  20  12
2  3  30  13
3  4  40  14
4  5  50  15

分解上述内容：

In [61]:

df.gt(0) & df.lt(1)
Out[61]:
       A     B      C
0  False  True  False
1  False  True  False
2  False  True  False
3  False  True  False
4  False  True  False
In [62]:

np.all(df.gt(0) & df.lt(1),axis=0)
Out[62]:
array([False,  True, False], dtype=bool)
In [63]:

df.columns[np.all(df.gt(0) & df.lt(1),axis=0)]
Out[63]:
Index(['B'], dtype='object')

我们可以构造一个布尔掩码，测试df中的值是否大于（）0且小于（）1，然后调用并传递
axis=0
，以生成一个布尔掩码来过滤列，然后将该列中的所有值乘以100：

In [58]:

df[df.columns[np.all(df.gt(0) & df.lt(1),axis=0)]] *= 100
df
Out[58]:
   A   B   C
0  1  10  11
1  2  20  12
2  3  30  13
3  4  40  14
4  5  50  15

分解上述内容：

In [61]:

df.gt(0) & df.lt(1)
Out[61]:
       A     B      C
0  False  True  False
1  False  True  False
2  False  True  False
3  False  True  False
4  False  True  False
In [62]:

np.all(df.gt(0) & df.lt(1),axis=0)
Out[62]:
array([False,  True, False], dtype=bool)
In [63]:

df.columns[np.all(df.gt(0) & df.lt(1),axis=0)]
Out[63]:
Index(['B'], dtype='object')

我们可以构造一个布尔掩码，测试df中的值是否大于（）0且小于（）1，然后调用并传递
axis=0
，以生成一个布尔掩码来过滤列，然后将该列中的所有值乘以100：

In [58]:

df[df.columns[np.all(df.gt(0) & df.lt(1),axis=0)]] *= 100
df
Out[58]:
   A   B   C
0  1  10  11
1  2  20  12
2  3  30  13
3  4  40  14
4  5  50  15

分解上述内容：

In [61]:

df.gt(0) & df.lt(1)
Out[61]:
       A     B      C
0  False  True  False
1  False  True  False
2  False  True  False
3  False  True  False
4  False  True  False
In [62]:

np.all(df.gt(0) & df.lt(1),axis=0)
Out[62]:
array([False,  True, False], dtype=bool)
In [63]:

df.columns[np.all(df.gt(0) & df.lt(1),axis=0)]
Out[63]:
Index(['B'], dtype='object')

我们可以构造一个布尔掩码，测试df中的值是否大于（）0且小于（）1，然后调用并传递
axis=0
，以生成一个布尔掩码来过滤列，然后将该列中的所有值乘以100：

In [58]:

df[df.columns[np.all(df.gt(0) & df.lt(1),axis=0)]] *= 100
df
Out[58]:
   A   B   C
0  1  10  11
1  2  20  12
2  3  30  13
3  4  40  14
4  5  50  15

分解上述内容：

In [61]:

df.gt(0) & df.lt(1)
Out[61]:
       A     B      C
0  False  True  False
1  False  True  False
2  False  True  False
3  False  True  False
4  False  True  False
In [62]:

np.all(df.gt(0) & df.lt(1),axis=0)
Out[62]:
array([False,  True, False], dtype=bool)
In [63]:

df.columns[np.all(df.gt(0) & df.lt(1),axis=0)]
Out[63]:
Index(['B'], dtype='object')

您可以根据选择标准选择数据帧：

df.update(df.loc[:, (df.ge(0).all() & df.le(1).all())].mul(100))

>>> df
     A   B   C
0    1  10  11
1    2  20  12
2    3  30  13
3    4  40  14
4    5  50  15

任何大于或等于零且小于或等于一的列都要乘以100

其他比较运算符：


.ge（大于或等于）
.gt（大于）
.le（小于或等于）
.lt（小于）
.eq（等于）
您可以根据选择标准选择数据帧：

df.update(df.loc[:, (df.ge(0).all() & df.le(1).all())].mul(100))

>>> df
     A   B   C
0    1  10  11
1    2  20  12
2    3  30  13
3    4  40  14
4    5  50  15

任何大于或等于零且小于或等于一的列都要乘以100

其他比较运算符：


.ge（大于或等于）
.gt（大于）
.le（小于或等于）
.lt（小于）
.eq（等于）
您可以根据选择标准选择数据帧：

df.update(df.loc[:, (df.ge(0).all() & df.le(1).all())].mul(100))

>>> df
     A   B   C
0    1  10  11
1    2  20  12
2    3  30  13
3    4  40  14
4    5  50  15

任何大于或等于零且小于或等于一的列都要乘以100

其他比较运算符：


.ge（大于或等于）
.gt（大于）
.le（小于或等于）
.lt（小于）
.eq（等于）
您可以根据选择标准选择数据帧：

df.update(df.loc[:, (df.ge(0).all() & df.le(1).all())].mul(100))

>>> df
     A   B   C
0    1  10  11
1    2  20  12
2    3  30  13
3    4  40  14
4    5  50  15

任何大于或等于零且小于或等于一的列都要乘以100

其他比较运算符：


.ge（大于或等于）
.gt（大于）
.le（小于或等于）
.lt（小于）
.eq（等于）