numpy 模块学习

_{首先引入该模块，建议下载anaconda。}

1.创建一个3*3的矩阵，打印一些基本操作：

import numpy


t=numpy.array([[2,3,4],[5,6,7],[8,9,10]])
print(t)
print(t[1,0])#打印矩阵的第二行第一个元素
print(t[:,1])#打印第二列
print(t[0,:])#打印第一行

运行结果：

[[ 2  3  4]
 [ 5  6  7]
 [ 8  9 10]]
5
[3 6 9]
[2 3 4]

 

2.关于向量的一些基本函数操作

print(t.sum(axis=1))#行求和
print(t.sum(axis=0))#列求和
print(t.shape)#（行数，列数）
print(t.ndim)#维度
print(t.dtype)#数据类型

运行结果如下：

[ 9 18 27]
[15 18 21]
(3, 3)
2 
int32

 

其中：sum求和源码如下：

    def sum(self, axis=None, dtype=None, out=None, keepdims=False): # real signature unknown; restored from __doc__
        """
        a.sum(axis=None, dtype=None, out=None, keepdims=False)
        
            Return the sum of the array elements over the given axis.
        
            Refer to `numpy.sum` for full documentation.
        
            See Also
            --------
            numpy.sum : equivalent function
        """
        pass

可以看到axis默认值为0，即sum求和默认进行列求和，注意：

print(t.sum())

最终得到的结果是一个数，而不是一个向量，在本例子下为59=15+18+21。

 

 

3.向量的一些基本判断（用的不多就简单用个例子）

equal=(t[:,2]==10)|(t[:,2]==4)
print(equal)
print(equal.dtype)

结果如下：

[ True False  True]
bool

python有一定基础的还是能看懂的，就不多作解释。

 

 

4.初始化一个矩阵

4.1先来创建个0矩阵：

zero=numpy.zeros((3,3))
print(zero)
print(zero.dtype)

第一行代码是创建一个3*3的0矩阵

先来看看运行结果：

[[ 0.  0.  0.]
 [ 0.  0.  0.]
 [ 0.  0.  0.]]
float64

可以看见每个0后面都有一个小数点，可见而且矩阵的类型是float64（注意，8个int32和一个float64元素组成的矩阵，最终矩阵的类型是float64，原因不多解释）

再来看看源码：

def zeros(shape, dtype=None, order='C'): # real signature unknown; restored from __doc__
    """
    zeros(shape, dtype=float, order='C')
    
        Return a new array of given shape and type, filled with zeros.
    
        Parameters
        ----------
        shape : int or sequence of ints
            Shape of the new array, e.g., ``(2, 3)`` or ``2``.
        dtype : data-type, optional
            The desired data-type for the array, e.g., `numpy.int8`.  Default is
            `numpy.float64`.
        order : {'C', 'F'}, optional
            Whether to store multidimensional data in C- or Fortran-contiguous
            (row- or column-wise) order in memory.
　　"""
　　pass

shape指定矩阵的大小，（3,3）表示创建3*3的矩阵，dtype默认是float64位，你可以在定义的时候修改。

4.2比如我们在下面创建全1矩阵时加上dtype修改（全1矩阵创建于零矩阵创建相似）

one=numpy.ones((3,3),dtype="int32")
print(one)

那么得到的矩阵将是int32类型的全1矩阵

[[1 1 1]
 [1 1 1]
 [1 1 1]]

4.3除了以上一些创建方法，当然还有手输方法外再来介绍3个创建矩阵的方法

#方法一：步长构造
rangelong=numpy.arange(0,90,10).reshape(3,3)
print(rangelong)

结果如下：

[[ 0 10 20]
 [30 40 50]
 [60 70 80]]

与python原生的range函数类似，最后一个元素是不包括的；reshape函数可以修改矩阵的大小，具体可以参考源码。

再来看看随机创建法：

#方法二：随机产生
random_num=numpy.random.random((3,3))
print(random_num)

该方法是创建一个指定大小的随机矩阵，numpy库下的random方法调用原生的python库下的random方法，都有random.random,random.randint等等方法

源码是这样实现的：

# Some aliases:
ranf = random = sample = random_sample
__all__.extend(['ranf', 'random', 'sample'])

 

直接来看看结果

[[ 0.53388226  0.71517292  0.04090343]
 [ 0.41318099  0.67611132  0.87381399]
 [ 0.28595662  0.07925135  0.14645728]]

最后一种是在给定范围内，指定数量的创建方法：

from numpy import pi
allnum=numpy.linspace(0,2*pi,16).reshape(4,4)
print(allnum)

其中pi这个量，numpy有定义，调用一下可以直接使用，该函数是创建一个从0开始到2pi结束中任意16个元素，并且大小调整为4*4的矩阵

[[ 0.          0.41887902  0.83775804  1.25663706]
 [ 1.67551608  2.0943951   2.51327412  2.93215314]
 [ 3.35103216  3.76991118  4.1887902   4.60766923]
 [ 5.02654825  5.44542727  5.86430629  6.28318531]]

 

 

5.运算法则

学过线性代数的都知道，矩阵的加减法是对应位相加减，代码实现与同类型的加减法一样，即a+b

重点是矩阵的乘法，python提供了两种方法，一个是叉乘一个是点乘：

a=numpy.array([[1,2,3],[4,5,6],[7,8,9]])
print(a)
b=numpy.random.randint(0,10,(3,3))
print(b)
print(a*b);#对应位相乘
print(a.dot(b))#点积即矩阵乘法

其中点乘还可以写成：

print(numpy.dot(a,b))

运行下结果：

[[1 2 3]
 [4 5 6]
 [7 8 9]]
[[3 4 9]
 [9 3 6]
 [5 5 5]]
[[ 3  8 27]
 [36 15 36]
 [35 40 45]]
[[ 36  25  36]
 [ 87  61  96]
 [138  97 156]]

6.矩阵的变换

经过以上学习，发现reshape函数基本可以实现总体需要。

但是还是介绍一些方法：

a=numpy.array([[1,2,3],[4,5,6],[7,8,9]])
print(a.ravel())
print(a.reshape(9,1))
print(a.T)#转置

[1 2 3 4 5 6 7 8 9]
[[1]
 [2]
 [3]
 [4]
 [5]
 [6]
 [7]
 [8]
 [9]]
[[1 4 7]
 [2 5 8]
 [3 6 9]]

ravel方法是将矩阵变成一个行向量。

而.T方法用的就多一些用于转置，也很好理解。

当然还有一种复制变换：

print(numpy.tile(a,(2,2)))

抽象的可以理解成【a  a】

　　　　　　　　【a   a】。

[[1 2 3 1 2 3]
 [4 5 6 4 5 6]
 [7 8 9 7 8 9]
 [1 2 3 1 2 3]
 [4 5 6 4 5 6]
 [7 8 9 7 8 9]]

 

7.拼接

a=numpy.array([[1,2,3],[4,5,6],[7,8,9]])
print(a)
b=numpy.random.randint(0,10,(3,3))
print(b)
print(numpy.vstack((a,b)))#横着拼
print(numpy.hstack((a,b)))#竖着拼
print(numpy.hsplit(a,3))#竖着切
print(numpy.vsplit(a,3))#横着切

运行结果如下：

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

无论是横着切还是竖着切，hsplit或者vsplit都是在原矩阵的基础上平分切。

8.复制

复制有两种比较常用的复制，一个是深复制，一个是浅复制。

深复制类似于指针，如：

a=numpy.array([[1,2,3],[4,5,6],[7,8,9]])
b=a

a和b就等价起来，修改b后，a则会发生改变。

 

浅复制就是copy一下，然后两者便相忘于江湖

a=numpy.array([[1,2,3],[4,5,6],[7,8,9]])
c=a.copy()

此时再修改c时，a不会发生改变。

好了就更新到这里。。。