Numpy笔记2

##numpy笔记2

#切片和索引

#基本切片是 Python 中基本切片概念到 n 维的扩展。
#通过将start，stop和step参数提供给内置的slice函数来构造一个 Python slice对象。
#此slice对象被传递给数组来提取数组的一部分。

import numpy as np
a = np.arange(10)
s = slice(2,7,2)
print(a[s])

#输出
#[2 4 6]

#在上面的例子中，ndarray对象由arange()函数创建。 然后，分别用起始，终止和步长值2，7和2定义切片对象。
#当这个切片对象传递给ndarray时，会对它的一部分进行切片，从索引2到7，步长为2。
#通过将由冒号分隔的切片参数(start:stop:step)直接提供给ndarray对象，也可以获得相同的结果。

a = np.arange(10)
b = a[2:7:2]
print(b)

#输出
#[2 4 6]

#如果只输入一个参数，则将返回与索引对应的单个项目。 如果使用a:，则从该索引向后的所有项目将被提取。
#如果使用两个参数(以:分隔)，则对两个索引(不包括停止索引)之间的元素以默认步骤进行切片。
a = np.arange(10)
b = a[5]
print(b)

#输出
#5

a = np.arange(10)
print(a[2:])

#输出
#[2 3 4 5 6 7 8 9]

a = np.arange(10)
print(a[2:5])

#输出
#[2 3 4]

#上面的描述也可用于多维ndarray

a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a)
对始于索引的元素进行切片
print(‘现在我们从索引 a[1:] 开始对数组切片’)
print(a[1:])

#输出
#[[1 2 3]
#[3 4 5]
#[4 5 6]]

#现在我们从索引 a[1:] 开始对数组切片
#[[3 4 5]
#[4 5 6]]

#切片还可以包括省略号(…)，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的ndarray。

a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(‘我们的数组是：’)
print(a)

#这会返回第二列元素的数组：
print(‘第二列的元素是：’)
print(a[…,1] )

现在我们从第二行切片所有元素：
print(‘第二行的元素是：’)
print(a[1,…])

现在我们从第二列向后切片所有元素：
print(‘第二列及其剩余元素是：’)
print(a[…,1:])

#输出
#我们的数组是：
#[[1 2 3]
#[3 4 5]
#[4 5 6]]

#第二列的元素是：
#[2 4 5]

#第二行的元素是：
#[3 4 5]

#第二列及其剩余元素是：
#[[2 3]
#[4 5]
[5 6]]

#高级索引

#整数索引
#这种机制有助于基于 N 维索引来获取数组中任意元素。 每个整数数组表示该维度的下标值。 当索引的元素个数就是目标ndarray的维度时，会变得相当直接。
#以下示例获取了ndarray对象中每一行指定列的一个元素。 因此，行索引包含所有行号，列索引指定要选择的元素。

x = np.array([[1, 2], [3, 4], [5, 6]])
y = x[[0,1,2], [0,1,0]]
print(y)

#输出
#[1 4 5]

#该结果包括数组中(0,0)，(1,1)和(2,0)位置处的元素。

#下面的示例获取了 4X3 数组中的每个角处的元素。 行索引是[0,0]和[3,3]，而列索引是[0,2]和[0,2]。
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print(‘我们的数组是：’)
print(x)

rows = np.array([[0,0],[3,3]])
cols = np.array([[0,2],[0,2]])
y = x[rows,cols]
print ‘这个数组的每个角处的元素是：’
print(y)

#输出
#我们的数组是：
#[[ 0 1 2]
#[ 3 4 5]
#[ 6 7 8]
#[ 9 10 11]]

#这个数组的每个角处的元素是：
#[[ 0 2]
#[ 9 11]]

#返回的结果是包含每个角元素的ndarray对象。
#高级和基本索引可以通过使用切片:或省略号…与索引数组组合。 以下示例使用slice作为列索引和高级索引。
#当切片用于两者时，结果是相同的。 但高级索引会导致复制，并且可能有不同的内存布局。

x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print(‘我们的数组是：’)
print(x)

切片
z = x[1:4,1:3]
print(‘切片之后，我们的数组变为：’)
print(z)

对列使用高级索引
y = x[1:4,[1,2]]
print(‘对列使用高级索引来切片：’)
print(y)

#输出
#我们的数组是：
#[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]

#切片之后，我们的数组变为：
#[[ 4 5]
[ 7 8]
[10 11]]

#对列使用高级索引来切片：
#[[ 4 5]
[ 7 8]
[10 11]]

#布尔索引

#当结果对象是布尔运算(例如比较运算符)的结果时，将使用此类型的高级索引。

#这个例子中，大于 5 的元素会作为布尔索引的结果返回。

x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print(‘我们的数组是：’)
print(x)

现在我们会打印出大于 5 的元素
print(‘大于 5 的元素是：’)
print(x[x > 5])

#输出
#我们的数组是：
#[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]

#大于 5 的元素是：
#[ 6 7 8 9 10 11]

#这个例子使用了~(取补运算符)来过滤NaN。

a = np.array([np.nan, 1,2,np.nan,3,4,5])
print(a[~np.isnan(a)])

#输出
#[ 1. 2. 3. 4. 5.]