numpy 数组和矩阵的创建

一、创建数组

创建数组的方式有很多种，比如使用array方法，并提供标准的Python列表或者元组作为参数。此时，数组的类型将根据序列中元素的类型推导出来。

>>> import numpy as np
>>> a = np.array([2,3,4])
>>> a
array([2, 3, 4])
>>> a.dtype
dtype('int32')
>>> b = np.array([1.2, 3.5, 5.1])
>>> b.dtype
dtype('float64')

常见的错误是直接将多个数值作为参数传递，正确的做法是将他们以列表或元组的方式传递，如下：

>>> a = np.array(1,2,3,4)    # 错误
>>> a = np.array([1,2,3,4])  # 正确

array函数会自动将二维或三维序列转换为对应的二维或三维数组。

>>> b = np.array([(1.5,2,3), (4,5,6)])
>>> b
array([[ 1.5,  2. ,  3. ],
       [ 4. ,  5. ,  6. ]])

在创建的时候，可以显式地指定数据的类型：

>>> c = np.array( [ [1,2], [3,4] ], dtype=complex )
>>> c
array([[ 1.+0.j,  2.+0.j],
       [ 3.+0.j,  4.+0.j]])

不只是数字类型，字符串也可以，只是我们不常用而已：

>>> s = 'hellow world'
>>> np.array(s)
array('hellow world', dtype='<U12')

很多时候，数组的元素最初都是未知的，但其大小形状是已知的。因此，numpy提供了几个函数来创建带有初始占位符内容的数组。

函数zero创建一个都是0的数组，函数one创建一个都是1的数组，函数empty创建一个初始内容是0或者垃圾值的数组，这取决于内存当时的状态。默认情况下，创建的数组的数据类型为float64。

>>> np.zeros((5,), dtype = np.float)
array([0., 0., 0., 0., 0.])
>>> np.zeros( (3,4) )
array([[ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.]])
>>> np.ones( (2,3,4), dtype=np.int16 )                # 同样可以指定类型
array([[[ 1, 1, 1, 1],
        [ 1, 1, 1, 1],
        [ 1, 1, 1, 1]],
       [[ 1, 1, 1, 1],
        [ 1, 1, 1, 1],
        [ 1, 1, 1, 1]]], dtype=int16)
>>> np.empty( (2,3) )   # 根据当前内存状态的不同，可能会返回未初始化的垃圾数值，不安全。
array([[0., 0., 0.],
       [0., 0., 0.]])

>>> np.full((3,4), 2.22) # 创建一个全部由2.22组成的数组
array([[2.22, 2.22, 2.22, 2.22],
       [2.22, 2.22, 2.22, 2.22],
       [2.22, 2.22, 2.22, 2.22]])

它们的原型分别为：

numpy.empty(shape, dtype = float, order = 'C')

　　1.shape：数据形状

　　2.dtype：数据类型，可选

　　3.order：有'C'和'F'两个选项，行优先和列优先，在计算机内存中的存储元素的顺序。

numpy.zeros(shape, dtype = float, order = 'C')

　　1.shape：数据形状

　　2.dtype：数据类型，可选

　　3.order：‘C’用于C的行数组，或者‘F’用于FORTRAN的列数组

numpy.ones(shape, dtype = None, order = 'C')

参数同上。

numpy.full(shape, fill_value, dtype=None, order='C')

　　1.shape：数据形状

　　2.fill_value：填充值，可以为数字或数字列表

　　3.dtype：数据类型，可选

　　4.order：‘C’用于C的行数组，或者‘F’用于FORTRAN的列数组

numpy还提供了一个返回array序列的函数，而不是返回一个Python的列表，这就是常用的arange函数：

>>> np.arange( 10, 30, 5 )
array([10, 15, 20, 25])
>>> np.arange( 0, 2, 0.3 )                 # 可以接受浮点类型的参数，比如这里的步长
array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8])

其原型为：

numpy.arange(start, stop, step, dtype)

1. start：范围的起始值，默认为0
2. stop： 范围的终止值（不包含）
3. step： 两个值的间隔（步长），默认为1
4. dtype： 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

当arange函数使用浮点步长的时候，可能出现精度的问题。这种情况下，我们一般使用linspace函数，它的第三个参数指定在区间内均匀生成几个数，至于步长，系统会自动计算。其用于创建一个一维数组，数组是一个等差数列构成的。

>>> from numpy import pi  # 导入圆周率
>>> np.linspace( 0, 2, 9 )                 # 从0到2之间的9个数
array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ,  1.25,  1.5 ,  1.75,  2.  ])
>>> x = np.linspace( 0, 2*pi, 100 )        # 从0到2Π之间，生成100个数
>>> f = np.sin(x)

其原型为：

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

1. start： 序列的起始值
2. stop： 序列的终止值，如果endpoint为True，则终止值包含于序列中
3. num： 要生成的等步长的样本数量，默认为50
4. endpoint： 序列中是否包含stop值，默认为Ture
5. retstep： 如果为True，生成的数组中会显示间距
6. dtype： 输出ndarray的数据类型

numpy也提供了创建等比数列的方法，logspace函数可以为我们创建一个等比数列。

>>> np.logspace(1, 3, 3, base=2)
array([2., 4., 8.])

其原型为：

numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

　　1.start：序列的起始值为：base**start

　　2.stop：序列的终止值为：base**stop，若endpoint为true，该值包含于数列中

　　3.num：要生成的等步长的样本数量，默认为50

　　4.endpoint：该值为true时，数列中包含stop值

　　5.base：对数log的底数

　　6.dtype：ndarray的数据类型

numpy也提供了一些用于创建随机数租的方法。

像random方法用于创建一个在[0,1)上随机分布的随机数组。

>>> np.random.random((2, 3))
array([[0.51586941, 0.3119743 , 0.77768478],
       [0.11534794, 0.17889212, 0.0952282 ]])

其原型为：

numpy.random.random(size=None)

　　size:数组的元素个数，若输入的为数，则返回的是一个长度为size的一维数组，若输入的为元组，则返回一个多维数组。默认为None，返回一个随机数

rand方法用于创建一个在[0,1)上均匀分布的随机数组。

>>> np.random.rand(2, 3)
array([[0.22917926, 0.67442768, 0.29765104],
       [0.32516362, 0.54908428, 0.70914768]])

其原型为：

numpy.random.rand(*dn)

　　*dn：数组的元素个数，若不输入，则返回一个随机数，若输入的为一个数字，则返回值为一维数组，若输入多个数，则返回值为多维数组。

更多类似的函数有：asarray，diag,eye，frombuffer，fromiter，geomspace,random.randn,random.randint,rangdom.uniform等。

二、矩阵的创建

numpy不光可以创建ndarray类型的数组，还可以创建矩阵。

在numpy中有多种方式可以创建矩阵，例如mat方法。

>>> m1=np.mat('1,2,3;4,5,6;7,8,9')#mat方法支持将特殊字符串转化为矩阵
>>> m1
matrix([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]])
>>> type(m1)
<class 'numpy.matrix'>
>>> m2 = np.mat([[1, 2, 3], [4, 5, 6]])#也可以将嵌套列表转化为矩阵
>>> m2
matrix([[1, 2, 3],
        [4, 5, 6]])
>>> m3 = np.mat(np.array([[1, 2], [3, 4]]))#也可以将二维数组转化为矩阵
>>> m3
matrix([[1, 2],
        [3, 4]])
>>> m3.ndim#矩阵只能是二维的
2

其原型为：

numpy.mat(data,dtype)

　　1.data：元素的数据

　　2.dtype：元素的数据类型

也可以用asmatrix方法，asmatrix方法的使用与mat方法的使用是一样的。在numpy的底层中asmatrix=mat。