python数据处理之numpy和pandas（中）

接着进行上篇开始讲，上篇主要介绍了numpy的一些基本数据操作，接下来我们进行的是numpy的矩阵合并和分割，索引等一些高级的东西。

4.索引

首先我们先将代码奉上，然后一一解读：

import numpy as np
a = np.arange(3,15)
print(a)
print(a[3])#索引
b = np.arange(3,15).reshape(3,4)
print(b)
print(b[2])
print(b[1][1])
print(b[1,1])
print(b[1,:])
print(b[:,1])
print(b[1,1:3])
for row in b:
    print(row)
for col in b.T:
    print(col)
print(b.flatten())
for item in b.flat:
    print(item)

按照前面所讲的，我们先创建一个有序的矩阵，要想知道某个位置上的具体数据，就索引出来，print(a[3])直接在屏幕上打印出来这个矩阵中第四个元素是多少。接着顺序创建一个（3,4）的矩阵，这样b[2]索引到的就是矩阵第三行的所有值，为什么是第三行？因为程序员们没有第一百朵玫瑰，哈哈。如果索引这个矩阵中的摸个位置上的具体值，就要将行和列都输上，b[1][1]是代表第二行第二列的那个数值，b[1][1]和b[1,1]是一样的效果。b[1,:]和b[1]在本例中是一样的，而b[:,1]是索引的第二列的数据，b[1,1:3]索引的是第一行第一列的和第一行第二列的数据。用for循环遍历b就是上面的方面，要想遍历b的转置就用接下来的方法。b.flatten()是将本矩阵写成一个列表的形式，若将矩阵中的数值写成一列，就需要for循环写成for item in b.flat这种循环了。

5.矩阵合并

矩阵合并共四个内置函数，训练代码如下：

import numpy as np

a = np.array([1,1,1])
b = np.array([2,2,2])
c = np.vstack((a,b))#上下合并
d = np.hstack((a,b))#左右合并
print(a.shape,b.shape)
print(c.shape)  
print(d)
print(d.shape)
print(a[np.newaxis,:])
print(a[:,np.newaxis])
A = a[:,np.newaxis]
B = b[:,np.newaxis]
e = np.vstack((A,B))
f = np.hstack((A,B))
print(e)
print(f)
C = np.concatenate((A,B,B,A),axis=1)
print(C)

现在我们来分析这段函数，首先定义两个（1,3）的矩阵，进行上下合并即变成（2,3），使用的是np.vstack(a,b)函数，a为第一行在上边。而np.hstack()是左右合并函数。a[:,np.newaxis]是改变矩阵的方向，将行矩阵变成列矩阵，同样的方法将b矩阵也变成列矩阵，这样，使用np.vstack()函数合并的话就变成6行一列，而上下合并，就变成了（3,2）矩阵。最后介绍一下合并函数np.concatenate()，可以实现若干个函数同时合并，要选择行合并和列合并只需要改变axis的值就可以了。下面贴出来输出的结果：

(3,) (3,)
(2, 3)
[1 1 1 2 2 2]
(6,)
[[1 1 1]]
[[1]
 [1]
 [1]]
[[1]
 [1]
 [1]
 [2]
 [2]
 [2]]
[[1 2]
 [1 2]
 [1 2]]
[[1 2 2 1]
 [1 2 2 1]
 [1 2 2 1]]

6.numpy分割

矩阵的分割和合并是相互呼应的，所以对比起来理解的话就会显得很容易记忆，不过这么多的函数，记是不能够全部记下来的，只能够在实际的应用中熟悉它们吧，现在，将本次的代码先贴上：

import numpy as np
a = np.arange(12).reshape((3,4))
print(a)
print(np.split(a,2,axis=1))#1代表列<1>
print(np.split(a,3,axis=0))#<2>
print(np.array_split(a,3,axis=1))#<3>
print(np.vsplit(a,3))#<4>
print(np.hsplit(a,2))#<5>

下面我们来具体分析这五个函数，顾名思义，np.split函数肯定是用来分割矩阵的，那么，函数里面的参数设计可以具体去调节如何分割。首先，分割成几块就填数字几，axis取值决定行分割还是列分割，取0是行分割，取1是列分割，还有一点值得注意，这种直接分割是不能分割成不整除份的。也就是说，三行的矩阵你不能这样分成两份，可以分成3份。如果想进行不平均的分配，可以是用<3>中的np.array_split()函数，它的分割方法是尽量让第一份分割多占一些比重以便让后续平均。<4><5>是行分割和列分割的函数式，直接使用而不用对axis进行赋值。好了，分割跟合并是一样的，那么我们贴出来结果：

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11]])]
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2],
       [ 6],
       [10]]), array([[ 3],
       [ 7],
       [11]])]
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11]])]
In [ ]:

​

7.numpy copy和deep copy

python的赋值语句很简单，主需要等号就能让左边的变量完全和右边相同，从而形成“命运共同体”，即无论二值谁改变则全部改变。这有好处，弊端也不小，基于这样的考虑，numpy中又提供了copy函数，这种函数只会源变量改变时不会传递到目标变量中的，代码如下：

import numpy as np
a = np.arange(4)
b = a
c = b
print(a)
b[0] = 1
print(a)
d = a.copy()
print(d)
c[3] = 0
print(d)
print(a)

很好理解，就不多做解释，直接将运行结果显示出来：

[0 1 2 3]
[1 1 2 3]
[1 1 2 3]
[1 1 2 3]
[1 1 2 0]

至此，numpy的学习要告一段落了，这7个部分讲了很多关于numpy库中函数的使用，现在去回想可能也记不住全部，不要担心，学过的东西忘了和没看过没学过是不一样的，就像有一句话说的那样：“我曾经读过的书现在不记得了，它并没有凭空消逝，而是变成了思想在我的头脑中，变成了血肉在我的身体里，变成了阅历在我前行的路上！”所学的东西用到实际上才会让人记忆深刻，接下来我们就要进入pandas的学习了。哈哈~~~

pandas

pandas跟numpy相辅相成，但是各有侧重，如果numpy是列表的话，pandas就是字典。当然，这样比喻是不够合理的，在实际的使用过程中，对数据的处理使对两个包都使用的，所以在编程中是要全部支持到的。pandas通常简称pd，不要搞特立独行，虽然换成hp也行，但是你的代码想让别人读懂就应该大家遵守同一个规范才行，不是吗？pandas是在numpy的基础值上创建出来的，所以存在自由它的优势之处，下面我们来进行pandas的学习，中间也会穿插numpy。

1.Series&DataFrame

先将代码贴出来，然后我们进行分析：

import numpy as np
import pandas as pd
s = pd.Series([1,3,4,np.nan,44,1])
print(s)
dates = pd.date_range('20171009',periods=6)
print(dates)
df = pd.DataFrame(np.random.rand(6,4),index = dates,columns=['a','b','c','d'])
print(df)
df1 = pd.DataFrame(np.arange(12).reshape(3,4))
print(df1)

pd.Series是字典的样式输出，即你赋予的值会在右边以列的形式打印出来，在左边会自动的生成编号。对于日期的表示可通过调节后面periods的值进行打印自己想要的日期序列，不过这步经常使用，只是展示一下如何用，包含着这种功能。DataFrame是一个表格型的数据结构，它包含一组有序的列，每列中是可以赋予不同的值得，这些值可以是整型，字符串甚至是布尔类型。它有行索引和列索引，比较全面，所以可以看做是Series组成的大字典。比如我们可以创建一组不定行不定列的标签，那么index就是从0开始的进行标定。则输出的结果如图所示：

0     1.0
1     3.0
2     4.0
3     NaN
4    44.0
5     1.0
dtype: float64
DatetimeIndex(['2017-10-09', '2017-10-10', '2017-10-11', '2017-10-12',
               '2017-10-13', '2017-10-14'],
              dtype='datetime64[ns]', freq='D')
                   a         b         c         d
2017-10-09  0.827857  0.151108  0.265419  0.792049
2017-10-10  0.280616  0.719324  0.556846  0.194033
2017-10-11  0.538966  0.044244  0.572865  0.081814
2017-10-12  0.560581  0.893978  0.861914  0.077088
2017-10-13  0.850714  0.729712  0.003048  0.308228
2017-10-14  0.051035  0.708464  0.715050  0.705602
   0  1   2   3
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11

再来看np.DataFrame()函数的另外一些用法，你可以给定一些数据包括索引之类的，如下所示：

df2 = pd.DataFrame({'A' : 1.,
                    'B' : pd.Timestamp('20130102'),
                    'C' : pd.Series(1,index=list(range(4)),dtype='float32'),
                    'D' : np.array([3] * 4,dtype='int32'),
                    'E' : pd.Categorical(["test","train","test","train"]),
                    'F' : 'foo'})
print(df2)
print(df2.dtypes)
print(df2.index)
print(df2.columns)
print(df2.values)
print(df2.describe())
print(df2.T)
print(df2.sort_index(axis=1,ascending=False))
print(df2.sort_values(by='B'))

就像df2的赋值一样，首先，我们可以查看它的各个数据的类型，输出也是以字典的形式。还可以查看index以及其类型，还可以查看横向的index以及其类型。除此之外，还可以查询df2内部的数据值，若想知道数据的总结，也是可以通过pd.describe实现的，翻转数据和前面Numpy中翻转矩阵是一样的，只不过一般不轻易去翻转，因为正如图中的翻转显示出来的效果就不那么直观和尽如人意了。如果想对index进行排序比如横向逆序排序或者是其他单单对数值进行输出，也是可以用这些方法去进行的。pandas是一个很好的模块，来源于numpy却在某些方面是高于Numpy的。下面我们将输出结果奉上：

  A          B    C  D      E    F
0  1.0 2013-01-02  1.0  3   test  foo
1  1.0 2013-01-02  1.0  3  train  foo
2  1.0 2013-01-02  1.0  3   test  foo
3  1.0 2013-01-02  1.0  3  train  foo
A           float64
B    datetime64[ns]
C           float32
D             int32
E          category
F            object
dtype: object
Int64Index([0, 1, 2, 3], dtype='int64')
Index(['A', 'B', 'C', 'D', 'E', 'F'], dtype='object')
[[1.0 Timestamp('2013-01-02 00:00:00') 1.0 3 'test' 'foo']
 [1.0 Timestamp('2013-01-02 00:00:00') 1.0 3 'train' 'foo']
 [1.0 Timestamp('2013-01-02 00:00:00') 1.0 3 'test' 'foo']
 [1.0 Timestamp('2013-01-02 00:00:00') 1.0 3 'train' 'foo']]
         A    C    D
count  4.0  4.0  4.0
mean   1.0  1.0  3.0
std    0.0  0.0  0.0
min    1.0  1.0  3.0
25%    1.0  1.0  3.0
50%    1.0  1.0  3.0
75%    1.0  1.0  3.0
max    1.0  1.0  3.0
                     0                    1                    2  \
A                    1                    1                    1   
B  2013-01-02 00:00:00  2013-01-02 00:00:00  2013-01-02 00:00:00   
C                    1                    1                    1   
D                    3                    3                    3   
E                 test                train                 test   
F                  foo                  foo                  foo   

                     3  
A                    1  
B  2013-01-02 00:00:00  
C                    1  
D                    3  
E                train  
F                  foo  
     F      E  D    C          B    A
0  foo   test  3  1.0 2013-01-02  1.0
1  foo  train  3  1.0 2013-01-02  1.0
2  foo   test  3  1.0 2013-01-02  1.0
3  foo  train  3  1.0 2013-01-02  1.0
     A          B    C  D      E    F
0  1.0 2013-01-02  1.0  3   test  foo
1  1.0 2013-01-02  1.0  3  train  foo
2  1.0 2013-01-02  1.0  3   test  foo
3  1.0 2013-01-02  1.0  3  train  foo