numpy数组特性及操作

numpy数组特性及操作

一、数组特性
dtype：返回数组中元素的类型。
astype：修改元素类型
shape：返回由整数组成的元组，元组中的每个整数依次对应数组的每个轴的元素个数。
size：返回一个整数，代表数组中元素的个数。
ndim：返回一个整数，代表数组的轴的个数，即维度。
nbytes：返回一个整数，代表用于保存数据的字节数。

eg：

import numpy as np
d = np.array([1, 2, 3, 4])
d.dtype
#dtype('int64')

d2 = np.array([1,2,3,4], dtype=float)
d2.dtype
#dtype('float64')

d.astype(float)
#array([1., 2., 3., 4.])
#数组d通过astype修改元素类型后，生成新的数组对象，数组d并未发生改变

d.shape
#(4,)
#表明是一维数组，有4个元素
dd = np.array([[1,2,3], [4,5,6]])
dd
#array([[1, 2, 3],
   [4, 5, 6]])
dd.shape
#(2, 3)
#表明0轴（横行）有两个2元素，1轴（竖列）有3个元素

dd.size
#6
#一共有6个元素，即dd.shape中的2*3

dd.ndim
#2
#表示是2维数组

db = np.array([1,2,3,4,5], ndmin=2)
db
#array([[1, 2, 3, 4, 5]])
db.ndim
#2
#通过ndmin可以修改数组 维度
db.shape
#(1, 5)

dn = np.arange(24)
dn = dn.reshape((2,3,4))
dn
#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]]])
dn.ndim
#3
#在0轴上有2个元素，在1轴上有3个元素，1轴上的每个元素又都是一个1维数组，有4个元素

数组操作，索引，切片，变形，组合，分割

索引
下标是整数

import numpy as np
b = np.linspace(0, 100, 5)
b
#array([  0.,  25.,  50.,  75., 100.])
b[3]
#75
#此处和列表索引一样

c = np.logspace(1, 3, 12).reshape((3, 4))
c
#array([[  10.        ,   15.19911083,   23.101297  ,   35.11191734],
   [  53.36699231,   81.11308308,  123.28467394,  187.38174229],
   [ 284.80358684,  432.87612811,  657.93322466, 1000.        ]])
c[1][2]
#123.28467394420659
c[1, 2]
#123.28467394420659
#c[1][2] = c[1, 2]
#此处索引出来的是元素本身的类型

下标是列表

b[[0,2]]
#array([ 0., 50.])
#取出了数组b中第0个和第2个元素，然后组成新的数组，此处索引出来会返回新的数组

c[[0,2]]
#array([[  10.        ,   15.19911083,  23.101297        ,   35.11191734],
       [ 284.80358684,  432.87612811,  657.93322466, 1000.        ]])
c[[0,2], [1,2]]
#array([ 15.19911083, 657.93322466])
#数组c的0轴第0个元素，1轴第1个元素；0轴第2个元素，1轴第2个元素,。是有对应关系的
c[[2,1,2,1]]
#array([[ 284.80358684,  432.87612811,  657.93322466, 1000.        ],
        [  53.36699231,   81.11308308,  123.28467394,  187.38174229],
       [ 284.80358684,  432.87612811,  657.93322466, 1000.        ],
        [  53.36699231,   81.11308308,  123.28467394,  187.38174229]])
#取数组c的第2个元素，第一个元素，第2个元素，第一个元素组成新的数组

下标是数组

v = np.array([0, 1, 3])
r = b[v]
r
#array([  0.,25.,  75.])
#和下表是列表是一致的

修改数组

c[1] = 100
c
#array([[  10.        ,   15.19911083,   23.101297  ,   35.11191734],
       [ 100.        ,  100.        ,  100.        ,  100.        ],
       [ 284.80358684,  432.87612811,  657.93322466, 1000.        ]])
c[0, 2] = 999
c
#array([[  10.        ,   15.19911083,  999.        ,   35.11191734],
       [ 100.        ,  100.        ,  100.        ,  100.        ],
       [ 284.80358684,  432.87612811,  657.93322466, 1000.        ]])

确认特定数值是否在数组中，若在，则输出

t = b == 50
t
#array([False, False,  True, False, False])
#在jypter notebook中可以直接使用 == 来进行判断，等于会返回True，不等于返回False
b[t]
#array([50.])
#使用数组作为下标索引，只有True才能输出
e = np.arange(10).reshape((2,5))
e
#array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])
t = e % 2 == 0
e[t]
#array([0, 2, 4, 6, 8])

切片

一维切片

a = np.arange(10, 20)
a
#array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
b = a[2: 8]
b
#array([12, 13, 14, 15, 16, 17])
a[: : 2]
#array([10, 12, 14, 16, 18])
#此处和列表切片时一致

二维切片

b = np.arange(0, 60, 10).reshape(-1, 1) + np.arange(0, 6)
b
#array([[ 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]])
#np.arange(0, 60, 10)  得到  array([ 0, 10, 20, 30, 40, 50])
#.reshape(-1, 1)表示0轴不知道，1轴1个元素
#+ np.arange(0, 6)是数组相加，下篇文章会写。
b[1: 4]
#array([[10, 11, 12, 13, 14, 15],
   [20, 21, 22, 23, 24, 25],
   [30, 31, 32, 33, 34, 35]])
b[1:4, 2:5]
#array([[12, 13, 14],
   [22, 23, 24],
   [32, 33, 34]])
 #先是数组b中1，2，3这三个元素，再在这三个元素中跳远每个元素的2，3，4元素
     即，先进行0轴切片，再进行1轴切片
b[:, 2]
#array([ 2, 12, 22, 32, 42, 52])
b[::2, ::2]
#array([[ 0,  2,  4],
   [20, 22, 24],
   [40, 42, 44]])

变形

np.arange(10).reshape((2, 5))
# np.arange(10).reshape((2, 5)) 和下面3行的结果一致 
#a = np.arange(10)
#b = np.reshape(a, (2, 5))
#b
#array([[0, 1, 2, 3, 4],
   [5, 6, 7, 8, 9]])
c = b.reshape((-1, 1))
c
#array([[0],
   [1],
   [2],
   [3],
   [4],
   [5],
   [6],
   [7],
   [8],
   [9]])
np.reshape(b, (10,))
#array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
np.reshape(b, (1, 10))
#array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])
b.shape
#(2, 5)
b.shape = (1, 10)
b
#array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])
#可以通过shape来进行变形
b.shape = (10, 1)
b
#array([[0],
       [1],
       [2],
       [3],
       [4],
       [5],
       [6],
       [7],
       [8],
       [9]])

b.flatten()
#array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
#一维化

ne = np.ravel(b)             #b.ravel()效果一致
ne
#array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
ne[1] = 111
ne
#array([  0, **111**,   2,   3,   4,   5,   6,   7,   8,   9])
b
#array([[  0],
   [**111**],
   [  2],
   [  3],
   [  4],
   [  5],
   [  6],
   [  7],
   [  8],
   [  9]])
#使用ravel得到新的数组，在新的数组中进行元素修改后，原数组元素同样变更
data = np.arange(0, 5) 
c = data[:, np.newaxis]                #和data[:, None]一样
c
#array([[0],
   [1],
   [2],
   [3],
   [4]])

组合

a = np.arange(9).reshape((3, 3))
b = np.arange(12).reshape((3,4))
c = np.arange(15).reshape(3,5)
a
#array([[0, 1, 2],
   [3, 4, 5],
   [6, 7, 8]])
b
#array([[ 0,  1,  2,  3],
   [ 4,  5,  6,  7],
   [ 8,  9, 10, 11]])
np.hstack((a, b))        # np.concatenate((a, b), axis=1)
#array([[ 0,  1,  2,  0,  1,  2,  3],
   [ 3,  4,  5,  4,  5,  6,  7],
   [ 6,  7,  8,  8,  9, 10, 11]])
np.vstack((a, b.T))     #np.concatenate((a, b.T), axis=0)
#array([[ 0,  1,  2],
   [ 3,  4,  5],
   [ 6,  7,  8],
   [ 0,  4,  8],
   [ 1,  5,  9],
   [ 2,  6, 10],
   [ 3,  7, 11]])
#0轴组合，其实是vstack，axis=0，其1轴部分需要元素数相等
#1轴组合，其实是hstack，axis=1，其0轴部分需要元素数相等

分割

a = np.arange(24).reshape(4, 6)
a
#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]])
np.split(a, 2, axis=1)
#[array([[ 0,  1,  2],
    [ 6,  7,  8],
    [12, 13, 14],
    [18, 19, 20]]), array([[ 3,  4,  5],
    [ 9, 10, 11],
    [15, 16, 17],
    [21, 22, 23]])]   
np.split(a, 2, axis=0)
#[array([[ 0,  1,  2,  3,  4,  5],
    [ 6,  7,  8,  9, 10, 11]]), array([[12, 13, 14, 15, 16, 17],
    [18, 19, 20, 21, 22, 23]])]
np.hsplit(a, 2)
#[array([[ 0,  1,  2],
    [ 6,  7,  8],
    [12, 13, 14],
    [18, 19, 20]]), array([[ 3,  4,  5],
    [ 9, 10, 11],
    [15, 16, 17],
    [21, 22, 23]])]