＃100DaysOfMLCode挑战的第5天，足够了Python基础知识。
Python提供了一些软件包，以使我们的工作更轻松。 我们也需要学习这些。
在本教程中，我们将学习使用Python的NumPy包执行数据操作和分析的核心方面。
是NumPy的时候了！
最后您将学到什么？
- NumPy-这是什么？
- 为什么这么重要？
- 安装/导入NumPy软件包
- 创建NumPy数组
- 对NumPy数组的操作
—矢量化的运营
—创建零和一数组
—合并到两个数组
—重塑和切片
—最小，最大，平均值计算
—随机数生成
—独特的元素
所以，让我们加油！
NumPy-这是什么？
NumPy是Python中用于科学计算和数据处理的最基本但功能最强大的软件包。 它是Python中可用的开源库。 它有助于进行数学和科学运算，并在数据科学中广泛使用。 它使我们可以处理多维数组和矩阵。
为什么Numpy如此重要？
- 高效的内存 ，可以处理大量数据。
- 其他数据分析包（如Pandas）都建立在NumPy和Scikit学习的基础上。
安装/导入NumPy
- 您可以通过在Anaconda Prompt中运行以下命令来安装NumPy ，
康达安装numpy的
- 对于未在计算机上安装Anaconda的用户，可以使用以下方法从终端安装该工具：
pip安装numpy
安装完成后，启动Jupyter Notebook并开始使用。
您可以通过检查软件包的版本并将其导入来验证安装。
将numpy导入为np
打印（np .__ version__）
创建NumPy数组
一切完成后，现在就可以开始了。
NumPy数组只是相同数据类型值的集合。
NumPy数组可以采用两种形式，即向量和矩阵。 向量严格是一维的，而矩阵是多维的。
我们可以从列表创建NumPy数组。
_list = [0,1,2,3,4] #Python列表
_arr1d = np.array（_list）＃从python列表创建numpy数组
打印（类型（_列表））
_arr1d
数组（[0，1，2，3，4]）
NumPy中的向量化运算
NumPy允许我们执行向量化操作，在这里我们可以将操作应用于整个数组，而不是单独应用于每个元素。 它还可以提高计算性能，而不是为此目的而使用循环。 这不能在列表上完成，因为它将在Python中引发TypeError。
NumPy在这里赢了！
_list + 2＃尝试对列表进行矢量化操作
TypeError：只能将列表（而不是“ int”）连接到列表
＃对已创建的numpy数组进行矢量化操作
打印（_arr + 2）
打印（_arr * 4）
打印（_arr / 2）
print（_arr // 2）
[2 3 4 5 6]
[0 4 8 12 16]
[0。 0.5 1. 1.5 2.]
[0 0 1 1 2]
创建零/一的数组
Numpy让我们只运行一行就可以创建一个零的数组。
np.zeros（（2,2））
数组（[[0.，0.]，
[0.，0.]]）
np.ones（（2,2））
array（[[1。，1.]，
[1.，1.]]）
合并两个数组
我们可以分别使用np.vstack（）和np.hstack（）将行或列转换为numpy数组。
注意：在应用hstack（）添加列时，我们应检查两个数组的行数，np.hstack（）无法将两个具有不同行数的数组连接起来。
arr1 = np.matrix（[1,2,3]）
arr2 = np.matrix（[4,5,6]）
print（’Horizontal Append：’，np.hstack（（arr1，arr2）））
print（’垂直追加：’，np.vstack（（arr1，arr2）））
水平追加：[[1 2 3 4 5 6]]
垂直附加：[[1 2 3]
[4 5 6]
＃从Python列表中创建二维数组
list1 = [[1,2,3]，[4,5,6]，[7,8,9]]
arr2d = np.array（list1）
arr2d
数组（[[1，2，3]，
[4、5、6]，
[7、8、9]]
创建特定类型的数组
要创建特定类型的数组，我们需要提及dtype参数的值作为所需的数据类型。
arr2df = np.array（list1，dtype =’float’ ）
arr2df
数组（[[1.，2.，3.]，
[4.，5.，6。]，
[7.，8.，9。]]）
NumPy的astype（）允许我们将数组的数据类型从一种类型转换为另一种类型。
arr2df.astype（’int’）。 astype（’str’）
数组（[['1'，'2'，'3']，
['4'，'5'，'6']，
['7'，'8'，'9']]，dtype ='<U11'）
＃创建布尔数组
arr2db = np.array（[1,0,5，0，0]，dtype =’bool’）
arr2db
array（[True，False，True，False，False]）
创建对象类型的数组使我们可以在数组中包含各种类型的元素。
arr2dobj = np.array（[‘1’，’ML’]，dtype =’object’）
arr2dobj
array（['1'，'ML']，dtype = object）
将数组转换回类型
list_conv = arr2dobj。 tolist（）
打印（类型（list_conv）
['1'，'ML']
清单
list3 = [[1、2、3、4]，[3、4、5、9]，[3、6、7、8]
arr3 = np.array（list3，dtype =’float’）
3号
数组（[[1.，2.，3.，4.]，
[3.，4.，5.，9.]，
[3.，6.，7.，8.]]）
形状功能
如果您要处理大量的数组，找到尺寸非常繁琐，那么我们可以使用形状函数。
＃形状
print（’Shape：’，arr3.shape）
＃dtype
print（’Datatype：’，arr3.dtype）
＃大小
print（’Size：’，arr3.size）
#ndim
print（’Num Dimensions：’，arr3.ndim）
形状：（3，4）
数据类型：float64
大小：12
数位尺寸：2
切片阵列中的特定部分
arr3 [：2，：2]
数组（[[1.，2.]，
[3.，4.]]）
list3 [：2，：2]
TypeError：列表索引必须是整数或切片，而不是元组
在应用条件表达式时创建布尔矩阵
我们可以使用条件和逻辑运算符（例如＆，|，和==运算符）对数组执行条件和逻辑运算，以将数组中的值与给定值进行比较，并根据运算结果创建一个新的布尔矩阵。表达。 这是如何做，
arr3＃这是我们的数组
数组（[[1.，2.，3.，4.]，
[3.，4.，5.，9.]，
[3.，6.，7.，8.]]）
boolean_matrix = arr3> 5＃应用条件并创建布尔矩阵
boolean_matrix＃打印结果
数组（[[False，False，False，False]，
[False，False，False，True]，
[False，True，True，True]]）
反转数组
仅在行位置反转数组
arr3 [::-1，]
array（[[3。，6.，7.，8.]，
[3.，4.，5.，9.]，
[1.，2.，3.，4.]]）
插入nan和inf
要将nan和inf插入数组，
arr3 [2,1] = np.nan＃不是数字
arr3 [1,2] = np.inf＃无限
3号
array（[[1.，2.，3.，4.]，
[3.，4.，inf，9.]，
[3.，nan，7.，8.]]）
将nan和inf替换为-1，
missing_values = np.isnan（arr3）| np.isinf（arr3）
arr3 [missing_values] = -1
3号
array（[[1.，2.，3.，4.]，
[3.，4.，-1。，9.]，
[3.，-1。，7.，8.]]）
最大值，最小值和平均值计算
使用max（），min（）和mean（），我们可以获得数组中值的最大值，最小值和平均值。
＃平均值，最大值和最小值
print（“平均值为：”，arr3.mean（））
打印（“最大值为：”，arr3.max（））
打印（“最小值为：”，arr3.min（））
平均值是：3.5
最大值是：9.0
最小值是：-1.0
＃行明智和列明智min
打印（“逐列最小值：”，np.amin（arr3，轴= 0））
打印（“行最小值：”，np.amin（arr3，轴= 1））
按列的最小值：[1. -1。 -1。 4.]
逐行最小值：[1. -1。 -1。]
＃行明智和列明智最大
打印（“逐列最小值：”，np.amax（arr3，轴= 0））
print（“ Row-wise minimum：”，np.amax（arr3，axis = 1））
列级最小值：[3。 4. 7. 9.]
逐行最小值：[4。 9. 8.]
将数组的一部分分配给其他
＃将arr3的一部分分配给arr3a
打印（arr3）
arr3a = arr3 [：2，：2]
arr3a [：1，：1] = 24＃24也将反映在父数组中
3号
[[1. 2. 3. 4.]
[3. 4. -1。 9.]
[3. -1。 7. 8.]]
数组（[[24.，2.，3.，4.]，
[3.，4.，-1。，9.]，
[3.，-1。，7.，8.]]）
＃使用copy（）将arr3的一部分分配给arr3_cpy
打印（arr3）
arr3_cpy = arr3 [：2，：2] .copy（）
arr3_cpy [：1，：1] = 1＃24也不会反映在父数组中
打印（“父母亲：”，arr3）
打印（arr3_cpy）
[[24。 2. 3. 4.]
[3. 4. -1。 9.]
[3. -1。 7. 8.]]
[[24。 2. 3. 4.]
[3. 4. -1。 9.]
[3. -1。 7. 8.]]
[[1。 2.]
[3。 4.]]
重塑数组
reshape（）函数允许我们将数组的形状从一种形式改变为另一种形式。
注意：只有当行和列在一起的元素数必须相等时，reshape（）才能转换。
＃将3×4数组整形为2×6数组，这里数组有12个元素，因此可以转换为形状（2,6）
arr3.reshape（2,6）
array（[[24。，2.，3.，4.，3.，4.]，
[-1。，9.，3.，-1。，7.，8.]]）
flatten（）和ravel（）函数：
＃将arr3展平为一维数组
arr3.flatten（）
array（[24。，2.，3.，4.，3.，4.，-1。，9.，3.，-1。，7.，8.]）
＃更改展平数组不会更改父级
test1 = arr3.flatten（）
test1 [0] = 1＃更改b1不会影响arr2
print（“ arr3没有变化，尽管我们更改了test1数组：\ n”）
print（“ arr3：“，arr3，end =” \ n \ n”）
打印（“ test1：”，test1）
尽管我们更改了test1数组，但是arr3并没有变化：
arr3：[[24。 2. 3. 4.]
[3. 4. -1。 9.]
[3. -1。 7. 8.]]
test1：[1. 2. 3. 4. 3. 4. -1。 9. 3. -1。 7. 8.]
＃更改ravel数组也会更改父对象。
test2 = arr3.ravel（）
test2 [0] = 0＃改变b2也会改变arr2
print（“虽然我们更改了test2数组，但arr3有所更改：\ n”）
print（“ arr3：“，arr3，end =” \ n \ n”）
打印（“ test2：”，test2）
尽管我们更改了test2数组，但是arr3发生了变化：
arr3：[[0. 2. 3. 4.]
[3. 4. -1。 9.]
[3. -1。 7. 8.]]
test2：[0. 2. 3. 4. 3. 4. -1。 9. 3. -1。 7. 8.]
随机数生成
我们可以使用rand（），randn（）或randint（）函数生成随机数数组。
＃使用随机数
打印（np.random.rand（3,3），end =” \ n \ n”）
＃以3×3的顺序打印0到1之间的随机数
打印（np.random.randn（3,3），end =” \ n \ n”）
＃打印形状为3,3且均值= 0和方差= 1的正态分布
打印（np.random.random（））
＃打印0到1之间的随机数
打印（np.random.random（size = [2,2]））
＃在（2,2）矩阵中打印介于0和1之间的随机数
打印（np.random.randint（0，10，size = [2,2]））
＃在（2,2）矩阵中打印0到10之间的随机数
3x3阶矩阵中介于0和1之间的随机数
[[0.82509486 0.83613181 0.07539491]
[0.01140079 0.04842057 0.35712271]
[0.66569338 0.01138961 0.10791777]
正态分布，均值= 0，方差= 1，形状为3,3
[[0.07939305 0.10796863 0.5069511]
[1.12558936 -1.00805248 0.35482923]
[-0.70266818 0.11345113 -1.0411337]]
0.5269503887473037
[[0.42710838 0.98263043]
[0.14045149 0.7484116]]
[[2 4]
[3 7]
＃在[0,10）之间创建大小为10的随机整数
np.random.seed（100）
arr_rand = np.random.randint（0，5，size = 10）
打印（arr_rand）
[0 0 3 0 2 4 2 2 2 2]
独特元素及其数量
假设我们需要从数组中获取唯一项及其计数，那么我们可以使用unique（）
uniq，count = np.unique（arr_rand，return_counts = True）
打印（“ Unique items：”，uniq）
打印（“计数：”，计数）
特有物品：[0 2 3 4]
计数：[3 5 1 1]
＃从给定列表中选择15个项目，并且几率相等
list4 = np.random.choice（[‘n’，’u’，’m’，’p’，’y’]，size = 15）
打印（list4）
['m'n'n'm'm'u'u'n'm'u'y'm'n'n'p'p'p'p']
打印（“唯一项目：”，uniq1）
print（“ Counts：”，count1）
唯一项：['m''n''p''u''y']
计数：[5 4 3 2 1]
掌声！ 我们终于结束了！
如果您完成了本教程，那么您将学习很多NumPy。
尝试自己做。 如果您有任何疑问，请在下面的部分中进行任何查询，如果您觉得本文有帮助，请不要忘记点击鼓掌按钮！
学习愉快！ 🙂
参考文献
- ML系列第4天-https://medium.com/data-science-everywhere/machine-learning-series-day-4-44832ed69342
- https://docs.scipy.org/doc/numpy/reference/
- https://www.tutorialspoint.com/numpy
- ML系列第6天- 熊猫-https: //medium.com/data-science-everywhere/ml-series-day-6-pandas-for-beginners-part-1-4aacad767d1c
