NumPy是一个Python库

简介
NumPy是一个Python库，用于对大型数据集进行数值计算。Numpy是Numerical Python的缩写，它是数据科学家常用的一个库，特别是用于机器学习问题。NumPy在你使用机器学习算法训练数据之前的预处理过程中非常有用。
与Python列表相比，在Numpy中处理n维数组更容易。Numpy数组也比Python列表快，因为与列表不同，NumPy数组是在内存中的一个连续位置存储的。这使得处理器能够有效地使用NumPy数组进行计算。
在这篇文章中，我们将了解使用Numpy的基本知识，包括数组操作、矩阵变换、生成随机值等等。
安装
NumPy的官方网站提供了清晰的安装说明，所以我不打算在这里再重复。 请在这里找到该说明。
使用NumPy工作
如果你想尝试一下下面的这些例子，这里有一个google colab笔记本。
导入NumPy
要在你的脚本中开始使用NumPy，你必须先导入它。

将数组转换为NumPy数组

import numpy as np

#将数组转换为NumPy数组
#你可以使用np.array()方法将你现有的python列表转换为NumPy数组。

arr = [1,2,3]
np.array(arr)

nested_arr = [[1,2],[3,4],[5,6]]
np.array(nested_arr)

print(np.arange(0,10)) # without distance parameter
OUTPUT:[0 1 2 3 4 5 6 7 8 9]
print(np.arange(0,10,2)) # with distance parameter
OUTPUT: [0 2 4 6 8]

在处理数据时，你会经常遇到需要生成数据的用例。
Numpy有一个 "range() "方法，你可以用它生成两个数字之间的数值范围。
arange函数接收起点、终点和一个可选的距离参数。

print(np.zeros(3))
OUTPUT: [0. 0. 0.]
print(np.ones(3))
OUTPUT: [1. 1. 1.]

你也可以用NumPy生成一个零或一的数组或矩阵
相信我，你会需要它！下面是方法。

print(np.zeros((4,5)))
OUTPUT:
[
 [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.]
]
print(np.ones((4,5)))
OUTPUT:
[
 [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.]
]

Identity Matrix 矩阵
你也可以使用Numpy的一个内置函数 "eye "来生成一个Identity Matrix

NumPy的Linspace函数
NumPy有一个linspace方法，可以在两个数字之间生成均匀的点。

print(np.linspace(0,10,3))
OUTPUT:[ 0.  5. 10.]

在上面的例子中，第一个和第二个参数是起点和终点，而第三个参数是你在起点和终点之间需要的点的数量。
下面是同一范围内的20个点。

print(np.linspace(0,10,20))
output:[ 0. 0.52631579 1.05263158 1.57894737 
2.10526316 2.63157895 3.15789474 3.68421053 
4.21052632 4.73684211 5.26315789 5.78947368 
6.31578947 6.84210526 7.36842105 7.89473684 
8.42105263 8.94736842 9.47368421 10.］

随机数生成
当你在处理机器学习问题时，你会经常遇到需要生成随机数的情况。Numpy也有内置的函数来处理这个问题。
但在我们开始生成随机数之前，让我们看看两种主要的分布类型。

正态分布
在一个标准的正态分布中，数值在中间达到峰值。正态分布是统计学中一个非常重要的概念，因为它在许多自然现象中都能看到。它也被称为 "钟形曲线"。

均匀分布
如果分布中的数值的概率是一个常数，那么它就被称为均匀分布。
例如，抛硬币有一个均匀分布，因为在抛硬币时得到正面或反面的概率是一样的。
现在你知道了这两个主要分布的作用，让我们来生成一些随机数。
要生成均匀分布的随机数，可以使用np.random中的rand()函数。

print(np.random.rand(10)) # 数组
output: [0.46015141 0.89326339 0.22589334 0.29874476 
0.5664353 0.39257603 0.77672998 0.35768031 0.95087408 0.34418542 ]

print(np.random.rand(3,4)) # 3x4矩阵
output:[[0.63775985 0.91746663 0.41667645 0.28272243]
 [0.14919547 0.72895922 0.87147748 0.94037953]
 [0.5545835 0.30870297 0.49341904 0.27852723] ]

要生成正态分布的随机数，可以使用np.random中的randn()函数。

print(np.random.randn(10))
output:[-1.02087155 -0.75207769 -0.22696798 0.86739858 
0.07367362 -0.41932541 0.86303979 0.13739312 0.13214285 
1.23089936 ]

print(np.random.randn(3,4))
输出： [[ 1.61013773 1.37400445 0.55494053 0.23133522] 
[0.31290971 -0.30866402 0.33093618 0.34868954]
 [-0.11659865 -1.22311073 0.36676476 0.40819545] ]

要生成低值和高值之间的随机整数，可以使用np.random中的randint()函数

print(np.random.randint(1,100,10))
输出：[64 37 62 27 4 33 23 52 70 7]

print(np.random.randint(1,100,(2,3))
输出:  [[92 42 38] [87 69 38]] 

如果你想让你的随机数在每次计算中都是相同的，就可以使用种子值。
下面是在NumPy中设置种子值的方法。
在NumPy中设置一个种子值

np.random.seed(42)
print(np.random.rand(4))

output:[0.37454012, 0.95071431, 0.73199394, 0.59865848]。

每当你使用一个种子数，你总是会得到相同的数组生成，没有任何变化。
重塑数组

作为一名数据科学家，你将为不同类型的计算重新塑造数据集。
在本节中，我们将探讨如何处理数组的形状。
要获得一个数组的形状，请使用shape属性。

arr = np.random.rand(2,2)
print(arr)
print(arr.shape)
OUTPUT:[
[0.19890857 0.00806693]
[0.48199837 0.55373954]
]
(2, 2)

要重塑一个数组，请使用reshape()函数。

print(arr.reshape(1,4))
OUTPUT: [[0.19890857 0.00806693 0.48199837 0.55373954]]
print(arr.reshape(4,1))

OUTPUT:[
[0.19890857]
[0.00806693]
[0.48199837]
[0.55373954]
]

为了永久地重塑一个数组，你必须将重塑后的数组分配给'arr'变量。
另外，只有在现有结构合理的情况下，重塑才会起作用。
你不能将一个2x2的数组重塑为3x1的数组。

数据切片

让我们看看如何从NumPy数组中获取数据。NumPy数组在获取数据的过程中
与Python列表的工作类似。要对一个数组进行切片：

myarr = np.arange(0,11)
print(myarr)
OUTPUT:[ 0  1  2  3  4  5  6  7  8  9 10]

sliced = myarr[0:5]
print(sliced)
OUTPUT: [0 1 2 3 4]

sliced[:] = 99
print(sliced)
OUTPUT: [99 99 99 99 99]

print(myarr)
OUTPUT:[99 99 99 99 99  5  6  7  8  9 10]

如果你看一下上面的例子，尽管我们把 "myarr "的切片分配给了变量 "sliced"，
但改变 "sliced "的值会影响到原始数组。这是因为 "slice "只是指向原始数组。
要制作一个数组的独立部分，可以使用copy()函数。

切分多维数组的工作与一维数组类似。

sliced = myarr.copy()[0:5] 
my_matrix = np.random.randint(1,30,(3,3))
print(my_matrix)
输出：[
[21 1 20]
[22 16 27]
[24 14 22]
]

print(my_matrix[0]) # 打印单一行
OUTPUT: [21 1 20]

print(my_matrix[0][0]) # 打印单个数值或第0行第0列
OUTPUT: 21

print(my_matrix[0,0]) #以另一种方式打印第0行、第0列的值
OUTPUT: 21

数组计算
现在让我们来看看数组计算的情况。Numpy以其在大型多维数组上进行复杂计算时的速度而闻名。
让我们尝试一些基本的操作。

new_arr = np.arange(1,11)
print(new_arr)
OUTPUT: [ 1 2 3 4 5 6 7 8 9 10]
加法
print(new_arr + 5)
OUTPUT: [ 6 7 8 9 10 11 12 13 14 15]
减法
print(new_arr - 5)
OUTPUT: [-4 -3 -2 -1 0 1 2 3 4 5]
数组加法
print(new_arr + new_arr)
OUTPUT: [ 2 4 6 8 10 12 14 16 18 20]
数组除法
print(new_arr / new_arr)
输出：[1. 1. 1. 1. 1. 1. 1.］

对于零除法的错误，Numpy将把数值转换为NaN（非数字）。
在NumPy中还有一些内置的计算方法可以用来计算平均值、标准差、方差等值。
总和 - np.sum()
平方根 - np.sqrt()
平均值 - np.mean()
方差 - np.var()
标准偏差 - np.std()
在处理二维数组时，你经常需要计算行间或列间的和、平均值、方差等。你可以使用可选的轴参数来指定你是要选择行还是列。

arr2d = np.arange(25).reshape(5,5)
print(arr2d)
OUTPUT: [
[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]
[20 21 22 23 24]
]

print(arr2d.sum())
OUTPUT: 300

print(arr2d.sum(axis=0))  # 列的总和
OUTPUT: [50 55 60 65 70]

print(arr2d.sum(axis=1)) #行的总和
OUTPUT: [ 10 35 60 85 110]

条件性操作
你也可以使用NumPy的方括号符号进行条件过滤。下面是一个例子。

arr = np.arange(0,10)
OUTPUT: [0,2,3,4,5,6,7,8,9]

print(arr > 4)
OUTPUT: [False False False False False  True  True  True  True  True]

print(arr[arr > 4])
OUTPUT: [5 6 7 8 9]

总结
当涉及到处理大型数据集时，Numpy是你工具包中的一个强大工具。
它能够处理高级数字计算和复杂的n维数组操作。
如果你打算在机器学习领域开始职业生涯，强烈建议你学习NumPy。