2022年 11月 5日

python列表索引总结

Python包含6种内建序列:

  • 列表
  • 元组
  • 字符串
  • Unicode字符串
  • buffer对象
  • xrange对象

1.数据结构

数据结构是以某种方式(如通过编号)组合起来的数据元素(如数、字符乃至其他数据结构)集合。在Python中,最基本的数据结构为序列(sequence)。序列中的每个元素都有编号,即其位置或索引,其中第一个元素的索引为0,第二个元素的索引为1,依此类推。在有些编程语言中,从1开始给序列中的元素编号,但从0开始指出相对于序列开头的偏移量。这显得更自然,同时可回绕到序列末尾,用负索引表示序列末尾元素的位置。

2.序列

元组是一种特殊的序列,类似于列表,列表和元组的主要不同在于,列表是可以修改的,而元组不可以。这意味着列表适用于需要中途添加元素的情形,而元组适用于出于某种考虑需要禁止修改序列的情形。禁止修改序列通常出于技术方面的考虑,与Python的内部工作原理相关,这也是有些内置函数返回元组的原因所在。在你自己编写程序时,几乎在所有情况下都可使用列表来代替元组。一种例外情况是将元组用作字典键。在需要处理一系列值时,序列很有用。在数据库中,你可能使用序列来表示人,其中第一个元素为姓名,而第二个元素为年龄。如果使用列表来表示(所有元素都放在方括号内,并用逗号隔开),将类似于下面这样:

>>> edward = ['Edward Gumby', 42]

序列还可包含其他序列,因此可创建一个由数据库中所有人员组成的列表:

  1. >>> edward = ['Edward Gumby', 42]
  2. >>> john = ['John Smith', 50]
  3. >>> database = [edward, john]
  4. >>> database
  5. [['Edward Gumby', 42], ['John Smith', 50]]

有几种操作适用于所有序列,包括索引、切片、相加、相乘和成员资格检查。另外,Python还提供了一些内置函数,可用于确定序列的长度以及找出序列中最大和最小的元素。

3. 索引

序列中的所有元素都有编号——从0开始递增。你可像下面这样使用编号来访问各个元素:

  1. >>> greeting = 'Hello'
  2. >>> greeting[0]
  3. 'H'

字符串就是由字符组成的序列。索引0指向第一个元素,这里为字母H。不同于其他一些语言,Python没有专门用于表示字符的类型,因此一个字符就是只包含一个元素的字符串。

这称为索引(indexing)。你可使用索引来获取元素。这种索引方式适用于所有序列。当你使用负数索引时,Python将从右(即从最后一个元素)开始往左数,因此-1是最后一个元素的位置。

  1. >>> greeting[-1]
  2. 'o'

对于字符串字面量(以及其他的序列字面量),可直接对其执行索引操作,无需先将其赋给变量。这与先赋给变量再对变量执行索引操作的效果是一样的。

  1. >>> 'Hello'[1]
  2. 'e

如果函数调用返回一个序列,可直接对其执行索引操作。例如,如果你只想获取用户输入的年份的第4位,可像下面这样做:

  1. >>> fourth = input('Year: ')[3]
  2. Year: 2005
  3. >>> fourth
  4. '5'

负数索引与正数索引之间存在一个规律:当正数索引+负数索引的绝对值=元素的个数,它们所指的是同一个元素。

  1. # Hello World!:总共有12个元素,含空格和标点符号
  2. print('Hello World!'[8]) # r
  3. print('Hello World!'[-4])# r

4. 切片

 除使用索引来访问单个元素外,还可使用切片(slicing)来访问特定范围内的元素。为此,可使用两个索引,并用冒号分隔:

  1. >>> tag = '<ahref="http://www.python.org">Python web site</a>'
  2. >>> tag[9:30]
  3. 'http://www.python.org'
  4. >>> tag[32:-4]
  5. 'Python web site'

如你所见,切片适用于提取序列的一部分,其中的编号非常重要:第一个索引是包含的第一个元素的编号,但第二个索引是切片后余下的第一个元素的编号。请看下面的示例:

  1. >>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  2. >>> numbers[3:6] [4, 5, 6]
  3. >>> numbers[0:1] [1]

简而言之,你提供两个索引来指定切片的边界,其中第一个索引指定的元素包含在切片内,但第二个索引指定的元素不包含在切片内。

4.1 绝妙的简写

分片用于截取某个范围内的元素,通过:来指定起始区间(左闭右开区间包含左侧索引值对应的元素,但不包含右测索引值对应的元素)。假设你要访问前述数字列表中的最后三个元素,显然可以明确地指定这一点。

  1. >>> numbers[7:10]
  2. [8, 9, 10]

在这里,索引10指的是第11个元素:它并不存在,但确实是到达最后一个元素后再前进一步所处的位置。明白了吗?如果要从列表末尾开始数,可使用负数索引。

  1. >>> numbers[-3:-1]
  2. [8, 9]

然而,这样好像无法包含最后一个元素。如果使用索引0,即到达列表末尾后再前进一步所处的位置,结果将如何呢?结果并不是你想要的。事实上,执行切片操作时,如果第一个索引指定的元素位于第二个索引指定的元素后面(在这里,倒数第3个元素位于第1个元素后面),结果就为空序列。好在你能使用一种简写:如果切片结束于序列末尾,可省略第二个索引。

  1. >>> numbers[-3:]
  2. [8, 9, 10]

同样,如果切片始于序列开头,可省略第一个索引。

  1. >>> numbers[:3]
  2. [1, 2, 3]

实际上,要复制整个序列,可将两个索引都省略。

  1. >>> numbers[:]
  2. [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

4.2 更大的步长

执行切片操作时,你显式或隐式地指定起点和终点,但通常省略另一个参数,即步长。在普通切片中,步长为1。这意味着从一个元素移到下一个元素,因此切片包含起点和终点之间的所有元素。

  1. >>> numbers[0:10:1]
  2. [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

在这个示例中,指定了另一个数。你可能猜到了,这显式地指定了步长。如果指定的步长大于1,将跳过一些元素。例如,步长为2时,将从起点和终点之间每隔一个元素提取一个元素。

  1. >>> numbers[0:10:2]
  2. [1, 3, 5, 7, 9]
  3. numbers[3:6:3]
  4. [4]

显式地指定步长时,也可使用前述简写。例如,要从序列中每隔3个元素提取1个,只需提供步长4即可。

  1. >>> numbers[::4]
  2. [1, 5, 9]

当然,步长不能为0,否则无法向前移动,但可以为负数,即从右向左提取元素。

  1. >>> numbers[8:3:-1]
  2. [9, 8, 7, 6, 5]
  3. >>> numbers[10:0:-2]
  4. [10, 8, 6, 4, 2]

步长为负数时,第一个索引必须比第二个索引大。否则无法取值

  1. >>> numbers[0:10:-2]
  2. []
  3. >>> numbers[::-2]
  4. [10, 8, 6, 4, 2]
  5. >>> numbers[5::-2]
  6. [6, 4, 2]
  7. >>> numbers[:5:-2]
  8. [10, 8]

在这种情况下,要正确地提取颇费思量。如你所见,第一个索引依然包含在内,而第二个索引不包含在内。步长为负数时,第一个索引必须比第二个索引大。当你省略起始和结束索引时:步长为正数时,它从起点移到终点,而步长为负数时,它从终点移到起点。

注意:数据的一些细微区别

  1. num = [1,2,3,4,5,6,7,8,9,10]
  2. num1 = num[-1] # 输出:10 type:int
  3. num2 = num[-1:]# 输出:[10] type:list

‘+’运算

表示两个序列的相连,但是仅对相同类型的序列进行连接操作。举例:

  1. #列表
  2. >>> [1,2,3] + [3,2,1]
  3. [1, 2, 3, 3, 2, 1]
  4. #字符串
  5. >>> 'Hi' + ',' + 'Baby'
  6. 'Hi,Baby'
  7. #元组(tuple)
  8. >>> ('This','is','a') + ('test','case')
  9. ('This', 'is', 'a', 'test', 'case')
  10. #如果序列类型不一致,则会报错
  11. >>> 'Hi' + [1,2]
  12. Traceback (most recent call last):
  13. File "<stdin>", line 1, in <module>
  14. TypeError: cannot concatenate 'str' and 'list' objects

‘*’运算(乘)

‘*’运算表示生成一个元素重复多次的序列,乘法表示将指定序列重复N次以生成一个新的序列,None可以用来初始化序列。

  1. >>>print('hi '*5)
  2. 'hi hi hi hi hi '
  3. >>> print("hello" * 3)
  4. 'hellohellohello'
  5. >>> (1,2,3) * 4 # tuple类型
  6. (1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3)
  7. >>> [1,2,3] * 4 # list类型
  8. [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
  9. >>> [None]*5 # none
  10. [None, None, None, None, None]
  11. >>> 4 * [1,2,3] # 支持交换律
  12. [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

 

参考:

https://blog.csdn.net/jamfiy/article/details/87910881

https://blog.csdn.net/qq_30622831/article/details/81704168

https://blog.csdn.net/wang_weina/article/details/53613099