Pandas value_counts操作Series數組

 

 

 

 

 

 

列中出現的每個值進行計數 對給定列里面的每個值進行計數並進行降序排序，無效值也會被排除(默認從最高到最低做降序排列)
value_counts () 返回的序列是降序的。我們只需要把參數 ascending 設置為 True，就可以把順序變成升序。
value_counts()返回的結果是一個Series數組，可以跟別的數組進行運算。value_count()跟透視表里（pandas或者excel）的計數很相似，都是返回一組唯一值，並進行計數。這樣能快速找出重復出現的值。

 

        dr = pd.DataFrame(df_search_issues.T, cite_bug_from_cycle_column)
                if self.switch_issue_priority:
                    self.df_issue_priority = pd.concat([dr.T['嚴重程度'].value_counts(), pd.DataFrame(index=['1', '2', '3', '4', '5'])], axis=1).T.rename(index=str, columns={"1": "一級", "2": "二級", "3": "三級", "4": "四級", "5": "五級"})
                    print('拼接嚴重程度表格:\n{}'.format(self.df_issue_priority))
                    self.df_issue_priority = self.df_issue_priority.rename(index={"嚴重程度": "總個數"}).fillna(0)
                    print('重命名索引:\n{}'.format(self.df_issue_priority))
                    self.df_issue_priority = self.df_issue_priority[['一級', '二級', '三級', '四級', '五級']].astype(int)
                    print('重命名索引:\n{}'.format(self.df_issue_priority))

 

 

def value_counts(
    values,
    sort: bool = True,
    ascending: bool = False,
    normalize: bool = False,
    bins=None,
    dropna: bool = True,
) -> "Series":
    """
    Compute a histogram of the counts of non-null values.

    Parameters
    ----------
    values : ndarray (1-d)
    sort : bool, default True
        Sort by values
    ascending : bool, default False
        Sort in ascending order
    normalize: bool, default False
        If True then compute a relative histogram
    bins : integer, optional
        Rather than count values, group them into half-open bins,
        convenience for pd.cut, only works with numeric data
    dropna : bool, default True
        Don't include counts of NaN

    Returns
    -------
    Series
    """
    from pandas.core.series import Series

    name = getattr(values, "name", None)

    if bins is not None:
        from pandas.core.reshape.tile import cut

        values = Series(values)
        try:
            ii = cut(values, bins, include_lowest=True)
        except TypeError:
            raise TypeError("bins argument only works with numeric data.")

        # count, remove nulls (from the index), and but the bins
        result = ii.value_counts(dropna=dropna)
        result = result[result.index.notna()]
        result.index = result.index.astype("interval")
        result = result.sort_index()

        # if we are dropna and we have NO values
        if dropna and (result.values == 0).all():
            result = result.iloc[0:0]

        # normalizing is by len of all (regardless of dropna)
        counts = np.array([len(ii)])

    else:

        if is_extension_array_dtype(values):

            # handle Categorical and sparse,
            result = Series(values)._values.value_counts(dropna=dropna)
            result.name = name
            counts = result.values

        else:
            keys, counts = _value_counts_arraylike(values, dropna)

            result = Series(counts, index=keys, name=name)

    if sort:
        result = result.sort_values(ascending=ascending)

    if normalize:
        result = result / float(counts.sum())

    return result

 

探索性數據分析（EDA）與數據分析的任何部分一樣重要，因為真實的數據集確實很亂，如果您不知道數據，很多事情都會出錯。為此，Pandas庫配備了一些方便的功能，並且value_counts是其中之一。Pandasvalue_counts返回一個對象，該對象按排序順序在pandas數據框中包含唯一值的計數。但是，大多數用戶傾向於忽略此功能，不僅可以與默認參數一起使用。因此，在本文中，我將向您展示如何value_counts通過更改默認參數和一些其他技巧來從熊貓中獲取更多價值，這些技巧將節省您的時間。

什么是value_counts（）函數？

該value_counts()函數用於獲取包含唯一值計數的系列。生成的對象將按降序排列，以便第一個元素是最頻繁出現的元素。默認情況下不包括NA值。

句法

df['your_column'].value_counts() -這將返回指定列中唯一事件的計數。

需要注意的是，value_counts僅適用於pandas系列，不適用於Pandas數據框。結果，我們只包含一個括號df ['your_column']，而不包含兩個括號df [['your_column']]。

參量

• normalize（布爾值，默認為False）-如果為True，則返回的對象將包含唯一值的相對頻率。
• sort（布爾值，默認為True）-按頻率排序。
• 升序（布爾，默認為False）-按升序排序。
• bins（整數，可選）-而不是對值進行計數，而是將它們分組為半開式垃圾箱，這對的方便之處pd.cut僅適用於數字數據。
• dropna（布爾值，默認為True）-不包括NaN計數。

加載實時演示的數據集

讓我們看看使用數據集的此方法的基本用法。我將使用Kaggle的Coursera課程數據集進行實時演示。我還在git上發布了一個隨附的筆記本，以防您想要獲取我的代碼。

讓我們從導入所需的庫和數據集開始。這是每個數據分析過程中的基本步驟。然后在Jupyter筆記本中查看數據集。

# import package
import pandas as pd

# Loading the dataset
df = pd.read_csv('coursea_data.csv')

#quick look about the information of the csv
df.head(10)

加載數據集

# check how many records are in the dataset 
# and if we have any NA

df.info()

這就告訴我們，我們的數據集中有891條記錄，並且沒有任何NA值。

1.）使用默認參數的value_counts（）

現在我們可以使用value_counts函數了。讓我們從函數的基本應用開始。

語法-df['your_column'].value_counts()

我們將從我們的數據框中獲取Course_difficulty列的計數。

# count of all unique values for the column course_difficulty

df['course_difficulty'].value_counts()

value_counts函數的基本用法

該value_counts函數以降序返回給定索引中所有唯一值的計數，不包含任何空值。我們可以很快地看到最大的課程具有初學者難度，其次是中級和混合，然后是高級。

既然我們已經了解了該函數的基本用法，那么現在該弄清楚參數的作用了。

2.）value_counts（）升序

value_counts()默認情況下，返回的系列是降序排列的。我們可以通過將ascending參數設置為來反轉大小寫True。

語法-df['your_column'].value_counts(ascending=True)

# count of all unique values for the column course_difficulty
# in ascending order

df['course_difficulty'].value_counts(ascending=True)

value_counts升序

3.）value_counts（）的人為計數或唯一值的相對頻率。

有時，獲得百分比計數比正常計數更好。通過設置normalize=True，返回的對象將包含唯一值的相對頻率。該normalize參數False默認設置為。

語法-df['your_column'].value_counts(normalize=True)

# value_counts percentage view

df['course_difficulty'].value_counts(normalize=True)

以百分比表示的value_counts

4.）value_counts（）將連續數據分成離散間隔

這是一個通常未被充分利用的偉大黑客。的 value_counts()可用於連續倉數據分成離散的間隔與所述的幫助bin參數。此選項僅適用於數值數據。它類似於pd.cut功能。讓我們使用course_rating列查看其工作方式。讓我們將列的計數分為4個bin。

語法-df['your_column'].value_counts(bin = number of bins)

# applying value_counts with default parameters 
df['course_rating'].value_counts()

# applying value_counts on a numerical column 
# with the bin parameter

df['course_rating'].value_counts(bins=4)

valse_counts默認參數 合並的value_counts個

Binning使您很容易理解所傳達的想法。我們可以很容易地看到，總人口中的大多數人對課程的評分高於4.5。評分低於4.15的異常值很少（只有7個評分低於4.15的課程）。

5.）value_counts（）顯示NaN值

默認情況下，從結果中排除空值計數。但是，通過將dropna參數設置為，可以輕松顯示相同內容False。由於我們的數據集沒有任何空值，因此設置dropna參數不會有任何不同。但這可以用於另一個具有空值的數據集，因此請記住這一點。

語法-df['your_column'].value_counts(dropna=False)

6.）value_counts（）作為數據框

如本文開頭所述，value_counts返回系列，而不是數據框。如果您希望將計數作為數據框使用，可以使用。.to_frame()之后的函數.value_counts()。

我們可以將序列轉換為數據框，如下所示：

語法-df['your_column'].value_counts().to_frame()

# applying value_counts with default parameters 
df['course_difficulty'].value_counts()

# value_counts as dataframe
df['course_difficulty'].value_counts().to_frame()

正常的value_counts和value_counts為df

如果您需要命名索引列並重命名一列（在數據框中包含計數），則可以以略有不同的方式轉換為數據框。

value_counts = df['course_difficulty'].value_counts()

# converting to df and assigning new names to the columns
df_value_counts = pd.DataFrame(value_counts)
df_value_counts = df_value_counts.reset_index()
df_value_counts.columns = ['unique_values', 'counts for course_difficulty'] # change column names
df_value_counts

7.）分組和value_counts

這是value_counts（）函數的我最喜歡的用法之一，也是未得到充分利用的函數。Groupby是一種非常強大的熊貓方法。您可以使用來對一列進行分組並針對該列值計算另一列的值value_counts。

語法-df.groupby('your_column_1')['your_column_2'].value_counts()

使用groupby和value_counts我們可以計算每種類型的課程難度的證書類型數量。

按課程難度和課程證書類型的值計數進行分組

這是一個多索引，是pandas數據框中的一個有價值的竅門，它使我們可以在數據框中使用幾個級別的索引層次結構。在這種情況下，課程難度為索引的級別0，證書類型為級別1。

8.帶有約束的熊貓值計數

使用數據集時，可能需要使用索引列返回的出現次數，該次數value_counts()也受到約束的限制。

語法-df['your_column'].value_counts().loc[lambda x : x>1]

上面的快速單行代碼將過濾出唯一數據的計數，並且僅查看指定列中的值大於1的數據。

讓我們通過限制課程等級大於4來證明這一點。

# prints standart value_counts for the column
df['course_rating'].value_counts()

# prints filtered value_counts for the column
df['course_rating'].value_counts().loc[lambda x : x>4] 

有約束的value_counts

因此，我們可以看到值計數是一個方便的工具，並且我們可以用這一行代碼進行一些有趣的分析

 

The resulting object will be in descending order so that the first element is the most frequently-occurring element. Excludes NA values by default.

Syntax:

Series.value_counts(self, normalize=False, sort=True, ascending=False, bins=None, dropna=True)

Parameters:

Name	Description	Type/Default Value	Required / Optional
normalize	If True then the object returned will contain the relative frequencies of the unique values.	boolean Default Value: False	Required
sort	Sort by frequencies.	boolean Default Value: True	Required
ascending	Sort in ascending order.	boolean Default Value: False	Required
bins	IRather than count values, group them into half-open bins, a convenience for pd.cut, only works with numeric data.	integer	Optional
dropna	Don’t include counts of NaN.	boolean Default Value: True	Required

Returns: Series

Example:

Examples

In [1]:

import numpy as np import pandas as pd 

In [2]:

index = pd.Index([2, 2, 5, 3, 4, np.nan]) index.value_counts() 

Out[2]:

2.0    2
4.0    1
3.0    1
5.0    1
dtype: int64

 

 

With normalize set to True, returns the relative frequency by dividing all values by the sum of values.

In [3]:

s = pd.Series([2, 2, 5, 3, 4, np.nan]) 

In [4]:

s.value_counts(normalize=True) 

Out[4]:

2.0    0.4
4.0    0.2
3.0    0.2
5.0    0.2
dtype: float64

 

 

bins
Bins can be useful for going from a continuous variable to a categorical variable; instead of counting
unique apparitions of values, divide the index in the specified number of half-open bins.

In [5]:

s.value_counts(bins=3) 

Out[5]:

(1.9960000000000002, 3.0]    3
(4.0, 5.0]                   1
(3.0, 4.0]                   1
dtype: int64

 

dropna
With dropna set to False we can also see NaN index values.

In [6]:

s.value_counts(dropna=False) 

Out[6]:

2.0    2
NaN    1
4.0    1
3.0    1
5.0    1
dtype: int64