约7500字解析：NumPy在数据科学中最重要且有用的数组创建等函数介绍

[id_[id_35[id_637182015]468765]52357528]

NumPy 有一些在数据科学中很有用的函数。

Numpy 是 python 中的一种重要工具。它能高效处理大容量数据。使用 NumPy 的一个重要原因是其具备众多处理数组的函数。在本文里，会介绍 NumPy 在数据科学中一些最为重要且最具实用价值的函数。

创建数组

1、Array

它用于创建一维或多维数组

numpy 有一个 array 函数，它可以接收一个 object 作为参数，还可以接收一个 dtype 参数，并且可以通过星号（*）来指定一些其他的参数。copy 为 True，order 为'K'，subok 为 False，ndmin 为 0，like 为 None。

Dtype:生成数组所需的数据类型。

ndim:指定生成数组的最小维度数。

import numpy as npnp.array([1,2,3,4,5])----------------array([1, 2, 3, 4, 5, 6])

可以利用此函数把 pandas 的 df 以及 series 转换成 NumPy 数组。

sex 等于一个 Series，这个 Series 的值为['Male','Male','Female']np.array(sex)------------------------有三个元素，分别是'Male'、'Male'、'Female'，其数据类型为 object。

2、Linspace

创建一个具有指定间隔的浮点数的数组。

numpy 从 start 开始到 stop 结束进行线性空间划分，数量为 50，终点为 True 。 即把 start 到 stop 的范围等分成 50 份，包含 stop 这个端点。 它可以生成一个在 start 和 stop 之间均匀分布的一维数组。 例如，当 start 为 0，stop 为 1 时，就会生成一个包含 50 个等间距元素的数组，从 0 到 1 均匀分布。 这个函数在数据处理和科学计算中经常被使用，方便生成等间距的数值序列。retstep 为 False，dtype 为 None，axis 为 0（来自 source）

start:起始数字

end:结束

Num:要生成的样本数，默认为50。

np.linspace(10,100,10)请提供需要改写的句子呀，你没有给出具体的内容呢。这是一个包含 10 个元素的数组，分别是 10.、20.、30.、40.、50.、60.、70.、80.、90.、100.

3、Arange

在给定的间隔内返回具有一定步长的整数。

numpy 有一个函数叫做 arange，它接受一些参数。其中一个参数是 start，如果指定了 start 则从这个值开始。另一个参数是 stop，它表示结束的值，但不包括这个值。还有一个参数是 step，用于指定步长。此外，还有一个参数 dtype，可以用来指定数据类型。还有一个参数 like，用于指定类似的对象。

step:数值步长。

np.arange(5,10,2)-----------------------array([5, 7, 9])

4、Uniform

在上下限之间的均匀分布中生成随机样本。

如果 size 为一个元组，则生成一个指定形状的多维数组

生成一个在 5 到 10 之间均匀分布的随机数数组，数组大小为 4 。具体来说，就是从 5 开始到 10 结束（包括 5 但不包括 10 ），按照均匀分布的规则生成 4 个随机数。------------该数组包含四个数值，分别是 6.47445571、5.60725873、8.82192327 和 7.47674099。
np.random.uniform(size = 5)------------数组中包含三个数值，分别是 0.83358092、0.41776134 和 0.72349553。
使用 np.random.uniform 函数生成一个大小为(2, 3)的随机数组。------------数组包含三个元素，分别是 0.7032511 、0.63212039 和 0.6779683 。

5、Random.randint

在一个范围内生成n个随机整数样本。

最终生成的数组数据类型为整数类型 dtype=int 。

np.random.randint(5,10,10)请提供需要改写的句子呀，你没有给出具体的内容呢。这个数组包含了多个数字，分别是 6、8、9、9、7、6、9、8、5、9。

6、Random.random

生成n个随机浮点数样本。

numpy.random 生成一个随机数数组，其大小由 size 参数指定，如果 size 为 None ，则生成一个单个随机数。

np.random.random(3)---------------------------数组中包含三个数值，分别是 0.87656396、0.24706716 和 0.98950278。

7、Logspace

在对数尺度上生成间隔均匀的数字。

numpy 从 start 到 stop 进行对数空间的划分，数量为 50，端点为 Truebase 的值为 10.0，数据类型为 None，沿着轴 0 进行相关操作。

Start:序列的起始值。

End:序列的最后一个值。

如果 endpoint 为 True，那么最后一个样本将会被包含在序列里。

base:底数。默认是10。

np.logspace(0,10,5,base=2)------------------数组中包含两个元素，第一个元素的值为 1.00000000e+00，第二个元素的值为 5.65685425e+00。

8、zeroes

np.zeroes会创建一个全部为0的数组。

创建一个指定形状的全零数组。形状由 shape 参数指定。数据类型默认为 float ，可以通过 dtype 参数进行修改。数组的内存布局顺序默认为 'C' ，可以通过 order 参数进行调整。还可以使用 like 参数来指定数组的类型和形状等属性。

shape:阵列的形状。

Dtype 指的是生成数组所需要的数据类型，它可以是' int '，也可以是默认的' float '。

np.zeros((2,3),dtype='int')---------------array([[0, 0, 0],      [0, 0, 0]])
np.zeros(5)-----------------array([0., 0., 0., 0., 0.])

9、ones

np.ones函数创建一个全部为1的数组。

numpy 生成一个形状为 shape 的全 1 数组，可指定数据类型 dtype，默认为 None，可指定内存布局 order 为 'C'，也可以通过 like 参数指定类似的数组来创建全 1 数组。

np.ones((3,4))------------------array([[1., 1., 1., 1.],      [1., 1., 1., 1.],      [1., 1., 1., 1.]])

10、full

创建一个单独值的n维数组。

numpy 用指定的形状（shape）、填充值（fill_value）、数据类型（dtype）、顺序（order）以及可选的类似对象（like）来创建一个全填充的数组。首先指定形状（shape），接着确定填充值（fill_value），然后可以选择数据类型（dtype），还能指定顺序（order），并且可以通过 like 参数指定类似的对象。

fill_value:填充值。

np.full((2,4),fill_value=2)--------------array([[2, 2, 2, 2],      [2, 2, 2, 2]])(2,4) : ꜱʜᴀᴘᴇ

11、Identity

创建具有指定维度的单位矩阵。

numpy 生成一个 n 阶单位矩阵。可以指定数据类型 dtype ，也可以通过 like 参数指定类似的对象来创建单位矩阵。

np.identity(4)----------array([[1., 0., 0., 0.],      [0., 1., 0., 0.],      [0., 0., 1., 0.],[0., 0., 0., 1.]  # 默认数据类型是 `float`

数组操作

12、min

返回数组中的最小值。

np 对 a 求最小值，不指定轴（axis=None），结果可以存储在 out 中，也可以不存储，并且可以保持维度（keepdims=False）。,       initial=, where=)

axis:用于操作的轴。

out:用于存储输出的数组。

arr 是一个数组，它由以下数字组成：1、1、2、3、3、4、5、6、6、2。这个数组是通过 np.array 函数创建的。np.min(arr)----------------1

13、max

返回数组中的最大值。

np.max(a, axis=None,out=None)

np.max(arr)------------------6

14、unique

返回一个所有唯一元素排序的数组。

numpy 对 ar 进行 unique 操作，不返回索引（return_index=False），不返回逆索引（return_inverse=False），不返回元素个数计数（return_counts=False），不指定轴（axis=None），并且在比较元素时 equal_nan 为 True

return_index:如果为True，返回数组的索引。

如果为 True，就会返回唯一数组的下标。

如果 return_counts 为 True，那么就会返回数组中每个唯一元素出现的次数。

axis:要操作的轴。默认情况下，数组被认为是扁平的。

使用 np.unique 函数对 arr 进行去重操作，并返回去重后的数组以及每个元素在原数组中出现的次数---------------------(数组为[1, 2, 3, 4, 5, 6]，这些元素是独特的。数组[2, 2, 2, 1, 1, 2]，数据类型为 int64。这是计数相关的内容。)

15、mean

返回数组的平均数

使用 numpy 库的 mean 函数，传入参数 a，axis 可以为 None，dtype 可以为 None，out 可以为 None

np.mean(arr,dtype='int')请提供需要改写的句子呀，你没有给出具体的内容呢。3

16、medain

返回数组的中位数。

numpy 对数组 a 进行中位数计算，可指定轴 axis 为 None ，也可将结果输出到 out 数组中

arr 是一个由两个子列表组成的列表，第一个子列表为 [1,2,3]，第二个子列表为 [5,8,4]，然后通过 np.array 函数将这个列表转换为一个 NumPy 数组。np.median(arr)-----------------------------3.5

17、digitize

返回输入数组中每个值所属的容器的索引。

numpy 的 digitize 函数用于将输入数组 x 按照指定的 bins 进行数字化处理，right 参数表示是否使用右侧闭合区间，该函数的源代码为[source]。

bin：容器的数组。

right:表示该间隔是否包括右边或左边的bin。

a 是一个数组，其元素为[-0.9, 0.5, 0.9, 1, 1.2, 1.4, 3.6, 4.7, 5.3]bins = np.array([0,1,2,3])np.digitize(a,bins)-------------------------------数组由 0、1、1、2、2、2、4、4、4 组成，数据类型为 int64Exp       Valuex < 0     :   00 <= x <1 :   11 <= x <2 :   22 <= x <3 :   33 <=x     :   4Compares -0.9 to 0, here x < 0 so Put 0 in resulting array.Compares 0.5 to 0, here 0 <= x <1 so Put 1.Compares 5.4 to 4, here 3<=x so Put 4

18、reshape

它是 NumPy 中较为常用的函数中的一个。它会给出一个数组，该数组里包含着有着新形状且数据相同的内容。

numpy.reshape(shap)

A 是通过 np.random.randint 函数生成的一个数组，其大小为(4,3)，数值范围在 15 以内。A----------------------array([[ 8, 14, 1],      [ 8, 11, 4],      [ 9, 4, 1],      [13, 13, 11]])
A.reshape(3,4)-----------------array([[ 8, 14, 1, 8],      [11, 4, 9, 4],      [ 1, 13, 13, 11]])
A.reshape(-1)  -------------------11 在数组中。

19、expand_dims

它用于扩展数组的维度。

numpy.expand_dims(a, axis)arr 是一个数组，这个数组由以下数字组成：8、14、1、8、11、4、9、4、1、13、13、11，它是通过 np.array 函数创建的。np.expand_dims(A,axis=0)-------------------------这是一个数组，其中包含了一些数字，分别是 8、14、1、8、11、4、9、4、1、13、13、11。
np.expand_dims(A,axis=1)---------------------------array([[ 8],      [14],      [ 1],      [ 8],      [11],      [ 4],      [ 9],      [ 4],      [ 1],      [13],      [13],      [11]])

20、squeeze

通过移除一个单一维度来降低数组的维度。

np.squeeze(a, axis=None)

arr 是一个数组，其元素为[[ 8],[14],[ 1],[ 8],[11],[ 4],[ 9],[ 4],[ 1],[13],[13],[11]]np.squeeze(arr)---------------------------array([ 8, 14, 1, 8, 11, 4, 9, 4, 1, 13, 13, 11])

21、count_nonzero

计算所有非零元素并返回它们的计数。

numpy 对数组 a 进行计数操作，计数的条件是不为零。可以指定轴 axis 来进行沿特定轴的计数，还可以通过 keepdims 参数来控制输出的维度是否保持与输入数组相同。如果 keepdims 为 False，则输出的维度会根据计数操作进行相应的缩减；如果 keepdims 为 True，则输出的维度会保持与输入数组相同，只是在指定的轴上进行计数操作。

a = np.array([0,0,1,1,1,0])np.count_nonzero(a)--------------------------3

22、argwhere

查找并返回非零元素的所有下标。

numpy.argwhere(a)

a = np.array([0,0,1,1,1,0])np.argwhere(a)---------------------这是一个数组，其元素分别为[2]、[3]、[4]，数据类型为 int64。

23、argmax & argmin

argmax 会返回数组里 Max 元素的索引。它能够在多类图像分类问题中被用来获取高概率预测标签的相关指标。

numpy 找到数组 a 中沿指定轴 axis 的最大值的索引。如果未指定 axis，则在整个数组上进行操作。可以指定输出数组 out 。还可以通过 keepdims 参数来控制输出数组的形状。如果 keepdims 为 True，则输出数组的形状将与输入数组在指定轴上的形状相同；如果 keepdims 为 False，则输出数组的形状将被压缩。)

arr 是一个数组，这个数组由一个包含四个元素的子数组构成，这四个元素分别是 0.12、0.64、0.19 和 0.05。np.argmax(arr)---------1

argmin将返回数组中min元素的索引。

numpy 找到数组 a 中的最小值的索引。可以指定轴 axis 来沿特定方向查找最小值。结果可以存储在 out 数组中。还可以通过 keepdims 参数来控制输出数组的维度。)

np.argmin(min)------3

24、sort

对数组排序。

使用 numpy 对数组 a 按照指定轴 axis=-1 进行排序，排序的方式 kind 为 None，排序的依据 order 为 None

排序算法的种类有：快速排序（‘quicksort’）、归并排序（‘mergesort’）、堆排序（‘heapsort’）以及稳定排序（‘stable’）。

arr = np.array([2,3,1,7,4,5])np.sort(arr)----------------array([1, 2, 3, 4, 5, 7])

25、abs

numpy 对 x 求绝对值，/ 表示某种特定的操作，out 是可选的输出参数，* 表示其他相关的参数或标志。where 的值为 True，进行的类型转换为'same_kind'。               order='K', dtype=None, subok=True，并且存在 signature 和 extobj 。这意味着在特定的操作或情境中，subok 被设置为 True ，同时还有 signature 和 extobj 相关的内容。

返回数组中元素的绝对值。当数组中包含负数时，它很有用。

A 等于一个数组，这个数组是 [[1, -3, 4], [-2, -4, 3]]，然后对 A 求绝对值，即 np.abs(A)---------------array([[1, 3, 4],      [2, 4, 3]])

26、round

将浮点值四舍五入到指定数目的小数点。

使用 numpy 库的 around 函数，对数组 a 进行四舍五入操作，指定小数位数为 0，结果可以存储在 out 数组中（如果提供了 out 数组），或者创建一个新的数组来存储结果（如果没有提供 out 数组）。

decimals:要保留的小数点的个数。

创建了一个名为 a 的数组，该数组是通过 np.random.random 函数生成的，其大小为(3, 4)。a-----[0.81695699, 0.42564822, 0.65951417, 0.2731807]这个数组包含了一些数值。这些数值分别是 0.81695699、0.42564822、0.65951417 和 0.2731807。

np.round(a,decimals=0)------------array([[1., 0., 1., 1.],      [1., 1., 1., 1.],      [0., 1., 0., 1.]])
np.round(a,decimals=1)-------------array([[0.8, 0. , 0.6, 0.6],      [0.5, 0.7, 0.7, 0.8],      [0.3, 0.9, 0.5, 0.7]])

27、clip

numpy 会对数组 a 进行裁剪操作，将其值限制在 a_min 和 a_max 之间。如果指定了 out 参数，则结果将存储在 out 数组中。此外，还可以通过 kwargs 传递其他参数。

它可以将数组的裁剪值保持在一个范围内。

arr 是一个数组，其元素为[0,1,-3,-4,5,6,7,2,3]，这个数组是通过 np.array 函数创建的。arr.clip(0,5)-----------------一个包含 0、1、0、0、5、5、5、2、3 的数组。这个数组有 9 个元素，其中 0 出现了 2 次，1 出现了 1 次，5 出现了 3 次，2 出现了 1 次，3 出现了 1 次。
arr.clip(0,3)------------------数组包含 0、1、0、0、3、3、3、2、3 这些元素。0 出现在数组中，1 也在其中，还有两个 0，接着有多个 3，之后是 2，最后又有多个 3。
arr.clip(3,5)------------------[3, 3, 3, 3, 5, 5, 5, 3, 3] 是一个数组，其中包含多个 3 和 5 。数组中的元素有 3 出现多次，还有 5 也出现多次。

替换数组中的值

28、where

返回满足条件的数组元素。

如果满足条件 condition，就返回 [x, y, ] 中的值；如果不满足条件 condition，就返回其他值（这里未明确给出其他值的情况）。

匹配的条件决定了返回的结果。如果条件为真，就返回 x；如果条件为假，就返回 y。

np 生成一个从 0 到 11 的数组，然后将其重塑为 4 行 3 列的形状，赋值给变量 aa-------array([[ 0, 1, 2],      [ 3, 4, 5],      [ 6, 7, 8],      [ 9, 10, 11]])
获取索引，即找出满足 a 大于 5 的那些位置。 找出 a 大于 5 的情况。 找到 a 大于 5 时的索引。 确定 a 大于 5 所对应的索引。 找出 a 中大于 5 的那些索引位置。 找到 a 大于 5 时的那些索引。 确定 a 大于 5 所对应的那些索引位置。--------------------数组([2, 2, 2, 3, 3, 3], 数据类型为 int64)数组由 0、1、2 组成，数据类型为 int64，其中包含两个 0、两个 1 和两个 2。
获取值，即找出 a 中大于 5 的那些值。--------------------------array([ 6, 7, 8, 9, 10, 11])

它还可以用来替换pandas df中的元素。

如果 data[feature] 为 null ，则返回 1 ，否则返回 0 。

29、put

用给定的值替换数组中指定的元素。

numpy.put(a, ind, v)

a:数组

Ind:需要替换的索引

V:替换值

arr = np.array([1,2,3,4,5,6])arr--------array([1, 2, 3, 4, 5, 6])
np.put(arr,[1,2],[6,7])arr--------array([1, 6, 7, 4, 5, 6])

30、copyto

将一个数组的内容复制到另一个数组中。

numpy 将 src 复制到 dst 中，在复制过程中进行类型转换，转换方式为“same_kind”，并且只有在 where 条件为 True 时才进行复制操作。

dst：目标

src：来源

arr1 = np.array([1,2,3])arr2 = np.array([4,5,6])print("Before arr1",arr1)print("Before arr2",arr1)np.copyto(arr1,arr2)print("After arr1",arr1)print("After arr2",arr2)---------------------------Before arr1 [1 2 3]Before arr2 [4 5 6]
After arr1 [4 5 6]After arr2 [4 5 6]

集合操作

31、查找公共元素

intersect1d 函数能够以排序的形式返回两个数组里的所有独特的值。

numpy 进行 intersect1d 操作，操作的对象是 ar1 和 ar2，其中 assume_unique 参数为 False，return_indices 参数也为 False

如果为真值，那就假设输入数组都是唯一的。

如果 Return_indices 为真，那么就会返回公共元素的索引。

ar1 = np.array([1,2,3,4,5,6])ar2 = np.array([3,4,5,8,9,1])np.intersect1d(ar1,ar2)---------------array([1, 3, 4, 5])
np.intersect1d 函数用于找出两个数组 ar1 和 ar2 的交集，并返回交集元素以及它们在 ar1 和 ar2 中的索引。该函数的参数 return_indices=True 表示不仅返回交集元素，还返回这些元素在 ar1 和 ar2 中的索引。---------------数组([1, 3, 4, 5])，这是常见元素。数组包含 0 、2 、3 、4 ，其数据类型为 int64 。数组([5, 0, 1, 2], 数据类型为 int64)

32、查找不同元素

numpy 执行 setdiff1d 操作，传入参数 ar1 和 ar2，并且 assume_unique 参数设置为 False

np.setdiff1d 函数会返回 arr1 当中那些在 arr2 里不存在的所有唯一的元素。

a 是一个数组，它包含的元素有 1、7、3、2、4、1，这些元素构成了数组 a，即 a = np.array([1, 7, 3, 2, 4, 1]) 。b 是一个数组，数组中的元素为 9、2、5、6、7、8 。np.setdiff1d(a, b)---------------------array([1, 3, 4])

33、从两个数组中提取唯一元素

numpy 执行 setxor1d 操作，传入参数 ar1 和 ar2，同时 assume_unique 参数设置为 False

Setxor1d 将按顺序返回两个数组中所有唯一的值。

a = np.array([1, 2, 3, 4, 6])数组 [1, 4, 9, 4, 36] 构成了 np 数组 b。np.setxor1d(a,b)--------------------array([ 2, 3, 6, 9, 36])

34、合并

numpy.union1d(ar1, ar2)

Union1d函数将两个数组合并为一个。

a = np.array([1, 2, 3, 4, 5])b 是一个数组，其元素为 1、3、5、4、36，这些元素构成了数组 b 的内容。np.union1d(a,b)-------------------array([ 1, 2, 3, 4, 5, 36])

数组分割

35、水平分割

numpy 将数组 ary 按照 indices_or_sections 进行水平分割。

Hsplit函数将数据水平分割为n个相等的部分。

A 是一个由两个子数组组成的数组，其中一个子数组为 [3,4,5,2]，另一个子数组为 [6,7,2,6]，且这个数组是通过 np.array 函数创建的。np.hsplit(A, 2) ；此操作将数据分成两个相等的部分---------------有两个数组，一个数组是[[3, 4],[6, 7]]，另一个数组是[[5, 2],[2, 6]]
np 把 A 水平分割成 4 部分，即将数据分成四个相等的部分。-----------------有两个数组，一个是[[3],[6]]，另一个是[[4],[7]]。有两个数组，一个是[[5],[2]]，另一个是[[2],[6]]

36、垂直分割

numpy 对 ary 进行垂直分割，分割依据是 indices_or_sections

Vsplit将数据垂直分割为n个相等的部分。

A = np.array([[3,4,5,2],[6,7,2,6]])np.vsplit(A,2)----------------[array([3, 4, 5, 2]), array([6, 7, 2, 6])] 有两个数组，一个数组的元素为 3、4、5、2，另一个数组的元素为 6、7、2、6。

数组叠加37、水平叠加

numpy.hstack(tup)

hstack 将在另一个数组的末尾追加一个数组。

a = np.array([1,2,3,4,5])b = np.array([1,4,9,16,25])
np.hstack((a,b))---------------------这个数组包含了 1、2、3、4、5 这些数字，同时还包含了 1 再次出现，以及 4、9、16、25 这些数字。

38、垂直叠加

numpy.vstack(tup)

vstack将一个数组堆叠在另一个数组上。

np.vstack((a,b))----------------------array([[ 1, 2, 3, 4, 5],      [ 1, 4, 9, 16, 25]])

数组比较

39、allclose

numpy 对 a 和 b 进行比较，相对容忍度为 1e-05，绝对容忍度为 1e-08，并且当两个数都为 NaN 时不认为它们相等，使用 numpy.allclose 函数来判断是否接近。

如果两个数组的形状是一样的，那么 Allclose 函数会依据公差值来查找这两个数组是否相等或者近似相等。

np 生成了一个数组，这个数组的元素分别是 0.25、0.4、0.6、0.32，该数组被赋值给变量 ab 是一个数组，这个数组的元素分别是 0.26、0.3、0.7、0.32 。
容忍度等于 0.1 。总差异为 0.1 。容忍值为 0.1 。0.1 是容忍度。0.1 代表总差异。0.1 就是容忍值。np.allclose(a,b,tolerance)---------False
tolerance = 0.5np.allclose(a,b,tolerance)----------True

40、equal

numpy 使 x1 与 x2 相等，通过 / 进行操作，输出结果存储在 out 中，同时需要满足 * 的条件。where 的值为 True，进行的转换类型为“same_kind”。order 为 'K'，数据类型为 None，允许返回子类的对象为 True，有签名、外部对象等参数（若有）。           ) =

它比较两个数组的每个元素，如果元素匹配就返回True。

np.equal(arr1,arr2)-------------这是一个数组，其中包含了多个布尔值。第一个元素为 True，第二个元素为 True，第三个元素为 True，第四个元素为 False，第五个元素为 True，第六个元素为 True。

重复的数组元素

41、repeat

它用于重复数组中的元素n次。

numpy 对数组 a 进行重复操作，重复的次数为 repeats，在指定的轴 axis 上进行重复，如果 axis 未指定，则在所有轴上进行重复。

A:重复的元素

Repeats:重复的次数。

np.repeat('2017',3)---------------------2017 出现了三次，其数据类型为

我们来看一个更实际的示例，我们拥有一个数据集，这个数据集中包含按年统计的销售数量。

fruits = pd.DataFrame([  ['Mango',40],  ['Apple',90],  ['Banana',130]这是一个关于数据的描述，其中包含了两列，分别是['Product']和['ContainerSales']。fruits

在数据集中，缺少年份列。我们尝试使用numpy添加它。

fruits 的['year']这一属性被设置为将 2020 重复 fruits.shape[0]次所得到的结果。fruits

42、tile

通过重复A，rep次来构造一个数组。

numpy.title(A, reps)

np.tile("Ram",5)-------Ram 多次出现，其类型为 dtype='。具体为 Ram 出现了 5 次，都为该类型。
np.tile(3,(2,3))-------array([[3, 3, 3],      [3, 3, 3]])

爱因斯坦求和

43、einsum

使用 einsum 函数，传入子脚本 subscripts 和操作数 operands 等参数，在 out 为 None 的情况下进行相关计算操作。            dtype=None, order='K', 设置为“安全”的 casting，且 optimize 为 False。

此函数用于计算数组上的多维和线性代数运算。

使用 np.arange 函数生成从 1 到 9 的数组，然后将其重塑为 3 行 3 列的形状并赋值给变量 ab 等于将从 21 到 29 的数字进行排列得到的数组，然后将这个数组重塑为 3 行 3 列的形状。
np.einsum('ii->i',a)------------array([1, 5, 9])
np.einsum('ji',a)------------array([[1, 4, 7],      [2, 5, 8],      [3, 6, 9]])
np.einsum('ij,jk',a,b)------------array([[150, 156, 162],      [366, 381, 396],      [582, 606, 630]])
p.einsum('ii',a)----------15

统计分析

44、直方图

numpy 对数组 a 进行直方图统计，设置 bins 为 10，range 为 Nonenormed 为 None，weights 为 None，density 为 None。

这是一个重要的统计分析函数，属于 Numpy。它能够计算出一组数据的直方图值。

A = np.array([[3, 4, 5, 2],            [6, 7, 2, 6]])np.histogram(A)-------------------数组([2, 0, 1, 0, 1, 0, 1, 0, 2, 1], dtype 为 int64)数组中包含 2. 到 7. 之间以 0.5 为间隔的数值。

45、百分位数

沿指定轴计算数据的Q-T-T百分位数。

numpy 计算数组 a 中给定百分位数 q 的值，可指定沿轴 axis 进行计算，结果可以存储在 out 数组中，若未指定 out 则创建新数组存储结果，axis 为 None 时在整个数组上计算。使用“linear”方法，并且不覆盖输入。                 keepdims=False, *,                  interpolation=None)[source]

a:输入。

q:要计算的百分位。

如果是 true 的话，就可以允许输入数组去修改中间的计算，这样能够节省内存。

a 是一个数组，其元素为[[2, 4, 6], [4, 8, 12]]
np.percentile(a, 50)-----------5.0
np.percentile(a, 10)------------3.0
arr = np.array([2,3,4,1,6,7])np.percentile(a,5)------------2.5

46、标准偏差

numpy 对数组 a 进行标准差计算，可指定轴 axis 为 None，指定数据类型 dtype，将结果存储到 out 中，或者不指定 out 而直接返回结果，不指定轴时计算整个数组的标准差，指定轴后则按轴计算标准差，同时可指定数据类型来控制计算结果的数据类型。          ddof=0, keepdims=, *,           where=)

std用于计算沿轴的标准偏差。

a = np.array([[2, 4, 6], [4, 8, 12]])np.std(a,axis=1)--------创建了一个数组，其中包含两个数值，分别是 1.63299316 和 3.26598632 。
np.std(a, 轴为 0)  这是按列进行计算的标准偏差--------array([1., 2., 3.])

47、方差

numpy 对 a 进行方差计算，其轴可以为 None，数据类型可以为 dtype，结果可以存储在 out 中          ddof=0, keepdims=, *,           where=)

var用于计算沿轴的方差。

a = np.array([[2, 4, 6], [4, 8, 12]])np.var(a,axis=1)-------------------数组包含两个数值，分别是 2.66666667 和 10.66666667 。
np.var(a,axis=0)-------------------array([1., 4., 9.])

数组打印

48、显示带有两个十进制值的浮点数

numpy 设定打印选项，精度设置为无，阈值设置为无，边缘项设置为无，linewidth 为 None，suppress 为 None，nanstr 为 None，infstr 为 None。formatter 为 None，sign 为 None，floatmode 为 None，并且需要满足以下条件：*（这里可以根据具体需求补充关于 * 的条件）                       legacy=None)

设置打印选项，将精度设置为 2 。
a 是一个由两个数字组成的数组，分别是 12.23456 和 32.34535 。这个数组被表示为 np.array([12.23456, 32.34535]) 。print(a)------------array([12.23,32.34])

设置打印数组最大值

设置打印选项，将阈值设置为无穷大，即 np.set_printoptions(threshold=np.inf) 。

增加一行中元素的数量

np.set_printoptions 中的 linewidth 默认是 75，现在将其设置为 100 。

保存和加载数据

49、保存

numpy.savetxt(fname, X, fmt='%.18e', delimiter=' ',               newline='\n', header='', footer='',               comments='# ', encoding=None)

savetxt用于在文本文件中保存数组的内容。

arr 是通过 np.linspace(10, 100, 500) 生成的数值序列，然后将其重新调整为 25 行 20 列的形状。np.savetxt('array.txt',arr)

50、加载

numpy.loadtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None,              converters=None, skiprows=0, usecols=None, unpack=False,               ndmin=0, encoding='bytes', max_rows=None, *,               quotechar=None, like=None)