pandas選擇單元格，選擇行列

首先創建示例df：

df = pd.DataFrame(np.arange(16).reshape(4, 4), columns=list('ABCD'), index=list('5678'))

df：

    A   B   C   D
5   0   1   2   3
6   4   5   6   7
7   8   9  10  11
8  12  13  14  15

注意：df的index是str類型，如果不指定index默認是0開始的int類型

 

分為如下幾個方面進行討論：

1）loc，行名稱列名稱

2）iloc，行數列數

3）ix，行名稱列名稱/行數列數混合

4）df[]

5)  df.x，選擇單列

6）Series的篩選方法

7）bool

8）reindex

最后，再補充了獲取行列名稱，和缺失值處理的方法

 

1，loc，行名稱列名稱

1.1，行

df.loc['6']           # 行名稱為6的行，即第2行，即4 5 6 7
df.loc['5':'7']       # 行名稱為5至7的行，即前3行，注意是前閉后閉
df.loc[['5', '7']]    # 行名稱為5和7的行，前第1第3行　

 

1.2，列

df.loc[:, 'B']        # 列名稱為'B‘的列，即第2列，1 5 9 13
df.loc[:, 'A':'C']    # 列名稱為A至C的列，即前3列，注意是前閉后閉
df.loc[:, ['A', 'C']] # 列名稱為A和C的列，即第1列第3列

 

1.3，塊

df.loc['5':'7', 'A':'C']       # 行名稱為5至7，列名稱為A~C的一塊數據，即前3行前3列
df.loc[['5', '7'], ['A', 'C']] # 行名稱為5和7，列名稱為A和C的一塊數據 
df.loc['5':'7', ['A', 'C']]    # 行名稱5至7，列名稱A和C的一塊數據
df.loc[['5', '7'], 'A':'C']    # 行名稱為5和7，列名稱為A~C的一塊數據

 

1.4，單元格

df.loc['5', 'A']   # 行名稱為5，列名稱為A的單元格數據
df.at['5', 'A']    # 同loc但速度快點

　　

2，iloc，行數列數

2.1，行

df.iloc[1]          # 第2行，即行名稱為6的行，4 5 6 7
df.iloc[0:3]        # 前3行
df.iloc[[0, 3]]     # 第1第4行

 

2.2，列   

df.iloc[:, 1]       # 第2列，即列名稱為'B'的列，1 4 9 13
df.iloc[:, 0:3]     # 前3列
df.iloc[:, [0, 3]]  # 第1第4列

 

2.3，塊

df.iloc[0:3, 0:3]          # 前3行，前3列的一塊數據
df.iloc[[0, 3],  [0, 3]]   # 第1第4行，第1第4列的一塊數據
df.iloc[0:3, [0, 3]]       # 前3行，第1第4列的一塊數據
df.iloc[[0, 3], 0:3]       # 第1第4行，前3列的一塊數據

 

2.4，單元格

df.iloc[1, 1]   # 第1行，第1列的單元格
df.iat[1, 1]    # 同iloc但速度快點

　　

3，df.ix，行名稱列名稱/行數列數混合

3.1，行

df.ix['7']    # 單行，下同
df.ix[2] 
df.ix[1: 3]   # 多行，下同
df.ix[[1, 3]]
df.ix['5':'7']
df.ix['5', '7']

如果是行/列的名稱是int類型時，只能根據行/列名稱選，不能根據行數/列數選：

df.index = range(1, 5)
df.ix[2]   # 輸出是行名稱為2的行，根據行數選擇應該是第3行
df.index = range(11, 15)  
df.ix[2]   # KeyError: 2　

　　

3.2，列

df.ix[:, 'C']   # 單列，下同
df.ix[:, 2] 
df.ix[:, 1: 3]   # 多列，下同
df.ix[:, [1, 3]]
df.ix[:, 'A':'C']
df.ix[:, ['A','C']]

 

3.3，塊（略）

多行和多列的排列組合

 

3.4，單元格（略）

單行和單列的排列組合

 

4，df[]

4.1，行

可以接收行名稱或者行數，但必須是切片

df[0:1]      # 第1行
df[0:3]      # 前3行 
df['5':'5']  # 行名稱為5的行
df['5':'7']  # 行名稱為5的行至行名稱為7的行

行數切片時，如果行索引類型為int，則會根據行數來切片，不會根據行名稱切片，這點與df.ix不同，例如：

df = pd.DataFrame(np.arange(16).reshape(4, 4), columns=list('ABCD'), index=range(5, 9))
df[5:8]   # Empty DataFrame
df[0:3]   # 第1至第3行

　

4.2，列

只能接收列名稱，可以是單個或列表

df['A']        # A列
df[['A', 'C']] # A和C列

 

4.3，塊

df[]無法選擇塊

 

4.4，單元格

df[]無法選擇單元格

 

5，df.x

df.A   # A列

 

6，Series的篩選方法

上述示例中，接收參數為單個標簽或索引的篩選，返回的都是Series，例如：

df.iloc[1]
df.iloc[:, 2]
df.loc['5']
df.loc[:, 'B']
df.ix[2]
df.ix[:, 'C']
df['A']
df.A

 

接收參數為切片或列表的篩選，即使只有一行/一列數據，返回的都是DataFrame：

df[0:1]
df['5': '5']
df.iloc[[1]]
df.loc[:, ['B']]
df[['A']]

因此，如果想獲取單行/單列數據的DataFrame，只需要將輸入的單個標簽或索引改為切片或列表

 

可以進一步在Series中篩選值，以A列的Series為例：

>>> df['A']
5     0
6     4
7     8
8    12
Name: A, dtype: int32

篩選出Series中第二個值4的方法有：

df['A'].iloc[1] 
df['A'].loc['6']  
df['A'].ix[1]
df['A'].ix['6']
df['A'][1]       
df['A'].values[1]

　

7，bool

7.1，bool列表

上述示例中，DataFrame或者Series可以接受切片/列表參數的地方，都可以接受bool列表，保留bool列表中真值對應的項目，例如：

生成bool列表：

chooses = [True, False, True, False]
chooses = [i == 0 or i == 8 for i in df['A']]  # 結果是[True, False, True, False]

根據bool列表篩選：

df.iloc[chooses]     # 只留第1第3行
df.loc[:, chooses]   # 只留第1第3列
df.ix[chooses]       # 只留第1第3行
df[chooses]          # 只留第1第3行
df['A'][chooses]     # 只留A列中第1第3個值

 

7.2，bool Series　

可以根據bool Series篩選，保留bool Series真值對應的項目，但是index要與df相同

1）按列生成的Series，index是原df的index，可以對行方向操作進行篩選

生成列方向的bool Series：

chooses = pd.Series([True, False, True, False], index=df.index)
chooses = df.loc[:, 'A'] > 1
chooses = df.iloc[:, 0] > 1
chooses = df['A'] > 1
chooses = df['A'] == 4
chooses = ~(df.A == 4)   # 可以直接取反，等效df.A != 4
chooses = ~(df['A'] > 1)
chooses = df['A'].isin(range(9))  # A列的值是否在range(9)中
chooses = (df['A'].isin(range(9))) & (df['B'] > 1)  # bool Series的&運算，即同時滿足A列range(9)內，B列大於1

根據bool Series可以在行方向做篩選，iloc用不了：

print(chooses.index)    # Index(['1', '2', '3', '4'], dtype='object')
df[chooses]             # DataFrame[]
df.A[chooses]           # Series[]
df.loc[chooses]         # loc
df.iloc[chooses]        # 應用在iloc會報錯，ValueError
df = df.ix[chooses]     # ix
df = df.loc[:, chooses] # 應用在列方向會報錯，pandas.core.indexing.IndexingError

如果有多個bool Series可以用“|”（或），“&”（和），例如：

df[(chooses1) | (chooses2)]
df[(chooses1) & (chooses2)]

2）按行生成的Series，index是原df的columns，可以對列方向操作進行篩選

生成行方向的bool Series：

chooses = pd.Series([True, False, True, False], index=df.columns)
chooses = df.loc['1'] > 1
chooses = df.iloc[0] > 1

根據bool Series可以在列方向做篩選，iloc用不了：

print(choose.index)   # Index(['A', 'B', 'C', 'D'], dtype='object')
df.loc[:, chooses]      # loc
df.iloc[:, chooses]     # 應用在iloc會報錯，ValueError
df.ix[:, chooses]       # ix
df.loc[chooses]         # 應用在行方向報錯，pandas.core.indexing.IndexingError

　　

7.3，bool DataFrame

DataFrame可以根據bool DataFrame進行篩選，保留bool DataFrame真值對應的值，其余值置為NaN

生成bool DataFrame：

chooses = df > 5

根據bool DataFrame進行篩選：

df[chooses]

 

8，reindex

DataFrame.reindex也可以用來對行/列進行篩選，它不會修改原DataFrame，需另存副本：

df.reindex(index=list('67'))      # 篩選出行名稱為6和7的行
df.reindex(columns=list('BC'))    # 篩選出列名稱為B和C的列

　　

9，獲取行名稱/列名稱

有時需要獲取符合條件的行名稱或者列名稱

9.1，通過Series獲取

可以先獲取行/列所在的Series，再獲取該Series對應的name：

df.iloc[1].name    # 第2行的name，'6'
df.iloc[:, 1].name # 第2列的name，'B'

 

9.2，通過DataFrame獲取

通過篩選獲得的DataFrame，可以直接獲index，columns

df_sub = df[df['A'] > 4]
df_sub.index            # Index(['7', '8'], dtype='object')
df_sub.columns          # Index(['A', 'B', 'C', 'D'], dtype='object')
df_sub.index.tolist()   # ['7', '8']
df_sub.columns.tolist() # ['A', 'B', 'C', 'D']

　　

10，缺失值處理

df.dropna(axis=0, how='any')   # 行里有缺失值就丟掉，如果行里所有值是缺失值才丟掉可以how='all'
df.dropna(axis=1, how='any')    # 列里有缺失值就丟掉
df.fillna(value=0)  # 將缺失值填為0
df.isnull() # 整個df是否有缺失值的情況，返回結果是df
np.any(df.isnull())=True) # 只要包含有缺失值就返回True，結果是一個bool值

 

歡迎轉載博客文章,轉載請標明出處!