Numpy

提供了两种基本的对象：ndarray（N-dimensional array object）和 ufunc（universal function object）。ndarray(下文统一称之为数组)是存储单一数据类型的多维数组，而ufunc则是能够对数组进行处理的函数

import numpy as np

数组

首先需要创建数组才能对其进行其它操作
可以通过给array函数传递Python的序列对象创建数组，如

>>> a = np.array([1, 2, 3, 4])
>>> b = np.array((5, 6, 7, 8))
>>> c = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]])
>>> b
array([5, 6, 7, 8])
>>> c
array([[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9, 10]])
>>> c.dtype
dtype('int32')
array.shape()函数调整数组行列

数组a的shape只有一个元素，因此它是一维数组。而数组c的shape有两个元素，因此它是二维数组，其中第0轴的长度为3，数组的大小可以通过其shape属性获得第1轴的长度为4。

还可以通过修改数组的shape属性，在保持数组元素个数不变的情况下，改变数组每个轴的长度。
将数组c的shape改为(4,3)，注意从(3,4)改为(4,3)并不是对数组进行转置，而只是改变每个轴的大小，数组元素在内存中的位置并没有改变

>>> a.shape
(4,)
>>> c.shape
(3, 4)
>>> c.shape = 4,3
>>> c
array([[ 1,  2,  3],
       [ 4,  4,  5],
       [ 6,  7,  7],
       [ 8,  9, 10]])
当某个轴的元素为-1时，将根据数组元素的个数自动计算此轴的长度
下面的程序将数组c的shape改为了(2,6)
>>> c.shape = 2,-1
>>> c
array([[ 1, 2, 3, 4, 4, 5], [ 6, 7, 7, 8, 9, 10]])
可以通过dtype参数在创建时指定元素类型
>>> np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]], dtype=np.float)
array([[ 1., 2., 3., 4.],
          [ 4., 5., 6., 7.],
          [ 7., 8., 9., 10.]])
NumPy提供了很多专门用来创建数组的函数

array.reshape(行,列)函数

把a中的行列按照reshape中的行列输出，a还是没有变

当行确定后，列不想算可以用-1代替即reshape(3,-1)或者reshape(-1,3)

reshape(-1,-1) 错误

总元素相等 否则会报错

import numpy as np
a=np.array([[1,2,3],[4,5,6]])
b=a.reshape(3,-1)
print(a)
print(b)
[[1 2 3]
[4 5 6]]
[[1 2]
[3 4]
[5 6]]
np.arange函数

类似于python的range函数，通过指定开始值、终值和步长来创建一维数组，注意数组不包括终值

默认从0开始 np.arange(10) = np.arange([0,1,2,3,4,5,6,7,8,9])步长为1，终值为10

>>> np.arange(0,1,0.1)
array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
np.linspace函数

通过指定开始值、终值和元素个数来创建一维数组(数组包括终值)，可以通过endpoint关键字指定是否包括终值，缺省设置是包括终值

>>> np.linspace(0, 1, 4)
array([ 0.        ,  0.33333333,  0.66666667,  1.        ])
数组元素的存取方法

切片+取下标+单独对元素 "访问"+"赋值"+"判断"

>>> a = np.arange(10) # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a[5] # 用整数作为下标可以获取数组中的某个元素 5
>>> a[3:5] # 用范围作为下标获取数组的一个切片，包括a[3]不包括a[5]
array([3, 4])
>>> a[:5] # 省略开始下标，表示从a[0]开始
array([0, 1, 2, 3, 4])
>>> a[:-1] # 下标可以使用负数，表示从数组后往前数
array([0, 1, 2, 3, 4, 5, 6, 7, 8])
>>> a[2:4] = 100,101 # 下标还可以用来修改元素的值
>>> a array([ 0, 1, 100, 101, 4, 5, 6, 7, 8, 9])
>>> a[1:-1:2] # 范围中的第三个参数表示步长，2表示隔一个元素取一个元素
array([ 1, 101, 5, 7])
>>> a[::-1] # 省略范围的开始下标和结束下标，步长为-1，整个数组头尾颠倒
array([ 9, 8, 7, 6, 5, 4, 101, 100, 1, 0])
>>> a[5:1:-2] # 步长为负数时，开始下标必须大于结束下标
[4 6]
当使用布尔数组bool作为下标存取数组x中的元素时，将收集数组x中所有在数组bool中对应下标为True的元素
>>> x = np.arange(5,0,-1)
>>> x array([5, 4, 3, 2, 1])
>>> x[np.array([True, False, True, False, False])]
>>> # 布尔数组中下标为0，2的元素为True，因此获取x中下标为0,2的元素
array([5, 3]) >>>
x[[True, False, True, False, False]]
>>> # 如果是布尔列表，则把True当作1, False当作0，按照整数序列方式获取x中的元素
array([4, 5, 4, 5, 5])
>>> x[np.array([True, False, True, True])]
>>> # 布尔数组的长度不够时，不够的部分都当作False array([5, 3, 2])
>>> x[np.array([True, False, True, True])] = -1, -2, -3
>>> # 布尔数组下标也可以用来修改元素
>>> x array([-1, 4, -2, -3, 1])
np.ndim()函数

数组的维数，也称为rank

np.size()函数
元素的总数。
array.dtype函数
每个元素的类型，可以是 numpy.int32, numpy.int16, and numpy.float64 等。
矩阵

随机数矩阵

np.random.rand()/randn()

import numpy as np
#生成5行5列方阵,其中每个元素是在[0,1]之间的服从均匀分布的随机数
a = np.random.rand(5,5)
#生成5行5列方阵,其中每个元素是服从标准正态分布的随机数
a = np.random.randn(5,5)

对角矩阵

np.diag([对角元素1,对角元素2...])

其他元素用 0 来填充


生成全0和全1矩阵

a = np.zeros([行数,列数])

a = np.ones([行数,列数])





多维数组

多维数组的存取和一维数组类似，因为多维数组有多个轴，因此它的下标需要用多个值来表示，NumPy采用组元(tuple)作为数组的下标



矩阵转置

矩阵a转置为a.T

import numpy as np
array_a=np.array([[1,2],[4,5]])
array_b=a.T

print("array_a:",array_a)
print("array_b:",array_b)
array_a: [[1 2]
[4 5]]
array_b: [[1 4]
[2 5]]

矩阵bool运算

import numpy as np
array_a=np.array([1,2,4,5])

print("array_a:",array_a<6)##arra_a中每个元素小于6
array_a: [ True  True  True  True]
矩阵点乘、矩阵乘法

array数组： 点乘 * 或者multiply()      矩阵乘 np.dot(array_a,array_b)  或者 array_a.dot(array_b)
matrix数组：点乘  multiply()        矩阵乘 matrix_a*matrix_b  或者  np.dot(matrix_a,matrix_b)  

或者 matrix_a.dot(matrix_b)

import numpy as np
array_a=np.array([[1,2],[4,5]])
array_b=np.array([[1,2],[4,5]])
array_c=array_a*array_b#点乘
array_d=np.dot(array_a,array_b)#矩阵乘
array_e=np.multiply(array_a,array_b)#点乘
print("array_c:",array_c)
print("array_d:",array_d)
print("array_e:",array_e)

matrix_a=np.matrix([[1,2],[4,5]])
matrix_b=np.matrix([[1,2],[4,5]])
matrix_c=matrix_a*matrix_b#点乘
matrix_d=np.dot(matrix_a,matrix_b)#矩阵乘
matrix_e=np.multiply(matrix_a,matrix_b)#点乘
print("matrix_c:",matrix_c)
print("matrix_d:",matrix_d)
print("matrix_e:",matrix_e)

array_c: [[ 1  4]
[16 25]]
array_d: [[ 9 12]
[24 33]]
array_e: [[ 1  4]
[16 25]]
matrix_c: [[ 9 12]
[24 33]]
matrix_d: [[ 9 12]
[24 33]]
matrix_e: [[ 1  4]
[16 25]]

---------------------
【转载，仅作分享，侵删】
原文：https://blog.csdn.net/qq_30138291/article/details/76204137

奈斯