python 学习之 pandas 的基本功能-上

测试开头

我变成无所谓的模样

0前言

看来还是有小伙伴们使用我的 在线 qPCR 数据分析 的软件的!

下面是小伙伴的使用体验:

qpcr 模板很容易上手，直接导入文件可以得出每一步的结果，个体合并成组的工具也很好用，有 t.test 简直更香！

其他的都超好用！出数据很快！

不足就是副孔只有 2 或 3 个选项，副孔间差异较大的值也没有办法剔除……但一般 384 熟手老司机孔间差异不大就没问题！

啊对！我和我师姐都用这个处理数据了哈哈哈!

当然有时间我也会进行改进和更新,感谢使用的小伙伴们的鼓励和支持!

不知道的小伙伴们点击 QPCR 数据快速分析和绘图 — by shiny 即可查看。

如果你不想在 grapgpad 里手动加 p 值,我还写了一个 pro 版本,自动检验加 p 值 QPCRpro 正式上线！。

1引言

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

2重新索引

pandas 对象的一个重要方法是 reindex，其作用是创建一个新对象，它的数据符合新的索引。看下面的例子：

In [91]: obj = pd.Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])

In [92]: obj
Out[92]:
d 4.5
b 7.2
a -5.3
c 3.6
dtype: float64

用该 Series 的 reindex 将会根据新索引进行重排。如果某个索引值当前不存在，就引入缺失值：

In [93]: obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])

In [94]: obj2
Out[94]:
a -5.3
b 7.2
c 3.6
d 4.5
e NaN
dtype: float64

对于时间序列这样的有序数据，重新索引时可能需要做一些插值处理。method 选项即可达到此目的，例如，使用ffill可以实现前向值填充：

In [95]: obj3 = pd.Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])

In [96]: obj3
Out[96]:
0 blue
2 purple
4 yellow
dtype: object

In [97]: obj3.reindex(range(6), method='ffill')
Out[97]:
0 blue
1 blue
2 purple
3 purple
4 yellow
5 yellow
dtype: object

借助 DataFrame，reindex 可以修改（行）索引和列。只传递一个序列时，会重新索引结果的行：

In [98]: frame = pd.DataFrame(np.arange(9).reshape((3, 3)),
  ....: index=['a', 'c', 'd'],
  ....: columns=['Ohio', 'Texas', 'California'])

In [99]: frame
Out[99]:
Ohio Texas California
a 0 1 2
c 3 4 5
d 6 7 8

In [100]: frame2 = frame.reindex(['a', 'b', 'c', 'd'])

In [101]: frame2
Out[101]:
Ohio Texas California
a 0.0 1.0 2.0
b NaN NaN NaN
c 3.0 4.0 5.0
d 6.0 7.0 8.0

列可以用columns关键字重新索引：

In [102]: states = ['Texas', 'Utah', 'California']

In [103]: frame.reindex(columns=states)
Out[103]:
Texas Utah California
a 1 NaN 2
c 4 NaN 5
d 7 NaN 8

以下列出了 reindex 函数的各参数及说明:

3丢弃指定轴上的项

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

In [105]: obj = pd.Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])

In [106]: obj
Out[106]:
a 0.0
b 1.0
c 2.0
d 3.0
e 4.0
dtype: float64

In [107]: new_obj = obj.drop('c')

In [108]: new_obj
Out[108]:
a 0.0
b 1.0
d 3.0
e 4.0
dtype: float64

In [109]: obj.drop(['d', 'c'])
Out[109]:
a 0.0
b 1.0
e 4.0
dtype: float64

对于 DataFrame，可以删除任意轴上的索引值。为了演示，先新建一个 DataFrame 例子：

In [110]: data = pd.DataFrame(np.arange(16).reshape((4, 4)),
.....: index=['Ohio', 'Colorado', 'Utah', 'New York'],
.....: columns=['one', 'two', 'three', 'four'])

In [111]: data
Out[111]:
      one two three four
Ohio     0 1 2 3
Colorado 4 5 6 7
Utah     8 9 10 11
New York 12 13 14 15

用标签序列调用 drop 会从行标签（axis 0）删除值：

In [112]: data.drop(['Colorado', 'Ohio'])
Out[112]:
        one two three four
Utah     8 9 10 11
New York 12 13 14 15

通过传递 axis=1 或axis='columns'可以删除列的值：

In [113]: data.drop('two', axis=1)
Out[113]:
        one three four
Ohio     0 2 3
Colorado 4 6 7
Utah     8 10 11
New York 12 14 15

In [114]: data.drop(['two', 'four'], axis='columns')
Out[114]:
        one three
Ohio     0 2
Colorado 4 6
Utah     8 10
New York 12 14

许多函数，如 drop，会修改 Series 或 DataFrame 的大小或形状，可以就地修改对象，不会返回新的对象：

In [115]: obj.drop('c', inplace=True)
In [116]: obj
Out[116]:
a 0.0
b 1.0
d 3.0
e 4.0
dtype: float64

小心使用 inplace，它会销毁所有被删除的数据。

4索引、选取和过滤

Series 索引（obj[…]）的工作方式类似于 NumPy 数组的索引，只不过 Series 的索引值 不只是整数。下面是几个例子：

In [117]: obj = pd.Series(np.arange(4.), index=['a', 'b', 'c', 'd'])

In [118]: obj
Out[118]:
a 0.0
b 1.0
c 2.0
d 3.0
dtype: float64

In [119]: obj['b']
Out[119]: 1.0

In [120]: obj[1]
Out[120]: 1.0

In [121]: obj[2:4]
Out[121]:
c 2.0
d 3.0
dtype: float64

In [122]: obj[['b', 'a', 'd']]
Out[122]:
b 1.0
a 0.0
d 3.0
dtype: float64

In [123]: obj[[1, 3]]
Out[123]:
b 1.0
d 3.0
dtype: float64

In [124]: obj[obj < 2]
Out[124]:
a 0.0
b 1.0
dtype: float64

利用标签的切片运算与普通的 Python 切片运算不同，其末端是包含的：

In [125]: obj['b':'c']
Out[125]:
b 1.0
c 2.0
dtype: float64

用切片可以对 Series 的相应部分进行设置：

In [126]: obj['b':'c'] = 5

In [127]: obj
Out[127]:
a 0.0
b 5.0
c 5.0
d 3.0
dtype: float64

用一个值或序列对 DataFrame 进行索引其实就是获取一个或多个列：

In [128]: data = pd.DataFrame(np.arange(16).reshape((4, 4)),
  .....: index=['Ohio', 'Colorado', 'Utah', 'New York'],
  .....: columns=['one', 'two', 'three', 'four'])

In [129]: data
Out[129]:
        one two three four
Ohio     0 1 2 3
Colorado 4 5 6 7
Utah     8 9 10 11
New York 12 13 14 15

In [130]: data['two']
Out[130]:
Ohio     1
Colorado 5
Utah     9
New York 13
Name: two, dtype: int64

In [131]: data[['three', 'one']]
Out[131]:
      three one
Ohio     2 0
Colorado 6 4
Utah     10 8
New York 14 12

这种索引方式有几个特殊的情况。首先通过切片或布尔型数组选取数据：

In [132]: data[:2]
Out[132]:
one two three four
Ohio     0 1 2 3
Colorado 4 5 6 7

In [133]: data[data['three'] > 5]
Out[133]:
        one two three four
Colorado 4 5 6 7
Utah     8 9 10 11
New York 12 13 14 15

选取行的语法 data[:2]十分方便。向[ ]传递单一的元素或列表，就可选择列。

另一种用法是通过布尔型DataFrame（比如下面这个由标量比较运算得出的）进行索引：

In [134]: data < 5
Out[134]:
           one two three four
Ohio       True True True True
Colorado   True False False False
Utah       False False False False
New York   False False False False

In [135]: data[data < 5] = 0
In [136]: data
Out[136]:
        one two three four
Ohio     0 0 0 0
Colorado 0 5 6 7
Utah     8 9 10 11
New York 12 13 14 15

这使得 DataFrame 的语法与 NumPy 二维数组的语法很像。

5用 loc 和 iloc 进行选取

对于 DataFrame 的行的标签索引，引入了特殊的标签运算符loc和iloc。它们可以让你用类似 NumPy 的标记，使用轴标签（loc）或整数索引（iloc），从 DataFrame 选择行和列的子集。

作为一个初步示例，让我们通过标签选择一行和多列：

In [137]: data.loc['Colorado', ['two', 'three']]
Out[137]:
two   5
three 6
Name: Colorado, dtype: int64

然后用 iloc 和整数进行选取：

In [138]: data.iloc[2, [3, 0, 1]] Out[138]:
four 11
one   8
two   9
Name: Utah, dtype: int64

In [139]: data.iloc[2]
Out[139]:
one   8
two   9
three 10
four  11
Name: Utah, dtype: int64

In [140]: data.iloc[[1, 2], [3, 0, 1]]
Out[140]:
        four one two
Colorado 7 0 5
Utah     11 8 9

这两个索引函数也适用于一个标签或多个标签的切片：

In [141]: data.loc[:'Utah', 'two']
Out[141]:
Ohio     0
Colorado 5
Utah     9
Name: two, dtype: int64

In [142]: data.iloc[:, :3][data.three > 5]
Out[142]:
        one two three
Colorado 0 5 6
Utah     8 9 10
New York 12 13 14

所以，在 pandas 中，有多个方法可以选取和重新组合数据。

6算术运算和数据对齐

pandas 最重要的一个功能是，它可以对不同索引的对象进行算术运算。在将对象相加时，如果存在不同的索引对，则结果的索引就是该索引对的并集。对于有数据库经验的用户，这就像在索引标签上进行自动外连接。看一个简单的例子：

In [150]: s1 = pd.Series([7.3, -2.5, 3.4, 1.5], index=['a', 'c', 'd', 'e'])

In [151]: s2 = pd.Series([-2.1, 3.6, -1.5, 4, 3.1],
  .....: index=['a', 'c', 'e', 'f', 'g'])

In [152]: s1
Out[152]:
a   7.3
c   -2.5
d   3.4
e   1.5
dtype: float64

In [153]: s2
Out[153]:
a   -2.1
c   3.6
e   -1.5
f   4.0
g   3.1
dtype: float64

将它们相加就会产生：

In [154]: s1 + s2
Out[154]:
a 5.2
c 1.1
d NaN
e 0.0
f NaN
g NaN
dtype: float64

自动的数据对齐操作在不重叠的索引处引入了 NA 值。缺失值会在算术运算过程中传播。

对于 DataFrame，对齐操作会同时发生在行和列上：

In [155]: df1 = pd.DataFrame(np.arange(9.).reshape((3, 3)), columns=list('bcd'),
.....: index=['Ohio', 'Texas', 'Colorado'])

In [156]: df2 = pd.DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'),
.....: index=['Utah', 'Ohio', 'Texas', 'Oregon'])

In [157]: df1
Out[157]:
          b c d
Ohio     0.0 1.0 2.0
Texas    3.0 4.0 5.0
Colorado 6.0 7.0 8.0

In [158]: df2
Out[158]:
          b d e
Utah    0.0 1.0 2.0
Ohio    3.0 4.0 5.0
Texas   6.0 7.0 8.0
Oregon  9.0 10.0 11.0

把它们相加后将会返回一个新的 DataFrame，其索引和列为原来那两个 DataFrame 的并集：

In [159]: df1 + df2
Out[159]:
          b c d e
Colorado NaN NaN NaN NaN
Ohio     3.0 NaN 6.0 NaN
Oregon   NaN NaN NaN NaN
Texas    9.0 NaN 12.0 NaN
Utah     NaN NaN NaN NaN

因为’c’和’e’列均不在两个 DataFrame 对象中，在结果中以缺省值呈现。行也是同样。

如果 DataFrame 对象相加，没有共用的列或行标签，结果都会是空：

In [160]: df1 = pd.DataFrame({'A': [1, 2]})
In [161]: df2 = pd.DataFrame({'B': [3, 4]})

In [162]: df1
Out[162]:
  A
0 1
1 2

In [163]: df2
Out[163]:
  B
0 3
1 4

In [164]: df1 - df2
Out[164]:
    A B
0 NaN NaN
1 NaN NaN

7在算术方法中填充值

在对不同索引的对象进行算术运算时，你可能希望当一个对象中某个轴标签在另一个对象中找不到时填充一个特殊值（比如 0）：

In [165]: df1 = pd.DataFrame(np.arange(12.).reshape((3, 4)),
  .....: columns=list('abcd'))

In [166]: df2 = pd.DataFrame(np.arange(20.).reshape((4, 5)),
  .....: columns=list('abcde'))

In [167]: df2.loc[1, 'b'] = np.nan In [168]: df1
Out[168]:
    a b c d
0 0.0 1.0 2.0 3.0
1 4.0 5.0 6.0 7.0
2 8.0 9.0 10.0 11.0

In [169]: df2
Out[169]:
    a b c d e
0 0.0 1.0 2.0 3.0 4.0
1 5.0 NaN 7.0 8.0 9.0
2 10.0 11.0 12.0 13.0 14.0
3 15.0 16.0 17.0 18.0 19.0

将它们相加时，没有重叠的位置就会产生 NA 值：

In [170]: df1 + df2
Out[170]:
    a b c d e
0 0.0 2.0 4.0 6.0 NaN
1 9.0 NaN 13.0 15.0 NaN
2 18.0 20.0 22.0 24.0 NaN
3 NaN NaN NaN NaN NaN

使用 df1 的 add 方法，传入 df2 以及一个fill_value参数：

In [171]: df1.add(df2, fill_value=0)

Out[171]:
    a b c d e
0 0.0 2.0 4.0 6.0 4.0
1 9.0 5.0 13.0 15.0 9.0
2 18.0 20.0 22.0 24.0 14.0
3 15.0 16.0 17.0 18.0 19.0

In [172]: 1 / df1
Out[172]:
    a b c d
0 inf 1.000000 0.500000 0.333333
1 0.250000 0.200000 0.166667 0.142857
2 0.125000 0.111111 0.100000 0.090909

In [173]: df1.rdiv(1)
Out[173]:
    a b c d
0 inf 1.000000 0.500000 0.333333
1 0.250000 0.200000 0.166667 0.142857
2 0.125000 0.111111 0.100000 0.090909

与此类似，在对 Series 或 DataFrame 重新索引时，也可以指定一个填充值：

In [174]: df1.reindex(columns=df2.columns, fill_value=0)
Out[174]:
    a b c d e
0 0.0 1.0 2.0 3.0 0
1 4.0 5.0 6.0 7.0 0
2 8.0 9.0 10.0 11.0 0

8DataFrame 和 Series 之间的运算

跟不同维度的 NumPy 数组一样，DataFrame 和 Series 之间算术运算也是有明确规定的。先来看一个具有启发性的例子，计算一个二维数组与其某行之间的差：

In [175]: arr = np.arange(12.).reshape((3, 4))
In [176]: arr
Out[176]:
array([[ 0., 1., 2., 3.],
       [ 4., 5., 6., 7.],
       [ 8., 9., 10., 11.]])

In [177]: arr[0]
Out[177]:
array([ 0., 1., 2., 3.])

In [178]: arr - arr[0]
Out[178]:
array([[ 0., 0., 0., 0.],
       [ 4., 4., 4., 4.],
       [ 8., 8., 8., 8.]])

当我们从 arr 减去 arr[0]，每一行都会执行这个操作。这就叫做 广播（broadcasting），DataFrame 和 Series 之间的运算差不多也是如此：

In [179]: frame = pd.DataFrame(np.arange(12.).reshape((4, 3)),
  .....: columns=list('bde'),
  .....: index=['Utah', 'Ohio', 'Texas', 'Oregon'])

In [180]: series = frame.iloc[0]

In [181]: frame
Out[181]:
          b d e
Utah    0.0 1.0 2.0
Ohio    3.0 4.0 5.0
Texas   6.0 7.0 8.0
Oregon  9.0 10.0 11.0

In [182]: series
Out[182]:
b 0.0
d 1.0
e 2.0
Name: Utah, dtype: float64

默认情况下，DataFrame 和 Series 之间的算术运算会将 Series 的索引匹配到 DataFrame 的列，然后沿着行一直向下广播：

In [183]: frame - series
Out[183]:
      b d e
Utah 0.0 0.0 0.0
Ohio 3.0 3.0 3.0
Texas 6.0 6.0 6.0
Oregon 9.0 9.0 9.0

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

In [184]: series2 = pd.Series(range(3), index=['b', 'e', 'f'])

In [185]: frame + series2
Out[185]:
        b d e f
Utah   0.0 NaN 3.0 NaN
Ohio   3.0 NaN 6.0 NaN
Texas  6.0 NaN 9.0 NaN
Oregon 9.0 NaN 12.0 NaN

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

In [186]: series3 = frame['d']

In [187]: frame
Out[187]:
        b d e
Utah   0.0 1.0 2.0
Ohio   3.0 4.0 5.0
Texas  6.0 7.0 8.0
Oregon 9.0 10.0 11.0

In [188]: series3
Out[188]:
Utah   1.0
Ohio   4.0
Texas  7.0
Oregon 10.0
Name: d, dtype: float64

In [189]: frame.sub(series3, axis='index')
Out[189]:
         b d e
Utah   -1.0 0.0 1.0
Ohio   -1.0 0.0 1.0
Texas  -1.0 0.0 1.0
Oregon -1.0 0.0 1.0