numpy-1. array的创建，输出和索引，切片，迭代等基本操作

numpy主要对象

存放同类元素的多维数组，元素具有相同类型，通过整数构成的元组索引，每一维叫做一个axis存放同类元素的多维数组，元素具有相同类型，通过整数构成的元组索引，每一维叫做一个axis
one axis: [1, 2, 1]
2 axis: [[1., 0., 0.], [0., 1., 2.]](第一个axis长度为2，第二个axis长度为3，从外到内去括号)
numpy的array类为ndarray (也叫array):
numpy.array不同于python的array.array (python中只处理一维数组)
ndarray对象的属性:
(1) ndarray.ndim：数组有几个axes（为一个标量）
(2) ndarray.shape：数组维度，返回整数元组，整数为每一维长度（返回元组）
(3) ndarray.size：数组的元素总个数，等于shape所有元素乘积
(4) ndarray.dtype：描述数组中元素的类型对象，类型可以是python类型，numpy也提供了自己的类型，如numpy.int16, numpy.float64等
(5) ndarray.itemsize：数组中每个元素的字节长度，float64的字节长度8（64/8=8）
(6) ndarray.data：数组元素的缓存，一般不使用，对数组元组访问多使用索引

>>> import numpy as np
>>> a = np.arange(15).reshape(3, 5)
>>> a
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
>>> a.ndim
2
>>> a.shape
(3, 5)
>>> a.size
15
>>> a.dtype
dtype('int64')
>>> a.itemsize
8
>>> a.data
<memory at 0x102e297e0>

array的创建

(1) 使用array从python的list(列表)或tuple(元组)创建，转换序列的序列为二维数组，序列的序列的序列为三维数组，以此类推；创建时可以显式指定类型
(2) 当不知道具体元素，只知道size时，可以有zeros、ones(元素全为0或全为1), empty(元素随机初始化)等函数，默认类型为float64
(3) 创建数字序列，numpy提供了类似range(返回lists)的函数arange(返回arrays)，arange不能预测可能的元素个数，可以换用函数linspace接收元素个数为参数(代替步长)

（1）
>>> import numpy as np
>>> a = np.array([2, 3, 4])
>>> a
array([2, 3, 4])
>>> b = np.array((2, 3, 4))
>>> b
array([2, 3, 4])
>>> c = np.array([(1.5, 2, 3),(0, 6, 9)])
>>> c
array([[1.5, 2. , 3. ],
       [0. , 6. , 9. ]])
>>> d = np.array([((2, 3), (8, 0)),  ((0, 6), (7, 3)), ((8, 9), (2, 5))])
>>> d
array([[[2, 3],
        [8, 0]],

       [[0, 6],
        [7, 3]],

       [[8, 9],
        [2, 5]]])
>>> f = np.array([[1, 2], [5, 6]], dtype = complex)
>>> f
array([[1.+0.j, 2.+0.j],
       [5.+0.j, 6.+0.j]])

(2)
>>> np.zeros((3,4))
array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])
>>> np.ones((2,3,4), dtype=np.int16)
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]]], dtype=int16)
>>> np.empty((2,3))
array([[9.9e-324, 1.5e-323, 0.0e+000],
       [3.0e-323, 4.0e-323, 4.4e-323]])

(3)
>>> np.arange(10, 30, 5)
array([10, 15, 20, 25])      # note: [10, 30)
>>> np.arange(0, 2, 0.3)    # used with float arguments
array([0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])
>>> np.linspace(0, 2, 9)	# (start, end and step)
array([0.  , 0.25, 0.5 , 0.75, 1.  , 1.25, 1.5 , 1.75, 2.  ])

打印数组 (从最后一个维度开始输出，即最内层)

数组的打印类似嵌套列表，遵循：
(1) 最后一个axis从左往右
(2) 第二个到最后一个从上往下
(3) 其余的从上往下，每一个slice和下一个通过empty line分开
如果数组太大，numpy会自动跳过中间部分只输出各个角的元素，若要输出整个数组，set_printoptions修改print操作

>>> a = np.arange(12).reshape(4,3)
>>> a
array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])
>>> b = np.arange(24).reshape(2,3,4)
>>> b
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]]])
        
>>> print(np.arange(10000).reshape(100,100))
array([[   0,    1,    2, ...,   97,   98,   99],
       [ 100,  101,  102, ...,  197,  198,  199],
       [ 200,  201,  202, ...,  297,  298,  299],
       ...,
       [9700, 9701, 9702, ..., 9797, 9798, 9799],
       [9800, 9801, 9802, ..., 9897, 9898, 9899],
       [9900, 9901, 9902, ..., 9997, 9998, 9999]])
>>> np.set_printoptions(threshold=np.nan)
>>> print(np.arange(10000).reshape(100,100))

基本操作

算数操作：elementwise，操作数组对应位置的元素

>>> a = np.array([20, 30, 40, 50])
>>> b = np.arange(4)
>>> c = a-b
>>> c
array([20, 29, 38, 47])
>>> b*2
array([0, 2, 4, 6])

矩阵乘法(matrix product)：使用@操作或dot方法

>>> A = np.array([[1, 1], [0, 1]])
>>> B = np.array([[2, 0], [3, 4]])
>>> A * B
array([[2, 0],
       [0, 4]])
>>> A @ B
array([[5, 4],
       [3, 4]])
>>> A.dot(B)
array([[5, 4],
       [3, 4]])

+=或*=修改已有数组

>>> a = np.ones((2,3), dtype=int)
>>> a
array([[1, 1, 1],
       [1, 1, 1]])
>>> a *= 3
>>> a
array([[3, 3, 3],
       [3, 3, 3]])

操作不同元素类型的数组时，允许upcasting

>>> a = np.ones(3, dtype=np.int32)
>>> b = np.linspace(0, 1.5, 3)
>>> b.dtype.name
'float64'
>>> c = a+b
>>> c
array([1.  , 1.75, 2.5 ])
>>> c.dtype.name
'float64'

许多一元操作，被作为ndarray类的函数实现，如max(), min()等
默认这些操作在元素为list时不考虑数组的形状，如果要具体到axis参数，可以指定把操作运用到数组的axis

>>> unary = np.arange(12).reshape(3,4)
>>> unary
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> unary.sum()
66
>>> unary.sum(axis=0)
array([12, 15, 18, 21])
>>> unary.sum(axis=1)
array([ 6, 22, 38])

通用函数(universal functions)

numpy提供了数学函数，比如sin、cos、exp等，这些函数操作也是elementwise的，输出为一个数组

>>> a = np.arange(3)
>>> np.sqrt(a)
array([0.        , 1.        , 1.41421356])
>>> np.exp(a)
array([1.        , 2.71828183, 7.3890561 ])
>>> b = np.array([2., 1., 3.])
>>> np.add(a, b)
array([2., 2., 5.])

索引、截断、迭代 (indexing, slicing and iterating)

一维数组可以被索引，切片和迭代

>>> a = np.arange(10)**3
>>> a
array([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729])
>>> a[3]            # indexing
27
>>> a[2:5]          # slicing 
array([ 8, 27, 64])
>>> a[:5:2] = -100     # 同 a[0:5:2 ] = -100, 0-5的每第2个位置设为-100
>>> a
array([-100,    1, -100,   27, -100,  125,  216,  343,  512,  729])
>>> a[ : :-1]			# 翻转，并不会改变a向量本身
array([ 729,  512,  343,  216,  125, -100,   27, -100,    1, -100])
>>> for i in a:        # iterating
...   print(i)
... 
-100
1
-100
27
-100
125
216
343
512
729

多维数组每个axis有一个index，如果对应axis没有index，默认’ : ’ 表示所有缺的axes的index，如果x的axes为5，
x[1, 2, …] = x[1, 2, :, :, :]
x[…, 3] = x[:, :, :, :, 3]
x[4, …, 5, :] = x[4, :, :, 5, :]

>>> def f(x,y):
...   return 10*x+y
... 
>>> b = np.fromfunction(f,(5,4), dtype=int)
>>> b
array([[ 0,  1,  2,  3],
       [10, 11, 12, 13],
       [20, 21, 22, 23],
       [30, 31, 32, 33],
       [40, 41, 42, 43]])
>>> b[2, 3]
23
>>> b[0:5, 1]
array([ 1, 11, 21, 31, 41])
>>> b[:, 1]
array([ 1, 11, 21, 31, 41])

# 当给定的indices少于axes数目时，b[i]也可以写作b[i, ...]
>>> b[1:3]
array([[10, 11, 12, 13],
       [20, 21, 22, 23]])
>>> b[1:3, :]
array([[10, 11, 12, 13],
       [20, 21, 22, 23]])
>>> b[1:3, ...]
array([[10, 11, 12, 13],
       [20, 21, 22, 23]])
       
# ...的使用
>>> c = np.arange(12).reshape(2,2,3)
>>> c
array([[[ 0,  1,  2],
        [ 3,  4,  5]],
       [[ 6,  7,  8],
        [ 9, 10, 11]]])
>>> c[1, ...]
array([[ 6,  7,  8],
       [ 9, 10, 11]])
>>> c[..., 2]
array([[ 2,  5],
       [ 8, 11]])

迭代多维数组则是在第一个axis上迭代 (减掉最外面的那个维度)

>>> for row in c:
...   print(row)
... 
[[0 1 2]
 [3 4 5]]
[[ 6  7  8]
 [ 9 10 11]]

如果想在数组的每个元素上操作，使用flat属性(在数组所有元素上迭代)

>>> for row in c.flat:
...   print(row)
... 
0
1
2
3
4
5
6
7
8
9
10
11