目录
首先导入 NumPy 和 Pandas 库。
import numpy as np
import pandas as pd
数据集team.xlsx下载地址：
链接：https://pan.quark.cn/s/9e3b2a933510
提取码：7i2y
一、选择行/列
（一）读取文件
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 对象。
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
