本文章仅供我本人学习记录使用，不允许任何转载及引用。特此声明。
>>> Numpy是多维数组，通过ndarray对象（ndarray：sample1， sample2...）生成，可以有一维，二维，三维，四维。。。
In[1]: import numpy as np
In[2]: sample1 = np.array([1, 2, 3, 4])
In[3]: a1.shape
Out[3]: (4,)
#shape 获取多维数组各个维度的大小，返回一个元组
#sample1是一维数组，大小为4
In[4]: sample1.size
Out[4]: 4
#size获取数组的元素个数
In[5]: sample1.dtype
Out[5]: dtype('int64')
#dtype获取数组内元素的数据类型
In[6]: sample2 = np.array([[1.0, 2.5, 3], [0.5, 4, 9]])
In[7]: sample2.shape
Out[7]: (2, 3)
#sample2是一个2行，3列的二维数组（如excel）
In[8]: sample2.size
Out[8]: 6
In[9]: sample2.min()
Out[9]: 0.5
#min()返回元素中的最小元素
In[10]: sample2.dtype
Out[10]: dtype('float64')
In[11]: sample1
Out[11]: array([1, 2, 3, 4])
#sample1是一维数组
In[12]: sample2
Out[12]: array([[1. , 2.5, 3. ],
[0.5, 4. , 9. ]])
#sample2是二维数组
In[13]: type(sample1)
Out[13]: numpy.ndarray
# 其他更多方法可以输入sample1.<tab>查看
>>> 除了上面使用np.array创建数组外，还有多种方法可以创建多位数组：
- np.arange，类似于range，创建一维数组；
- np.ones， 创建元素值全部是1的数组；
- np.zeros，创建元素值全部是0的数组；
- np.empty，创建空值的多位数组，只分配内存，不填充任何值；
- np.random.random，创建元素值为随机值的多位数组；
--- 以上全部函数都接受一个dtype参数，用于指定多位数组元素的类型。在后面加上参数如：dtype = np.int64，当没有指定dtype时，默认float64。
--- 后四个函数需要通过元组指定创建的数组形状，比如（2， 3）指定创建数组为2行3列二维数组，或（3，4，2）创建一个三维数组，（2，5，4，4）创建一个思维数组。
--- 数组的维度可以通过sample2(ndarray).ndim获取
如下：
In[1]: s1 = np.arange(4)
In[2]: s1
Out[2]: array([0, 1, 2, 3])
In[3]: s1.ndim
Out[3]: 1
In[4]: s2 = np.ones((4, 4), type = np.int64)
In[5]: s2
Out[5]:
array([[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]])
In[6]: s2.dtype
Out[6]: dtype('int64')
In[7]: s2.ndim
Out[7]: 2
In[8]: s2.shape
Out[8]: (4, 4)
In[9]: s3 = np.zeros((2, 2))
In[10]: s3
Out[10]:
array([[0., 0.],
[0., 0.]])
In[11]: s3.dtype
Out[11]: dtype('float64')
In[12]: s4 = np.empty((3, 3), dtype = np.int64)
In[13]: s4
Out[13]:
array([[ 8070450532247928832, -2305834237023131736, 140355069542405],
[ 0, 0, 0],
[ 140355069597696, 140355069597696, 0]])
In[14]: s5 = np.ones((4, 3, 4))
In[15]: s5
Out[15]:
array([[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]]])
In[16]: s5.ndim
Out[16]: 3
# ndarray对象还可以通过reshape方法变形为其他维度的数组：
In[17]: a = np.arange(12)
In[18]: a
Out[18]: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
In[19]: a.reshape(4, 3)
Out[19]:
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])
In[20]: a.reshape(2, 2, 3)
Out[20]:
array([[[ 0, 1, 2],
[ 3, 4, 5]],
[[ 6, 7, 8],
[ 9, 10, 11]]])
>>> 多维数组索引:
使用‘：’切片选择部分元素，如下：
In[1]: l = [1, 2, 3, 4, 5]
In[2]: l[:2]
Out[2]: [1, 2]
# 列表的前两个元素
In[3]: l[2:4]
Out[3]: [3, 4]
# 列表的第3、第4个元素
In[4]: l[1:5:2]
Out[4]: [2, 4]
# 列表的第2到第5个元素，且步长为2（间隔1个元素）。
# 需要注意的是列表的索引从0开始，第一个索引是0，第二个索引是1。
In[5]: a = np.arange(12)
In[6]: a
Out[6]: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
In[7]: a[1:4]
Out[7]: array([1, 2, 3])
In[8]: a[1:10:2]
Out[8]: array([1, 3, 5, 7, 9])
Numpy的列表切片比Python的要强大的多，因为通过切片，numpy可以进行赋值操作，一次性改变数组中的多个元素：
In[1]: a = np.arange(12)
In[2]: a
Out[2]: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
In[3]: a[1:5] = -1
Out[3]: array([ 0, -1, -1, -1, -1, 5, 6, 7, 8, 9, 10, 11])
In[4]: a[1:10:2] = 1
Out[4]: array([ 0, 1, -1, 1, -1, 1, 6, 1, 8, 1, 10, 11])
以上是一维数组切片，多维数组我们可以在每一个维度上进行切片：
In[1]: a = np.arange(12).reshape(3, 4)
In[2]: a.shape
Out[2]: (3, 4)
In[3]: a
Out[3]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
In[4]: a[0]
Out[4]: array([0, 1, 2, 3])
In[5]: a[1]
Out[5]: array([4, 5, 6, 7])
In[6]: a[:, 0]
Out[6]: array([0, 4, 8])
# 第一列元素
In[7]: a[:, 1]
Out[7]: array([1, 5, 9])
# 第二列元素
In[8]: a[0, 0]
Out[8]: 0
# a数组的第一行的第一列的元素
In[9]: a[0, 1]
Out[9]: 1
# a数组的第一行的第二列的元素
In[10]: a[1, 2]
Out[10]: 6
# a数组的第二行的第三列的元素
In[11]: a[0] = 1
Out[11]:
array([[ 1, 1, 1, 1],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
In[12]: a[:, 1] = -1
Out[12]:
array([[ 1, -1, 1, 1],
[ 4, -1, 6, 7],
[ 8, -1, 10, 11]])
# 对于二维数组，可以通过a[x, y]的方式进行索引；
# 对于三维数组，可以通过a[x, y, z]的方式进行索引
另外，也可在高维数组上进行降维索引：
In[1]: a
Out[1]:
array([[ 1, 1, 1, 1],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
In[2]: a[1, 1]
Out[2]: 5
# 二维索引
In[3]: a[1]
Out[3]: array([4, 5, 6, 7])
# 二维数组的一维索引
# 三维数组的降维索引如下：
In[4]: a = np.arange(27).reshape(3, 3, 3)
Out[4]:
array([[[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8]],
[[ 9, 10, 11],
[12, 13, 14],
[15, 16, 17]],
[[18, 19, 20],
[21, 22, 23],
[24, 25, 26]]])
In[5]: a.ndim
Out[5]: 3
In[6]: a.shape
Out[6]: (3, 3, 3)
# a是三维数组，各维度大小是3，3，3
In[7]: a1 = a[1]
Out[7]:
array([[ 9, 10, 11],
[12, 13, 14],
[15, 16, 17]])
In[8]: a1.shape
Out[8]: (3, 3)
# a1是二维数组，各维度大小是3， 3
In[9]: a2 = a[1, 1]
Out[9]: array([12, 13, 14])
In[10]: a2.shape
Out[10]: (3,)
In[11]: a2.ndim
Out[11]: 1
# a2是一维数组，有3个元素
In[12]: a[2, 2, 2]
Out[12]: 26
# 定位三维数组中的一个元素
# 以下是同时修改每个维度中的特定行、列或一个元素：
In[13]: a[:, 1]
Out[13]:
array([[ 3, 4, 5],
[12, 13, 14],
[21, 22, 23]])
# 同时选择所有第二维度上的元素,
# 以下是统一修改这个维度上的内容
In[14]: a[:, 1] = 1
Out[14]:
array([[[ 0, 1, 2],
[ 1, 1, 1],
[ 6, 7, 8]],
[[ 9, 10, 11],
[ 1, 1, 1],
[15, 16, 17]],
[[18, 19, 20],
[ 1, 1, 1],
[24, 25, 26]]])
In[15]: a[:, 1] = ([1], [2], [3])
Out[15]:
array([[[ 0, 1, 2],
[ 1, 1, 1],
[ 6, 7, 8]],
[[ 9, 10, 11],
[ 2, 2, 2],
[15, 16, 17]],
[[18, 19, 20],
[ 3, 3, 3],
[24, 25, 26]]])
In[16]: a[:, 1] = [1, 2, 3]
Out[16]:
array([[[ 0, 1, 2],
[ 1, 2, 3],
[ 6, 7, 8]],
[[ 9, 10, 11],
[ 1, 2, 3],
[15, 16, 17]],
[[18, 19, 20],
[ 1, 2, 3],
[24, 25, 26]]])
>>> 多维数组的基本运算：
在Python自带的列表中，如果想让所有元素都加上同一个数，需要通过遍历实现，但在Numpy中则一场简单：
In[1]: a = np.arange(12).reshape(3, 4)
In[2]: a
Out[2]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
In[3]: a += 1
Out[3]:
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
# 所有元素翻倍：
In[4]: a *= 2
Out[4]:
array([[ 2, 4, 6, 8],
[10, 12, 14, 16],
[18, 20, 22, 24]])
# 多维数组间的运算也非常简单：
In[5]: a = np.arange(4).reshape(2, 2)
Out[5]:
array([[0, 1],
[2, 3]])
In[6]: b = np.arange(4, 8).reshape(2, 2)
Out[6]:
array([[4, 5],
[6, 7]])
# 创建从4-7为元素值的数组
In[7]: b - a
Out[7]:
array([[4, 4],
[4, 4]])
# 数组间的shape必须相同。
# 需要注意的是：
# 多维数组的组织方式和矩阵相同，但乘法的运算规格却和矩阵不同，如果像对ndarray对像使用矩阵的乘法运算规则，可以使用ndarray.dot方法，a和b的矩阵乘法结果如下：
In[8]: a.dot(b)
Out[8]:
array([[ 6, 7],
[26, 31]])
# 多维数组还支持逻辑比较运算，比如我们想知道一个多维数组中那些值大于某一个指定值，典型的做法是通过循环实现，但是在Numpy中却可以直接通过比较方法实现：
In[9]: a = np.arange(12).reshape(4, 3)
Out[9]:
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])
In[10]: b = a > 5
# 通过a > 5 生成一个形状与a一直的多维数组b
In[11]: b
Out[11]:
array([[False, False, False],
[False, False, False],
[ True, True, True],
[ True, True, True]])
In[12]: b.dtype
Out[12]: dtype('bool')
In[13]: a[b]
Out[13]: array([ 6, 7, 8, 9, 10, 11])
# 所有大于5为True的元素的位置在a中的值就可以使用a[b]这种形式列出来。
Numpy的多维数组还有一些方法，可以用于【统计数组中的一些流量值】，如下：
- a.sum :计算多位数组的所有元素的和；
- a.max :最大值计算；
- a.min : 最小值计算；
- a.mean :平均值计算；
- a.std :标准差计算；
- a.var :方差计算。
以上所有方法，都可以接受一个axis参数（用于指定具体统计哪根轴上的数据。比如二维数组，可以理解为有x, y两根轴代表行，列，指定axis = 0时表示分别统计每列上的数据；axis = 1时，表示分别统计每行上的数据；没有指定axis参数时，代表统计所有元素。）
如下：
In[14]: a
Out[14]:
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])
In[15]: a.sum()
Out[15]: 66
In[16]: a.sum(axis=0)
Out[16]: array([18, 22, 26])
In[17]: a.sum(axis=1)
Out[17]: array([ 3, 12, 21, 30])
除了ndarray多位数组对象自己的方法外，Numpy还自带了一些通用函数，可以进行各种计算：
- np.sqrt :开方运算；
- np.dot :矩阵乘法；
- np.sort :排序；
- np.linalg :模块中包含了一些基本的线形代数计算函数；
- 更多可查阅文档。
网友评论