numpy 库的使用

numpy 库的使用

文档地址

http://numpy.org/

默认规则:

import numpy as np

列表:

标准Python的列表(list)中,元素本质是对象。如:L = [1, 2, 3],需要3个指针和三个整数对象,对于数值运算比较浪费内存和CPU。
因此,Numpy提供了ndarray(N-dimensional array object)对象:存储单一数据类型的多维数组。

例:

  • 通过array函数传递list对象:

    L = [1, 2, 3, 4, 5, 6]
    a = np.array(L)
    print a
    print type(a)

  • 若传递的是多层嵌套的list,将创建多维数组:

    b = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
    print b
    
  • 数组大小可以通过其shape属性获得:

    print a.shape
    a.shape = 4, 3
    print b
    

注:从(3,4)改为(4,3)并不是对数组进行转置,而只是改变每个轴的大小,数组元素在内存中的位置并没有改变

  • 当某个轴为-1时,将根据数组元素的个数自动计算此轴的长度:

    b.shape = 2, -1
    print b
    print b.shape
    b.shape = 3, 4
    
  • 使用reshape方法,可以创建改变了尺寸的新数组,原数组的shape保持不变

    c = b.reshape(4, -1)
    print "b = \n", b
    print 'c = \n', c
    
  • 数组b和c共享内存,修改任意一个将影响另外一个:

    b[0][1] = 20
    print "b = \n", b
    print "c = \n", c
    
  • 数组的元素类型可以通过dtype属性获得:

    print a.dtype
    print b.dtype
    
  • 可以通过dtype参数在创建时指定元素类型:

    d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.float)
    f = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.complex)
    print d
    print f
    
  • 如果更改元素类型,可以使用astype安全的转换

    f = d.astype(np.int)
    print f
    
  • 但不要强制仅修改元素类型,如下面这句,将会以int来解释单精度float类型

    d.dtype = np.int
    print d
    

np.arange

np.arange 函数类似于python的range函数, 通过指定起始值、终止值和步长来创建数组生成矩阵,和Python的range类似,arange同样不包括终值;但arange可以生成浮点类型,而range只能是整数类型:

np.arange(起始值, 终止值, 步长)
  • 例:

    np.arange(0, 60, 10)

  • 改变形状:

    np.arange(0, 60, 10).reshape((-1, 1))
    
  • 相加(行列分别相加):

    a = np.arange(0, 60, 10).reshape((-1, 1)) + np.arange(6)
    

np.linspace

  • np.linspace 函数通过指定起始值、终止值和元素个数来创建数组,缺省包括终止值:

    b = np.linspace(1, 10, 10)
    print 'b = ', b
    
  • 可以通过endpoint关键字指定是否包括终值:

    c = np.linspace(1, 10, 10, endpoint=False)
    print 'c = ', c
    
  • 终止值默认为 50:

    np.linspace(0, 10)
    
    array([  0.        ,   0.20408163,   0.40816327,   0.6122449 ,
             0.81632653,   1.02040816,   1.2244898 ,   1.42857143,
             1.63265306,   1.83673469,   2.04081633,   2.24489796,
             2.44897959,   2.65306122,   2.85714286,   3.06122449,
             3.26530612,   3.46938776,   3.67346939,   3.87755102,
             4.08163265,   4.28571429,   4.48979592,   4.69387755,
             4.89795918,   5.10204082,   5.30612245,   5.51020408,
             5.71428571,   5.91836735,   6.12244898,   6.32653061,
             6.53061224,   6.73469388,   6.93877551,   7.14285714,
             7.34693878,   7.55102041,   7.75510204,   7.95918367,
             8.16326531,   8.36734694,   8.57142857,   8.7755102 ,
             8.97959184,   9.18367347,   9.3877551 ,   9.59183673,
             9.79591837,  10.        ])
    

np.logspace

和linspace类似,logspace可以创建等比数列

  • 下面函数创建起始值为101,终止值为102,有20个数的等比数列

    d = np.logspace(1, 2, 10, endpoint=True)
    print d
    
  • 下面创建起始值为20,终止值为210(包括),有10个数的等比数列

    f = np.logspace(0, 10, 11, endpoint=True, base=2)
    print f
    

np.frombuffer, np.fromstring, np.fromfile

使用 np.frombuffer, np.fromstring, np.fromfile 等函数可以从字节序列创建数组

s = 'abcd'
g = np.fromstring(s, dtype=np.int8)
print g

math 库的实现

  • sin cos log

    画一个正弦函数在区间 [-pi, pi] 的图像:

    x = np.arange(-np.pi, np.pi, 0.01)
    y = np.sin(x)
    

存取

数组元素的存取方法和Python的标准方法相同

  • 随机生成数组:

    a = np.arange(10)
    print a
    
  • 获取某个元素:

    print a[3]
    
  • 切片[3,6),左闭右开:

    print a[3:6]
    
  • 省略开始下标,表示从0开始:

    print a[:5]
    
  • 省略结束下标,表示到最后一个:

    print a[3:]
    
  • 下标为负表示从后向前数:

    print a[3:-2]
    
  • 步长为2:

    print a[1:9:2]
    
  • 步长为-1,即翻转

    print a[::-1]
    
  • 切片数据是原数组的一个视图,与原数组共享内容空间,可以直接修改元素值

    a[1:4] = 10, 20, 30
    print a
    
  • 因此,在实践中,切实注意原始数据是否被破坏,如:

    b = a[2:5]
    b[0] = 200
    print a
    

整数/布尔数组存取

根据整数数组存取:当使用整数序列对数组元素进行存取时,将使用整数序列中的每个元素作为下标,整数序列可以是列表(list)或者数组(ndarray)。使用整数序列作为下标获得的数组不和原始数组共享数据空间。

  • 生成数据

    a = np.logspace(0, 9, 10, base=2)
    print a
    i = np.arange(0, 10, 2)
    print i
    
  • 利用i取a中的元素

    b = a[i]
    print b
    
  • b的元素更改,a中元素不受影响

    b[2] = 1.6
    print b
    print a
    
  • 使用布尔数组i作为下标存取数组a中的元素:返回数组a中所有在数组b中对应下标为True的元素

    a = np.random.rand(10) #生成10个满足[0,1)中均匀分布的随机数
    print a
    print a > 0.5  #大于0.5的元素索引
    b = a[a > 0.5] #大于0.5的元素
    print b
    
  • 将原数组中大于0.5的元素截取成0.5

    a[a > 0.5] = 0.5
    print a
    print b #b不受影响
    

二维数组的切片

  • 生成数据

    a = np.arange(0, 60, 10)    # 行向量
    print 'a = ', a
    
    b = a.reshape((-1, 1))      # 转换成列向量
    print b
    
    c = np.arange(6)
    print c
    
    f = b + c   # 行 + 列
    print f
    
  • 合并上述代码:

    a = np.arange(0, 60, 10).reshape((-1, 1)) + np.arange(6)
    print a
    
    [[ 0  1  2  3  4  5]
     [10 11 12 13 14 15]
     [20 21 22 23 24 25]
     [30 31 32 33 34 35]
     [40 41 42 43 44 45]
     [50 51 52 53 54 55]]
    
  • 二维数组的切片

    print a[(0,1,2,3), (2,3,4,5)]
    
    [ 2 13 24 35]
    
    print a[3:, [0, 2, 5]]
    
    [[30 32 35]
     [40 42 45]
     [50 52 55]]
    
    i = np.array([True, False, True, False, False, True])
    print a[i]
    
    [[ 0  1  2  3  4  5]
     [20 21 22 23 24 25]
     [50 51 52 53 54 55]]
    
    print a[i, 3]
    
    [ 3 23 53]
    

科学计算