精华内容
下载资源
问答
  • 最近在将个算法matlab转成python,初学python,很多地方还不熟悉,总体感觉就是上手容易,实际上很优雅地用python还是蛮难的。目前为止,觉得就算法仿真研究而言,还是matlab用得特别舒服,可能比较熟悉的缘故...

    最近在将一个算法由matlab转成python,初学python,很多地方还不熟悉,总体感觉就是上手容易,实际上很优雅地用python还是蛮难的。目前为止,觉得就算法仿真研究而言,还是matlab用得特别舒服,可能是比较熟悉的缘故吧。matlab直接集成了很多算法工具箱,函数查询、调用、变量查询等非常方便,或许以后用久了python也会感觉很好用。与python相比,最喜欢的莫过于可以直接选中某段代码执行了,操作方便,python也可以实现,就是感觉不是很方便。

    言归正传,做算法要用到很多的向量和矩阵运算操作,这些嘛在matlab里面已经很熟悉了,但用python的时候需要用一个查一个,挺烦的,所以在此稍作总结,后续使用过程中会根据使用体验更新。

    python的矩阵运算主要依赖numpy包,scipy包以numpy为基础,大大扩展了后者的运算能力。

    2.创建一般的多维数组

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    import numpy as np

    a = np.array([1,2,3], dtype=int)  # 创建1*3维数组   array([1,2,3])

    type(a)  # numpy.ndarray类型

    a.shape  # 维数信息(3L,)

    a.dtype.name   # 'int32'

    a.size   # 元素个数:3

    a.itemsize  #每个元素所占用的字节数目:4

    b=np.array([[1,2,3],[4,5,6]],dtype=int)  # 创建2*3维数组  array([[1,2,3],[4,5,6]])

    b.shape  # 维数信息(2L,3L)

    b.size   # 元素个数:6

    b.itemsize   # 每个元素所占用的字节数目:4

    c=np.array([[1,2,3],[4,5,6]],dtype='int16')  # 创建2*3维数组  array([[1,2,3],[4,5,6]],dtype=int16)

    c.shape  # 维数信息(2L,3L)

    c.size   # 元素个数:6

    c.itemsize   # 每个元素所占用的字节数目:2

    c.ndim  # 维数

    d=np.array([[1,2,3],[4,5,6]],dtype=complex)    #  复数二维数组

    d.itemsize  # 每个元素所占用的字节数目:16

    d.dtype.name  # 元素类型:'complex128'

    3.创建特殊类型的多维数组

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    62

    a1 = np.zeros((3,4))    # 创建3*4全零二维数组

    输出:

    array([[ 0.,  0.,  0.,  0.],

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

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

    a1.dtype.name   # 元素类型:'float64'

    a1.size  # 元素个数:12

    a1.itemsize  # 每个元素所占用的字节个数:8

    a2 = np.ones((2,3,4), dtype=np.int16)  # 创建2*3*4全1三维数组

    a2 = np.ones((2,3,4), dtype='int16')     # 创建2*3*4全1三维数组

    输出:

    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)

    a3 = np.empty((2,3))  # 创建2*3的未初始化二维数组

    输出:(may vary)

    array([[ 1.,  2.,  3.],

    [ 4.,  5.,  6.]])

    a4 = np.arange(10,30,5)   # 初始值10,结束值:30(不包含),步长:5

    输出:array([10, 15, 20, 25])

    a5 = np.arange(0,2,0.3)    # 初始值0,结束值:2(不包含),步长:0.2

    输出:array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8])

    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, 9)

    输出:

    array([ 0.        ,  0.78539816,  1.57079633,  2.35619449,  3.14159265,

    3.92699082,  4.71238898,  5.49778714,  6.28318531])

    a = np.arange(6)

    输出:

    array([0, 1, 2, 3, 4, 5])

    b = np.arange(12).reshape(4,3)

    输出:

    array([[ 0,  1,  2],

    [ 3,  4,  5],

    [ 6,  7,  8],

    [ 9, 10, 11]])

    c = np.arange(24).reshape(2,3,4)

    输出:

    array([[[ 0,  1,  2,  3],

    [ 4,  5,  6,  7],

    [ 8,  9, 10, 11]],

    [[12, 13, 14, 15],

    [16, 17, 18, 19],

    [20, 21, 22, 23]]])

    使用numpy.set_printoptions可以设置numpy变量的打印格式

    在ipython环境下,使用help(numpy.set_printoptions)查询使用帮助和示例

    4.多维数组的基本操作

    加法和减法操作要求操作双方的维数信息一致,均为M*N为数组方可正确执行操作。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    a = np.arange(4)

    输出:

    array([0, 1, 2, 3])

    b = a**2

    输出:

    array([0, 1, 4, 9])

    c = 10*np.sin(a)

    输出:

    array([ 0.        ,  8.41470985,  9.09297427,  1.41120008])

    n < 35

    输出:

    array([ True,  True,  True,  True], dtype=bool)

    A = np.array([[1,1],[0,1]])

    B = np.array([[2,0],[3,4]])

    C = A * B    # 元素点乘

    输出:

    array([[2, 0],

    [0, 4]])

    D = A.dot(B)   # 矩阵乘法

    输出:

    array([[5, 4],

    [3, 4]])

    E = np.dot(A,B)   # 矩阵乘法

    输出:

    array([[5, 4],

    [3, 4]])

    多维数组操作过程中的类型转换

    When operating with arrays of different types, the type of the resulting array corresponds to the more general or precise one (a behavior known as upcasting)

    即操作不同类型的多维数组时,结果自动转换为精度更高类型的数组,即upcasting

    1

    2

    3

    4

    a = np.ones((2,3),dtype=int)      # int32

    b = np.random.random((2,3))     # float64

    b += a  # 正确

    a += b  # 错误

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    a = np.ones(3,dtype=np.int32)

    b = np.linspace(0,pi,3)

    c = a + b

    d = np.exp(c*1j)

    输出:

    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

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    a = np.random.random((2,3))

    a.sum()

    a.min()

    a.max()

    b = np.arange(12).reshape(3,4)

    输出:

    array([[ 0,  1,  2,  3],

    [ 4,  5,  6,  7],

    [ 8,  9, 10, 11]])

    b.sum(axis=0)    # 按列求和

    输出:

    array([12, 15, 18, 21])

    b.sum(axis=1)    # 按行求和

    输出:

    array([ 6, 22, 38])

    b.cumsum(axis=0)   # 按列进行元素累加

    输出:

    array([[ 0,  1,  2,  3],

    [ 4,  6,  8, 10],

    [12, 15, 18, 21]])

    b.cumsum(axis=1)   # 按行进行元素累加

    输出:

    array([[ 0,  1,  3,  6],

    [ 4,  9, 15, 22],

    [ 8, 17, 27, 38]])

    universal functions

    1

    2

    3

    4

    5

    B = np.arange(3)

    np.exp(B)

    np.sqrt(B)

    C = np.array([2.,-1.,4.])

    np.add(B,C)

    其他的ufunc函数包括:

    5.数组索引、切片和迭代

    1

    2

    3

    4

    5

    6

    a = np.arange(10)**3

    a[2]

    a[2:5]

    a[::-1] # 逆序输出

    for i in a:

    print (i**(1/3.))

    1

    2

    3

    4

    5

    6

    7

    8

    def f(x,y):

    return 10*x+y

    b = np.fromfunction(f,(5,4),dtype=int)

    b[2,3]

    b[0:5,1]

    b[:,1]

    b[1:3,:]

    b[-1]

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    c = np.array([[[0,1,2],[10,11,12]],[[100,101,102],[110,111,112]]])

    输出:

    array([[[  0,   1,   2],

    [ 10,  11,  12]],

    [[100, 101, 102],

    [110, 111, 112]]])

    c.shape

    输出:

    (2L, 2L, 3L)

    c[0,...]

    c[0,:,:]

    输出:

    array([[ 0,  1,  2],

    [10, 11, 12]])

    c[:,:,2]

    c[...,2]

    输出:

    array([[  2,  12],

    [102, 112]])

    for row in c:

    print(row)

    for element in c.flat:

    print(element)

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    a = np.floor(10*np.random.random((3,4)))

    输出:

    array([[ 3.,  9.,  8.,  4.],

    [ 2.,  1.,  4.,  6.],

    [ 0.,  6.,  0.,  2.]])

    a.ravel()

    输出:

    array([ 3.,  9.,  8., ...,  6.,  0.,  2.])

    a.reshape(6,2)

    输出:

    array([[ 3.,  9.],

    [ 8.,  4.],

    [ 2.,  1.],

    [ 4.,  6.],

    [ 0.,  6.],

    [ 0.,  2.]])

    a.T

    输出:

    array([[ 3.,  2.,  0.],

    [ 9.,  1.,  6.],

    [ 8.,  4.,  0.],

    [ 4.,  6.,  2.]])

    a.T.shape

    输出:

    (4L, 3L)

    a.resize((2,6))

    输出:

    array([[ 3.,  9.,  8.,  4.,  2.,  1.],

    [ 4.,  6.,  0.,  6.,  0.,  2.]])

    a.shape

    输出:

    (2L, 6L)

    a.reshape(3,-1)

    输出:

    array([[ 3.,  9.,  8.,  4.],

    [ 2.,  1.,  4.,  6.],

    [ 0.,  6.,  0.,  2.]])

    详查以下函数:

    6.组合不同的多维数组

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    a = np.floor(10*np.random.random((2,2)))

    输出:

    array([[ 5.,  2.],

    [ 6.,  2.]])

    b = np.floor(10*np.random.random((2,2)))

    输出:

    array([[ 0.,  2.],

    [ 4.,  1.]])

    np.vstack((a,b))

    输出:

    array([[ 5.,  2.],

    [ 6.,  2.],

    [ 0.,  2.],

    [ 4.,  1.]])

    np.hstack((a,b))

    输出:

    array([[ 5.,  2.,  0.,  2.],

    [ 6.,  2.,  4.,  1.]])

    from numpy import newaxis

    np.column_stack((a,b))

    输出:

    array([[ 5.,  2.,  0.,  2.],

    [ 6.,  2.,  4.,  1.]])

    a = np.array([4.,2.])

    b = np.array([2.,8.])

    a[:,newaxis]

    输出:

    array([[ 4.],

    [ 2.]])

    b[:,newaxis]

    输出:

    array([[ 2.],

    [ 8.]])

    np.column_stack((a[:,newaxis],b[:,newaxis]))

    输出:

    array([[ 4.,  2.],

    [ 2.,  8.]])

    np.vstack((a[:,newaxis],b[:,newaxis]))

    输出:

    array([[ 4.],

    [ 2.],

    [ 2.],

    [ 8.]])

    np.r_[1:4,0,4]

    输出:

    array([1, 2, 3, 0, 4])

    np.c_[np.array([[1,2,3]]),0,0,0,np.array([[4,5,6]])]

    输出:

    array([[1, 2, 3, 0, 0, 0, 4, 5, 6]])

    详细使用请查询以下函数:

    7.将较大的多维数组分割成较小的多维数组

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    a = np.floor(10*np.random.random((2,12)))

    输出:

    array([[ 9.,  7.,  9., ...,  3.,  2.,  4.],

    [ 5.,  3.,  3., ...,  9.,  7.,  7.]])

    np.hsplit(a,3)

    输出:

    [array([[ 9.,  7.,  9.,  6.],

    [ 5.,  3.,  3.,  1.]]), array([[ 7.,  2.,  1.,  6.],

    [ 7.,  5.,  0.,  2.]]), array([[ 9.,  3.,  2.,  4.],

    [ 3.,  9.,  7.,  7.]])]

    np.hsplit(a,(3,4))

    输出:

    [array([[ 9.,  7.,  9.],

    [ 5.,  3.,  3.]]), array([[ 6.],

    [ 1.]]), array([[ 7.,  2.,  1., ...,  3.,  2.,  4.],

    [ 7.,  5.,  0., ...,  9.,  7.,  7.]])]

    实现类似功能的函数包括:

    hsplit,vsplit,array_split

    8.多维数组的复制操作

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    a = np.arange(12)

    输出:

    array([ 0,  1,  2, ...,  9, 10, 11])

    not copy at all

    b = a

    b is a    # True

    b.shape = 3,4

    a.shape  # (3L,4L)

    def f(x)   # Python passes mutable objects as references, so function calls make no copy.

    print(id(x))   # id是python对象的唯一标识符

    id(a)   # 111833936L

    id(b)   # 111833936L

    f(a)     # 111833936L

    浅复制

    c = a.view()

    c is a   # False

    c.base is a   # True

    c.flags.owndata    # False

    c.shape = 2,6

    a.shape   # (3L,4L)

    c[0,4] = 1234

    print(a)

    输出:

    array([[   0,    1,    2,    3],

    [1234,    5,    6,    7],

    [   8,    9,   10,   11]])

    s = a[:,1:3]

    s[:] = 10

    print(a)

    输出:

    array([[   0,   10,   10,    3],

    [1234,   10,   10,    7],

    [   8,   10,   10,   11]])

    深复制

    d = a.copy()

    d is a   # False

    d.base is a   # False

    d[0,0] = 9999

    print(a)

    输出:

    array([[   0,   10,   10,    3],

    [1234,   10,   10,    7],

    [   8,   10,   10,   11]])

    numpy基本函数和方法一览

    Array   Creation

    Conversions

    Manipulations

    Ordering

    Operations

    Basic Statistics

    Basic Linear Algebra

    完整的函数和方法一览表链接:

    https://docs.scipy.org/doc/numpy-dev/reference/routines.html#routines

    9.特殊的索引技巧

    1 a = np.arange(12)**2

    2 输出:

    3 array([  0,   1,   4, ...,  81, 100, 121])

    4 i = np.array([1,1,3,8,5])

    5 a[i]

    6 输出:

    7 array([ 1,  1,  9, 64, 25])

    8

    9 j = np.array([[3,4],[9,7]])

    10 a[j]

    11 输出:

    12 array([[ 9, 16],

    13        [81, 49]])

    14

    15

    16 palette = np.array([[0,0,0],[255,0,0],[0,255,0],[0,0,255],[255,255,255]])

    17 image = np.array([[0,1,2,0],[0,3,4,0]])

    18 palette[image]

    19 输出:

    20 array([[[  0,   0,   0],

    21         [255,   0,   0],

    22         [  0, 255,   0],

    23         [  0,   0,   0]],

    24

    25        [[  0,   0,   0],

    26         [  0,   0, 255],

    27         [255, 255, 255],

    28         [  0,   0,   0]]])

    29

    30

    31 i = np.array([[0,1],[1,2]])

    32 j = np.array([[2,1],[3,3]])

    33 a[i,j]

    34 输出:

    35 array([[ 2,  5],

    36        [ 7, 11]])

    37 l = [i,j]

    38 a[l]

    39 输出:

    40 array([[ 2,  5],

    41        [ 7, 11]])

    42

    43

    44 a[i,2]

    45 输出:

    46 array([[ 2,  6],

    47        [ 6, 10]])

    48

    49 a[:,j]

    50 输出:

    51 array([[[ 2,  1],

    52         [ 3,  3]],

    53

    54        [[ 6,  5],

    55         [ 7,  7]],

    56

    57        [[10,  9],

    58         [11, 11]]])

    s = np.array([i,j])

    print(s)

    array([[[0, 1],

    [1, 2]],

    [[2, 1],

    [3, 3]]])

    a[tuple(s)]

    输出:

    array([[ 2,  5],

    [ 7, 11]])

    print(tupe(s))

    输出:

    (array([[0, 1],

    [1, 2]]), array([[2, 1],

    [3, 3]]))

    10.寻找最大值/最小值及其对应索引值

    time = np.linspace(20, 145, 5)

    输出:

    array([  20.  ,   51.25,   82.5 ,  113.75,  145.  ])

    data = np.sin(np.arange(20)).reshape(5,4)

    输出:

    array([[ 0.        ,  0.84147098,  0.90929743,  0.14112001],

    [-0.7568025 , -0.95892427, -0.2794155 ,  0.6569866 ],

    [ 0.98935825,  0.41211849, -0.54402111, -0.99999021],

    [-0.53657292,  0.42016704,  0.99060736,  0.65028784],

    [-0.28790332, -0.96139749, -0.75098725,  0.14987721]])

    ind = data.argmax(axis=0)

    输出:

    array([2, 0, 3, 1], dtype=int64)

    time_max = time[ind]

    输出:

    array([  82.5 ,   20.  ,  113.75,   51.25])

    data_max = data[ind, xrange(data.shape[1])]

    输出:

    array([ 0.98935825,  0.84147098,  0.99060736,  0.6569866 ])

    np.all(data_max == data.max(axis=0))

    输出:

    True

    a = np.arange(5)

    a[[1,3,4]] = 0

    print(a)

    输出:

    array([0, 0, 2, 0, 0])

    a = np.arange(5)

    a[[0,0,2]] = [1,2,3]

    print(a)

    输出:

    array([2, 1, 3, 3, 4])

    a = np.arange(5)

    a[[0,0,2]] += 1

    print(a)

    输出:

    array([1, 1, 3, 3, 4])

    a = np.arange(12).reshape(3,4)

    b = a > 4

    输出:

    array([[False, False, False, False],

    [False,  True,  True,  True],

    [ True,  True,  True,  True]], dtype=bool)

    a[b]

    输出:

    array([ 5,  6,  7,  8,  9, 10, 11])

    a[b] = 0

    print(a)

    输出:

    array([[0, 1, 2, 3],

    [4, 0, 0, 0],

    [0, 0, 0, 0]])

    a = np.arange(12).reshape(3,4)

    b1 = np.array([False,True,True])

    b2 = n.array([True,False,True,False])

    a[b1,:]

    输出:

    array([[ 4,  5,  6,  7],

    [ 8,  9, 10, 11]])

    a[b1]

    输出:

    array([[ 4,  5,  6,  7],

    [ 8,  9, 10, 11]])

    a[:,b2]

    输出:

    array([[ 0,  2],

    [ 4,  6],

    [ 8, 10]])

    a[b1,b2]

    输出:

    array([ 4, 10])

    11. ix_() function

    1 a = np.array([2,3,4,5])

    2 b = np.array([8,5,4])

    3 c = np.array([5,4,6,8,3])

    4 ax,bx,cx = np.ix_(a,b,c)

    5 print(ax)   # (4L, 1L, 1L)

    6 输出:

    7 array([[[2]],

    8

    9        [[3]],

    10

    11        [[4]],

    12

    13        [[5]]])

    14 print(bx)    # (1L, 3L, 1L)

    15 输出:

    16 array([[[8],

    17         [5],

    18         [4]]])

    19 print(cx)   # (1L, 1L, 5L)

    20 输出:

    21 array([[[5, 4, 6, 8, 3]]])

    22

    23

    24 result = ax + bx*cx

    25 输出:

    26 array([[[42, 34, 50, 66, 26],

    27         [27, 22, 32, 42, 17],

    28         [22, 18, 26, 34, 14]],

    29

    30        [[43, 35, 51, 67, 27],

    31         [28, 23, 33, 43, 18],

    32         [23, 19, 27, 35, 15]],

    33

    34        [[44, 36, 52, 68, 28],

    35         [29, 24, 34, 44, 19],

    36         [24, 20, 28, 36, 16]],

    37

    38        [[45, 37, 53, 69, 29],

    39         [30, 25, 35, 45, 20],

    40         [25, 21, 29, 37, 17]]])

    41

    42 result[3,2,4]

    43 输出:17

    12.线性代数运算

    a = np.array([[1.,2.],[3.,4.]])

    a.transpose()   # 转置

    np.linalg.inv(a)   # 求逆

    u = np.eye(2)   # 产生单位矩阵

    np.dot(a,a)    # 矩阵乘积

    np.trace(a)    # 求矩阵的迹

    y = np.array([5.],[7.]])

    np.linalg.solve(a,y)  # 求解线性方程组

    np.linalg.eig(a)   # 特征分解

    “Automatic” Reshaping

    1 a = np.arange(30)

    2 a.shape = 2,-1,3

    3 a.shape   #  (2L, 5L, 3L)

    4 print(a)

    5 array([[[ 0,  1,  2],

    6         [ 3,  4,  5],

    7         [ 6,  7,  8],

    8         [ 9, 10, 11],

    9         [12, 13, 14]],

    10

    11        [[15, 16, 17],

    12         [18, 19, 20],

    13         [21, 22, 23],

    14         [24, 25, 26],

    15         [27, 28, 29]]])

    1 x = np.arange(0,10,2)

    2 y = np.arange(5)

    3 m = np.vstack([x,y])

    4 输出:

    5 array([[0, 2, 4, 6, 8],

    6        [0, 1, 2, 3, 4]])

    7 n = np.hstack([x,y])

    8 输出:

    9 array([0, 2, 4, 6, 8, 0, 1, 2, 3, 4])

    13.矩阵的创建

    a = np.array([1,2,3])

    a1 = np.mat(a)

    输出:

    matrix([[1, 2, 3]])

    type(a1)

    输出:

    numpy.matrixlib.defmatrix.matrix

    a1.shape

    输出:

    (1L, 3L)

    a.shape

    输出:

    (3L,)

    b=np.matrix([1,2,3])

    输出:

    matrix([[1, 2, 3]])

    from numpy import *

    data1 = mat(zeros((3,3)))

    data2 = mat(ones((2,4)))

    data3 = mat(random.rand(2,2))

    data4 = mat(random.randint(2,8,size=(2,5)))

    data5 = mat(eye(2,2,dtype=int))

    14.常见的矩阵运算

    1 a1 = mat([1,2])

    2 a2 = mat([[1],[2]])

    3 a3 = a1 * a2

    4 print(a3)

    5 输出:

    6 matrix([[5]])

    7

    8 print(a1*2)

    9 输出:

    10 matrix([[2, 4]])

    11

    12 a1 = mat(eye(2,2)*0.5)

    13 print(a1.I)

    14 输出:

    15 matrix([[ 2.,  0.],

    16         [ 0.,  2.]])

    17

    18

    19 a1 = mat([[1,2],[2,3],[4,2]])

    20 a1.sum(axis=0)

    21 输出:

    22 matrix([[7, 7]])

    23 a1.sum(axis=1)

    24 输出:

    25 matrix([[3],

    26         [5],

    27         [6]])

    28 a1.max()  # 求矩阵元素最大值

    29 输出:

    30 4

    31 a1.min()  # 求矩阵元素最小值

    32 输出:

    33 1

    34

    35 np.max(a1,0)  # 求矩阵每列元素最大值

    36 输出:

    37 matrix([[4, 3]])

    38 np.max(a1,1)  # 求矩阵每行元素最大值

    39 输出:

    40 matrix([[2],

    41         [3],

    42         [4]])

    43

    44

    45 a = mat(ones((2,2)))

    46 b = mat(eye((2)))

    47 c = hstack((a,b))

    48 输出:

    49 matrix([[ 1.,  1.,  1.,  0.],

    50         [ 1.,  1.,  0.,  1.]])

    51 d = vstack((a,b))

    52 输出:

    53 matrix([[ 1.,  1.],

    54         [ 1.,  1.],

    55         [ 1.,  0.],

    56         [ 0.,  1.]])

    15.矩阵、数组、列表之间的互相转换

    1 aa = [[1,2],[3,4],[5,6]]

    2 bb = array(aa)

    3 cc = mat(bb)

    4

    5 cc.getA()  # 矩阵转换为数组

    6 cc.tolist()  # 矩阵转换为列表

    7 bb.tolist() # 数组转换为列表

    8

    9

    10 # 当列表为一维时,情况有点特殊

    11 aa = [1,2,3,4]

    12 bb = array(aa)

    13 输出:

    14 array([1, 2, 3, 4])

    15 cc = mat(bb)

    16 输出:

    17 matrix([[1, 2, 3, 4]])

    18

    19 cc.tolist()

    20 输出:

    21 [[1, 2, 3, 4]]

    22

    23 bb.tolist()

    24 输出:

    25 [1, 2, 3, 4]

    26

    27 cc.tolist()[0]

    28 输出:

    29 [1, 2, 3, 4]

    展开全文
  • Java中所谓的多维数组实际上是由一维数组嵌套而成。 即一维数组的元素是另外一个一维数组时则称为二维数组 以此类推,一维数组的多次嵌套就构成了二维数组 二、多维数组的使用(以二维数组为例) (一)静态初始...

    总是让二维数组绕迷糊该怎么办?
    快和小乔一起来用一个超具体、好理解的例子一起学习吧~
    保证让你看后收获满满!!

    一、视频讲解

    【本期视频图文讲解会放在专栏里】||【新手友好型视频】全面讲解Java二维数组(内含带答案和讲解的练习题喔)

    点击这里即可去B站观看

    二、多维数组的介绍

    • Java中所谓的多维数组实际上是由一维数组嵌套而成
    • 一维数组的元素是另外一个一维数组时则称为二维数组
    • 以此类推,一维数组的多次嵌套就构成了二维数组

    三、多维数组的使用(以二维数组为例)

    (一)静态初始化——指定数组内容

    以下面图片为例子,便于大家理解

    在这里插入图片描述

    1.一般格式:

    数据类型 [ ] [ ] 数组名称 = new 数据类型 [ ] [ ] {{元素1,元素2,…},{元素1,元素2,…},{…}};
    eg:String [ ] [ ] wodeaidou = new String [ ] [ ] {{“易烊千玺”,“男”},{“小乔”,“女”},{“小乔1”,“女”},{“小乔2”,“女”},{“小乔3”,“女”}};

    2.简便格式:

    数据类型 [ ] [ ] 数组名称 ={{元素1,元素2,…},{元素1,元素2,…},{…}};
    eg:String [ ] [ ] wodeaidou ={
    {“易烊千玺”,“男”},{“小乔”,“女”},{“小乔1”,“女”},{“小乔2”,“女”},{“小乔3”,“女”}};

    (二)动态初始化——指定数组长度

    以下面图片为例子,便于大家理解

    在这里插入图片描述
    在这里插入图片描述
    eg:String [ ] [ ] wodeaidou = new String [5] [4];

    在这里插入图片描述
    eg:String [ ] [ ] wodeaidou = new String [5] [ ];

    四、二维数组的遍历

    1.代码:

    package Sort;
    
    public class ArrayExerciseT {
    
    	public static void main(String[] args) {
    		String wodeaidou[][] = new String[5][2];// 创建5个一维数组,每一一维数组中存放2个元素
    		wodeaidou[0][0] = "易烊千玺";
    		wodeaidou[0][1] = "男";
    		wodeaidou[1][0] = "小乔";
    		wodeaidou[1][1] = "女";
    		wodeaidou[2][0] = "小乔1";
    		wodeaidou[2][1] = "女";
    		wodeaidou[3][0] = "小乔2";
    		wodeaidou[3][1] = "女";
    		wodeaidou[4][0] = "小乔3";
    		wodeaidou[4][1] = "女";
    		for (int i = 0; i < wodeaidou.length; i++) {// 遍历一维数组的个数即wodeaidou.length为5(行数)
    			for (int j = 0; j < wodeaidou[i].length; j++) {// 遍历每个一维数组中元素的个数即wodeaidou[i].length为2(列数)
    				System.out.print(wodeaidou[i][j]);// 每遍历一次输出一次
    			}
    			System.out.println();
    		}
    	}
    }
    
    

    2.讲解

    (1)执行 String wodeaidou[][] = new String[5][2]; 后结果如下图:
    (因为此时没有初始化,所以存储的是String类型数组的默认值null)
    在这里插入图片描述
    (2)执行下面代码,执行完后得到如下图片:

    		wodeaidou[0][0] = "易烊千玺";
    		wodeaidou[0][1] = "男";
    		wodeaidou[1][0] = "小乔";
    		wodeaidou[1][1] = "女";
    		wodeaidou[2][0] = "小乔1";
    		wodeaidou[2][1] = "女";
    		wodeaidou[3][0] = "小乔2";
    		wodeaidou[3][1] = "女";
    		wodeaidou[4][0] = "小乔3";
    		wodeaidou[4][1] = "女";
    

    结果:
    在这里插入图片描述
    (3)遍历数组:

    i = 0 i < wodeaidou.length(即i<5) j=0 j < wodeaidou[0].length(即j<2) 输出wodeaidou[0] [0]即"易烊千玺"
    i = 0 i < wodeaidou.length(即i<5) j=1 j < wodeaidou[0].length(即j<2) 输出wodeaidou[0] [1]即"男"
    i = 1 i < wodeaidou.length(即i<5) j=0 j < wodeaidou[1].length(即j<2) 输出wodeaidou[1] [0]即"小乔"
    i = 1 i < wodeaidou.length(即i<5) j=1 j < wodeaidou[1].length(即j<2) 输出wodeaidou[1] [1]即"女"
    i = 2 i < wodeaidou.length(即i<5) j=0 j < wodeaidou[2].length(即j<2) 输出wodeaidou[2] [0]即"小乔1"
    i = 2 i < wodeaidou.length(即i<5) j=1 j < wodeaidou[2].length(即j<2) 输出wodeaidou[2] [1]即"女"
    i = 3 i < wodeaidou.length(即i<5) j=0 j < wodeaidou[3].length(即j<2) 输出wodeaidou[3] [0]即"小乔2"
    i = 3 i < wodeaidou.length(即i<5) j=1 j < wodeaidou[3].length(即j<2) 输出wodeaidou[3] [1]即"女"
    i = 4 i < wodeaidou.length(即i<5) j=0 j < wodeaidou[4].length(即j<2) 输出wodeaidou[4] [0]即"小乔3"
    i = 4 i < wodeaidou.length(即i<5) j=1 j < wodeaidou[4].length(即j<2) 输出wodeaidou[4] [1]即"女"

    (4)输出结果:
    在这里插入图片描述
    (5)总结:

    • 二维数组的遍历需要使用双重for循环
    • 第一个for循环得到一维数组的个数(即行数)
    • 第二个for循环得到每个一维数组中存放的元素的个数(即每行的列数)
    for (int i = 0; i < wodeaidou.length; i++) {// 遍历一维数组的个数即wodeaidou.length为5(行数)
    			for (int j = 0; j < wodeaidou[i].length; j++) {// 遍历每个一维数组中元素的个数即wodeaidou[i].length为2(列数)
    

    五、练习题彩蛋

    在这里插入图片描述
    推荐你看:

    如果你觉得这篇文章还不错,麻烦帮我点个赞鸭!可以让更多人看到这篇文章。让我有动力继续更技术文~

    展开全文
  • 一维数组是由数字组成的以单纯的排序结构排列的结构单一的数组。一维数组是计算机程序中最基本的数组。二维及多维数组可以看作是一维数组的多次叠加产生的。 数组是计算机编程中的重要概念,运用数组可以方便地处理...

    在程序中可以使用下标变量,即说明这些变量的整体为数组,数组中的每个变量的数据类型是相同的。
    当数组中每个元素都只带有一个下标时,称这样的数组为一维数组。
    一维数组是由数字组成的以单纯的排序结构排列的结构单一的数组。一维数组是计算机程序中最基本的数组。二维及多维数组可以看作是一维数组的多次叠加产生的。
    数组是计算机编程中的重要概念,运用数组可以方便地处理大规模的数据。
    PHP 中的数组实际上是一个有序映射。映射是一种把 values 关联到 keys 的类型。此类型在很多方面做了优化,因此可以把它当成真正的数组,或列表(向量),散列表(是映射的一种实现),字典,集合,栈,队列以及更多可能性。由于数组元素的值也可以是另一个数组,树形结构和多维数组也是允许的。
    下面我来介绍一个简单的一维数组求最大值、最小值、平均值;代码如下
    在这里插入图片描述
    结果如下:
    在这里插入图片描述
    本篇文章就是关于求一维数组98,23,76,99,88,68的最大值、最小值和平均值的具体介绍,仅供参考,希望对有需要的朋友有所帮助!

    展开全文
  • 本质上多维数组一维数组是一样的,他们在内存中是线性排列的,这里对多维的定义实际上是反复递归对一维的定义,即N维数组是一个集合,包含多个元素,每个元素又是一个N-1维数组。 对于多维数组,我们约定方括号越...

    二维数组的初识及初始化

    二维数组定义的形式是数组名[常量表达式][常量表达式] 。本质上多维数组与一维数组是一样的,他们在内存中是线性排列的,这里对多维的定义实际上是反复递归对一维的定义,即N维数组是一个集合,包含多个元素,每个元素又是一个N-1维数组
    对于多维数组,我们约定方括号越往左边成为高维,越往右边称为低维,最左边的是第一维,其每一维的长度由方括号内的常量表达式决定,如a[3][4],表示有三个一维数组,每个一位数组里有4个元素.
    二维数组的内存结构
    让我们看下面的这个例子:

    #include<stdio.h>
    int b[4][4];  //在函数体外定义的全局变量自动初始化为零 
    int main(void)
    {
    	int a[4][4] = {{1},{1,2},{1,2,3},{1,2,3,4}};  //在函数体内定义的变量需要自己初始化,注意多维数组初始化的格式 
    	int i , j ;
    	for(i = 0; i <= 3; i++ )
    		{for(j = 0; j <= 3; j++ )
    			printf("a[%d][%d] %d  ", i , j, a[i][j] );
    		}
    	for(i = 0; i <= 3; i++ )
    		{for(j = 0; j <= 3; j++ )
    			printf("b[%d][%d] %d  ", i , j, b[i][j] );
    		}
    	return 0;
    }
    

    对于多维数组的初始化,我们有两种方法一种是按多维数组初始化,另外一种是按一维数组初始化。
    按多维数组初始化按一维数组初始化
    另外,在函数体内初始化和在函数体外初始化也是不同的,在上面的例子中,在函数体外定义的b数组自动初始化为零,不需额外操作,而在函数体内定义的a数组则需要自己初始化,要注意多维数组初始化的格式。并且,在函数体内定义的数组如果只初始化了一部分,剩下的元素都会被初始化为零。
    在已经给出初值列表的情况下,定义多维数时可以不用说明第一维数组的长度,编译器会根据列出的元素自动给出能容纳元素的最小数组长度。
    在这里插入图片描述

    二维数组的引用与遍历

    #include<stdio.h>
    int main(void)
    {
    	int i , j , n ;
    	printf("Please input how many dimensional array you want to create\n");
    	scanf("%d",&n);
    	int a[n][n] ;
    	printf("Please input your Multidimensional array\n");
    	for(i =0 ; i < n ; i++ )
    		for(j =0 ; j < n ; j++ )
    			scanf("%d",&a[i][j]);
    	printf("\n");
    	for(i =0 ; i < n ; i++ )
    		{for(j =0 ; j < n ; j++ )
    			{printf("%d  ",a[i][j]);
    			if(j == n-1)
    			printf("\n");
    			}
    		}
    	return 0;
    } 
    

    在引用二维数组时,和一维数组一样,我们不能直接引用整个数组,而是只能引用其中的元素,要注意每个元素的下标。

    #include<stdio.h>
    int main(void)
    {
    	int a[4][4] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16} ;
    	int i , j , sum ; 
    	//主对角线元素遍历 
    	for( sum = 0 , i = 0 ; i < 4 ; i++ )
    		{j = i ;
    		printf("%d ", a[i][j] );
    		sum += a[i][j] ;
    		}
    	printf("\n主对角线元素之和为%d\n",sum) ;
    	//副对角线元素遍历
    	for( sum = 0 , i = 0 ; i < 4 ; i++ )
    		{j = 3-i ;
    		printf("%d ", a[i][j] );
    		sum += a[i][j] ; 
    		}
    	printf("\n副对角线元素之和为%d\n",sum) ;
    	//左上三角元素遍历
    	for( sum = 0 , i = 0 ; i < 4 ; i++ )
    		{for( j = 0 ; j < 4-i ; j++ )
    			{printf("%d ", a[i][j] );
    			sum += a[i][j] ;
    			}
    		}
    	printf("\n左上三角元素之和为%d\n",sum) ;
    	//左下三角元素遍历
    	for( sum = 0 , i = 0 ; i < 4 ; i++ )
    		{for( j = 0 ; j < i+1 ; j++ )
    			{printf("%d ", a[i][j] );
    			sum += a[i][j] ;
    			}
    		}
    	printf("\n左下三角元素之和为%d\n",sum) ;
    	//右下三角元素遍历
    	for( sum = 0 , i = 0 ; i < 4 ; i++ )
    		{for( j = 3-i ; j < 4 ; j++ )
    			{printf("%d ", a[i][j] );
    			sum += a[i][j] ;
    			}
    		}
    	printf("\n右下三角元素之和为%d\n",sum) ;
    	//右上三角元素遍历
    	for( sum = 0 , i = 0 ; i < 4 ; i++ )
    		{for( j = i ; j < 4 ; j++ )
    			{printf("%d ", a[i][j] );
    			sum += a[i][j] ;
    			}
    		}
    	printf("\n右上三角元素之和为%d\n",sum) ;
    	//内部元素遍历 
    	for( sum = 0 , i = 1 ; i < 3 ; i++ )
    		{for( j = 1 ; j < 3 ; j++ )
    			{printf("%d ", a[i][j] );
    			sum += a[i][j] ;
    			}
    		}
    	printf("\n内部元素之和为%d\n",sum) ;
    	//外部元素遍历 
    	for( sum = 0 , i = 0 ; i < 4 ; i++ )
    		{for( j = 0 ; j < 4 ; j++ )
    			{printf("%d ", a[i][j] );
    			sum += a[i][j] ;
    			}
    		}
    	printf("\n外部元素之和为%d\n",sum) ;
    	return 0;
    }
    

    通过对下表的条件限制,我们可以实现对二维数组中元素的遍历,进而实现求和求积等操作。

    展开全文
  • 3.10.7 不规则数组 到目前为止,读者所看到的数组与其他程序设计语言中提供的数组没有多...例如,在前面的示例中,balances数组实际上是一个包含10个元素的数组,而每个元素又是6个浮点数组成的数组(请参看...
  •  Java语言中的数组可以分为:一维数组多维数组,本部分将首先以一维数组为基础进行讲解,最后讲解多维数组的概念和相关的理解、使用。了解了数组以上相关的概念以后,在实际使用数组时,数组的类型、数组的长度...
  • 基本概念一维数据表示一维数据的存储一维数据处理(未进行实际操作!!!!!)1.基本概念1.1 维度:一组数据的组织形式1.2一维数据由对等关系的有序或无序数据...中国大学排行榜多维数据由一维或二维数据在新维度扩...
  • 关于Java数组 数组可以分为动态数组,和静态数组。 数组的变量只是一个引用变量,数组的对象保存在堆内存中的连续内存空间,数组引用保存在栈内存中,对数组的初始... 数组中的多维数组实际上是一维数组 Java变量
  • Tensor实际上就是多维数组(multidimensional array) Tensor的目的能够创造更高维度的矩阵、向量。 色彩的例子 彩色图像文件(RGB)一般都会处理成3-d tensor,每个2d array中的element表示个像素,R...
  • 数据分析---科学计算工具numpy(

    千次阅读 多人点赞 2019-07-18 13:48:25
    科学计算根据numpy 、什么numpy? Numpypython开源的科学计算工具包。...numpy数组是一多维数组对象,称为ndarray,其两部分构成: 实际的数据 描述这些数据的元数据 eg: import n...
  • opencv中的Mat类型实际上可以理解为多维多通道的矩阵,如果个普通的彩色图像读进来后赋值给个Mat类型的对象M,那么这个M就是个二维数组,这个二维数组中的每个元素都是一个含有三个RGB值得数据,那这个M...
  • 实际上是两个指针值(地址) 相减之差再除以该数组元素的长度(字节数)。例如pf1和pf2 是指向同一浮点数组的两个指针变量,设pf1的值为2010H,pf2的值为2000H,而浮点数组每个元素占4个字节,所以pf1-pf2的结果为(2000H...
  • 作者在网络版CFAQ列表的基础进行了大幅度的扩充和丰富,结合代码示例,权威而且详细深入地解答了实际学习和工作中最常遇到的495个C语言问题,涵盖了初始化、数组、指针、字符串、内存分配、库函数、C预处理器等...
  • 作者在网络版CFAQ列表的基础进行了大幅度的扩充和丰富,结合代码示例,权威而且详细深入地解答了实际学习和工作中最常遇到的495个C语言问题,涵盖了初始化、数组、指针、字符串、内存分配、库函数、C预处理器等...
  • 1.23 能否声明和传入数组大小一致的局部数组,或者其他参数指定大小的参数数组? 42 1.24 我在个文件中定义了个extern数组,然后在另个文件中使用,为什么sizeof取不到数组的大小? 42 声明问题 43 1.25...
  • 6.18 当我向个接受指针的指针的函数传入二维数组的时候,编译器报错了。  6.19 我怎样编写接受编译时宽度未知的二维数组的函数?  6.20 我怎样在函数参数传递时混用静态和动态多维数组?  数组的大小  6.21...
  • 到底指针是一数组,还是数组是一种指针? 6.11 我看到一些“搞笑”的代码,包含5["abcdef"]这样的“表达式”。这为什么合法的C语言表达式呢? 数组的指针 6.12 既然数组引用会退化为指针,如果array是数组...
  • c++ 程序设计

    2019-01-20 22:53:37
    5.2 一维数组的定义和引用 5.2.1 定义一维数组 5.2.2 引用一维数组的元素 5.2.3 一维数组的初始化 5.2.4 一维数组程序举例 5.3 二维数组的定义和引用 5.3.1 定义二维数组 5.3.2 二维数组的引用 5.3.3 二维数组的初始...
  • 6.18 当我向个接受指针的指针的函数传入二维数组的时候,编译器报错了。 6.19 我怎样编写接受编译时宽度未知的二维数组的函数? 6.20 我怎样在函数参数传递时混用静态和动态多维数组? 数组的大小 6.21 当数组...
  • 1.23 能否声明和传入数组大小一致的局部数组,或者其他参数指定大小的参数数组? 13 1.24 我在个文件中定义了个extern数组,然后在另个文件中使用,为什么sizeof取不到数组的大小? 13 声明问题 14 ...
  • 《你必须知道的495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    1.23 能否声明和传入数组大小一致的局部数组,或者其他参数指定大小的参数数组? 13 1.24 我在个文件中定义了个extern数组,然后在另个文件中使用,为什么sizeof取不到数组的大小? 13 声明问题 14 ...
  • o 7.15 当我向个接受指针的指针的函数传入二维数组的时候, 编译器报错了。 o 7.16 我怎样编写接受编译时宽度未知的二维数组的函数 ? o 7.17 我怎样在函数参数传递时混用静态和动态多维数组 ? o 7.18 当数组...
  • 你必须知道的495个C语言问题(PDF)

    热门讨论 2009-09-15 10:25:47
    1.2 64 位机的64 位类型什么样的? . . . . . . . . . . . . . . . . 1 1.3 怎样定义和声明全局变量和函数最好? . . . . . . . . . . . . . . . 2 1.4 extern 在函数声明中什么意思? . . . . . . . . . . . ...
  • 最后,读者将学习如何创建二维数组以及如何使用嵌套循环来处理它们。 第6章:分支语句和逻辑操作符 如果程序可以根据实际情况调整执行,我们就说程序能够智能地行动。在本章,读者将了解到如何使用if 、if else...
  • 最后,读者将学习如何创建二维数组以及如何使用嵌套循环来处理它们。 第6章:分支语句和逻辑操作符 如果程序可以根据实际情况调整执行,我们就说程序能够智能地行动。在本章,读者将了解到如何使用if 、if else...
  • 最后,读者将学习如何创建二维数组以及如何使用嵌套循环来处理它们。 第6章:分支语句和逻辑操作符 如果程序可以根据实际情况调整执行,我们就说程序能够智能地行动。在本章,读者将了解到如何使用if 、if else...
  • 本书从函数功能、函数格式、参数说明、注意事项、Excel 版本提醒、案例应用、交叉参考7 个方面,全面、细致地介绍了Excel 2016/2013/2010/2007/2003 中公式和函数的使用方法、实际应用和操作技巧。最后3 章还将公式...

空空如也

空空如也

1 2
收藏数 31
精华内容 12
关键字:

多维数组实际上是由一维数组