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) #int32subok参数使用示例
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不会新建，而是与参数共享同一个内存。重点就是这个共享内存。
