numpy的安装
pip3 install numpy
numpy的ndarray对象
- NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。
- ndarray 对象是用于存放同类型元素的多维数组。
- ndarray 中的每个元素在内存中都有相同存储大小的区域。
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
object 数组或嵌套的数列
dtype 数组元素的数据类型，可选
copy 对象是否需要复制，可选
order 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok 默认返回一个与基类类型一致的数组
ndmin 指定生成数组的最小维度
import numpy as np
a = np.array([1,2,3])
print (a)
# 输出结果如下：
# [1, 2, 3]
# 多于一个维度
import numpy as np
a = np.array([[1, 2], [3, 4]])
print (a)
# 输出结果如下：
# [[1, 2]
# [3, 4]]
# 最小维度
import numpy as np
a = np.array([1, 2, 3, 4, 5], ndmin = 2)
print (a)
# 输出如下：
# [[1, 2, 3, 4, 5]]
# dtype 参数
import numpy as np
a = np.array([1, 2, 3], dtype = complex)
print (a)
# 输出结果如下：
# [ 1.+0.j, 2.+0.j, 3.+0.j]
ndarray 对象由计算机内存的连续一维部分组成，并结合索引模式，将每个元素映射到内存块中的一个位置。内存块以行顺序(C样式)或列顺序(FORTRAN或MatLab风格，即前述的F样式)来保存元素
numpy数组的属性
NumPy 数组的维数称为秩（rank），一维数组的秩为 1，二维数组的秩为 2，以此类推。在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴（axis），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。很多时候可以声明 axis。axis=0，表示沿着第 0 轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作.
| 属性 | 说明 |
|---|---|
| ndarray.ndim | 秩，即轴的数量或维度的数量 |
| ndarray.shape | 数组的维度，对于矩阵，n行m列 |
| ndarray.size | 数组元素的总个数，相当于shape中 n*m 的值 |
| ndarray.dtype | ndarray 对象的元素类型 |
| ndarray.itemsize | ndarray 对象中每个元素的大小，以字节为单位 |
| ndarray.flags | ndarray 对象的内存信息 |
| ndarray.real | ndarray元素的实部 |
| ndarray.imag | ndarray 元素的虚部 |
import numpy as np
a = np.arange(24)
print (a.ndim) # a 现只有一个维度
# 现在调整其大小
b = a.reshape(2,4,3) # b 现在拥有三个维度
print (b.ndim)
# 输出结果为：
# 1
# 3
# ndarray.shape 表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。比如，一个二维数组，其维度表示"行数"和"列数"。ndarray.shape 也可以用于调整数组大小。
a = np.array([[1,2,3],[4,5,6]])
print (a.shape)
# 输出结果为：
# (2, 3)
a = np.array([[1,2,3],[4,5,6]])
a.shape = (3,2)
print(a)
# 输出结果为：
# [[1 2]
# [3 4]
# [5 6]]
# NumPy 也提供了 reshape 函数来调整数组大小
a = np.array([[1,2,3],[4,5,6]])
b = a.reshape(3,2)
print (b)
# 输出结果为：
# [[1, 2]
# [3, 4]
# [5, 6]]
#ndarray.itemsize 以字节的形式返回数组中每一个元素的大小。
#例如，一个元素类型为 float64 的数组 itemsiz 属性值为 8(float64 占用 64 个 bits，每个字节长度为 8，所以 64/8，占用 8 个字节），又如，一个元素类型为 complex32 的数组 item 属性为 4（32/8）。
# 数组的 dtype 为 int8（一个字节）
x = np.array([1,2,3,4,5], dtype = np.int8)
print (x.itemsize)
# 数组的 dtype 现在为 float64（八个字节）
y = np.array([1,2,3,4,5], dtype = np.float64)
print (y.itemsize)
# 输出结果为：
# 1
# 8
numpy创建数组
numpy.empty方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组
import numpy as np
x = np.empty([3,2], dtype = int)
print (x)
'''
输出结果为：
[[ 6917529027641081856 5764616291768666155]
[ 6917529027641081859 -5764598754299804209]
[ 4497473538 844429428932120]]
'''
# 注意:数组元素为随机值，因为它们未初始化。
numpy.zeros创建指定大小的数组，数组元素以 0 来填充
mport numpy as np
# 默认为浮点数
x = np.zeros(5)
print(x)
# 设置类型为整数
y = np.zeros((5,), dtype = np.int)
print(y)
'''
输出结果为：
[0. 0. 0. 0. 0.]
[0 0 0 0 0]
'''
numpy.ones创建指定形状的数组，数组元素以 1 来填充
import numpy as np
# 默认为浮点数
x = np.ones(5)
print(x)
# 自定义类型
x = np.ones([2,2], dtype = int)
print(x)
'''
输出结果为：
[1. 1. 1. 1. 1.]
[[1 1]
[1 1]]
'''
numpy从已有的数组创建数组
numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个
将列表转换为 ndarray:
import numpy as np
x = [1,2,3]
a = np.asarray(x)
print (a)
# 输出结果为：
# [1 2 3]
将元组转换为 ndarray
import numpy as np
x = (1,2,3)
a = np.asarray(x)
print (a)
# 输出结果为：
# [1 2 3]
x = [(1,2,3),(4,5)]
a = np.asarray(x)
print (a)
# 输出结果为：
# [(1, 2, 3) (4, 5)]
numpy从数值范围创建数组
numpy.arange
# 生成 0 到 5 的数组:
import numpy as np
x = np.arange(5)
print (x)
# 输出结果如下：
# [0 1 2 3 4]
# 设置了 dtype
x = np.arange(5, dtype=float)
print (x)
# 输出结果如下：
# [0. 1. 2. 3. 4.]
# 设置了起始值、终止值及步长：
x = np.arange(10,20,2)
print (x)
# 输出结果如下：
# [10 12 14 16 18]
numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
import numpy as np
a = np.linspace(1,10,10)
print(a)
# 输出结果为：
# [ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
# 设置元素全部是1的等差数列：
a = np.linspace(1,1,10)
print(a)
# 输出结果为：
# [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
numpy.logspace 函数用于创建一个于等比数列
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
start 序列的起始值为：base ** start
stop 序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中
num 要生成的等步长的样本数量，默认为50
endpoint 该值为 ture 时，数列中中包含stop值，反之不包含，默认是True。
base 对数 log 的底数。
dtype ndarray 的数据类型
import numpy as np
# 默认底数是 10
a = np.logspace(1.0, 2.0, num = 10)
print (a)
'''
输出结果为：
[ 10. 12.91549665 16.68100537 21.5443469 27.82559402
35.93813664 46.41588834 59.94842503 77.42636827 100. ]
'''
# 将对数的底数设置为2
a = np.logspace(0,9,10,base=2)
print (a)
# 输出如下：
# [ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]
numpy的切片和索引
ndarray对象的内容可以通过索引或切片来访问和修改，与Python的list切片是一样的
普通索引
import numpy as np
a = np.arange(10)
s = slice(2,7,2) # 从索引2开始到索引7停止，间隔为2
print (a[s])
# 输出结果为：
# [2 4 6]
# 我们也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作
a = np.arange(10)
b = a[2:7:2] # 从索引2开始到索引7停止，间隔为2
print(b)
# 输出结果为：
# [2 4 6]
a = np.arange(10) # [0 1 2 3 4 5 6 7 8 9]
b = a[5]
print(b)
# 输出结果为：
# 5
a = np.arange(10)
print(a[2:])
# 输出结果为：
# [2 3 4 5 6 7 8 9]
a = np.arange(10) # [0 1 2 3 4 5 6 7 8 9]
print(a[2:5])
# 输出结果为：
# [2 3 4]
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
# 从某个索引处开始切割
print(a[1:])
# [[3 4 5]
# [4 5 6]]
# 切片还可以包括省略号 …，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的 ndarray
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print (a[...,1]) # 第2列元素
print (a[1,...]) # 第2行元素
print (a[...,1:]) # 第2列及剩下的所有元素
'''
输出结果为：
[2 4 5]
[3 4 5]
[[2 3]
[4 5]
[5 6]]
'''
整数数组索引
import numpy as np
a = np.array([[1,2,3], [4,5,6],[7,8,9]])
b = a[1:3, 1:3]
c = a[1:3,[1,2]]
d = a[...,1:]
print(b)
print(c)
print(d)
'''
输出结果为：
[[5 6]
[8 9]]
[[5 6]
[8 9]]
[[2 3]
[5 6]
[8 9]]
'''
布尔索引
我们可以通过一个布尔数组来索引目标数组。布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组
# 以下实例获取大于 5 的元素
import numpy as np
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print (x)
print (x[x > 5])
'''
输出结果为：
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
[ 6 7 8 9 10 11]
'''
# 以下实例使用了 ~（取补运算符）来过滤 NaN。
a = np.array([np.nan, 1,2,np.nan,3,4,5])
print (a[~np.isnan(a)])
# [ 1. 2. 3. 4. 5.]
# 以下实例演示如何从数组中过滤掉非复数元素。
a = np.array([1, 2+6j, 5, 3.5+5j])
print (a[np.iscomplex(a)])
# 输出如下：
# [2.0+6.j 3.5+5.j]
花式索引
花式索引指的是利用整数数组进行索引。花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素；如果目标是二维数组，那么就是对应下标的行。花式索引跟切片不一样，它总是将数据复制到新数组中。
# 传入顺序索引数组
import numpy as np
x=np.arange(32).reshape((8,4))
print (x[[4,2,1,7]])
'''
输出结果为：
[[16 17 18 19]
[ 8 9 10 11]
[ 4 5 6 7]
[28 29 30 31]]
'''
# 传入倒序索引数组
x=np.arange(32).reshape((8,4))
print (x[[-4,-2,-1,-7]])
'''
输出结果为：
[[16 17 18 19]
[24 25 26 27]
[28 29 30 31]
[ 4 5 6 7]]
'''
# 传入多个索引数组（要使用np.ix_）
x=np.arange(32).reshape((8,4))
print (x[np.ix_([1,5,7,2],[0,3,1,2])]) # 第一个数组表示行，第二个数组表示列
'''
输出结果为：
[[ 4 7 5 6]
[20 23 21 22]
[28 31 29 30]
[ 8 11 9 10]]
'''
numpy的线性代数
numpy.dot() 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为内积)；对于二维数组，计算的是两个数组的矩阵乘积；对于多维数组，它的通用计算公式如下，即结果数组中的每个元素都是：数组a的最后一维上的所有元素与数组b的倒数第二位上的所有元素的乘积和： dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])
import numpy.matlib
import numpy as np
a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(np.dot(a,b))
'''
输出结果为：
[[37 40]
[85 92]]
计算式为：
[[1*11+2*13, 1*12+2*14],[3*11+4*13, 3*12+4*14]]
'''
numpy.vdot() 函数是两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数是多维数组，它会被展开.
import numpy as np
a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
# vdot 将数组展开计算内积
print (np.vdot(a,b))
'''
输出结果为：
130
计算式为：
1*11 + 2*12 + 3*13 + 4*14 = 130
'''
numpy.inner() 函数返回一维数组的向量内积。对于更高的维度，它返回最后一个轴上的和的乘积
import numpy as np
a = np.array([[1,2], [3,4]])
b = np.array([[11, 12], [13, 14]])
print (np.inner(a,b))
'''
输出结果为：
[[35 41]
[81 95]]
内积计算式为：
1*11+2*12, 1*13+2*14
3*11+4*12, 3*13+4*14
'''
numpy.linalg.det() 函数计算输入矩阵的行列式
import numpy as np
a = np.array([[1,2], [3,4]])
print (np.linalg.det(a))
# -2.0
numpy.linalg.solve() 函数给出了矩阵形式的线性方程的解
numpy.linalg.inv() 函数计算矩阵的乘法逆矩阵
import numpy as np
a = np.array([[1,1,1],[0,2,5],[2,5,-1]])
print ('数组 a：')
print (a)
ainv = np.linalg.inv(a)
print ('a 的逆：')
print (ainv)
print ('矩阵 b：')
b = np.array([[6],[-4],[27]])
print (b)
print ('计算：A^(-1)B：')
x = np.linalg.solve(a,b)
print (x)
# 这就是线性方向 x = 5, y = 3, z = -2 的解
'''
输出结果为：
数组 a：
[[ 1 1 1]
[ 0 2 5]
[ 2 5 -1]]
a 的逆：
[[ 1.28571429 -0.28571429 -0.14285714]
[-0.47619048 0.14285714 0.23809524]
[ 0.19047619 0.14285714 -0.0952381 ]]
矩阵 b：
[[ 6]
[-4]
[27]]
计算：A^(-1)B：
[[ 5.]
[ 3.]
[-2.]]
'''