1: 基本切片

对于任何可迭代对象（例如 string、list 等），Python 都允许您对其数据进行切分并返回子串或子列表。

切分格式

iterable_name[start:stop:step]

其中

• start 是片段的第一个索引。默认为 0（第一个元素的索引）
• stop 是分片最后一个索引之后的一个索引。默认为 len(iterable)
• step 是步长（下面的示例可以更好地解释这一点）

示例

a = "abcdef"
a # "abcdef"
  # Same as a[:] or a[::] since it uses the defaults for all three indices
a[-1] # "f"
a[:] # "abcdef"
a[::] # "abcdef"
a[3:] # "def" (from index 3, to end(defaults to size of iterable))
a[:4] # "abcd" (from beginning(default 0) to position 4 (excluded))
a[2:4] # "cd" (from position 2, to position 4 (excluded))

此外，上述任何一种方法都可以使用已定义的步长：

a[::2] # "ace" (every 2nd element)
a[1:4:2] # "bd" (from index 1, to index 4 (excluded), every 2nd element)

指数可以是负数，在这种情况下，指数从序列末尾开始计算

a[:-1] # "abcde" (from index 0 (default), to the second last element (last element - 1))
a[:-2] # "abcd" (from index 0 (default), to the third last element (last element -2))
a[-1:] # "f" (from the last element to the end (default len())

步长也可以是负数，在这种情况下，slice 会以相反的顺序遍历列表：

a[3:1:-1] # "dc" (from index 2 to None (default), in reverse order)

该结构可用于反转可迭代

a[::-1] # "fedcba" (from last element (default len()-1), to first, in reverse order(-1))

请注意，对于负步长，默认的 end_index 是 None （参见
http://stackoverflow.com/a/12521981 )

a[5:None:-1] # "fedcba" (this is equivalent to a[::-1])
a[5:0:-1] # "fedcb" (from the last element (index 5) to second element (index 1)

2: 反转对象

你可以使用分片来非常容易地反转 str、list 或 tuple（或者基本上任何使用步长参数实现分片的集合对象）。下面是一个反转字符串的示例，尽管这同样适用于上面列出的其他类型：

s = 'reverse me!'
s[::-1] # '!em esrever'

让我们快速了解一下语法。[::-1]"表示切片应从字符串的开头一直切到结尾（因为省略了开头和结尾），步长为-1 表示应在字符串中反向移动。

3: Slice assignment

使用片段的另一个巧妙功能是片段赋值。Python 允许您在一次操作中分配新的片段来替换列表中的旧片段。

这意味着，如果您有一个 list，您可以在一次赋值中替换多个成员：

lst = [1, 2, 3]
lst[1:3] = [4, 5]
print(lst) # Out: [1, 4, 5]

因此，如果您想用大小不同的新切片替换旧切片，也是可以的：

lst = [1, 2, 3, 4, 5]
lst[1:4] = [6]
print(lst) # Out: [1, 6, 5]

也可以使用已知的切分语法来完成替换整个列表等操作：

lst = [1, 2, 3]
lst[:] = [4, 5, 6]
print(lst) # Out: [4, 5, 6]

或者只有最后两名成员：

lst = [1, 2, 3]
lst[-2:] = [4, 5, 6]
print(lst) # Out: [1, 4, 5, 6]

4: 制作数组的浅层副本

复制数组的快速方法（而不是为变量赋值，使其具有对原始数组的另一个引用）是

arr[:]

让我们来看看语法。[:] 表示省略了 start、end 和 slice。它们的默认值分别是 0、len(arr) 和 1，这意味着我们请求的子数组将包含 arr 从开始到结束的所有元素。

实际上，这看起来像

arr = ['a', 'b', 'c']
copy = arr[:]
arr.append('d')
print(arr) # ['a', 'b', 'c', 'd']
print(copy) # ['a', 'b', 'c']

可以看到，ar.append('d') 将 d 添加到了 arr 中，但copy 保持不变！

请注意，这只是浅层复制，与 arr.copy() 相同。

Section 64.5: 索引自定义类： __getitem__, __setitem__和 delitem`

class MultiIndexingList:
  def __init__(self, value):
    self.value = value

  def __repr__(self):
    return repr(self.value)

  def __getitem__(self, item):
    if isinstance(item, (int, slice)):
      return self.__class__(self.value[item])
    return [self.value[i] for i in item]

  def __setitem__(self, item, value):
    if isinstance(item, int):
      self.value[item] = value
    elif isinstance(item, slice):
      raise ValueError('Cannot interpret slice with multiindexing')
    else:
      for i in item:
        if isinstance(i, slice):
          raise ValueError('Cannot interpret slice with multiindexing')
          self.value[i] = value

  def __delitem__(self, item):
    if isinstance(item, int):
      del self.value[item]
    elif isinstance(item, slice):
      del self.value[item]
    else:
      if any(isinstance(elem, slice) for elem in item):
        raise ValueError('Cannot interpret slice with multiindexing')
      item = sorted(item, reverse=True)
      for elem in item:
        del self.value[elem]

这样就可以对元素访问进行切分和索引：

a = MultiIndexingList([1,2,3,4,5,6,7,8])
a
# Out: [1, 2, 3, 4, 5, 6, 7, 8]

a[1,5,2,6,1]
# Out: [2, 6, 3, 7, 2]

a[4, 1, 5:, 2, ::2]
# Out: [5, 2, [6, 7, 8], 3, [1, 3, 5, 7]]
# 4|1-|----50:---|2-|-----::2----- <-- indicated which element came from which index

而设置和删除元素只允许使用逗号分隔的整数索引（不允许分片）：

a[4] = 1000
a
# Out: [1, 2, 3, 4, 1000, 6, 7, 8]

a[2,6,1] = 100
a
# Out: [1, 100, 100, 4, 1000, 6, 100, 8]

del a[5]
a
# Out: [1, 100, 100, 4, 1000, 100, 8]

del a[4,2,5]
a
# Out: [1, 100, 4, 8]

6: 基本索引编制

Python 列表以 0 为基础，即列表中的第一个元素可以通过索引 0 访问

arr = ['a', 'b', 'c', 'd']
print(arr[0])
'a'

您可以通过索引 1 访问列表中的第二个元素，通过索引 2 访问第三个元素，以此类推：

print(arr[1])
'b'
print(arr[2])
'c'

您还可以使用负索引访问列表末尾的元素，例如，索引-1 将显示列表的最后一个元素，索引-2 将显示列表倒数第二个元素：

print(arr[-1])
'd'
print(arr[-2])
'c'

如果尝试访问列表中不存在的索引，则会引发 IndexError：

print(arr[6])
Traceback (most recent call last):
File "", line 1, in 
IndexError: list index out of range