Python---数据分析(Pandas十:二维数组DataFrame统计计算一)
1、 count
用于计算 DataFrame 中非 NaN 值的数量。
DataFrame.count(axis=0, numeric_only=False)| 描述 | 说明 |
|---|---|
| axis | {0 或 ‘index’, 1 或 ‘columns’}，决定统计的方向。 如果 axis=0 或 axis='index'，则对每列进行计数，返回一个 Series，其 索引为列名，值为每列非 NaN 值的数量。 如果 axis=1 或 axis='columns'，则对每行进行计数，返回一个 Series， 其索引为行索引，值为每行非 NaN 值的数量。 |
| numeric_only | 是否只计算数值列中的非 NaN 值的数量，忽略非数值列，默认 为 False。 |
import pandas as pd
import numpy as np
# 创建一个包含 NaN 值的 DataFrame
df = pd.DataFrame({
'A': [1, 2, np.nan, 4],
'B': [5, np.nan, np.nan, 8],
'C': ['foo', 'bar', 'baz', np.nan]
})
print(df)
# 计算每列非 NaN 值的数量
count_per_column = df.count()
print("Count per column:")
print(count_per_column)
# 计算每行非 NaN 值的数量
count_per_row = df.count(axis=1)
print("\nCount per row:")
print(count_per_row)
# 只计算数值列的非 NaN 值的数量
count_numeric_only = df.count(numeric_only=True)
print("\nCount numeric only:")
print(count_numeric_only) A B C
0 1.0 5.0 foo
1 2.0 NaN bar
2 NaN NaN baz
3 4.0 8.0 NaN
Count per column:
A 3
B 2
C 3
dtype: int64
Count per row:
0 3
1 2
2 1
3 2
dtype: int64
Count numeric only:
A 3
B 2
dtype: int642、 sum
用于计算 DataFrame 中数值的总和。
DataFrame.sum(axis=0, skipna=True, numeric_only=False, min_count=0, **kwargs)| 描述 | 说明 |
|---|---|
| axis | {0 或 ‘index’, 1 或 ‘columns’, None}, 默认为 0。这个参数决定了求和是在 哪个轴上进行： 如果 axis=0 或 axis='index'，则对每列进行求和，返回一个 Series，其 索引为列名，值为每列的总和。 如果 axis=1 或 axis='columns'，则对每行进行求和，返回一个 Series， 其索引为行索引，值为每行的总和。 |
| skipna | 布尔值，默认为 True。如果为 True，则在计算总和时会忽略 NaN 值。 |
| numeric_only | 布尔值，默认为 False。如果为 True，则只对数值列进行求和， 忽略非数值列。 |
| min_count | 默认为 0。这个参数指定了在计算总和之前，至少需要非 NaN 值的最小数量。如果某个分组中的非 NaN 值的数量小于 min_count，则结果为 NaN。 |
| **kwargs | 其他关键字参数。这些参数通常用于兼容性或特殊用途，通常不需 要。 |
import pandas as pd
import numpy as np
# 创建一个包含 NaN 值的 DataFrame
df = pd.DataFrame({
'A': [1, 2, np.nan, 4],
'B': [5, np.nan, np.nan, 8],
'C': ['foo', 'bar', 'baz', 'qux']
})
print(df)
# 计算每列的总和
sum_per_column = df.sum()
print("Sum per column:")
print(sum_per_column)
# 只计算数值列的总和
sum_numeric_only = df.sum(numeric_only=True)
print("\nSum numeric only:")
print(sum_numeric_only)
# 使用 min_count 参数
sum_with_min_count = df.sum(min_count=3)
print("\nSum with min_count=2:")
print(sum_with_min_count) A B C
0 1.0 5.0 foo
1 2.0 NaN bar
2 NaN NaN baz
3 4.0 8.0 qux
Sum per column:
A 7.0
B 13.0
C foobarbazqux
dtype: object
Sum numeric only:
A 7.0
B 13.0
dtype: float64
Sum with min_count=2:
A 7.0
B NaN
C foobarbazqux
dtype: object3、 mean
用于计算 DataFrame 中数值的平均值。
DataFrame.mean(axis=0, skipna=True, numeric_only=False, **kwargs)| 描述 | 说明 |
|---|---|
| axis | {0 或 ‘index’, 1 或 ‘columns’, None}, 默认为 0。这个参数决定了计算平均 值是在哪个轴上进行： 如果 axis=0 或 axis='index'，则对每列进行计算，返回一个 Series，其 索引为列名，值为每列的平均值。 如果 axis=1 或 axis='columns'，则对每行进行计算，返回一个 Series， 其索引为行索引，值为每行的平均值。 |
| skipna | 布尔值，默认为 True。如果为 True，则在计算平均值时会忽略 NaN 值。 |
| numeric_only | 布尔值，默认为 False。如果为 True，则只对数值列进行计算， 忽略非数值列。 |
| **kwargs | 其他关键字参数。这些参数通常用于兼容性或特殊用途，通常不需 要。 |
import pandas as pd
import numpy as np
df = pd.DataFrame({
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
})
sum_per_column = df.mean()
print("mean per column:")
print(sum_per_column)mean per column:
A 2.5
B 6.5
dtype: float644、 median
用于计算 DataFrame 中数值的中位数。
DataFrame.median(axis=0, skipna=True, numeric_only=False, **kwargs)| 描述 | 说明 |
|---|---|
| axis | {0 或 ‘index’, 1 或 ‘columns’, None}, 默认为 0。这个参数决定了计算中位数是在哪个轴上进行： 如果 axis=0 或 axis='index'，则对每列进行计算，返回一个 Series，其 索引为列名，值为每列的中位数。 如果 axis=1 或 axis='columns'，则对每行进行计算，返回一个 Series， 其索引为行索引，值为每行的中位数。 |
| skipna | 布尔值，默认为 True。如果为 True，则在计算中位数时会忽略 NaN 值。 |
| numeric_only | 布尔值，默认为 False。如果为 True，则只对数值列进行计算， 忽略非数值列。 |
| **kwargs | 其他关键字参数。这些参数通常用于兼容性或特殊用途，通常不需 要。 |
import pandas as pd
import numpy as np
df = pd.DataFrame({
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
})
sum_per_column = df.median()
print("median per column:")
print(sum_per_column)mean per column:
A 2.5
B 6.5
dtype: float645、 min
用于计算 DataFrame 中数值的最小值。
DataFrame.min(axis=0, skipna=True, numeric_only=False, **kwargs)| 描述 | 说明 |
|---|---|
| axis | {0 或 ‘index’, 1 或 ‘columns’, None}, 默认为 0。这个参数决定了计算最小值是在哪个轴上进行： 如果 axis=0 或 axis='index'，则对每列进行计算，返回一个 Series，其 索引为列名，值为每列的最小值。 如果 axis=1 或 axis='columns'，则对每行进行计算，返回一个 Series， 其索引为行索引，值为每行的最小值。 |
| skipna | 布尔值，默认为 True。如果为 True，则在计算最小值时会忽略 NaN 值。 |
| numeric_only | 布尔值，默认为 False。如果为 True，则只对数值列进行计算， 忽略非数值列。 |
| **kwargs | 其他关键字参数。这些参数通常用于兼容性或特殊用途，通常不需 要。 |
import pandas as pd
import numpy as np
df = pd.DataFrame({
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
})
sum_per_column = df.min()
print("min per column:")
print(sum_per_column)min per column:
A 1
B 5
dtype: int646、 max
用于计算 DataFrame 中数值的最大值。
DataFrame.max(axis=0, skipna=True, numeric_only=False, **kwargs)| 描述 | 说明 |
|---|---|
| axis | {0 或 ‘index’, 1 或 ‘columns’, None}, 默认为 0。这个参数决定了计算最大值是在哪个轴上进行： 如果 axis=0 或 axis='index'，则对每列进行计算，返回一个 Series，其 索引为列名，值为每列的最大值。 如果 axis=1 或 axis='columns'，则对每行进行计算，返回一个 Series， 其索引为行索引，值为每行的最大值。 |
| skipna | 布尔值，默认为 True。如果为 True，则在计算最大值时会忽略 NaN 值。 |
| numeric_only | 布尔值，默认为 False。如果为 True，则只对数值列进行计算， 忽略非数值列。 |
| **kwargs | 其他关键字参数。这些参数通常用于兼容性或特殊用途，通常不需 要。 |
import pandas as pd
import numpy as np
df = pd.DataFrame({
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
})
sum_per_column = df.max()
print("max per column:")
print(sum_per_column)max per column:
A 4
B 8
dtype: int647 、var
用于计算 DataFrame 中数值的方差。
DataFrame.var(axis=0, skipna=True, ddof=1, numeric_only=False, **kwargs)| 描述 | 说明 |
|---|---|
| axis | {0 或 ‘index’, 1 或 ‘columns’, None}, 默认为 0。这个参数决定了计算方差是在哪个轴上进行： 如果 axis=0 或 axis='index'，则对每列进行计算，返回一个 Series，其 索引为列名，值为每列的方差。 如果 axis=1 或 axis='columns'，则对每行进行计算，返回一个 Series， 其索引为行索引，值为每行的方差。 |
| skipna | 布尔值，默认为 True。如果为 True，则在计算方差时会忽略 NaN 值。 |
| ddof | 整数，默认为 1。Delta Degrees of Freedom，计算样本方差时使用的无 偏估计的自由度修正。对于整个群体的方差， ddof 应该设置为 0。 |
| numeric_only | 布尔值，默认为 False。如果为 True，则只对数值列进行计算， 忽略非数值列。 |
| **kwargs | 其他关键字参数。这些参数通常用于兼容性或特殊用途，通常不需 要。 |
import pandas as pd
import numpy as np
df = pd.DataFrame({
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
})
sum_per_column = df.var()
print("var per column:")
print(sum_per_column)var per column:
A 1.666667
B 1.666667
dtype: float64