numpy的索引、切片与迭代

最新推荐文章于 2022-08-10 12:17:10 发布
最新推荐文章于 2022-08-10 12:17:10 发布
阅读量376 收藏 1
点赞数
分类专栏： numpy 文章标签： numpy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Candylx/article/details/109240243
版权

副本与视图

个人理解 副本很好理解，视图呢，也可把它看成原样本

  • numpy.ndarray.copy() 函数创建一个副本。 对副本数据进行修改，不会影响到原始数据，它们物理内存不在同一位置。
import numpy as np
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = x
y[0] = -1
print(x)
print(y)

[-1  2  3  4  5  6  7  8]
[-1  2  3  4  5  6  7  8]
  • 以上例子说明直接赋值后，改变赋值后的变量，原数据也随之修改
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = x.copy()
y[0] = -1
print(x)
print(y)

[1 2 3 4 5 6 7 8]
[-1  2  3  4  5  6  7  8]
  • 数组切片操作返回的对象只是原数组的视图,通俗的说就是通过切片修改数据后，源数据也会随之改变
x = np.array([[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]])
y = x
y[::2, :3:2] = -1
print(x)
print(y)

[[-1 12 -1 14 15]
 [16 17 18 19 20]
 [-1 22 -1 24 25]
 [26 27 28 29 30]
 [-1 32 -1 34 35]]
[[-1 12 -1 14 15]
 [16 17 18 19 20]
 [-1 22 -1 24 25]
 [26 27 28 29 30]
 [-1 32 -1 34 35]]

x = np.array([[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]])
y = x.copy()
y[::2, :3:2] = -1
print(x)
print(y)

[[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]]
[[-1 12 -1 14 15]
 [16 17 18 19 20]
 [-1 22 -1 24 25]
 [26 27 28 29 30]
 [-1 32 -1 34 35]]

索引与切片

整数索引

#获取单个元素
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
print(x[2])

3

x = np.array([[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]])
print(x[2])
#当只有一个数字时，他代表 行，索引从0开始

[21 22 23 24 25]

#获取第三行二个元素
#方法一
print(x[2][1])

22

#方法二
print(x[2, 1])

22

切片索引

注意

  • python 列表进行切片操作得到的数组是原数组的副本
  • 而对 Numpy 数据进行切片操作得到的数组则是指向相同缓冲区的视图。
  • 切片形式（ start:stop:step ）
  • 为了更好地理解切片语法，还应该了解不明确指明起始和结束位置的情况。如省去第一个数字，numpy 会认为第一个数字是0；如省去第二个数字，numpy 则会认为第二个数字是数组的最大索引值；如省去最后一个数字，它将会被理解为1，也就是抽取所有元素而不再考虑间隔。
#一维
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
print(x[0:2])

[1 2]

print(x[0:5:2])

[1 3 5]

#巧用负数索引
print(x[::-1])

[8 7 6 5 4 3 2 1]

#二维
x = np.array([[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]])
print(x[0:2])
#取前两行

[[11 12 13 14 15]
 [16 17 18 19 20]]

print(x[0:2:2])

[[11 12 13 14 15]]

print(x[:-2])#左闭右开

[[11 12 13 14 15]
 [16 17 18 19 20]
 [21 22 23 24 25]]

print(x[2, :])
#取第三行所有元素

[21 22 23 24 25]

#取所有行第三列元素
print(x[:, 2])

[13 18 23 28 33]

#取第一行第二到三个元素
print(x[0, 1:4])
#当我们知道怎么去取二维数组的值时，也就会了怎么修改某个元素的值

[12 13 14]
  • 总结：对于二维切片（针对二维数组），其中格式为（切片一， 切片二），其中切片一是对二维数组的行进行操作，切片二是对二维数组的列进行操作，若切片一或者切片二为具体数字，则是指定行数或者列数

dots 索引

NumPy 允许使用…表示足够多的冒号来构建完整的索引列表。

比如，如果 x 是 5 维数组：

  • x[1,2,…] 等于 x[1,2,:,:,:]
  • x[…,3] 等于 x[:,:,:,:,3]
  • x[4,…,5,:] 等于 x[4,:,:,5,:]
    -* 通俗来说就是用省略号来代替冒号，numpy会自动计算缺失的冒号个数
x = np.random.randint(1, 100, [2, 2, 3])
print(x)

[[[56 20 94]
  [75 11 33]]

 [[41 92 59]
  [60 66 63]]]

#第一个维度上取第一行其余另两个维度取所有
print(x[1, ...])

[[41 92 59]
 [60 66 63]]

print(x[...,2])

[[94 33]
 [59 63]]

整数数组索引

方括号内传入多个索引值，可以同时选择多个元素。

x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
r = [0, 1, 2]
#代表取第前三个元素
print(x[r])

[1 2 3]

r = [0, 1, -1]
print(x[r])

[1 2 8]

x = np.array([[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]])
r = [0, 1, 2]
#此时代表取前三行，列不做要求
print(x[r])

[[11 12 13 14 15]
 [16 17 18 19 20]
 [21 22 23 24 25]]

r = [0, 1, -1]
print(x[r])

[[11 12 13 14 15]
 [16 17 18 19 20]
 [31 32 33 34 35]]

r = [0, 1, 2]
c = [2, 3, 4]
print(x[r, c])

[13 19 25]
  • 注意， 此处r和c的维度必须相同，不然会报错，而且r与c中的每个数字相对应，上例中是取第一行第三个元素、第二行第四个元素、第三行第五个元素
r = [0, 1, 2]
c = [1, 2, 3, 4]
print(x[r, c])

---------------------------------------------------------------------------

IndexError                                Traceback (most recent call last)

<ipython-input-31-0eb63a79f178> in <module>
      1 r = [0, 1, 2]
      2 c = [1, 2, 3, 4]
----> 3 print(x[r, c])


IndexError: shape mismatch: indexing arrays could not be broadcast together with shapes (3,) (4,) 

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

[[1 2]
 [4 5]]

x = np.array([[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]])
r = np.array([[0, 1], [3, 4]])
#都取行数
print(x[r])

[[[11 12 13 14 15]
  [16 17 18 19 20]]

 [[26 27 28 29 30]
  [31 32 33 34 35]]]

r = np.array([[0, 0], [4, 4]])
c = np.array([[0, 4], [0, 4]])
print(x[r, c])
#为什么是这样的结果呢？我们要这样看，竖着看，就是（0， 0）（0， 4）（4， 0）（4， 4）第一个数字代表行，第二个数字代表列

[[11 15]
 [31 35]]

print(x[r])

[[[11 12 13 14 15]
  [11 12 13 14 15]]

 [[31 32 33 34 35]
  [31 32 33 34 35]]]

#可以借助切片:与整数数组组合
x = np.array([[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]])
y = x[0:3, [1, 2, 2]]
#在前三行中取值，列数取第二列、第三列、第三列
print(y)

[[12 13 13]
 [17 18 18]
 [22 23 23]]
  • numpy. take(a, indices, axis=None, out=None, mode=‘raise’) Take elements from an array along an axis.
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
r = [0, 1, 2]
print(np.take(x, r))

[1 2 3]

r = [1, 2, -1]
print(np.take(x, r))

[2 3 8]

x = np.array([[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]])
r = [0, 1, 2]
print(np.take(x, r, axis=0))
#axis=0表明对行进行操作

[[11 12 13 14 15]
 [16 17 18 19 20]
 [21 22 23 24 25]]

r = [0, 1, -1]
print(np.take(x, r, axis=0))

[[11 12 13 14 15]
 [16 17 18 19 20]
 [31 32 33 34 35]]

r = [0, 1, 2]
c = [2, 3, 4]
y = np.take(x, [r, c])#r和c否是默认对第一行进行操作的
print(y)

[[11 12 13]
 [13 14 15]]

r = [0, 1, 2]
c = [2, 3, 4]
y = np.take(x, [r, c], axis = 0)#r和c否是默认对第一行进行操作的
print(y)

[[[11 12 13 14 15]
  [16 17 18 19 20]
  [21 22 23 24 25]]

 [[21 22 23 24 25]
  [26 27 28 29 30]
  [31 32 33 34 35]]]

x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
r = [0, 1, 2]
c = [2, 3, 4]
print(np.take(x, [r, c]))

[[1 2 3]
 [3 4 5]]
  • 注意：使用切片索引到numpy数组时，生成的数组视图将始终是原始数组的子数组, 但是整数数组索引，不是其子数组，是形成新的数组。
#切片索引
a=np.array([[1,2],[3,4],[5,6]])
b = a[0:1, 0:1]#使用切片索引
print(b)

[[1]]

b[0, 0] = 2
print(b)

[[2]]

print(a[0, 0] == b)

[[ True]]

#a与b共享“相对应”的存储位置
a[0, 0]

2

#整数数组索引
a=np.array([[1,2],[3,4],[5,6]])
b = a[0, 0]#使用整数索引
b = 2
b

2

a[0, 0]

1

print(a[0, 0] == b)

False

布尔索引

我们可以通过一个布尔数组来索引目标数组。

import numpy as np
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = x > 5
print(y)

[False False False False False  True  True  True]

#此处x>5代表直接取数组中大于数值5的元素值
print(x[x > 5])

[6 7 8]

x = np.array([np.nan, 1, 2, np.nan, 3, 4, 5])
#numpy.logical_not(x)返回X非逻辑后的布尔值。
y = np.logical_not(np.isnan(x))
print(x[y])

[1. 2. 3. 4. 5.]

x = np.array([[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]])
y = x > 25
print(y)

[[False False False False False]
 [False False False False False]
 [False False False False False]
 [ True  True  True  True  True]
 [ True  True  True  True  True]]

print(x[x>25])

[26 27 28 29 30 31 32 33 34 35]
  • 区别：当x > num单独出现时，会输出bool值，但当x > num作为索引出现时，会输出所有满足条件的值，并封装为一维数组
import matplotlib.pyplot as plt
x = np.linspace(0, 2 * np.pi, 50)
y = np.sin(x)
print(len(x))

50

plt.plot(y)

[<matplotlib.lines.Line2D at 0x184648f7808>]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NkGDbrAm-1603428241826)(output_64_1.png)]

plt.plot(x, y)

[<matplotlib.lines.Line2D at 0x1846496f808>]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CeMb0prv-1603428241830)(output_65_1.png)]

  • 两幅图对比可以看出x确定了横坐标的范围
mask = y >= 0
print(len(x[mask])) 

25

print(mask)

[ True  True  True  True  True  True  True  True  True  True  True  True
  True  True  True  True  True  True  True  True  True  True  True  True
  True False False False False False False False False False False False
 False False False False False False False False False False False False
 False False]

plt.plot(x[mask], y[mask], 'b')

[<matplotlib.lines.Line2D at 0x18464d4ba88>]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MNQYziGO-1603428241831)(output_69_1.png)]

plt.plot(x[mask], y[mask], 'bo')

[<matplotlib.lines.Line2D at 0x18464ee9648>]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mYRa8uLP-1603428241833)(output_70_1.png)]

plt.plot(x[mask], y[mask])

[<matplotlib.lines.Line2D at 0x184649a6a88>]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IWKYJNfo-1603428241834)(output_71_1.png)]

mask = np.logical_and(y >= 0, x <= np.pi / 2)
print(mask)

[ True  True  True  True  True  True  True  True  True  True  True  True
  True False False False False False False False False False False False
 False False False False False False False False False False False False
 False False False False False False False False False False False False
 False False]

plt.plot(x[mask], y[mask], 'go')
plt.show()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XlSQ3R4D-1603428241835)(output_73_0.png)]

数组迭代

x = np.array([[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]])
y = np.apply_along_axis(np.sum, 0, x)
print(y)
#对每一列求和

[105 110 115 120 125]

#对每一行求和
y = np.apply_along_axis(np.sum, 1, x)
print(y)

[ 65  90 115 140 165]

y = np.apply_along_axis(np.mean, 1, x)
print(y)

[13. 18. 23. 28. 33.]

def my_func(x):
    return (x[0] + x[-1]) * 0.5
y = np.apply_along_axis(my_func, 0, x)

print(y)

[21. 22. 23. 24. 25.]

y = np.apply_along_axis(my_func, 1, x)
y

array([13., 18., 23., 28., 33.])

print(y)

[13. 18. 23. 28. 33.]

y

array([13., 18., 23., 28., 33.])
咸鱼在厦大
关注
专栏目录
NumPy数据分析基础：ndarray数组运算基本操作及切片索引迭代
master_hunter的博客
10-02 1217
作为数据分析三巨头Pandas、matplotlib、NumPy之一，必然要给足面子单独拿出来讲解一波。NumPy应用场景十分宽泛，Pandas很多函数转换后也都是NumPy数组类型的数据结构。在机器学习、深度学习以及一些数据处理操作中使用的频率甚至比Pandas都高。而且NumPy功能强大，使用起来也十分便捷，支持多种复杂操作。平时我的Pandas以及一些机器学习的文章都有用到NumPy，但是博客内容并没有详细解答NumPy的操作也没有记录有关NumPy操作的一些具体函数解答。
NumPy基础-索引
m0_54342642的博客
03-10 871
数组索引是指使用方括号（[]）来索引数组值。索引有很多选项，这给NumPy提供了强大的索引功能，但是强大的功能也带来了一些复杂性和潜在的混乱。 单个元素的索引 一维数组的单元素索引是我们所期望的，它的工作方式与其他标准Python序列完全相同。它基于0，并且接受复索引以数组末尾开始索引。 与列表和元组不同，numpy数组支持多维数组的多维索引。这意味着不必将每个维度的索引都分成自己的一组方括号。 这里我们要注意，如果索引一个多维数组的索引比维数少，则将获得一个多维数组。例如： 也就是说，指定的每个索引
Numpy学习第二天
PJHLTL的博客
10-22 258
副本与视图 心得总结： np.ndarray.copy()函数会复制一个副本，从而不会更改原来的数据。 import numpy as np x = np.array([1, 2, 3, 4, 5, 6, 7, 8]) y = x y[0] = -1 print(x) # [-1 2 3 4 5 6 7 8] x = np.array([1, 2, 3, 4, 5, 6, 7, 8]) y = x.copy() y[0] = -1 print(x) # [1 2 3 4 5 6 7 8]
numpy索引、切片与迭代
weixin_53680017的博客
03-26 1985
1.numpy中，在做数组运算和操作时，返回结果不是数组的副本就是视图。而赋值运算不会为数组和任何元素创建副本。 numpy.ndarray.copy() 函数创建一个副本。对副本修改，不会影响到原始数据。 >>> x = np.array([1, 2, 3, 4, 5, 6, 7, 8]) >>> y = x >>> y[0] = -1 >>> print(x) [-1 2 3 4 5 6 7 8] #没有创建副
Python基础学习——Numpy包（2、索引、切片与迭代）
weixin_51060564的博客
08-10 382
主要进行了Numpy包中索引、切片、和数组迭代的学习。
02 Numpy索引、切片与迭代
deftntxz的博客
10-21 227
副本与视图 在Numpy中进行数组运算或者数组操作时，返回结果为数组的副本或视图。 在Numpy中，所有赋值运算不会为数组和数组中的任何元素创建副本。 使用 numpy.ndarray.copy函数来创建一个副本。对副本中的数据进行修改不会影响到原始数据，因为它们存放的物理地址不同。 数组切片操作返回的是原数组的视图，而非副本 索引与切片 数组索引机制指的是用方括号（[]）加序号的形式引用单个数组元素，它的用处很多，比如抽取元素，选取数组的几个元素，甚至为其赋一个新值。 整数索引 import nump
NumPy索引、切片和迭代
明远
12-28 385
基本运算 数组的算术运算是按元素的。新的数组被创建并且被结果填充。 a = array( [20,30,40,50] ) b = arange( 4 ) b array([0, 1, 2, 3]) c = a-b c array([20, 29, 38, 47]) b**2 array([0, 1, 4, 9]) 10*...
Numpy数组和矩阵运算（3.索引、切片和迭代）
06-14
在深入了解Numpy中的索引、切片和迭代之前，先简要回顾一下Numpy的基本概念及其相对于Python标准库中的列表的优势： - **运算速度更快**：Numpy通过C语言实现核心操作，因此比纯Python代码执行效率更高。 - **占用...
numpy（时间，数组，索引切片）
qq_52683824的博客
06-30 313
numpy
【基础】NumPy库入门：数组索引与切片技巧
[【基础】NumPy库入门：数组索引与切片技巧](https://img-blog.csdnimg.cn/img_convert/31a81f8f95e7bc5edfb98a79c498a042.png) # 2.1 基本索引 NumPy 数组支持使用整数索引来访问单个元素或元素子集。基本索引使用...
NumPy 基本切片和索引的具体使用方法
09-19
主要介绍了NumPy 基本切片和索引的具体使用方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
numpy 数组索引切片迭代
m0_69316239的博客
05-30 104
import numpy as np a = np.arange(10)** 3 #立方 print(a) print(a[2]) print(a[2:5]) #左闭右开 print([:6]) #切片中的0可以省略 print([:5:2]) #步长为2 a[2:5] = 6 #改 print(a) print(a[::-1]) #倒序数组 #迭代 for i in a: #迭代每一行 print(i) b = np.array([[0, 1, 2, 3], ...
Numpy入门教程：02. 索引、切片与迭代
老马的程序人生
06-01 691
背景 什么是 NumPy 呢？ NumPy 这个词来源于两个单词 – Numerical和Python。其是一个功能强大的 Python 库，可以帮助程序员轻松地进行数值计算，通常应用于以下场景： 执行各种数学任务，如：数值积分、微分、内插、外推等。因此，当涉及到数学任务时，它形成了一种基于 Python 的 MATLAB 的快速替代。 计算机中的图像表示为多维数字数组。NumPy 提供了一些优秀的库函数来快速处理图像。例如，镜像图像、按特定角度旋转图像等。 在编写机器学习算法时，需要对矩阵进行各种数值
（100天2小时第十六天）numpy数组——索引，切片和迭代
zhangxue1232的博客
11-10 200
一、通用函数 B = np.arange(3) print(B) print(np.exp(B)) print(2.71828183 * 2.71828183) print(np.sqrt(B)) C = np.array([2., -1., 4.]) print(np.add(B, C)) 二、索引，切片和迭代 一维数组的索引，切片，迭代跟普通的python列表一样 a = np.arange(10) ** 3 print(a) print(a[2]) print(a[2:5]) prin
【numpy】02索引
weixin_50883256的博客
10-22 204
副本与视图 在 Numpy 中，尤其是在做数组运算或数组操作时，返回结果不是数组的 副本 就是 视图。 在 Numpy 中，所有赋值运算不会为数组和数组中的任何元素创建副本。 numpy.ndarray.copy()创建一个副本。 对副本数据进行修改，不会影响到原始数据，它们物理内存不在同一位置。 【例】 import numpy as np x = np.array([1, 2, 3, 4, 5, 6, 7, 8]) y = x y[0] = -1 print(x) # [-1 2 3 4 5
1基于STM32的智能气象站项目.docx
最新发布
10-30
1基于STM32的智能气象站项目
技术资料分享SH-HC-05蓝牙模块技术手册很好的技术资料.zip
10-30
技术资料分享SH-HC-05蓝牙模块技术手册很好的技术资料.zip
【路径规划】改进的人工势场算法机器人避障路径规划【含Matlab源码 1151期】.zip
10-30
【路径规划】改进的人工势场算法机器人避障路径规划【含Matlab源码 1151期】.zip
链表HuffmanTree.zip
10-30
链表HuffmanTree.zip
全面掌握Python Numpy与数据分析教程
通过本教程，学习者可以掌握Numpy的基本概念，包括数组的创建、索引、切片和迭代等操作。此外，教程还将深入讲解数组的数据类型、数组的形状操作，以及数组与标量之间的运算等高级话题。 在数据分析方面，教程将...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值