安装numpy包
导包
"""
ndarray.ndim：数组的维数。在Python世界中，维数称之为rank
ndarray.shape：数组的维度。这是一系列数字，长度由数组的维度（ndim）决定。例如：长度为n的一维数组的shape是n。一个n行m列的矩阵的shape是n,m
ndarray.size：数组中所有元素的数量
ndarray.dtype：数组中元素的类型，例如numpy.int32, numpy.int16或者numpy.float64
ndarray.itemsize：数组中每个元素的大小，单位为字节
ndarray.data：存储数组元素的缓冲。通常我们只需要通过下标来访问元素，而不需要访问缓冲
"""
a = np.array([1,2,3])
print(a)
print("a's ndim {}".format(a.ndim))
print("a's shape {}".format(a.shape))
print("a's size {}".format(a.size))
print("a's dtype {}".format(a.dtype))
print("a's itemsize {}".format(a.itemsize))
# [1 2 3]
# a's ndim 1
# a's shape (3,)
# a's size 3
# a's dtype int32
# a's itemsize 4
b = np.array([[1,2,3],[4,5,6]])
print(b)
print("b's ndim {}".format(b.ndim))
print("b's shape {}".format(b.shape))
print("b's size {}".format(b.size))
print("b's dtype {}".format(b.dtype))
print("b's itemsize {}".format(b.itemsize))
# [[1 2 3]
# [4 5 6]]
# b's ndim 2
# b's shape (2, 3)
# b's size 6
# b's dtype int32
# b's itemsize 4
"""
zeros：用来创建元素全部是0的数组
ones：用来创建元素全部是1的数组
empty：用来创建未初始化的数据，因此是内容是不确定的
arange：通过指定范围和步长来创建数组
linespace：通过指定范围和元素数量来创建数组
random：用来生成随机数
"""
c = np.zeros((2,3))
print(c)
# [[0. 0. 0.]
# [0. 0. 0.]]
d = np.ones((3,2))
print(d)
# [[1. 1.]
# [1. 1.]
# [1. 1.]]
e = np.empty((2,3))
print(e)
# [[6.23042070e-307 3.56043053e-307 1.37961641e-306]
# [6.23039015e-307 1.69115935e-306 2.11392033e-307]]
f = np.arange(1,2,0.3)
print(f)
# [1. 1.3 1.6 1.9]
g = np.linspace(1,2,3)
print(g)
# [1. 1.5 2. ]
h = np.random.random((2,3))
print(h)
# [[0.64425744 0.4496131 0.88346286]
# [0.3458989 0.89334331 0.61867948]]
"""
除了生成数组之外，当我们已经持有某个数据之后，我们可能会需要根据已有数组来产生一些新的数据结构，这时候我们可以使用下面这些函数：
reshape：根据已有数组和指定的shape，生成一个新的数组
vstack：用来将多个数组在垂直（v代表vertical）方向拼接（数组的维度必须匹配）
hstack：用来将多个数组在水平（h代表horizontal）方向拼接（数组的维度必须匹配）
hsplit：用来将数组在水平方向拆分
vsplit：用来将数组在垂直方向拆分
下面我们通过一些例子来进行说明。
为了便于测试，我们先创建几个数据。这里我们创建了：
zero_line：一行包含3个0的数组
one_column：一列包含3个1的数组
a：一个2行3列的矩阵
b：[11, 20)区间的整数数组
"""
zero_line = np.zeros((1,3))
one_column = np.ones((3,1))
# [[0. 0. 0.]]
# [[1.]
# [1.]
# [1.]]
a = np.array(([1,2,3],[4,5,6]))
b = np.arange(11,20)
# [[1 2 3]
# [4 5 6]]
# [11 12 13 14 15 16 17 18 19]
#数组b原先是一个一维数组，现在我们通过reshape方法将其调整成为一个3行3列的矩阵
#这里的第二参数设为-1，表示根据实际情况自动决定。由于原先是9个元素的数组，因此调整后刚好是3X3的矩阵
b = b.reshape(3,-1)
print(b)
# [[11 12 13]
# [14 15 16]
# [17 18 19]]
# 竖直方向拼接数组
c = np.vstack((a,b,zero_line))
print(c)
# [[ 1. 2. 3.]
# [ 4. 5. 6.]
# [11. 12. 13.]
# [14. 15. 16.]
# [17. 18. 19.]
# [ 0. 0. 0.]]
a = a.reshape(3,-1)
print(a)
# [[1 2]
# [3 4]
# [5 6]]
# 水平方向拼接数组
d = np.hstack((a,b,one_column))
print(d)
# [[ 1. 2. 11. 12. 13. 1.]
# [ 3. 4. 14. 15. 16. 1.]
# [ 5. 6. 17. 18. 19. 1.]]
# 指定数量进行水平拆分
e = np.hsplit(d,3)
print(e)
# [array([[1., 2.],
# [3., 4.],
# [5., 6.]]), array([[11., 12.],
# [14., 15.],
# [17., 18.]]), array([[13., 1.],
# [16., 1.],
# [19., 1.]])]
# 指定列数进行水平拆分
f = np.hsplit(d,(1,3))
print(f)
# [array([[1.],
# [3.],
# [5.]]), array([[ 2., 11.],
# [ 4., 14.],
# [ 6., 17.]]), array([[12., 13., 1.],
# [15., 16., 1.],
# [18., 19., 1.]])]
# 竖直拆分
g = np.vsplit(d,3)
print(g)
# [array([[ 1., 2., 11., 12., 13., 1.]]), array([[ 3., 4., 14., 15., 16., 1.]]), array([[ 5., 6., 17., 18., 19., 1.]])]
"""
索引
"""
base_data = np.arange(100,200)
print(base_data)
print(base_data[10])
"""
[100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
190 191 192 193 194 195 196 197 198 199]
110
"""
every_five = np.arange(0,100,5)
print(every_five)
# [ 0 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95]
print(base_data[every_five])
# [100 105 110 115 120 125 130 135 140 145 150 155 160 165 170 175 180 185 190 195]
a = np.array([(1,2),[10,20]])
print(a)
# [[ 1 2]
# [10 20]]
print(base_data[a])
# [[101 102]
# [110 120]]
base_data2 = base_data.reshape(10, -1)
print(base_data2)
"""
[[100 101 102 103 104 105 106 107 108 109]
[110 111 112 113 114 115 116 117 118 119]
[120 121 122 123 124 125 126 127 128 129]
[130 131 132 133 134 135 136 137 138 139]
[140 141 142 143 144 145 146 147 148 149]
[150 151 152 153 154 155 156 157 158 159]
[160 161 162 163 164 165 166 167 168 169]
[170 171 172 173 174 175 176 177 178 179]
[180 181 182 183 184 185 186 187 188 189]
[190 191 192 193 194 195 196 197 198 199]]
"""
print(base_data2[-1,-1]) # 199
# 切片索引从0开始
print(base_data2[2, :])
# [120 121 122 123 124 125 126 127 128 129]
print(base_data2[:,3])
# [103 113 123 133 143 153 163 173 183 193]
"""
数字运算
"""
base_data = (np.random.random((5,5))-0.5) * 100
"""
[[ -4.99893607 39.77193936 -15.46706727 16.80691258 -38.51945213]
[-49.06612449 49.35329335 -0.4216167 13.12483635 -41.60876645]
[-43.18292355 -25.25568989 0.44448147 -2.89856688 -24.13873839]
[ 32.75485688 11.0737333 18.77766764 22.513295 3.48913839]
[-10.96543248 -40.42721305 30.38299405 -32.77083843 40.39435566]]
"""
print(np.amin(base_data))
# -49.06612449306485
print(np.amax(base_data))
# 49.35329334672289
print(np.average(base_data))
# -2.0333544702011186
print(np.sin(base_data))
"""
[[ 0.95922553 0.87660695 -0.23857285 -0.89073028 -0.73137794]
[ 0.93180625 -0.7908454 -0.40923611 0.52988566 0.69474259]
[ 0.71691953 -0.12263914 0.42998979 -0.24064058 0.83821559]
[ 0.9732393 -0.99694714 -0.07182638 -0.4987417 -0.34059131]
[ 0.99954577 -0.40180897 -0.858805 -0.97678732 0.43167496]]
"""
print(np.sum(base_data))
-50.83386175502796
"""
矩阵运算
"""
base_data = np.floor((np.random.random((5,5))-0.5) * 100)
"""
[[ 39. -20. -44. -45. 6.]
[ -5. 44. 42. -33. -6.]
[-14. -9. -13. -30. -4.]
[ 31. -50. 5. 7. 45.]
[ 39. -16. 42. 39. -24.]]
"""
# 矩阵转置
print(base_data.T) 或着
print(base_data.transpose())
"""
[[ 39. -5. -14. 31. 39.]
[-20. 44. -9. -50. -16.]
[-44. 42. -13. 5. 42.]
[-45. -33. -30. 7. 39.]
[ 6. -6. -4. 45. -24.]]
"""
matri_one = np.ones((5,5))
"""
[[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.]]
"""
minu_one = np.dot(matri_one, -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.]]
"""
print(np.dot(base_data,minu_one))
"""
[[-32. -32. -32. -32. -32.]
[-84. -84. -84. -84. -84.]
[-72. -72. -72. -72. -72.]
[ 51. 51. 51. 51. 51.]
[ 46. 46. 46. 46. 46.]]
"""
"""
随机数
生成20个随机数，它们每一个都是[0.0, 1.0)之间
根据指定的shape生成随机数
生成指定范围内（[0, 100)）的指定数量（20）的随机整数
对已有的数据（[0, 1, 2, ..., 19]）的顺序随机打乱顺序
"""
print("random: {}\n".format(np.random.random(20)))
"""
random: [0.105123 0.90013672 0.58255936 0.27769054 0.00139627 0.69873449
0.32550338 0.72112185 0.35799445 0.72302835 0.67139936 0.30039148
0.83770639 0.07878046 0.77641452 0.6054163 0.72421693 0.77157218
0.08644228 0.65128463]
"""
print("rand: {}\n".format(np.random.rand(3, 4)))
"""
rand: [[0.73446485 0.30451937 0.49029421 0.62473099]
[0.09829422 0.55518899 0.83903237 0.71153898]
[0.11826133 0.53736883 0.47913765 0.0438171 ]]
"""
print("randint: {}\n".format(np.random.randint(0, 100, 20)))
"""
randint: [39 51 97 22 92 29 19 54 92 30 5 61 26 19 92 59 23 64 85 97]
"""
print("permutation: {}\n".format(np.random.permutation(np.arange(20))))
"""
permutation: [ 5 0 14 10 6 13 11 7 18 19 2 12 17 3 9 8 1 15 4 16]
"""