NumPy学习
什么是NumPy?
- NumPy是一个用于处理数组的Python库。
- 它也有在线性代数、傅里叶变换和矩阵领域工作的功能。
- NumPy是Numerical Python的缩写。
为什么使用NumPy?
- 在Python中,我们有列表,可以达到数组的目的,但它们的处理速度很慢
- NumPy旨在提供一个数组对象,它比传统的Python列表快50倍
- NumPy中的数组对象被称为ndarray,它提供了很多支持性的函数,使得使用ndarray非常容易
- 数组在数据科学中使用得非常频繁,速度和资源都非常重要
为什么NumPy比列表快?
- 与列表不同,NumPy的数组被存储在内存中的一个连续位置,所以进程可以非常有效地访问和操作它们
- 这种行为在计算机科学中被称为引用的位置性
- 这就是NumPy比列表快的主要原因。此外,它还被优化以适用于最新的CPU架构
NumPy是用哪种语言编写的?
NumPy是一个Python库,部分是用Python编写的,但大部分需要快速计算的部分是用C或C++编写的
NumPy的代码库地址
NumPy的源代码位于这个github仓库
https://github.com/numpy/numpy
基础知识
数组
创建NumPy ndarray对象
NumPy用于处理数组,NumPy中的数组对象称为ndarray
我们可以使用array()函数创建一个NumPy ndarray对象
# 引入NumPy
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数组
# 列表(list)
a = [5, 5, 5, 5, 5, 5]
b = [5] * 6
# ndarray对象
arr = np.array([5] * 6)
print(a)
print(b)
print(arr)
print(type(a))
print(type(b))
print(type(arr))
[5, 5, 5, 5, 5, 5]
[5, 5, 5, 5, 5, 5]
[5 5 5 5 5 5]
<class 'list'>
<class 'list'>
<class 'numpy.ndarray'>
# 使用元组创建NumPy数组
# 元组(tuple)
a = (1, 2, 3, 4, 5)
# ndarray对象
arr = np.array((1, 2, 3, 4, 5))
print(a)
print(arr)
print(type(a))
print(type(arr))
(1, 2, 3, 4, 5)
[1 2 3 4 5]
<class 'tuple'>
<class 'numpy.ndarray'>
数组中的维
数组中的维是数组深度(嵌套数组)的一个级别
嵌套数组:指的是将数组作为元组的数组
0-D数组
0-D数组,或标量(Scalars),是数组中的元素,数组中的每个值都是一个0-D数组
1-D数组
其元素为0-D数组的数组,称为一维或1-D数组
这是常见和基础的数组
# 用值61创建0-D数组
arr = np.array(61)
print(arr)
61
# 创建包含值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
arr = np.array([[1], [2], [3], [4]])
# 获取第一个元素
print(arr[0])
# 获取第二个元素
print(arr[1])
# 获取第三个和第四个元素并将其加和
print(arr[2] + arr[3])
[1]
[2]
[7]
访问2-D数组
要访问二维数组中的元素,我们可以使用逗号分隔的整数表示元素的维数和的索引
访问3-D数组
要访问3-D数组中的元素,我们可以使用逗号分隔的整数来表示元素的维数和索引
arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
print(arr)
# 访问第一个数组中的第二个元素
print('2nd element on 1st dim:', arr[0, 1])
# 访问第二个数组中的第五个元素
print('5nd element on 2nd dim:', arr[1, 4])
[[ 1 2 3 4 5]
[ 6 7 8 9 10]]
2nd element on 1st dim: 2
5nd element on 2nd dim: 10
# 访问第一个数组的第二个数组的第三个元素
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🔚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 6]
[5 6 7]
[1 2 3 4]
负裁切
使用减号运算符从末尾开始的索引
arr = np.array([1, 2, 3, 4, 5, 6, 7])
# 从末尾开始的索引3到末尾开始的索引1(包括索引1),对数组进行裁切
print(arr[-3:])
[5 6 7]
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]])
# 从第二个元素开始,对从索引1到索引4(不包括)的元素进行切片
print(arr[1, 1:4])
# 从两个元素中返回索引2 !!!!注意与下面的2-D数组区分
print(arr[0:2, 2])
# 从两个元素裁切索引1到索引4(不包括),这将返回一个2-D数组
print(arr[0:2, 1:4])
[7 8 9]
[3 8]
[[2 3 4]
[7 8 9]]
数据类型
Python中的数据类型
默认情况下,Python拥有以下数据类型:
- strings - 用于表示文本数据,文本用引号引起来,例如:“ABCD”
- integer - 用于表示整数,例如;-1,-2,-3
- float - 用于表示实数,例如:1.2,42.1
- boolean - 用于表示True或False
- complex - 用于表示复平面中的数字,例如:1.0+2.0j,1.5+2.5j
NumPy中的数据类型
NumPy中有一些额外的数据类型,并通过一个字符引用数据类型,例如i代表整数,u代表无符号整数等
以下是NumPy中所有数据类型的列表以及用于表示它们的字符
字符 | 数据类型 | 字符 | 数据类型 | 字符 | 数据类型 |
---|---|---|---|---|---|
i | 整数 | c | 复合浮点数 | S | (byte-)字符串 |
b | 布尔 | m | timedelta | U | unicode字符串 |
u | 无符号整数 | M | datatime | V | 固定的其他类型的内存块(void) |
f | 浮点 | O | 对象 | - | - |
检查数组的数据类型
Numpy数组对象有一个名为dtype的属性,该属性返回数组的数据类型
arr = np.array([1,2,3,4])
print(arr.dtype)
arr1 = np.array(['apple','banana','cherry'])
print(arr1)
print(arr1.dtype)
int32
['apple' 'banana' 'cherry']
<U6
用已定义的数据类型创建数组
我们使用array()函数来创建数组,该函数可以使用可选参数:dtype,它允许我们定义数组元素的预期数据类型
# 创建数据类型为(byte)字符串类型的数组
arr = np.array([1,2,3,4],dtype='S')
print(arr)
print(arr.dtype)
# 创建数据类型为4字节的整数的数组
arr1=np.array([1,2,3,4],dtype='i4')
print(arr1)
print(arr1.dtype)
[b'1' b'2' b'3' b'4']
|S1
[1 2 3 4]
int32
假如值无法转换会怎么样?
如果给出了不能强制转换元素的类型,则Numpy将引发ValueError
ValueError:在Python中,如果传递给函数的参数的类型是非预期或错误的,则会引发ValueError
arr = np.array(['a','2','3'],dtype='i')
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
Cell In[29], line 1
----> 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)
# 通过使用int作为参数值,将数据类型从浮点数更改为整数
arr1=np.array([1.1,2.1,3.1])
newarr1=arr1.astype(int)
print(newarr1)
print(newarr1.dtype)
[1 2 3]
int32
[1 2 3]
int32
NumPy数组副本 VS 视图
副本和视图之间的区别
- 副本和数据视图之间的主要区别在于副本是一个新数组,而这个视图只是原始数组的视图
- 副本拥有数据,对副本所做的任何更改都不会影响原始数组,对原始数组所做的任何更改也不会影响副本
- 视图不拥有数据,对视图所做的任何更改都会影响原始数据,而对原始数组所做的任何更改都会影响视图
副本
视图
arr=np.array([1,2,3,4,5])
x=arr.copy()
arr[0] =61
print(arr)
print(x)
x[0]=31
print(arr)
print(x)
[61 2 3 4 5]
[1 2 3 4 5]
[61 2 3 4 5]
[31 2 3 4 5]
arr=np.array([1,2,3,4,5])
x=arr.view()
arr[0] =61
print(arr)
print(x)
x[0]=31
print(arr)
print(x)
[61 2 3 4 5]
[61 2 3 4 5]
[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的属性,该属性返回一个元组,这个元组的长度就是维度的数目,即 ndim 属性(秩)。比如,一个二维数组,其维度表示"行数"和"列数"。
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
# 返回(3,4),这意味着该数组有2个维,第一维度有3个元素,第二维度有4个元素
print(arr.shape)
# 利用ndmin使用值1,2,3,4的向量创建有5个维度的数组,并验证最后一个维度有4个元素
arr1 = np.array([1, 2, 3, 4], ndmin=5)
print(arr1)
print(arr1.shape)
(3, 4)
[[[[[1 2 3 4]]]]]
(1, 1, 1, 1, 4)
NumPy数组重塑
数组重塑
重塑意味着更改数组的形状
数组的形状是每个维中元素的数量
通过重塑,我们可以添加或删除维度或更改每个维度中元素的数量
从1-D重塑为2-D
从1-D重塑为3-D
# 将以下具有12个元素的1-D数组装换为2-D数组
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)
print(newarr.shape)
(12,)
[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]]
(4, 3)
# 将以下具有12个元素的1-D数组装换为3-D数组
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
newarr = arr.reshape(2, 2, 3)
print(arr.shape)
print(newarr)
print(newarr.shape)
(12,)
[[[ 1 2 3]
[ 4 5 6]]
[[ 7 8 9]
[10 11 12]]]
(2, 2, 3)
我们可以重塑成任何形状吗?
是的,只要重塑所需的元素数量在两种形状中均相等
我们可以将8个元素1-D数组重塑为2行4个元素的2-D数组,但是我们不能将其重塑为3行3个元素2-D数组
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
newarr = arr.reshape(3, 3)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
Cell In[48], line 2
1 arr=np.array([1,2,3,4,5,6,7,8])
----> 2 newarr=arr.reshape(3,3)
ValueError: cannot reshape array of size 8 into shape (3,3)
返回副本还是视图?
重塑后的数组是原始数组的一个视图
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
newarr = arr.reshape(2, 4)
print(arr)
print(newarr)
print(newarr.base)
# 返回的是原始数组,因此重塑后的数组是一个视图
[1 2 3 4 5 6 7 8]
[[1 2 3 4]
[5 6 7 8]]
[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)
print(newarr.shape)
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]
(2, 2, 2)
展平数组
展平数组(Flattening the arrays)是指将多维数组装换为1-D数组
我们可以使用reshape(-1)来做到这一点
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
newarr = arr.reshape(-1)
print(newarr)
[1 2 3 4 5 6 7 8]
操作(迭代、连接、拆分、搜索、排序、过滤)
NumPy数组迭代
数组迭代
迭代意味着逐一遍历元素
当我们在NumPy中处理多维数组时,可以使用Python的基本for循环来完成此操作
如果我们对1-D数组进行迭代,他将逐一遍历每个元素
arr=np.array([1,2,3])
for x in arr:
print(x)
1
2
3
迭代2-D数组
在2-D数组中,他将遍历所有行
# 如果我们迭代一个n-D数组,它将逐一遍历第n-1维
arr=np.array([[1,2,3],[4,5,6]])
for x in arr:
print(x)
# 如需返回实际值,标量,我们必须迭代每个维中的数组
arr1=np.array([[1,2,3],[4,5,6]])
for x in arr1:
for y in x:
print(y)
[1 2 3]
[4 5 6]
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'
以不同的步长迭代
我们可以使用过滤,然后进行迭代
# 每遍历2-D数组的一个标量元素,跳过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)
arr1=np.array([[1,2,3,4],[5,6,7,8]])
for idx,x in np.ndenumerate(arr1):
print(idx,x)
(0,) 1
(1,) 2
(2,) 3
(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中,我们按轴连接数组
numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组
我们传递了一系列要与轴一起连接到concatenate()函数的数组。如果未显示传递轴,则将其视为0
# 沿着列(axis=0)连接两个2-D数组
arr1=np.array([[1,2],[3,4]])
arr2=np.array([[5,6],[7,8]])
arr=np.concatenate((arr1,arr2))
print(arr,arr.shape)
# 沿着行(axis=1)连接两个2-D数组
arr3=np.array([[1,2],[3,4]])
arr4=np.array([[5,6],[7,8]])
arr=np.concatenate((arr3,arr4),1)
print(arr,arr.shape)
[[1 2]
[3 4]
[5 6]
[7 8]] (4, 2)
[[1 2 5 6]
[3 4 7 8]] (2, 4)
使用堆栈函数连接数组
堆栈与级联相同,唯一的不同是堆栈是沿着新轴完成的
我们可以沿着第二个轴连接两个一维数组,这将导致它们彼此重叠,即堆叠(stacking)
# 沿轴0堆叠两个数组
arr = np.stack((arr1, arr2), axis=0)
print(arr, arr.shape)
# 沿轴1堆叠两个数组
newarr = np.stack((arr1, arr2), axis=1)
print(newarr, newarr.shape)
[[[1 2]
[3 4]]
[[5 6]
[7 8]]] (2, 2, 2)
[[[1 2]
[5 6]]
[[3 4]
[7 8]]] (2, 2, 2)
沿行堆叠
NumPy提供了一个辅助函数:hstack()沿行堆叠,等同于按轴1(行)连接两数组
arr=np.hstack((arr1,arr2))
print(arr,arr.shape)
[[1 2 5 6]
[3 4 7 8]]
沿列堆叠
NumPy提供了一个辅助函数:vstack()沿列堆叠,等同于按轴0(列)连接两数组
arr=np.vstack((arr1,arr2))
print(arr,arr.shape)
[[1 2]
[3 4]
[5 6]
[7 8]] (4, 2)
沿高度(深度)堆叠
NumPy提供了一个辅助函数:dstack()沿高度(深度)堆叠,该高度与深度相同
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()或split()分割数组,将要分割的数组和要分割的数目传递给它
array_split()与split()的区别在于数组不能平均划分时,array_split()会将平均分后的最后一个数组再划分,而split()会报错
arr=np.array([1,2,3,4,5,6])
newarr=np.array_split(arr,3)
print(newarr)
# 返回值是一个包含三个数组的数组
print(newarr[0])
print(newarr[1])
print(newarr[2])
newarr1=np.array_split(arr,4)
print(newarr1)
[array([1, 2]), array([3, 4]), array([5, 6])]
[1 2]
[3 4]
[5 6]
[array([1, 2]), array([3, 4]), array([5]), array([6])]
newarr=np.split(arr,3)
print(newarr)
newarr1=np.split(arr,4)
print(newarr1)
[array([1, 2]), array([3, 4]), array([5, 6])]
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
Cell In[99], line 4
1 newarr=np.split(arr,3)
2 print(newarr)
----> 4 newarr1=np.split(arr,4)
5 print(newarr1)
File D:\Python\Miniconda3\miniconda3\envs\p2s\lib\site-packages\numpy\lib\shape_base.py:864, in split(ary, indices_or_sections, axis)
862 N = ary.shape[axis]
863 if N % sections:
--> 864 raise ValueError(
865 'array split does not result in an equal division') from None
866 return array_split(ary, indices_or_sections, axis)
ValueError: array split does not result in an equal division
分割二维数组
拆分二维数组时,请使用相同的语法
使用array_split()或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)
#另一种解决方案是使用与vstack()相反的vsplit()
newarr1=np.vsplit(arr,3)
print(newarr1)
(6, 3)
[array([[1, 2, 3],
[4, 5, 6]]), array([[ 7, 8, 9],
[10, 11, 12]]), array([[13, 14, 15],
[16, 17, 18]])]
[array([[1, 2, 3],
[4, 5, 6]]), array([[ 7, 8, 9],
[10, 11, 12]]), array([[13, 14, 15],
[16, 17, 18]])]
newarr=np.array_split(arr,3,axis=1)
print(newarr)
#另一种解决方案是使用与hstack()相反的hsplit()
newarr1=np.hsplit(arr,3)
print(newarr1)
[array([[ 1],
[ 4],
[ 7],
[10],
[13],
[16]]), array([[ 2],
[ 5],
[ 8],
[11],
[14],
[17]]), array([[ 3],
[ 6],
[ 9],
[12],
[15],
[18]])]
[array([[ 1],
[ 4],
[ 7],
[10],
[13],
[16]]), array([[ 2],
[ 5],
[ 8],
[11],
[14],
[17]]), array([[ 3],
[ 6],
[ 9],
[12],
[15],
[18]])]
NumPy数组搜索
搜索数组
您可以在数组中搜索(检索)某个值,然后返回获得匹配的索引
要搜索数组,请使用where()方法
numpy.where() 函数返回输入数组中满足给定条件的元素的索引
arr=np.array([1,2,3,4,5,4,7])
x=np.where(arr==4)
print(x)
# 值4出现在索引3,5
#查找值为偶数的索引
y=np.where(arr%2==0)
print(y)
#查找值为奇数的索引
z=np.where(arr%2!=0)
print(z)
(array([3, 5], dtype=int64),)
(array([1, 3, 5], dtype=int64),)
(array([0, 2, 4, 6], dtype=int64),)
搜索排序
有一个名为searchsorted()的方法,该方法在数组中执行二进制搜索,并返回将在其中指定值以维持搜索顺序的索引
假定searchsorted()方法用于排序数组
哪侧开始 | 满足条件 | 何时停止 | 返回序号 |
---|---|---|---|
left | a[i-1]<v<=a[i] | 最后一个满足条件处 | i |
right | a[i-1]<=v<a[i] | 第一个满足条件处 | i |
# 该方法从左侧开始搜索,并返回第一个索引,其中9不再大于10,故在8-10间停止
arr=np.array([6,8,10,15])
# arr[i-1=1]=8 < 9 <= arr[i=2]=10,返回i即2
x=np.searchsorted(arr,9)
print(x)
# 从右侧开始搜索,并返回第一个索引,其中9大于8,故在8-10间停止
# arr[i-1=1]=8 <= 9 < arr[i=2]=10, 返回i即2
y=np.searchsorted(arr,9,side='right')
print(y)
2
2
多个值
要搜索多个值,请使用拥有指定值的数组
arr=np.array([1,3,5,7])
x = np.searchsorted(arr,[2,4,6])
print(x)
[1 2 3]
NumPy数组排序
数组排序
排序是指将元素按有序顺序排列
有序序列是拥有与元素相对应的顺序的任何序列,例如数字或字母,升序或降序
NumPy有一个名为sort()的函数,该函数将对指定的数组进行排序
arr=np.array([3,2,0,1])
print(np.sort(arr))
newarr = np.array(['banana','cherry','apple'])
print(np.sort(newarr))
newarr1=np.array([True,False,True])
print(np.sort(newarr1))
[0 1 2 3]
['apple' 'banana' 'cherry']
[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提供了解决问题的好办法
我们可以在条件中直接替换数组而不是iterable变量,它会如我们期待地那样工作
注:什么是iterable?
在Python中,iterable指的是可以迭代的对象。简单地说,如果一个对象可以被遍历,则称它为iterable。一个iterable对象可以返回一个迭代器(iterator),这个迭代器能够遍历该对象中的所有元素。
在Python中,常见的iterable对象包括列表、元组、集合、字典等。此外,字符串、文件对象等也是iterable对象。
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]
更详细教程可关注
https://www.runoob.com/numpy/numpy-tutorial.html
记录者:ZL-Qin