numpy_basic
一、Numpy是什么
- Numerical Python,数值的Python,补充了Python语言所欠缺的数值计算能力。
- Numpy是其它数据分析及机器学习库的底层库。
- Numpy完全标准C语言实现,运行效率充分优化。
- Numpy开源免费。
二、Numpy的历史
- 1995年,Numeric,Python语言数值计算扩充。
- 2001年,Scipy->Numarray,多维数组运算。
- 2005年,Numeric+Numarray->Numpy。
- 2006年,Numpy脱离Scipy成为独立的项目。
三、Numpy的核心:多维数组
- 代码简洁:减少Python代码中的循环。
- 底层实现:厚内核(C)+薄接口(Python),保证性能。
# vector.py
import datetime as dt
import numpy as np
n = 100000
start = dt.datetime.now()
A, B = [], []
for i in range(n):
A.append(i ** 2)
B.append(i ** 3)
C = []
for a, b in zip(A, B):
C.append(a + b)
print("原始方法:", (dt.datetime.now() - start).microseconds)
start = dt.datetime.now()
A, B = np.arange(n) ** 2, np.arange(n) ** 3
C = A + B
print("Numpy方法:", (dt.datetime.now() - start).microseconds)
原始方法: 106456
numpy方法: 5676
四、Numpy基础
数组对象
1. 用np.ndarray
类的对象表示n维数组
- 实际数据:数组中元素
- 元数据:描述数组中的元素
- 将实际数据与元数据分开存放,一方面提高了内存空间的使用效率,另一方面减少对实际数据的访问频率,提高性能
2. Numpy数组是同质数组,即所有元素的数据类型必须相同
3. Numpy数组的下标从0开始,最后一个元素的下标为数组长度减1
4. np.ndarray.dtype/shape/size
:类型/维度/大小
5. np.arange(起始值(0),终止值,步长(1))
->等差序列
- np.array(任何可被解释为Numpy数组的逻辑结构)
- 任意维度和类型的数组对象
# shape.py
import numpy as np
a = np.arange(1, 3)
print(a, a.shape)
b = np.array([[1, 2, 3],
[4, 5, 6]])
print(b, b.shape)
c = np.array([np.arange(1, 4), np.arange(4, 7), np.arange(7, 10)]) # 二维
print(c, c.shape)
[1 2] (2,)
[[1 2 3]
[4 5 6]] (2, 3)
[[1 2 3]
[4 5 6]
[7 8 9]] (3, 3)
# type.py
import numpy as np
a = np.arange(1, 10)
print(a, type(a[0]), a.dtype)
# 转换float类型
b = a.astype(float)
print(b, type(b[0]), b.dtype)
# 转换字符类型
c = a.astype(str)
print(c, type(c[0]), c.dtype)
[1 2 3 4 5 6 7 8 9] <class 'numpy.int64'> int64
[1. 2. 3. 4. 5. 6. 7. 8. 9.] <class 'numpy.float64'> float64
['1' '2' '3' '4' '5' '6' '7' '8' '9'] <class 'numpy.str_'> <U21
# size.py
import numpy as np
a = np.array([[10, 20, 30],
[40, 50, 60]])
print(a, a.shape, a.size, len(a)) # 一维的话len都可以,二维以上需要用size
b = a.reshape((6,))
print(b, b.shape, b.size, len(b))
[[10 20 30]
[40 50 60]] (2, 3) 6 2
[10 20 30 40 50 60] (6,) 6 6
6. 元素索引(下标)
数组对象[..., 页号, 行号, 列号]
数组对象.shape->(..., 页数, 行数, 列数)
- X号:
[0, X数-1]
# index.py
import numpy as np
a = np.array([[[1, 2],
[3, 4]],
[[5, 6],
[7, 8]]])
print(a, a.shape)
print(a[0])
print(a[0][0])
print(a[0][0][0])
# 遍历每一个元素
print("遍历每一个元素:")
for i in range(a.shape[0]): # 遍历每一页(2)
for j in range(a.shape[1]): # 遍历每一页中的每一行(2)
for k in range(a.shape[2]): # 遍历每一行中的每一列(2)
print(a[i][j][k], end=' ')
[[[1 2]
[3 4]]
[[5 6]
[7 8]]] (2, 2, 2)
[[1 2]
[3 4]]
[1 2]
1
遍历每一个元素:
1 2 3 4 5 6 7 8
7. Numpy的内部基本数据类型
- 布尔型:bool_
- 整数型:int8/int16/int32/int64
- 有符号:int8(-128~127)/int16/int32/int64
- 无符号:uint8(0~255)/uint16/uint32/uint64
- 浮点型:float16/float32/float64
- 复数型:complex64/complex128
- 字串型:str_,每个字符用32位Unicode编码表示
8. 自定义复合类型
# dtype.py
import numpy as np
a = np.array([('123', [4, 5, 6])], dtype='U3, 3i4') # 3个Unicode组成的串,3个4字节整型组成的元素
print(a, a[0]['f0'], a[0]['f1'])
b = np.array([('123', [4, 5, 6])], dtype=[('fa', np.str_, 3), ('fb', np.int32, 3)])
# 两个元组内分别代表两个元素的名称、类别、长度
print(b, b[0]['fa'], b[0]['fb'])
# 把dtype放入字典中
c = np.array([('123', [4, 5, 6])],
dtype={'names': ['fa', 'fb'],
'formats': ['U3', '3i4']})
print(c, c[0]['fa'], c[0]['fb'], d.itemsize)
# 指定内存占用空间
d = np.array([('123', [4, 5, 6])],
dtype={'fa':('U3', 0),
'fb':('3i4', 20)})
print(d, d[0]['fa'], d[0]['fb'], d.itemsize) # 显示占用内存大小,有时候内存布局会影响效率
#
e = np.array([0x1234], dtype=('>u2', {'lo':('u1', 0), # 用大于小于号规定大端小端字节序
'hi':('u1', 1)}))
print('{:x} {:x}'.format(e['lo'][0], e['hi'][0]))
[('123', [4, 5, 6])] 123 [4 5 6]
[('123', [4, 5, 6])] 123 [4 5 6]
[('123', [4, 5, 6])] 123 [4 5 6] 32
[('123', [4, 5, 6])] 123 [4 5 6] 32
12 34
9. 类型字符码
np.bool_: ?
np.int8: b
np.uint8: B
np.int8/16/32/64: i1/2/4/8
np.uint8/16/32/64: u1/2/4/8
np.float/16/32/64: f2/4/8
np.complex64/128: c8/16
np.str_: U<字符数>
np.datetime64: M8
- 字节序前缀,用于多字节整数和字符串:
</>/[=]
分别表示小端/大端/硬件字节序。
-
>3i4
:大端字节序,3个元素的一维数组,每个元素都是整型,每个整型元素占4个字节。<(2,3)u8
:小端字节序,6个元素2行3列的二维数组,每个元素都是无符号整型,每个无符号整型元素占8个字节。>U7
: 包含7个字符的Unicode字符串,每个字符占4个字节,采用大端字节序。
10. 切片
数组对象[起始位置:终止位置:位置步长, ...]
- 缺省起始位置:(位置步长+)首/(位置步长-)尾
- 缺省终止位置:(位置步长+)尾后/(位置步长-)首前
- 缺省位置步长:1
# slice.py
import numpy as np
a = np.arange(1, 10)
print(a)
print(a[:3]) # 切到第四个元素之前
print(a[3:6])
print(a[6:]) # 从第七个元素取到最后
print(a[::-1])
print(a[:-4:-1])
print(a[-4:-7:-1])
print(a[-7::-1])
print(a[::])
print(a[:])
print(a[::3])
print("========三维========")
b = np.arange(1, 25).reshape(2, 3, 4)
print(b)
print("========切片========")
print(b[:, 0, 0])
print(b[0, :, :])
print(b[0, 1])
print(b[0, 1, ::2])
print(b[..., 1])
print(b[:, 1])
print(b[0, 1, 1::2])
print(b[0, :, -1])
print(b[0, ::-1, -1])
print(b[0, ::2, -1])
print(b[::-1, ::-1])
print(b[..., ::-1])
print(b[-1, 1:, 2:])
[1 2 3 4 5 6 7 8 9]
[1 2 3]
[4 5 6]
[7 8 9]
[9 8 7 6 5 4 3 2 1]
[9 8 7]
[6 5 4]
[3 2 1]
[1 2 3 4 5 6 7 8 9]
[1 2 3 4 5 6 7 8 9]
[1 4 7]
========三维========
[[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
[[13 14 15 16]
[17 18 19 20]
[21 22 23 24]]]
========切片========
[ 1 13]
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
[5 6 7 8]
[5 7]
[[ 2 6 10]
[14 18 22]]
[[ 5 6 7 8]
[17 18 19 20]]
[6 8]
[ 4 8 12]
[12 8 4]
[ 4 12]
[[[21 22 23 24]
[17 18 19 20]
[13 14 15 16]]
[[ 9 10 11 12]
[ 5 6 7 8]
[ 1 2 3 4]]]
[[[ 4 3 2 1]
[ 8 7 6 5]
[12 11 10 9]]
[[16 15 14 13]
[20 19 18 17]
[24 23 22 21]]]
[[19 20]
[23 24]]
11. 改变维度
- 返回一个具有新维度的新数组对象
- 视图变维
reshape/ravel
- 数据共享
- 复制变维
flatten
- 数据独立
- 视图变维
- 就地变维,在原数组对象之上,改变其维度,不返回新数组
xxx.shape = ...
xxx.resize(...)
# reshape.py
a = np.arange(1, 9)
print(a)
b = a.reshape(2, 4)
print(b)
c = b.reshape(2, 2, 2)
print(c)
d = c.ravel()
print(d)
e = c.flatten()
print(e)
a += 10
print(a)
print("================")
print(b, c, d, e) # a中的数据做出改变,abcd都会改变,由于数据共享,e使用的是flatten,数据独立
a.shape = (2, 4)
print(a)
f = b.transpose() # 转置,同样也是视图变维
print(f)
[1 2 3 4 5 6 7 8]
[[1 2 3 4]
[5 6 7 8]]
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]
[1 2 3 4 5 6 7 8]
[1 2 3 4 5 6 7 8]
[11 12 13 14 15 16 17 18]
================
[[11 12 13 14]
[15 16 17 18]] [[[11 12]
[13 14]]
[[15 16]
[17 18]]] [11 12 13 14 15 16 17 18] [1 2 3 4 5 6 7 8]
[[11 12 13 14]
[15 16 17 18]]
[[11 15]
[12 16]
[13 17]
[14 18]]
12. 组合与拆分
- 垂直:
np.vstack((上, 下))
->组合数组np.vsplit(数组, 份数)
->拆分:上, ..., 下np.concatenate((上, 下), axis=0)
->组合数组np.split(数组, 份数, axis=0)
->拆分
- 水平:
np.hstack((左, 右))
->组合数组np.hsplit(数组, 份数)
->拆分:左, ..., 右np.concatenate((左, 右), axis=1)
->组合数组np.split(数组, 份数, axis=1)
->拆分
- axis表示轴向
- 二维:0-行,垂直,1-列,水平
三维:0-页,深度,1-行,垂直,2-列,水平
- 深度:
np.dstack((前, 后))
->组合数组np.dsplit(数组, 份数)
->前, ..., 后
- 行列(可以用一维数组做参数)
np.row_stack((上, 下))
->组合数组np.column_stack((左, 右))
->组合数组
# stack.py
import numpy as np
a = np.arange(11, 20).reshape(3, 3)
print(a)
b = a + 10
print(b)
c = np.vstack((a,b))
print(c)
d = np.concatenate((a, b), axis=0)
print(d)
e, f = np.vsplit(c, 2)
print("e, f:", e, f, sep='\n')
g, h = np.split(d, 2, axis=0)
print("g, h:", e, f, sep='\n')
i = np.hstack((a, b))
print(i)
j = np.concatenate((a, b), axis=1)
print(j)
k, l = np.hsplit(i, 2)
print("k, l:", k, l, sep='\n')
m, n = np.split(j, 2, axis=1)
print("m, n:", m, n, sep='\n')
o = np.dstack((a, b))
print(o)
p, q = np.dsplit(o, 2)
print("p, q:", p.T[0].T, q.T[0].T, sep='\n')
a, b = a.ravel(), b.ravel()
print(a, b)
r = np.row_stack((a, b))
print(r)
[[11 12 13]
[14 15 16]
[17 18 19]]
[[21 22 23]
[24 25 26]
[27 28 29]]
[[11 12 13]
[14 15 16]
[17 18 19]
[21 22 23]
[24 25 26]
[27 28 29]]
[[11 12 13]
[14 15 16]
[17 18 19]
[21 22 23]
[24 25 26]
[27 28 29]]
e, f:
[[11 12 13]
[14 15 16]
[17 18 19]]
[[21 22 23]
[24 25 26]
[27 28 29]]
g, h:
[[11 12 13]
[14 15 16]
[17 18 19]]
[[21 22 23]
[24 25 26]
[27 28 29]]
[[11 12 13 21 22 23]
[14 15 16 24 25 26]
[17 18 19 27 28 29]]
[[11 12 13 21 22 23]
[14 15 16 24 25 26]
[17 18 19 27 28 29]]
k, l:
[[11 12 13]
[14 15 16]
[17 18 19]]
[[21 22 23]
[24 25 26]
[27 28 29]]
m, n:
[[11 12 13]
[14 15 16]
[17 18 19]]
[[21 22 23]
[24 25 26]
[27 28 29]]
[[[11 21]
[12 22]
[13 23]]
[[14 24]
[15 25]
[16 26]]
[[17 27]
[18 28]
[19 29]]]
p, q:
[[11 12 13]
[14 15 16]
[17 18 19]]
[[21 22 23]
[24 25 26]
[27 28 29]]
[11 12 13 14 15 16 17 18 19] [21 22 23 24 25 26 27 28 29]
[[11 12 13 14 15 16 17 18 19]
[21 22 23 24 25 26 27 28 29]]
13. ndarray类的属性
- shape - 维度
- dtype - 元素类型
- size - 元素数量
- ndim - 维数,len(shape)
- itemsize - 元素字节数
- nbytes - 总字节数 = size x itemsize
- real - 复数数组的实部数组
- imag - 复数数组的虚部数组
- T - 数组对象的转置视图
- flat - 扁平迭代器
- 数组对象.tolist()->列表
# attr.py
a = np.array([[1 + 1j, 2 + 4j, 3 + 7j],
[4 + 2j, 5 + 5j, 6 + 8j],
[7 + 3j, 8 + 6j, 9 + 9j]])
print(a.shape)
print(a.dtype)
print(a.size)
print(a.ndim)
print(a.size)
print(a.itemsize)
print(a.nbytes)
print(a.real, a.imag, sep='\n')
print(a.T)
print([elem for elem in a.flat])
b = a.tolist()
print(b)
(3, 3)
complex128
9
2
9
16
144
[[1. 2. 3.]
[4. 5. 6.]
[7. 8. 9.]]
[[1. 4. 7.]
[2. 5. 8.]
[3. 6. 9.]]
[[1.+1.j 4.+2.j 7.+3.j]
[2.+4.j 5.+5.j 8.+6.j]
[3.+7.j 6.+8.j 9.+9.j]]
[(1+1j), (2+4j), (3+7j), (4+2j), (5+5j), (6+8j), (7+3j), (8+6j), (9+9j)]
[[(1+1j), (2+4j), (3+7j)], [(4+2j), (5+5j), (6+8j)], [(7+3j), (8+6j), (9+9j)]]