python学习基础——numpy

引言

我竟然跟着百度文库学numpy，具体链接：Python中的Numpy入门教程
看pytorch文档，第一句就是“本文的默认读者已经熟悉numpy”，面对这句话，我有点虚，就回去仔细看一看numpy的内容。毕竟用过MATLAB，应该还好。这里主要记录numpy的主要函数。这里附上中文手册：NumPy中文手册
点开了中文手册，这期的主题改了，围绕中文手册的快速入门进行学习，应该够了。

NumPy的主要对象是同类型的多维数组。它是一张表，所有元素（通常是数字）的类型都相同，并通过正整数元组索引。在NumPy中，维度称为轴。轴的数目为rank。
例如，3D空间中的点的坐标 [1, 2, 1] 是rank为1的数组，因为它具有一个轴。该轴的长度为3。在下面的示例中，该数组有2个轴。
第一个轴（维度）的长度为2，第二个轴（维度）的长度为3。
[[ 1., 0., 0.],
[ 0., 1., 2.]]

这里与MATLAB有所不同，MATLAB用“；”来表示y方向，用“，”表示x方向。再高的维度就继续叠加口号和符号；
numpy中，均已“[]”最为一个维度表示。基层[]代表及维或者几个轴，而且，表示各轴元素个数从前到后对应从外层[]到内层[]。

import numpy as np
a = np.ones((2, 3, 4))
print(a)
# 打印结果
[[[1. 1. 1. 1.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]

 [[1. 1. 1. 1.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]]

array主要属性

• ndarray.ndim：数组的轴（维度）的个数。在Python世界中，维度的数量被称为rank。
• ndarray.shape：数组的维度。这是一个整数的元组，表示每个维度中数组的大小。对于有n行和m列的矩阵，shape将是(n,m)。因此，shape元组的长度就是rank或维度的个数 ndim。
• ndarray.size：数组元素的总数。这等于shape的元素的乘积。
• ndarray.dtype：一个描述数组中元素类型的对象。可以使用标准的Python类型创建或指定dtype。另外NumPy提供它自己的类型。例如numpy.int32、numpy.int16和numpy.float64。
• ndarray.itemsize：数组中每个元素的字节大小。例如，元素为 float64 类型的数组的 itemsize 为8（=64/8），而 complex32 类型的数组的 itemsize 为4（=32/8）。它等于 ndarray.dtype.itemsize 。
• ndarray.data：该缓冲区包含数组的实际元素。通常，我们不需要使用此属性，因为我们将使用索引访问数组中的元素。

创建数组array

a = np.array([1, 2, 5, 3])
# 输出
array([1, 2, 5, 3])

c = np.array([(1, 2), (5, 6)])
print(c)
# 输出
[[1 2]
 [5 6]]

建立空数组有全0、全1还有空（随机）：np.ones、np.zeros、np.empty。
创建数字序列，有两种，一种是arange，一种是linspace；
其中arange的参数是起止数值和步长；
linspace的参数是起止数值和序列长度。

np.arange( 0, 2, 0.3 )                 # it accepts float arguments
array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8])
np.linspace( 0, 2, 9 )                 # 9 numbers from 0 to 2
array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ,  1.25,  1.5 ,  1.75,  2.  ])

数组计算

数组间运算

数组可以直接计算，加减乘除。平方，三角函数等都可以，都是针对数组内元素进行的。

>>> a = np.array( [20,30,40,50] )
>>> b = np.arange( 4 )
>>> b
array([0, 1, 2, 3])
>>> c = a-b
>>> c
array([20, 29, 38, 47])
>>> b**2
array([0, 1, 4, 9])
>>> 10*np.sin(a)
array([ 9.12945251, -9.88031624,  7.4511316 , -2.62374854])
>>> a<35
array([ True, True, False, False])

矩阵乘法

进行矩阵运算需要使用dot函数或==.dot==方法

>>> A = np.array( [[1,1],
...             [0,1]] )
>>> B = np.array( [[2,0],
...             [3,4]] )
>>> A*B                         # 乘号是数组元素对应相乘
array([[2, 0],
       [0, 4]])
>>> A.dot(B)                    # 矩阵相乘
array([[5, 4],
       [3, 4]])
>>> np.dot(A, B)                # 矩阵相乘
array([[5, 4],
       [3, 4]])

全数组元素计算

计算数组内元素和、最值和均值等都是用类的方法实现的。

>>> a.sum()
2.5718191614547998

axis指定维度计算

axis = 0 沿着最外侧括号计算其内部最大单位的元素

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

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

axis = 1 沿着次外侧括号计算其内部最大单位的元素

c = np.arange(24).reshape(2,3,4)
print(c.min(axis = 1))
# output axis = 1 沿着次外侧括号计算其内部最大单位的元素

axis = 2 沿着最内侧括号计算其内部最大单位的元素

c = np.arange(24).reshape(2,3,4)
print(c.min(axis = 2))
# output 

索引

>>> a = np.arange(10)**3
>>> a
array([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729])
>>> a[2]
8
>>> a[2:5]
array([ 8, 27, 64])
>>> a[:6:2] = -1000    # equivalent to a[0:6:2] = -1000; from start to position 6, exclusive, set every 2nd element to -1000
># 从0到6个元素，每2个赋值-1000；
>>> a
array([-1000,     1, -1000,    27, -1000,   125,   216,   343,   512,   729])
>>> a[ : :-1]  # 全收尾颠倒
array([  729,   512,   343,   216,   125, -1000,    27, -1000,     1, -1000])

d = np.arange(24).reshape(2,3,4)
print(d)
print(d[1][::-1])	#与下一句效果一样
print(d[1, ::-1])
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
[[20 21 22 23]# 最外侧括号内的索引1，全部颠倒
 [16 17 18 19]
 [12 13 14 15]]

for aaa in d:
	print(aaa)
# 直接循环最外层括号
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[12 13 14 15]
 [16 17 18 19]
 [20 21 22 23]]
 for aaa in d.flat:
	print(aaa)
# .flat 可以循环所有元素，无关维度
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23