Python3 pandas.MultiIndex 概述
- 層次化索引（hierarchical indexing）在一個(gè)軸上擁有多個(gè)（兩個(gè)以上）索引級(jí)別，使用戶能以低維度形式處理高維度數(shù)據(jù)。
- levels：每個(gè)等級(jí)上軸標(biāo)簽的唯一值
- labels：以整數(shù)來表示每個(gè)level上標(biāo)簽的位置
- sortorder：按照指定level上的標(biāo)簽名稱的字典順序進(jìn)行排序（可選參數(shù)）
- names：index level的名稱
- copy：布爾值，默認(rèn)為False。是否拷貝元數(shù)據(jù)產(chǎn)生新的對(duì)象
- verify_integrity：布爾值，默認(rèn)為Ture。檢查levels/labels是否持續(xù)有效
入門級(jí)demo學(xué)習(xí)
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Time : 2019-06-13 10:11
# @Author : LiYahui
# @Description : python multiindex demo
import pandas as pd
import numpy as np
data = pd.Series(np.random.randn(10),
index=[['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'd', 'd'],
[1, 2, 3, 1, 2, 3, 1, 2, 2, 3]])
print("----------print data---------------")
print(data)
'''
a 1 -0.902378
2 -1.512923
3 -1.082350
b 1 -0.900975
2 -1.723988
3 -0.791613
c 1 -1.631530
2 2.290227
d 2 0.530892
3 1.199453
dtype: float64
'''
print("----------print data.index-------------")
print(data.index)
'''
MultiIndex(levels=[['a', 'b', 'c', 'd'], [1, 2, 3]],
codes=[[0, 0, 0, 1, 1, 1, 2, 2, 3, 3], [0, 1, 2, 0, 1, 2, 0, 1, 1, 2]])
'''
print("----------print data.index.levels[0]----------------")
print(data.index.levels[0])
'''
Index(['a', 'b', 'c', 'd'], dtype='object')
'''
print("----------print data.index.levels[1]----------------")
print(data.index.levels[1])
'''
Int64Index([1, 2, 3], dtype='int64')
'''
- 總結(jié)分析如下：
- level中的唯一標(biāo)簽值集合分別為[‘a(chǎn)’, ‘b’, ‘c’, ‘d’]和[1, 2, 3]。
- data.index.levels[0]上的標(biāo)簽abcd對(duì)應(yīng)的索引為0123。data.index.levels[1]上的標(biāo)簽123對(duì)應(yīng)的索引為012。
- 外層level的label值[0, 0, 0, 1, 1, 1, 2, 2, 3, 3]表示對(duì)應(yīng)的標(biāo)簽值分別出現(xiàn)幾次：a和b為3次，c和d為2次
- 內(nèi)層level的label值[0, 1, 2, 0, 1, 2, 0, 1, 1, 2]按個(gè)數(shù)與外層label相對(duì)應(yīng)。例如：外層a出現(xiàn)3次，則內(nèi)層label的前3個(gè)值與a相對(duì)應(yīng)，這三個(gè)索引值為0，1，2，分別對(duì)應(yīng)1，2，3。
MultiIndex創(chuàng)建的方式
第一種
- 我們在創(chuàng)建Series或DataFrame時(shí)，可以通過給index（columns）參數(shù)傳遞多維數(shù)組，進(jìn)而構(gòu)建多維索引?！緮?shù)組中每個(gè)維度對(duì)應(yīng)位置的元素，組成每個(gè)索引值】
- 多維索引的也可以設(shè)置名稱（names屬性），屬性的值為一維數(shù)組，元素的個(gè)數(shù)需要與索引的層數(shù)相同（每層索引都需要具有一個(gè)名稱）。
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Time : 2019-06-13 10:52
# @Author : LiYahui
# @Description : MultiIndex demo
import pandas as pd
import numpy as np
# 創(chuàng)建多層索引的第一種方式
# 創(chuàng)建Series對(duì)象，具有單層索引。
s1 = pd.Series([1, 2, 3], index=["a", "b", "c"])
print(s1)
'''
a 1
b 2
c 3
dtype: int64
'''
# 創(chuàng)建多層索引。多層索引需要一個(gè)二維的數(shù)組，每個(gè)元素（一維數(shù)組）來指定每個(gè)層級(jí)的索引。順序
# 由高層（左邊）到底層（右邊）。
s2 = pd.Series([1, 2, 3, 4], index=[["a", "a", "b", "b"], ["c", "d", "e", "f"], ["m", "m", "k", "t"]])
print(s2)
'''
a c m 1
d m 2
b e k 3
f t 4
dtype: int64
'''
print("-------df--------")
df = pd.DataFrame(np.random.random(size=(4, 4)), index=[["上半年", "上半年", "下半年", "下半年"],
["第一季度", "第二季度", "第三季度", "第四季度"]],
columns=[["水果", "水果", "蔬菜", "蔬菜"], ["蘋果", "葡萄", "白菜", "蘿卜"]])
print(df)
'''
水果 蔬菜
蘋果 葡萄 白菜 蘿卜
上半年 第一季度 0.356637 0.358602 0.402864 0.550727
第二季度 0.963110 0.010293 0.378511 0.051015
下半年 第三季度 0.098882 0.394281 0.554502 0.676566
第四季度 0.828770 0.506423 0.681128 0.542206
'''
print(df.index)
'''
MultiIndex(levels=[['上半年', '下半年'], ['第一季度', '第三季度', '第二季度', '第四季度']],
codes=[[0, 0, 1, 1], [0, 2, 1, 3]])
'''
print(df.columns)
'''
MultiIndex(levels=[['水果', '蔬菜'], ['白菜', '蘋果', '蘿卜', '葡萄']],
codes=[[0, 0, 1, 1], [1, 3, 0, 2]])
'''
# 如果是單層索引，我們可以通過索引對(duì)象的name屬性來設(shè)置索引的名稱。
s2 = pd.Series([1, 2, 3, 4], index=["a", "b", "c", "d"])
s2.index.name = "索引名稱"
print("--------s2----------")
print(s2)
'''
索引名稱
a 1
b 2
c 3
d 4
dtype: int64
'''
# 對(duì)于多層索引，也可以設(shè)置索引的名稱，此時(shí)，設(shè)置名稱的屬性為names（通過一維數(shù)組來設(shè)置）。
# 每層索引都具有名稱。
# 修改df的索引
df.index.names = ["年度", "季度"]
df.columns.names = ["大類別", "小類別"]
print(df)
'''
大類別 水果 蔬菜
小類別 蘋果 葡萄 白菜 蘿卜
年度 季度
上半年 第一季度 0.078253 0.961293 0.770540 0.267522
第二季度 0.845138 0.239290 0.208779 0.347256
下半年 第三季度 0.869534 0.148100 0.046563 0.753004
第四季度 0.926966 0.305344 0.379041 0.467218
'''
第二種
- 我們可以通過MultiIndex類的相關(guān)方法，預(yù)先創(chuàng)建一個(gè)MultiIndex對(duì)象，然后作為Series與DataFrame中的index（或columns）參數(shù)值。同時(shí)，可以通過names參數(shù)指定多層索引的名稱。
- from_arrays：接收一個(gè)多維數(shù)組參數(shù)，高維指定高層索引，低維指定底層索引。
- from_tuples：接收一個(gè)元組的列表，每個(gè)元組指定每個(gè)索引（高維索引，低維索引）。
- from_product：接收一個(gè)可迭代對(duì)象的列表，根據(jù)多個(gè)可迭代對(duì)象元素的笛卡爾積進(jìn)行創(chuàng)建索引。
from_product相對(duì)于前兩個(gè)方法而言，實(shí)現(xiàn)相對(duì)簡單，但是，也存在局限。
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Time : 2019-06-13 11:13
# @Author : LiYahui
# @Description :multiindex demo
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.random(size=(4, 4)), index=[["上半年", "上半年", "下半年", "下半年"],
["第一季度", "第二季度", "第三季度", "第四季度"]],
columns=[["水果", "水果", "蔬菜", "蔬菜"], ["蘋果", "葡萄", "白菜", "蘿卜"]])
print(df)
'''
水果 蔬菜
蘋果 葡萄 白菜 蘿卜
上半年 第一季度 0.645330 0.408014 0.121088 0.106337
第二季度 0.671892 0.212711 0.792635 0.031329
下半年 第三季度 0.063841 0.513930 0.342464 0.885220
第四季度 0.091936 0.745129 0.905859 0.760001
'''
# 創(chuàng)建多層索引的第二種方式
# ------------from_arrays-------------------
# from_arrays 參數(shù)為一個(gè)二維數(shù)組，每個(gè)元素（一維數(shù)組）來分別制定每層索引的內(nèi)容。
mindex_arrsys = pd.MultiIndex.from_arrays([["上半年", "上半年", "下半年", "下半年"], ["1季度", "2季度", "3季度", "4季度"]])
df2 = pd.DataFrame(np.random.random(size=(4, 4)), index=mindex_arrsys)
print(df2)
'''
0 1 2 3
上半年 1季度 0.578044 0.636138 0.497155 0.389131
2季度 0.195453 0.623200 0.769118 0.637451
下半年 3季度 0.562462 0.629691 0.684193 0.981682
4季度 0.873525 0.489149 0.883518 0.252548
'''
# ------------from_tuples-------------------
# from_tuples 參數(shù)為一個(gè)（嵌套的）可迭代對(duì)象,元素為元祖類型。元祖的格式為：(高層索引內(nèi)容，低層索引內(nèi)容)
mindex_tuples = pd.MultiIndex.from_tuples([("上半年", "1季度"), ("上半年", "2季度"), ("下半年", "3季度"), ("下半年", "4季度")])
df3 = pd.DataFrame(np.random.random(size=(4, 4)), index=mindex_tuples)
print(df3)
'''
0 1 2 3
上半年 1季度 0.843825 0.242793 0.132814 0.024581
2季度 0.404961 0.870869 0.134744 0.220976
下半年 3季度 0.196361 0.074073 0.588173 0.181438
4季度 0.936489 0.246351 0.941209 0.144210
'''
# ------------from_products-------------------
# 使用笛卡爾積的方式來創(chuàng)建多層索引。參數(shù)為嵌套的可迭代對(duì)象。結(jié)果為使用每個(gè)一維數(shù)組中的元素與其他一維數(shù)組中的元素來生成
# 索引內(nèi)容。
mindex_products = pd.MultiIndex.from_product([["a", "b"], ["c", "d"]], names=["outer", "inner"])
print(mindex_products)
'''
MultiIndex(levels=[['a', 'b'], ['c', 'd']],
codes=[[0, 0, 1, 1], [0, 1, 0, 1]],
names=['outer', 'inner'])
'''
print(pd.MultiIndex.from_arrays([["a", "a", "b", "b"], ["c", "d", "c", "d"]]))
'''
MultiIndex(levels=[['a', 'b'], ['c', 'd']],
codes=[[0, 0, 1, 1], [0, 1, 0, 1]])
'''
print(pd.MultiIndex.from_arrays([["a", "a", "b"], ["c", "d", "d"]]))
'''
MultiIndex(levels=[['a', 'b'], ['c', 'd']],
codes=[[0, 0, 1], [0, 1, 1]])
'''
# MultiIndex的三個(gè)類方法，可以創(chuàng)建MultiIndex類型的對(duì)象。三種方式相比，第三種方式（笛卡爾積的方式）更加簡便，但是，
# 其也具有一定的局限：兩兩組合必須都存在，否則，就不能使用這種方式。
# 在創(chuàng)建多層索引對(duì)象時(shí)，可以通過names參數(shù)來指定每個(gè)索引層級(jí)的名稱。
df4 = pd.DataFrame(np.random.random(size=(4, 4)),index=mindex_products)
print(df4)
print(df4.index)
'''
0 1 2 3
outer inner
a c 0.213218 0.561547 0.224423 0.764169
d 0.296970 0.557486 0.809295 0.300886
b c 0.134809 0.111138 0.619714 0.223240
d 0.707181 0.872395 0.800698 0.676075
MultiIndex(levels=[['a', 'b'], ['c', 'd']],
codes=[[0, 0, 1, 1], [0, 1, 0, 1]],
names=['outer', 'inner'])
'''
# 還有第三種方式（因?yàn)榉爆?，所以不用），最直接的方式?mindex = pd.MultiIndex(levels=[['a', 'b'], ['c', 'd']],
codes=[[0, 0, 1, 1], [0, 1, 0, 1]],
names=['outer', 'inner'])
print(mindex)
'''
MultiIndex(levels=[['a', 'b'], ['c', 'd']],
codes=[[0, 0, 1, 1], [0, 1, 0, 1]],
names=['outer', 'inner'])
'''
多層索引操作
- 對(duì)于多層索引，同樣也支持單層索引的相關(guān)操作，例如，索引元素，切片，索引數(shù)組選擇元素等。我們也可以根據(jù)多級(jí)索引，按層次逐級(jí)選擇元素。
- 多層索引的優(yōu)勢：通過創(chuàng)建多層索引，我們就可以使用高層次的索引，來操作整個(gè)索引組的數(shù)據(jù)。
- 格式：
- s[操作]
- s.loc[操作]
- s.iloc[操作]
其中，操作可以是索引，切片，數(shù)組索引，布爾索引。
Series多層索引
- 通過loc（標(biāo)簽索引）操作，可以通過多層索引，獲取該索引所對(duì)應(yīng)的一組值。
- 通過iloc（位置索引）操作，會(huì)獲取對(duì)應(yīng)位置的元素值（與是否多層索引無關(guān)）。
- 通過s[操作]的行為有些詭異，建議不用。
- 對(duì)于索引（單級(jí)），首先按照標(biāo)簽選擇，如果標(biāo)簽不存在，則按照位置選擇。
- 對(duì)于多級(jí)索引，則按照標(biāo)簽進(jìn)行選擇。
- 對(duì)于切片，如果提供的是整數(shù)，則按照位置選擇，否則按照標(biāo)簽選擇。
- 對(duì)于數(shù)組索引, 如果數(shù)組元素都是整數(shù)，則根據(jù)位置進(jìn)行索引，否則，根據(jù)標(biāo)簽進(jìn)行索引（此時(shí)如果標(biāo)簽不存在，也不會(huì)出現(xiàn)錯(cuò)誤）。
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Time : 2019-06-13 11:28
# @Author : LiYahui
# @Description : 位置選擇
import pandas as pd
s = pd.Series([1, 2, 3, 4], index=[["a", "a", "b", "b"], ["c", "d", "e", "f"]])
print(s)
'''
a c 1
d 2
b e 3
f 4
dtype: int64
'''
# 多層索引的優(yōu)勢，可以一次獲取一組元素（值）
print(s.loc["a"])
'''
c 1
d 2
dtype: int64
'''
# 也可以沿著索引層次進(jìn)行訪問。
print(s.loc["a", "d"]) # 訪問指定坐標(biāo)的元素值
'''
2
'''
# 通過位置索引訪問元素，與多層索引沒有任何關(guān)系。
print(s.iloc[0])
'''
1
'''
# 切片
print(s.loc["a":"b"])
'''
a c 1
d 2
b e 3
f 4
dtype: int64
'''
# 行index上的序號(hào)類型的切片
print(s.iloc[0:2])
'''
a c 1
d 2
b e 3
f 4
dtype: int64
'''
DataFrame多層索引
- 通過loc（標(biāo)簽索引）操作，可以通過多層索引，獲取該索引所對(duì)應(yīng)的一組值。
- 通過iloc（位置索引）操作，會(huì)獲取對(duì)應(yīng)位置的一行（與是否多層索引無關(guān)）。
- 通過s[操作]的行為有些詭異，建議不用。
- 對(duì)于索引，根據(jù)標(biāo)簽獲取相應(yīng)的列（如果是多層索引，則可以獲得多列）。
- 對(duì)于數(shù)組索引, 根據(jù)標(biāo)簽，獲取相應(yīng)的列（如果是多層索引，則可以獲得多列）。
- 對(duì)于切片，首先按照標(biāo)簽進(jìn)行索引，然后再按照位置進(jìn)行索引（取行）。
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Time : 2019-06-13 11:28
# @Author : LiYahui
# @Description : 位置選擇
import pandas as pd
data=[[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
df=pd.DataFrame(data)
print(df)
'''
0 1 2 3
0 1 2 3 4
1 5 6 7 8
2 9 10 11 12
3 13 14 15 16
'''
# 指定行索引
df.index=[["a", "a", "b", "b"], ["c", "d", "c", "d"]]
# 指定列索引
df.columns=[["x", "x", "y", "y"], ["z", "u", "z", "u"]]
print("-----------指定行和列索引之后的數(shù)據(jù)值---------------")
print(df)
'''
x y
z u z u
a c 1 2 3 4
d 5 6 7 8
b c 9 10 11 12
d 13 14 15 16
'''
print('-------df.loc["a"]------------')
print(df.loc["a"]) # 對(duì)應(yīng)的外層索引的切片
'''
x y
z u z u
c 1 2 3 4
d 5 6 7 8
'''
print('--------df.loc["a", "c"]-----------')
print(df.loc["a", "c"]) #取的是對(duì)應(yīng)的行數(shù)據(jù)
'''
x z 1
u 2
y z 3
u 4
'''
print('------df["x", "z"])--------')
print(df["x", "z"]) #取的是列數(shù)據(jù)
'''
a c 1
d 5
b c 9
d 13
Name: (x, z), dtype: int64
'''
# 通過位置訪問元素與是否多層索引無關(guān)。
print('----------df.iloc[0])-----------------')
print(df.iloc[0])
'''
x z 1
u 2
y z 3
u 4
Name: (a, c), dtype: int64
'''
交換索引
我們可以調(diào)用DataFrame對(duì)象的swaplevel方法來交換兩個(gè)層級(jí)索引。該方法默認(rèn)對(duì)倒數(shù)第2層與倒數(shù)第1層進(jìn)行交換。我們也可以指定交換的層。層次從0開始，由外向內(nèi)遞增（或者由上到下遞增），也可以指定負(fù)值，負(fù)值表示倒數(shù)第n層。除此之外，我們也可以使用層次索引的名稱來進(jìn)行交換。
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Time : 2019-06-13 13:07
# @Author : LiYahui
# @Description :
# 交換索引的層級(jí)，可以以一種不同的方式來進(jìn)行展示（統(tǒng)計(jì)）。
import pandas as pd
data=[[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
df = pd.DataFrame(data, index=[["a", "a", "b", "b"],
["north", "north", "south", "south"], [2017, 2018, 2017, 2018]])
print(df)
'''
0 1 2 3
a north 2017 1 2 3 4
2018 5 6 7 8
b south 2017 9 10 11 12
2018 13 14 15 16
'''
# 層級(jí)：從外層到內(nèi)層，值為0， 1， 2……，同時(shí)，層級(jí)也可以為負(fù)值，表示倒數(shù)第n個(gè)層級(jí)（由內(nèi)層到外層）。
# 例如，-1表示最內(nèi)層。
# 如果沒有顯式指定交換的層級(jí)，則默認(rèn)交換最內(nèi)層的兩個(gè)層級(jí)。
df = df.swaplevel(0, 2)
print(df)
'''
0 1 2 3
2017 north a 1 2 3 4
2018 north a 5 6 7 8
2017 south b 9 10 11 12
2018 south b 13 14 15 16
'''
# 索引名字的作用。
# 除了數(shù)值來指定索引的層級(jí)外，我們也可以通過索引的名字來指定索引的層級(jí)。
df.index.names = ["x", "area", "year"]
df.swaplevel("area", "year")
print(df)
'''
0 1 2 3
x area year
2017 north a 1 2 3 4
2018 north a 5 6 7 8
2017 south b 9 10 11 12
2018 south b 13 14 15 16
'''
df.sort_index()
print(df)
'''
0 1 2 3
x area year
2017 north a 1 2 3 4
2018 north a 5 6 7 8
2017 south b 9 10 11 12
2018 south b 13 14 15 16
'''
索引排序
我們可以使用sort_index方法對(duì)索引進(jìn)行排序處理。
- level：指定根據(jù)哪一層進(jìn)行排序，默認(rèn)為最外（上）層。該值可以是數(shù)值，索引名，或者是由二者構(gòu)成的列表。
- inplace：是否就地修改。默認(rèn)為False。
# 層級(jí)索引的排序
df = pd.DataFrame(data, index=[["b", "a", "c", "c"],
["c", "y", "k", "k"], [3, -2, 5, 2]])
print(df)
'''
0 1 2 3
b c 3 1 2 3 4
a y -2 5 6 7 8
c k 5 9 10 11 12
2 13 14 15 16
'''
# 在對(duì)索引進(jìn)行排序時(shí)，可以通過level參數(shù)指定索引的層級(jí)（排序的層級(jí)）。
# 如果沒有顯式指定，則默認(rèn)為最外層的層級(jí)（層級(jí)為0）。
# 當(dāng)我們對(duì)某個(gè)層級(jí)進(jìn)行排序時(shí)，該層級(jí)的所有內(nèi)層層級(jí)也會(huì)進(jìn)行排序。
print(df.sort_index())
'''
0 1 2 3
a y -2 5 6 7 8
b c 3 1 2 3 4
c k 2 13 14 15 16
5 9 10 11 12
'''
print(df.sort_index(level=1))
'''
0 1 2 3
b c 3 1 2 3 4
c k 2 13 14 15 16
5 9 10 11 12
a y -2 5 6 7 8
'''
索引堆疊
- 通過DataFrame對(duì)象的stack方法，可以進(jìn)行索引堆疊，即將指定層級(jí)的列轉(zhuǎn)換成行。
- level：指定轉(zhuǎn)換的層級(jí)，默認(rèn)為-1。
*詳見 Python--pandas--unstack() 與stack()
取消堆疊
- 通過DataFrame對(duì)象的unstack方法，可以取消索引堆疊，即將指定層級(jí)的行轉(zhuǎn)換成列。
- level：指定轉(zhuǎn)換的層級(jí)，默認(rèn)為-1。
- fill_value：指定填充值。默認(rèn)為NaN。
- 詳見： Python--pandas--unstack() 與stack()
設(shè)置索引
- 在DataFrame中，如果我們需要將現(xiàn)有的某一（幾）列作為索引列，可以調(diào)用set_index方法來實(shí)現(xiàn)。
- drop：是否丟棄作為新索引的列，默認(rèn)為True。
- append：是否以追加的方式設(shè)置索引，默認(rèn)為False。
- inplace：是否就地修改，默認(rèn)為False。
- 詳見Python-pandas--set_index與reset_index
重置索引
- 調(diào)用在DataFrame對(duì)象的reset_index，可以重置索引。該操作與set_index正好相反。
- level：重置索引的層級(jí)，默認(rèn)重置所有層級(jí)的索引。如果重置所有索引，將會(huì)創(chuàng)建默認(rèn)整數(shù)序列索引。
- drop：是否丟棄重置的索引列，默認(rèn)為False。
- inplace：是否就地修改，默認(rèn)為False。
- 詳見 Python-pandas--set_index與reset_index
