• 5星
3.65MB Dream_Gao1989 2020-12-10 19:49:57
• 5星
26KB weixin_43959833 2021-06-25 16:02:32
• 5星
50.68MB xipengbozai 2021-05-25 21:11:57
• 1,Indexing and slicing numpy arrays https://www.pythoninformer.com/python-libraries/numpy/numpy-and-images/ In this section we will look at indexing and slicing. These work in a similar way to ...
1,Indexing and slicing numpy arrays
https://www.pythoninformer.com/python-libraries/numpy/numpy-and-images/
In this section we will look at indexing and slicing. These work in a similar way to indexing and slicing with standard Python lists, with a few differences
Indexing an array
Indexing is used to obtain individual elements from an array, but it can also be used to obtain entire rows, columns or planes from multi-dimensional arrays.
Indexing in 1 dimension
We can create 1 dimensional numpy array from a list like this:
import numpy as np

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

print(a1)  # [1, 2, 3, 4]

We can index into this array to get an individual element, exactly the same as a normal list or tuple:
print(a1[0]) # 1
print(a1[2]) # 3

Indexing in 2 dimensions
We can create a 2 dimensional numpy array from a python list of lists, like this:
import numpy as np

a2 = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])

Here is a diagram of the array:

We can index an element of the array using two indices - i selects the row, and j selects the column:
print(a2[2, 1]) # 8

Notice the syntax - the i and j values are both inside the square brackets, separated by a comma (the index is actually a tuple (2, 1), but tuple packing is used). The example picks row 2, column 1, which has the value 8. This compares with the syntax you might use with a 2D list (ie a list of lists):
v = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]

print(v[2][1]) # 8

Picking a row or column
If we can supply a single index, it will pick a row (i value) and return that as a rank 1 array:
print(a2[2]) # [7, 8, 9]

That is quite similar to the what would happen with a 2D list. However, numpy allows us to select a single columm as well:
print(a2[:, 1]) # [2, 5, 8]

We are skipping ahead slightly to slicing, later in this tutorial, but what this syntax means is:
for the i value, take all values (: is a full slice, from start to end)for the j value take 1
Giving this array [2, 5, 8]:

The array you get back when you index or slice a numpy array is a view of the original array. It is the same data, just accessed in a different order. If you change the view, you will change the corresponding elements in the original array.

Indexing in 3 dimensions
We can create a 3 dimensional numpy array from a python list of lists of lists, like this:
import numpy as np

a3 = np.array([[[10, 11, 12], [13, 14, 15], [16, 17, 18]],
[[20, 21, 22], [23, 24, 25], [26, 27, 28]],
[[30, 31, 32], [33, 34, 35], [36, 37, 38]]])

Here is a diagram of the array:

A 3D array is like a stack of matrices:
The first index, i, selects the matrixThe second index, j, selects the rowThe third index, k, selects the column
Here is the same diagram, spread out a bit so we can see the values:

Here is how to index a particular value in a 3D array:
print(a3[2, 0, 1]) # 31

This selects matrix index 2 (the final matrix), row 0, column 1, giving a value 31.
Picking a row or column in a 3D array
You can access any row or column in a 3D array. There are 3 cases.
Case 1 - specifying the first two indices. In this case, you are choosing the i value (the matrix), and the j value (the row). This will select a specific row. In this example we are selecting row 2 from matrix 1:
print(a3[1, 2]) # [26 27 28]

Case 2 - specifying the i value (the matrix), and the k value (the column), using a full slice (:) for the j value (the row). This will select a specific column. In this example we are selecting column 1 from matrix 0:
print(a3[0, :, 1]) # [11 14 17]

Case 3 - specifying the j value (the row), and the k value (the column), using a full slice (:) for the i value (the matrix). This will create a row by taking the same element from each matrix. In this case we are taking row 1, column 2 from each matrix:
print(a3[:, 1, 2]) # [15, 25, 35]

Picking a matrix in a 3D array
If we only specify the i index, numpy will return the corresponding matrix. We will call this case 1. In this example we will request matrix 2:
print(a3[2]) # [[30 31 32]
#  [33 34 35]
#  [36 37 38]]

Case 2 if we specify just the j value (using a full slice for the i values), we will obtain a matrix made from the selected row taken from each plane. In this example we will take row 1:
print(a3[:, 1]) # [[13 14 15]
#  [23 24 25]
#  [33 34 35]]

Case 3 if we specify just the k value (using full slices for the i and j values), we will obtain a matrix made from the selected column taken from each plane. In this example we will take column 0:   注:取到的元素以行的形式排列
print(a3[:, :, 0]) # [[10 13 16]
#  [20 23 26]
#  [30 33 36]]

Slicing an array
You can slice a numpy array is a similar way to slicing a list - except you can do it in more than one dimension.

As with indexing, the array you get back when you index or slice a numpy array is a view of the original array. It is the same data, just accessed in a different order. This is different to lists, where a slice returns a completely new list.

Slicing lists - a recap
Just a quick recap on how slicing works with normal Python lists. Suppose we have a list:
a = [10, 11, 12, 13, 14]

We can use slicing to take a sub-list, like this:
b = a[1:4]    # [11, 12, 13]

The slice notation specifies a start and end value [start:end] and copies the list from start up to but not including end.
We can omit the start, in which case the slice start at the beginning of the list. We can omit the end, so the slice continues to the end of the list. If we omit both the slice created is a copy of the entire list:
c = a[:3]    # [10, 11, 12]
d = a[2:]    # [12, 13, 14]
e = a[:]     # [10, 11, 12, 13, 14]

One final thing to note is the difference between an index and a slice of length 1:
f = a[2]    # 12
g = a[2:3]  # [12]

The index returns an element of the array, the slice returns a list of one element.
Slicing 1D numpy arrays
Slicing a 1D numpy array is almost exactly the same as slicing a list:
import numpy as np

a1 = np.array([1, 2, 3, 4, 5])
b = a1[1:4]

print(b)  # [2, 3, 4]

The only thing to remember if that (unlike a list) a1 and b are both looking at the same underlying data (b is a view of the data). So if you change an element in b, a1 will be affected (and vice versa):
b[1] = 10
print(b)  # [2, 10, 4]
print(a1) # [1, 2, 10, 4, 5]

Slicing a 2D array
You can slice a 2D array in both axes to obtain a rectangular subset of the original array. For example:
import numpy as np

a2 = np.array([[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19],
[20, 21, 22, 23, 24],
[25, 26, 27, 28, 29]])

print(a2[1:,2:4])  # [[17 18]
#  [22 23]
#  [27 28]]

This selects rows 1: (1 to the end of bottom of the array) and columns 2:4 (columns 2 and 3), as shown here:

Slicing a 3D array
You can slice a 3D array in all 3 axes to obtain a cuboid subset of the original array:
import numpy as np

a3 = np.array([[[10, 11, 12], [13, 14, 15], [16, 17, 18]],
[[20, 21, 22], [23, 24, 25], [26, 27, 28]],
[[30, 31, 32], [33, 34, 35], [36, 37, 38]]])

print(a3[:2,1:,:2])  # [[ [13 14] [16 17] ]
#  [ [23 24] [26 27] ]]

This selects:
planes :2 (the first 2 planes)rows 1: (the last 2 rows)columns :2 (the first 2 columns)
As shown here:

Full slices
You can, of course, use full slices : to select all planes, columns or rows. However, for trailing indices, simply omitting the index counts as a full slice. So for 2D arrays:
a2[1:3,:] # is the same as
a2[1:3]

For 3D arrays:
a3[1:,:2,:] # is the same as
a3[1:,:2]

a3[1:,:,:] # is the same as
a3[1:,:]   # and is also the same as
a3[1:]

Slices vs indexing
As we saw earlier, you can use an index to select a particular plane column or row. Here we select row 1, columns 2:4:
import numpy as np

a2 = np.array([[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19],
[20, 21, 22, 23, 24],
[25, 26, 27, 28, 29]])

print(a2[1,2:4])  # [17 18]

You can also use a slice of length 1 to do something similar (slice 1:2 instead of index 1):
print(a2[1:2,2:4])  # [[17 18]]

Notice the subtle difference. The first creates a 1D array, the second creates a 2D array with only one row.
Visit the PythonInformer Discussion Forum for numeric Python.

2,From Python Nested Lists to Multidimensional numpy Arrays
https://cognitiveclass.ai/blog/nested-lists-multidimensional-numpy-arrays
3,A Visual Intro to NumPy and Data Representation
http://jalammar.github.io/visual-numpy/
展开全文
hello_program_world 2020-12-26 20:54:33
• 常见切片类型： x[n,:]、x[:,n]、x[m:n,:]、...1、首先区分数组类型：在中括号中将m:n看做整体的前提之下，二维数组（中括号中有一个冒号），三维数组（中括号中有两个冒号） 2、需要注意到情况如：通常情况每个维...

常见切片类型：
x[n,:]、x[:,n]、x[m:n,:]、x[:,m:n]x[n,::]、x[:,n:]、x[::,n]、x[:,:,n]、x[m:n,::]、x[:,m:n:]、x[::,m:n]、x[:,:,m:n]
1、首先区分数组类型：在中括号中将m:n看做整体的前提之下，二维数组（中括号中有一个冒号），三维数组（中括号中有两个冒号）
2、需要注意到情况如：通常情况每个维度的操作结束通过逗号分割（n，或m:m，），但如n:或者m:n:表示的是从n或者m:n开始到该维度的最后元素。
3、在进行切片过程中，可以根据逗号判断切片是如何选取元素的，例如三维数组中基本模式是[个数，行数，列数],所以加入b是一个shape=（3,3,4）的三维数组时

，b[1,::]代表了行列全取的情况下，第2个数组（重点是根据逗号索引第一个逗号代表个数，后面：：之前无逗号可以整体切片）

b[:,:, 1]代表了分开取个数、行、列（重点是个数和行之后都有逗号，则分开选取而不是整体切片），分开切片个数，行全选情况下选第二列元素

补充总结：在numpy的数组中，用逗号分隔的是轴的索引，引号表示该轴下的所有元素，比如说如下数组：
a = np.array([[[3,4]], [[1,2]],[[5,7]],[[3,7]],[[1,8]]])a.shape=(5, 1, 2) 表示是三个轴，a[;,0]表示第一个轴的所有元素，和第二个轴的第一个元素（注意：当给出的索引号少于数组中的总索引数，则将已给出的索引数按顺序指派到轴上并默认将未写的索引数提取全部内容），细说就是再详细一点，a的全体内容为：[[[3,4]], [[1,2]],[[5,7]],[[3,7]],[[1,8]]]。去掉第一层方括号，其中有五个元素，每个元素为[[3,4]]这样的，所以第一个索引的范围为[0:5]。
注意：OpenCV函数返回的多维数组和常见的numpy数组的不同之处！（后续跟进补充）

参考博客： https://blog.csdn.net/zgcr654321/article/details/88015849
https://blog.csdn.net/sunny2038/article/details/12889059 
展开全文
weixin_38698410 2019-05-22 10:45:41
• 38KB weixin_38628990 2020-09-18 09:07:50
• ## numpy二维以及三维数组切片 [i,:] [:,i,j] 等 python numpy

三维数组3. 补充：区分高维数组的维度 1. 注意： 因为是从计算机是从0开始，所以计算机中第二个元素就是俗语第3个。以下不做赘述 2. 二维数组 >>> import numpy as np >>> x = np.random.randint...


文章目录
1. 注意：2. 二维数组3. 三维数组3. 补充：区分高维数组的维度

1. 注意：
因为是从计算机是从0开始，所以计算机中第二个元素就是俗语第3个。以下不做赘述
2. 二维数组
>>> import numpy as np
>>> x = np.random.randint(1,9,(4,6))  #第一个维度即4,，指行。第二个维度即6，指列
>>> x
array([[5, 4, 6, 4, 3, 4],
[8, 5, 3, 2, 8, 3],
[1, 4, 4, 5, 8, 2],
[3, 6, 8, 5, 5, 2]])
>>> x[2,:]  #返回第一个维度的第2个元素（从0开始）。俗语：第3行
array([1, 4, 4, 5, 8, 2])

>>> x[:,2]  #返回第二个维度的第2个元素（从0开始）。俗语：第3列
array([6, 3, 4, 8])

>>> x[:,2:5] #返回第二个维度的第2（包括）——5（不包括）个元素。俗语：第3——6列（包括3，不包括6）
array([[6, 4, 3],
[3, 2, 8],
[4, 5, 8],
[8, 5, 5]])

>>> x[:,2:5:2]#返回第二个维度的第2（包括）——5（不包括）个元素，2为间隔距离，跟列表相似。俗语：第3——6列（包括3，不包括6），间隔为2
array([[6, 3],
[3, 8],
[4, 8],
[8, 5]])

>>> x[1:3,:] #返回第一个维度的第1（包括）——3（不包括）个元素。俗语：第2——4列（包括2，不包括4）
array([[8, 5, 3, 2, 8, 3],
[1, 4, 4, 5, 8, 2]])

>>> x[1:3:2,:]#返回第一个维度的第1（包括）——3（不包括）个元素，间隔距离为2，与列表相似。俗语：第2——4列（包括2，不包括4），间隔为2
array([[8, 5, 3, 2, 8, 3]])

3. 三维数组
>>> x = np.random.randint(1,9,(4,6,5)) #第一维度4，第二维度6，第三维度5
>>> x
array([[[6, 4, 3, 7, 5],
[4, 7, 6, 3, 5],
[4, 2, 3, 3, 7],
[5, 6, 5, 5, 5],
[8, 5, 7, 7, 3],
[7, 7, 1, 1, 7]],

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

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

[[6, 2, 6, 8, 8],
[1, 7, 3, 8, 3],
[3, 1, 1, 6, 3],
[2, 6, 1, 2, 6],
[1, 8, 3, 7, 1],
[1, 7, 8, 5, 2]]])
>>> x[2,3,3] #返回第一个维度的第2个元素，第二个维度的第3个元素，第三个维度的第3个元素
5            #俗语：第3个矩阵的第4行4列（以下就不写俗语了，自己心中加一即可）

>>> x[2:,3,3]#返回第一个维度的（第2至结束）个元素，第二个维度的第3个元素，第三个维度的第3个元素
array([5, 2])

>>> x[2,3,:]#返回第一个维度的第2个元素，第二个维度的第3个元素
array([1, 2, 6, 5, 7])

>>> x[2,:,3]#返回第一个维度的第2个元素，第三个维度的第3个元素
array([7, 7, 1, 5, 8, 1])

>>> x[:,3,3]#返回第二个维度的第3个元素，第三个维度的第3个元素
array([5, 8, 5, 2])

>>> x[:,:3,3]#返回第二个维度的第3个之前（不包括第三个）的元素，第三个维度的第3个元素
array([[7, 3, 3],
[4, 8, 5],
[7, 7, 1],
[8, 8, 6]])

>>> x[:,:3,:3]#返回第二个维度的第3个之前（不包括第三个）的元素，第三个维度的第3个之前（不包括第三个）元素
array([[[6, 4, 3],
[4, 7, 6],
[4, 2, 3]],

[[1, 2, 3],
[5, 8, 3],
[6, 1, 8]],

[[4, 7, 4],
[2, 6, 8],
[1, 2, 7]],

[[6, 2, 6],
[1, 7, 3],
[3, 1, 1]]])
>>>


3. 补充：区分高维数组的维度
这一部分这位大神写的比较好：https://theonegis.blog.csdn.net/article/details/89348130 尤其是下图：
维度是从整体到局部看的，最外围的[ ]是第一个维度，然后依次往里，最内部的[ ]就是最后一维。
展开全文
weixin_45562000 2020-03-15 18:58:38
• 文章全来自Python二维数组与三维数组切片详解 1.二维数组 import numpy as np a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16], [17, 18, 19, 20]]) print(a.shape) print(a[0, :...
文章全来自Python二维数组与三维数组切片详解

1.二维数组
import numpy as np

a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16], [17, 18, 19, 20]])
print(a.shape)
print(a[0, :], a[0, :].shape)
print(a[1, :], a[1, :].shape)
print(a[-1, :], a[-1, :].shape)
print(a[0:2, :], a[0:2, :].shape)
print(a[:, 0], a[:, 0].shape)
print(a[:, 1], a[:, 1].shape)
print(a[:, -1], a[:, -1].shape)
print(a[:, 0:2], a[:, 0:2].shape)
结果
(5, 4)
[1 2 3 4] (4,)
[5 6 7 8] (4,)
[17 18 19 20] (4,)
[[1 2 3 4]
[5 6 7 8]] (2, 4)
[ 1  5  9 13 17] (5,)
[ 2  6 10 14 18] (5,)
[ 4  8 12 16 20] (5,)
[[ 1  2]
[ 5  6]
[ 9 10]
[13 14]
[17 18]] (5, 2)

上例中，a是shape=(5,4)的数组。第0个维度上有5个元素，第1个维度上有4个元素(元素不一定是单个值， 也可能是数组，这里的元素的叫法是相对于某个维度而言的)。
a[0, :]、a[1, :]、a[-1, :]分别提取了a的第0个维度上的第0、1和-1个元素，每个元素都是一个含有4个元素的数组。 a[0:2, :]提取了a的第0个维度上的第0和1两个元素，两个元素都是一个含有4个元素的数组，共同组成一个二维数组。 a[:, 0]、a[:, 1]、a[:, -1]分别提取了a的第1个维度上的0、1和-1个元素，每个元素都是单个元素值。 a[:, 0:2]提取了a的第1个维度上的第0和1两个元素，两个元素都是单个元素值，共同组成一个二维数组。
2.三维数组
import numpy as np

b = np.array([[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],
[[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]],
[[25, 26, 27, 28], [29, 30, 31, 32], [33, 34, 35, 36]],
])

print(b.shape)
print("b[0, ::],b[1, ::],b[-1, ::],b[0:2, ::]")
print(b[0, ::], b[0, ::].shape)
print(b[1, ::], b[1, ::].shape)
print(b[-1, ::], b[-1, ::].shape)
print(b[0:2, ::], b[0:2, ::].shape)
print("b[:, 0:],b[:, 1:],b[:, -1:],b[:, 0:2:]")
print(b[:, 0:], b[:, 0:].shape)
print(b[:, 1:], b[:, 1:].shape)
print(b[:, -1:], b[:, -1:].shape)
print(b[:, 0:2:], b[:, 0:2:].shape)
print("b[::, 0],b[::, 1],b[::, -1],b[::, 0:2:]")
print(b[::, 0], b[::, 0].shape)
print(b[::, 1], b[::, 1].shape)
print(b[::, -1], b[::, -1].shape)
print(b[::, 0:2:], b[::, 0:2].shape)
print("b[:,:, 0],b[:,:, 1],b[:,:, -1],b[:,:, 0:2:]")
print(b[:, :, 0], b[:, :, 0].shape)
print(b[:, :, 1], b[:, :, 1].shape)
print(b[:, :, -1], b[:, :, -1].shape)
print(b[:, :, 0:2:], b[:, :, 0:2].shape)
结果
(3, 3, 4)
b[0, ::],b[1, ::],b[-1, ::],b[0:2, ::]
[[ 1  2  3  4]
[ 5  6  7  8]
[ 9 10 11 12]] (3, 4)
[[13 14 15 16]
[17 18 19 20]
[21 22 23 24]] (3, 4)
[[25 26 27 28]
[29 30 31 32]
[33 34 35 36]] (3, 4)
[[[ 1  2  3  4]
[ 5  6  7  8]
[ 9 10 11 12]]

[[13 14 15 16]
[17 18 19 20]
[21 22 23 24]]] (2, 3, 4)
b[:, 0:],b[:, 1:],b[:, -1:],b[:, 0:2:]
[[[ 1  2  3  4]
[ 5  6  7  8]
[ 9 10 11 12]]

[[13 14 15 16]
[17 18 19 20]
[21 22 23 24]]

[[25 26 27 28]
[29 30 31 32]
[33 34 35 36]]] (3, 3, 4)
[[[ 5  6  7  8]
[ 9 10 11 12]]

[[17 18 19 20]
[21 22 23 24]]

[[29 30 31 32]
[33 34 35 36]]] (3, 2, 4)
[[[ 9 10 11 12]]

[[21 22 23 24]]

[[33 34 35 36]]] (3, 1, 4)
[[[ 1  2  3  4]
[ 5  6  7  8]]

[[13 14 15 16]
[17 18 19 20]]

[[25 26 27 28]
[29 30 31 32]]] (3, 2, 4)
b[::, 0],b[::, 1],b[::, -1],b[::, 0:2:]
[[ 1  2  3  4]
[13 14 15 16]
[25 26 27 28]] (3, 4)
[[ 5  6  7  8]
[17 18 19 20]
[29 30 31 32]] (3, 4)
[[ 9 10 11 12]
[21 22 23 24]
[33 34 35 36]] (3, 4)
[[[ 1  2  3  4]
[ 5  6  7  8]]

[[13 14 15 16]
[17 18 19 20]]

[[25 26 27 28]
[29 30 31 32]]] (3, 2, 4)
b[:,:, 0],b[:,:, 1],b[:,:, -1],b[:,:, 0:2:]
[[ 1  5  9]
[13 17 21]
[25 29 33]] (3, 3)
[[ 2  6 10]
[14 18 22]
[26 30 34]] (3, 3)
[[ 4  8 12]
[16 20 24]
[28 32 36]] (3, 3)
[[[ 1  2]
[ 5  6]
[ 9 10]]

[[13 14]
[17 18]
[21 22]]

[[25 26]
[29 30]
[33 34]]] (3, 3, 2)
上例中，b是shape=(3,3,4)的数组。第0个维度上有3个元素，第1个维度上有3个元素，第2个维度上有4个元素(元素不一定是单个值， 也可能是数组，这里的元素的叫法是相对于某个维度而言的)。
b[0, ::]、b[1, ::]、b[-1, ::]分别提取了b的第0个维度上的第0、1和-1个元素，每个元素都是一个二维数组。 b[0:2, ::]提取了b的第0个维度上的第0和1两个元素，两个元素都是一个二维数组，共同组成一个三维数组。 b[:, 0:]、b[:, 1:]、b[:, -1:]分别提取了b的全部元素(都是由4个元素的单个数组)、b的第1个维度上除第0号外的所有元素(都是由4个元素的单个数组)、b的第1个维度上的所有最后一个位置上的元素(都是由4个元素的单个数组)。 b[:, 0:2:]提取了b的第1个维度上的第0和1两个元素，两个元素都是一个有4个元素的数组，共同组成一个三维数组。 b[::, 0]、b[::, 1]、b[::, -1]分别提取了b的第2个维度上的0、1和-1个元素（这里的元素就是单个有4个元素的数组），每个元素都是有4个元素的数组。 b[::, 0:2]提取了b的第2个维度上的第0和1两个元素（这里的元素就是单个有4个元素的数组），两个元素都是有4个元素的数组。 b[:,:, 0]、b[:,:, 1]、b[:,:, -1]分别提取了b的第2个维度的所有元素（即有4个元素的数组）中的第0、1和-1个元素值，每个元素都是单个元素值。 b[:,:, 0:2]提取了b的第2个维度的所有元素（即有4个元素的数组）中的第0和1两个元素值，两个元素都是单个元素值。
展开全文
Doraemon_Zzn 2020-02-15 11:59:30
• ## Python | Numpy三维数组维度变换/提取 python

qq_43580646 2021-12-13 20:31:08
• ## numpy三维数据切片 python

weixin_40529493 2021-10-01 11:22:25
• weixin_35368330 2021-02-03 08:07:28
• ## numpy的二维数组和三维数组合并 python numpy

u011304078 2021-06-23 14:15:27
• m0_46653437 2020-12-15 12:05:39
• ## Numpy 二维数组，按某行或者某列排序 python

A541925504 2021-10-04 13:25:26
• ## 关于Numpy多维数组切片的方法及注意事项 numpy 多维数组切片

weixin_40779727 2019-07-04 17:44:25
• ## python对三维数组切片 python numpy 数据分析

weixin_46035550 2021-09-17 09:43:35
• ## numpy的二维数组的切片索引 python

qq_28057379 2021-07-19 17:41:18
• zgcr654321 2019-02-28 10:53:06
• 30KB weixin_38741030 2020-12-25 00:28:35
• jcodery 2021-03-25 12:46:31
• sinat_39372048 2018-07-12 11:13:33
• weixin_39551996 2020-11-28 21:10:53
• ## Python中numpy数组切片 python numpy

qq_37887764 2020-07-23 16:10:01
• weixin_39611666 2020-12-08 12:50:14
• ## OpenCV 使用NumPy库中对二维数组进行切片式索引操作 numpy python

qq_53703628 2021-07-19 19:50:32
• Corollary 2020-04-08 00:51:00
• ## numpy函数：多维数组切片存取 numpy python

Heloiselt 2018-04-23 13:54:04
• weixin_29368571 2021-02-10 05:40:12
• weixin_45798949 2020-06-02 16:03:00
• ## numpy数组索引，切片，重新赋值，矢量计算，广播 numpy

qq_44407005 2020-04-11 12:51:57
• ## numpy 创建n维数组_numpy速成课程构建强大的n维数组 python numpy java javascript

weixin_26716079 2020-10-09 04:25:02

...