Pandas---3.下標存取([]/loc/iloc/ix/at/iat/query方法/多級索引/整數label)

本文轉載自查看原文 2019-12-27 17:15 286 Pandas

一、[ ] 操作符

1.Index

對於Index對象，可以通過[]來選取數據，它類似於一維ndarray的索引。下標可以為下列幾種下標對象：

一個整數下標。此時返回對應的label
一個整數slice。此時返回對應的Index（根據一維labels先切片，再組裝成Index）
一個array-like對象（元素可以為下標或者布爾值）。此時返回對應的Index。（根據一維labels先索引，再組裝成Index）
由None組成的二元組，其中None相當於新建一個軸。
1. 如果None為第一個元素，則新建的軸為 0 軸；
2. 如果None為第二個元素，則新建的軸為 1 軸。
3. 另外idx[None]等價於idx[None,:]，但是idx[None]返回的是ndarray。
4. 它並沒有將Index 轉換成MultiIndex，只是將Index內部的數據數組擴充了一個軸

Index 的索引只支持整數/整數slice/整數序列/布爾序列/整數數組/布爾數組/None 等。

舉例：

import numpy as np
import pandas as pd

idx = pd.Index(['a','b','c','d'],name='idx1')
idx
# Index(['a', 'b', 'c', 'd'], dtype='object', name='idx1')

idx[0],idx[0:2] # 整數或者切片
# ('a', Index(['a', 'b'], dtype='object', name='idx1'))

idx[None],idx[0,None],idx[:,None],idx[None,:] # 擴充為二維數組
# (array([['a', 'b', 'c', 'd']], dtype=object),
 Index(['a'], dtype='object', name='idx1'),
 Index([['a'], ['b'], ['c'], ['d']], dtype='object', name='idx1'),
 Index([['a', 'b', 'c', 'd']], dtype='object', name='idx1'))

idx[[0,1,2,3]],idx[np.array([1,2,3])],idx[[True,True,False,False]] # 一維序列
# (Index(['a', 'b', 'c', 'd'], dtype='object', name='idx1'),
 Index(['b', 'c', 'd'], dtype='object', name='idx1'),
 Index(['a', 'b'], dtype='object', name='idx1'))

idx[np.array([[0,1],[1,2]])] # 二維數組
# Index([['a', 'b'], ['b', 'c']], dtype='object', name='idx1')

2.Series

（1）[]

對於Series對象，可以通過[]來選取數據，它類似於一維ndarray的索引。下標可以為下列幾種下標對象：

一個整數下標/一個屬性（屬性名為某個label）/字典索引（鍵為label）：返回對應的數值
一個整數切片/一個label切片：返回對應的Series。（根據一維Series先切片，再組裝成Series）。注意：label切片同時包含了起始label和終止label
一個整數array-like/一個label array-like/一個布爾ndarray：返回對應的Series。（根據一維Series先索引，再組裝成Series）
一個二維整數array-like/二維label array-like：返回對應值組成的二維ndarray

注意：Series必須使用布爾數組來索引，不支持布爾序列來索引(拋出KeyError異常)。

舉例：

idx
# Index(['a', 'b', 'c', 'd'], dtype='object', name='idx1')

s = pd.Series([0,3,5,7],index=idx,name='ser1')
s
# idx1
a    0
b    3
c    5
d    7
Name: ser1, dtype: int64

s.a,s['b'],s[2] # 單個label，單個loc
# (0, 3, 5)

print(s['a':'c'],s[0:2],sep='\n------\n') # 切片labels,切片loc
# idx1
a    0
b    3
c    5
Name: ser1, dtype: int64
------
idx1
a    0
b    3
Name: ser1, dtype: int64

print(s[['a','c','b']],s[[3,0,1]],sep='\n------\n') # 序列label,序列loc
# idx1
a    0
c    5
b    3
Name: ser1, dtype: int64
------
idx1
d    7
a    0
b    3
Name: ser1, dtype: int64

r1 = s[np.array(['a','c','b'])]
r2 = s[np.array([0,1,1,3])]
r3 = s[np.array([[0,1],[1,3]])]
print(r1,type(r1),r2,type(r2),r3,type(r3),sep="\n----------\n") # 數組label,數組loc
# idx1
a    0
c    5
b    3
Name: ser1, dtype: int64
----------
<class 'pandas.core.series.Series'>
----------
idx1
a    0
b    3
b    3
d    7
Name: ser1, dtype: int64
----------
<class 'pandas.core.series.Series'>
----------
[[0 3]
 [3 7]]
----------
<class 'numpy.ndarray'>

r = s[s>4]
print(r) # 數組label,數組loc
# idx1
c    5
d    7
Name: ser1, dtype: int64

（2）索引標簽

Series對象除了支持使用位置作為下標存取元素之外，還可以使用索引標簽來存取元素。這個功能與字典類似，因此它也支持字典的一些方法，如Series.iteritems()。

舉例：

bool_df = pd.DataFrame({'c1':[True,False],'c4':[True,False]},index=['a','e'])
df[bool_df]# 一個布爾DataFrame,未出現的值為False

#	c1	c2	c3
idx1			
a	1.0	NaN	NaN
b	NaN	NaN	NaN
c	NaN	NaN	NaN
d	NaN	NaN	NaN

idx = pd.Index(['a','b','c','d'],name='index1')
s = pd.Series([1,3,5,7],index=idx,name='sr1')
s
# index1
a    1
b    3
c    5
d    7
Name: sr1, dtype: int64

s.iteritems()
# <zip at 0x21ba1c8e288>

[item for item in s.iteritems()]
# [('a', 1), ('b', 3), ('c', 5), ('d', 7)]

（3）對於`Series`的賦值與刪除

對於單個索引或者切片索引，要求右側數值的長度與左側相等
為不存在的label賦值會創建出一個新行（必須用字典的形式，不能用屬性賦值的形式）
關鍵字del用於刪除行（必須用字典的形式，不能用屬性賦值的形式）

舉例：

s = pd.Series(np.arange(1,4),index=['a','b','c'])
s
# a    1
b    2
c    3
dtype: int32

s.a = -1 # 直接賦值
s
# a   -1
b    2
c    3
dtype: int32

s[0:2] = -11,-22 # 元組賦值
s
# a   -11
b   -22
c     3
dtype: int32

s['d'] = 4 # 創建一個新的行
s
# a   -11
b   -22
c     3
d     4
dtype: int64

del s['d']
s
# 
a   -11
b   -22
c     3
dtype: int64

3.DataFrame

（1）[]

對於DataFrame對象，可以通過[]來選取數據。下標可以為下列幾種下標對象：

一個屬性（屬性名為某個column label）/字典索引（鍵為column label）：返回對應的列對應的Series

不可以使用單個整數來索引
一個整數切片/一個row label切片：返回對應的行組成的DataFrame。注意：label切片同時包含了起始label和終止label
一個一維label array-like：返回對應的列組成的DataFrame
一個布爾數組：返回數組中True對應的行組成的DataFrame。
一個布爾DataFrame：將該布爾DataFrame中的False對應的元素設置為NaN（布爾DataFrame中沒有出現的值為False）

舉例：

df = pd.DataFrame({'c1':[1,2,3,4],'c2':[5,6,7,8],'c3':[9,10,11,12]},index=idx)
df
# 	c1	c2	c3
idx1			
a	1	5	9
b	2	6	10
c	3	7	11
d	4	8	12

print(df.c1,df['c2'],sep='\n------------\n') # 單個值,選取列
# idx1
a    1
b    2
c    3
d    4
Name: c1, dtype: int64
------------
idx1
a    5
b    6
c    7
d    8
Name: c2, dtype: int64

print(df[0:2],df['a':'c'],sep='\n------------\n') # 切片,選取行
#       c1  c2  c3
idx1            
a      1   5   9
b      2   6  10
------------
      c1  c2  c3
idx1            
a      1   5   9
b      2   6  10
c      3   7  11

print(df[['c1','c2','c1']],df[np.array(['c1','c2','c3'])],sep='\n------------\n') #序列，選取列
#       c1  c2  c1
idx1            
a      1   5   1
b      2   6   2
c      3   7   3
d      4   8   4
------------
      c1  c2  c3
idx1            
a      1   5   9
b      2   6  10
c      3   7  11
d      4   8  12

df[df.c1>=3] # 一維布爾數組
# 	c1	c2	c3
idx1			
c	3	7	11
d	4	8	12

bool_df = pd.DataFrame({'c1':[True,False],'c4':[True,False]},index=['a','e'])
df[bool_df]# 一個布爾DataFrame,未出現的值為False
# 
c1	c2	c3
idx1			
a	1.0	NaN	NaN
b	NaN	NaN	NaN
c	NaN	NaN	NaN
d	NaN	NaN	NaN

（2）對於`DataFrame`的賦值與列刪除

將列表或者數組賦值給某個列時，其長度必須跟DataFrame的行數匹配。
將標量賦值給某個列時，會將標量擴充
將Series賦值給某個列時，會精確匹配DataFrame的索引。如果DataFrame中某個label在Series中找不到，則賦值NaN（空位都將被填上缺失值）
為不存在的列賦值會創建出一個新列（必須用字典的形式，不能用屬性賦值的形式）
關鍵字del用於刪除列（必須用字典的形式，不能用屬性賦值的形式）

舉例：

import numpy as np
import pandas as pd

df = pd.DataFrame(np.arange(0,12).reshape(3,4),index=['a','b','c'],columns=['c1','c2','c3','c4'])
df
# 	c1	c2	c3	c4
a	0	1	2	3
b	4	5	6	7
c	8	9	10	11

df.c1 = [-1,-4,-8] # 長度匹配
df
# c1	c2	c3	c4
a	-1	1	2	3
b	-4	5	6	7
c	-8	9	10	11

df.c2 = -2 # 可以賦值一個標量,標量擴充
df
#c1	c2	c3	c4
a	-1	-2	2	3
b	-4	-2	6	7
c	-8	-2	10	11 

df.c3 = pd.Series(range(10,14),index=['a','c','d','e']) 
df # Series長度任意，df.cs中的label與Series中的匹配，如果無匹配則賦值NaN
#      c1	c2	c3	c4
a	-1	-2	10.0	3
b	-4	-2	NaN	7
c	-8	-2	11.0	11

df['c5'] = [-1,-2,-3] # 創建一個新列
df
# c1	c2	c3	c4	c5
a	-1	-2	10.0	3	-1
b	-4	-2	NaN	7	-2
c	-8	-2	11.0	11	-3

del df['c5']
df
# c1	c2	c3	c4
a	-1	-2	10.0	3
b	-4	-2	NaN	7
c	-8	-2	11.0	11

4.注意事項

（1）對於Series/DataFrame切片方式的索引，返回的結果與原始對象共享基礎數據。對於采用其他方式的索引，返回的結果並不與元素對象共享基礎數據。

idx = pd.Index(['a','b','c','d'],name='index1')
s = pd.Series([1,3,5,7],index=idx,name='sr1')
s
# index1
a    1
b    3
c    5
d    7
Name: sr1, dtype: int64

r = s[1:] # 切片形式
print(r.values.base is s.values)
r = s[[1,2]] # 序列/數組形式
print(r.values.base is s.values)
# True
False

df = pd.DataFrame({'c1':[1,3,5,6],'c2':[1,2,3,4],'c3':[1,2,5,9]},index=idx)
df
# 	c1	c2	c3
index1			
a	1	1	1
b	3	2	2
c	5	3	5
d	6	4	9

r = df.c1 # 引用一列
print(r.values.base is df.values.base)
r = df['c1':'c3'] # 切片形式
print(r.values.base is df.values.base)
r = df[['c1','c2']] # 序列/數組形式
print(r.values.base is df.values.base)
# True
True
False

（2）如果Series/DataFrame的索引有重復label，則數據的選取行為將有所不同：

如果索引對應多個label，則Series返回一個Sereis，DataFrame返回一個DataFrame
如果索引對應單個label，則Series返回一個標量值，DataFrame返回一個Series

你可以通過Index.is_unique屬性得知索引是否有重復的。

對於[]、字典索引、屬性索引或者.loc/.ix存取器，結論如上所述
對於.at存取器：如果索引對應單個label，索引結果正常。如果索引對應多個label，則Series返回一個一維ndarray；DataFrame則拋出異常。

舉例：

import numpy as np
import pandas as pd

idx = pd.Index(['a','a','c','d'],name='idx1')
s = pd.Series([1,5,3,7],index=idx,name='sr1') # 有重復值
s
# idx1
a    1
a    5
c    3
d    7
Name: sr1, dtype: int64

print(s.c,s.a,s.index.is_unique,sep='\n-----\n') # 重復的index返回Series
# 3
-----
a    1
a    5
Name: sr1, dtype: int64
-----
False

print(s.loc['a'],s.at['a'],s.ix['a'],sep='\n------\n') # 重復的index
# idx1
a    1
a    5
Name: sr1, dtype: int64
------
[1 5]
------
idx1
a    1
a    5
Name: sr1, dtype: int64

idx = pd.Index(['a','b','c','d'],name='idx1')
df = pd.DataFrame({'c1':[1,3,2,4],'c2':[11,14,13,12]},index=idx)
# df.columns = pd.Index(['c1','c1'],name='idx2')
df
#	c1	c2
idx1		
a	1	11
b	3	14
c	2	13
d	4	12

df.columns = pd.Index(['c1','c1'],name='idx2')
df
# 
idx2	c1	c1
idx1		
a	1	11
b	3	14
c	2	13
d	4	12

df.index
# Index(['a', 'b', 'c', 'd'], dtype='object', name='idx1')

print(df.c1,s.index.is_unique,sep='\n-------\n') # 重復的index，返回DataFrame
# idx2  c1  c1
idx1        
a      1  11
b      3  14
c      2  13
d      4  12
-------
False

print(df.loc[:,'c1'],df.ix[:,'c1'],sep='\n--------\n') # 重復的index
# idx2  c1  c1
idx1        
a      1  11
b      3  14
c      2  13
d      4  12
--------
idx2  c1  c1
idx1        
a      1  11
b      3  14
c      2  13
d      4  12

（3）對於Series/DataFrame，它們可以使用ndarray的接口。因此可以通過ndarray 的索引規則來索引它們。

df=pd.DataFrame(...)
df[:,0] #使用了 ndarray 的索引方式

二、loc/iloc/ix 存取器

1.loc

（1）Series

對於Series，.loc[]的下標對象可以為：

單個label，此時返回對應的值
label的array-like、label slice以及布爾array-like：返回對應值組成的Series

舉例：

import numpy as np
import pandas as pd

idx = pd.Index(['a','b','c','d'],name='idx1')
s = pd.Series([0,3,5,7],index=idx,name='ser1')
s
# idx1
a    0
b    3
c    5
d    7
Name: ser1, dtype: int64

print(s.loc['a'],s.loc['a':'c'],s.loc[['a','c']],s.loc[[True,True,False,False]],sep='\n-------------\n') #單個Label，切片label，label列表
# 0
-------------
idx1
a    0
b    3
c    5
Name: ser1, dtype: int64
-------------
idx1
a    0
c    5
Name: ser1, dtype: int64
-------------
idx1
a    0
b    3
Name: ser1, dtype: int64

（2）DataFrame

對於DataFrame，.loc[]的下標對象是一個元組，其中兩個元素分別與DataFrame的兩個軸對應。如果下標不是元組，則該下標對應的是第0軸，第一軸為默認值:。

每個軸的下標都支持單個label、label array-like、label slice、布爾array-like。
若獲取的是某一列或者某一行，則返回的是Series；若返回的是多行或者多列，則返回的是DataFrame；如果返回的是某個值，則是普通的標量。

舉例：

df = pd.DataFrame({'c1':[1,2,3,4],'c2':[5,6,7,8],'c3':[9,10,11,12]},index=idx)
df
# 	c1	c2	c3
idx1			
a	1	5	9
b	2	6	10
c	3	7	11
d	4	8	12

print(df.loc['a'],df.loc['a':'c'],df.loc[['a','c']],df.loc[[True,False,True,False]],sep='\n---------\n')
# 下標為元組，這里第二個元素默認為':'
# 單個Label，切片label，label列表，布爾數組
# c1    1
c2    5
c3    9
Name: a, dtype: int64
---------
      c1  c2  c3
idx1            
a      1   5   9
b      2   6  10
c      3   7  11
---------
      c1  c2  c3
idx1            
a      1   5   9
c      3   7  11
---------
      c1  c2  c3
idx1            
a      1   5   9
c      3   7  11

print(df.loc['a','c1'],df.loc['a':'c','c1'],df.loc[['a','c'],'c1':'c2'],df.loc[[True,False,True,False],[True,False,False]],sep='\n---------\n')
# 下標為元組，第一個為0軸，第二個為1軸
# 1
---------
idx1
a    1
b    2
c    3
Name: c1, dtype: int64
---------
      c1  c2
idx1        
a      1   5
c      3   7
---------
      c1
idx1    
a      1
c      3

2.iloc

.iloc[]和.loc[]類似，但是.iloc[]使用整數下標，而不是使用label。注意整數切片不包括最后一個值。

（1）Serise

import numpy as np
import pandas as pd

idx = pd.Index(['a','b','c','d'],name='idx1')
s = pd.Series([0,3,5,7],index=idx,name='ser1')
s
# idx1
a    0
b    3
c    5
d    7
Name: ser1, dtype: int64

print(s.iloc[0],s.iloc[0:1],s.iloc[[0,1,2]],s.iloc[[True,False,True,False]],sep='\n-----\n')
# iloc使用整數下標而不是label
# 0
-----
idx1
a    0
Name: ser1, dtype: int64
-----
idx1
a    0
b    3
c    5
Name: ser1, dtype: int64
-----
idx1
a    0
c    5
Name: ser1, dtype: int64

（2）DataFrame

df = pd.DataFrame({'c1':[1,2,3,4],'c2':[5,6,7,8],'c3':[9,10,11,12]},index=idx)
df
# c1	c2	c3
idx1			
a	1	5	9
b	2	6	10
c	3	7	11
d	4	8	12

print(df.iloc[0],df.iloc[0:2],df.iloc[[0,2]],df.iloc[[True,False,True,False]],sep='\n--------\n')
# 下標為元組，這里第二個元素默認為':'，# iloc使用整數下標而不是label
# c1    1
c2    5
c3    9
Name: a, dtype: int64
--------
      c1  c2  c3
idx1            
a      1   5   9
b      2   6  10
--------
      c1  c2  c3
idx1            
a      1   5   9
c      3   7  11
--------
      c1  c2  c3
idx1            
a      1   5   9
c      3   7  11

print(df.iloc[0,0],df.iloc[0:2,0],df.iloc[[0,2],0:1],df.iloc[[True,False,True,False],[True,False,False]],sep='\n--------\n')
# 下標為元組，這里第二個元素默認為':'， iloc使用整數下標而不是label
# 1
--------
idx1
a    1
b    2
Name: c1, dtype: int64
--------
      c1
idx1    
a      1
c      3
--------
      c1
idx1    
a      1
c      3

`3.ix`

.ix[]存取器綜合了.iloc/.loc：它可以混合使用label和位置下標。注意：如果有整數索引，則應該使用.loc/.iloc從而避免混淆

（1）Series

import numpy as np
import pandas as pd

idx = pd.Index(['a','b','c','d'],name='idx1')
s = pd.Series([0,3,5,7],index=idx,name='ser1')
s
# idx1
a    0
b    3
c    5
d    7
Name: ser1, dtype: int64

print(s.ix[0],s.ix['a':'b'],s.ix[[0,1,2]],s.ix[[True,False,True,False]],sep='\n------\n')
# ix混合使用整數下標和label
# 0
------
idx1
a    0
b    3
Name: ser1, dtype: int64
------
idx1
a    0
b    3
c    5
Name: ser1, dtype: int64
------
idx1
a    0
c    5
Name: ser1, dtype: int64

（2）DataFrame

df = pd.DataFrame({'c1':[1,2,3,4],'c2':[5,6,7,8],'c3':[9,10,11,12]},index=idx)
df
# c1	c2	c3
idx1			
a	1	5	9
b	2	6	10
c	3	7	11
d	4	8	12

print(df.ix['a'],df.ix['a':'c'],df.ix[[0,2]],df.ix[[True,False,True,False]],sep='\n---------\n')
# 下標為元組,這里第二個元素默認為'':，ix默認使用整數下標和label
# c1    1
c2    5
c3    9
Name: a, dtype: int64
---------
      c1  c2  c3
idx1            
a      1   5   9
b      2   6  10
c      3   7  11
---------
      c1  c2  c3
idx1            
a      1   5   9
c      3   7  11
---------
      c1  c2  c3
idx1            
a      1   5   9
c      3   7  11

print(df.ix[0,'c1'],df.ix['a':'b',0],df.ix[['a','c']],df.ix[[True,False,True,False],[True,False,False]],sep='\n---------\n')
# 下標為元組，第一個為0周，第二個為1軸，ix混合使用整數下標和label
# 1
---------
idx1
a    1
b    2
Name: c1, dtype: int64
---------
      c1  c2  c3
idx1            
a      1   5   9
c      3   7  11
---------
      c1
idx1    
a      1
c      3

4.注意

（1）Index對象不能使用loc/iloc/ix存取器

（2）對於.loc/.iloc/.ix：

如果某軸的索引為array-like或者布爾array-like，則返回的結果與原來的對象不再共享基礎數據；
如果軸的索引全部都是slice或者單個整數、單個label，則返回的結果與原來的對象共享基礎數據。

idx = pd.Index(['a','b','c','d'],name='idx1')
df = pd.DataFrame({'c1':[1,2,3,4],'c2':[5,6,7,8],'c3':[9,10,11,12]},index=idx)
df
# c1	c2	c3
idx1			
a	1	5	9
b	2	6	10
c	3	7	11
d	4	8	12

r1 = df.ix[0,0] # 都是整數
r2 = df.loc['a',:] # 一個切片
r3 = df.iloc[:,0] # 一個切片
r4 = df.ix[: , :] # 兩個切片
r5 = df.ix[0,[0,1]] # 一個列表
r6 = df.loc[: , ['c1','c2']] # 一個列表
r7 = df.iloc[[0,1],[0,1]] # 兩個列表
(type(r1),# 都是整數
r2.values.base is df.values.base, # 一個切片
r3.values.base is df.values.base, # 一個切片
r4.values.base is df.values.base, # 一個切片
r5.values.base is df.values.base, # 一個切片
r6.values.base is df.values.base, # 一個切片
r7.values.base is df.values.base, # 一個切片
)
# (numpy.int64, True, True, True, False, False, False)

三、at/iat 存取器

1..at和.iat分別使用label和整數下標獲取單個值。它類似於.loc/.iloc，但是.at/.iat的速度更快

每個索引只能是單個label或者單個整數

舉例：

import numpy as np
import pandas as pd

idx = pd.Index(['a','b','c','d'],name='idx1')
s = pd.Series([1,3,5,7],index=idx,name='ser1')
s
# idx1
a    1
b    3
c    5
d    7
Name: ser1, dtype: int64

print(s.at['a'],s.iat[0]) # at使用label獲取單個值,iat使用整數獲取單個值
# 1 1

idx = pd.Index(['a','b','c','d'],name='idx1')
df = pd.DataFrame({'c1':[1,2,3,4],'c2':[5,6,7,8],'c3':[9,10,11,12]},index=idx)
df
# 	c1	c2	c3
idx1			
a	1	5	9
b	2	6	10
c	3	7	11
d	4	8	12

2.對於DataFrame，.lookup(row_labels, col_labels)類似於：.loc[row_labels, col_labels]，但是.lookup返回的是一維ndarray。

要求row_labels和col_labels長度相同。(row_labels[0],col_labels[0]決定了結果中第一個元素的位置，...(row_labels[i],col_labels[i]決定了結果中第 i+1個元素的位置，

舉例：

import numpy as np
import pandas as pd

df=pd.DataFrame(np.arange(0,12).reshape(3,4),index=['a','b','c'],columns=['c1','c2','c3','c4'])
df
# c1	c2	c3	c4
a	0	1	2	3
b	4	5	6	7
c	8	9	10	11

df.lookup(['a','b'],['c1','c2'])
# array([0, 5])

df.loc[['a','b'],['c1','c2']]
# 	c1	c2
a	0	1
b	4	5

3.DataFrame.get_value(index, col, takeable=False)等價於.loc[index, col]，它返回單個值。而Series.get_value(label, takeable=False)等價於.loc[label]，它也返回單個值

舉例：

import numpy as np
import pandas as pd

idx = pd.Index(['a','b','c','d'],name='idx1')
s = pd.Series([0,1,2,3],index=idx,name='ser1')
s
# idx1
a    0
b    1
c    2
d    3
Name: ser1, dtype: int64

s.get_value('a') # 返回單個值
# 0

idx = pd.Index(['a','b','c','d'],name='idx1')
df = pd.DataFrame({'c1':[1,2,3,4],'c2':[5,6,7,8],'c3':[9,10,11,12]},index=idx)
df
# 	c1	c2	c3
idx1			
a	1	5	9
b	2	6	10
c	3	7	11
d	4	8	12

df.get_value('a','c2') # 返回單個值
# 5

4..get(key[, default])方法與字典的get()方法的用法相同。對於DataFrame，key為col_label

舉例：

import numpy as np
import pandas as pd

idx = pd.Index(['a','b','c','d'],name='idx1')
s = pd.Series([0,1,2,3],index=idx,name='ser1')
s
# idx1
a    0
b    1
c    2
d    3
Name: ser1, dtype: int64

s.get('a'),s.get('e',-1)
# (0, -1)

idx = pd.Index(['a','b','c','d'],name='idx1')
df = pd.DataFrame({'c1':[1,2,3,4],'c2':[5,6,7,8],'c3':[9,10,11,12]},index=idx)
df
# c1	c2	c3
idx1			
a	1	5	9
b	2	6	10
c	3	7	11
d	4	8	12

df.get('c1'),df.get('e',-1)
# (idx1
 a    1
 b    2
 c    3
 d    4
 Name: c1, dtype: int64, -1)

5..head([n=5])和.tail([n=5])返回頭部/尾部n行數據

四、query方法

1.對於DataFrame，當需要根據一定的條件對行進行過濾時，通常可以先創建一個布爾數組，然后使用該數組獲取True對應的行。另一個方案就是采用query(expr, inplace=False, **kwargs)方法：

expr是個運算表達式字符串，如'label1 >3 and label2<5'
表達式中的變量名表示對應的列，可以使用not/and/or等關鍵字進行向量布爾運算。該方法會篩選出那些滿足條件的行。
如果希望在表達式中使用Python變量，則在變量名之前使用@
inplace是個布爾值，如果為True，則原地修改。否則返回一份拷貝。

舉例：

import numpy as np
import pandas as pd

idx = pd.Index(['a','b','c','d'],name='idx1')
df = pd.DataFrame({'c1':[1,2,3,4],'c2':[5,6,7,8],'c3':[9,10,11,12]},index=idx)
df
# 	c1	c2	c3
idx1			
a	1	5	9
b	2	6	10
c	3	7	11
d	4	8	12

r = df.query('c1+c2<10')
print(r,df,sep='\n------\n') # 非原地修改 
#       c1  c2  c3
idx1            
a      1   5   9
b      2   6  10
------
      c1  c2  c3
idx1            
a      1   5   9
b      2   6  10
c      3   7  11
d      4   8  12

r = df.query('c1+c2<10',inplace=True) # 原地修改 
print(r,df,sep='\n------\n')
# None
------
      c1  c2  c3
idx1            
a      1   5   9
b      2   6  10

c1 = 3
df.query('c1==@c1') # 使用python變量
# 	c1	c2	c3
idx1			
c	3	7	11

五、多級索引

1.對於.loc/.ix/[]，其下標可以指定多級索引中，每級索引上的標簽。

多級索引軸對應的下標是一個下標元組，該元組中每個元素與索引中每級索引對應
如果下標不是元組，則將其轉換成長度為1的元組
如果元組的長度比索引的層數少，則在其后面補充slice(None)

舉例：

import numpy as np
import pandas as pd
levels = [['a','b'],['c','d']]
labels = [[0,1,0,1],[0,0,1,1]]
idx = pd.MultiIndex(levels=levels,labels=labels,names=['lv1','lv2'])
s = pd.Series([1,2,3,4],index=idx,name='ser1')

s
# lv1  lv2
a    c      1
b    c      2
a    d      3
b    d      4
Name: ser1, dtype: int64

s.ix[(0,0)],s.loc[('a','c')] # 下標索引為元組
# (1, 1)

df = pd.DataFrame({'c1':[1,2,3,4],'c2':[5,6,7,8],'c3':[9,10,11,12]},index=idx)
df
# 	c1	c2	c3
lv1	lv2			
a	c	1	5	9
b	c	2	6	10
a	d	3	7	11
b	d	4	8	12

print(df.loc['a',['c1','c2']],df.loc[('a',slice(None)),['c1','c2']],sep='\n----------\n')
# 二者等價
# c1  c2
lv2        
c     1   5
d     3   7
----------
         c1  c2
lv1 lv2        
a   c     1   5
    d     3   7

df.loc[(slice(None),'c'),['c1','c2']] # 0軸的level為:
# c1	c2
lv1	lv2		
a	c	1	5
b	c	2	6

print(s['a'],s[:,'c'],s['a','c'],sep='\n-------------------------\n')#使用[]索引
# lv2
c    1
d    3
Name: ser1, dtype: int64
-------------------------
lv1
a    1
b    2
Name: ser1, dtype: int64
-------------------------
1

六、整數 label

1.label不一定是字符串，也有可能是整數（如RangeIndex/Int64Index等），尤其是當label是自動生成的時候。

當你的label是整數時，面向整數的下標索引總是面向label的，而不是面向position的。因此推薦使用.loc來基於label索引，使用.iloc來基於position索引。

舉例：

import numpy as np
import pandas as pd

s1 = pd.Series([11,12,15,17]) # 自動生成index
s2 = pd.Series([21,22,25,27],index=[1,3,5,7]) # 整數index
s3 = pd.Series([31,32,35,37],index=['a','b','c','d'])#字符串index
print(s1,s2,s3,sep='\n------------------------\n')

0    11
1    12
2    15
3    17
dtype: int64
------------------------
1    21
3    22
5    25
7    27
dtype: int64
------------------------
a    31
b    32
c    35
d    37
dtype: int64
\n------------------------\n
print(s1.index,type(s1.index),
    s2.index,type(s2.index),
    s3.index,type(s3.index),sep='\n------------------------\n')
RangeIndex(start=0, stop=4, step=1)
------------------------
<class 'pandas.core.indexes.range.RangeIndex'>
------------------------
Int64Index([1, 3, 5, 7], dtype='int64')
------------------------
<class 'pandas.core.indexes.numeric.Int64Index'>
------------------------
Index(['a', 'b', 'c', 'd'], dtype='object')
------------------------
<class 'pandas.core.indexes.base.Index'>
 # 面向position
print(s2[7], # 面向label
      s3[0]) # 面向position
27 31
 #面向position
print(s2.loc[7],#面向label
      s2.iloc[-1],#面向position
      s3.loc['d'],#面向label
      s3.iloc[-1] #面向position
     )
27 27 37 37

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 pandas索引操作之loc，iloc，ix等方法 pandas DataFrame的查詢方法（loc,iloc,at,iat,ix的用法和區別） pandas之loc iloc ix DataFrame的查詢方法（loc,iloc,at,iat,ix的用法和區別） pandas (loc、iloc、ix)的區別 pandas (loc、iloc、ix)的區別 python pandas （ix & iloc &loc）的區別 python數據分析之pandas數據選取：df[] df.loc[] df.iloc[] df.ix[] df.at[] df.iat[] 在Pandas DataFrames中選擇行和列使用iloc，loc和ix Pandas：Series、DataFrame數據的loc、iloc、ix 查詢 / 讀取

Pandas---3.下標存取([]/loc/iloc/ix/at/iat/query方法/多級索引/整數label)

一、[ ] 操作符

1.Index

2.Series

（1）[]

（2）索引標簽

（3）對於Series的賦值與刪除

3.DataFrame

（1）[]

（2）對於DataFrame的賦值與列刪除

4.注意事項

二、loc/iloc/ix 存取器

1.loc

（1）Series

（2）DataFrame

2.iloc

（1）Serise

（2）DataFrame

3.ix

（1）Series

（2）DataFrame

4.注意

三、at/iat 存取器

四、query方法

五、多級索引

六、整數 label

免責聲明！

（3）對於`Series`的賦值與刪除

（2）對於`DataFrame`的賦值與列刪除

`3.ix`