[python]-数据科学库Numpy学习

一、Numpy简介：

Python中用列表(list)保存一组值，可以用来当作数组使用，不过由于列表的元素可以是任何对象，因此列表中所保存的是对象的指针。这样为了保存一个简单的[1,2,3]，需要有3个指针和三个整数对象。对于数值运算来说这种结构显然比较浪费内存和CPU计算时间。此外Python还提供了一个array模块，array对象和列表不同，它直接保存数值，和C语言的一维数组比较类似。但是由于它不支持多维，也没有各种运算函数，因此也不适合做数值运算。

NumPy提供了两种基本的对象：ndarray（N-dimensional array object）和 ufunc（universal function object）。ndarray(下文统一称之为数组)是存储单一数据类型的多维数组，而ufunc则是能够对数组进行处理的函数。

二、nadrray对象：

1、创建一个数组对象:

  • 函数生成：ones(),zeros(),eye(),diag()......
    • zeros:（4）,zeros(（5,2）)生成全0的数组
    • >>> import numpy as np
>>> np.zeros(5) //一维
array([ 0.,  0.,  0.,  0.,  0.])
>>> np.zeros((5,2))//二维
array([[ 0., 0.],
       [ 0., 0.],
       [ 0., 0.],
       [ 0., 0.],
       [ 0., 0.]])

      　>>> np.zeros((5,2,2))//三维
        array([[[ 0., 0.],
                [ 0., 0.]],

               [[ 0., 0.],
                [ 0., 0.]],

               [[ 0., 0.],
                [ 0., 0.]],

               [[ 0., 0.],
                [ 0., 0.]],

               [[ 0., 0.],
                [ 0., 0.]]])

    • ones():生成全1的数组
    • >>> import numpy as np
>>> np.ones(10) //一维
array([ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.])
>>> np.ones(10,dtype="int32")//一维
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])

        >>> np.ones((4,1)) //二维
        array([[ 1.],
               [ 1.],
               [ 1.],
               [ 1.]])

    • arange函数：类似于list的range函数，通过指定初始值，终值，和步长来生成一维数组。（不包括终值）
    • import numpy as np
      d = np.arange(0,10,1)
e =  np.arange(0,10,2)
print (d)
#----------------------------------
[0 1 2 3 4 5 6 7 8 9]
[0 2 4 6 8]
    • linspace函数：通过指定初始值，终值和 元素个数来创建一维数组。（默认包含终值，可用endpoint关键字指定包含终值）
    • f = np.linspace(0,10,11,endpoint=False)
print (f)
#----------------------------------------
[ 0.          0.90909091  1.81818182  2.72727273  3.63636364  4.54545455
  5.45454545  6.36363636  7.27272727  8.18181818  9.09090909]
    • logspace函数：类似linspace创建等比数列,下面的例子产生1(10^0)到100(10^2)、有20个元素的等比数列:
    • g = np.logspace(0,2,20)
print (g)
[   1.            1.27427499    1.62377674    2.06913808    2.6366509
    3.35981829    4.2813324     5.45559478    6.95192796    8.8586679
   11.28837892   14.38449888   18.32980711   23.35721469   29.76351442
   37.92690191   48.32930239   61.58482111   78.47599704  100.        ]
    • frombuffer,fromstring,fromfile等函数可以从字节序列创建数组。python自负产是字符序列，每个字符占一个字节，因此如果从字符串s创建一个8bit的整数数组的话得到的每个元书就是字符的ascii码值。
    • s= "abcdefgh"
sa = np.fromstring(s,dtype = np.int8)
print (sa)
#--------------------------------------
[ 97  98  99 100 101 102 103 104]
    • fromfuction函数：传入一个函数来创建数组
    • def fun(i,j):
    return (i+1)*(j+1)
fa = np.fromfunction(fun,(9,9)) #(9,9)表示数组的shape，传给fun的书是每个元素的定位，有81个位置，可以得到81个元素
print (fa)
#---------------------------------------------------
[[  1.   2.   3.   4.   5.   6.   7.   8.   9.]
 [  2.   4.   6.   8.  10.  12.  14.  16.  18.]
 [  3.   6.   9.  12.  15.  18.  21.  24.  27.]
 [  4.   8.  12.  16.  20.  24.  28.  32.  36.]
 [  5.  10.  15.  20.  25.  30.  35.  40.  45.]
 [  6.  12.  18.  24.  30.  36.  42.  48.  54.]
 [  7.  14.  21.  28.  35.  42.  49.  56.  63.]
 [  8.  16.  24.  32.  40.  48.  56.  64.  72.]
 [  9.  18.  27.  36.  45.  54.  63.  72.  81.]]
  • 序列传入： 
    • import numpy as np
a = np.array([1,2,3,4,5])
b = np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10]])
print (a)
print (b)
#-------------------------------------------
[1 2 3 4 5]
[[ 1  2  3  4]
 [ 4  5  6  7]
 [ 7  8  9 10]]

2、数组的属性：

    • ndim属性：数组的维数
    • >>> np.ones((3,2))
array([[ 1.,  1.],
       [ 1.,  1.],
       [ 1.,  1.]])
>>> np.ones((3,2)).ndim
2 #二维
    • size：数组元素的总个数，等于shape属性中元组元素的乘积。
    • >>> np.ones((3,2)).size
6 #6个元素
    • dtype属性：查看或指定数组类型
    • print(a.dtype) # 数组的元素类型 int32，32bit整型数据
print(b.dtype) # 数组的元素类型 int32
aa = np.array([2,3,4,5,6],dtype = np.float)
print (aa)
#----------------------------------------------
[ 2.  3.  4.  5.  6.]
    • shape属性：查看或改变数组的大小
    • print(a.shape) #数组的大小 （5）
print(b.shape) #数组的大小 shape （3，4）

#修改shape来修改数组轴的大小：
b.shape = (4,3)
print (b)
#--------------------------------------
[[ 1  2  3]
 [ 4  4  5]
 [ 6  7  7]
 [ 8  9 10]]
#如果某个轴的值为-1，则会根据数组的总数计算此轴的长度。如b一共12个元素，修改shape
b.shape = (2,-1) #那么就会得到一个2*6的数组
print (b)
#--------------------------------------
[[ 1  2  3  4  4  5]
 [ 6  7  7  8  9 10]]
b.shape = (6,-1) #那么就会得到一个6*2的数组
print (b)
#--------------------------------------
[[ 1  2]
 [ 3  4]
 [ 4  5]
 [ 6  7]
 [ 7  8]
 [ 9 10]]
    • reshape属性：修改一个数组的尺寸得到一个新数组，原数组不变，但是这两个数组共享内存，如果修改值的话这两个数组都会变。
    • c = a.reshape((5,1)) #此方法实验证明:只能是x*y=数组的总元素才可以，这里1*5只能换成5*1
print (c) #此时a的结构并没改变,a,c共享内存。
print (a)
#--------------------------------------
[[1]
 [2]
 [3]
 [4]
 [5]]
[1 2 3 4 5]
#修改a[1][2]的值
a[2] = 100
print (c) #此时a的结构并没改变,a,c共享内存。
print (a)
#--------------------------------------
[1 2 3 4 5]
[[  1]
 [  2]
 [100]
 [  4]
 [  5]]
[  1   2 100   4   5]

3、数组存取：

  • 切片法[[[----***逗号“，”分行，列。冒号“：”分范围***---]]]
  • >>> import numpy as np
>>> np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10]])
array([[ 1,  2,  3,  4],
       [ 4,  5,  6,  7],
       [ 7,  8,  9, 10]])
>>> b = np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10]])
>>> b[0]
array([1, 2, 3, 4])
>>> b[1]
array([4, 5, 6, 7])
>>> b[1,2]
6
>>> b[1,3]
7
>>> b[1,-1]
7
>>> b[-1]
array([ 7,  8,  9, 10])
>>> b[-1,2]
9
>>> b[-1,-2]
9
    >>> b[:-2] #0--负2列
array([[1, 2, 3, 4]])
>>> b[1:2]
array([[4, 5, 6, 7]])
>>> b[1:3]
array([[ 4,  5,  6,  7],
       [ 7,  8,  9, 10]])
    #*************矩阵的截取***********************

      >>> a=np.mat(np.random.randint(2,15,size=(3,3)))
      >>> a
      matrix([[ 4, 10, 14],
              [11, 3, 12],
              [ 4, 2, 12]])
      >>> a[1:,1:,]
      matrix([[ 3, 12],
              [ 2, 12]])

三、矩阵对象matrix：

numpy库提供了matrix类，使用matrix类创建的是矩阵对象，它们的加减乘除运算缺省采用矩阵方式计算。但是由于NumPy中同时存在ndarray和matrix对象，因此很容易将两者弄混。

  • 创建矩阵：matrix函数（也可以用简写mat） a = np.matrix([[1,2,3],[5,5,6],[7,9,9]]) 
  • #利用ones()创建一个2*4的全1矩阵
    >>> np.mat(np.ones((2,4))) 
matrix([[ 1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.]])
  • #用numpy的随机数rand产生一个2*2的随机数组并转化成矩阵
    >>> np.mat(np.random.rand(2,2)) 
matrix([[ 0.4340437 ,  0.98055453],
        [ 0.52937992,  0.81452857]])
    #产生一个2-8之间的整数数组大小是2*5，再转换成矩阵。
    >>> np.mat(np.random.randint(2,8,size=(2,5)))
matrix([[3, 6, 4, 4, 5],
        [3, 7, 7, 2, 3]])
    #eye()函数产生单位对角数组，转换成单位对角阵
>>> np.mat(np.eye(2,2,dtype=int))
matrix([[1, 0],
        [0, 1]])
>>> np.mat(np.eye(3,2,dtype=int))
matrix([[1, 0],
        [0, 1],
        [0, 0]])
>>> np.mat(np.eye(3,3,dtype=int))
matrix([[1, 0, 0],
        [0, 1, 0],
        [0, 0, 1]])
    #将一维数组转换成对角阵
>>> np.mat(np.diag([1,2,3]))
matrix([[1, 0, 0],
        [0, 2, 0],
        [0, 0, 3]])
>>>
  • 矩阵运算：乘积，求逆，幂运算，转置 
    >>> import numpy as np
>>> a = np.matrix([[1,2,3],[5,5,6],[7,9,9]])
>>> a
matrix([[1, 2, 3],
        [5, 5, 6],
        [7, 9, 9]])
>>> a**-1 #求逆 a.I也是a的逆
matrix([[-0.6       ,  0.6       , -0.2       ],
        [-0.2       , -0.8       ,  0.6       ],
        [ 0.66666667,  0.33333333, -0.33333333]])
>>> a*a**-1 #a乘a的逆，矩阵内积
matrix([[  1.00000000e+00,   1.66533454e-16,  -1.11022302e-16],
        [  0.00000000e+00,   1.00000000e+00,  -4.44089210e-16],
        [  4.44089210e-16,   5.55111512e-17,   1.00000000e+00]])
    >>> a.T #a的转置
matrix([[1, 5, 7],
        [2, 5, 9],
        [3, 6, 9]])
>>>
  • 矩阵函数：
    • dot():做矩阵乘法，一维数组做点积，二维数组做内积，不过乘积必须满足矩阵相乘的形式（M(x,y)*M2(y,z)）,两个矩阵的行列必须对应，都是一维的话必须是一个行向量，一个列向量，可以用m.reshape(-1,1)将行向量转为列向量，或者m.reshape(1,-1)将列向量转为行向量。
    • inner():
    • outer():
  • 矩阵中更高级的一些运算可以在NumPy的线性代数子库linalg中找到。例如inv函数计算逆矩阵，solve函数可以求解多元一次方程组。
  • >>> from numpy import linalg as ll
>>> ll.inv(a) #求逆
matrix([[-0.6       ,  0.6       , -0.2       ],
        [-0.2       , -0.8       ,  0.6       ],
        [ 0.66666667,  0.33333333, -0.33333333]])
>>> a
matrix([[1, 2, 3],
        [5, 5, 6],
        [7, 9, 9]])
 参考：http://blog.csdn.net/sunny2038/article/details/9002531
 参考：http://old.sebug.net/paper/books/scipydoc/numpy_intro.html#id8
posted @ 2017-06-14 23:40  NextNight  阅读(981)  评论(0)  编辑  收藏  举报