Numpy 数组及其索引

先导入numpy：

In [1]:

from numpy import *

产生数组

从列表产生数组：

In [2]:

lst = [0, 1, 2, 3]
a = array(lst)
a

Out[2]:

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

或者直接将列表传入：

In [3]:

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

Out[3]:

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

数组属性

查看类型：

In [4]:

type(a)

Out[4]:

numpy.ndarray

查看数组中的数据类型：

In [5]:

# 32比特的整数
a.dtype

Out[5]:

dtype('int32')

查看每个元素所占的字节：

In [6]:

a.itemsize

Out[6]:

查看形状，会返回一个元组，每个元素代表这一维的元素数目：

In [7]:

# 1维数组，返回一个元组
a.shape

Out[7]:

(4L,)

或者使用：

In [8]:

shape(a)

Out[8]:

(4L,)

shape 的使用历史要比 a.shape 久，而且还可以作用于别的类型：

In [9]:

lst = [1,2,3,4]
shape(lst)

Out[9]:

(4L,)

查看元素数目：

In [10]:

a.size

Out[10]:

In [11]:

size(a)

Out[11]:

查看所有元素所占的空间：

In [12]:

a.nbytes

Out[12]:

但事实上，数组所占的存储空间要比这个数字大，因为要用一个header来保存shape，dtype这样的信息。

查看数组维数：

In [13]:

a.ndim

Out[13]:

使用fill方法设定初始值

可以使用 fill 方法将数组设为指定值：

In [14]:

a.fill(-4.8)
a

Out[14]:

array([-4, -4, -4, -4])

但是与列表不同，数组中要求所有元素的 dtype 是一样的，如果传入参数的类型与数组类型不一样，需要按照已有的类型进行转换。

索引与切片

和列表相似，数组也支持索引和切片操作。

索引第一个元素：

In [15]:

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

Out[15]:

修改第一个元素的值：

In [16]:

a[0] = 10
a

Out[16]:

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

切片，支持负索引：

In [17]:

a = array([11,12,13,14,15])
a[1:3]

Out[17]:

array([12, 13])

In [18]:

a[1:-2]

Out[18]:

array([12, 13])

In [19]:

a[-4:3]

Out[19]:

array([12, 13])

省略参数：

In [20]:

a[::2]

Out[20]:

array([11, 13, 15])

In [21]:

a[-2:]

Out[21]:

array([14, 15])

假设我们记录一辆汽车表盘上每天显示的里程数：

In [22]:

od = array([21000, 21180, 21240, 22100, 22400])

可以这样计算每天的旅程：

In [23]:

dist = od[1:] - od[:-1]
dist

Out[23]:

array([180,  60, 860, 300])

在本质上，Python会将array的各种计算转换为类似这样的C代码：

int compute_sum(int *arr, int N) {
    int sum = 0;
    int i;
    for (i = 0; i < N; i++) {
        sum += arr[i];
    }
    return sum;
}

多维数组及其属性

array 还可以用来生成多维数组：

In [24]:

a = array([[ 0, 1, 2, 3],
           [10,11,12,13]])
a

Out[24]:

array([[ 0,  1,  2,  3],
       [10, 11, 12, 13]])

事实上我们传入的是一个以列表为元素的列表，最终得到一个二维数组。

甚至可以扩展到3D或者4D的情景。

查看形状：

In [25]:

a.shape

Out[25]:

(2L, 4L)

这里2代表行数，4代表列数。

查看总的元素个数：

In [26]:

# 2 * 4 = 8
a.size

Out[26]:

查看维数：

In [27]:

a.ndim

Out[27]:

多维数组索引

对于二维数组，可以传入两个数字来索引：

In [28]:

a[1, 3]

Out[28]:

其中，1是行索引，3是列索引，中间用逗号隔开，事实上，Python会将它们看成一个元组(1,3)，然后按照顺序进行对应。

可以利用索引给它赋值：

In [29]:

a[1, 3] = -1
a

Out[29]:

array([[ 0,  1,  2,  3],
       [10, 11, 12, -1]])

事实上，我们还可以使用单个索引来索引一整行内容：

In [30]:

# 返回第二行元组组成的array
a[1]

Out[30]:

array([10, 11, 12, -1])

Python会将这单个元组当成对第一维的索引，然后返回对应的内容。

多维数组切片

多维数组，也支持切片操作：

In [31]:

a = 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]])
a

Out[31]:

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]])

想得到第一行的第 4 和第 5 两个元素：

In [32]:

a[0, 3:5]

Out[32]:

array([3, 4])

得到最后两行的最后两列：

In [33]:

a[4:, 4:]

Out[33]:

array([[44, 45],
       [54, 55]])

得到第三列：

In [34]:

a[:, 2]

Out[34]:

array([ 2, 12, 22, 32, 42, 52])

每一维都支持切片的规则，包括负索引，省略：

[lower:upper:step]

例如，取出3，5行的奇数列：

In [35]:

a[2::2, ::2]

Out[35]:

array([[20, 22, 24],
       [40, 42, 44]])

切片是引用

切片在内存中使用的是引用机制。

In [36]:

a = array([0,1,2,3,4])
b = a[2:4]
print b

[2 3]

引用机制意味着，Python并没有为 b 分配新的空间来存储它的值，而是让 b 指向了 a 所分配的内存空间，因此，改变 b 会改变 a 的值：

In [37]:

b[0] = 10
a

Out[37]:

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

而这种现象在列表中并不会出现：

In [38]:

a = [1,2,3,4,5]
b = a[2:3]
b[0] = 13234
print a

[1, 2, 3, 4, 5]

这样做的好处在于，对于很大的数组，不用大量复制多余的值，节约了空间。

缺点在于，可能出现改变一个值改变另一个值的情况。

一个解决方法是使用copy()方法产生一个复制，这个复制会申请新的内存：

In [39]:

a = array([0,1,2,3,4])
b = a[2:4].copy()
b[0] = 10
a

Out[39]:

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

花式索引

切片只能支持连续或者等间隔的切片操作，要想实现任意位置的操作，需要使用花式索引 fancy slicing 。

一维花式索引

与 range 函数类似，我们可以使用 arange 函数来产生等差数组。

In [40]:

a = arange(0, 80, 10)
a

Out[40]:

array([ 0, 10, 20, 30, 40, 50, 60, 70])

花式索引需要指定索引位置：

In [41]:

indices = [1, 2, -3]
y = a[indices]
print y

[10 20 50]

还可以使用布尔数组来花式索引：

In [42]:

mask = array([0,1,1,0,0,1,0,0],
            dtype=bool)

In [43]:

a[mask]

Out[43]:

array([10, 20, 50])

或者用布尔表达式生成 mask，选出了所有大于0.5的值：

In [44]:

from numpy.random import rand
a = rand(10)
a

Out[44]:

array([ 0.37214708,  0.48594733,  0.73365131,  0.15769295,  0.30786017,
        0.62068734,  0.36940654,  0.09424167,  0.53085308,  0.12248951])

In [45]:

mask = a > 0.5
a[mask]

Out[45]:

array([ 0.73365131,  0.62068734,  0.53085308])

mask 必须是布尔数组。

二维花式索引

In [46]:

a = 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]])
a

Out[46]:

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]])

对于二维花式索引，我们需要给定 row 和 col 的值：

In [47]:

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

Out[47]:

array([ 1, 12, 23, 34, 45])

返回的是一条次对角线上的5个值。

In [48]:

a[3:, [0,2,5]]

Out[48]:

array([[30, 32, 35],
       [40, 42, 45],
       [50, 52, 55]])

返回的是最后三行的第1，3，5列。

也可以使用mask进行索引：

In [49]:

mask = array([1,0,1,0,0,1],
            dtype=bool)
a[mask, 2]

Out[49]:

array([ 2, 22, 52])

与切片不同，花式索引返回的是原对象的一个复制而不是引用。

“不完全”索引

只给定行索引的时候，返回整行：

In [50]:

y = a[:3]
y

Out[50]:

array([[ 0,  1,  2,  3,  4,  5],
       [10, 11, 12, 13, 14, 15],
       [20, 21, 22, 23, 24, 25]])

这时候也可以使用花式索引取出第2，3，5行：

In [51]:

condition = array([0,1,1,0,1],
                 dtype=bool)
a[condition]

Out[51]:

array([[10, 11, 12, 13, 14, 15],
       [20, 21, 22, 23, 24, 25],
       [40, 41, 42, 43, 44, 45]])

三维花式索引

In [52]:

a = arange(64)
a.shape = 4,4,4
a

Out[52]:

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],
        [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, 63]]])

In [53]:

y = a[:,:,[2, -1]]
y

Out[53]:

array([[[ 2,  3],
        [ 6,  7],
        [10, 11],
        [14, 15]],

       [[18, 19],
        [22, 23],
        [26, 27],
        [30, 31]],

       [[34, 35],
        [38, 39],
        [42, 43],
        [46, 47]],

       [[50, 51],
        [54, 55],
        [58, 59],
        [62, 63]]])

where语句

where(array)

where 函数会返回所有非零元素的索引。

一维数组

先看一维的例子：

In [54]:

a = array([0, 12, 5, 20])

判断数组中的元素是不是大于10：

In [55]:

a > 10

Out[55]:

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

数组中所有大于10的元素的索引位置：

In [56]:

where(a > 10)

Out[56]:

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

注意到 where 的返回值是一个元组。

使用元组是由于 where 可以对多维数组使用，此时返回值就是多维的。

在使用的时候，我们可以这样：

In [57]:

indices = where(a > 10)
indices = indices[0]
indices

Out[57]:

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

或者：

In [58]:

indices = where(a>10)[0]
indices

Out[58]:

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

可以直接用 where 的返回值进行索引：

In [59]:

loc = where(a > 10)
a[loc]

Out[59]:

array([12, 20])

多维数组

考虑二维数组：

In [60]:

a = array([[0, 12, 5, 20],
           [1, 2, 11, 15]])
loc = where(a > 10)

返回结果是一个二维的元组，每一维代表这一维的索引值：

In [61]:

loc

Out[61]:

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

也可以直接用来索引a：

In [62]:

a[loc]

Out[62]:

array([12, 20, 11, 15])

或者可以这样：

In [63]:

rows, cols = where(a>10)

In [64]:

rows

Out[64]:

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

In [65]:

cols

Out[65]:

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

In [66]:

a[rows, cols]

Out[66]:

array([12, 20, 11, 15])

再看另一个例子：

In [67]:

a = arange(25)
a.shape = 5,5
a

Out[67]:

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, 24]])

In [68]:

a > 12

Out[68]:

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

In [69]:

where(a > 12)

Out[69]:

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

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

031.md

031.md

Numpy 数组及其索引

产生数组

数组属性

使用fill方法设定初始值

索引与切片

多维数组及其属性

多维数组索引

多维数组切片

切片是引用

花式索引

一维花式索引

二维花式索引

“不完全”索引

三维花式索引

where语句

一维数组

多维数组

Files

031.md

Latest commit

History

031.md

File metadata and controls

Numpy 数组及其索引

产生数组

数组属性

使用fill方法设定初始值

索引与切片

多维数组及其属性

多维数组索引

多维数组切片

切片是引用

花式索引

一维花式索引

二维花式索引

“不完全”索引

三维花式索引

where语句

一维数组

多维数组