Numpy的介绍和使用

介绍

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

NumPy 的前身 Numeric 最早是由 Jim Hugunin 与其它协作者共同开发，2005 年，Travis Oliphant 在 Numeric 中结合了另一个同性质的程序库 Numarray 的特色，并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。

NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：

• 一个强大的N维数组对象 ndarray
• 广播功能函数
• 整合 C/C++/Fortran 代码的工具
• 线性代数、傅里叶变换、随机数生成等功能

Ndarray

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。

ndarray 对象是用于存放同类型元素的多维数组。

ndarray 中的每个元素在内存中都有相同存储大小的区域。

ndarray 内部由以下内容组成：

• 一个指向数据（内存或内存映射文件中的一块数据）的指针。
• 数据类型或 dtype，描述在数组中的固定大小值的格子。
• 一个表示数组形状（shape）的元组，表示各维度大小的元组。
• 一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。

ndarray 的内部结构:

跨度可以是负数，这样会使数组在内存中后向移动，切片中 obj[::-1] 或 obj[:,::-1] 就是如此。

创建一个 ndarray 只需调用 NumPy 的 array 函数即可：

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

名称	描述
object	数组或嵌套的数列
dtype	数组元素的数据类型，可选
copy	对象是否需要复制，可选
order	创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok	默认返回一个与基类类型一致的数组
ndmin	指定生成数组的最小维度

import numpy as np

score = np.array([[80, 89, 86, 67, 79],
                  [78, 97, 89, 67, 81],
                  [90, 94, 78, 67, 74],
                  [91, 91, 90, 67, 69],
                  [76, 87, 75, 67, 86],
                  [70, 79, 84, 67, 84],
                  [94, 92, 93, 67, 64],
                  [86, 85, 83, 67, 80]])
print(score)
print(type(score))

输出

[[80 89 86 67 79]
 [78 97 89 67 81]
 [90 94 78 67 74]
 [91 91 90 67 69]
 [76 87 75 67 86]
 [70 79 84 67 84]
 [94 92 93 67 64]
 [86 85 83 67 80]]
<class 'numpy.ndarray'>

ndarray与Python原生list运算效率对比

# ndarray和list效率对比
python_list = []
start_time = datetime.datetime.now()
for i in range(100000000):
    python_list.append(random.random())
end_time = datetime.datetime.now()
print("list的运行时间:", end_time-start_time)

start_time = datetime.datetime.now()
ndarray_list = np.array(python_list)
end_time = datetime.datetime.now()
print("ndarray的运行时间:", end_time-start_time)

输出

list的运行时间: 0:00:22.598421
ndarray的运行时间: 0:00:04.590315

啧啧啧，这能比？？？

为啥Ndarray这么快

1. 内存块风格

   ndarray到底跟原生python列表有什么不同呢，请看一张图：

   

   从图中我们可以看出ndarray在存储数据的时候，数据与数据的地址都是连续的，这样就给使得批量操作数组元素时速度更快。

   这是因为ndarray中的所有元素的类型都是相同的，而Python列表中的元素类型是任意的，所以ndarray在存储元素时内存可以连续，而python原生list就只能通过寻址方式找到下一个元素，这虽然也导致了在通用性能方面Numpy的ndarray不及Python原生list，但在科学计算中，Numpy的ndarray就可以省掉很多循环语句，代码使用方面比Python原生list简单的多。

2. ndarray支持并行化运算（向量化运算）

   numpy内置了并行运算功能，当系统有多个核心时，做某种计算时，numpy会自动做并行计算

3. 效率远高于纯Python代码

   Numpy底层使用C语言编写，内部解除了GIL（全局解释器锁），其对数组的操作速度不受Python解释器的限制，所以，其效率远高于纯Python代码。

Ndarray的属性

属性	说明
ndarray.ndim	秩，即轴的数量或维度的数量
ndarray.shape	数组的维度，对于矩阵，n 行 m 列
ndarray.size	数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype	ndarray 对象的元素类型
ndarray.itemsize	ndarray 对象中每个元素的大小，以字节为单位
ndarray.flags	ndarray 对象的内存信息
ndarray.real	ndarray元素的实部
ndarray.imag	ndarray 元素的虚部
ndarray.data	包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。

score = np.array([[80, 89, 86, 67, 79],
                  [78, 97, 89, 67, 81],
                  [90, 94, 78, 67, 74],
                  [91, 91, 90, 67, 69],
                  [76, 87, 75, 67, 86],
                  [70, 79, 84, 67, 84],
                  [94, 92, 93, 67, 64],
                  [86, 85, 83, 67, 80]])
print(type(score))

print(score.shape)  # (8, 5)
print(score.ndim)  # 2
print(score.size)  # 40
print(score.dtype)  # int32 默认
print(score.itemsize)  # 4

输出

<class 'numpy.ndarray'>
(8, 5)
2
40
int32
4

Ndarray数据类型

名称	描述
bool_	布尔型数据类型（True 或者 False）
int_	默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
intc	与 C 的 int 类型一样，一般是 int32 或 int 64
intp	用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）
int8	字节（-128 to 127）
int16	整数（-32768 to 32767）
int32	整数（-2147483648 to 2147483647）
int64	整数（-9223372036854775808 to 9223372036854775807）
uint8	无符号整数（0 to 255）
uint16	无符号整数（0 to 65535）
uint32	无符号整数（0 to 4294967295）
uint64	无符号整数（0 to 18446744073709551615）
float_	float64 类型的简写
float16	半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
float32	单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
float64	双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
complex_	complex128 类型的简写，即 128 位复数
complex64	复数，表示双 32 位浮点数（实数部分和虚数部分）
complex128	复数，表示双 64 位浮点数（实数部分和虚数部分）

numpy 的数值类型实际上是 dtype 对象的实例，并对应唯一的字符，包括 np.bool_，np.int32，np.float32，等等。

import numpy as np
data = np.array([1.1, 1.2, 1.3], dtype=np.float32)
print(data)
print(data.dtype)

输出

[1.1 1.2 1.3]
float32

Ndarray常用操作

生成0和1数组

zero = np.zeros([3, 4])
print(zero)
print("元素类型", zero.dtype)

print("------------------")

one = np.ones([3, 4], dtype=np.int_)
print(one)

输出

[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
元素类型 float64
------------------
[[1 1 1 1]
 [1 1 1 1]
 [1 1 1 1]]

从现有的数组中生成

print("-----array(深拷贝)-----")
data01[0, 3] = 100
print("原始数据：", score[0])
print("array产生的数组修改后的数据(data01)：", data01[0])
print("array产生的数组修改后的数据(score)：", score[0])

print("-----asarray(浅拷贝)-----")
data02[0, 3] = 110
print("原始数据：", score[0])
print("array产生的数组修改后的数据(data02)：", data02[0])
print("array产生的数组修改后的数据(score)：", score[0])

print("-----copy(深拷贝)-----")
data03[0, 3] = 120
print("原始数据：", score[0])
print("array产生的数组修改后的数据(data02)：", data03[0])
print("array产生的数组修改后的数据(score)：", score[0])

输出

-----array(深拷贝)-----
原始数据： [80 89 86 67 79]
array产生的数组修改后的数据(data01)： [ 80  89  86 100  79]
array产生的数组修改后的数据(score)： [80 89 86 67 79]
-----asarray(浅拷贝)-----
原始数据： [ 80  89  86 110  79]
array产生的数组修改后的数据(data02)： [ 80  89  86 110  79]
array产生的数组修改后的数据(score)： [ 80  89  86 110  79]
-----copy(深拷贝)-----
原始数据： [ 80  89  86 110  79]
array产生的数组修改后的数据(data02)： [ 80  89  86 120  79]
array产生的数组修改后的数据(score)： [ 80  89  86 110  79]

生成固定范围的数组

arr = np.linspace(0, 10, 5)  # [0, 10] 等距离,num默认是50
print(arr)
arr = np.arange(0, 10, 2.5)  #  [a, b) c是步长,step默认是1
print(arr)

输出

[ 0.   2.5  5.   7.5 10. ]
[0.  2.5 5.  7.5]

均匀分布

data = np.random.uniform(-1, 1, 1000000)
plt.figure(figsize=(20, 8), dpi=80)
plt.hist(data, bins=1000)
plt.show()

正态分布

data = np.random.normal(1.75, 0.1, 100000)
plt.figure(figsize=(20, 8), dpi=80)
plt.hist(data, bins=1000)
plt.show()

案例：随机生成8只股票2周的交易日涨幅数据

stock_change = np.random.normal(loc=0, scale=1, size=(8, 10))
print(stock_change)
# 获取第一个股票的前3个交易日的涨跌幅数据
stock_change[0, :3]

输出

[[-0.03469926,  1.68760014,  0.05915316,  2.4473136 , -0.61776756,
  -0.56253866, -1.24738637,  0.48320978,  1.01227938, -1.44509723],
 [-1.8391253 , -1.10142576,  0.09582268,  1.01589092, -1.20262068,
  0.76134643, -0.76782097, -1.11192773,  0.81609586,  0.07659056],
 [-0.74293074, -0.7836588 ,  1.32639574, -0.52735663,  1.4167841 ,
  2.10286726, -0.21687665, -0.33073563, -0.46648617,  0.07926839],
 [ 0.45914676, -0.78330377, -1.10763289,  0.10612596, -0.63375855,
  -1.88121415,  0.6523779 , -1.27459184, -0.1828502 , -0.76587891],
 [-0.50413407, -1.35848099, -2.21633535, -1.39300681,  0.13159471,
  0.65429138,  0.32207255,  1.41792558,  1.12357799, -0.68599018],
 [ 0.3627785 ,  1.00279706, -0.68137875, -2.14800075, -2.82895231,
  -1.69360338,  1.43816168, -2.02116677,  1.30746801,  1.41979011],
 [-2.93762047,  0.22199761,  0.98788788,  0.37899235,  0.28281886,
  -1.75837237, -0.09262863, -0.92354076,  1.11467277,  0.76034531],
 [-0.39473551,  0.28402164, -0.15729195, -0.59342945, -1.0311294 ,
  -1.07651428,  0.18618331,  1.5780439 ,  1.31285558,  0.10777784]]


[ 0.75372007  0.37205739 -0.45823456]

形状修改

print(stock_change.reshape((10, 8)).shape)
stock_change.resize((10, 8))
print(stock_change.shape)
print(stock_change.T.shape)

输出

(10, 8)
(10, 8)
(8, 10)

序列化

print(stock_change.tostring())

输出

b'\x1cDY5\xba\xf6\xfd?\x1f!\xa4"H\x12\xd3\xbf\x8a\xb8\n"n\x86\xe8?V\xc8E\x01\x0c\xba\xe4?#\xa5\xcd4\xfd8\xdc?-\xfb\x01\x9by\xee\xb5?\x97\xca\xc6\xd3\xaf;\xe0?\x9b;\x1f\xd9d\x17\xfb\xbfY\x10\xca\x9c\x99D\xe5?d\xbf\x93\xfe\xfbr\xf1\xbfQ\x89\x0f\xca\x88:\xf7\xbfo\xdd22=\x9d\xf2\xbf\xa1,\xbc\xc7>B\xf0\xbfl\x8d\......省略

数组去重

data = np.array([[1,2,3,4],[3,4,5,6]])
print(np.unique(data))
print(set(data.flatten()))

输出

[1 2 3 4 5 6]
{1, 2, 3, 4, 5, 6}

Ndarray运算

逻辑运算

import numpy as np

stock_change = np.random.normal(1.5, 2, (8, 10))
# 逻辑判断, 如果涨跌幅大于等于0.5就标记为True 否则为False
print(stock_change >= 0.5)
# 修改所有涨幅小于0.5的为0.5
stock_change[stock_change < 0.5] = 0.5

输出

[[False  True  True  True False  True False  True False  True]
 [False  True  True  True  True  True False  True  True False]
 [ True  True  True False  True  True False  True False False]
 [ True  True False  True  True  True False False  True False]
 [ True  True  True False  True  True  True False False  True]
 [ True  True  True  True  True  True  True  True  True False]
 [ True  True  True  True  True  True  True  True  True  True]
 [ True  True  True  True  True  True  True  True  True  True]]

where运算

temp = stock_change[:4, :4]
print(temp)
print(np.where(temp > 0.5, 1, 0))
# 判断前四个股票前四天的涨跌幅 大于0.5并且小于1的，换为1，否则为0
# 判断前四个股票前四天的涨跌幅 大于0.5或者小于-0.5的，换为1，否则为0
print(np.where(np.logical_and(temp > 0.5, temp < 1), 1, 0))
print(np.where(np.logical_or(temp > 0.5, temp < -0.5), 1, 0))

输出

[[ 2.11334994  2.75371732 -1.45919878 -0.54644526]
 [ 2.50898042  2.49334823  3.46757975  1.67814258]
 [-1.63742684  2.21757841  0.51642822 -1.10437119]
 [ 1.08439702  0.2920416   0.31753524  2.20334352]]

[[1 1 0 0]
 [1 1 1 1]
 [0 1 1 0]
 [1 0 0 1]]

[[0 0 0 0]
 [0 0 0 0]
 [0 0 1 0]
 [0 0 0 0]]

[[1 1 1 1]
 [1 1 1 1]
 [1 1 1 1]
 [1 0 0 1]]

最大值最小值

print(np.max(stock_change))
# 0代表列，1代表行
print(np.max(stock_change, axis=0))
print(np.max(stock_change, axis=1))
# 最大值的位置
print(np.argmax(stock_change, axis=0))
print(np.argmax(stock_change, axis=1))

输出

6.693146605729187
[6.69314661 2.82844572 5.81205157 5.35317406 4.01567427 5.66452237
 2.61476055 3.99797746 4.19418698 5.17729721]
[4.48925181 4.29683647 3.99797746 2.09293751 5.81205157 5.35317406
 5.17729721 6.69314661]
[7 4 4 5 6 7 2 2 5 6]
[5 0 7 1 2 3 9 0]

广播机制

简单理解：对两个数组，分别比较他们的每一个维度（若其中一个数组没有当前维度则忽略），满足：

• 数组拥有相同形状。
• 当前维度的值相等。
• 当前维度的值有一个是 1

A (3d array): 		256 × 256 × 3
B (1d array): 		   		    3
Result (3d array):   256 × 256 × 3
    
A (4d array): 		9 × 1 × 7 × 1
B (3d array): 		    8 × 1 × 5
Result (4d array):   9 × 8 × 7 × 5
    
A (2d array): 		5 × 4
B (1d array): 		    1
Result (2d array):   5 × 4
    
A (3d array): 		15 × 3 × 5
B (3d array): 		15 × 1 × 1
Result (3d array):   15 × 3 × 5

矩阵运算

两种方法存储矩阵

1. ndarray 二维数组
2. matrix数据结构

data = np.array([[80, 86],
                [82, 80],
                [85, 78],
                [90, 90],
                [86, 82],
                [82, 90],
                [78, 80],
                [92, 94]])

# matrix存储矩阵
data_mat = np.mat([[80, 86],
                    [82, 80],
                    [85, 78],
                    [90, 90],
                    [86, 82],
                    [82, 90],
                    [78, 80],
                    [92, 94]])

weights = np.array([[2], [3]])
weights_mat = np.mat([[2], [3]])
# 矩阵乘法
print(np.matmul(data, weights))
print(np.dot(data, weights))
print(data @ weights)
print(data_mat * weights_mat)

输出

[[418]
 [404]
 [404]
 [450]
 [418]
 [434]
 [396]
 [466]]
.....都是一样的，就省略了

合并

data_1 = np.array([1, 2, 3])
data_2 = np.array([5, 6, 7])
print(np.hstack((data_1, data_2)))  # 水平拼接 horizontally
print(np.vstack((data_1, data_2)))  # 竖直拼接 vertically

data_1 = np.array([[1, 2, 3], [2, 3, 4], [3, 4, 5]])
data_2 = np.array([[5, 6, 7]])
print(np.concatenate((data_1, data_2), axis=0))  # 自定义合并
print(np.concatenate((data_1, data_2.T), axis=1))  # 自定义合并

输出

[1 2 3 5 6 7]

[[1 2 3]
 [5 6 7]]

[[1 2 3]
 [2 3 4]
 [3 4 5]
 [5 6 7]]

[[1 2 3 5]
 [2 3 4 6]
 [3 4 5 7]]

分割

print("-----分割-----")
data = np.arange(0, 10)
print(np.split(data, 2))
print(np.split(data, [4, 6]))

输出

[array([0, 1, 2, 3, 4]), array([5, 6, 7, 8, 9])]
[array([0, 1, 2, 3]), array([4, 5]), array([6, 7, 8, 9])]

IO操作和数值处理

文件内容

id,value1,value2,value3
1,123,1.4,23
2,110,,18
3,,2.1,19

代码

test = np.genfromtxt("test.csv", delimiter=",")
print(test)
print(type(test[0, 0]))

输出

[[  nan   nan   nan   nan]
 [  1.  123.    1.4  23. ]
 [  2.  110.    nan  18. ]
 [  3.    nan   2.1  19. ]]
<class 'numpy.float64'>

我们可以看到，出现了缺失值nan。

为什么呢？当我们读取本地的文件为float的时候，如果数据类型不对(或者为None)，就会出现nan

上方的[0,0]明明是字符串，但是是按float读取的，就出现了nan。这是由ndarray的数据结构决定的

总结