Numpy.array()详解

1. Numpy.array()详解

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

1.1 函数形式

1. numpy.array(object, 
2.     dtype=None, 
3.     copy=True, 
4.     order='K', 
5.     subok=False, 
6.     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. import numpy as np
2.  
3. arr01 = np.array([1,2,3])
4. print(arr01) #[1 2 3]
5. print(type(arr01))  #<class 'numpy.ndarray'>
6. print(arr01.dtype)  #int32
7.  
8. #Upcasting
9. arr02 = np.array([1.,2.,3.])
10. print(arr02) #[1. 2. 3.]
11. print(arr02.dtype)  #float64
12.  
13. #More than one dimension:
14. arr03 = np.array([[1,2],[3,4]])
15. print(arr03)
16. """
17. [[1 2]
18.  [3 4]]
19. """

dtype参数使用示例

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

subok参数使用示例

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

前文对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'>。
 

2. Asarray和Array辨析

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

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

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

2.2 object对象是ndarray对象时

1. import numpy as np
2.  
3. data = np.ones((3,))
4. #print(type(data)) #<class 'numpy.ndarray'> 数组类型
5. arr_ar = np.array(data)
6. arr_as = np.asarray(data)
7.  
8. print(arr_ar) #[1. 1. 1.]
9. print(arr_as) #[1. 1. 1.]
10.  
11. """
12. 这边区别就出来了。修改原始序列后，
13. np.array()产生的数组不变，
14. 但是np.asarray()产生的数组发生了变化
15. """
16. data[1]=2
17. print(arr_ar) #[1. 1. 1.]
18. print(arr_as) #[1. 2. 1.]  !!!
19.  
20.  
21. """
22. 这边也有区别，修改array产生的数组，不影响原始序列
23. 修改asarray产生的数组，会影响原始序列
24. """
25. #此时data=[1. 2. 1.]
26. arr_ar[2]=3
27. print(data)  #[1. 2. 1.]
28. arr_as[2]=3
29. print(data)  #[1. 2. 3.]

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