numpy基础运算

import numpy as np

t1 = np.array([1, 2, 3, 4, 5])
# numpy数组类型为numpy.ndarray
print("type(np.array)=", type(t1))
t2 = np.array(range(6))
print("t1:", t1)
print("t2:", t2)

# np.arange([start,] stop [, stop, ], dtype=None)
# np.arange()和range类似的生成数据列表的方式
t3 = np.arange(6)
t4 = np.arange(4, 10, 2)
print("t3:", t3)
print("t4:", t4)

# 可以用dtype来查看numpy数组元素的类型
print("type(t4[0])=", t4.dtype)

type(np.array)= <class 'numpy.ndarray'>
t1: [1 2 3 4 5]
t2: [0 1 2 3 4 5]
t3: [0 1 2 3 4 5]
t4: [4 6 8]
type(t4[0])= int64

import random

# 指定创建的数组的数据类型
t5 = np.arange(3, dtype=float)
print("type(t5[0])=", t5.dtype)
print("t5:", t5)

t6= np.array([1, 0, 1, 0], dtype=bool)
print("type(t6[0])=", t6.dtype)
print("t6:", t6)

# 修改数组的数据类型
t5 = t5.astype(int)
print("type(t5[0])=", t5.dtype)
print("t5:", t5)

t7 = np.array([random.random() for i in range(5)])
print("t7:", t7)
# 修改浮点型的小数位数
t7 = np.round(t7, 2)
print("t7:", t7)

type(t5[0])= float64
t5: [0. 1. 2.]
type(t6[0])= bool
t6: [ True False  True False]
type(t5[0])= int64
t5: [0 1 2]
t7: [0.55552792 0.38900276 0.32096574 0.35900877 0.28718253]
t7: [0.56 0.39 0.32 0.36 0.29]

# 一维数组的shape是元素个数
a = np.arange(6)
print("a", a.shape)

# 多维数组的shape是每个维度的元素个数, 即数组的形状
b = np.array([[1, 2, 3], [4, 5, 6]])
print("b", b.shape)

c = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print("c", c.shape)

print()
# 修改数组的形状
d = np.arange(12)
print("d:", d)
d = d.reshape((3, 4))
print("d:", d)

print()
# 2块3行4列
e = np.arange(24).reshape(2, 3, 4)
print("e:", e, '\n')

# 4行6列
e = e.reshape((4, 6))
print("e:", e, '\n')

# 一维数组
e = e.reshape(24)
print("e:", e, '\n')

# 1行24列
e = e.reshape((1, 24))
print("e:", e, '\n')

# 扁平化，转换为一维数组
e = e.flatten()
print("e:", e, '\n')

# 24行1列
# e = e.reshape((24, 1))
# print("e:", e, '\n')

a (6,)
b (2, 3)
c (2, 2, 3)

d: [ 0  1  2  3  4  5  6  7  8  9 10 11]
d: [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

e: [[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]] 

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

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

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

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

# 数组和数的计算, 由于广播机制, 运算会被广播到数组的所有元素上
a = np.array([random.randint(1 ,10) for i in range(10)])
print(a)

a = a + 1
print(a)

a = a * 3
print(a)

[ 5  9 10  5  2  9  7  8  1  5]
[ 6 10 11  6  3 10  8  9  2  6]
[18 30 33 18  9 30 24 27  6 18]

# 数组和数组的计算, 对应位置的元素相加减
a = np.arange(1, 25).reshape((4, 6))
b = np.arange(100, 124).reshape((4, 6))
print("a:", a, sep='\n')
print("b:", b, sep='\n')
print("a+b:", a + b, sep='\n')
print("a*b:", a * b, sep='\n')

# 如果两个数组的维度不对应, 也可以计算, 但是仅限于有一个维度相同的情况下才可以进行运算
# 其余情况下维度不同的数组不能进行运算

a:
[[ 1  2  3  4  5  6]
 [ 7  8  9 10 11 12]
 [13 14 15 16 17 18]
 [19 20 21 22 23 24]]
b:
[[100 101 102 103 104 105]
 [106 107 108 109 110 111]
 [112 113 114 115 116 117]
 [118 119 120 121 122 123]]
a+b:
[[101 103 105 107 109 111]
 [113 115 117 119 121 123]
 [125 127 129 131 133 135]
 [137 139 141 143 145 147]]
a*b:
[[ 100  202  306  412  520  630]
 [ 742  856  972 1090 1210 1332]
 [1456 1582 1710 1840 1972 2106]
 [2242 2380 2520 2662 2806 2952]]

广播原则：
如果两个数组的后缘维度（从末尾开始算起的维度）的轴长度相符或者其中一方的长度为1，则认为是广播兼容的。

维度可以理解为shape所对应的数字个数。

shape为(3,3,3)的数组不能够和(3,2)的数组进行计算

shape为(3,3,2)的数组能够和(3,2)的数组进行计算

shape为(3,3,2)的数组能够和(3,1)的数组进行计算

轴(axis)在numpy中可以理解为方向, 使用0,1,2...数字表示,对于一个一维数组,只有一个0轴,对于2维数组(shape(2,2)),有0轴和1轴,对于三维数组(shape(2,2, 3)),有0,1,2轴。

np.arange(0,10).reshape((2,5))的reshpe中2表示0轴长度(包含数据的条数)为2,1轴长度为5,2*5一共10个数据