Numpy是用Python进行科学计算，尤其是数据分析时，所用到的一个基础库。它是大量python数学和科学计算包的基础，比如后面要讲到的pandas库就用到了Numpy。pandas库专门用于数据分析，充分借鉴了Python标准库Numpy的相关概念。而Python标准库所提供的内置工具对数据分析方面的大多数计算来说都过于简单或不够用。
为了更好地理解和是用Python所有的科学计算包，尤其是pandas,需要先行掌握Numpy库的用法，这样才能把pandas的用法发挥到极致。
NumPy - 数据类型
NumPy 支持比 Python 更多种类的数值类型。 下表显示了 NumPy 中定义的不同标量数据类型。
| 数据类型 | 类型代码 | 描述 |
|---|---|---|
| bool_ | 存储为一个字节的布尔值（真或假） | |
| int_ | 默认整数，相当于 C 的long，通常为int32或int64 | |
| intc | 相当于 C 的int，通常为int32或int64 | |
| intp | 用于索引的整数，相当于 C 的size_t，通常为int32或int64 | |
| int8 | i1 | 字节（-128 ~ 127） |
| int16 | i2 | 16 位整数（-32768 ~ 32767） |
| int32 | i4 | 32 位整数（-2147483648 ~ 2147483647） |
| int64 | i8 | 64 位整数（-9223372036854775808 ~ 9223372036854775807） |
| uint8 | u1 | 8 位无符号整数（0 ~ 255） |
| uint16 | u2 | 16 位无符号整数（0 ~ 65535） |
| uint32 | u4 | 32 位无符号整数（0 ~ 4294967295） |
| uint64 | u8 | 64 位无符号整数（0 ~ 18446744073709551615） |
| float_ | float64的简写 | |
| float16 | f2 | 半精度浮点：符号位，5 位指数，10 位尾数 |
| float32 | f4或者f | 单精度浮点：符号位，8 位指数，23 位尾数 |
| float64 | f8或者d | 双精度浮点：符号位，11 位指数，52 位尾数 |
| complex_ | c16 | complex128的简写 |
| complex64 | c8 | 复数，由两个 32 位浮点表示（实部和虚部） |
| omplex128 | c16 | 复数，由两个 64 位浮点表示（实部和虚部） |
| bool | ? | 存储True和False值的布尔类型 |
| object | O | python对象类型 |
| String | S | 固定场读字符串类型（每一个字符一个字节）。创建一个长度为8的字符串，应该使用S8 |
| Unicode_ | U | 固定长度的unicode类型（字节数由平台决定），和字符串定义方式一样 |
np.array([1,2],dtype='f8') |
结果：array([1., 2.])
建立ndarray多维数组
n3 = np.array( |
array([[[1, 2, 3, 4],
[2, 3, 4, 5]],
[[3, 4, 5, 6],
[4, 5, 6, 7]]])
n3.ndim #维度 |
- 3
n3.shape #形状 |
- (2, 2, 4)
n3.itemsize #每个元素的长度为几个字节 |
- 4
n3.size #数组长度 |
- 16
n3.data #指向数组数据开始的Python缓冲区对象 |
n4 = np.array( |
array([[[1, 2, 3, 4],
[2, 3, 4, 5]],
[[3, 4, 5, 6],
[4, 5, 6, 7]],
[[3, 4, 5, 6],
[4, 5, 6, 7]]])
n4.shape |
- (3, 2, 4)
n5 = np.array([['1','2']]) |
#<表示字节顺序，小端（最小有效字节存储在最小地址中）| ：忽视字节顺序 |
- dtype(‘<U1’)
n5.dtype.name |
- ‘str32’
n6 = np.array([['12','22']]) |
- dtype(‘<U2’)
np.array(['Python','tanzhou ','hello','sa'],dtype='<U4') |
- array([‘Pyth’, ‘tanz’, ‘hell’, ‘sa’], dtype=’<U4’)
np.array(['1','2 ','2'],dtype='int') |
- array([1, 2, 2])
np.array(['1.1','2 ','2'],dtype='float') |
- array([1.1, 2. , 2. ])
n6.size |
- 2
n6.dtype.type |
- numpy.str_
n4[0][0][2] |
- 3
x = np.zeros((3,3)) #生成指定维度的全0矩阵 |
array([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])
y = np.zeros([3,3]) |
array([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])
np.ones((3,4,5),dtype=np.int) #生成指定维度的全1矩阵 |
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, 1, 1],
[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1]]])
np.empty((3,4)) #生成指定维度的垃圾值矩阵，只分配，不对其进行初始化 |
输出：
array([[4.6e-322, 0.0e+000, 0.0e+000, 0.0e+000],
[0.0e+000, 0.0e+000, 0.0e+000, 0.0e+000],
[0.0e+000, 0.0e+000, 0.0e+000, 0.0e+000]])
a = np.zeros((3,4,5)) |
array([[[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.]],
[[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.]],
[[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.]]])
b = np.zeros_like(a) |
out:
array([[[0., 0., 0., 0., 0.], |
In:
c = np.ones_like(a) |
out:
array([[[1., 1., 1., 1., 1.], |
in:
np.arange(0,10) #生成数值序列的数组 类似python range |
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
np.arange(0,10,0.6) |
array([0. , 0.6, 1.2, 1.8, 2.4, 3. , 3.6, 4.2, 4.8, 5.4, 6. , 6.6, 7.2,7.8, 8.4, 9. , 9.6])
np.arange(0,12).reshape(3,4) |
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
np.linspace(0,10,5) |
array([ 0. , 2.5, 5. , 7.5, 10. ])
np.logspace(0,2,5) #0 表示 10^0 2 表示10^2 5个元素等比数列 |
array([ 1. , 3.16227766, 10. , 31.6227766 , 100. ])
np.logspace(0,2,5,endpoint=False) #10**(0.4)=2.51188643150958 |
array([ 1. , 2.51188643, 6.30957344, 15.84893192, 39.81071706])
np.logspace(0,1,12,base=2,endpoint=False) |
array([1. , 1.05946309, 1.12246205, 1.18920712, 1.25992105,
1.33483985, 1.41421356, 1.49830708, 1.58740105, 1.68179283,
1.78179744, 1.88774863])
np.logspace(0,1,12,base=np.e) |
array([1. , 1.09516944, 1.1993961 , 1.31354196, 1.43855101,
1.5754571 , 1.72539247, 1.88959711, 2.06942901, 2.26637541,
2.48206508, 2.71828183])
np.random.random(3) |
array([0.42129851, 0.82031203, 0.2013445 ])
a = np.arange(0, 40, 10) |
[ 0 10 20 30]
array([[ 0, 10, 20, 30, 0, 10, 20, 30, 0, 10, 20, 30, 0, 10, 20, 30,
0, 10, 20, 30],
[ 0, 10, 20, 30, 0, 10, 20, 30, 0, 10, 20, 30, 0, 10, 20, 30,
0, 10, 20, 30],
[ 0, 10, 20, 30, 0, 10, 20, 30, 0, 10, 20, 30, 0, 10, 20, 30,
0, 10, 20, 30]])
s = b'Hello World' |
array([ 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100], dtype=int8)
np.fromfile('save_date.npy') |
array([1.87585069e-309, 1.17119999e+171, 5.22741680e-037, 8.44740097e+252,
2.65141232e+180, 9.92152605e+247, 2.16209968e+233, 1.05176541e-153,
6.01399921e-154, 6.01347002e-154, 6.01347002e-154, 6.01347002e-154,
6.01347002e-154, 6.01347002e-154, 6.01347002e-154, 6.55490914e-260,
6.54218855e-001, 3.99443697e-001, 4.50091561e-001, 6.60862373e-001,
8.77753297e-001, 3.89115607e-001, 9.45576953e-001, 4.07118309e-001,
3.05937465e-001, 7.01606366e-001, 9.23868345e-001, 3.49139962e-001,
2.71655829e-001, 6.88059971e-001, 1.25104393e-001, 5.42319627e-001])
def func(i,x): |
array([[0., 0.],
[1., 1.],
[2., 2.],
[3., 3.],
[4., 4.],
[5., 5.],
[6., 6.],
[7., 7.],
[8., 8.],
[9., 9.]])
def func2(i,j): |
array([[ 1., 2., 3., 4., 5., 6., 7., 8., 9.],
[ 2., 4., 6., 8., 10., 12., 14., 16., 18.],
[ 3., 6., 9., 12., 15., 18., 21., 24., 27.],
[ 4., 8., 12., 16., 20., 24., 28., 32., 36.],
[ 5., 10., 15., 20., 25., 30., 35., 40., 45.],
[ 6., 12., 18., 24., 30., 36., 42., 48., 54.],
[ 7., 14., 21., 28., 35., 42., 49., 56., 63.],
[ 8., 16., 24., 32., 40., 48., 56., 64., 72.],
[ 9., 18., 27., 36., 45., 54., 63., 72., 81.]])
基本操作
算术运算符
| 算术 | 函数 |
|---|---|
| y = x1 + x2 | add(x1, x2 [, y]) |
| y = x1 - x2 | subtract(x1, x2 [, y]) |
| y = x1 * x2 | multiply (x1, x2 [, y]) |
| y = x1 / x2 | divide (x1, x2 [, y]), 如果两个数组的元素为整数，那么用整数除法 |
| y = x1 / x2 | true_divide (x1, x2 [, y]), 总是返回精确的商 |
| y = x1 // x2 | floor_divide (x1, x2 [, y]), 总是对返回值取整 |
| y = - x | negative(x [,y]) |
| y = x1 ** x 2 | power(x1, x2 [, y]) |
| y = x1 % x2 | remainder(x1, x2 [, y]),或mod(x1, x2, [, y]) |
a = np.arange(4) |
array([0, 1, 2, 3])
b = a+4 |
array([4, 5, 6, 7])
a*2 |
array([0, 2, 4, 6])
c = a + b #元素级操作，对应位置元素运算组成新数组 |
array([ 4, 6, 8, 10])
c-a |
array([4, 5, 6, 7])
a * np.sin(b) #正弦曲线 |
array([-0. , -0.95892427, -0.558831 , 1.9709598 ])
a * np.sqrt(b) #平方根 |
array([0. , 2.23606798, 4.89897949, 7.93725393])
A = np.arange(0,9).reshape(3,3) |
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
B = np.ones((3,3)) |
array([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])
A*B |
array([[0., 1., 2.],
[3., 4., 5.],
[6., 7., 8.]])
矩阵积
np.dot(A,B) |
array([[ 3., 3., 3.],
[12., 12., 12.],
[21., 21., 21.]])
A.dot(B) |
array([[ 3., 3., 3.],
[12., 12., 12.],
[21., 21., 21.]])
B.dot(A) |
array([[ 9., 12., 15.],
[ 9., 12., 15.],
[ 9., 12., 15.]])
自增自减
a = np.arange(4) |
array([0, 1, 2, 3])
a += 1 |
array([1, 2, 3, 4])
a -= 1 |
array([0, 1, 2, 3])
a *= 2 |
array([0, 2, 4, 6])
a+=1 |
array([1, 3, 5, 7])
通用函数
通用函数（ufunc）是一种对ndarray中的数据执行元素级运算的函数。
一元ufunc
| 函数 | 说明 |
|---|---|
| abs、fabs | 计算整数、浮点数或复数的绝对值 |
| sqrt | 计算各元素平方根 |
| square | 计算各元素平方 |
| exp | 计算各元素的指数 |
| log、log10、log2、log1p | 分别为自然对数(底数为e)、底数为10的log、底数为2的log、log(1+x) |
| sign | 计算各元素的正负号 |
| ceil | 计算各元素的ceiling值，即大于等于该值的最小整数 |
| floor | 计算各元素的floor值，即小于等于该值的最大整数 |
| rint | 将各元素值四舍五入到最接近的 |
| modf | 将数组的小数和整数部分以两个独立的数组形式返回 |
| isnan | “哪些值是NaN” 返回布尔值 |
| isfinite、isinf | “哪些元素是有穷的” “哪些元素是无穷的” |
| cos、cosh、sin、sinh、tan、tanh | 普通型和双曲型三角函数 |
| arccos、arccosh、arcsin、arcsinh、arctan、arctanh | 反三角函数 |
| logical_not | 计算各元素not x的真值，相当于 |
二元ufunc
| 函数 | 说明 |
|---|---|
| add | 元素相加 |
| subtract | 从第一个数组中减去第二个数组的元算 |
| multiply | 元素相乘 |
| divide、floor_divide | 除法或向下圆整除法（丢弃余数） |
| power | A的b次方 |
| maximum、fmax | 元素级的最大值计算。fmax将忽略nan |
| minimum、fmin | 元素级的最小值计算。fmin将忽略nan |
| mod | 元素级的求模计算（除法） |
| copysign | 将第二个数组中的值的符号复制给第一个数组中的 |
| greater、greater_equal、less、less_equal、equal、not_equal | 执行元素级的比较运算，产生布尔型数组 |
| logical_and、logical_or、logical_xor | 执行元素级的真值逻辑运算。相当于& \ |
a = np.arange(1,5) |
array([1, 2, 3, 4])
b = np.arange(1,5) |
array([1, 2, 3, 4])
np.add(a,b) |
array([2, 4, 6, 8])
np.sqrt(a) |
array([1. , 1.41421356, 1.73205081, 2. ])
np.log(a) |
array([0. , 0.69314718, 1.09861229, 1.38629436])
np.sin(a) |
array([ 0.84147098, 0.90929743, 0.14112001, -0.7568025 ])
x = np.random.rand(12).reshape(3,4) |
array([[0.07660223, 0.88255407, 0.24269254, 0.18597141],
[0.25274604, 0.80124666, 0.9287589 , 0.91310848],
[0.28050844, 0.17827769, 0.98518043, 0.05057346]])
np.sort(x) #每行 |
array([[0.07660223, 0.18597141, 0.24269254, 0.88255407],
[0.25274604, 0.80124666, 0.91310848, 0.9287589 ],
[0.05057346, 0.17827769, 0.28050844, 0.98518043]])
np.sort(x,axis = 0) |
array([[0.07660223, 0.17827769, 0.24269254, 0.05057346],
[0.25274604, 0.80124666, 0.9287589 , 0.18597141],
[0.28050844, 0.88255407, 0.98518043, 0.91310848]])
j = np.argsort(x) #每行，索引 |
array([[0, 3, 2, 1],
[0, 1, 3, 2],
[3, 1, 0, 2]], dtype=int64)
聚合函数
a = np.array([3.3,4.4,5.5,6.6,7.7],dtype='f8') |
array([3.3, 4.4, 5.5, 6.6, 7.7])
a.sum() |
27.499999999999996
a.min() |
3.3
a.max() |
7.7
a.mean() |
5.499999999999999
a.std() |
1.5556349186104046
索引机制、切片和迭代方法
a = np.arange(10,16) |
array([10, 11, 12, 13, 14, 15])
a[4] |
14
a[-1] |
15
a[:] |
array([10, 11, 12, 13, 14, 15])
a[1:3] |
array([11, 12])
a[1:5:2] |
array([11, 13])
A = np.arange(10,19).reshape(3,3) |
array([[10, 11, 12],
[13, 14, 15],
[16, 17, 18]])
A[1,2] |
15
A[0:] |
array([[10, 11, 12],
[13, 14, 15],
[16, 17, 18]])
A[:,0] |
array([10, 13, 16])
A[0:2,0:2] |
array([[10, 11],
[13, 14]])
A[[0,2],0:2] #抽取行或列的索引不连续，可以吧这几个索引放在数组中 |
array([[10, 11],
[16, 17]])
数组迭代
for row in A: |
[10 11 12]
[13 14 15]
[16 17 18]
for item in A.flat: #遍历每一个元素，A.flat |
10
11
12
13
14
15
16
17
18
除了for循环，Numpy提供了更为优雅的遍历方法
通常用函数处理行、列或单个元素时，需要用到遍历。如果想用聚合函数处理每一列或行，返回一个数值作为结果，做好用纯NumPy方法处理循环：apply_along_axis()函数
np.apply_along_axis(np.mean,axis = 0,arr = A ) #axis 为0 按列 |
array([13., 14., 15.])
np.apply_along_axis(np.mean,axis = 1,arr = A ) #axis 为1 按行 |
array([11., 14., 17.])
def foo(x): |
array([[5. , 5.5, 6. ],
[6.5, 7. , 7.5],
[8. , 8.5, 9. ]])
条件和布尔数组
A = np.random.random((4,4)) |
array([[0.06191449, 0.69862293, 0.60835369, 0.46886347],
[0.06462235, 0.76134531, 0.22378327, 0.13396092],
[0.81113357, 0.84190968, 0.97530762, 0.55843035],
[0.89516065, 0.42526586, 0.54832821, 0.63796767]])
A<0.5 |
array([[ True, False, False, True],
[ True, False, True, True],
[False, False, False, False],
[False, True, False, False]])
A[A<0.5] |
array([0.06191449, 0.46886347, 0.06462235, 0.22378327, 0.13396092,
0.42526586])
形状变换
a = np.random.random(12) |
array([0.20564606, 0.13384151, 0.14979041, 0.52310893, 0.29431663,0.21416307, 0.97855221, 0.96023057, 0.88113124, 0.70537608,0.2383707 , 0.80332851])
A = a.reshape(3,4) #返回新数组，创建新对象 |
array([[0.20564606, 0.13384151, 0.14979041, 0.52310893],
[0.29431663, 0.21416307, 0.97855221, 0.96023057],
[0.88113124, 0.70537608, 0.2383707 , 0.80332851]])
a.shape = 3,4 #a.shape = （3,4） |
array([[0.20564606, 0.13384151, 0.14979041, 0.52310893],
[0.29431663, 0.21416307, 0.97855221, 0.96023057],
[0.88113124, 0.70537608, 0.2383707 , 0.80332851]])
a = a.ravel() |
array([0.20564606, 0.13384151, 0.14979041, 0.52310893, 0.29431663,
0.21416307, 0.97855221, 0.96023057, 0.88113124, 0.70537608,
0.2383707 , 0.80332851])
a.shape = (3,4) |
array([[0.20564606, 0.13384151, 0.14979041, 0.52310893],
[0.29431663, 0.21416307, 0.97855221, 0.96023057],
[0.88113124, 0.70537608, 0.2383707 , 0.80332851]])
a.shape = 12 |
array([0.20564606, 0.13384151, 0.14979041, 0.52310893, 0.29431663,
0.21416307, 0.97855221, 0.96023057, 0.88113124, 0.70537608,
0.2383707 , 0.80332851])
A.transpose() |
array([[0.20564606, 0.29431663, 0.88113124],
[0.13384151, 0.21416307, 0.70537608],
[0.14979041, 0.97855221, 0.2383707 ],
[0.52310893, 0.96023057, 0.80332851]])
A.T |
array([[0.20564606, 0.29431663, 0.88113124],
[0.13384151, 0.21416307, 0.70537608],
[0.14979041, 0.97855221, 0.2383707 ],
[0.52310893, 0.96023057, 0.80332851]])
数组操作
连接数组
A = np.ones((3,3)) |
array([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])
B |
array([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])
np.vstack((A,B)) |
array([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.],
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])
np.hstack((A,B)) |
array([[1., 1., 1., 0., 0., 0.],
[1., 1., 1., 0., 0., 0.],
[1., 1., 1., 0., 0., 0.]])
c = np.arange(16).reshape(4,4) |
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
a = np.array([0,1,2]) |
np.column_stack((a,b,c)) |
array([[0, 3, 6],
[1, 4, 7],
[2, 5, 8]])
np.row_stack((a,b,c)) |
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
数组切分
A = np.arange(16).reshape((4,4)) |
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
[B,C] = np.hsplit(A,2) |
array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]])
C |
array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])
[B,C] = np.vsplit(A,2) |
array([[0, 1, 2, 3],
[4, 5, 6, 7]])
C |
array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])
[A1,A2,A3] = np.split(A,[1,3],axis=1) #axis = 0 按行切分，axis = 1 按列切分 |
A1 |
array([[ 0],
[ 4],
[ 8],
[12]])
A2 |
array([[ 1, 2],
[ 5, 6],
[ 9, 10],
[13, 14]])
A3 |
array([[ 3],
[ 7],
[11],
[15]])
[A1,A2,A3] = np.split(A,[1,3],axis=0) |
A1 |
array([[0, 1, 2, 3]])
A2 |
array([[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
A3 |
array([[12, 13, 14, 15]])
广播机制
广播机制这一操作实现了对两个或以上数组进行运算或用函数处理，即使这些数组形状并不完全相同。并不是所有的维度都要彼此兼容才符合广播机制的要求，但它们必须满足一定的条件。
若两个数组的各维度兼容，也就是两个数组的每一维等长，或其中一个数组为一维，那么广播机制就适用。如果这两个条件都不能满足，Numpy就会抛出异常，说两个数组不兼容。
广播机制两条规则。第一条是为缺失的维度补上个1.如果这时满足兼容性条件，就可以应用光比机制。再来看第二条规则。 第二条规则鉴定缺失元素（一维）都用已有值进行了补充。
A = np.arange(16).reshape(4,4) |
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
b |
array([0, 1, 2, 3])
A + b |
array([[ 0, 2, 4, 6],
[ 4, 6, 8, 10],
[ 8, 10, 12, 14],
[12, 14, 16, 18]])
m = np.arange(6).reshape(3,1,2) |
array([[[0, 1]],
[[2, 3]],
[[4, 5]]])
n |
array([[[0],
[1]],
[[2],
[3]],
[[4],
[5]]])
m + n |
array([[[ 0, 1],
[ 1, 2]],
[[ 4, 5],
[ 5, 6]],
[[ 8, 9],
[ 9, 10]]])
结构化数组
structarray = np.array([(1,'First',0.5,1+2j),(2,'Second',1.3,2-2j),(3,'Third',0.8,1+3j)],dtype=('i2,a6,f4,c8')) |
array([(1, b'First', 0.5, 1.+2.j), (2, b'Second', 1.3, 2.-2.j),
(3, b'Third', 0.8, 1.+3.j)],
dtype=[('f0', '<i2'), ('f1', 'S6'), ('f2', '<f4'), ('f3', '<c8')])
structarray = np.array([(1,'First',0.5,1+2j),(2,'Second',1.3,2-2j),(3,'Third',0.8,1+3j)]) |
array([['1', 'First', '0.5', '(1+2j)'],
['2', 'Second', '1.3', '(2-2j)'],
['3', 'Third', '0.8', '(1+3j)']], dtype='<U11')
structarray = np.array([(1,'First',0.5,1+2j),(2,'Second',1.3,2-2j),(3,'Third',0.8,1+3j)],dtype=[('id','<i2'),('position','S6'),('value','f4'),('complex','c8')]) |
array([(1, b'First', 0.5, 1.+2.j), (2, b'Second', 1.3, 2.-2.j),
(3, b'Third', 0.8, 1.+3.j)],
dtype=[('id', '<i2'), ('position', 'S6'), ('value', '<f4'), ('complex', '<c8')])
数组数据文件的读写
data = np.random.random(16).reshape(4,4) |
array([[0.51264409, 0.4027414 , 0.49030108, 0.60320778],
[0.09145262, 0.15780606, 0.43957007, 0.46891392],
[0.60041983, 0.93856545, 0.22183402, 0.51324425],
[0.76605488, 0.74672403, 0.02454652, 0.85436632]])
np.save('save_date',data) |
loaded_data = np.load('save_date.npy') |
loaded_data |
array([[0.51264409, 0.4027414 , 0.49030108, 0.60320778],
[0.09145262, 0.15780606, 0.43957007, 0.46891392],
[0.60041983, 0.93856545, 0.22183402, 0.51324425],
[0.76605488, 0.74672403, 0.02454652, 0.85436632]])
data = np.array([(1., 123., 1.4, 23.), (2., 110., 0.5, 18.), (3., 164., 2.1, 19.)], |
np.savetxt('datas.csv',data,delimiter=',') |
np.loadtxt('datas.csv',delimiter=',') |
array([[ 1. , 123. , 1.4, 23. ],
[ 2. , 110. , 0.5, 18. ],
[ 3. , 164. , 2.1, 19. ]])
读写文本格式的数据（如TXT或CSV）
data = np.genfromtxt('data.csv',delimiter=',',names = True) #文件名，分割值的字符，是否含有标题 |
data |
array([(1., 123., 1.4, 23.), (2., 110., 0.5, 18.), (3., 164., 2.1, 19.)],
dtype=[('id', '<f8'), ('value1', '<f8'), ('value2', '<f8'), ('value3', '<f8')])
data['id'] |
array([1., 2., 3.])
np.where函数
np.where函数是三元表达式 x if condition else y 的矢量化版本
x = np.array([2,3,4,5,6,]) |
array([ 2, 11, 4, 5, 14])
处理缺失值
data =np.array([[1,2,np.NaN,4],[np.NaN,2,3,4]]) |
array([[ 1., 2., nan, 4.],
[nan, 2., 3., 4.]])
np.isnan(data) |
array([[False, False, True, False],
[ True, False, False, False]])
np.where(np.isnan(data),0,data) |
array([[1., 2., 0., 4.],
[0., 2., 3., 4.]])
数组去重
np.unique([1, 1, 2, 2, 3, 3]) |
array([1, 2, 3])
a = np.array([[1, 1], [2, 3]]) |
array([1, 2, 3])