Numpy使用入门

　　numpy是一个数值计算库，它提供了对矩阵的计算操作(不知道矩阵是什么的就先去补补吧)，虽然python自带的list也可以表示矩阵的形式，但是明显的它并没有提供矩阵相关的计算能力。同时它也具备数组的能力，提供了对n维数组的丰富操作。下面就介绍numpy的简单使用方式。

一、numpy的几个属性

当我们创建了一个numpy数组后，它就默认自带了某些属性。

• ndim：数组的维数，比如一维数组、二维数组等
• shape：数组的形状，也叫维度。比如一个3行4列的数组，它的shape就是(3，4)
• size：数组的元素总个数，这个都很容易理解
• dtype：数组中元素的数据类型，numpy中自带了好些数据类型，在我们创建数组的时候可以指定这个dtype是什么。
• itemsize：每个元素的字节大小
• data：实际数组元素的缓冲区(然并卵，一般不会用到这玩意)

看着有点不明白，没关系，来个栗子：

  #我们要使用numpy首先需要导入，一般习惯会命名为np
  import numpy as np

    #创建一个一维数组
    oneDimentionArray = np.array([1,2,3])
    #创建一个二维数组
    twoDimentionArray = np.array([[11,22,33],
                                  [44,55,66]])
    print("一维数组：\n",oneDimentionArray)
    print("二维数组：\n",twoDimentionArray)

    print("一维数组维度：",oneDimentionArray.ndim)
    print("二维数组维度：",twoDimentionArray.ndim)

    print("一维数组dtype：",oneDimentionArray.dtype)
    print("二维数组dtype：",twoDimentionArray.dtype)

    print("一维数组的shape：",oneDimentionArray.shape)
    print("二维数组的shape：",twoDimentionArray.shape)

    print("一维数组的size：",oneDimentionArray.size)
    print("二维数组的size：",twoDimentionArray.size)

    print("一维数组的itemsize：",oneDimentionArray.itemsize)
    print("二维数组的itemsize：",twoDimentionArray.itemsize)
    ##########################################################
    # 一维数组：
    #  [1 2 3]
    # 二维数组：
    #  [[11 22 33]
    #  [44 55 66]]
    # 一维数组维度： 1
    # 二维数组维度： 2
    # 一维数组dtype： int32
    # 二维数组dtype： int32
    # 一维数组的shape： (3,)
    # 二维数组的shape： (2, 3)
    # 一维数组的size： 3
    # 二维数组的size： 6
    # 一维数组的itemsize： 4
    # 二维数组的itemsize： 4

二、numpy中的各种函数

numpy中的的函数特别多，这里就说一些比较典型的，它们的用法也比较简单，如果需要看更详细的就在官网上查看相关api文档点我送你过去。

1、创建函数

函数名	描述
array()	将输入的列表转换为ndarray
zeros()	生成一个全是0的数组
ones()	生成一个全是1的数组
empty()	生成一个未初始化的数组，其实它的item的值特别的小，接近0
identity()	创建一个单位矩阵
eye()	创建一个单位矩阵,可以设置row和colum以及对角线
arange()	和python的range()类似，创建一个从start到end的数组，指定的参数是等差值
linspace()	创建一个从start到end的等差数组，指定的参数是元素个数
random()	创建的数组元素的值是0-1间的随机数
reshape()	将数组设置为指定的m行n列

• array()
  我们可以传一个列表作为参数，array会将其转化为一个numpy的数组

array = np.array([1,2,3])
print(array)
#[1 2 3]

当然也可以指定一个dtype参数来设置数组元素的数据类型

array = np.array([1,2,3],dtype=np.float64)
print(array)
print(array.dtype)
# [ 1.  2.  3.]
# float64

注意：
- 数组中的元素的数据类型必须一致
- 在创建数组的时候，如果没有指定dtype，那么会有一个默认的dtype，通过传递的列表参数自动判断
- array中参数必须在方括号中，用列表的形式传递

• zeros()、ones()、empty()
  顾名思义，它们就是创建一个元素全为0，全为1，全为空的数组。

    array = np.zeros((3,4))
    print(array)
    print(array.dtype)
    # [[ 0.  0.  0.  0.]
    #  [ 0.  0.  0.  0.]
    #  [ 0.  0.  0.  0.]]
    # float64

    array1 = np.ones((3,4))
    print(array1)
    print(array1.dtype)
    # [[ 1.  1.  1.  1.]
    #  [ 1.  1.  1.  1.]
    #  [ 1.  1.  1.  1.]]
    # float64

    array2 = np.empty((2,3))
    print(array2)
    print(array2.dtype)
    # [[  5.98026839e+197   5.03510981e-308   3.32653140e-109]
    #  [  1.86235054e-310   5.23044209e-143   5.98027833e+197]]
    # float64

同样它们也是可以制定dtype的。
我们看到empty()函数创建的数组，元素不是空的，其实它是一个非常接近0的一个数。

• identity()和eye()
  identify和eye都能够返回一个单位矩阵(主对角线上的值为1，其它的位置为0)，它们的区别是identify返回的矩阵是rou和colum大小一致，主对角线的值为1，而eye()返回的矩阵的row和colum可以任意设置，它的对角线的位置可以在任意位置。说着有点绕，看下例子就明白了。

iden = np.identity(3)#单位矩阵
print(iden)
# [[ 1.  0.  0.]
#  [ 0.  1.  0.]
#  [ 0.  0.  1.]]

e = np.eye(3)#单位矩阵
print(e)
# [[ 1.  0.  0.]
#  [ 0.  1.  0.]
#  [ 0.  0.  1.]]

e1 = np.eye(3,4)#3行4列的矩阵，主对角线为1
print(e1)
# [[ 1.  0.  0.  0.]
#  [ 0.  1.  0.  0.]
#  [ 0.  0.  1.  0.]]

e2 = np.eye(3,4,1)#3行4列，从第一列开始对角线为1
print(e2)
# [[ 0.  1.  0.  0.]
#  [ 0.  0.  1.  0.]
#  [ 0.  0.  0.  1.]]

e3 = np.eye(3,4,-1)#3行4列，从第一行开始对角线为1
print(e3)
# [[ 0.  0.  0.  0.]
#  [ 1.  0.  0.  0.]
#  [ 0.  1.  0.  0.]]

• arange()
  和python中的range()方法类似，生成一个从start到stop的等差数组，step可以设置差值

array1 = np.arange(10,20)
array2 = np.arange(10,20,2)
print(array1)
# [10 11 12 13 14 15 16 17 18 19]
print(array2)
# [10 12 14 16 18]

• linspace()
  linspace和arange看起来有点类似，不过arange传的一个参数是步长，而linspace传的参数是元素个数,它也会生成一个等差数组。

array = np.linspace(0,1,5)
print(array)
# [ 0.    0.25  0.5   0.75  1.  ]

• random()
  创建的数组元素的值是0到1之间的随机数。

print(np.random.random((2,3)))
# [[ 0.88976404  0.9054507   0.07523331]
#  [ 0.14238848  0.60497407  0.05816551]]

• reshape()
  reshape()函数可以变换数组的形状，它将数组转换为指定的m行n列。一般它都是与以上这些函数配合使用的。

a = np.arange(0,12).reshape((3,4))
print(a)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

---

2、计算函数

函数名	描述
mean()	求均值
sin()	三角运算
add()/subtract()/multiply() /divide()/floor_divide()	加、减、乘、除、整除(也可以直接使用+、-、*、/、//运算符)
max()/min()	求最大/最小值
sum()/cumsum()	最大值/最小值
var()/std()	方差/标准差
argmax()/argmin()	最大值索引/最小值索引
dot()	矩阵相乘
transpose()	转置矩阵，和ndarray.T一样

• 加减乘除
  可以看到一些基本运算是对数组的每个元素进行操作的

a1 = np.arange(0,12).reshape((3,4))
a2 = np.arange(20,32).reshape((3,4))
print(a1 + a2)
print(np.add(a1,a2))
# [[20 22 24 26]
#  [28 30 32 34]
#  [36 38 40 42]]
#
# [[20 22 24 26]
#  [28 30 32 34]
#  [36 38 40 42]]

print(a1 - a2)
print(np.subtract(a1,a2))
# [[-20 -20 -20 -20]
#  [-20 -20 -20 -20]
#  [-20 -20 -20 -20]]
#
# [[-20 -20 -20 -20]
#  [-20 -20 -20 -20]
#  [-20 -20 -20 -20]]

print(a1 * a2)
print(np.multiply(a1,a2))
# [[  0  21  44  69]
#  [ 96 125 156 189]
#  [224 261 300 341]]

# [[  0  21  44  69]
#  [ 96 125 156 189]
#  [224 261 300 341]]

print(a1/a2)
print(np.divide(a1,a2))
# [[ 0.          0.04761905  0.09090909  0.13043478]
#  [ 0.16666667  0.2         0.23076923  0.25925926]
#  [ 0.28571429  0.31034483  0.33333333  0.35483871]]
# 
# [[ 0.          0.04761905  0.09090909  0.13043478]
#  [ 0.16666667  0.2         0.23076923  0.25925926]
#  [ 0.28571429  0.31034483  0.33333333  0.35483871]]

• mean()
  axis可以指定轴(行和列)，0表示在列上运算，1表示在行上运算

a = np.arange(0,12).reshape((3,4))
print(a)
print(np.mean(a))
print(np.mean(a,axis=0))
print(np.mean(a,axis=1))
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
# 5.5
# [ 4.  5.  6.  7.]
# [ 1.5  5.5  9.5]

• sin()
  sin()方法是对数组中的每一个元素进行运算，同理其他的几个三角函数也是如此

a = np.arange(0,12).reshape((3,4))
print(a)
print(np.sin(a))
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
# [[ 0.          0.84147098  0.90929743  0.14112001]
#  [-0.7568025  -0.95892427 -0.2794155   0.6569866 ]
#  [ 0.98935825  0.41211849 -0.54402111 -0.99999021]]

• max()/min()
  找到数组中的最大值或者最小值，当然，也可以在每一行或者每一列找到最大值或者最小值。

a = np.arange(0,12).reshape((3,4))
print(a)
print(np.max(a))
print(np.max(a,axis=0))
print(np.max(a,axis=1))

print(np.min(a))
print(np.min(a,axis=0))
print(np.min(a,axis=1))
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

# 11
# [ 8  9 10 11]
# [ 3  7 11]

# 0
# [0 1 2 3]
# [0 4 8]

• argmax()/argmin()
  找到数组中最大值或者最小值的索引，也可以找到每行每列的最大值或者最小值的索引。

a = np.arange(0,12).reshape((3,4))
print(a)

print(np.argmax(a))
print(np.argmax(a,axis=0))
print(np.argmax(a,axis=1))

print(np.argmin(a))
print(np.argmin(a,axis=0))
print(np.argmin(a,axis=1))
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

# 11
# [2 2 2 2]
# [3 3 3]

# 0
# [0 0 0 0]
# [0 0 0]

• var()/std()
  计算数组的方差和标准差

a = np.arange(0,10).reshape((2,5))

print(np.var(a))
print(np.var(a,axis=0))
print(np.var(a,axis=1))
print(np.std(a))
print(np.std(a,axis=0))
print(np.std(a,axis=1))

# 8.25
# [ 6.25  6.25  6.25  6.25  6.25]
# [ 2.  2.]
# 
# 2.87228132327
# [ 2.5  2.5  2.5  2.5  2.5]
# [ 1.41421356  1.41421356]

• dot()
  矩阵乘法

a1 = np.array([[1,3,5],
              [2,4,6]])
a2 = np.array([[1,2],
               [3,4],
               [5,6]])

print(np.dot(a1,a2))
# [[35 44]
#  [44 56]]

• transpose()
  转置矩阵

a1 = np.array([[1,3,5],
              [2,4,6]])
print(np.transpose(a1))
print(a1.T)
# [[1 2]
#  [3 4]
#  [5 6]]
# 
# [[1 2]
#  [3 4]
#  [5 6]]

---

3、索引/切片函数

numpy的索引和切片与python中的list类似

函数名	描述
ndarray[n:m]	index从n到m的数，不包含m
ndarray[:]	所有元素
ndarray[n:]	index为n以后的所有数
ndarray[:n]	从index为0开始到index为n的所有数
ndarray[n,m] /ndarray[n][m]	第n行m列的数

array = np.arange(0,20).reshape((4,5))
print(array)
print(array[2,2])#第二行，第二列的这个数
print(array[:,3])#第三列
print(array[2,:])#第二行
# [[ 0  1  2  3  4]
#  [ 5  6  7  8  9]
#  [10 11 12 13 14]
#  [15 16 17 18 19]]

# 12
# [ 3  8 13 18]
# [10 11 12 13 14]

---

4、合并分割函数

vstack()垂直合并
hstack()水平合并

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(a)
print(b)
# [1 2 3]
# [4 5 6]
# 垂直合并，相当于添加行
print(np.vstack((a, b)))  # vertical stack
# [[1 2 3]
# [4 5 6]]
# 水平合并，相当于添加列
print(np.hstack((a, b)))  # horizonl stack
# [1 2 3 4 5 6]

可以使用newaxis()增加一行或者增加一列

newA = a[np.newaxis, :]  # 增加一个行维度，相当于增加一个空行
newB = b[:, np.newaxis]  # 增加一个列维度，相当于增加一个空列
print(newA)
print(newA.shape)
print(newB)
print(newB.shape)
#[[1 2 3]]
#(1, 3)
# [[4]
# [5]
# [6]]
#(3, 1)

以上vstack()和hstack()方法可以使用concatenate()代替

array1 = np.random.random(6).reshape((2,3))
array2 = np.random.random(6).reshape((2,3))

print(np.concatenate((array1,array2),axis=0))
print(np.concatenate((array1,array2),axis=1))

# [[ 0.25893022  0.74593388  0.76681581]
#  [ 0.75128011  0.55362299  0.9446353 ]
#  [ 0.22287324  0.6396172   0.06330689]
#  [ 0.23732455  0.44834296  0.09945036]]
# [[ 0.25893022  0.74593388  0.76681581 0.22287324  0.6396172 0.06330689]
#  [ 0.75128011  0.55362299  0.9446353  0.23732455  0.44834296 0.09945036]]

array = np.arange(12).reshape((3,4))
print(array)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

print(np.split(array,3,axis=0))#在列这个维度分割，分割3列
print(np.split(array,2,axis=1))#在行这个维度分割，分割2行
# [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]])]

print(np.array_split(array,2,axis=0))
# [array([[0, 1, 2, 3],
#        [4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]

print(np.vsplit(array,3))
print(np.hsplit(array,2))
# [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]])]

注意：在使用split方法或者hsplit或者hsplit方法的时候，它们是等量分割的，比如将5列分割为2列是会报错的，如果需要进行不等量的分割，使用array_split。

参考：
1、numpy快速入门

2、《Python数据分析常用手册》一、NumPy和Pandas篇

3、Python基础数据处理库-NumPy