python數據分組

1. python 數據處理（二十八）—— MultiIndex 分層索引

本節將介紹使用多級索引（分層索引）和其他高級索引技巧

分層或多級次索引的存在是非常有意義的，因為它打開了復雜的數據分析和操作的大門，特別是處理高維數據

從本質上講，它允許您在較低維度的數據結構包括 Series(1d) 和 DataFrame(2d) 中存儲和操作任意維度的數據

在本節中，我們將展示分層索引的確切含義，以及如何結合前面介紹的所有 pandas 索引功能使用

在 0.24.0 版本之後， MultiIndex.label 重命名為 MultiIndex.codes 。 MultiIndex.set_labels 重命名為 MultiIndex.set_codes .

MultiIndex 對象是標准 Index 對象的分層模式，它通常在 pandas 對象中存儲軸標簽

你可以把 MultiIndex 看成一個元組數組，其中每個元組都是唯一的。 MultiIndex 有如下創建方式

當傳遞給 Index 構造函數一個元組列表時，它將嘗試返回一個 MultiIndex 。

下面的示例演示了初始化 MultiIndex 的不同方法。

當你想要對兩個可迭代對象中的每個元素進行兩兩配對時，可以使用 MultiIndex.from_proct()

您也可以使用 MultiIndex.from_frame() 方法直接從 DataFrame 中構造一個 MultiIndex 。

為了方便起見，你可以直接將數組列表傳遞給 Series 或 DataFrame 的 index 參數來自動構造一個 MultiIndex

所有的 MultiIndex 構造函數都接受一個 name 參數，該參數存儲索引級別的名稱。如果沒有設置，則值為 None

索引可以放在任何軸上，索引的層級也可以隨你設置

這已經簡化了較高層次的索引，使控制台的輸出更容易看清。

注意 ，索引的顯示方式可以通過 pandas.set_options() 中的 multi_sparse 選項來控制。

值得注意的是，將元組用作軸上的原子標簽也是可以的

多索引之所以重要，是因為它允許您執行分組、選擇和重塑操作，我們將在下面以及後續部分中描述這些操作

get_level_values() 方法能夠返回特定級別的標簽向量

分級索引的一個重要特性是，您可以通過標識數據中的子組的部分標簽來選擇數據

部分選擇以一種完全類似於在常規 DataFrame 中選擇列的方式，返回的結果會 "降低" 分層索引的級別

MultiIndex 會保留索引的所有已經定義了的級別，盡管它們實際上可能並沒有被使用。

在對索引進行切片時，您可能會注意到這一點。例如

這樣做的目的是為了避免重新計算級別，以提高切片的性能。如果你只想看某一級別，可以使用 get_level_values() 方法

可以使用 remove_unused_levels() 方法重構 MultiIndex

在具有 MultiIndex 的不同索引對象之間的操作會自動對齊

Series/DataFrames 的 reindex() 方法可以傳入一個 MultiIndex ，甚至可以是一個元組列表或元組數組

2. Python 數據處理（三十九）—— groupby（過濾）

filter 方法可以返回原始對象的子集.

例如，我們想提取分組內的和大於 3 的所有分組的元素

filter 的參數必須是一個函數，函數參數是每個分組，並且返回 True 或 False

例如，提取元素個數大於 2 的分組

另外，我們也可以過濾掉不滿足條件的組，而是返回一個類似索引對象。在這個對象中，沒有通過的分組的元素被 NaN 填充

對於具有多列的 DataFrames ，過濾器應明確指定一列作為過濾條件

在進行聚合或轉換時，你可能想對每個分組調用一個實例方法，例如

但是，如果需要傳遞額外的參數時，它會變得很冗長。我們可以直接使用分派到組對象上的方法

實際上這生成了一個函數包裝器，在調用時，它接受所有傳遞的參數，並在每個分組上進行調用。

然後，這個結果可以和 agg 和 transform 結合在一起使用

在上面的例子中，我們按照年份分組，然後對每個分組中使用 fillna 補缺失值

nlargest 和 nsmallest 可以在 Series 類型的 groupby 上使用

對分組數據的某些操作可能並不適合聚合或轉換。或者說，你可能只是想讓 GroupBy 來推斷如何合並結果

我們可以使用 apply 函數，例如

改變返回結果的維度

在 Series 上使用 apply 類似

對於之前的示例數據

假設，我們想按 A 分組並計算組內的標准差，但是 B 列的數據我們並不關心。

如果我們的函數不能應用於某些列，則會隱式的刪除這些列，所以

直接計算標准差並不會報錯

可以使用分類變數進行分組，分組的順序會按照分類變數的順序

可以使用 pd.Grouper 控制分組，對於如下數據

可以按照一定的頻率對特定列進行分組，就像重抽樣一樣

可以分別對列或索引進行分組

類似於 Series 和 DataFrame ，可以使用 head 和 tail 獲取分組前後幾行

在 Series 或 DataFrame 中可以使用 nth() 來獲取第 n 個元素，也可以用於獲取每個分組的某一行

如果你要選擇非空項，可以使用關鍵字參數 dropna ，如果是 DataFrame ，需要指定為 any 或 all (類似於 DataFrame.dropna(how='any|all') )

與其他方法一樣，使用 as_index=False 分組名將不會作為索引

你也可以傳入一個整數列表，一次性選取多行

使用 cumcount 方法，可以查看每行在分組中出現的順序

可以使用 ngroup() 查看分組的順序，該順序與 cumcount 的順序相反。

注意 ：該順序與迭代時的分組順序一樣，並不是第一次觀測到的順序

3. python groupby忽略每組前幾個

• python中groupby函數主要的作用是進行數據的分組以及分組後地組內運算！

• 對於數據的分組和分組運算主要是指groupby函數的應用，具體函數的規則如下：

df[](指輸出數據的結果屬性名稱).groupby([df[屬性],df[屬性])(指分類的屬性，數據的限定語，可以有多個).mean()(對於數據的計算方式——函數名稱)

• 另外，我們也可以過濾掉和忽略掉你不想要的組，而是返回一個類似索引對象。在這個對象中，我們分組時需要設置一個過濾條件，那麼沒有通過的分組的元素被NaN 填充，這樣分組後被NaN 填充的數據就可以忽略了。

4. python pandas groupby分組後的數據怎麼用

pandas提供了一個靈活高效的groupby功能，它使你能以一種自然的方式對數據集進行切片、切塊、摘要等操作。根據一個或多個鍵（可以是函數、數組或DataFrame列名）拆分pandas對象。計算分組摘要統計，如計數、平均值、標准差，或用戶自定義函數。對DataFrame的列應用各種各樣的函數。應用組內轉換或其他運算，如規格化、線性回歸、排名或選取子集等。計算透視表或交叉表。執行分位數分析以及其他分組分析。
1、首先來看看下面這個非常簡單的表格型數據集（以DataFrame的形式）：

123456789101112

>>> import pandas as pd>>> df = pd.DataFrame({'key1':['a', 'a', 'b', 'b', 'a'],... 'key2':['one', 'two', 'one', 'two', 'one'],... 'data1':np.random.randn(5),... 'data2':np.random.randn(5)})>>> df data1 data2 key1 key20 -0.410673 0.519378 a one1 -2.120793 0.199074 a two2 0.642216 -0.143671 b one3 0.975133 -0.592994 b two4 -1.017495 -0.530459 a one

假設你想要按key1進行分組，並計算data1列的平均值，我們可以訪問data1，並根據key1調用groupby：

123

>>> grouped = df['data1'].groupby(df['key1'])>>> grouped<pandas.core.groupby.SeriesGroupBy object at 0x04120D70>

變數grouped是一個GroupBy對象，它實際上還沒有進行任何計算，只是含有一些有關分組鍵df['key1']的中間數據而已，然後我們可以調用GroupBy的mean方法來計算分組平均值：

12345

>>> grouped.mean()key1a -1.182987b 0.808674dtype: float64

說明：數據（Series）根據分組鍵進行了聚合，產生了一個新的Series，其索引為key1列中的唯一值。之所以結果中索引的名稱為key1，是因為原始DataFrame的列df['key1']就叫這個名字。
2、如果我們一次傳入多個數組，就會得到不同的結果：

12345678

>>> means = df['data1'].groupby([df['key1'], df['key2']]).mean()>>> meanskey1 key2a one -0.714084 two -2.120793b one 0.642216 two 0.975133dtype: float64

通過兩個鍵對數據進行了分組，得到的Series具有一個層次化索引（由唯一的鍵對組成）：

12345

>>> means.unstack()key2 one twokey1 a -0.714084 -2.120793b 0.642216 0.975133

在上面這些示例中，分組鍵均為Series。實際上，分組鍵可以是任何長度適當的數組：

12345678

>>> states = np.array(['Ohio', 'California', 'California', 'Ohio', 'Ohio'])>>> years = np.array([2005, 2005, 2006, 2005, 2006])>>> df['data1'].groupby([states, years]).mean()California 2005 -2.120793 2006 0.642216Ohio 2005 0.282230 2006 -1.017495dtype: float64

3、此外，你還可以將列名（可以是字元串、數字或其他Python對象）用作分組將：

123456789101112

>>> df.groupby('key1').mean() data1 data2key1 a -1.182987 0.062665b 0.808674 -0.368333>>> df.groupby(['key1', 'key2']).mean() data1 data2key1 key2 a one -0.714084 -0.005540 two -2.120793 0.199074b one 0.642216 -0.143671 two 0.975133 -0.592994

說明：在執行df.groupby('key1').mean()時，結果中沒有key2列。這是因為df['key2']不是數值數據，所以被從結果中排除了。默認情況下，所有數值列都會被聚合，雖然有時可能會被過濾為一個子集。
無論你准備拿groupby做什麼，都有可能會用到GroupBy的size方法，它可以返回一個含有分組大小的Series：

1234567

>>> df.groupby(['key1', 'key2']).size()key1 key2a one 2 two 1b one 1 two 1dtype: int64

注意：分組鍵中的任何缺失值都會被排除在結果之外。
4、對分組進行迭代
GroupBy對象支持迭代，可以產生一組二元元組（由分組名和數據塊組成）。看看下面這個簡單的數據集：

12345678910111213

>>> for name, group in df.groupby('key1'):... print(name)... print(group)...a data1 data2 key1 key20 -0.410673 0.519378 a one1 -2.120793 0.199074 a two4 -1.017495 -0.530459 a oneb data1 data2 key1 key22 0.642216 -0.143671 b one3 0.975133 -0.592994 b two

對於多重鍵的情況，元組的第一個元素將會是由鍵值組成的元組：

1234567891011121314151617

>>> for (k1, k2), group in df.groupby(['key1', 'key2']):... print k1, k2... print group...a one data1 data2 key1 key20 -0.410673 0.519378 a one4 -1.017495 -0.530459 a onea two data1 data2 key1 key21 -2.120793 0.199074 a twob one data1 data2 key1 key22 0.642216 -0.143671 b oneb two data1 data2 key1 key23 0.975133 -0.592994 b two

當然，你可以對這些數據片段做任何操作。有一個你可能會覺得有用的運算：將這些數據片段做成一個字典：

1234567891011121314

>>> pieces = dict(list(df.groupby('key1')))>>> pieces['b'] data1 data2 key1 key22 0.642216 -0.143671 b one3 0.975133 -0.592994 b two>>> df.groupby('key1')<pandas.core.groupby.DataFrameGroupBy object at 0x0413AE30>>>> list(df.groupby('key1'))[('a', data1 data2 key1 key20 -0.410673 0.519378 a one1 -2.120793 0.199074 a two4 -1.017495 -0.530459 a one), ('b', data1 data2 key1 key22 0.642216 -0.143671 b one3 0.975133 -0.592994 b two)]

groupby默認是在axis=0上進行分組的，通過設置也可以在其他任何軸上進行分組。那上面例子中的df來說，我們可以根據dtype對列進行分組：

12345678910111213141516171819

>>> df.dtypesdata1 float64data2 float64key1 objectkey2 objectdtype: object>>> grouped = df.groupby(df.dtypes, axis=1)>>> dict(list(grouped)){dtype('O'): key1 key20 a one1 a two2 b one3 b two4 a one, dtype('float64'): data1 data20 -0.410673 0.5193781 -2.120793 0.1990742 0.642216 -0.1436713 0.975133 -0.5929944 -1.017495 -0.530459}

1234567891011121314

>>> grouped<pandas.core.groupby.DataFrameGroupBy object at 0x041288F0>>>> list(grouped)[(dtype('float64'), data1 data20 -0.410673 0.5193781 -2.120793 0.1990742 0.642216 -0.1436713 0.975133 -0.5929944 -1.017495 -0.530459), (dtype('O'), key1 key20 a one1 a two2 b one3 b two4 a one)]

5、選取一個或一組列
對於由DataFrame產生的GroupBy對象，如果用一個（單個字元串）或一組（字元串數組）列名對其進行索引，就能實現選取部分列進行聚合的目的，即：

123456

>>> df.groupby('key1')['data1']<pandas.core.groupby.SeriesGroupBy object at 0x06615FD0>>>> df.groupby('key1')['data2']<pandas.core.groupby.SeriesGroupBy object at 0x06615CB0>>>> df.groupby('key1')[['data2']]<pandas.core.groupby.DataFrameGroupBy object at 0x06615F10>

和以下代碼是等效的：

123456

>>> df['data1'].groupby([df['key1']])<pandas.core.groupby.SeriesGroupBy object at 0x06615FD0>>>> df[['data2']].groupby([df['key1']])<pandas.core.groupby.DataFrameGroupBy object at 0x06615F10>>>> df['data2'].groupby([df['key1']])<pandas.core.groupby.SeriesGroupBy object at 0x06615E30>

尤其對於大數據集，很可能只需要對部分列進行聚合。例如，在前面那個數據集中，如果只需計算data2列的平均值並以DataFrame形式得到結果，代碼如下：

1234567891011121314

>>> df.groupby(['key1', 'key2'])[['data2']].mean() data2key1 key2 a one -0.005540 two 0.199074b one -0.143671 two -0.592994>>> df.groupby(['key1', 'key2'])['data2'].mean()key1 key2a one -0.005540 two 0.199074b one -0.143671 two -0.592994Name: data2, dtype: float64

這種索引操作所返回的對象是一個已分組的DataFrame（如果傳入的是列表或數組）或已分組的Series（如果傳入的是標量形式的單個列明）：

12345678910

>>> s_grouped = df.groupby(['key1', 'key2'])['data2']>>> s_grouped<pandas.core.groupby.SeriesGroupBy object at 0x06615B10>>>> s_grouped.mean()key1 key2a one -0.005540 two 0.199074b one -0.143671 two -0.592994Name: data2, dtype: float64

6、通過字典或Series進行分組
除數組以外，分組信息還可以其他形式存在，來看一個DataFrame示例：

123456789101112

>>> people = pd.DataFrame(np.random.randn(5, 5),... columns=['a', 'b', 'c', 'd', 'e'],... index=['Joe', 'Steve', 'Wes', 'Jim', 'Travis']... )>>> people a b c d eJoe 0.306336 -0.139431 0.210028 -1.489001 -0.172998Steve 0.998335 0.494229 0.337624 -1.222726 -0.402655Wes 1.415329 0.450839 -1.052199 0.731721 0.317225Jim 0.550551 3.201369 0.669713 0.725751 0.577687Travis -2.013278 -2.010304 0.117713 -0.545000 -1.228323>>> people.ix[2:3, ['b', 'c']] = np.nan

假設已知列的分組關系，並希望根據分組計算列的總計：

123456

>>> mapping = {'a':'red', 'b':'red', 'c':'blue',... 'd':'blue', 'e':'red', 'f':'orange'}>>> mapping{'a': 'red', 'c': 'blue', 'b': 'red', 'e': 'red', 'd': 'blue', 'f': 'orange'}>>> type(mapping)<type 'dict'>

現在，只需將這個字典傳給groupby即可：

12345678910

>>> by_column = people.groupby(mapping, axis=1)>>> by_column<pandas.core.groupby.DataFrameGroupBy object at 0x066150F0>>>> by_column.sum() blue redJoe -1.278973 -0.006092Steve -0.885102 1.089908Wes 0.731721 1.732554Jim 1.395465 4.329606Travis -0.427287 -5.251905

Series也有同樣的功能，它可以被看做一個固定大小的映射。對於上面那個例子，如果用Series作為分組鍵，則pandas會檢查Series以確保其索引跟分組軸是對齊的：

12345678910111213141516

>>> map_series = pd.Series(mapping)>>> map_seriesa redb redc blued bluee redf orangedtype: object>>> people.groupby(map_series, axis=1).count() blue redJoe 2 3Steve 2 3Wes 1 2Jim 2 3Travis 2 3

7、通過函數進行分組
相較於字典或Series，Python函數在定義分組映射關系時可以更有創意且更為抽象。任何被當做分組鍵的函數都會在各個索引值上被調用一次，其返回值就會被用作分組名稱。
具體點說，以DataFrame為例，其索引值為人的名字。假設你希望根據人名的長度進行分組，雖然可以求取一個字元串長度數組，但其實僅僅傳入len函數即可：

12345

>> people.groupby(len).sum() a b c d e3 2.272216 3.061938 0.879741 -0.031529 0.7219145 0.998335 0.494229 0.337624 -1.222726 -0.4026556 -2.013278 -2.010304 0.117713 -0.545000 -1.228323

將函數跟數組、列表、字典、Series混合使用也不是問題，因為任何東西最終都會被轉換為數組：

1234567

>>> key_list = ['one', 'one', 'one', 'two', 'two']>>> people.groupby([len, key_list]).min() a b c d e3 one 0.306336 -0.139431 0.210028 -1.489001 -0.172998 two 0.550551 3.201369 0.669713 0.725751 0.5776875 one 0.998335 0.494229 0.337624 -1.222726 -0.4026556 two -2.013278 -2.010304 0.117713 -0.545000 -1.228323

8、根據索引級別分組
層次化索引數據集最方便的地方在於它能夠根據索引級別進行聚合。要實現該目的，通過level關鍵字傳入級別編號或名稱即可：

12345678910111213141516171819
>>> columns = pd.MultiIndex.from_arrays([['US', 'US', 'US', 'JP', 'JP'],... [1, 3, 5, 1, 3]], names=['cty', 'tenor'])>>> columnsMultiIndex[US 1, 3, 5, JP 1, 3]>>> hier_df = pd.DataFrame(np.random.randn(4, 5), columns=columns)>>> hier_dfcty US JP tenor 1 3 5 1 30 -0.166600 0.248159 -0.082408 -0.710841 -0.0971311 -1.762270 0.687458 1.235950 -1.407513 1.3040552 1.089944 0.258175 -0.749688 -0.851948 1.6877683 -0.378311 -0.078268 0.247147 -0.018829 0.744540>>> hier_df.groupby(level='cty', axis=1).count()cty JP US0 2 31 2 32 2 33 2 3

5. PYTHON的數據結構和演算法介紹

當你聽到數據結構時，你會想到什麼？

數據結構是根據類型組織和分組數據的容器。它們基於可變性和順序而不同。可變性是指創建後改變對象的能力。我們有兩種類型的數據結構，內置數據結構和用戶定義的數據結構。

什麼是數據演算法-是由計算機執行的一系列步驟，接受輸入並將其轉換為目標輸出。

列表是用方括弧定義的，包含用逗號分隔的數據。該列表是可變的和有序的。它可以包含不同數據類型的混合。

months=['january','february','march','april','may','june','july','august','september','october','november','december']
print(months[0])#print the element with index 0
print(months[0:7])#all the elements from index 0 to 6
months[0]='birthday #exchange the value in index 0 with the word birthday

print(months)

元組是另一種容器。它是不可變有序元素序列的數據類型。不可變的，因為你不能從元組中添加和刪除元素，或者就地排序。

length, width, height =9,3,1 #We can assign multiple variables in one shot

print("The dimensions are {} * {} * {}".format(length, width, height))

一組

集合是唯一元素的可變且無序的集合。它可以讓我們快速地從列表中刪除重復項。

numbers=[1,2,3,4,6,3,3]

unique_nums = set(numbers)
print(unique_nums)

models ={'declan','gift','jabali','viola','kinya','nick',betty' }

print('davis' in models)#check if there is turner in the set models
models.add('davis')
print(model.pop())remove the last item#
字典

字典是可變和無序的數據結構。它允許存儲一對項目(即鍵和值)

下面的例子顯示了將容器包含到其他容器中來創建復合數據結構的可能性。

* 用戶定義的數據結構*

使用數組的堆棧堆棧是一種線性數據結構，其中元素按順序排列。它遵循L.I.F.O的機制，意思是後進先出。因此，最後插入的元素將作為第一個元素被刪除。這些操作是:

溢出情況——當我們試圖在一個已經有最大元素的堆棧中再放一個元素時，就會出現這種情況。

下溢情況——當我們試圖從一個空堆棧中刪除一個元素時，就會出現這種情況。

隊列是一種線性數據結構，其中的元素按順序排列。它遵循先進先出的F.I.F.O機制。

描述隊列特徵的方面

兩端:

前端-指向起始元素。

指向最後一個元素。

有兩種操作:

樹用於定義層次結構。它從根節點開始，再往下，最後的節點稱為子節點。

鏈表

它是具有一系列連接節點的線性數據。每個節點存儲數據並顯示到下一個節點的路由。它們用來實現撤銷功能和動態內存分配。

圖表

這是一種數據結構，它收集了具有連接到其他節點的數據的節點。

它包括:

演算法

在演算法方面，我不會講得太深，只是陳述方法和類型:

原文：https://www.tuicool.com/articles/hit/VRRvYr3