【pandas小记】pandas中易混淆的描述性统计

以下几种pandas描述性感觉容易混淆，记录下
1，pandas.DataFrame.count

DataFrame.count(self, axis=0, level=None, numeric_only=False)
#统计为每列或每行非NA数

# 参数
"""
axis : {0 or ‘index’, 1 or ‘columns’}, 默认为 0
level : int 或 str, 对于分层索引指定层级
numeric_only : boolean, 默认为 False 如果为True 仅包含float，int或boolean数据
"""

#demo
df = pd.DataFrame({'k1': list('aabba'),
                   'k2': ['one', 'two', 'one', 'two', 'one'],
                   'value1': [np.nan, 2, np.nan, 3, 4],
                   'value2': [10, 20, np.nan, np.nan, 40]})
"""
  k1   k2  value1  value2
0  a  one     NaN    10.0
1  a  two     2.0    20.0
2  b  one     NaN     NaN
3  b  two     3.0     NaN
4  a  one     4.0    40.0
"""
print(df.count(axis=0))
""" 统计每列非NA数
k1        5
k2        5
value1    3
value2    3
dtype: int64
"""
print(df.set_index(['k1', 'k2']).count(level=1))
""" 分层索引 按K2统计非NA数
     value1  value2
k2                 
one       1       2
two       2       1
"""
print(df.groupby(['k1', 'k2']).count())
"""groupby也有同样的方法，统计组内非NA数，无任何参数
        value1  value2
k1 k2                 
a  one       1       2
   two       1       1
b  one       0       0
   two       1       0
"""
print(df['k1'].count())
""" Series 也有同样的方法
5
"""

2，pandas.Series.value_counts

Series.value_counts(self, normalize=False, sort=True, ascending=False, bins=None, dropna=True)
"""
 对Series里面的每个值进行计数并且排序，
 结果对象将按降序排列，默认情况下不包括NA值。
 """
 #参数
 """
 normalize：bool, 默认False 如果为True,返回频率占比
 sort：bool, default True，按照频率排序
 ascending：bool, default False 降序排序
 bins:不是计数，而是将它们分组到半开的容器中,与pd.cut类似，只针对数值
 dropna:bool, default True,忽略NAN
 """
 
 #demo
 
df = pd.DataFrame({'k1': list('aabba'),
                   'k2': ['one', 'two', 'one', 'two', 'one'],
                   'value1': [11, 20, 21, 21, 41],
                   'value2': [11, 20, 21, 31, 40]})

print(df['k2'].value_counts(ascending=True,normalize=True))
""" 使用频率占比
two    0.4
one    0.6
Name: k2, dtype: float64
"""

print(df['value2'].value_counts(bins=2))
""" 分层两个容器
(10.97, 25.5]    3
(25.5, 40.0]     2
Name: value2, dtype: int64
"""
print(df[['value1', 'value2']].apply(pd.value_counts))
"""DataFrame通过apply调用value_counts
    value1  value2
11     1.0     1.0
20     1.0     1.0
21     2.0     1.0
31     NaN     1.0
40     NaN     1.0
41     1.0     NaN
"""

3，pandas.DataFrame.size

DataFrame.size
# 返回表示此对象中元素数

#demo
df = pd.DataFrame({'k1': list('aabba'),
                   'k2': ['one', 'two', 'one', 'two', 'one'],
                   'value1': [np.nan, 2, np.nan, 3, 4],
                   'value2': [10, 20, np.nan, np.nan, 40]})
print(df)
print(df.size)  # 20
"""
size 与 count()不同
1，size是property，count是method
2，size统计整个df或者series的元素数，而count()可以按行或列统计
3，size包含NAN，而count()可以排除NAN
"""
# 在groupby中size计数时包含NaN值，而count不包含NaN值
print(df.groupby(['k1', 'k2'])['value1'].size())
"""
k1  k2 
a   one    2
    two    1
b   one    1
    two    1
Name: value1, dtype: int64
"""
print(df.groupby(['k1', 'k2'])['value1'].count())
"""k1  k2 
a   one    1
    two    1
b   one    0
    two    1
Name: value1, dtype: int64
"""

4，pandas.Series.unique

Series.unique(self)
# 返回Series每个特征的唯一值,也返回去重后剩余的值

# demo
df = pd.DataFrame({'k1': list('aabba'),
                   'k2': ['one', 'two', 'one', 'two', 'one'],
                   'value1': [11, 20, 21, 21, 41],
                   'value2': [11, 20, 21, 31, 40]})
print(df)
print(df['value1'].unique())  # [11 20 21 41]  

5，pandas.DataFrame.nunique

DataFrame.nunique(self, axis=0, dropna=True)
# 返回沿指定轴上唯一值的个数，忽略NAN，也返回重后剩余值的个数

#参数
"""
axis：轴向 默认0轴
dropna：bool, default True，忽略NAN
"""

# demo

df = pd.DataFrame({'k1': list('aabba'),
                   'k2': ['one', 'two', 'one', 'two', 'one'],
                   'value1': [11, 20, 21, np.nan, 41],
                   'value2': [11, np.nan, 21, np.nan, 40]})

print(df.nunique(axis=0))
"""
k1        2  ['a','b'] 两个值
k2        2  ['one','two'] 两个值
value1    4  [11.20,21,41]
value2    3  [11,21,40]
dtype: int64
"""
print(df['k1'].nunique())  # Series 也有nunique()，不过无axis参数