Python numpy基础知识

叁歲伎倆 2022-06-16 08:26 199阅读 0赞

1.基础知识  
NumPy的主要对象是多维数组。它是由相同元素（通常是数字）组成的，通过正整数元组（tuple）作为索引的表格。  
在数组中，纬度（dimensional）被称为轴（axis），轴的数量被称为级（rank），如下面这个数组，它有两个轴（axis），第一个纬度（dimension，或者称为轴axis）长度为2（既纵向），第二个纬度长度为三（既横向）。

[[ 1., 0., 0.],
    [ 0., 1., 2.]]
       
        
         1
         2
        
       
        
        
         
       
        
       
        
         1
         2

Numpy的数组类被称为ndarray，别名array。要注意numpy.array并不等同于[Python][]标准库中的array.array，标准库中的array只提供了一维数组还有很少的函数。  
1.1 数组的属性  
ndarray对象的主要属性有：  
ndarray.ndim 纬度或者轴的数量  
ndarray.shape 数组的每个纬度的尺寸  
ndarray.size 数组元素的总个数  
ndarray.dtype 数组元素的类型  
ndarray.itemsize 数组元素二进制的大小  
ndarray.data 数组元素容器（不常用）

>>> import numpy as np
    >>> a = np.arange(15).reshape(3, 5)
    >>> a
    array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14]])
    >>> a.shape
    (3, 5)
    >>> a.ndim
    2
    >>> a.dtype.name
    'int64'
    >>> a.itemsize
    8
    >>> a.size
    15
    >>> type(a)
    <type 'numpy.ndarray'>
    >>> b = np.array([6, 7, 8])
    >>> b
    array([6, 7, 8])
    >>> type(b)
    <type 'numpy.ndarray'>
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
        
       
        
        
         
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23

1.2 创建数组  
通过列表（list）或者元组（tuple）和array（）函数来建立数组。元素的类型会依据序列中元素的类型来判定。

>>> import numpy as np
    >>> a = np.array([2,3,4])
    >>> a
    array([2, 3, 4])
    >>> a.dtype
    dtype('int64')
    >>> b = np.array([1.2, 3.5, 5.1])
    >>> b.dtype
    dtype('float64')
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
        
       
        
        
         
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9

数组将会把序列的序列转换为二维数组，将序列的序列的序列转化为三维数组。

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

可以提前设置数组的类型

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

NumPy提供了创建包含占位符的数组的函数，这样就可以初始化内容不先预先确定的数组。

>>> 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 ) # dtype can also be specified
    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) ) # uninitialized, output may vary
    array([[ 3.73603959e-262, 6.02658058e-154, 6.55490914e-260], [ 5.30498948e-313, 3.14673309e-307, 1.00000000e+000]])
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
        
       
        
        
         
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14

NumPy提供了和range（）类似的函数arange（）来直接创建序列数组。

>>> np.arange( 10, 30, 5 )
    array([10, 15, 20, 25])
    >>> np.arange( 0, 2, 0.3 ) # it accepts float arguments
    array([ 0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])
       
        
         1
         2
         3
         4
        
       
        
        
         
       
        
       
        
         1
         2
         3
         4

类似的我们还可以使用linspace（）函数来创建，注意参数的不同之处

>>> from numpy import pi
    >>> np.linspace( 0, 2, 9 ) # 9 numbers from 0 to 2
    array([ 0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ])
    >>> x = np.linspace
       
        
         1
         2
         3
         4
        
       
        
        
         
       
        
       
        
         1
         2
         3
         4

1.3 打印数组  
打印数组遵循以下三个规律：  
1）最后一个轴是从左往右打印  
2）倒数第二个轴是从上往下打印  
3）剩下的轴也是从上到下，每个片段会用空白的行隔开

>>> a = np.arange(6) # 1d array
    >>> print(a)
    [0 1 2 3 4 5]
    >>>
    >>> b = np.arange(12).reshape(4,3) # 2d array
    >>> print(b)
    [[ 0 1 2] [ 3 4 5] [ 6 7 8] [ 9 10 11]]
    >>>
    >>> c = np.arange(24).reshape(2,3,4) # 3d array
    >>> print(c)
    [[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]]
    [[12 13 14 15] [16 17 18 19] [20 21 22 23]]]
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
        
       
        
        
         
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19

如果数组太大，那么NumPy会跳过中间的数据，如果不想着这样需要设置打印选项

>>> np.set_printoptions(threshold='nan')
       
        
         1
        
       
        
        
         
       
        
       
        
         1

1.4 基本操作  
算数运算会被作用在元素对元素。结果会输出为新的数组。

>>> a = np.array( [20,30,40,50] )
    >>> b = np.arange( 4 )
    >>> b
    array([0, 1, 2, 3])
    >>> c = a-b
    >>> c
    array([20, 29, 38, 47])
    >>> b**2
    array([0, 1, 4, 9])
    >>> 10*np.sin(a)
    array([ 9.12945251, -9.88031624, 7.4511316 , -2.62374854])
    >>> a<35
    array([ True, True, False, False], dtype=bool)
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
        
       
        
        
         
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13

不同于其他语言的矩阵运算，积运算符（\*）也是元素对元素，如果想进行矩阵积运算则需要使用dot（）函数：

>>> A = np.array( [[1,1], ... [0,1]] )
    >>> B = np.array( [[2,0], ... [3,4]] )
    >>> A*B # elementwise product
    array([[2, 0], [0, 4]])
    >>> A.dot(B) # matrix product
    array([[5, 4], [3, 4]])
    >>> np.dot(A, B) # another matrix product
    array([[5, 4], [3, 4]])
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
        
       
        
        
         
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13

一些运算，比如+=，\*=会对本身进行更改，而不会产生新数组：

>>> a = np.ones((2,3), dtype=int)
    >>> b = np.random.random((2,3))
    >>> a *= 3
    >>> a
    array([[3, 3, 3], [3, 3, 3]])
    >>> b += a
    >>> b
    array([[ 3.417022 , 3.72032449, 3.00011437], [ 3.30233257, 3.14675589, 3.09233859]])
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
        
       
        
        
         
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10

当两种不同类型的数组进行运算时，结果将会和更一般的或者精确度更高的数组保持一致。

>>> a = np.ones(3, dtype=np.int32)
    >>> b = np.linspace(0,pi,3)
    >>> b.dtype.name
    'float64'
    >>> c = a+b
    >>> c
    array([ 1. , 2.57079633, 4.14159265])
    >>> c.dtype.name
    'float64'
    >>> d = np.exp(c*1j)
    >>> d
    array([ 0.54030231+0.84147098j, -0.84147098+0.54030231j,
    -0.54030231-0.84147098j])
    >>> d.dtype.name
    'complex128'
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
        
       
        
        
         
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15

ndarray也可以进行一元运算：

>>> a = np.random.random((2,3))
    >>> a
    array([[ 0.18626021, 0.34556073, 0.39676747], [ 0.53881673, 0.41919451, 0.6852195 ]])
    >>> a.sum()
    2.5718191614547998
    >>> a.min()
    0.1862602113776709
    >>> a.max()
    0.6852195003967595
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
        
       
        
        
         
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10

默认情况下，这些运算会把整个数组当成一个list，而忽略了它的纬度。但是，你可以指定轴（axis）。

>>> b = np.arange(12).reshape(3,4)
    >>> b
    array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]])
    >>>
    >>> b.sum(axis=0) # sum of each column
    array([12, 15, 18, 21])
    >>>
    >>> b.min(axis=1) # min of each row
    array([0, 4, 8])
    >>>
    >>> b.cumsum(axis=1) # cumulative sum along each row
    array([[ 0, 1, 3, 6], [ 4, 9, 15, 22], [ 8, 17, 27, 38]])
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
        
       
        
        
         
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16

1.5 通用函数  
NumPy提供了常用的数学函数比如sin、cos、exp，运算后将会返回数组。

>>> B = np.arange(3)
    >>> B
    array([0, 1, 2]) >>> np.exp(B) array([ 1. , 2.71828183, 7.3890561 ]) >>> np.sqrt(B) >array([ 0. , 1. , 1.41421356]) >>> C = np.array([2., -1., 4.]) >>> np.add(B, C) array([ 2., 0., 6.])
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
        
       
        
        
         
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10

1.6 索引、切片和迭代  
一维数组的操作就像list等其他的python序列一样。

>>> a = np.arange(10)**3
    >>> a
    array([ 0, 1, 8, 27, 64, 125, 216, 343, 512, 729])
    >>> a[2]
    8
    >>> a[2:5]
    array([ 8, 27, 64])
    >>> a[:6:2] = -1000 # equivalent to a[0:6:2] = -1000; from start to position 6, exclusive, set every >>> a
    array([-1000, 1, -1000, 27, -1000, 125, 216, 343, 512, 729])
    >>> a[ : :-1] # reversed a
    array([ 729, 512, 343, 216, 125, -1000, 27, -1000, 1, -1000])
    >>> for i in a:
    ... print(i**(1/3.))
    ...
    nan
    1.0
    nan
    3.0
    nan
    5.0
    6.0
    7.0
    8.0
    9.0
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
        
       
        
        
         
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24

多维数组可以通过不同轴进行索引。

>>> def f(x,y):
    ... return 10*x+y
    ...
    >>> b = np.fromfunction(f,(5,4),dtype=int)
    >>> b
    array([[ 0, 1, 2, 3], [10, 11, 12, 13], [20, 21, 22, 23], [30, 31, 32, 33], [40, 41, 42, 43]])
    >>> b[2,3]
    23
    >>> b[0:5, 1] # each row in the second column of b
    array([ 1, 11, 21, 31, 41])
    >>> b[ : ,1] # equivalent to the previous example
    array([ 1, 11, 21, 31, 41])
    >>> b[1:3, : ] # each column in the second and third row of b
    array([[10, 11, 12, 13], [20, 21, 22, 23]])
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
        
       
        
        
         
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19

迭代器：

>>> for row in b:
    ... print(row)
    ...
    [0 1 2 3]
    [10 11 12 13]
    [20 21 22 23]
    [30 31 32 33]
    [40 41 42 43]
       
        
         1
         2
         3
         4
         5
         6
         7
         8
        
       
        
        
         
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8

如果想迭代出每一个元素，则可以使用flat属性：

>>> for element in b.flat:
    ... print(element)
    ...
    0
    1
    2
    3
    10
    11
    12
    13
    20
    21
    22
    23
    30
    31
    32
    33
    40
    41
    42
    43
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
        
       
        
        
         
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23

[Python]: http://lib.csdn.net/base/python