python列表索引总结

Python包含6种内建序列：

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

1.数据结构

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

2.序列

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

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

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

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

>>> john = ['John Smith', 50]
>>> database = [edward, john]
>>> database
[['Edward Gumby', 42], ['John Smith', 50]]

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

3. 索引

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

>>> greeting = 'Hello'
>>> greeting[0]
'H'

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

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

>>> greeting[-1]
'o'

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

>>> 'Hello'[1]
'e

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

>>> fourth = input('Year: ')[3]
Year: 2005
>>> fourth
'5'

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

# Hello World!：总共有12个元素，含空格和标点符号
print('Hello World!'[8]) # r
print('Hello World!'[-4])# r

4. 切片

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

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

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

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

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

4.1 绝妙的简写

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

>>> numbers[7:10]
[8, 9, 10]

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

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

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

>>> numbers[-3:]
[8, 9, 10]

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

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

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

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

4.2 更大的步长

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

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

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

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

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

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

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

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

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

>>> numbers[0:10:-2]         
[]
>>> numbers[::-2]
[10, 8, 6, 4, 2]

>>> numbers[5::-2]
[6, 4, 2]
>>> numbers[:5:-2]
[10, 8]

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

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

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

‘+’运算

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

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

‘*’运算（乘）

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

>>>print('hi '*5)
'hi hi hi hi hi '
>>> print("hello" * 3)
'hellohellohello'
>>> (1,2,3) * 4 # tuple类型
(1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3)
>>> [1,2,3] * 4 # list类型
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> [None]*5 # none
[None, None, None, None, None]
>>> 4 * [1,2,3] # 支持交换律
[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