数组
创建Numpy ndarray对象
numpy用于处理数组。numpy中的数组对象称为ndarray
我们可以使用array()函数创建一个numpy ndarray对象
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr)
print(type(arr))
[1 2 3 4 5]
<class 'numpy.ndarray'>
type():这个内置的Python函数告诉我们传递给它的对象的类型。像上面的代码一样，它表明arr是numpy ndarray类型。
要创建ndarray，我们可以将列表、元组或任何类似数组的对象传递给array()方法，然后它将被转换为ndarray：
#使用元组创建numpy数组：
arr = np.array((1, 2, 3, 4, 5))
print(arr)
[1 2 3 4 5]
数组中的维
数组中的维是数组深度（嵌套数组）的一个级别。
嵌套数组：指的是将数组作为元素的数组。
0-D数组
0-D数组，或标量（scalars），是数组中的元素。数组中的每个值都是一个0-D数组。
#用值61创建0-D数组：
arr = np.array(61)
print(arr)
61
1-D数组
其元素为0-D数组的数组，称为一维或1-D数组。
这是最常见和基础的数组。
#穿件包含值1、2、3、4、5、6的1-D数组：
arr = np.array([1, 2, 3, 4, 5, 6])
print(arr)
[1 2 3 4 5 6]
2-D数组
其元素为1-D数组的数组，称为2-D数组。
它们通常用于表示矩阵或二阶张量
numpy有一个专门用于矩阵运算的完整子模块 Numpy.mat
#创建包含值1、2、3和4、5、6两个数组的2-D数组：
arr = np.array([[1, 2, 3],[4, 5, 6]])
print(arr)
[[1 2 3]
[4 5 6]]
3-D数组
其元素为2-D数组的数组，称为3-D数组
#用两个2-D数组创建一个3-D数组，这两个数组均包含值1、2、3和4、5、6的两个数组：
arr = np.array([[[1, 2, 3],[4, 5, 6]],[[1, 2, 3],[4, 5, 6]]])
print(arr)
[[[1 2 3]
[4 5 6]]
[[1 2 3]
[4 5 6]]]
检查维度
numpy数组提供了ndim属性，该属性返回一个整数，该整数会告诉我们数组有多少维。
#检查数组有多少维：
a = np.array(42)
b = np.array([1, 2, 3, 4, 5])
c = np.array([[1, 2, 3],[4, 5, 6]])
d = np.array([[[1, 2, 3],[4, 5, 6]], [[1, 2, 3],[4, 5, 6]]])
print(a.ndim)
print(b.ndim)
print(c.ndim)
print(d.ndim)
0
1
2
3
更高维的数组
数组可以拥有任意数量的维。
在创建数组时，可以使用ndmin参数定义维数。
#创建一个有5个维度的数组，并验证它拥有5个维度：
arr = np.array([1, 2, 3, 4], ndmin = 5)
print(arr)
print('number of dimensions :', arr.ndim)
[[[[[1 2 3 4]]]]]
number of dimensions : 5
数组索引
访问数组元素
数组索引等同于访问数组元素。
可以通过引用其索引号来访问数组元素。
Numpy数组中的索引以0开头，这意味着第一个元素的索引为0，第二个元素的索引为1，以此类推。
arr = np.array([1, 2, 3, 4])
#获取第一个元素
print(arr[0])
#获取第二个元素
print(arr[1])
#获取第三和第四个元素并将其相加
print(arr[2] + arr[3])
1
2
7
访问2-D数组
要访问二维数组中的元素，我们可以使用逗号分隔的整数表示元素的维数和索引
arr = np.array([[1, 2, 3, 4, 5],[6, 7, 8, 9, 10]])
print(arr)
#访问第一维中的第二个元素
print('2nd element on lis dim: ',arr[0, 1])
#访问第二维中的第五个元素
print('5th element on 2nd dim: ',arr[1, 4])
[[ 1 2 3 4 5]
[ 6 7 8 9 10]]
2nd element on lis dim: 2
5th element on 2nd dim: 10
访问3-D数组
要访问3-D数组中的元素，我们可以使用逗号分割的整数来表示元素的维数和索引
arr = np.array([[[1, 2, 3], [4, 5, 6]],[[7, 8, 9], [10, 11, 12]]])
print(arr)
#访问第一个数组的第二个数组的第三个元素
print(arr[0, 1, 2])
[[[ 1 2 3]
[ 4 5 6]]
[[ 7 8 9]
[10 11 12]]]
6
负索引
使用负索引从尾开始访问数组。
arr = np.array([[1, 2, 3, 4, 5],[6, 7, 8, 9, 10]])
print(arr)
#打印第二个维中的最后一个元素
print('Last element from 2nd dim: ', arr[1, -1])
[[ 1 2 3 4 5]
[ 6 7 8 9 10]]
Last element from 2nd dim: 10
数组裁切
裁切数组
python中裁切的意思是将元素从一个给定的索引带到另一个给定的索引。
我们像这样传递切片而不是索引：[start: end]
我们还可以定义步长，如下所示：[start: end: step]
如果我们不传递start，则将其视为0
如果我们不传递end， 则视为该维度内数组的长度
如果我们不传递step，则视为1
arr = np.array([1, 2, 3, 4, 5, 6, 7])
#裁切索引1到索引5的元素
print(arr[1:5])
#裁切索引4到结尾的元素
print(arr[4:])
#裁切从开头到索引4（不包括）的元素
print(arr[:4])
[2 3 4 5]
[5 6 7]
[1 2 3 4]
负裁切
使用减号运算符从末尾开始引用索引：
arr = np.array([1, 2, 3, 4, 5, 6, 7])
#从末尾开始的索引3到末尾开始的索引1，对数组进行裁切
print(arr[-3: -1])
[5 6]
step
使用step值确定裁切的步长：
arr = np.array([1, 2, 3, 4, 5, 6, 7])
#从索引1到索引5，返回相隔的元素
print(arr[1: 5: 2])
#返回数组中相隔的元素
print(arr[::2])
[2 4]
[1 3 5 7]
裁切2-D数组
arr = np.array([[1, 2, 3, 4, 5],[6, 7, 8, 9, 10]])
print(arr)
#从第二个元素开始，对从索引1到索引4（不包括）的元素进行切片
print(arr[1, 1:4])
#从两个元素中返回索引2
print(arr[0:2, 2])
#从两个元素裁切索引1到索引4（不包括），这将返回一个2-D数组
print(arr[0:2, 1:4])
[[ 1 2 3 4 5]
[ 6 7 8 9 10]]
[7 8 9]
[3 8]
[[2 3 4]
[7 8 9]]
数据类型
numpy数据类型
python中的数据类型
默认情况下，python拥有以下数据类型：
strings - 用于表示文本数据，文本用引号引起来。入了“ABCD”
integer - 用于表示整数。例如-1，-2，-3
float - 用于表示实数。例如1.2,42.42
Boolean - 用于表示True或False
complex - 用于表示复平面中的数字。例如1.0 + 2.0j， 1.5+2.5j
numpy中的数据类型
numpy有一些额外的数据类型，并通过一个字符引用数据类型，例如i代表整数，u代表无符号整数等
以下是numpy中所有数据类型的列表以及用于表示他们的字符
i - 整数 b - 布尔 u - 无符号整数 f - 浮点
c - 复合浮点数 m - timedaita M - datetime O - 对象
S - 字符串 U - unicode 字符串 V - 固定的其他类型的内存块（void）
检查数组的数据类型
numpy数组对象有一个名为dtype的属性，该属性返回数组的数据类型：
import numpy as np
arr = np.array([1, 2, 3, 4])
print(arr.dtype)
int32
arr = np.array(['apple', 'banana', 'cherry'])
print(arr.dtype)
<U6
用已定义的数据类型创建数组
我们使用array()函数来创建数组，该函数可以使用可选参数：dtype，它允许我们定义数组元素的预期数据类型：
arr = np.array([1, 2, 3, 4], dtype='S')
print(arr)
print(arr.dtype)
[b'1' b'2' b'3' b'4']
|S1
#创建数据类型为4字节整数的数组
arr = np.array([1, 2, 3, 4], dtype='i4')
print(arr)
print(arr.dtype)
[1 2 3 4]
int32
假如值无法转换会怎样？
arr = np.array(['a', '2', '3'], dtype = 'i')
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-21-7ac2a87e7a72> in <module>
----> 1 arr = np.array(['a', '2', '3'], dtype = 'i')
ValueError: invalid literal for int() with base 10: 'a'
转换已有数组的数据类型
更改现有数组的数据类型的最佳方法，是使用astype()方法复制该数组
astype()函数创建数组的副本，并允许将数据类型指定位为参数
数据类型可以使用字符串指定，例如‘f’代表浮点数，‘i’代表整数等，或者可以直接使用数据类型，例如float表示浮点数，int表示整数。
#通过使用‘i’作为参数值，将数据类型从浮点数更改为整数
arr = np.array([1.1, 2.1, 3.1])
newarr = arr.astype('i')
print(newarr)
print(newarr.dtype)
[1 2 3]
int32
#通过使用int作为参数值，将数据类型从浮点数更改为整数
arr = np.array([1.1, 2.1, 3.1])
newarr = arr.astype(int)
print(newarr)
print(newarr.dtype)
[1 2 3]
int32
#将数据类型从整形更改为布尔值
arr = np.array([1, 0, 3])
newarr = arr.astype(bool)
print(newarr)
print(newarr.dtype)
[ True False True]
bool
numpy数组副本 vs 视图
副本和视图之间的区别
副本和数组视图之间的主要区别在于副本是一个新数组，而这个视图只是原始数组的视图
副本拥有数据，对副本所做的任何更改都不会影响原始数组，对原始数组所做的任何更改也不会影响副本
视图不拥有数据，对视图所做的任何更改都会影响原始数组，而对原始数组所做的任何更改都会影响视图·
副本
arr = np.array([1, 2, 3, 4, 5])
x = arr.copy()
arr[0] = 61
print(arr)
print(x)
[61 2 3 4 5]
[1 2 3 4 5]
视图
aarr = np.array([1, 2, 3, 4, 5])
x = arr.view()
arr[0]=61
print(arr)
print(x)
[61 2 3 4 5]
[61 2 3 4 5]
arr = np.array([1, 2, 3, 4, 5])
x = arr.view()
x[0]=31
print(arr)
print(x)
[31 2 3 4 5]
[31 2 3 4 5]
检查数组是否拥有数据
如上所述，副本拥有数据，而视图不拥有数据，但是我们如何检查呢？
每个numpy数组都有一个属性base，如果该数组拥有数据，则这个base属性返回None
否则，base属性将引用原始对象。
arr = np.array([1, 2, 3, 4, 5])
x = arr.copy()
y = arr.view()
print(x.base)
print(y.base)
print(arr.base)
None
[1 2 3 4 5]
None
数组形状
numpy数组形状
数组的形状
数组的形状是每个维中元素的数量
获取数组的形状
numpy数组有一个名为shape的属性，该属性返回一个元组，每个索引具有相应元素的数量
import numpy as np
arr = np.array([[1, 2, 3, 4],[5, 6, 7, 8], [5, 6, 7, 8]])
print(arr.shape)
#返回（3， 4），这意味着该数组有2个维， 每个维有4个元素
(3, 4)
#利用ndmin使用值1,2,3,4的向量创建有5个维度的数组，并验证最后一个维度的值为4
arr = np.array([1, 2, 3, 4], ndmin=5)
print(arr)
print('shape of array :', arr.shape)
[[[[[1 2 3 4]]]]]
shape of array : (1, 1, 1, 1, 4)
numpy数组重塑
数组重塑
重塑意味着更改数组的形状
数组的形状是每个维中的元素的数量
通过重塑，我们可以添加或者删除维度或者更改每个维度中的元素的数量
从1-D重塑为2-D
# 将以下具有12个元素的1-D数组转换为2-D数组
import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
newarr = arr.reshape(4, 3)
print(arr.shape)
print(newarr)
(12,)
[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]]
从1-D重塑为3-D
#将以下具有12个元素的1-D数组转换为3-D数组
newarr = arr.reshape(2, 3, 2)
print(newarr)
print(newarr.shape)
[[[ 1 2]
[ 3 4]
[ 5 6]]
[[ 7 8]
[ 9 10]
[11 12]]]
(2, 3, 2)
可以重塑成任何形状吗？
是的，只要重塑所需的元素在两种形状中均相等。
我们可以将8元素的1D数组重塑为2行2D数组中的4个元素，但不能将其重塑为3元素3行2D数组
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
newarr = arr.reshape(3, 3)
print(newarr)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-33-428f107e9370> in <module>
1 arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
2
----> 3 newarr = arr.reshape(3, 3)
4
5 print(newarr)
ValueError: cannot reshape array of size 8 into shape (3,3)
返回副本还是视图？
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
print(arr.reshape(2, 4).base)
#从上面的例子返回原始数组，因此它是一个视图
[1 2 3 4 5 6 7 8]
未知的维
可以使用一个“未知”的维度
这意味着不必在reshape方法中为维度之一指定确切的数字
传递-1作为值，Numpy将计算该数字
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
newarr = arr.reshape(2, 2, -1)
print(newarr)
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]
展平数组
展平数组(flattening the arrays)是指将多维数组转换为1D数组
我们可以使用reshape(-1)来做到这一点
arr = np.array([[1, 2, 3], [4, 5, 6]])
newarr = arr.reshape(-1)
print(newarr)
[1 2 3 4 5 6]
数组操作
numpy数组迭代
数组迭代
迭代意味着逐一遍历元素
当我们在numpy中处理多维数组时，可以使用python的基本for循环来完成此操作
如果我们对1-D数组进行迭代，它将逐一遍历每个元素
import numpy as np
arr = np.array([1, 2, 3])
for x in arr:
print(x)
1
2
3
迭代2-D数组
在2-D数组中，它将遍历所有的行
arr = np.array([[1, 2, 3], [4, 5, 6]])
for x in arr:
print(x)
#如果我们迭代一个n-D数组，它将逐一遍历第n-1维
[1 2 3]
[4 5 6]
#如需返回实际值、标量，我们必须迭代每个维中的数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
for x in arr:
for y in x:
print(y)
1
2
3
4
5
6
迭代3-D数组
在3-D数组中，它将遍历所有2-D数组
#要返回实际值、标量，我们必须迭代每个维中的数组
arr = np.array([[[1, 2, 3], [4, 5, 6]],[[7, 8, 9], [10, 11, 12]]])
for x in arr:
for y in x:
for z in y:
print(z)
1
2
3
4
5
6
7
8
9
10
11
12
使用nditer()迭代数组
函数nditer()是一个辅助函数，从非常基本的迭代到非常高级的迭代都可以使用。它解决了我们在迭代中面临的一些基本问题
迭代每个标量元素
在基本的for循环中，迭代遍历数组的每个标量，我们需要使用n个for循环，对于具有高维数的数组可能很难编写
arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
for x in np.nditer(arr):
print(x)
1
2
3
4
5
6
7
8
迭代不同数据类型的数组
可以使用op_dtypes参数，并传递期望的数据类型，以在迭代时更改元素的数据类型
numpy不会就地更改元素的数据类型（元素位于数组中），因此它需要一些其他空间来执行此操作，该额外空间称为buffer，为了在nditer()中启用它，我们传参flags=[‘buffered’]
arr = np.array([1, 2, 3])
for x in np.nditer(arr, flags=['buffered'], op_dtypes=['S']):
print(x)
b'1'
b'2'
b'3'
以不同的步长迭代
#每遍历2D数组的一个标量元素，跳过1个元素
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
for x in np.nditer(arr[:,::2]):
print(x)
1
3
5
7
使用ndenumerate()进行枚举迭代
枚举是指逐一提及事物的序号
有时，我们在迭代时需要元素的相应的索引，对于这些用例，可以使用ndenumerate()方法
arr = np.array([1, 2, 3])
for idx, x in np.ndenumerate(arr):
print(idx, x)
(0,) 1
(1,) 2
(2,) 3
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
for idx, x in np.ndenumerate(arr):
print(idx, x)
(0, 0) 1
(0, 1) 2
(0, 2) 3
(0, 3) 4
(1, 0) 5
(1, 1) 6
(1, 2) 7
(1, 3) 8
numpy数组连接
连接numpy数组
连接意味着将两个或多个数组的内容放在单个数组中
在SQL中，我们给予键来连接表。而在Numpy中，我们按轴连接数组
我们传递了一系列要与轴连接到concatenate()函数的数组。如果未显式传递轴，则将其视为0
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])
arr = np.concatenate((arr1, arr2))
print(arr, arr.shape)
[[1 2]
[3 4]
[5 6]
[7 8]] (4, 2)
#沿着行（axis=1）连接两个2-D数组
arr = np.concatenate((arr1, arr2), axis=1)
print(arr, arr.shape)
[[1 2 5 6]
[3 4 7 8]] (2, 4)
使用堆栈函数连接数组
堆栈与级联相同，唯一的不同是堆栈是沿着新轴完成的
我们可以沿着第二个轴连接两个一维数组，这将导致他们彼此重叠，即，堆叠（stacking） .
我们传递了一系列要与轴一起连接到concatenate()方法的数组。如果未显式传递轴，则将其视为0
arr = np.stack((arr1, arr2), axis=0)
print(arr, arr.shape)
[[[1 2]
[3 4]]
[[5 6]
[7 8]]] (2, 2, 2)
arr = np.stack((arr1, arr2), axis=1)
print(arr, arr.shape)
[[[1 2]
[5 6]]
[[3 4]
[7 8]]] (2, 2, 2)
沿行堆叠
numpy提供了一个辅助函数：hstack()沿行堆叠
arr = np.hstack((arr1, arr2))
print(arr, arr.shape)
[[1 2 5 6]
[3 4 7 8]] (2, 4)
沿列堆叠
arr = np.vstack((arr1, arr2))
print(arr, arr.shape)
[[1 2]
[3 4]
[5 6]
[7 8]] (4, 2)
沿高度堆叠（深度）
arr = np.dstack((arr1, arr2))
print(arr, arr.shape)
[[[1 5]
[2 6]]
[[3 7]
[4 8]]] (2, 2, 2)
Numpy数组拆分
拆分numpy数组
拆分是连接的反向操作
连接（joining）是将多个数组合并成一个，拆分（spliting）将一个数组拆分为多个
我们使用array_split()分割数组，将要分割的数组和分割数传递给它
arr = np.array([1, 2, 3, 4, 5, 6])
newarr = np.array_split(arr, 3)
print(newarr)
#返回值是一个包含三个数组的数组
[array([1, 2]), array([3, 4]), array([5, 6])]
arr = np.array([1, 2, 3, 4, 5, 6])
newarr = np.array_split(arr, 4)
print(newarr)
[array([1, 2]), array([3, 4]), array([5]), array([6])]
newarr = np.split(arr, 3)
print(newarr)
[array([1, 2]), array([3, 4]), array([5, 6])]
newarr = np.split(arr, 4)
print(newarr)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
D:\anaconda\envs\python36\lib\site-packages\numpy\lib\shape_base.py in split(ary, indices_or_sections, axis)
866 try:
--> 867 len(indices_or_sections)
868 except TypeError:
TypeError: object of type 'int' has no len()
During handling of the above exception, another exception occurred:
ValueError Traceback (most recent call last)
<ipython-input-56-cf3072ca747d> in <module>
----> 1 newarr = np.split(arr, 4)
2
3 print(newarr)
<__array_function__ internals> in split(*args, **kwargs)
D:\anaconda\envs\python36\lib\site-packages\numpy\lib\shape_base.py in split(ary, indices_or_sections, axis)
871 if N % sections:
872 raise ValueError(
--> 873 'array split does not result in an equal division')
874 return array_split(ary, indices_or_sections, axis)
875
ValueError: array split does not result in an equal division
分割二维数组
拆分二维数组时，请使用相同的语法
使用array_split()方法，传入要分割的数组和想要分割的数目
arr = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]])
print(arr.shape)
newarr = np.array_split(arr, 3)
print(newarr)
(6, 2)
[array([[1, 2],
[3, 4]]), array([[5, 6],
[7, 8]]), array([[ 9, 10],
[11, 12]])]
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]])
print(arr.shape)
newarr = np.array_split(arr, 3)
print(newarr)
(6, 3)
[array([[1, 2, 3],
[4, 5, 6]]), array([[ 7, 8, 9],
[10, 11, 12]]), array([[13, 14, 15],
[16, 17, 18]])]
# print(arr)
newarr = np.array_split(arr, 3, axis=1)
print(newarr)
[array([[ 1],
[ 4],
[ 7],
[10],
[13],
[16]]), array([[ 2],
[ 5],
[ 8],
[11],
[14],
[17]]), array([[ 3],
[ 6],
[ 9],
[12],
[15],
[18]])]
#另一种解决方案是使用与hstack()相反的hsplit()
newarr = np.hsplit(arr, 3)
print(newarr)
[array([[ 1],
[ 4],
[ 7],
[10],
[13],
[16]]), array([[ 2],
[ 5],
[ 8],
[11],
[14],
[17]]), array([[ 3],
[ 6],
[ 9],
[12],
[15],
[18]])]
numpy数组搜索
搜索数组
可以在数组中搜索（检索）某个值， 然后返回获得匹配的索引
要搜索数组，应使用where()方法
arr = np.array([1, 2, 3, 4, 5, 4, 4])
x = np.where(arr == 4)
print(x)
#输出的是4的位置
(array([3, 5, 6], dtype=int64),)
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
x = np.where(arr%2 == 0)
print(x)
#输出的是偶数的索引
(array([1, 3, 5, 7], dtype=int64),)
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
x = np.where(arr%2 == 1)
print(x)
#输出的是奇数的位置
(array([0, 2, 4, 6], dtype=int64),)
搜索排序
注意：已经排序好了！
有一个名为searchsorted()的方法，该方法在数组中执行二进制搜索，并返回将在其中指定值以维持搜素顺序的索引
假定searchsorted（）方法用于排序数组
left
a[i-1] < v <= a[i]
right
a[i-1] <= v < a[i]
#该方法从左侧开始搜索，并返回第一个索引，其中数字9不再大于下一个值
arr = np.array([6, 8, 9, 15])
x = np.searchsorted(arr, 9)
print(x)
2
#从右侧开始搜索，并返回第一个索引，其中数字9不再小于下一个值
arr = np.array([6, 8, 9, 15])
x = np.searchsorted(arr, 9, side='right')
print(x)
3
#从右侧开始搜索，并返回第一个索引，其中数字9不再小于下一个值
arr = np.array([6, 8, 9, 10, 14, 15])
x = np.searchsorted(arr, 12, side='right')
print(x)
4
#从右侧开始搜索，并返回第一个索引，其中数字9不再小于下一个值
arr = np.array([6, 8, 9, 10, 14, 15])
x = np.searchsorted(arr, 12)
print(x)
4
多个值
要搜索多个值，应使用拥有指定值的数组(输出的一直是索引！）
arr = np.array([1, 3, 5, 7])
x = np.searchsorted(arr, [2, 4, 6])
print(x)
[1 2 3]
numpy数组排序
数组排序
排序是指将元素按有序顺序排列。
有序序列是拥有与元素相对应的顺序的任何序列，例如数字或字母、升序或降序
Numpy ndarray 对象有一个名为sort()的函数，该函数将对指定的数组进行排序。
arr = np.array([3, 2, 0, 1])
print(np.sort(arr))
[0 1 2 3]
arr = np.array(['banana', 'cherry', 'apple'])
print(np.sort(arr))
['apple' 'banana' 'cherry']
arr = np.array([True, False, True])
print(np.sort(arr))
[False True True]
对2-D数组排序
如果在二维数组上使用sort()方法，则将对两个数组进行排序：(注意只对最后一个维度进行排序！)
arr = np.array([[3, 2, 4], [5, 0, 1]])
print(np.sort(arr))
[[2 3 4]
[0 1 5]]
Numpy数组过滤
数组过滤
从现有数组中取出一些元素并从中创建新数组称为过滤（filtering）
在numpy中，我们使用布尔索引列表来过滤数组
布尔索引列表是与数组中的索引相对应的布尔值列表
如果索引处的值为True,则该元素包含在过滤后的数组中；如果索引处的值为False，则该元素将从过滤后的数组中排除。
arr = np.array([61, 62, 63, 64, 65])
x =[True, False, True, False, True]
newarr = arr[x]
print(newarr)
[61 63 65]
创建过滤器数组
在上例子中，我们对True和False值进行了硬编码，但通常的用途是根据条件创建过滤器数组。
#创建一个仅返回大于62的值的过滤器数组
arr = np.array([61, 62, 63, 64, 65])
#创建一个空列表
filter_arr = []
#遍历arr中的每个元素
for element in arr:
#如果元素大于62，则将值设置为True，否则为False
if element > 62:
filter_arr.append(True)
else:
filter_arr.append(False)
newarr = arr[filter_arr]
print(filter_arr)
print(newarr)
[False, False, True, True, True]
[63 64 65]
#创建一个过滤器数组，该数组仅返回原始数组中的偶数元素
arr = np.array([1, 2, 3, 4, 5, 6, 7])
#创建一个空列表
filter_arr = []
#遍历arr中的每个元素
for element in arr:
#如果元素可以被2整除，则将值设置为True，否则为False
if element % 2 == 0:
filter_arr.append(True)
else:
filter_arr.append(False)
newarr = arr[filter_arr]
print(filter_arr)
print(newarr)
[False, True, False, True, False, True, False]
[2 4 6]
直接从数组创建过滤器
上例是numpy中非常常见的任务，numpy提供了解决该问题的好方法
我们可以在条件中直接替换数组而不是ilterable变量，它会如我们期望的那样工作。
arr = np.array([61, 62, 63, 64, 65])
filter_arr = arr > 62
newarr = arr[filter_arr]
print(filter_arr)
print(newarr)
[False False True True True]
[63 64 65]
arr = np.array([1, 2, 3, 4, 5, 6, 7])
filter_arr = arr % 2 == 0
newarr = arr[filter_arr]
print(filter_arr)
print(newarr)
[False True False True False True False]
[2 4 6]
862
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
