numpy 的索引与切片，副本与视图

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

numpy 的索引与切片，副本与视图

numpy 的索引与切片

整数索引

import numpy as np

x = np.arange(10)
print(x)
# [0 1 2 3 4 5 6 7 8 9]

x[3]
# 3

切片索引

numpy 的切片索引使用方法和python list 中的切片索引相同

x[a : b : c = 1] 就是访问 x 的从索引为 a 到索引为 b-1 的元素，c表示步长，步长默认为 1

步长，相当于我们走路的步伐，步长为1就是依次访问每一个元素，步长为2就是按照 1，3，5 … 的顺序来访问

对一维数组的切片

x[:6] 相当于 x[0:6]

x[6:] 相当于 从索引6到最后一个元素（包括最后一个元素）

x = np.arange(1,9)
print(x)

# [1 2 3 4 5 6 7 8]

# 前六个元素，不包括索引为6的元素
print(x[0:6])
# [1 2 3 4 5 6]

# 相当于 x[0:6]
print(x[:6])
# [1 2 3 4 5 6]

print(x[:6:2])
# [1 3 5]

print(x[2:])
# [3 4 5 6 7 8]

print(x[2::2])
# [3 5 7]

print(x[2:-1])
# [3 4 5 6 7]

print(x[:])
# [1 2 3 4 5 6 7 8]

print(x[::-1])
# [8 7 6 5 4 3 2 1]

对二维数组的切片

二维数组有两个切片，两个切片以逗号分割，第一个切片是行的切片，第二个切片是列的切片

行的切片索引
x = np.arange(11,36).reshape(5,-1)
print(x)

# [[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:3])

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

# 二维数组的第二行和第四行
print(x[1:5:2])

#[[16 17 18 19 20]
# [26 27 28 29 30]]

# 二维数组从第二行到最后一行
print(x[2:])

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

# 二维数组前两行
print(x[:2])

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

# 二维数组的后两行
print(x[-2:])

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

# 二维数组第一行到倒数第三行
print(x[:-2])

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

# 二维数组本身
print(x[:])

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

# [21 22 23 24 25]

# 所有行的第三列，虽然是一列的元素，但会以一维数组的形式返回
y = x[:,2]
print(y)
print(type(y))
print(y.shape)

# [13 18 23 28 33]
# <class 'numpy.ndarray'>
# (5,)

# 二维数组的所有行，所有列的元素，也就是二维数组自身
print(x[:,:])

# [[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)

# [[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,::2])

# [[11 13 15]
# [21 23 25]
# [31 33 35]]

# 倒着访问每一行
print(x[::-1,:])

# [[31 32 33 34 35]
# [26 27 28 29 30]
# [21 22 23 24 25]
# [16 17 18 19 20]
# [11 12 13 14 15]]

# 倒着访问每一行每一列的元素
print(x[::-1,::-1])

# [[35 34 33 32 31]
# [30 29 28 27 26]
# [25 24 23 22 21]
# [20 19 18 17 16]
# [15 14 13 12 11]]

# 倒着访问每一列的元素
print(x[:,::-1])

# [[15 14 13 12 11]
# [20 19 18 17 16]
# [25 24 23 22 21]
# [30 29 28 27 26]
# [35 34 33 32 31]]
使用二维数组的切片修改元素
x = np.arange(11,36).reshape(5,-1)
print(x)

# [[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]]

# 奇数行，2，5列的元素全部修改为0
x[::2,1::3] = 0
print(x)

# [[11  0 13 14  0]
# [16 17 18 19 20]
# [21  0 23 24  0]
# [26 27 28 29 30]
# [31  0 33 34  0]]

整数数组索引

nmupy的 array 与python 的 list 的切片的区别除了numpy的切片会返回数据的视图之外，

还有一个区别：numpy的切片可以是一个数组

x = np.arange(1,9)

index = [0,1,2]
print(x[index])

# [1 2 3]

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

# [1 2 8]

X = np.arange(11,36).reshape(5,-1)
print(X)

# [[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]]

# 二维数组的 0，1，2 行
index = [0,1,2]
print(X[index])

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

# 二维数组的 第1行，第2行和最后一行
index = [0,1,-1]
print(X[index])

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

# 相当于 X[0,2],X[1,3],X[2,4]
row = [0,1,2]
col = [2,3,4]
print(X[row,col])

# [13 19 25]

可以使用切片访问一维数组，使其返回一个二维数组，并且不会改变原数据

x = np.arange(1,9)
r = np.array([[0,1],[3,4]])

print(x[r])

# [[1 2]
# [4 5]]
    
print(x)
# [1 2 3 4 5 6 7 8]

X = np.arange(11,36).reshape(5,-1)
print(X)

# [[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]]]

print(X)

# [[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]]

打印二维数组的四个角

X = np.arange(11,36).reshape(5,-1)

r = np.array([[0,0],[4,4]])
c = np.array([[0,4],[0,4]])
y = X[r,c]

print(y)

# [[11 15]
# [31 35]]

可以借助切片与整数数组组合

X = np.arange(11,36).reshape(5,-1)
print(X)

# [[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,3]]
print(y)

# [[12 13 14]
# [17 18 19]
# [22 23 24]]

布尔索引

numpy 中索引可以是一个 布尔类型的数组

x = np.arange(1,9)

# 表示将 x 的所有元素依次与 5 比较，返回一个布尔类型的数组
y = x>5
print(y)

# [False False False False False  True  True  True]

print(type(y))
# <class 'numpy.ndarray'>

# 访问索引位置为True的元素
print(x[y])
# [6 7 8]

x = np.array([np.nan,1,2,np.nan,3,4,5])
print(f"x:{x}")

y = np.logical_not(np.isnan(x))
print(f"y:{y}")

print(f"x[y]:{x[y]}")

# x:[nan  1.  2. nan  3.  4.  5.]
# y:[False  True  True False  True  True  True]
# x[y]:[1. 2. 3. 4. 5.]

X = np.arange(11,36).reshape(5,-1)
print(X)

y = X>25
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]]

# [[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[y])
# [26 27 28 29 30 31 32 33 34 35]

ndarray的副本与视图

python的 list 的切片返回是原数据的副本，即开辟了一个新的内存地址，

numpy 以效率为主，所以 numpy 的切片返回的是原数据的视图，即不会创建新的内存地址，而是对原数据内存地址的引用。

numpy 中所有的运算操作符都不会为数组创建副本

import numpy as np

x = np.arange(1,10).reshape(3,-1)
print(x)

# [[1 2 3]
# [4 5 6]
# [7 8 9]]

y = x
print(y)

# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

y[1,1] = 999
print(y)

# [[  1   2   3]
# [  4 999   6]
# [  7   8   9]]

print(x)

# [[  1   2   3]
# [  4 999   6]
# [  7   8   9]]

np.ndarray.copy() 可以创建一个副本，开辟一个新的内存地址

z = x.copy()
print(z)

[[  1   2   3]
 [  4 999   6]
 [  7   8   9]]
 
z[1,1] = 111
print(z)

# [[  1   2   3]
# [  4 111   6]
# [  7   8   9]]
 
print(x)

# [[  1   2   3]
# [  4 999   6]
# [  7   8   9]]

再来试一下二维数组

ndarray 的切片返回的是对原数据内存地址的引用

x = np.arange(11,36).reshape(5,-1)
print(x)

# [[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(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]]

print(x)
# [[-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]]

copy() 返回的是数组的副本

x = np.arange(11,36).reshape(5,-1)
y = x.copy()

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

# [[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]]
大数据老张
关注
专栏目录
numpy 深复制 切片创建视图
长门有希的博客
04-30 148
import numpy as np a = np.array([[10,10],[2,3],[4,5]]) print(a) [行起始:行结束,列起始:列结束] s = a[:,1:2] print(s) [[10 10] [ 2 3] [ 4 5]] [[10] [ 3] [ 5]] 此时对s进行shape 变化的话不会影响a ...
Numpy学习第二天
PJHLTL的博客
10-22 242
副本与视图 心得总结： 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副本和视图
ccc369639963的博客
04-14 324
NumPy副本和视图 对 NumPy 数组执行些函数操作时，其中一部分函数会返回数组的副本，而另一部分函数则返回数组的视图。本节对数组的副本和视图做重点讲解。 其实从内存角度来说，副本就是对原数组进行深拷贝，新产生的副本与原数组具有不同的存储位置。而视图可理解为对数组的引用，它和原数组有着相同的内存位置。 赋值操作 赋值操作是数组引用的一种方法。比如，将 a 数组赋值给变量 b，被赋值后的变量 b 与 a 组具有相同的内存 id。因此，无论操作 a、b 中哪个数组，另一个数组也会受到影响。例如下： impo
【Numpy学习06】副本与视图
Xiao_Spring的博客
10-23 349
前言 在学习本章之前，我们先回顾一下Python中引用和对象的概念： Python 中，一切皆对象。每个对象由：标识（identity）、类型（type）、value（值） 组成。 标识用于唯一标识对象，通常对应于对象在计算机内存中的地址。使用内置函数 id(obj) 可返回对象 obj 的标识。 类型用于表示对象存储的“数据”的类型。类型可以限制对象的取值范围以及可执行的 操作。可以使用 type(obj)获得对象的所属类型。 值表示对象所存储的数据的信息。使用 print(obj)可以直接打印出值。
对比 Python 原生切片，讲述 Numpy 数组切片！
Python中文社区
05-13 379
1. 本文介绍今天为大家介绍以下内容：Ⅰ Python原生切片，与numpy数组切片，有哪些不同？Ⅱ numpy中，应该如何使用切片？2. Python原生切片，与numpy数组切片，有哪...
python中索引与切片的区别_numpy中索引和切片详解
weixin_39591455的博客
12-04 3535
索引和切片一维数组一维数组很简单，基本和列表一致。它们的区别在于数组切片是原始数组视图(这就意味着，如果做任何修改，原始都会跟着更改)。这也意味着，如果不想更改原始数组，我们需要进行显式的复制，从而得到它的副本(.copy())。import numpy as np #导入numpyarr = np.arange(10) #类似于list的range()arrOut[3]: array([0, 1...
numpy索引和切片
小子令狐冲
02-24 725
1、基本的索引和切片基本索引与切片与python列表操作类似arr = [1,2,3,4,5] arr[2:4] #[3,4] 当把标量值赋予给一个切片时（如arr[2:4]=12），该值会广播到整个选区。注意数组切片是原始数组的视图。这意味着数据不会被复制，视图上的任何修改都会直接反映到源数据上。多维数据索引中，索引位置上的元素不是标量，而是一维数组了arr2=np.array([[1,2,3...
numpy中索引和切片详解
09-20
首先，一维数组的索引和切片与Python中的列表类似，但有一个关键区别：数组的切片是原始数组的视图，这意味着对切片的修改会影响到原始数组。例如，创建一个一维数组`arr`，通过索引`arr[4]`获取第四个元素，通过...
多维数组的索引与切片_Numpy多维数组索引与切片详解
weixin_31437777的博客
12-24 1617
作者：Zarten简介： 互联网一线工作者，尊重原创并欢迎评论留言指出不足之处，也希望多些关注和点赞是给作者最好的鼓励 ！概述numpy中多维数组的索引与切片跟python中的列表类似，但最大的区别是，数组切片是原始数组的视图，也就是说对视图上的修改直接会影响到原始数组，因为numpy的主要是处理大数据，如果每次切片都进行一次复制，那对性能和内存是相当大的考验。索引及切片1.一维数组的索引及切片...
Numpy入门教程：02. 索引、切片与迭代
老马的程序人生
06-01 684
背景 什么是 NumPy 呢？ NumPy 这个词来源于两个单词 – Numerical和Python。其是一个功能强大的 Python 库，可以帮助程序员轻松地进行数值计算，通常应用于以下场景： 执行各种数学任务，如：数值积分、微分、内插、外推等。因此，当涉及到数学任务时，它形成了一种基于 Python 的 MATLAB 的快速替代。 计算机中的图像表示为多维数字数组。NumPy 提供了一些优秀的库函数来快速处理图像。例如，镜像图像、按特定角度旋转图像等。 在编写机器学习算法时，需要对矩阵进行各种数值
对Numpy切片的认识
最新发布
Fiona20的博客
11-21 561
而numpy 以效率为主，所以 numpy 的切片返回的是原数据的视图，即不会创建新的内存地址，而是对原数据内存地址的引用。视图：当对通过视图看到的数据进行修改时，相应的基本表的数据也要发生变化，同时，若基本表的数据发生变化，则这种变化也可以自动地反映到视图中。python的 list 的切片返回是原数据的副本，即开辟了一个新的内存地址储存数据，因此修改切片出来的结果，原数据并不会发生改变。数组切片不会复制内部数组数据生成一个副本，只会生成原始数据的新视图，这点与 python 不同。
Python numpy 结构化数组之索引
m0_71437598的博客
06-06 829
numpy 结构化数据类型是字段的结集合。每一个字段由 name、type 和 offset 组成。字段的数据类型可以是任何numpy数据类型、其他结构化数据类型和子数组数据类型。numpy也提供了结构化数组类型创建的四种方法: 对于 numpy 结构化数组的操作，我们已经在 numpy 结构化数组赋值 学习了结构化数组的三种赋值方法分别为在 numpy 中普通数组最常见的操作就是索引，同理对于结构化数组也同样支持索引操作。 本期，我们将学习 numpy 结构化数组的索引操作相关方法，Let’s go~在
Python中的副本和视图
gaoxueyi551的专栏
10-17 2568
何为副本？何为视图？ 副本：就是原有数据的一份拷贝。 视图：可理解为原有数据的一个别称或引用，通过该别称或引用亦便可访问、操作原有数据，但原有数据不会产生拷贝。 视图与副本的区别 副本即原有数据的一份拷贝，因此对副本的任何修改不会影响原有数据，同理，对原有数据的任何修改亦不影响副本数据。         视图仅是原有数据的一个引用或别称，通过视图修改数据可反映到对原有数据的修
Python学习笔记（十六）——Numpy
weixin_60535956的博客
11-14 4586
详细解释Numpy数据库，为广大读者启蒙数据分析！
numpy 视图copy和切片
花木兰
09-04 403
from numpy import * #1完全不copy # a=arange(12) # b=a # b is a # Out[29]: True # b.shape=3,4 # a.shape # Out[31]: (3, 4) # id(a) # Out[32]: 3011172246752 # id(b) # Out[33]: 3011172246752 #2视图和浅copy # c=...
pandas numpy切片和副本
yy的博客
01-08 932
切片和副本的问题: pandas: b = a 视图(修改视图,原值一起改变) b = a[:] 视图(修改视图,原值一起改变) b = a[[列名1,列名2...]] 副本,修改副本,原值不一起变,这种切片是pandas特有的,并且是副本  # pandas奇葩方法,返回副本 b = a.copy() 副本 关于loc切片问题:知乎     numpy: b = a 视图(修...
python--NumPy/Pandas 数据赋值时的视图和副本问题
by 一目
05-28 2048
1.NumPy数组的切片、赋值将一个标量赋值给一个切片（如arr[5:8]=12）时，该值会自动传播到整个选区。跟列表最重要的区别在于，数组切片是原始数组的视图。即数据不会被复制，视图上的任何修改 都会直接反映到源数组上。注：如果想要得到的是ndarray切片的一份副本而非视图，就需要显式地进行复制操作，如arr[5:8].copy()。2.pandas--DataFrame数据切片、赋值通过索引...
numpy的切片操作
xiaofeng
01-06 7226
numpy切片操作
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值