【数据处理包Pandas】DataFrame数据选择的基本方法

目录

• • 一、选择行/列
  • • （一）读取文件
    • （二）选择行
    • （三）选择列
    • （四）选择多行多列
  • 二、带条件筛选
  • • （一）startswith()方法
    • （二）mean()方法
    • （三）columns属性
    • （四）apply()方法
    • （五）copy()方法
    • （六）groupby()方法

---

首先导入 NumPy 和 Pandas 库。

import numpy as np
import pandas as pd

数据集team.xlsx下载地址：下载team.xlsx

一、选择行/列

（一）读取文件

pd.read_excel()格式：pandas.read_excel(io, sheetname, header=0, index_col=None, names=None, dtype)

参数名称	说明
io	接收string ，表示文件路径，无默认
sheetname	接收string、int，代表excel表内数据的分表位置，默认为0
header	接收int或sequence，表示将某行数据作为列名，默认为infer，表示自动识别
names	接收int、sequence或者False，表示索引列的位置，取值为sequence则代表多重索引，默认为None
index_col	接收int、sequence或者False，表示索引列的位置，取值为sequence则代表多重索引，默认为None
dtype	接收dict，代表写入的数据类型（列名为key，数据格式为values），默认为None

df = pd.read_excel('team.xlsx')
df

（二）选择行

选取通过 DataFrame 提供的head和tail方法可以得到多行数据，但是用这两种方法得到的数据都是从开始或者末尾获取连续的数据， 而利用sample可以随机抽取数据并显示。

• head()：认获取前 5 行
• head(n)：获取前 n 行
• tail()：默认获取后 5 行
• tail(n)：获取后 n 行
• sample(n)：随机抽取 n 行显示

df.head(10)

（三）选择列

选择列的方法主要基于把 DataFrame 看成字典的观点。

1、选择单列

# 选择单列
# df['team']
df['team'].unique()

unique()方法：去掉重复值

array(['E', 'C', 'A', 'D', 'B'], dtype=object)

2、选择多列

# 选择多列
df[['name','Q1']].head(6)

（四）选择多行多列

1、使用位置索引器iloc

选择行的方法主要基于把 DataFrame 看成二维数组的观点。选择多行多列，使用位置索引器iloc，行列下标的位置上都允许切片和花式索引。

df.iloc[3:5,[0,2]]

为了使用标签索引，需要先判断name列的取值是否唯一。判断姓名是否有重名。

# df['name'].unique().shape
df['name'].unique().shape==df['name'].shape  

True

发现无重名，则可以把name作为行索引Index。

df.set_index('name',inplace=True)
df.head(10)

2、使用标签索引器loc

选择多行多列，使用标签索引器loc，行列下标的位置上都允许切片和花式索引。

df.loc['Eorge':'Harlie','Q1':'Q4']

注意：使用切片时，位置索引不包含终值，而标签索引却包含终值。

3、使用ix索引器

也可以用ix索引器，混合使用位置和标签索引，但不建议这样做。

df.ix[3:5,'Q1':'Q4']

C:\Users\Administrator\Anaconda3\lib\site-packages\ipykernel_launcher.py:2: DeprecationWarning: 
.ix is deprecated. Please use
.loc for label based indexing or
.iloc for positional indexing

See the documentation here:
http://pandas.pydata.org/pandas-docs/stable/indexing.html#ix-indexer-is-deprecated

二、带条件筛选

（一）startswith()方法

1、选择 DataFrame df中索引值以字母'A'开头的所有行，并选择'team'列：

# 带条件筛选
df.loc[df.index.str.startswith('A'),'team']

2、选择 DataFrame df中索引值以字母 'A' 开头的所有行，并选择所有列：

# loc中使用函数筛选满足条件的行
df.loc[lambda x:x.name.str.startswith('A'),:]

将整个 DataFrame 对象作为实参传递给形参x，注意x的行索引是整数。

（二）mean()方法

比较 DataFrame 中列'Q1'的每个元素是否大于或等于'Q1'列的平均值：

df['Q1']>=df['Q1'].mean()

它的返回结果将是一个布尔类型的 Series，其中每个元素对应于相应的 'Q1' 列元素是否大于或等于 'Q1' 列的平均值。

0      True
1     False
2      True
3      True
4      True
5     False
6      True
7     False
8      True
9      True
10    False
11    False
12     True
13     True
14     True
15    False
16     True
17     True
18     True
19     True
20     True
21     True
22    False
23     True
24     True
25     True
26     True
27     True
28     True
29    False
      ...  
70     True
71     True
72    False
73    False
74     True
75     True
76     True
77     True
78    False
79     True
80     True
81    False
82    False
83     True
84     True
85    False
86    False
87    False
88     True
89    False
90    False
91     True
92     True
93    False
94    False
95    False
96    False
97     True
98    False
99    False
Name: Q1, Length: 100, dtype: bool

（三）columns属性

获取 DataFrame 中倒数第四列及其后面的所有列的列名：

df.columns[-4:]

df.columns返回一个包含 DataFrame 中所有列名的 Index 对象。通过索引-4:，获取了倒数第四列及其后面的所有列的列名。

Index(['Q1', 'Q2', 'Q3', 'Q4'], dtype='object')

（四）apply()方法

使用apply()函数，它会对 DataFrame 的每一列应用指定的函数。

df1 = df.apply(lambda x: np.sum(x) if x.name.startswith('Q') else print(x.name))  #默认一次处理一列
df1

• 对于以 'Q' 开头的列，lambda x: np.sum(x)函数会计算该列的总和。
• 对于其他列，print(x.name)函数会打印列的名称。

然而，需要注意的是，apply()函数返回的是一个 Series，其中包含每一列的处理结果。这意味着，对于那些不以 'Q' 开头的列，由于print(x.name)函数没有返回值，因此相应位置的结果会是 NaN。另外，可能想要使用axis=0参数来指定apply()函数按列而不是按行进行操作。

（五）copy()方法

df2 = df.copy()
df2

首先通过df.copy()创建了 DataFrame df的副本df2。这样做是为了避免在对df2进行操作时影响到原始的 DataFrame df。

副本df2与原始的 DataFrame df具有相同的数据和结构，但它们是独立的对象，对其中一个对象的操作不会影响另一个对象。因此，通过这样的方式可以安全地对df2进行任何需要的修改或处理。

对 DataFrame df2中的每一行，从 'Q1' 到 'Q4' 列的值进行求和：

df2.apply(lambda x:sum(x['Q1':'Q4']),axis=1)  # 一次处理一行

使用了apply()函数，对 DataFrame 中的每一行进行操作。

其中lambda x: sum(x['Q1':'Q4'])表示对每一行从 'Q1' 到 'Q4' 列进行求和操作。而axis=1参数指定了按行操作。

因此，该代码将会对 DataFrame df2中的每一行，从 'Q1' 到 'Q4' 列的值进行求和，并返回一个包含每一行求和结果的 Series。

name
Liver       198
Arry        167
Ack         219
Eorge       338
Oah         261
Harlie      167
Acob        258
Lfie        155
Reddie      286
Oscar       179
Leo         133
Logan       198
Archie      299
Theo        251
Thomas      225
James       188
Joshua      177
Henry       198
William     177
Max         216
Lucas       240
Ethan       301
Arthur      179
Mason       251
Isaac       190
Harrison    195
Teddy       231
Finley      287
Daniel      233
Riley       203
           ... 
Nathan      239
Blake       203
Luke6       306
Elliot      130
Roman       143
Stanley     276
Dexter      240
Michael     261
Elliott     133
Tyler       198
Ryan        257
Ellis       187
Finn         92
Albert0     181
Kai         172
Liam        131
Calum       203
Louis2      180
Aaron       234
Ezra        219
Leon        136
Connor      209
Grayson7    250
Jamie0      275
Aiden       181
Gabriel     268
Austin7     125
Lincoln4    212
Eli         234
Ben         179
Length: 100, dtype: int64

（六）groupby()方法

1、将 DataFrame 按照'team'列进行分组，并对每个分组应用了一个函数：

df.groupby('team').apply(lambda x :print(x))

这段代码使用了groupby()函数将 DataFrame 按照'team'列进行分组，并对每个分组应用了一个函数。

在这个例子中，使用了一个lambda函数，它接受每个分组作为输入，并将其打印出来。print(x)语句会打印每个分组的内容。

请注意，这段代码在每个分组中都会打印出该分组的内容，而不会返回任何值。

        team  Q1  Q2  Q3  Q4
name                        
Ack        A  57  60  18  84
Lfie       A   9  10  99  37
Oscar      A  77   9  26  67
Joshua     A  63   4  80  30
Henry      A  91  15  75  17
Lucas      A  60  41  77  62
Arthur     A  44  53  42  40
Reggie1    A  30  12  23   9
Toby       A  52  27  17  68
Dylan      A  86  87  65  20
Hugo0      A  28  25  14  71
Caleb      A  64  34  46  88
Nathan     A  87  77  62  13
Blake      A  78  23  93   9
Stanley    A  69  71  39  97
Tyler      A  75  16  44  63
Aaron      A  96  75  55   8
        team  Q1  Q2  Q3  Q4
name                        
Ack        A  57  60  18  84
Lfie       A   9  10  99  37
Oscar      A  77   9  26  67
Joshua     A  63   4  80  30
Henry      A  91  15  75  17
Lucas      A  60  41  77  62
Arthur     A  44  53  42  40
Reggie1    A  30  12  23   9
Toby       A  52  27  17  68
Dylan      A  86  87  65  20
Hugo0      A  28  25  14  71
Caleb      A  64  34  46  88
Nathan     A  87  77  62  13
Blake      A  78  23  93   9
Stanley    A  69  71  39  97
Tyler      A  75  16  44  63
Aaron      A  96  75  55   8
         team  Q1  Q2  Q3  Q4
name                         
Acob        B  61  95  94   8
Leo         B  17   4  33  79
Logan       B   9  89  35  65
Thomas      B  80  48  56  41
Harrison    B  89  13  18  75
Edward      B  57  38  86  87
Samuel      B   9  38  88  66
Elijah      B  97  89  15  46
Harley      B   2  99  12  13
Jenson      B  66  77  88  74
Frankie     B  18  62  52  33
David       B  21  47  99   2
Lewis       B   4  34  77  28
Ronnie      B  53  13  34  99
Harvey2     B  43  76  87  90
Michael     B  89  21  59  92
Elliott     B   9  31  33  60
Albert0     B  85  38  41  17
Kai         B  66  45  13  48
Liam        B   2  80  24  25
Grayson7    B  59  84  74  33
Jamie0      B  39  97  84  55
          team  Q1  Q2  Q3  Q4
name                          
Arry         C  36  37  37  57
Eorge        C  93  96  71  78
Harlie       C  24  13  87  43
Archie       C  83  89  59  68
Theo         C  51  86  87  27
William      C  80  68   3  26
Daniel       C  50  50  72  61
Alexander    C  91  76  26  79
Adam         C  90  32  47  39
Sebastian    C   1  14  68  48
Tommy        C  29  44  28  76
Jake3        C  69  23  11  40
Ollie3       C  10  76  30  36
Matthew      C  44  33  41  98
Elliot       C  15  17  76  22
Ellis        C  34  34  77  42
Calum        C  14  91  16  82
Louis2       C  13  94  51  22
Connor       C  62  38  63  46
Gabriel      C  48  59  87  74
Austin7      C  21  31  30  43
Lincoln4     C  98  93   1  20
          team  Q1  Q2  Q3  Q4
name                          
Oah          D  65  49  61  86
Reddie       D  64  93  57  72
Ethan        D  79  45  89  88
Mason        D  80  96  26  49
Finley       D  62  73  84  68
Benjamin     D  15  88  52  25
Louie        D  24  84  54  11
Carter7      D  57  52  77  50
Bobby1       D  50  55  60  59
Albie1       D  79  82  56  96
Luca         D   5  40  91  83
Alex         D  14  70  55  87
Reuben       D  70  72  76  56
Jayden6      D  64  21  10  21
Hunter3      D  38  80  82  40
Theodore3    D  43   7  68  80
Luke6        D  15  97  95  99
Ezra         D  16  56  86  61
Aiden        D  20  31  62  68
         team  Q1  Q2  Q3  Q4
name                         
Liver       E  89  21  24  64
James       E  48  77  52  11
Max         E  97  75  41   3
Isaac       E  74  23  28  65
Teddy       E  71  91  21  48
Riley       E  35  26  59  83
Joseph      E  67  87  87  93
Jaxon       E  88  98  19  98
Arlo8       E  48  34  52  51
Jude        E   8  45  13  65
Rory9       E   8  12  58  27
Zachary     E  12  71  85  93
Jackson5    E   6  10  15  33
Roman       E  73   1  25  44
Dexter      E  73  94  53  20
Ryan        E  92  70  64  31
Finn        E   4   1  55  32
Leon        E  38  60  31   7
Eli         E  11  74  58  91
Ben         E  21  43  41  74

2、使用 NumPy 的np.max()函数计算每个分组中的最大值：

df.groupby('team').apply(lambda x :np.max(x))  # 一次传一组

结果是一个包含每个分组最大值的 DataFrame。

3、返回一个包含每个分组中 'Q1' 和 'Q4' 列的最大值：

df.groupby('team')['Q1','Q4'].apply(max)

对 DataFrame df根据 'team' 列进行分组，然后对每个分组中的 'Q1' 和 'Q4' 列应用了max()函数，以找到每个组中 'Q1' 和 'Q4' 列的最大值。

如果 'Q1' 和 'Q4' 列中包含数值数据，那么该操作将返回一个包含每个分组中 'Q1' 和 'Q4' 列的最大值的 Series 对象。