pandas基础--基本功能

Posted mrlayfolk

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了pandas基础--基本功能相关的知识,希望对你有一定的参考价值。

本节介绍操作Series和DataFrame中的数据的基本手段。

1.1 重新索引

重新索引reindex,其作用是创建一个适应新索引的新对象。调用reindex将会根据新索引进行重排,如果某个索引值当前不存在,就引入缺失值。

 1 >>> obj = pd.Series([4.5, 7.2, -5.3, 3.6], index=[d, b, a, c])
 2 >>> obj
 3 d    4.5
 4 b    7.2
 5 a   -5.3
 6 c    3.6
 7 dtype: float64
 8 >>> obj2 = obj.reindex([a, b, c, d, e]) 
 9 >>> obj2
10 a   -5.3
11 b    7.2
12 c    3.6
13 d    4.5
14 e    NaN
15 dtype: float64
16 >>> obj.reindex([a, b, c, d, e], fill_value=0) 
17 a   -5.3
18 b    7.2
19 c    3.6
20 d    4.5
21 e    0.0
22 dtype: float64
23 >>>

对于时间序列这样的有序数据,重新索引时可能需要做一些插值处理,method选项即可达到此目的。

1 >>> obj3 = pd.Series([blue, purple, yellow], index=[0, 2, 4]) 
2 >>> obj3.reindex(range(6), method=ffill)
3 0      blue
4 1      blue
5 2    purple
6 3    purple
7 4    yellow
8 5    yellow
9 dtype: object

下表是可用的method选项。

ffill或pad

前向填充(或搬运)值

bfill或backfill

后向填充(或搬运)值

对于DataFrame,reindex可以修改(行)索引、列,或两个都修改,如果仅传入一个序列,则会重新索引行。

 1 >>> frame = pd.DataFrame(np.arange(9).reshape((3, 3)), index=[a, c, d], columns=[Ohio, 
 2 Texas, California])
 3 >>> frame
 4    Ohio  Texas  California
 5 a     0      1           2
 6 c     3      4           5
 7 d     6      7           8
 8 >>> frame2 = frame.reindex([a, b, c, d])  #重新索引行
 9 >>> frame2
10    Ohio  Texas  California
11 a   0.0    1.0         2.0
12 b   NaN    NaN         NaN
13 c   3.0    4.0         5.0
14 d   6.0    7.0         8.0
15 >>> states = [Texas, Utah, California]
16 >>> frame.reindex(columns=states)  #使用columns关键字重新索引列
17    Texas  Utah  California
18 a      1   NaN           2
19 c      4   NaN           5
20 d      7   NaN           8
21 >>> frame.reindex(index=[a, b, c, d], method=ffill)                 
22    Ohio  Texas  California
23 a     0      1           2
24 b     0      1           2
25 c     3      4           5
26 d     6      7           8

下表是reindex函数的各参数及说明。

参数

说明

index

用作索引的新序列,既可以是Index实例,也可以是其他序列型的python数据结构,Index会被完全使用,就像没有任何复制一样

method

插值(填充)方式,具体常见之前的表格

fill_value

在重新索引的过程中,需要引入缺失值时使用的替代值

limit

前向或后向填充时的最大填充量

level

在MultiIndex的指定级别上匹配简单索引,否则选取其子集

copy

默认为True,无论无何都复制,否则为False,则新旧相等就不复制

1.2 丢弃指定轴上的项

丢弃某条轴上的一个或多个项只要有一个索引数组或列表即可完成。由于需要执行一些数据整理和集合逻辑,所以drop方法返回的是一个在指定轴上删除了指定值的新对象。

 1 >>> obj = pd.Series(np.arange(5), index=[a, b, c, d, e])
 2 >>> new_obj = obj.drop(c)
 3 >>> new_obj
 4 a    0
 5 b    1
 6 d    3
 7 e    4
 8 dtype: int32
 9 >>> obj.drop([d, c])
10 a    0
11 b    1
12 e    4
13 dtype: int32

对于DataFrame,可以删除任意轴上的索引值。

 1 >>> data = pd.DataFrame(np.arange(16).reshape((4, 4)), index=[Oh, Co, Ut, New], columns=[one, two, three, four])
 2 >>> data
 3      one  two  three  four
 4 Oh     0    1      2     3
 5 Co     4    5      6     7
 6 Ut     8    9     10    11
 7 New   12   13     14    15
 8 >>> data.drop(two, axis=1)
 9      one  three  four
10 Oh     0      2     3
11 Co     4      6     7
12 Ut     8     10    11
13 New   12     14    15
14 >>> data.drop([two, four], axis=1) 
15      one  three
16 Oh     0      2
17 Co     4      6
18 Ut     8     10
19 New   12     14

1.3 索引、选取和过滤

Series索引(obj[…])的工作方式类似于NumPy数组的索引,只不过Series的索引值不是整数。

 1 >>> obj = pd.Series(np.arange(4), index=[a, b, c, d])
 2 >>> obj[b] 
 3 1
 4 >>> obj[1]   
 5 1
 6 >>> obj[2:4] 
 7 c    2
 8 d    3
 9 dtype: int32
10 >>> obj[[b, a, d]] 
11 b    1
12 a    0
13 d    3
14 dtype: int32
15 >>> obj[[1, 3]]          
16 b    1
17 d    3
18 dtype: int32
19 >>> obj[obj < 2] 
20 a    0
21 b    1
22 dtype: int32
23 >>>

利用标签的切片运算和普通的python切片运算不同,其末端是包含的。

 1 >>> obj
 2 a    0
 3 b    1
 4 c    2
 5 d    3
 6 dtype: int32
 7 >>> obj[b:d]
 8 b    1
 9 c    2
10 d    3
11 dtype: int32
12 >>> obj[b:d] = 5  #赋值操作
13 >>> obj
14 a    0
15 b    5
16 c    5
17 d    5
18 dtype: int32

对DataFrame进行索引就是获取一个或多个列。

 1 >>> data
 2      one  two  three  four
 3 Oh     0    1      2     3
 4 Co     4    5      6     7
 5 Ut     8    9     10    11
 6 New   12   13     14    15
 7 >>> data[two] 
 8 Oh      1
 9 Co      5
10 Ut      9
11 New    13
12 Name: two, dtype: int32
13 >>> data[[three, one]] 
14      three  one
15 Oh       2    0
16 Co       6    4
17 Ut      10    8
18 New     14   12
19 >>> data[:2]   # 通过切片选取行
20     one  two  three  four
21 Oh    0    1      2     3
22 Co    4    5      6     7
23 >>> data[data[three] > 5]  #通过布尔型数组选取行
24      one  two  three  four
25 Co     4    5      6     7
26 Ut     8    9     10    11
27 New   12   13     14    15
28 >>> data < 5
29        one    two  three   four
30 Oh    True   True   True   True
31 Co    True  False  False  False
32 Ut   False  False  False  False
33 New  False  False  False  False
34 >>> data[data < 5] = 0  #通过布尔型数组选取行
35 >>> data
36      one  two  three  four
37 Oh     0    0      0     0
38 Co     0    5      6     7
39 Ut     8    9     10    11
40 New   12   13     14    15
41 >>>

DataFrame的索引选项如下表所示:

类型

说明

obj[val]

选取DataFrame的单个列或一组列,在一些特殊情况下会比较方便:布尔型数组(过滤行)、切片(行切片)、布尔型DataFrame(根据条件设置值)

reindex方法

将一个或多个轴匹配到新索引

xs

根据标签选取单行或单列,返回一个Series

1.4 算术运算和数据对齐

pandas可以对不同索引的对象进行算术运算。在将对象相加时,如果存在不同的索引对,则结果的所以该索引对的并集。自动的数据对齐操作在不重叠的索引处引入了NaN值,缺失值会在算术运算过程中传播。

 1 >>> s1 = pd.Series([1, 2, 3, 4], index=[a, b, c, d]) 
 2 >>> s2 = pd.Series([5, 6, 7, 8], index = [a, c, e, f])
 3 >>> s1 + s2  #加法操作
 4 a    6.0
 5 b    NaN
 6 c    9.0
 7 d    NaN
 8 e    NaN
 9 f    NaN
10 dtype: float64
11 >>>

对于DataFrame,对齐操作会同时发生在行和列上。它们相加后会返回一个新的DataFrame,其索引和列为原来那两个DataFrame的并集。

 1 >>> df1 = pd.DataFrame(np.arange(9).reshape((3, 3)), columns=list(bcd), index=[one, two, 
 2 three])
 3 >>> df2 = pd.DataFrame(np.arange(4).reshape((2, 2)), columns=list(be), index=[two, four])
 4 >>> df1
 5        b  c  d
 6 one    0  1  2
 7 two    3  4  5
 8 three  6  7  8
 9 >>> df2
10       b  e
11 two   0  1
12 four  2  3
13 >>> df1 + df2  #相加
14          b   c   d   e
15 four   NaN NaN NaN NaN
16 one    NaN NaN NaN NaN
17 three  NaN NaN NaN NaN
18 two    3.0 NaN NaN NaN
19 >>>

1.5 在算术方法中填充值

对不同索引的对象进行算术运算时,当一个对象中某个轴标签在另一个对象中找不到时填充一个特殊值。

 1 >>> df1
 2        b  c  d
 3 one    0  1  2
 4 two    3  4  5
 5 three  6  7  8
 6 >>> df2
 7       b  e
 8 two   0  1
 9 four  2  3
10 >>> df1.add(df2, fill_value=0)
11          b    c    d    e
12 four   2.0  NaN  NaN  3.0
13 one    0.0  1.0  2.0  NaN
14 three  6.0  7.0  8.0  NaN
15 two    3.0  4.0  5.0  1.0
16 >>> df1.add(df2, fill_value=1) 
17          b    c    d    e
18 four   3.0  NaN  NaN  4.0
19 one    1.0  2.0  3.0  NaN
20 three  7.0  8.0  9.0  NaN
21 two    3.0  5.0  6.0  2.0
22 >>> df1.reindex(columns=df2.columns, fill_value=0) 
23        b  e
24 one    0  0
25 two    3  0
26 three  6  0

灵活的算术方法如下表所示:

方法

说明

add

用于加法(+)的方法

sub

用于减法(-)的方法

div

用于除法(/)的方法

mul

用于乘法(*)的方法

1.6 DataFrame和Series之间的运算

DATaFrame和Series之间的运算由明确的规定。例如计算一个二维数组与其某行之间的差。

 1 >>> arr = np.arange(12).reshape((3, 4))
 2 >>> arr
 3 array([[ 0,  1,  2,  3],
 4        [ 4,  5,  6,  7],
 5        [ 8,  9, 10, 11]])
 6 >>> arr[0]
 7 array([0, 1, 2, 3])
 8 >>> arr - arr[0]  #会进行广播
 9 array([[0, 0, 0, 0],
10        [4, 4, 4, 4],
11        [8, 8, 8, 8]])

DataFrame和Series之间的运算会将Series的索引匹配到DataFrame的列,然后沿着行一直向下广播。

 1 >>> frame = pd.DataFrame(np.arange(12).reshape((4, 3)), columns=list(bde), index=[Ut, Oh, Te, Or])
 2 >>> frame
 3     b   d   e
 4 Ut  0   1   2
 5 Oh  3   4   5
 6 Te  6   7   8
 7 Or  9  10  11
 8 >>> series = pd.Series(np.arange(3), index=[b, d, e])
 9 >>> series
10 b    0
11 d    1
12 e    2
13 dtype: int32
14 >>> frame - series 
15     b  d  e
16 Ut  0  0  0
17 Oh  3  3  3
18 Te  6  6  6
19 Or  9  9  9
20 >>>

如果某个索引值在DataFrame的列或Series的索引中找不到,则参与运算的两个对象就会被重新索引以形成并集。

 1 >>> series2 = pd.Series(range(3), index=list(bef))
 2 >>> series2
 3 b    0
 4 e    1
 5 f    2
 6 dtype: int64
 7 >>> frame
 8     b   d   e
 9 Ut  0   1   2
10 Oh  3   4   5
11 Te  6   7   8
12 Or  9  10  11
13 >>> frame + series2
14       b   d     e   f
15 Ut  0.0 NaN   3.0 NaN
16 Oh  3.0 NaN   6.0 NaN
17 Te  6.0 NaN   9.0 NaN
18 Or  9.0 NaN  12.0 NaN
19 >>>

如果希望匹配行且在列上广播,则必须使用算术运算方法。

 1 >>> series3 = frame[d]
 2 >>> frame
 3     b   d   e
 4 Ut  0   1   2
 5 Oh  3   4   5
 6 Te  6   7   8
 7 Or  9  10  11
 8 >>> series3
 9 Ut     1
10 Oh     4
11 Te     7
12 Or    10
13 Name: d, dtype: int32
14 >>> frame.sub(series3, axis=0) 
15     b  d  e
16 Ut -1  0  1
17 Oh -1  0  1
18 Te -1  0  1
19 Or -1  0  1

1.7 函数应用和映射

NumPy的ufuncs(元素级数组方法)也可用于操作pandas对象。

 1 >>> frame
 2     b  d   e
 3 Ut  0 -3   2
 4 Oh  3 -3   5
 5 Te  6 -3   8
 6 Or  9 -3  11
 7 >>> np.abs(frame) 
 8     b  d   e
 9 Ut  0  3   2
10 Oh  3  3   5
11 Te  6  3   8
12 Or  9  3  11

另一个常见操作,将函数应用到各列或行所形成的一维数组上。DataFrame的apply方法可实现此功能。

 1 >>> f = lambda x: x.max() - x.min() 
 2 >>> frame
 3     b  d   e
 4 Ut  0 -3   2
 5 Oh  3 -3   5
 6 Te  6 -3   8
 7 Or  9 -3  11
 8 >>> frame.apply(f)
 9 b    9
10 d    0
11 e    9
12 dtype: int64
13 >>> frame.apply(f, axis=1) 
14 Ut     5
15 Oh     8
16 Te    11
17 Or    14
18 dtype: int64
19 >>>

除标量值外,传递给apply的函数还可以返回由多个值组成的Series。

 1 >>> def f(x):
 2 ...     return pd.Series([x.min(), x.max()], index=[min, max])
 3 ... 
 4 >>> frame
 5     b  d   e
 6 Ut  0 -3   2
 7 Oh  3 -3   5
 8 Te  6 -3   8
 9 Or  9 -3  11
10 >>> frame.apply(f)
11      b  d   e
12 min  0 -3   2
13 max  9 -3  11
14 >>>

元素级的python函数也是可以使用的。例如求frame中各个浮点值的格式化字符串,使用applymap即可。

1 >>> format = lambda x: %.2f % x
2 >>> frame.applymap(format) 
3        b      d      e
4 Ut  0.00  -3.00   2.00
5 Oh  3.00  -3.00   5.00
6 Te  6.00  -3.00   8.00
7 Or  9.00  -3.00  11.00

1.8 排序和排名

(1)排序

根据条件对数据集排序(sorting)也是一种重要的内置运算。要对行或列索引进行排序(按字典顺序),可使用sort_index方法,它返回的是一个已排序的新对象。

1 >>> obj = pd.Series(range(4), index=[d, e, b, c])
2 >>> obj.sort_index()
3 b    2
4 c    3
5 d    0
6 e    1
7 dtype: int64

对于DataFrame,可以根据任意一个轴上的索引进行排序。

 1 >>> frame = pd.DataFrame(np.arange(8).reshape((2, 4)), index=[three, one], columns=[d, e, b, c])
 2 >>> frame.sort_index()
 3        d  e  b  c
 4 one    4  5  6  7
 5 three  0  1  2  3
 6 >>> frame.sort_index(axis=1)  #对轴1进行排序
 7        b  c  d  e
 8 three  2  3  0  1
 9 one    6  7  4  5
10 >>> frame.sort_index(axis=1, ascending=False)  #默认为升序,改为降序
11        e  d  c  b
12 three  1  0  3  2
13 one    5  4  7  6
14 >>>

(2)排名

排名跟排序密切相关,且它会增加一个排名值(从1开始,一直到数组中有效数据的数量)。使用的是rank方法,rank是通过“为各组分配一个平均排名”的方式破坏平级关系的。

这里有点不好理解,可按照下图理解。

原始数据

人为的排名

method参数值

索引

average

min

max

first

0

7

6

6.5

6

7

6

1

-5

1

1

1

1

1

2

7

7

6.5

6

7

7

3

4

4

4.5

4

5

4

4

2

3

3

3

3

3

5

0

2

2

2

2

2

6

4

5

4.5

4

5

5

method参数说明。

method

说明

‘average’

默认,在相等分组中,为各个值分配平均排名

‘min’

使用整个分组的最小排名

‘max’

使用整个分组的最大排名

‘first’

按值在原始数据中出现顺序分配排名

示例:

 1 >>> obj = pd.Series([7, -5, 7, 4, 2, 0, 4]) 
 2 >>> obj.rank()
 3 0    6.5
 4 1    1.0
 5 2    6.5
 6 3    4.5
 7 4    3.0
 8 5    2.0
 9 6    4.5
10 dtype: float64
11 >>> obj
12 0    7
13 1   -5
14 2    7
15 3    4
16 4    2
17 5    0
18 6    4
19 dtype: int64
20 >>> obj.rank(method=first)  #根据值在原数据中出现的顺序给出排名
21 0    6.0
22 1    1.0
23 2    7.0
24 3    4.0
25 4    3.0
26 5    2.0
27 6    5.0
28 dtype: float64
29 >>> obj.rank(ascending=False, method=max)  #按降序进行排名
30 0    2.0
31 1    7.0
32 2    2.0
33 3    4.0
34 4    5.0
35 5    6.0
36 6    4.0
37 dtype: float64

DataFrame可以在行或列上计算排名:

 1 >>> frame = pd.DataFrame({b: [4.3, 7, -3, 2], a: [0, 1, 0, 1], c: [-2, 5, 8, -2.5]}) 
 2 >>> frame
 3      b  a    c
 4 0  4.3  0 -2.0
 5 1  7.0  1  5.0
 6 2 -3.0  0  8.0
 7 3  2.0  1 -2.5
 8 >>> frame.rank(axis=1)  
 9      b    a    c
10 0  3.0  2.0  1.0
11 1  3.0  1.0  2.0
12 2  1.0  2.0  3.0
13 3  3.0  2.0  1.0

1.9 带有重复值的轴索引

pandas并不强制要求轴标签唯一。对于带有重复值的索引,数据选取的型位将会有所不同。如果某个索引对应多个值,则返回一个Series;而对应单个值的,则返回一个标量值。DataFrame也是如此。

 1 >>> obj = pd.Series(range(5), index=[a, a, b, b, c])
 2 >>> obj
 3 a    0
 4 a    1
 5 b    2
 6 b    3
 7 c    4
 8 dtype: int64
 9 >>> obj.index.is_unique
10 False
11 >>> obj[a]           
12 a    0
13 a    1
14 dtype: int64
15 >>> obj[c] 
16 4

以上是关于pandas基础--基本功能的主要内容,如果未能解决你的问题,请参考以下文章

Pandas基本功能

html PHP代码片段: - AJAX基本示例:此代码演示了使用PHP和JavaScript实现的基本AJAX功能。

python进阶--pandas基本功能

python进阶--pandas基本功能

python进阶--pandas基本功能

python进阶--pandas基本功能