个人中心
gpt4 book ai didi

聊聊Numpy.array中[:]和[::]的区别在哪

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 25 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章聊聊Numpy.array中[:]和[::]的区别在哪由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

[:]和[::]的区别蛮大的，用的好可以节省时间，下面以实例进行分析 。

array([:])

?
1
2
3
4
5
6
7
8
9
10
11
12
13
>>> import numpy as np
>>>
>>> x = np.array([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 , 12 ])
>>> print (x[ 1 : 5 ]) #打印index为1~5的数组，范围是左闭右开
[ 2 3 4 5 ]
>>> print (x[ 3 :]) #打印index=3之后的数组，包含index=3
[ 4  5  6  7  8  9 10 11 12 ]
>>> print (x[: 9 ]) #打印index=9之前的数组，不包含index=9
[ 1 2 3 4 5 6 7 8 9 ]
>>> print (x[ 1 : - 2 ]) #打印index=1到倒数第2个index之间的数组
[ 2  3  4  5  6  7  8  9 10 ]
>>> print (x[ - 9 : - 2 ]) #打印倒数第9个index和倒数第2个index之间的数组，左开右闭
[ 4  5  6  7  8  9 10 ]

array([::])

?
1
2
3
4
5
6
7
8
9
10
11
12
>>> print (x[ 1 :: 3 ]) #以index=1为起始位置，间隔3
[ 2  5  8 11 ]
>>> print (x[:: 3 ]) #默认从index=0开始，间隔3
[ 1  4  7 10 ]
>>> print (x[ 3 ::]) #和[3:]一样
[ 4  5  6  7  8  9 10 11 12 ]
>>> print (x[:: - 1 ]) #反向打印数据，从最后一个index开始，间隔为1
[ 12 11 10  9  8  7  6  5  4  3  2  1 ]
>>> print (x[:: - 3 ]) #反向打印数据，从最后一个index开始，间隔为3
[ 12  9  6  3 ]
>>> print (x[ 7 : 2 : - 1 ]) #反向打印index=2(不包含)到index=7之间的数据
[ 8 7 6 5 4 ]

也是碰到这方面的问题，没搞明白，干脆试了试就清楚了，应该[:]和[::]还有很多有趣的地方.

补充：Numpy.array()详解 、np.array与np.asarray辨析、 np.array和np.ndarry的区别 。

记录一下numpy.array()的详细用法，以及与np.asarray()和np.ndarray()的区别.

1. Numpy.array()详解

该函数的作用一言蔽之就是用来产生数组.

1.1 函数形式

?
1
2
3
4
5
6
numpy.array( object ,
     dtype = None ,
     copy = True ,
     order = 'K' ,
     subok = False ,
     ndmin = 0 )

1.2 参数详解

object：必选参数，类型为array_like，可以有四种类型：数组，公开数组接口的任何对象，__array__方法返回数组的对象，或任何（嵌套）序列。np.array()的作用就是按照一定要求将object转换为数组.

dtype：可选参数，用来表示数组元素的类型。如果没有给出，那么类型将被确定为保持序列中的对象所需的最小类型。注： This argument can only be used to ‘upcast' the array. For downcasting, use the .astype(t) method. 。

copy：可选参数，类型为bool值。如果为true（默认值），则复制对象。否则的话只有在以下三种情况下才会返回副本：（1）.if __array__ returns a copy；（2）. if obj is a nested sequence；（3）. if a copy is needed to satisfy any of the other requirements (dtype, order, etc.) 。

order：{‘K', ‘A', ‘C', ‘F'}，optional 。指定阵列的内存布局。该参数我至今还没有遇到过具体用法，这句话的意思就是我不会，故在此省略.

subok：可选参数，类型为bool值。如果为True，则子类将被传递，否则返回的数组将被强制为基类数组（默认）。或者说，True：使用object的内部数据类型，False：使用object数组的数据类型.

ndmin：可选参数，类型为int型。指定结果数组应具有的最小维数.

返回对象 。

out：输出ndarray，满足指定要求的数组对象.

1.3 具体用法

简单示例 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import numpy as np
 
arr01 = np.array([ 1 , 2 , 3 ])
print (arr01) #[1 2 3]
print ( type (arr01))  #<class 'numpy.ndarray'>
print (arr01.dtype)  #int32
 
#Upcasting
arr02 = np.array([ 1. , 2. , 3. ])
print (arr02) #[1. 2. 3.]
print (arr02.dtype)  #float64
 
#More than one dimension:
arr03 = np.array([[ 1 , 2 ],[ 3 , 4 ]])
print (arr03)
"""
[[1 2]
  [3 4]]
"""

dtype参数使用示例 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np
 
#指定数组元素类型为复数类型
DYX = np.array([ 1 , 2 , 3 ],dtype = complex )
print (DYX) #[1.+0.j 2.+0.j 3.+0.j]
print (DYX.dtype)  #complex128
 
#由多个元素组成的数据类型：
HXH = np.array([( 1 , 2 ),( 3 , 4 )],dtype = [( 'a' , '<i4' ),( 'b' , '<i8' )])
print (HXH)  #[(1, 2) (3, 4)]
#下面的输出有点神奇，我也只能记住规律了。
print (HXH[ "a" ]) #[1 3]
print (HXH[ "b" ])  #[2 4]
print (HXH.dtype)  #[('a', '<i4'), ('b', '<i8')]
print (HXH[ "a" ].dtype) #int32
print (HXH[ "b" ].dtype) #int64
 
TSL = np.array([( 1 , 2 , 3 ),( 4 , 5 , 6 )],dtype = [( "a" , "i" ),( "b" , "i" ),( "c" , "i" )])
print (TSL[ "a" ]) #[1 4]
print (TSL[ "a" ].dtype)  #int32

上述代码中，numpy的数据类型，可以百度下 。

subok参数使用示例 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np
 
DYX = np.array(np.mat( '1 2; 3 4' ))
#没有显示的写出subok的值，但是默认为False
print (DYX)
#数组类型
print ( type (DYX))  #<class 'numpy.ndarray'>
"""
[[1 2]
  [3 4]]
"""
 
HXH = np.array(np.mat( '1 2; 3 4' ), subok = True )
print (HXH)
#矩阵类型
print ( type (HXH))  #<class 'numpy.matrixlib.defmatrix.matrix'>
"""
[[1 2]
  [3 4]]
"""

前文对subok的描述是这样的：“如果为True，则子类将被传递，否则返回的数组将被强制为基类数组（默认）”.

在上文的代码中“np.mat('1 2; 3 4')”，就是子类，是矩阵类型。DYX = np.array(np.mat('1 2; 3 4'))中subok为False，返回的数组类型被强制为基类数组，所以DYX的类型是<class 'numpy.ndarray'>，是数组；HXH = np.array(np.mat('1 2; 3 4'), subok=True)中subok为True，子类被传递，所以HXH的类型是矩阵<class 'numpy.matrixlib.defmatrix.matrix'>.

这就是区别所在.

ndmin参数使用示例 。

?
1
2
3
4
5
6
7
8
9
10
import numpy as np
 
DYX = np.array([ 1 , 2 , 3 ],ndmin = 0 )
print (DYX,DYX.shape) #[1 2 3] (3,)
 
HXH = np.array([ 1 , 2 , 3 ],ndmin = 1 )
print (HXH,HXH.shape) #[1 2 3] (3,)
 
TSL = np.array([ 1 , 2 , 3 ],ndmin = 2 )
print (TSL,TSL.shape) #[[1 2 3]] (1, 3)

其他两个参数copy和order，我至今还没有遇到过，所以暂且不表。谁有介绍这两个参数用法的博客吗?

2. Asarray和Array辨析

Numpy.asaray的用法不再赘述，主要介绍一下二者的区别.

2.1 object对象是普通迭代序列时

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import numpy as np
 
data = [ 1 , 1 , 1 ]
print ( type (data)) #<class 'list'> 列表类型
arr_ar = np.array(data)
arr_as = np.asarray(data)
 
#输出上没有区别
print (arr_ar) #[1 1 1]
print (arr_as) #[1 1 1]
 
data[ 1 ] = 2
#改变原序列对arr_ar和arr_as没影响
print (arr_ar) #[1 1 1]
print (arr_as) #[1 1 1]
 
#此时data是[1, 2, 1]
#改变arr_ar和arr_as对原序列没有影响
arr_ar[ 1 ] = 3
print (data) #[1, 2, 1]
arr_as[ 1 ] = 3
print (data)  #[1, 2, 1]

可见在参数对象是普通迭代序列时，asarray和array没有区别（在我的理解范围内）.

2.2 object对象是ndarray对象时

?
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
import numpy as np
data = np.ones(( 3 ,))
#print(type(data)) #<class 'numpy.ndarray'> 数组类型
arr_ar = np.array(data)
arr_as = np.asarray(data)
 
print (arr_ar) #[1. 1. 1.]
print (arr_as) #[1. 1. 1.]
 
"""
这边区别就出来了。修改原始序列后，
np.array()产生的数组不变，
但是np.asarray()产生的数组发生了变化
"""
data[ 1 ] = 2
print (arr_ar) #[1. 1. 1.]
print (arr_as) #[1. 2. 1.]  !!!
 
"""
这边也有区别，修改array产生的数组，不影响原始序列
修改asarray产生的数组，会影响原始序列
"""
#此时data=[1. 2. 1.]
arr_ar[ 2 ] = 3
print (data)  #[1. 2. 1.]
arr_as[ 2 ] = 3
print (data)  #[1. 2. 3.]

我们总结一下:

相同点：array和asarray都可以将数组转化为ndarray对象.

区别：当参数为一般数组时，两个函数结果相同；当参数本身就是ndarray类型时，array会新建一个ndarray对象，作为参数的副本，但是asarray不会新建，而是与参数共享同一个内存。重点就是这个共享内存.

3.Numpy.ndarray()

这是最近在一个项目里看到的用法，搜索了一下用法，只在stackoverflow看到了一个问题：“What is the difference between ndarray and array in numpy?”.

地址如下：https://stackoverflow.com/questions/15879315/what-is-the-difference-between-ndarray-and-array-in-numpy 。

numpy.array只是一个创建ndarray的便利函数；它本身不是一个类。他讲到也可以使用numpy.ndarray创建一个数组，但这不是推荐的方法。 numpy.ndarray() 是一个类，而numpy.array() 是一个创建ndarray的方法/函数.

在numpy docs中，如果你想从ndarray类创建一个数组，你可以用引用的2种方式来做：

（1）.using array(), zeros() or empty() methods: Arrays should be constructed using array, zeros or empty (refer to the See Also section below). The parameters given here refer to a low-level method (ndarray(…)) for instantiating an array.【1-使用array()， zeros()或empty()方法：数组应该使用array, zeros()或empty()构造。这里给出的参数引用用于实例化数组的低级方法(ndarray(…))。】 。

（2）.from ndarray class directly: There are two modes of creating an array using new: If buffer is None, then only shape, dtype, and order are used. If buffer is an object exposing the buffer interface, then all keywords are interpreted.【2-来自ndarray类：使用new创建数组有两种模式：如果buffer是None，则只使用shape，dtype和order。 如果buffer是公开buffer接口的对象，则解释所有关键字。】 。

所以说老老实实用numpy.array()吧.

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我.

原文链接：https://blog.csdn.net/zhuqiang9607/article/details/83903487 。

最后此篇关于聊聊Numpy.array中[:]和[::]的区别在哪的文章就讲到这里了,如果你想了解更多关于聊聊Numpy.array中[:]和[::]的区别在哪的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

25 4 0
文章推荐： NumPy-ndarray 的数据类型用法说明
文章推荐： Java中的字节流文件读取教程（二）
文章推荐： Java中的字节流文件读取教程（一）
文章推荐： Android+OpenCv4实现边缘检测及轮廓绘制出图像最大边缘
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com