这些10种Numpy高级操作你都会吗？转载

原创

小哥 3年前 (2022-10-16) 阅读数 53 #大杂烩

来源: CSDN-逐梦er

一.数组迭代数组

===============

NumPy 包含迭代器对象包括迭代器对象numpy.nditer。它是一个有效的多维迭代器对象，可用于迭代数组。数组的每个元素都可以使用 Python 的标准Iterator要访问的接口。接口来访问它。用于访问的接口。

import numpy as np
a = np.arange(0, 60, 5)
a = a.reshape(3, 4)
print(a)
for x in np.nditer(a):
    print(x)

[[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]
0
5
10
15
20
25
30
35
40
45
50
55

如果两个数组是可广播的，如果两个数组是可广播的，则这两个数组是可广播的nditer组合对象可以同时迭代它们。假设这个数字组a具有维度 3X4存在一个维度，维度的存在 1X4 的另一个数组和的另一个数组b如果使用以下类型的迭代器，则使用以下类型的迭代器；如果使用以下类型的迭代器，则使用以下类型的迭代器(数组b被广播到a的大小)。

import numpy as np
a = np.arange(0, 60, 5)
a = a.reshape(3, 4)
print(a)
b = np.array([1, 2, 3, 4], dtype=int)
print(b)
for x, y in np.nditer([a, b]):
    print(x, y)

[[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]
[1 2 3 4]
0 1
5 2
10 3
15 4
20 1
25 2
30 3
35 4
40 1
45 2
50 3
55 4

二.数组形状修改函数数组形状修改函数数组形状修改函数

1.ndarray.reshape

该函数在不更改数据的情况下修改形状，参数如下。

ndarray.reshape(arr, newshape, order)

其中：

import numpy as np
a = np.arange(8)
print(a)
b = a.reshape(4, 2)
print(b)

2.ndarray.flat

函数返回数组上的一维迭代器，其行为类似于 Python 内置迭代器。内置迭代器。内置迭代器。内置迭代器。

import numpy as np
a = np.arange(0, 16, 2).reshape(2, 4)
print(a)
# 返回展开数组的下标的对应元素
print(list(a.flat))

[[ 0  2  4  6]
 [ 8 10 12 14]]
[0, 2, 4, 6, 8, 10, 12, 14]

3.ndarray.flatten

该函数返回折叠到一维的数组副本，并接受以下参数。

ndarray.flatten(order)其中：order：‘C’ — 按行，‘F’ — 按列，‘A’ — 原始订单，‘原始订单，’原始订单，‘k’ -元素在内存中的出现顺序。-元素在内存中出现的顺序。-元素在内存中的出现顺序。

import numpy as np
a = np.arange(8).reshape(2, 4)
print(a)
# default is column-major
print(a.flatten())
print(a.flatten(order=F))

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

三.数组反转运算函数数组反转运算函数

=================

1.numpy.transpose

函数用于反转给定数组的维度。如果可能，它将返回一个视图。此函数接受以下参数。

numpy.transpose(arr, axes)

其中：

• arr：要转置的数组：要转置的数组：要转置的数组

• axes：与尺寸对应的整数列表，通常翻转所有尺寸。

import numpy as np
a = np.arange(24).reshape(2, 3, 4)
print(a)
b = np.array(np.transpose(a))
print(b)
print(b.shape)

[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
[[[ 0 12]
  [ 4 16]
  [ 8 20]]

 [[ 1 13]
  [ 5 17]
  [ 9 21]]

 [[ 2 14]
  [ 6 18]
  [10 22]]

 [[ 3 15]
  [ 7 19]
  [11 23]]]
(4, 3, 2)

b = np.array(np.transpose(a, (1, 0, 2)))
print(b)
print(b.shape

[[[ 0  1  2  3]
  [12 13 14 15]]

 [[ 4  5  6  7]
  [16 17 18 19]]

 [[ 8  9 10 11]
  [20 21 22 23]]]
(3, 2, 4)

2. numpy.ndarray.T

此函数属于此函数是此函数所属的部分ndarray类，行为类似于类，行为类似于行为类似于numpy.transpose.

import numpy as np
a = np.arange(12).reshape(3, 4)
print(a)
print(a.T)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

3.numpy.swapaxes

函数交换数组的两个轴。此函数接受以下参数。

– numpy.swapaxes(arr, axis1, axis2)

– 参数：

• arr：要交换轴的输入数组

• axis1：第一轴对应的整数：第一轴对应的整数

• axis2：第二轴对应的整数：第二轴对应的整数

import numpy as np
a = np.arange(8).reshape(2, 2, 2)
print(a)
print(np.swapaxes(a, 2, 0))

[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
[[[0 4]
  [2 6]]

 [[1 5]
  [3 7]]]

4.numpy.rollaxis

s 该函数向后滚动特定的轴，直到特定的位置。此函数

接受三个参数。接受三个参数。接受三个参数。

– numpy.rollaxis(arr, axis, start)

– 其中：

• arr：输入数组

• axis：要回滚的轴，其他轴的相对位置不会改变

• start：默认为零，表示全滚动。将滚动到特定位置。

import numpy as np
a = np.arange(8).reshape(2,2,2)
print(a)
print(np.rollaxis(a,2))
print(np.rollaxis(a,2,1))

[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
[[[0 2]
  [4 6]]

 [[1 3]
  [5 7]]]
[[[0 2]
  [1 3]]

 [[4 6]
  [5 7]]]

四.数组修改维度函数数组修改维度函数

1.numpy.broadcast_to

函数将数组广播到新形状。它仅在原始数组上返回读一读这一观点。它通常不是连续的。如果新形状与 NumPy 播放规则，函数可以抛出播放规则，函数可以抛出ValueError。此函数接受以下参数。

– numpy.broadcast_to(array, shape, subok)

import numpy as np
a = np.arange(4).reshape(1,4)
print(a)
print(np.broadcast_to(a,(4,4)))

[[0 1 2 3]]
[[0 1 2 3]
 [0 1 2 3]
 [0 1 2 3]
 [0 1 2 3]]

2.numpy.expand_dims

函数通过在指定位置插入新的轴来扩展数组形状。该函数有两个参数。

– numpy.expand_dims(arr, axis)

– 其中：

• arr：输入数组
• axis：新轴插入的位置：新轴插入的位置：新轴插入的位置

import numpy as np
x = np.array(([1, 2], [3, 4]))
print(x)
y = np.expand_dims(x, axis=0)
print(y)
print(x.shape, y.shape)
y = np.expand_dims(x, axis=1)
print(y)
print(x.ndim, y.ndim)
print(x.shape, y.shape)

[[1 2]
 [3 4]]
[[[1 2]
  [3 4]]]
(2, 2) (1, 2, 2)
[[[1 2]]

 [[3 4]]]
2 3
(2, 2) (2, 1, 2)

3.numpy.squeeze

函数从给定数组的形状中移除一维条目。此函数使用两个参数个参数。

– numpy.squeeze(arr, axis)

– 其中：

• arr：输入数组

• axis：用于选择形状中的一维条目子集的整数或整数元组

import numpy as np
x = np.arange(9).reshape(1, 3, 3)
print(x)
y = np.squeeze(x)
print(y)
print(x.shape, y.shape)

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

五.数组的联接运算数组串联运算数组串联运算

NumPy中的数组有四个主要的串联函数

concatenate 沿现有轴连接数据序列沿现有轴连接数据序列

stack 沿新轴连接数组序列沿新轴连接数组序列

hstack 水平堆叠序列中的阵列水平堆叠序列中的阵列水平堆叠序列中的阵列(列方向)

vstack 垂直堆叠序列中的阵列垂直堆叠序列中的阵列垂直堆叠序列中的阵列(行方向)

1.numpy.stack

该函数沿新的轴联接数组序列，并需要以下参数。

– numpy.stack(arrays, axis)

– 其中：

• arrays：同形数组序列：同形数组序列：同形数组序列

• axis：返回数组中沿其堆叠输入数组的轴

import numpy as np
a = np.array([[1,2],[3,4]])
print(a)
b = np.array([[5,6],[7,8]])
print(b)
print(np.stack((a,b),0))
print(np.stack((a,b),1))

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

 [[5 6]
  [7 8]]]
[[[1 2]
  [5 6]]

 [[3 4]
  [7 8]]]

2.numpy.hstack

是numpy.stack通过堆叠生成水平单个数组的函数的变体。

import numpy as np
a = np.array([[1, 2], [3, 4]])
print(a)
b = np.array([[5, 6], [7, 8]])
print(b)
print(水平堆叠。水平堆叠。水平堆叠。水平堆叠。水平堆叠：。。)
c = np.hstack((a, b))
print(c)

[[1 2]
 [3 4]]
[[5 6]
 [7 8]]
水平堆叠。水平堆叠。水平堆叠。水平堆叠。水平堆叠：。。
[[1 2 5 6]
 [3 4 7 8]]

3.numpy.vstack

是numpy.stack通过堆叠生成垂直单数组的函数的变体。

import numpy as np
a = np.array([[1, 2], [3, 4]])
print(a)
b = np.array([[5, 6], [7, 8]])
print(b)
print(垂直堆叠。垂直堆叠。垂直堆叠：。)
c = np.vstack((a, b))
print(c)

[[1 2]
 [3 4]]
[[5 6]
 [7 8]]
垂直堆叠。垂直堆叠。垂直堆叠：。
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

4.numpy.concatenate

函数用于沿指定的轴联接两个或多个形状相同的数组。

此函数接受以下参数。

– numpy.concatenate((a1, a2, …), axis)

– 其中：

• a1, a2, ...：相同类型的数组序列：相同类型的数组序列

• axis：它沿着其连接阵列的轴，默认为 0

import numpy as np
a = np.array([[1,2],[3,4]])
print(a)
b = np.array([[5,6],[7,8]])
print(b)
print(np.concatenate((a,b)))
print(np.concatenate((a,b),axis = 1))

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

六.阵列分区阵列分区操作阵列拆分操作阵列拆分操作

NumPy中数组的主要数组分区函数如下。

– split 将阵列拆分为多个子阵列将阵列拆分为多个子阵列将阵列划分为多个子阵列
– hsplit 将数组水平拆分为多个子数组(按列) 
– vsplit 将数组垂直拆分为多个子数组(按行)

1.numpy.split

该函数沿特定的轴将数组分割为子数组。函数接受三个参数。接受三个参数。接受三个参数。

– numpy.split(ary, indices_or_sections, axis)

• ary：拆分输入数组：拆分输入数组

• indices_or_sections：可以是一个整数，指示要从输入数组创建的相同大小的子数组的数量。如果此参数是一维数组，则其元素指示要创建的新子数组的点。

• axis：默认为 0

import numpy as np
a = np.arange(9)
print(a)
print(将数组分为三个大小相等的子数组。)
b = np.split(a,3)
print(b)
print(在一维数组指示的位置对数组进行分区。)
b = np.split(a,[4,7])
print(b)

2.numpy.hsplit

split()函数的一个特例，其中轴是 1 表示水平分段。表示水平分段。表示水平分割。表示水平拆分。

import numpy as np
a = np.arange(16).reshape(4,4)
print(a)
print(水平分割。水平分段。水平拆分。水平拆分。)
b = np.hsplit(a,2)
print(b)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
水平分割。水平分段。水平拆分。水平拆分。
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]

3.numpy.vsplit

split()函数的一个特例，其中轴是 0 表示垂直分区，与输入数组的维度无关。

import numpy as np
a = np.arange(16).reshape(4,4)
print(a)
print(垂直分割。垂直分段。垂直拆分。垂直拆分。)
b = np.vsplit(a,2)
print(b)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
垂直分割。垂直分段。垂直拆分。垂直拆分。
[array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]

七.数组元素操作数组元素操作数组元素操作

===============

NumPy中的主要数组操作函数

– resize 返回指定形状的新数组返回指定形状的新数组返回指定形状的新数组

– append 将值添加到数组的末尾将值添加到数组的末尾

– insert 沿指定的轴在指定的下标之前插入值

– delete 返回删除了轴的子数组的新数组

– unique 查找数组中的唯一元素查找数组中的唯一元素

1.numpy.resize

函数返回指定大小的新数组。如果新大小大于原始大小，则包含原始数组中的元素的重复副本。如果小于则去掉原始数组的部分数据。此函数接受以下参数。

– numpy.resize(arr, shape)

– 其中：

• arr：需要修改大小的输入数组：需要调整大小的输入数组：需要修改的输入数组：需要调整大小的输入数组
• shape：返回数组的新形状

import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a)
print(a.shape)
b = np.resize(a, (3,2))
print(b)
print(b.shape)
print(修改第二个数组的大小。)
b = np.resize(a,(3,3))
print(b)
print(修改第三个数组的大小。)
b = np.resize(a,(2,2))
print(b)

[[1 2 3]
 [4 5 6]]
(2, 3)
[[1 2]
 [3 4]
 [5 6]]
(3, 2)
修改第二个数组的大小。
[[1 2 3]
 [4 5 6]
 [1 2 3]]
修改第三个数组的大小。
[[1 2]
 [3 4]]

2.numpy.append

函数将值添加到输入数组的末尾。追加操作不是就地操作，而是分配一个新数组。此外，输入数组的维度必须匹配，否则将生成ValueError。该函数接受以下函数。

– numpy.append(arr, values, axis)

– 其中：

• arr：输入数组
• values：要向arr例如，附加值和附加值，例如和arr形状相同(除了除了要添加的轴之外的要添加的轴之外的要添加的轴) 
• axis：它沿其完成操作的轴。如果未提供，则两个参数都将展开。

import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a)
print(np.append(a, [[7,8,9]],axis = 0))
print(np.append(a, [[5,5,5],[7,8,9]],axis = 1))

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

3.numpy.insert

该函数将沿输入数组中给定轴的值插入到给定索引之前。如果将值转换为要插入的类型，则它与输入数组不同。没有就地插入，该函数返回一个新数组。此外，如果未提供轴，则扩展输入数组。

insert()该函数接受以下参数。函数接受以下参数。函数接受以下参数。

– numpy.insert(arr, obj, values, axis)

• arr：输入数组
• obj：在其前面插入值的索引：在其之前插入值的索引：在其前面插入值的索引
• values：要插入的值：要插入的值：要插入的值
• axis：沿其插入的轴：沿轴插入

import numpy as np
a = np.array([[1,2],[3,4],[5,6]])
print(a)
print(np.insert(a,3,[11,12]))
print(np.insert(a,1,[11],axis = 0))
print(np.insert(a,1,[11],axis = 1))

[[1 2]
 [3 4]
 [5 6]]
[ 1  2  3 11 12  4  5  6]
[[ 1  2]
 [11 11]
 [ 3  4]
 [ 5  6]]
[[ 1 11  2]
 [ 3 11  4]
 [ 5 11  6]]

4.numpy.delete

该函数返回一个新数组，该数组从输入数组中移除指定的子数组。不像insert()与函数的情况一样，如果没有提供轴参数，则将展开输入数组。该功能该数字接受以下参数。Number接受以下参数。可以接受以下参数。

– Numpy.delete(arr, obj, axis)

• arr：输入数组
• obj：可以是切片、整数或整数数组，指示要从输入数组中移除的子数组
• axis：删除给定子数组的轴

import numpy as np
a = np.array([[1,2],[3,4],[5,6]])
print(a)
print(np.delete(a,5))
print(np.delete(a,1,axis = 1))

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

5.numpy.unique

该函数返回输入数组中已消除重复项的元素的数组。该函数可以返回包含已消除重复的数组和关联索引数组的元组。索引的性质取决于函数调用中返回参数的类型。

– numpy.unique(arr, return_index, return_inverse, return_counts)

• arr：输入数组，如果不是一维数组，则展开
• return_index：如果为true返回输入数组中元素的下标
• return_inverse：如果为true它返回已消除重复项的数组的下标，可用于重构输入数组
• return_counts：如果为true返回已消除重复数据的数组的元素在原始数组中出现的次数

import numpy as np
a = np.array([5,2,6,2,7,5,6,8,2,9])
u = np.unique(a)
print(u)
u,indices = np.unique(a, return_index = True)
print(u, indices)
u,indices = np.unique(a,return_inverse = True)
print(u, indices)
u,indices = np.unique(a,return_counts = True)
print(u, indices)

[2 5 6 7 8 9]
[2 5 6 7 8 9] [1 0 2 4 7 9]
[2 5 6 7 8 9] [1 0 2 0 3 1 2 4 0 5]
[2 5 6 7 8 9] [3 2 2 1 1 1]

八.NumPy - 字符串函数字符串函数

下列函数用于下列函数dtype为numpy.string_或numpy.unicode_数组执行向量的数组执行向量数组执行向量字符串运算基于它们所基于的 Python 内置库中的标准字符串函数字符串函数。字符数组类(numpy.char)中定义

import numpy as np
print(np.char.add([hello],[ xyz]))
print(np.char.add([hello, hi],[ abc,  xyz]))
print(np.char.multiply(Hello ,3))
print(np.char.center(hello, 20,fillchar = *))
print(np.char.capitalize(hello world))
print(np.char.title(hello how are you?))
print(np.char.lower([HELLO,WORLD]))
print(np.char.lower(HELLO))
print(np.char.upper(hello))
print(np.char.upper([hello,world]))
print(np.char.split (hello how are you?))
print(np.char.split (YiibaiPoint,Hyderabad,Telangana, sep = ,))
print(np.char.splitlines(hello

how are you?)) print(np.char.splitlines(hello how are you?)) print(np.char.strip(ashok arora,a)) print(np.char.strip([arora,admin,java],a)) print(np.char.join(:,dmy)) print(np.char.join([:,-],[dmy,ymd])) print(np.char.replace (He is a good boy, is, was)) a = np.char.encode(hello, cp500) print(a) print(np.char.decode(a,cp500))

[hello xyz]
[hello abc hi xyz]
Hello Hello Hello 
*******hello********
Hello world
Hello How Are You?
[hello world]
hello
HELLO
[HELLO WORLD]
[hello, how, are, you?]
[YiibaiPoint, Hyderabad, Telangana]
[hello, how are you?]
[hello, how are you?]
shok aror
[ror dmin jav]
d:m:y
[d:m:y y-m-d]
He was a good boy
bx88x85x93x93x96
hello

九.NumPy - 算数函数

=====================

NumPy 包含用于各种数学运算的大量函数。NumPy 提供标准三角函数、算术运算函数、复数处理函数等。

– 三角函数
– 舍入函数
– 算数函数

1. NumPy -三角函数

NumPy 具有以弧度单位返回给定角度的三角函数的标准三角函数
数比值。arcsin，arccos，和arctan函数返回给定函数的角度返回sin，cos和tan的反
三角函数。这些函数的结果可以通过以下方式获得numpy.degrees()通过将弧度系统设置为通过将弧度系统转换为功能来转换弧度系统功能转换为角度系统进行验证。转换为角度系统以进行验证。转换为角度系统进行验证。转换为角度系统进行验证。

import numpy as np
a = np.array([0,30,45,60,90])
# 通过乘 pi/180 转换为弧度转换为圆弧
print(np.sin(a*np.pi/180))
print(np.cos(a*np.pi/180))
print(np.tan(a*np.pi/180))

[ 0.          0.5         0.70710678  0.8660254   1.        ]
[  1.00000000e+00   8.66025404e-01   7.07106781e-01   5.00000000e-01
   6.12323400e-17]
[  0.00000000e+00   5.77350269e-01   1.00000000e+00   1.73205081e+00
   1.63312394e+16]

2.NumPy -舍入函数

• numpy.around()此函数返回四舍五入到所需精度的值

– numpy.around(a,decimals) – a 输入数组
– decimals 要舍入的小数位数。要舍入到的小数位数。要舍入的小数位数。要舍入的小数位数。 默认值为0。 如果为负数，则将整数舍入到小数点左侧

• numpy.floor() 该函数返回不大于输入参数的最大整数。

• numpy.ceil() 该函数返回输入值的上限，即大于输入参数的最小整数。

import numpy as np
a = np.array([1.0, 5.55, 123, 0.567, 25.532])
print(np.around(a))
print(np.around(a, decimals=1))
print(np.floor(a))
print(np.ceil(a))

[   1.    6.  123.    1.   26.]
[   1.     5.6  123.     0.6   25.5]
[   1.    5.  123.    0.   25.]
[   1.    6.  123.    1.   26.]

3.NumPy - 算数运算

用于执行算术运算的算术运算的算术运算(如add()，subtract()，multiply()和divide())输入阵列必须具有相同的形状或符合阵列广播规则。

– numpy.reciprocal() 该函数逐个返回参数元素的倒数。
– numpy.power() 该函数以第一个输入数组中的元素为基，并将其计算为第二个输入数组中相应元素的幂。
– numpy.mod() 该函数返回输入数组中相应元素除法的余数。

import numpy as np
a = np.array([0.25, 2, 1, 0.2, 100])
print(np.reciprocal(a))
print(np.power(a,2))
a = np.array([10,20,30])
b = np.array([3,5,7])
print(np.mod(a,b))

[ 4.    0.5   1.    5.    0.01]
[  6.25000000e-02   4.00000000e+00   1.00000000e+00   4.00000000e-02
   1.00000000e+04]
[1 0 2]

4.NumPy - 统计函数

NumPy 有许多有用的统计函数用于从数组中的给定元素找出最小、最大、百分比标准差和方差等。

– numpy.amin() , numpy.amax() 返回指定轴上给定数组元素的最小值和最大值。
– numpy.ptp() 此函数返回轴上的值范围(最大值 - 最小值)。
– numpy.percentile() 以百分比形式指示小于此可观测值 
    • numpy.percentile(a, q, axis)
    • a 输入数组;q 要以要计算的百分位数计算的百分位数 0 ~ 100 之间;axis 计算百分位数的轴计算百分位数的轴
– numpy.median() 返回数据样本的中位数。
– numpy.mean() 返回数组中元素沿轴的算术平均值。
– numpy.average() 返回通过将每个分量乘以反映其重要性的系数而获得的加权平均值

import numpy as np
a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print(np.amin(a,1))
print(np.amax(a,1))
print(np.ptp(a))
print(np.percentile(a,50))
print(np.median(a))
print(np.mean(a))
print(np.average(a))
print(np.std([1,2,3,4])) #返回数组的标准差返回数组的标准差返回数组的标准差
print(np.var([1,2,3,4])) #返回数组方差返回数组方差返回数组方差

[3 3 2]
[7 8 9]
7
4.0
4.0
5.0
5.0
1.11803398875
1.25

十.NumPy排序、搜索和计数功能排序、搜索和计数功能

NumPy中提供了各种与排序相关的函数

– numpy.sort该函数返回输入数组的排序副本。numpy.sort(a, axis, kind, order)
    • a 要排序的数组要排序的数组要排序的数组; 
    • axis 数组排序所沿着的轴，如果没有数组，它将沿着最后一个轴展开和排序; • kind 默认为quicksort(快速排序);
    • order 如果数组包含字段，则它们是要排序的字段
– numpy.argsort() 该函数沿给定轴对输入数组执行间接排序，并使用指定的排序类型返回数据的索引数组。该索引数组用于构造排序数组。
– numpy.lexsort()函数使用键序列执行间接排序。可以将键视为电子表格中的一列。该函数返回一个索引数组，可用于获取排序后的数据。请注意，最后一个键恰好是 sort 的主键。
– numpy.argmax() 和 numpy.argmin()这两个函数分别返回沿给定轴的最大和最小元素的索引。
– numpy.nonzero() 此函数返回输入数组的非零元素的索引。
– numpy.where() 该函数返回满足给定条件的输入数组中元素的索引。
– numpy.extract() 该函数返回满足任何条件的元素。

import numpy as np
a = np.array([[3, 7, 3, 1], [9, 7, 8, 7]])
print(np.sort(a))
print(np.argsort(a))
print(np.argmax(a))
print(np.argmin(a))
print(np.nonzero(a))
print(np.where(a > 3))
nm = (raju, anil, ravi, amar)
dv = (f.y., s.y., s.y., f.y.)
print(np.lexsort((dv, nm)))

[[1 3 3 7]
 [7 7 8 9]]
[[3 0 2 1]
 [1 3 2 0]]
4
3
(array([0, 0, 0, 0, 1, 1, 1, 1], dtype=int64), array([0, 1, 2, 3, 0, 1, 2, 3], dtype=int64))
(array([0, 1, 1, 1, 1], dtype=int64), array([1, 0, 1, 2, 3], dtype=int64))
[3 1 0 2]

十一.NumPy IO文件操作

ndarray可以将对象保存到磁盘文件或从磁盘文件加载对象。可用 IO 功能有：

– numpy.save() 该文件将输入数组存储在一个包含npy磁盘文件中的扩展名。磁盘文件中的扩展名。磁盘文件中的扩展名。磁盘文件中的扩展名。
– numpy.load() 从npy在文件中重建阵列。在文件中重建阵列。在文件中重建阵列。
– numpy.savetxt()和numpy.loadtxt() 函数以简单的文本文件格式存储和检索数组数据。

import numpy as np
a = np.array([1,2,3,4,5])
np.save(outfile,a)
b = np.load(outfile.npy)
print(b)
a = np.array([1,2,3,4,5])
np.savetxt(out.txt,a)
b = np.loadtxt(out.txt)
print(b)

[1 2 3 4 5]
[ 1.  2.  3.  4.  5.]

推荐阅读:
入门: 最完整的零基学习最全面的零基学习最完整的零基学习Python的问题  | 从零开始学习从零基础学习从零基础学习8个月的Python  | 实战项目 |学Python这是捷径，这是捷径，这是捷径
干货:爬行豆瓣短评，电影《后来的我们》 | 38年NBA最佳球员分析最佳球员分析 |   从万众期待到口碑惨败！唐探3令人失望  | 笑新伊田图龙记笑新伊田图龙记笑新伊田图龙记 | 谜语之王回答灯谜之王灯谜之王谜语之王 ｜用Python人山人海素描图人山人海素描图人山人海 Dishonor太火了，我用机器学习做了一个迷你推荐系统电影
趣味:弹球游戏  | 九宫格  | 漂亮的花 | 两百行Python日常酷跑游戏日常酷跑游戏日常酷跑游戏!
AI: 会写诗的机器人会写诗的机器人会写诗的机器人 | 给图片上色给图片上色给图片上色 | 预测收入 | 《耻辱》太火了，我用机器学习做了一部迷你推荐系统电影
小工具: Pdf转Word易于修复表单和水印！易于处理的表单和水印！易于修复表单和水印！简单的表格和水印！ | 一键把html将页面另存为网页另存为网页另存为pdf！|  再见PDF提款费！提款费！提款费！提款费用！ | 用90构建最强大的代码行构建最强大的代码行构建最强大的代码行PDF转换器，word、PPT、excel、markdown、html一键转换 | 制作一个固定的低成本机票提醒！制作一张别针的低价机票提醒！ ｜60代码行做了一个语音墙纸切换，天天见女士！

年度弹出文案年度弹出文案年度爆炸性文案

1). 卧槽！Pdf转Word用Python轻松搞定！
2).学Python闻起来好香！我用100一行代码做了一个网站，帮助人们做了一行代码，做了一个网站，帮助了人们做了一行代码，帮助了人们PS旅行图片赚鸡腿吃旅行图片赚鸡腿
3).第一次播放量过亿，火爆全网，我分析了《顺风车妹妹》，发现了这些秘密
4). 80一行行代码！使用Python让救济金做正确的事做做的人做好事的人A梦分身
5).你必须掌握的东西你必须掌握20个python代码，简短而紧凑，永无止境的有用代码，简短而甜蜜，永无止境的有用的代码，简短而紧凑，永无止境的使用代码，简短而甜蜜，永无止境的用途
6). 30个Python古怪技能集古怪小贴士收藏古怪技能集
7). 我总结的80《菜鸟学习专页》《菜鸟学习专页》《菜鸟学习》Python精选干货.pdf》,都是干货
8). 再见Python！我要学Go了！2500词深度分析词深度分析词深度分析！
9).发现了一只舔狗的福利！这Python爬虫神器太酷了，不能自动下载女孩的照片