numpy_basic

一、Numpy是什么

1. Numerical Python，数值的Python，补充了Python语言所欠缺的数值计算能力。
2. Numpy是其它数据分析及机器学习库的底层库。
3. Numpy完全标准C语言实现，运行效率充分优化。
4. Numpy开源免费。

---

二、Numpy的历史

1. 1995年，Numeric，Python语言数值计算扩充。
2. 2001年，Scipy->Numarray，多维数组运算。
3. 2005年，Numeric+Numarray->Numpy。
4. 2006年，Numpy脱离Scipy成为独立的项目。

---

三、Numpy的核心：多维数组

1. 代码简洁：减少Python代码中的循环。
2. 底层实现：厚内核(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)]]