python基础知识之索引与切片详解

目录
  • 基本索引
  • 嵌套索引
  • 切片
  • numpy.array 索引 一维
  • numpy.array 索引 二维
  • pandas Series 索引
  • pandas DataFrame 索引
  • 填坑
  • 总结

基本索引

In [4]: sentence = 'You are a nice girl'In [5]: L = sentence.split()In [6]: LOut[6]: ['You', 'are', 'a', 'nice', 'girl']

# 从0开始索引In [7]: L[2]Out[7]: 'a'

# 负数索引,从列表右侧开始计数In [8]: L[-2]Out[8]: 'nice'

# -1表示列表最后一项In [9]: L[-1]Out[9]: 'girl'

# 当正整数索引超过返回时In [10]: L[100]---------------------------------------------------------------------------IndexError                                Traceback (most recent call last)
<ipython-input-10-78da2f882365> in <module>()----> 1 L[100]IndexError: list index out of range# 当负整数索引超过返回时In [11]: L[-100]---------------------------------------------------------------------------IndexError                                Traceback (most recent call last)
<ipython-input-11-46b47b0ecb55> in <module>()----> 1 L[-100]IndexError: list index out of range# slice 索引In [193]: sl = slice(0,-1,1)In [194]: L[sl]Out[194]: ['You', 'are', 'a', 'nice']In [199]: sl = slice(0,100)In [200]: L[sl]Out[200]: ['You', 'are', 'a', 'nice', 'girl']

嵌套索引

In [14]: L = [[1,2,3],{'I':'You are a nice girl','She':'Thank you!'},(11,22),'My name is Kyles']

In [15]: L
Out[15]:
[[1, 2, 3],
 {'I': 'You are a nice girl', 'She': 'Thank you!'},
 (11, 22),
 'My name is Kyles']# 索引第1项,索引为0In [16]: L[0]
Out[16]: [1, 2, 3]# 索引第1项的第2子项In [17]: L[0][1]
Out[17]: 2# 索引第2项词典In [18]: L[1]
Out[18]: {'I': 'You are a nice girl', 'She': 'Thank you!'}# 索引第2项词典的 “She”In [19]: L[1]['She']
Out[19]: 'Thank you!'# 索引第3项In [20]: L[2]
Out[20]: (11, 22)# 索引第3项,第一个元组In [22]: L[2][0]
Out[22]: 11# 索引第4项In [23]: L[3]
Out[23]: 'My name is Kyles'# 索引第4项,前3个字符In [24]: L[3][:3]
Out[24]: 'My '

切片

# 切片选择,从1到列表末尾In [13]: L[1:]Out[13]: ['are', 'a', 'nice', 'girl']# 负数索引,选取列表后两项In [28]: L[-2:]Out[28]: ['nice', 'girl']# 异常测试,这里没有报错!In [29]: L[-100:]Out[29]: ['You', 'are', 'a', 'nice', 'girl']# 返回空In [30]: L[-100:-200]Out[30]: []# 正向索引In [32]: L[-100:3]Out[32]: ['You', 'are', 'a']# 返回空In [33]: L[-1:3]Out[33]: []# 返回空In [41]: L[0:0]Out[41]: []

看似简单的索引,有的人不以为然,我们这里采用精准的数字索引,很容易排查错误。若索引是经过计算出的一个变量,就千万要小心了,否则失之毫厘差之千里。

numpy.array 索引 一维

In [34]: import numpy as npIn [35]: arr = np.arange(10)In [36]: arrOut[36]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])In [40]: arr.shapeOut[40]: (10,)# [0,1) In [37]: arr[0:1]Out[37]: array([0])# [0,0) In [38]: arr[0:0]Out[38]: array([], dtype=int32)# 右侧超出范围之后In [42]: arr[:1000]Out[42]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])# 左侧超出之后In [43]: arr[-100:1000]Out[43]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])# 两侧都超出In [44]: arr[100:101]Out[44]: array([], dtype=int32)# []In [45]: arr[-100:-2]Out[45]: array([0, 1, 2, 3, 4, 5, 6, 7])# []In [46]: arr[-100:-50]Out[46]: array([], dtype=int32)

numpy.array 索引 二维

In [49]: arr = np.arange(15).reshape(3,5)

In [50]: arr
Out[50]:
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

In [51]: arr.shape
Out[51]: (3, 5)

# axis = 0 增长的方向
In [52]: arr[0]
Out[52]: array([0, 1, 2, 3, 4])

# 选取第2行
In [53]: arr[1]
Out[53]: array([5, 6, 7, 8, 9])

# axis = 1 增长的方向,选取每一行的第1列
In [54]: arr[:,0]
Out[54]: array([ 0,  5, 10])

# axis = 1 增长的方向,选取每一行的第2列
In [55]: arr[:,1]
Out[55]: array([ 1,  6, 11])

# 选取每一行的第1,2列
In [56]: arr[:,0:2]
Out[56]:
array([[ 0,  1],
       [ 5,  6],
       [10, 11]])

# 右侧超出范围之后
In [57]: arr[:,0:100]
Out[57]:
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

# 左侧超出范围之后
In [62]: arr[:,-10:2]
Out[62]:
array([[ 0,  1],
       [ 5,  6],
       [10, 11]])

# []
In [58]: arr[:,0:0]
Out[58]: array([], shape=(3, 0), dtype=int32)

# []
In [59]: arr[0:0,0:1]
Out[59]: array([], shape=(0, 1), dtype=int32)

# 异常
In [63]: arr[:,-10]---------------------------------------------------------------------------IndexError                                Traceback (most recent call last)
<ipython-input-63-2ffa6627dc7f> in <module>()----> 1 arr[:,-10]IndexError: index -10 is out of bounds for axis 1 with size 5

numpy.array 索引 三维…N维

In [67]: import numpy as np

In [68]: arr = np.arange(30).reshape(2,3,5)

In [69]: arr
Out[69]:
array([[[ 0,  1,  2,  3,  4],
        [ 5,  6,  7,  8,  9],
        [10, 11, 12, 13, 14]],       [[15, 16, 17, 18, 19],
        [20, 21, 22, 23, 24],
        [25, 26, 27, 28, 29]]])

# 根据 axis = 0 选取
In [70]: arr[0]
Out[70]:
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

In [71]: arr[1]
Out[71]:
array([[15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24],
       [25, 26, 27, 28, 29]])

# 根据 axis = 1 选取
In [72]: arr[:,0]
Out[72]:
array([[ 0,  1,  2,  3,  4],
       [15, 16, 17, 18, 19]])

In [73]: arr[:,1]
Out[73]:
array([[ 5,  6,  7,  8,  9],
       [20, 21, 22, 23, 24]])

# 异常指出 axis = 1 超出范围
In [74]: arr[:,4]---------------------------------------------------------------------------IndexError                                Traceback (most recent call last)
<ipython-input-74-9d489478e7c7> in <module>()----> 1 arr[:,4]IndexError: index 4 is out of bounds for axis 1 with size 3  # 根据 axis = 2 选取
In [75]: arr[:,:,0]
Out[75]:
array([[ 0,  5, 10],
       [15, 20, 25]])

# 降维
In [76]: arr[:,:,0].shape
Out[76]: (2, 3)

In [78]: arr[:,:,0:2]
Out[78]:
array([[[ 0,  1],
        [ 5,  6],
        [10, 11]],       [[15, 16],
        [20, 21],
        [25, 26]]])

In [79]: arr[:,:,0:2].shape
Out[79]: (2, 3, 2)

# 左/右侧超出范围
In [81]: arr[:,:,0:100]
Out[81]:
array([[[ 0,  1,  2,  3,  4],
        [ 5,  6,  7,  8,  9],
        [10, 11, 12, 13, 14]],       [[15, 16, 17, 18, 19],
        [20, 21, 22, 23, 24],
        [25, 26, 27, 28, 29]]])

# 异常 axis = 0In [82]: arr[100,:,0:100]---------------------------------------------------------------------------IndexError                                Traceback (most recent call last)
<ipython-input-82-21efcc74439d> in <module>()----> 1 arr[100,:,0:100]IndexError: index 100 is out of bounds for axis 0 with size 2

pandas Series 索引

In [84]: s = pd.Series(['You','are','a','nice','girl'])In [85]: sOut[85]:0     You1     are2       a3    nice4    girl
dtype: object# 按照索引选择In [86]: s[0]Out[86]: 'You'# []In [87]: s[0:0]Out[87]: Series([], dtype: object)In [88]: s[0:-1]Out[88]:0     You1     are2       a3    nice
dtype: object# 易错点,ix包含区间为 []In [91]: s.ix[0:0]Out[91]:0    You
dtype: objectIn [92]: s.ix[0:1]Out[92]:0    You1    are
dtype: object# ix索引不存在indexIn [95]: s.ix[400]
KeyError: 400# 按照从0开始的索引In [95]: s.iloc[0]Out[95]: 'You'In [96]: s.iloc[1]Out[96]: 'are'In [97]: s.iloc[100]
IndexError: single positional indexer is out-of-boundsIn [98]: s = pd.Series(['You','are','a','nice','girl'], index=list('abcde'))In [99]: sOut[99]:
a     You
b     are
c       a
d    nice
e    girl
dtype: objectIn [100]: s.iloc[0]Out[100]: 'You'In [101]: s.iloc[1]Out[101]: 'are'# 按照 label 索引In [103]: s.loc['a']Out[103]: 'You'In [104]: s.loc['b']Out[104]: 'are'In [105]: s.loc[['b','a']]Out[105]:
b    are
a    You
dtype: object# loc切片索引In [106]: s.loc['a':'c']Out[106]:
a    You
b    are
c      a
dtype: objectIn [108]: s.indexOut[108]: Index(['a', 'b', 'c', 'd', 'e'], dtype='object')

pandas DataFrame 索引

In [114]: import pandas as pdIn [115]: df = pd.DataFrame({'open':[1,2,3],'high':[4,5,6],'low':[6,3,1]}, index=pd.period_range('30/12/2017',perio
     ...: ds=3,freq='H'))In [116]: dfOut[116]:
                  high  low  open2017-12-30 00:00     4    6     12017-12-30 01:00     5    3     22017-12-30 02:00     6    1     3# 按列索引In [117]: df['high']Out[117]:2017-12-30 00:00    42017-12-30 01:00    52017-12-30 02:00    6Freq: H, Name: high, dtype: int64In [118]: df.highOut[118]:2017-12-30 00:00    42017-12-30 01:00    52017-12-30 02:00    6Freq: H, Name: high, dtype: int64In [120]: df[['high','open']]Out[120]:
                  high  open2017-12-30 00:00     4     12017-12-30 01:00     5     22017-12-30 02:00     6     3In [122]: df.ix[:]
D:\CodeTool\Python\Python36\Scripts\ipython:1: DeprecationWarning:
.ix is deprecated. Please use
.loc for label based indexing or.iloc for positional indexingIn [123]: df.iloc[0:0]Out[123]:Empty DataFrame
Columns: [high, low, open]Index: []In [124]: df.ix[0:0]Out[124]:Empty DataFrame
Columns: [high, low, open]Index: []

# 按照 label 索引In [127]: df.indexOut[127]: PeriodIndex(['2017-12-30 00:00', '2017-12-30 01:00', '2017-12-30 02:00'], dtype='period[H]', freq='H')In [128]: df.loc['2017-12-30 00:00']Out[128]:
high    4low     6open    1Name: 2017-12-30 00:00, dtype: int64

# 检查参数In [155]: df.loc['2017-12-30 00:00:11']Out[155]:
high    4low     6open    1Name: 2017-12-30 00:00, dtype: int64In [156]: df.loc['2017-12-30 00:00:66']
KeyError: 'the label [2017-12-30 00:00:66] is not in the [index]'

填坑

In [158]: df = pd.DataFrame({'a':[1,2,3],'b':[4,5,6]}, index=[2,3,4])In [159]: dfOut[159]:
   a  b2  1  43  2  54  3  6# iloc 取第一行正确用法In [160]: df.iloc[0]Out[160]:
a    1b    4Name: 2, dtype: int64

# loc 正确用法In [165]: df.loc[[2,3]]Out[165]:
   a  b2  1  43  2  5# 注意此处 index 是什么类型In [167]: df.loc['2']
KeyError: 'the label [2] is not in the [index]'# 索引 Int64IndexOut[172]: Int64Index([2, 3, 4], dtype='int64')

# 索引为字符串In [168]: df = pd.DataFrame({'a':[1,2,3],'b':[4,5,6]}, index=list('234'))In [169]: dfOut[169]:
   a  b2  1  43  2  54  3  6In [170]: df.indexOut[170]: Index(['2', '3', '4'], dtype='object')

# 此处没有报错,千万注意 index 类型In [176]: df.loc['2']Out[176]:
a    1b    4Name: 2, dtype: int64

# ix 是一个功能强大的函数,但是争议却很大,往往是错误之源
# 咦,怎么输出与预想不一致!In [177]: df.ix[2]
D:\CodeTool\Python\Python36\Scripts\ipython:1: DeprecationWarning:
.ix is deprecated. Please use
.loc for label based indexing or.iloc for positional indexing

See the documentation here:
http://pandas.pydata.org/pandas-docs/stable/indexing.html#ix-indexer-is-deprecatedOut[177]:
a    3b    6Name: 4, dtype: int64

# 注意开闭区间In [180]: df.loc['2':'3']Out[180]:
   a  b2  1  43  2  5

总结

pandas中ix是错误之源,大型项目大量使用它时,往往造成不可预料的后果。0.20.x版本也标记为抛弃该函数,二义性 和 []区间,违背 “Explicit is better than implicit.” 原则。建议使用意义明确的 iloc和loc 函数。

当使用字符串时切片时是 []区间 ,一般是 [)区间

当在numpy.ndarry、list、tuple、pandas.Series、pandas.DataFrame 混合使用时,采用变量进行索引或者切割,取值或赋值时,别太自信了,千万小心错误,需要大量的测试。

我在工程中使用matlab的矩阵和python混合使用以上对象,出现最多就是shape不对应,index,columns 错误。

最好不要混用不同数据结构,容易出错,更增加转化的性能开销

到此这篇关于python基础知识之索引与切片的文章就介绍到这了,更多相关python索引与切片内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 对Python中list的倒序索引和切片实例讲解

    Python中list的倒序索引和切片是非常常见和方便的操作,但由于是倒序,有时候也不太好理解或者容易搞混. >>> nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> print(nums[-1]) 9 >>> print(nums[-2:]) [8, 9] >>> print(nums[:-3]) [0, 1, 2, 3, 4, 5, 6] 例如,给定一个数组nums. 索引操作 nums[-1]

  • 浅析Python字符串索引、切片、格式化

    目录 1 字符串索引 1.1 循环索引字符 2 字符使用 2.1 字符串运算 3 字符串切片 3.1 切片方法 4 字符串格式化 除了数字,Python中最常见的数据类型就是字符串,无论那种编程语言,字符串无处不在.例如,从用户哪里读取字符串,并将字符串打印到屏幕显示出来. 字符串是一种数据结构,这让我们有机会学习索引和切片--用于从字符串中提取子串的方法. 1 字符串索引 在Python语法支持中,我们简单的阐述过字符串的使用,现在我们看看python程序在处理字符串时,如何对其进行索引,打印

  • Python 切片索引越界的问题(数组下标越界)

    前言 Python语言处理字符串.数组类的问题时有一定概率需要使用切片方法,比如:Leetcode_5. 学习官方解法时发现切片的索引可以超出字符串或数组最大索引值,此时编译器不会报错. 欢迎大佬留言说明这种情况的具体原因,本文只进行一些情况的简单测试. 实例代码 a = '123' b = a[:5] print(b) 发现结果为123,编译器没有报错.而当直接使用a[5]时即报错string index out of range.下面是测试结果. 测试代码(字符串) a = "1234567

  • python 实现列表的切片操作允许索引超出范围

    其余的不说, 列表切片操作允许索引超出范围: 补充:关于python3报错列表索引超出界限的解决方法 python3报错: IndexError: list index out of rang 这个可能是因为在取索引的时候列表里面没有元素了或者不够,那这样自然取不出来了,会报告说超出界限,这样子的话我们可以给这句代码一个if判断,让它如果里面有元素或元素够了才让它取出来,就不会报错了! 补充:Python_怎么利用切片从列表中取出一部分使用 我想从列表中取出一部分拿来使用,可以创建切片,指定需要

  • Python切片索引用法示例

    本文实例讲述了Python切片索引用法.分享给大家供大家参考,具体如下: 在Python中,可以用用简单的方括号加一个下标的方式访问序列的每一个元素,这种方式称之为切片操作符,切片操作符有三种形式: [],[:],[::] 访问某一数据元素的语法如下: sequence[index] sequence是序列的名字,index是访问元素的对应的偏移量,为正数,0<=index<=len(sequence)-1:使用负索引的时候,其范围为-len(sequence) <=index <

  • python numpy数组的索引和切片的操作方法

    NumPy - 简介 NumPy 是一个 Python 包. 它代表 "Numeric Python". 它是一个由多维数组对象和用于处理数组的例程集合组成的库. Numeric,即 NumPy 的前身,是由 Jim Hugunin 开发的. 也开发了另一个包 Numarray ,它拥有一些额外的功能. 2005年,Travis Oliphant 通过将 Numarray 的功能集成到 Numeric 包中来创建 NumPy 包. 这个开源项目有很多贡献者. NumPy 操作 使用Nu

  • python基础知识之索引与切片详解

    目录 基本索引 嵌套索引 切片 numpy.array 索引 一维 numpy.array 索引 二维 pandas Series 索引 pandas DataFrame 索引 填坑 总结 基本索引 In [4]: sentence = 'You are a nice girl'In [5]: L = sentence.split()In [6]: LOut[6]: ['You', 'are', 'a', 'nice', 'girl'] # 从0开始索引In [7]: L[2]Out[7]: '

  • Python基础之Numpy的基本用法详解

    一.数据生成 1.1 手写数组 a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) # 一维数组 b = np.array([[1, 2], [3, 4]]) #二维数组 1.2 序列数组 numpy.arange(start, stop, step, dtype),start默认0,step默认1 c = np.arange(0, 10, 1, dtype=int) # =np.arange(10) [0 1 2 3 4 5 6 7 8 9] d

  • numpy中索引和切片详解

    索引和切片 一维数组 一维数组很简单,基本和列表一致. 它们的区别在于数组切片是原始数组视图(这就意味着,如果做任何修改,原始都会跟着更改). 这也意味着,如果不想更改原始数组,我们需要进行显式的复制,从而得到它的副本(.copy()). import numpy as np #导入numpy arr = np.arange(10) #类似于list的range() arr Out[3]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) arr[4] #索引(注意是从

  • 微信小程序开发数据缓存基础知识辨析及运用实例详解

    提示:这里可以添加本文要记录的大概内容: 例如:随着人工智能的不断发展,机器学习这门技术也越来越重要,很多人都开启了学习机器学习,本文就介绍了机器学习的基础内容. 提示:以下是本篇文章正文内容,下面案例可供参考 一.微信数据缓存是什么? 在实际开发中,在用到一个数据时,我们需要调用api接口去得到,然后渲染在页面中,但是对于一些数据,是经常需要使用的,如果每次使用时都需要调用api接口,会十分麻烦.数据缓存就解决了这个问题,我们可以在初次调用某api得到数据的同时将数据缓存,那么在之后的使用过程

  • python基础之Socket套接字详解

    前言 Python语言提供了Socket套接字来实现网络通信. Python的应用程序通常通过Socket"套接字"向网络发出请求或者应答网络请求,使主机间或者一台计算机上的进程间可以通讯. 服务器和客户端的源代码 服务器端 #coding=utf-8 #创建TCP服务器 import socket import time from time import ctime HOST = '127.0.0.1' PORT = 8080 BUFSIZE=1024 sock = socket.s

  • python基础之停用词过滤详解

    目录 一.什么是停用词 二.加载停用词字典 三.删除停用词 四.分词以及删除停用词 五.直接删除停用词(不分词) 一.什么是停用词 在汉语中,有一类没有多少意义的词语,比如组词"的",连词"以及".副词"甚至",语气词"吧",被称为停用词.一个句子去掉这些停用词,并不影响理解.所以,进行自然语言处理时,我们一般将停用词过滤掉. 而HanLP库提供了一个小巧的停用词字典,它位于Lib\site-packages\pyhanlp\

  • Python基础语法之变量与数据类型详解

    目录 一. 输出函数print 1.1 可以输出数字 1.2 可以输出字符串 1.3 可以输出表达式 1.4 可以输出至文件中 二. 变量与数据类型 2.1 整型 2.2 浮点型 2.3 字符串型 2.4 布尔型 3. 数据类型转换 3.1 int() 3.2 float() 3.3 str() 一. 输出函数print 在python中,print()是可以直接使用的输出函数,将数据输出到控制台上. 1. print函数的使用 1.1 可以输出数字 只要是数字都可以输出 # author: 爪

  • Python基础之类的定义和使用详解

    目录 1.定义类 2.创建类的实例 3.“魔术”方法——_ init () 4.创建类的成员并访问 4.1.创建实例方法并访问 4.2.创建数据成员并访问 5.访问限制 在Python中,类表示具有相同属性和方法的对象的集合.在使用类时,需要先定义类,然后再创建类的实例,通过类的实例就可以访问类中的属性和方法了. 1.定义类 在Python中,类的定义使用class关键字来实现,语法如下: class ClassName:“”“类的帮助信息”“” # 类文本字符串statement # 类体 参

  • Python基础面向对象之继承与派生详解

    目录 一.面向对象三大特征之继承 1.继承的概念 2.继承的本质 3.继承的实操 4.继承后名字查找的顺序 5.经典类与新式类 二.派生 1.派生的概念 2.派生的方法 一.面向对象三大特征之继承 python三大特征: 封装.继承.多态 三者中继承最为核心,实际应用多,感受较为直观 封装和多态略微抽象 1.继承的概念 继承的含义: 在现实生活中,继承表示人与人之间资源的从属关系 例如:儿子继承父亲 在编程的世界中,继承表示类与类之间的资源从属关系 例如:类a继承类b 继承的目的: 在现实生活中

  • Python pandas之多级索引取值详解

    目录 数据需求 需求拆解 需求处理 方法一 方法二 总结 最近发现周围的很多小伙伴们都不太乐意使用pandas,转而投向其他的数据操作库,身为一个数据工作者,基本上是张口pandas,闭口pandas了,故而写下此系列以让更多的小伙伴们爱上pandas. 平台: windows 10 python 3.8 pandas 1.2.4 数据需求 给定一份多级索引数据,查找指定值. 需求拆解 数据提取在pandas中,或者说在python中就是索引式提取,在单层索引中采用.loc或.iloc方法已经非

随机推荐