Python数据分析-小技巧[1]

写在前面

小博主一心想踏上数据分析的路，所以在用 Python 学习的过程中发现了一点点自以为是的小技巧（不仅限数据分析），避免遗忘（记性不好，用笔记怕是又会越积越多）且为了时常看看，所以写下这篇文，hhh
ps.小博主现在的专业是生物信息，所以一些小技巧可能是与生物数据相关的，但可能也会对处理非生物类的数据有启发呢 : )

更新日志

• 2017.6.3
  
  • 文件操作-with
  • 合并列表-extend
  • 控制流-pass
  • 分开绘制多图-figure
  • 添加水平线/垂直线-axhline/axvline
• 2017.6.12
  
  • 有序列表的二分搜索与插入-bisect
  • 切片
  • 内置序列函数-enumerate
  • 内置序列函数-zip

文件操作-with

对于初入Python的人来说，文件操作的步骤：打开、读/写、关闭，可能用的是比较“原始”的open() … close()，后来通过学习，发现了with语句在文件操作这一方面的用处：

with open(filepath, 'r') as fr:
    ...

Python 中的 with 句段取代了 try、except 和 finally 语句，语法上更为简洁，语义上也更为精准。

这类语句保证了当with句段退出时，即使存在异常，文件也会被关闭，所以可以认为是较为安全的文件操作方式。

合并列表-extend

对于列表的合并，可能部分人想到的是 append，但实质上，append 把操作的对象当做一个元素进行添加，并不是真正的“合并列表”，更详细地说，如果 append 操作的对象是一个列表，那么 append 会把整个列表作为一个元素进行添加，所以如果处理的情况是想要将列表中的元素逐个添加，即“合并列表”就要用到 extend

>>> A = []
>>> B = [1, 2, 3]
>>> A.append(B)
>>> A
>>> [[1, 2, 3]]
>>> A.extend(B)
>>> A
>>> [[1, 2, 3], 1, 2, 3]

其实对两个列表进行‘+’操作，也能达到 extend 的效果，但还是更推荐使用 extend，原因：‘+’操作是创建一个新的列表并将所有对象复制进去，extend 是将元素附加到现有列表，因此 extend 的效率更高

控制流-pass

在粗略地学习 Python 的过程中，其实我是没注意到还有 pass 这个控制语句的，后来发觉其还是有一定的作用：

pass 是 python 中的“空操作”语句。它可以被用在那些没有任何功能的代码块中。

换言之，pass 的作用就是“占位”，而不实现其他功能。间接的作用是：
①防止语法错误（用在开发新功能时）
②增加代码的可读性

这里给出一个使用 pass 的例子：
只输出 a 中≥2的元素：

>>> a = [1, 2, 3]
>>> for item in a:
...     if item < 2:
...         pass
...     else:
...         print(item)

分开绘制多图-figure

这里指 matplotlib.pyplot.figure()
如果是刚接触 matplotlib 绘图，用一行行代码绘图的时候，会发现所有的图形都集中在一张图上，打算分开绘制图形时，又不想用 subplot 将一张图划分为若干个子绘图区域进行绘图（大多数时候显得比较拥挤），这时用 figure 会得到比较好的效果，figure 的作用是生成一个新的绘图窗口用于绘图

import numpy as np
import matplotlib.pyplot as plt

x = np.array([1, 2, 3, 4, 5])
y1 = x + 1
y2 = -x + 1

fig1 = plt.figure()
plt.plot(x, y1, 'g1-')
plt.show()

fig2 = plt.figure()
plt.plot(x, y2, 'b3:')
plt.show()

添加水平线/垂直线-axhline/axvline

这里指 matplotlib.pyplot.axhline/axvline
在展示数据的过程中，我们可能需要在图中绘出代表某阈值的水平线/垂直线，这时就需要用到 axhline/axvline 了

import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0, 2*np.pi, 0.01)
y = np.sin(x)

plt.plot(x, y, 'g')
plt.axhline(0.5)
plt.show()

有序列表的二分搜索与插入-bisect

bisect 是内置的模块，可以实现有序列表的二分查找（bisect.bisect）与插入（bisect.insort）操作

In [1]: import bisect

In [2]: tmp = [1, 2, 2, 3, 4, 5, 7, 8, 8]

In [3]: bisect.bisect(tmp, 6)   # 6应该被插入到的位置
Out[3]: 6
In [4]: bisect.insort(tmp, 6)   # 将6插入到 tmp 中

In [5]: tmp
Out[5]: [1, 2, 2, 3, 4, 5, 6, 7, 8, 8]

bisect模块的函数不会判断原列表是否是有序的，因为这样做的开销太大了。因此，将它们用于无序列表虽然不会报错，但可能会导致不正确的结果。

切片

这里介绍的是给定步长的切片和用切片实现倒序

In [1] : tmp = [1, 2, 3, 4, 5, 6]

In [2]: tmp[::2]
Out[2]: [1, 3, 5]

In [3]: tmp[::3]
Out[3]: [1, 4]

In [4]: tmp[::-1]
Out[4]: [6, 5, 4, 3, 2, 1]

内置序列函数-enumerate

对序列进行迭代时，可以使用 enumerate 函数记录索引，返回可迭代的 enumerate 对象

In [1]: tmp = ['a', 'b', 'c', 'd']

In [2]: for i, value in enumerate(tmp):
   ...:     print((i, value))  #此处可以为对 value 的其他操作
   ...:     
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')

enumerate 还有一种使用方法：将序列值映射到所在位置的字典

In [1]: tmp = ['a', 'b', 'c']

In [2]: mapping = dict((v, i) for i, v in enumerate(tmp))

In [3]: mapping
Out[3]: {'a': 0, 'b': 1, 'c': 2}

内置序列函数-zip

zip 函数可以将多个序列的元素进行配对，返回一个新的元组列表，元组的个数由配对的最短序列决定

In [1]: seq1 = ['a', 'b', 'c']

In [2]: seq2 = ['one', 'two', 'three']

In [3]: for item in zip(seq1, seq2):
   ...:     print(item)
   ...: 
('a', 'one')
('b', 'two')
('c', 'three')

In [4]: seq3 = [1, 2]

In [5]: for item in zip(seq2, seq3):
   ...:     print(item)
   ...: 
('one', 1)
('two', 2)

相反地，zip 函数还可对配对的元组序列进行“解压”

In [1]: tmp = [('one', 1), ('two', 2), ('three', 3)]

In [2]: first_item, second_item = zip(*tmp)

In [3]: first_item
Out[3]: ('one', 'two', 'three')

In [4]: second_item
Out[4]: (1, 2, 3)