眾所周知，我們可以通過(guò)索引值（或稱(chēng)下標(biāo)）來(lái)查找序列類(lèi)型（如字符串、列表、元組…）中的單個(gè)元素，那么，如果要獲取一個(gè)索引區(qū)間的元素該怎么辦呢？

切片（slice）就是一種截取索引片段的技術(shù)，借助切片技術(shù)，我們可以十分靈活地處理序列類(lèi)型的對(duì)象。通常來(lái)說(shuō)，切片的作用就是截取序列對(duì)象，然而，對(duì)于非序列對(duì)象，我們是否有辦法做到切片操作呢？在使用切片的過(guò)程中，有什么要點(diǎn)值得重視，又有什么底層原理值得關(guān)注呢？本文將主要跟大家一起來(lái)探討這些內(nèi)容，希望我能與你共同學(xué)習(xí)進(jìn)步。

1、切片的基礎(chǔ)用法

列表是 Python 中極為基礎(chǔ)且重要的一種數(shù)據(jù)結(jié)構(gòu)，也是最能發(fā)揮切片的用處的一種數(shù)據(jù)結(jié)構(gòu)，所以在前兩節(jié)，我將以列表為例介紹切片的一些常見(jiàn)用法。

首先是切片的書(shū)寫(xiě)形式：[i : i+n : m] ；其中，i 是切片的起始索引值，為列表首位時(shí)可省略；i+n 是切片的結(jié)束位置，為列表末位時(shí)可省略；m 可以不提供，默認(rèn)值是1，不允許為0 ，當(dāng)m為負(fù)數(shù)時(shí)，列表翻轉(zhuǎn)。注意：這些值都可以大于列表長(zhǎng)度，不會(huì)報(bào)越界。

切片的基本含義是：從序列的第i位索引起，向右取到后n位元素為止，按m間隔過(guò)濾 。

li = [1, 4, 5, 6, 7, 9, 11, 14, 16]

# 以下寫(xiě)法都可以表示整個(gè)列表，其中 X >= len(li)
li[0:X] == li[0:] == li[:X] == li[:] 
== li[::] == li[-X:X] == li[-X:]

li[1:5] == [4,5,6,7] # 從1起，取5-1位元素
li[1:5:2] == [4,6] # 從1起，取5-1位元素，按2間隔過(guò)濾
li[-1:] == [16] # 取倒數(shù)第一個(gè)元素
li[-4:-2] == [9, 11] # 從倒數(shù)第四起，取-2-(-4)=2位元素
li[:-2] == li[-len(li):-2] 
== [1,4,5,6,7,9,11] # 從頭開(kāi)始，取-2-(-len(li))=7位元素

# 步長(zhǎng)為負(fù)數(shù)時(shí)，列表先翻轉(zhuǎn)，再截取
li[::-1] == [16,14,11,9,7,6,5,4,1] # 翻轉(zhuǎn)整個(gè)列表
li[::-2] == [16,11,7,5,1] # 翻轉(zhuǎn)整個(gè)列表，再按2間隔過(guò)濾
li[:-5:-1] == [16,14,11,9] # 翻轉(zhuǎn)整個(gè)列表，取-5-(-len(li))=4位元素
li[:-5:-3] == [16,9] # 翻轉(zhuǎn)整個(gè)列表，取-5-(-len(li))=4位元素，再按3間隔過(guò)濾

# 切片的步長(zhǎng)不可以為0
li[::0] # 報(bào)錯(cuò)（ValueError: slice step cannot be zero）

上述的某些例子對(duì)于初學(xué)者（甚至很多老手）來(lái)說(shuō)，可能還不好理解，但是它們都離不開(kāi)切片的基本語(yǔ)法，所以為方便起見(jiàn)，我將它們也歸入基礎(chǔ)用法中。

對(duì)于這些樣例，我個(gè)人總結(jié)出兩條經(jīng)驗(yàn)：

（1）牢牢記住公式[i : i+n : m]，當(dāng)出現(xiàn)缺省值時(shí)，通過(guò)想象把公式補(bǔ)全；

（2）索引為負(fù)且步長(zhǎng)為正時(shí)，按倒數(shù)計(jì)算索引位置；索引為負(fù)且步長(zhǎng)為負(fù)時(shí)，先翻轉(zhuǎn)列表，再按倒數(shù)計(jì)算索引位置。

2、切片的高級(jí)用法

一般而言，切片操作的返回結(jié)果是一個(gè)新的獨(dú)立的序列。以列表為例，列表切片后得到的還是一個(gè)列表，占用新的內(nèi)存地址。

當(dāng)取出切片的結(jié)果時(shí)，它是一個(gè)獨(dú)立對(duì)象，因此，可以將其用于賦值操作，也可以用于其它傳遞值的場(chǎng)景。但是，切片只是淺拷貝 ，它拷貝的是原列表中元素的引用，所以，當(dāng)存在變長(zhǎng)對(duì)象的元素時(shí)，新列表將受制于原列表。

li = [1, 2, 3, 4]
ls = li[::]

li == ls # True
id(li) == id(ls) # False
li.append(li[2:4]) # [1, 2, 3, 4, [3, 4]]
ls.extend(ls[2:4]) # [1, 2, 3, 4, 3, 4]

# 下例等價(jià)于判斷l(xiāng)i長(zhǎng)度是否大于8
if(li[8:]):
  print("not empty")
else:
  print("empty")

# 切片列表受制于原列表
lo = [1,[1,1],2,3]
lp = lo[:2] # [1, [1, 1]]
lo[1].append(1) # [1, [1, 1, 1], 2, 3]
lp # [1, [1, 1, 1]]

由于可見(jiàn)，將切片結(jié)果取出，它可以作為獨(dú)立對(duì)象使用，但是也要注意，是否取出了變長(zhǎng)對(duì)象的元素。

切片既可以作為獨(dú)立對(duì)象被“取出”原序列，也可以留在原序列，作為一種占位符使用。

不久前，我介紹了幾種拼接字符串的方法（鏈接見(jiàn)文末），其中三種格式化類(lèi)的拼接方法（即 %、format()、template）就是使用了占位符的思想。對(duì)于列表來(lái)說(shuō)，使用切片作為占位符，同樣能夠?qū)崿F(xiàn)拼接列表的效果。特別需要注意的是，給切片賦值的必須是可迭代對(duì)象。

li = [1, 2, 3, 4]

# 在頭部拼接
li[:0] = [0] # [0, 1, 2, 3, 4]
# 在末尾拼接
li[len(li):] = [5,7] # [0, 1, 2, 3, 4, 5, 7]
# 在中部拼接
li[6:6] = [6] # [0, 1, 2, 3, 4, 5, 6, 7]

# 給切片賦值的必須是可迭代對(duì)象
li[-1:-1] = 6 # （報(bào)錯(cuò)，TypeError: can only assign an iterable）
li[:0] = (9,) # [9, 0, 1, 2, 3, 4, 5, 6, 7]
li[:0] = range(3) # [0, 1, 2, 9, 0, 1, 2, 3, 4, 5, 6, 7]

上述例子中，若將切片作為獨(dú)立對(duì)象取出，那你會(huì)發(fā)現(xiàn)它們都是空列表，即 li[:0]==li[len(li):]==li[6:6]==[] ，我將這種占位符稱(chēng)為“純占位符”，對(duì)純占位符賦值，并不會(huì)破壞原有的元素，只會(huì)在特定的索引位置中拼接進(jìn)新的元素。刪除純占位符時(shí)，也不會(huì)影響列表中的元素。

與“純占位符”相對(duì)應(yīng)，“非純占位符”的切片是非空列表，對(duì)它進(jìn)行操作（賦值與刪除），將會(huì)影響原始列表。如果說(shuō)純占位符可以實(shí)現(xiàn)列表的拼接，那么，非純占位符可以實(shí)現(xiàn)列表的替換。

li = [1, 2, 3, 4]

# 不同位置的替換
li[:3] = [7,8,9] # [7, 8, 9, 4]
li[3:] = [5,6,7] # [7, 8, 9, 5, 6, 7]
li[2:4] = ['a','b'] # [7, 8, 'a', 'b', 6, 7]

# 非等長(zhǎng)替換
li[2:4] = [1,2,3,4] # [7, 8, 1, 2, 3, 4, 6, 7]
li[2:6] = ['a'] # [7, 8, 'a', 6, 7]

# 刪除元素
del li[2:3] # [7, 8, 6, 7]

切片占位符可以帶步長(zhǎng)，從而實(shí)現(xiàn)連續(xù)跨越性的替換或刪除效果。需要注意的是，這種用法只支持等長(zhǎng)替換。

li = [1, 2, 3, 4, 5, 6]

li[::2] = ['a','b','c'] # ['a', 2, 'b', 4, 'c', 6]
li[::2] = [0]*3 # [0, 2, 0, 4, 0, 6]
li[::2] = ['w'] # 報(bào)錯(cuò)，attempt to assign sequence of size 1 to extended slice of size 3

del li[::2] # [2, 4, 6]

3、自定義對(duì)象實(shí)現(xiàn)切片功能

切片是 Python 中最迷人最強(qiáng)大最 Amazing 的語(yǔ)言特性（幾乎沒(méi)有之一），以上兩小節(jié)雖然介紹了切片的基礎(chǔ)用法與高級(jí)用法，但這些還不足以充分地展露切片的魅力，所以，在接下來(lái)的兩章節(jié)中，我們將聚焦于它的更高級(jí)用法。

前兩節(jié)內(nèi)容都是基于原生的序列類(lèi)型（如字符串、列表、元組……），那么，我們是否可以定義自己的序列類(lèi)型并讓它支持切片語(yǔ)法呢？更進(jìn)一步，我們是否可以自定義其它對(duì)象（如字典）并讓它支持切片呢？

3.1、魔術(shù)方法：`getitem()`

想要使自定義對(duì)象支持切片語(yǔ)法并不難，只需要在定義類(lèi)的時(shí)候給它實(shí)現(xiàn)魔術(shù)方法 __getitem__() 即可。所以，這里就先介紹一下這個(gè)方法。

語(yǔ)法：object.__getitem__(self, key)

官方文檔釋義：Called to implement evaluation of self[key]. For sequence types, the accepted keys should be integers and slice objects. Note that the special interpretation of negative indexes (if the class wishes to emulate a sequence type) is up to the __getitem__() method. If key is of an inappropriate type, TypeError may be raised; if of a value outside the set of indexes for the sequence (after any special interpretation of negative values), IndexError should be raised. For mapping types, if key is missing (not in the container), KeyError should be raised.

概括翻譯一下： __getitem__() 方法用于返回參數(shù) key 所對(duì)應(yīng)的值，這個(gè) key 可以是整型數(shù)值和切片對(duì)象，并且支持負(fù)數(shù)索引；如果 key 不是以上兩種類(lèi)型，就會(huì)拋 TypeError；如果索引越界，會(huì)拋 IndexError ；如果定義的是映射類(lèi)型，當(dāng) key 參數(shù)不是其對(duì)象的鍵值時(shí)，則會(huì)拋 KeyError 。

3.2、自定義序列實(shí)現(xiàn)切片功能

接下來(lái)，我們定義一個(gè)簡(jiǎn)單的 MyList ，并給它加上切片功能。（PS：僅作演示，不保證其它功能的完備性）。

import numbers

class MyList():
  def __init__(self, anylist):
    self.data = anylist
  def __len__(self):
    return len(self.data)
  def __getitem__(self, index):
    print("key is : " + str(index))
    cls = type(self)
    if isinstance(index, slice):
      print("data is : " + str(self.data[index]))
      return cls(self.data[index])
    elif isinstance(index, numbers.Integral):
      return self.data[index]
    else:
      msg = "{cls.__name__} indices must be integers"
      raise TypeError(msg.format(cls=cls))

l = MyList(["My", "name", "is", "Python貓"])

### 輸出結(jié)果：
key is : 3
Python貓
key is : slice(None, 2, None)
data is : ['My', 'name']
<__main__.MyList object at 0x0000019CD83A7A90>
key is : hi
Traceback (most recent call last):
...
TypeError: MyList indices must be integers or slices

從輸出結(jié)果來(lái)看，自定義的 MyList 既支持按索引查找，也支持切片操作，這正是我們的目的。

3.3、自定義字典實(shí)現(xiàn)切片功能

切片是序列類(lèi)型的特性，所以在上例中，我們不需要寫(xiě)切片的具體實(shí)現(xiàn)邏輯。但是，對(duì)于其它非序列類(lèi)型的自定義對(duì)象，就得自己實(shí)現(xiàn)切片邏輯。以自定義字典為例（PS：僅作演示，不保證其它功能的完備性）：

class MyDict():
  def __init__(self):
    self.data = {}
  def __len__(self):
    return len(self.data)
  def append(self, item):
    self.data[len(self)] = item
  def __getitem__(self, key):
    if isinstance(key, int):
      return self.data[key]
    if isinstance(key, slice):
      slicedkeys = list(self.data.keys())[key]
      return {k: self.data[k] for k in slicedkeys}
    else:
      raise TypeError

d = MyDict()
d.append("My")
d.append("name")
d.append("is")
d.append("Python貓")
print(d[2])
print(d[:2])
print(d[-4:-2])
print(d['hi'])

### 輸出結(jié)果：
is
{0: 'My', 1: 'name'}
{0: 'My', 1: 'name'}
Traceback (most recent call last):
...
TypeError

上例的關(guān)鍵點(diǎn)在于將字典的鍵值取出，并對(duì)鍵值的列表做切片處理，其妙處在于，不用擔(dān)心索引越界和負(fù)數(shù)索引，將字典切片轉(zhuǎn)換成了字典鍵值的切片，最終實(shí)現(xiàn)目的。

4、迭代器實(shí)現(xiàn)切片功能

好了，介紹完一般的自定義對(duì)象如何實(shí)現(xiàn)切片功能，這里將迎來(lái)另一類(lèi)非同一般的對(duì)象。

迭代器是 Python 中獨(dú)特的一種高級(jí)對(duì)象，它本身不具備切片功能，然而若能將它用于切片，這便仿佛是錦上添花，能達(dá)到如虎添翼的效果。所以，本節(jié)將隆重地介紹迭代器如何實(shí)現(xiàn)切片功能。

4.1、迭代與迭代器

首先，有幾個(gè)基本概念要澄清：迭代、可迭代對(duì)象、迭代器。

迭代 是一種遍歷容器類(lèi)型對(duì)象（例如字符串、列表、字典等等）的方式，例如，我們說(shuō)迭代一個(gè)字符串“abc”，指的就是從左往右依次地、逐個(gè)地取出它的全部字符的過(guò)程。（PS：漢語(yǔ)中迭代一詞有循環(huán)反復(fù)、層層遞進(jìn)的意思，但 Python 中此詞要理解成單向水平線性的，如果你不熟悉它，我建議直接將其理解為遍歷。）

那么，怎么寫(xiě)出迭代操作的指令呢？最通用的書(shū)寫(xiě)語(yǔ)法就是 for 循環(huán)。

# for循環(huán)實(shí)現(xiàn)迭代過(guò)程
for char in "abc":
  print(char, end=" ")
# 輸出結(jié)果：a b c

for 循環(huán)可以實(shí)現(xiàn)迭代的過(guò)程，但是，并非所有對(duì)象都可以用于 for 循環(huán)，例如，上例中若將字符串“abc”換成任意整型數(shù)字，則會(huì)報(bào)錯(cuò)： 'int' object is not iterable .

這句報(bào)錯(cuò)中的單詞“iterable”指的是“可迭代的”，即 int 類(lèi)型不是可迭代的。而字符串（string）類(lèi)型是可迭代的，同樣地，列表、元組、字典等類(lèi)型，都是可迭代的。

那怎么判斷一個(gè)對(duì)象是否可迭代呢？為什么它們是可迭代的呢？怎么讓一個(gè)對(duì)象可迭代呢？

要使一個(gè)對(duì)象可迭代，就要實(shí)現(xiàn)可迭代協(xié)議，即需要實(shí)現(xiàn)__iter__() 魔術(shù)方法，換言之，只要實(shí)現(xiàn)了這個(gè)魔術(shù)方法的對(duì)象都是可迭代對(duì)象。

那怎么判斷一個(gè)對(duì)象是否實(shí)現(xiàn)了這個(gè)方法呢？除了上述的 for 循環(huán)外，我還知道四種方法：

# 方法1：dir()查看__iter__
dir(2)   # 沒(méi)有，略
dir("abc") # 有，略

# 方法2：isinstance()判斷
import collections
isinstance(2, collections.Iterable)   # False
isinstance("abc", collections.Iterable) # True

# 方法3：hasattr()判斷
hasattr(2,"__iter__")   # False
hasattr("abc","__iter__") # True

# 方法4：用iter()查看是否報(bào)錯(cuò)
iter(2)   # 報(bào)錯(cuò)：'int' object is not iterable
iter("abc") # <str_iterator at 0x1e2396d8f28>

### PS：判斷是否可迭代，還可以查看是否實(shí)現(xiàn)__getitem__，為方便描述，本文從略。

這幾種方法中最值得一提的是 iter() 方法，它是 Python 的內(nèi)置方法，其作用是將可迭代對(duì)象變成迭代器 。這句話可以解析出兩層意思：（1）可迭代對(duì)象跟迭代器是兩種東西；（2）可迭代對(duì)象能變成迭代器。

實(shí)際上，迭代器必然是可迭代對(duì)象，但可迭代對(duì)象不一定是迭代器。兩者有多大的區(qū)別呢？

如上圖藍(lán)圈所示，普通可迭代對(duì)象與迭代器的最關(guān)鍵區(qū)別可概括為：一同兩不同 ，所謂“一同”，即兩者都是可迭代的（__iter__），所謂“兩不同”，即可迭代對(duì)象在轉(zhuǎn)化為迭代器后，它會(huì)丟失一些屬性（__getitem__），同時(shí)也增加一些屬性（__next__）。

首先看看增加的屬性 __next__ ， 它是迭代器之所以是迭代器的關(guān)鍵，事實(shí)上，我們正是把同時(shí)實(shí)現(xiàn)了 __iter__ 方法 和 __next__ 方法的對(duì)象定義為迭代器的。

有了多出來(lái)的這個(gè)屬性，可迭代對(duì)象不需要借助外部的 for 循環(huán)語(yǔ)法，就能實(shí)現(xiàn)自我的迭代/遍歷過(guò)程。我發(fā)明了兩個(gè)概念來(lái)描述這兩種遍歷過(guò)程（PS：為了易理解，這里稱(chēng)遍歷，實(shí)際也可稱(chēng)為迭代）：它遍歷 指的是通過(guò)外部語(yǔ)法而實(shí)現(xiàn)的遍歷，自遍歷 指的是通過(guò)自身方法實(shí)現(xiàn)的遍歷。

借助這兩個(gè)概念，我們說(shuō)，可迭代對(duì)象就是能被“它遍歷”的對(duì)象，而迭代器是在此基礎(chǔ)上，還能做到“自遍歷”的對(duì)象。

ob1 = "abc"
ob2 = iter("abc")
ob3 = iter("abc")

# ob1它遍歷
for i in ob1:
  print(i, end = " ")  # a b c
for i in ob1:
  print(i, end = " ")  # a b c
# ob1自遍歷
ob1.__next__() # 報(bào)錯(cuò)： 'str' object has no attribute '__next__'

# ob2它遍歷
for i in ob2:
  print(i, end = " ")  # a b c  
for i in ob2:
  print(i, end = " ")  # 無(wú)輸出
# ob2自遍歷
ob2.__next__() # 報(bào)錯(cuò)：StopIteration

# ob3自遍歷
ob3.__next__() # a
ob3.__next__() # b
ob3.__next__() # c
ob3.__next__() # 報(bào)錯(cuò)：StopIteration

通過(guò)上述例子可看出，迭代器的優(yōu)勢(shì)在于支持自遍歷，同時(shí)，它的特點(diǎn)是單向非循環(huán)的，一旦完成遍歷，再次調(diào)用就會(huì)報(bào)錯(cuò)。

對(duì)此，我想到一個(gè)比方：普通可迭代對(duì)象就像是子彈匣，它遍歷就是取出子彈，在完成操作后又裝回去，所以可以反復(fù)遍歷（即多次調(diào)用for循環(huán)，返回相同結(jié)果）；而迭代器就像是裝載了子彈匣且不可拆卸的槍?zhuān)M(jìn)行它遍歷或者自遍歷都是發(fā)射子彈，這是消耗性的遍歷，是無(wú)法復(fù)用的（即遍歷會(huì)有盡頭）。

寫(xiě)了這么多，稍微小結(jié)一下：迭代是一種遍歷元素的方式，按照實(shí)現(xiàn)方式劃分，有外部迭代與內(nèi)部迭代兩種，支持外部迭代（它遍歷）的對(duì)象就是可迭代對(duì)象，而同時(shí)還支持內(nèi)部迭代（自遍歷）的對(duì)象就是迭代器；按照消費(fèi)方式劃分，可分為復(fù)用型迭代與一次性迭代，普通可迭代對(duì)象是復(fù)用型的，而迭代器是一次性的。

4.2、迭代器切片

前面提到了“一同兩不同”，最后的不同是，普通可迭代對(duì)象在轉(zhuǎn)化成迭代器的過(guò)程中會(huì)丟失一些屬性，其中關(guān)鍵的屬性是 __getitem__ 。在前一節(jié)中，我已經(jīng)介紹了這個(gè)魔術(shù)方法，并用它實(shí)現(xiàn)了自定義對(duì)象的切片特性。

那么問(wèn)題來(lái)了：為啥迭代器不繼承這個(gè)屬性呢？

首先，迭代器使用的是消耗型的遍歷，這意味著它充滿不確定性，即其長(zhǎng)度與索引鍵值對(duì)是動(dòng)態(tài)衰減的，所以很難 get 到它的 item ，也就不再需要 __getitem__ 屬性了。其次，若強(qiáng)行給迭代器加上這個(gè)屬性，這并不合理，正所謂強(qiáng)扭的瓜不甜……

由此，新的問(wèn)題來(lái)了：既然會(huì)丟失這么重要的屬性（還包括其它未標(biāo)識(shí)的屬性），為什么還要使用迭代器呢？

這個(gè)問(wèn)題的答案在于，迭代器擁有不可替代的強(qiáng)大的有用的功能，使得 Python 要如此設(shè)計(jì)它。限于篇幅，此處不再展開(kāi)，后續(xù)我會(huì)專(zhuān)門(mén)填坑此話題。

還沒(méi)完，死纏爛打的問(wèn)題來(lái)了：能否令迭代器擁有這個(gè)屬性呢，即令迭代器繼續(xù)支持切片呢？

hi = "歡迎關(guān)注公眾號(hào)：Python貓"
it = iter(hi)

# 普通切片
hi[-7:] # Python貓

# 反例：迭代器切片
it[-7:] # 報(bào)錯(cuò)：'str_iterator' object is not subscriptable

迭代器因?yàn)槿鄙賍_getitem__ ，因此不能使用普通的切片語(yǔ)法。想要實(shí)現(xiàn)切片，無(wú)非兩種思路：一是自己造輪子，寫(xiě)實(shí)現(xiàn)的邏輯；二是找到封裝好的輪子。

Python 的 itertools 模塊就是我們要找的輪子，用它提供的方法可輕松實(shí)現(xiàn)迭代器切片。

import itertools

# 例1：簡(jiǎn)易迭代器
s = iter("123456789")
for x in itertools.islice(s, 2, 6):
  print(x, end = " ")  # 輸出：3 4 5 6
for x in itertools.islice(s, 2, 6):
  print(x, end = " ")  # 輸出：9

# 例2：斐波那契數(shù)列迭代器
class Fib():
  def __init__(self):
    self.a, self.b = 1, 1

  def __iter__(self):
    while True:
      yield self.a
      self.a, self.b = self.b, self.a + self.b
f = iter(Fib())
for x in itertools.islice(f, 2, 6):
  print(x, end = " ") # 輸出：2 3 5 8
for x in itertools.islice(f, 2, 6):
  print(x, end = " ") # 輸出：34 55 89 144

itertools 模塊的 islice() 方法將迭代器與切片完美結(jié)合，終于回答了前面的問(wèn)題。然而，迭代器切片跟普通切片相比，前者有很多局限性。首先，這個(gè)方法不是“純函數(shù)”（純函數(shù)需遵守“相同輸入得到相同輸出”的原則）；其次，它只支持正向切片，且不支持負(fù)數(shù)索引，這都是由迭代器的損耗性所決定的。

那么，我不禁要問(wèn)：itertools 模塊的切片方法用了什么實(shí)現(xiàn)邏輯呢？下方是官網(wǎng)提供的源碼：

def islice(iterable, *args):
  # islice('ABCDEFG', 2) --> A B
  # islice('ABCDEFG', 2, 4) --> C D
  # islice('ABCDEFG', 2, None) --> C D E F G
  # islice('ABCDEFG', 0, None, 2) --> A C E G
  s = slice(*args)
  # 索引區(qū)間是[0,sys.maxsize]，默認(rèn)步長(zhǎng)是1
  start, stop, step = s.start or 0, s.stop or sys.maxsize, s.step or 1
  it = iter(range(start, stop, step))
  try:
    nexti = next(it)
  except StopIteration:
    # Consume *iterable* up to the *start* position.
    for i, element in zip(range(start), iterable):
      pass
    return
  try:
    for i, element in enumerate(iterable):
      if i == nexti:
        yield element
        nexti = next(it)
  except StopIteration:
    # Consume to *stop*.
    for i, element in zip(range(i + 1, stop), iterable):
      pass

islice() 方法的索引方向是受限的，但它也提供了一種可能性：即允許你對(duì)一個(gè)無(wú)窮的（在系統(tǒng)支持范圍內(nèi)）迭代器進(jìn)行切片的能力。這是迭代器切片最具想象力的用途場(chǎng)景。

除此之外，迭代器切片還有一個(gè)很實(shí)在的應(yīng)用場(chǎng)景：讀取文件對(duì)象中給定行數(shù)范圍的數(shù)據(jù)。

我們知道，從文件中讀取內(nèi)容主要有兩種方法（參見(jiàn)之前關(guān)于文件讀寫(xiě)的文章）：read() 適合讀取內(nèi)容較少的情況，或者是需要一次性處理全部?jī)?nèi)容的情況；而 readlines() 適用性更廣，因?yàn)樗堑刈x取內(nèi)容，既減少內(nèi)存壓力，又方便逐行對(duì)數(shù)據(jù)處理。

雖然 readlines() 有迭代讀取的優(yōu)勢(shì)，但它是從頭到尾逐行讀取，若文件有幾千行，而我們只想要讀取少數(shù)特定行（例如第1000-1009行），那它還是效率太低了。考慮到文件對(duì)象天然就是迭代器 ，我們可以使用迭代器切片先行截取，然后再處理，如此效率將大大地提升。

# test.txt 文件內(nèi)容
'''
貓
Python貓
python is a cat.
this is the end.
'''

from itertools import islice
with open('test.txt','r',encoding='utf-8') as f:
  print(hasattr(f, "__next__")) # 判斷是否迭代器
  content = islice(f, 2, 4)
  for line in content:
    print(line.strip())

### 輸出結(jié)果：
True
python is a cat.
this is the end.

本節(jié)內(nèi)容較多，簡(jiǎn)單回顧一下：迭代器是一種特殊的可迭代對(duì)象，可用于它遍歷與自遍歷，但遍歷過(guò)程是損耗型的，不具備循環(huán)復(fù)用性，因此，迭代器本身不支持切片操作；通過(guò)借助 itertools 模塊，我們能實(shí)現(xiàn)迭代器切片，將兩者的優(yōu)勢(shì)相結(jié)合，其主要用途在于截取大型迭代器（如無(wú)限數(shù)列、超大文件等等）的片段，實(shí)現(xiàn)精準(zhǔn)的處理，從而大大地提升性能與效率。

5、小結(jié)

最后總結(jié)一下，切片是 Python 的一種高級(jí)特性，常用于截取序列類(lèi)型的元素，但并不局限于此，本文主要介紹了它的基礎(chǔ)用法、高級(jí)用法（如占位符用法）、自定義對(duì)象切片、以及迭代器切片等使用內(nèi)容。除此之外，切片還有更廣闊多樣的使用場(chǎng)景，例如 Numpy 的多維切片、內(nèi)存視圖切片、異步迭代器切片等等，都值得我們?nèi)ヌ剿饕环?br />

以上就是本文的全部?jī)?nèi)容，希望對(duì)大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。