chapter14.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 可迭代的对象、迭代器、生成器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 迭代\n",
    "- 目的：惰性获取数据\n",
    "- 所有生成器都是迭代器，迭代器用于从集合中去除元素，而生成器用于凭空生成元素\n",
    "- 生成器可以在无穷集合中生成"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import reprlib\n",
    "from random import randint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第一版sentence类\n",
    "- 通过将句子划分成序列，实现迭代"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "RE_WORD = re.compile('\\w+')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Sentence:\n",
    "    def __init__(self, text):\n",
    "        self.text = text\n",
    "        self.words = RE_WORD.findall(text)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        return self.words[index]\n",
    "\n",
    "    def __len__(self, index):\n",
    "        return len(self.words)\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'Sentence(%s)' % reprlib.repr(self.text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## iter\n",
    "- 解释器需要迭代对象x时，会自动调用iter(x)\n",
    "- 检查顺序：对象是否实现了``__iter__``，实现了就获取迭代器->是否实现``__getitem__``方法，是吸纳了就创建迭代器->抛出typeerror异常"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 可迭代对象、迭代器\n",
    "- 两者不同，python从可迭代的对象中获取迭代器，可迭代的对象是吸纳了``__iter__``方法返回迭代器\n",
    "- for语句隐含实现了获取迭代器，再进行迭代\n",
    "- for、列表推导、元组拆包都自动捕获StopIteration，保证正常迭代直至结束\n",
    "- 迭代器的定义：**实现了无参数的``__next__``方法，返回序列中的下一个元素；如果没有元素了，那么抛出StopIteration异常。Python中的迭代器还实现了``__iter__``方法，因此迭代器也可以迭代**\n",
    "- 可迭代的对象包含``__iter__``方法，每次都实例化返回一个新的迭代器；迭代器要实现``__next__``方法，返回单个元素，此外还要实现``__iter__``方法，返回迭代器本身。即：迭代器可以迭代，但是可迭代的对象不是迭代器。\n",
    "- 一般不建议让一个类既是可迭代的对象，又是迭代器，因为我们需要能从同一个可迭代的实例中获取多个独立的迭代器，而且各个迭代器要能维护自身的内部状态。要实现这样就需要将迭代的实现放在可迭代对象的``__iter__``方法中，每次实例化一个新的迭代器，而不是在可迭代对象中直接实现``__next__``方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 实现标准的迭代器接口\n",
    "- 包含``__next__``和``__iter__``两个接口\n",
    "- 两个接口再collections.abc.Iterator中定义\n",
    "    - Iterator类定义了``__next__``抽象方法\n",
    "    - Iterator类继承自Iterable类\n",
    "    - Iterable类定义了``__iter__``抽象方法\n",
    "    - ``Iterable.__iter__``方法返回一个Iterator实例\n",
    "    - 具体的Iterator类必须实现``__next__``方法\n",
    "    - ``Iterator.__iter__``方法直接返回实例本身"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 第二版Sentence类\n",
    "- 这一版Sentence类定义了``__iter__``方法，返回一个迭代器\n",
    "- 因此定义了一个迭代器类，该类实现了``__next__``方法，同时也满足迭代器的定义，实现了``__iter__``方法并返回本身"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Sentence:\n",
    "    def __init__(self, text):\n",
    "        self.text = text\n",
    "        self.words = RE_WORD.findall(text)\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'Sentence(%s)' % reprlib.repr(self.text)\n",
    "\n",
    "    def __iter__(self):\n",
    "        return SentenceIterator(self.words)\n",
    "\n",
    "\n",
    "class SentenceIterator:\n",
    "    def __init__(self, words):\n",
    "        self.words = words\n",
    "        self.index = 0\n",
    "\n",
    "    def __next__(self):\n",
    "        try:\n",
    "            word = self.words[self.index]\n",
    "        except IndexError:\n",
    "            raise StopIteration()\n",
    "        self.index += 1\n",
    "        return word\n",
    "\n",
    "    def __iter__(self):\n",
    "        return self"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 生成器函数\n",
    "- 包含yield关键字的函数就是生成器函数\n",
    "- 调用生成器函数会返回一个生成器对象\n",
    "- 生成器函数会创建一个生成器对象，包装生成器函数的定义体\n",
    "- 把生成器传给next函数时，生成器函数会向前执行到函数体的下一个yield语句，返回yeild后面的产出值\n",
    "- 生成器不会以常规的方式返回值，而是产出值\n",
    "- 生成器函数中的return语句会抛出StopIteration异常"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 第三版Sentence类\n",
    "- 通过生成器函数实现"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Sentence:\n",
    "    def __init__(self, text):\n",
    "        self.text = text\n",
    "        self.words = RE_WORD.findall(text)\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'Sentence(%s)' % reprlib.repr(self.text)\n",
    "\n",
    "    def __iter__(self):\n",
    "        for word in self.words:\n",
    "            yield word\n",
    "        return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 第四版Sentence类\n",
    "- 惰性实现\n",
    "- 只在需要的实现生成单词，而不是一次性生成整个单词列表\n",
    "- findall可以改为惰性实现finditer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Sentence:\n",
    "    def __init__(self, text):\n",
    "        self.text = text\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'Sentence(%s)' % reprlib.repr(self.text)\n",
    "\n",
    "    def __iter__(self):\n",
    "        for match in RE_WORD.finditer(self.text):\n",
    "            yield match.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 第五版Sentence类\n",
    "- 生成器表达式可以理解为列表推导的惰性版本\n",
    "- 生成器表达式是语法糖，完全可以替换成生成器函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Sentence:\n",
    "    def __init__(self, text):\n",
    "        self.text = text\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'Sentence(%s)' % reprlib.repr(self.text)\n",
    "\n",
    "    def __iter__(self):\n",
    "        return (match.group() for match in RE_WORD.finditer(self.text))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## itertools以及内置中包含了许多实现优秀的生成器函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in module itertools:\n",
      "\n",
      "NAME\n",
      "    itertools - Functional tools for creating and using iterators.\n",
      "\n",
      "DESCRIPTION\n",
      "    Infinite iterators:\n",
      "    count(start=0, step=1) --> start, start+step, start+2*step, ...\n",
      "    cycle(p) --> p0, p1, ... plast, p0, p1, ...\n",
      "    repeat(elem [,n]) --> elem, elem, elem, ... endlessly or up to n times\n",
      "    \n",
      "    Iterators terminating on the shortest input sequence:\n",
      "    accumulate(p[, func]) --> p0, p0+p1, p0+p1+p2\n",
      "    chain(p, q, ...) --> p0, p1, ... plast, q0, q1, ... \n",
      "    chain.from_iterable([p, q, ...]) --> p0, p1, ... plast, q0, q1, ... \n",
      "    compress(data, selectors) --> (d[0] if s[0]), (d[1] if s[1]), ...\n",
      "    dropwhile(pred, seq) --> seq[n], seq[n+1], starting when pred fails\n",
      "    groupby(iterable[, keyfunc]) --> sub-iterators grouped by value of keyfunc(v)\n",
      "    filterfalse(pred, seq) --> elements of seq where pred(elem) is False\n",
      "    islice(seq, [start,] stop [, step]) --> elements from\n",
      "           seq[start:stop:step]\n",
      "    starmap(fun, seq) --> fun(*seq[0]), fun(*seq[1]), ...\n",
      "    tee(it, n=2) --> (it1, it2 , ... itn) splits one iterator into n\n",
      "    takewhile(pred, seq) --> seq[0], seq[1], until pred fails\n",
      "    zip_longest(p, q, ...) --> (p[0], q[0]), (p[1], q[1]), ... \n",
      "    \n",
      "    Combinatoric generators:\n",
      "    product(p, q, ... [repeat=1]) --> cartesian product\n",
      "    permutations(p[, r])\n",
      "    combinations(p, r)\n",
      "    combinations_with_replacement(p, r)\n",
      "\n",
      "CLASSES\n",
      "    builtins.object\n",
      "        accumulate\n",
      "        chain\n",
      "        combinations\n",
      "        combinations_with_replacement\n",
      "        compress\n",
      "        count\n",
      "        cycle\n",
      "        dropwhile\n",
      "        filterfalse\n",
      "        groupby\n",
      "        islice\n",
      "        permutations\n",
      "        product\n",
      "        repeat\n",
      "        starmap\n",
      "        takewhile\n",
      "        zip_longest\n",
      "    \n",
      "    class accumulate(builtins.object)\n",
      "     |  accumulate(iterable[, func]) --> accumulate object\n",
      "     |  \n",
      "     |  Return series of accumulated sums (or other binary function results).\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class chain(builtins.object)\n",
      "     |  chain(*iterables) --> chain object\n",
      "     |  \n",
      "     |  Return a chain object whose .__next__() method returns elements from the\n",
      "     |  first iterable until it is exhausted, then elements from the next\n",
      "     |  iterable, until all of the iterables are exhausted.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Class methods defined here:\n",
      "     |  \n",
      "     |  from_iterable(...) from builtins.type\n",
      "     |      chain.from_iterable(iterable) --> chain object\n",
      "     |      \n",
      "     |      Alternate chain() constructor taking a single iterable argument\n",
      "     |      that evaluates lazily.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class combinations(builtins.object)\n",
      "     |  combinations(iterable, r) --> combinations object\n",
      "     |  \n",
      "     |  Return successive r-length combinations of elements in the iterable.\n",
      "     |  \n",
      "     |  combinations(range(4), 3) --> (0,1,2), (0,1,3), (0,2,3), (1,2,3)\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  __sizeof__(...)\n",
      "     |      Returns size in memory, in bytes.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class combinations_with_replacement(builtins.object)\n",
      "     |  combinations_with_replacement(iterable, r) --> combinations_with_replacement object\n",
      "     |  \n",
      "     |  Return successive r-length combinations of elements in the iterable\n",
      "     |  allowing individual elements to have successive repeats.\n",
      "     |  combinations_with_replacement('ABC', 2) --> AA AB AC BB BC CC\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  __sizeof__(...)\n",
      "     |      Returns size in memory, in bytes.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class compress(builtins.object)\n",
      "     |  compress(data, selectors) --> iterator over selected data\n",
      "     |  \n",
      "     |  Return data elements corresponding to true selector elements.\n",
      "     |  Forms a shorter iterator from selected data elements using the\n",
      "     |  selectors to choose the data elements.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class count(builtins.object)\n",
      "     |  count(start=0, step=1) --> count object\n",
      "     |  \n",
      "     |  Return a count object whose .__next__() method returns consecutive values.\n",
      "     |  Equivalent to:\n",
      "     |  \n",
      "     |      def count(firstval=0, step=1):\n",
      "     |          x = firstval\n",
      "     |          while 1:\n",
      "     |              yield x\n",
      "     |              x += step\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class cycle(builtins.object)\n",
      "     |  cycle(iterable) --> cycle object\n",
      "     |  \n",
      "     |  Return elements from the iterable until it is exhausted.\n",
      "     |  Then repeat the sequence indefinitely.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class dropwhile(builtins.object)\n",
      "     |  dropwhile(predicate, iterable) --> dropwhile object\n",
      "     |  \n",
      "     |  Drop items from the iterable while predicate(item) is true.\n",
      "     |  Afterwards, return every element until the iterable is exhausted.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class filterfalse(builtins.object)\n",
      "     |  filterfalse(function or None, sequence) --> filterfalse object\n",
      "     |  \n",
      "     |  Return those items of sequence for which function(item) is false.\n",
      "     |  If function is None, return the items that are false.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class groupby(builtins.object)\n",
      "     |  groupby(iterable, key=None) -> make an iterator that returns consecutive\n",
      "     |  keys and groups from the iterable.  If the key function is not specified or\n",
      "     |  is None, the element itself is used for grouping.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class islice(builtins.object)\n",
      "     |  islice(iterable, stop) --> islice object\n",
      "     |  islice(iterable, start, stop[, step]) --> islice object\n",
      "     |  \n",
      "     |  Return an iterator whose next() method returns selected values from an\n",
      "     |  iterable.  If start is specified, will skip all preceding elements;\n",
      "     |  otherwise, start defaults to zero.  Step defaults to one.  If\n",
      "     |  specified as another value, step determines how many values are \n",
      "     |  skipped between successive calls.  Works like a slice() on a list\n",
      "     |  but returns an iterator.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class permutations(builtins.object)\n",
      "     |  permutations(iterable[, r]) --> permutations object\n",
      "     |  \n",
      "     |  Return successive r-length permutations of elements in the iterable.\n",
      "     |  \n",
      "     |  permutations(range(3), 2) --> (0,1), (0,2), (1,0), (1,2), (2,0), (2,1)\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  __sizeof__(...)\n",
      "     |      Returns size in memory, in bytes.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class product(builtins.object)\n",
      "     |  product(*iterables, repeat=1) --> product object\n",
      "     |  \n",
      "     |  Cartesian product of input iterables.  Equivalent to nested for-loops.\n",
      "     |  \n",
      "     |  For example, product(A, B) returns the same as:  ((x,y) for x in A for y in B).\n",
      "     |  The leftmost iterators are in the outermost for-loop, so the output tuples\n",
      "     |  cycle in a manner similar to an odometer (with the rightmost element changing\n",
      "     |  on every iteration).\n",
      "     |  \n",
      "     |  To compute the product of an iterable with itself, specify the number\n",
      "     |  of repetitions with the optional repeat keyword argument. For example,\n",
      "     |  product(A, repeat=4) means the same as product(A, A, A, A).\n",
      "     |  \n",
      "     |  product('ab', range(3)) --> ('a',0) ('a',1) ('a',2) ('b',0) ('b',1) ('b',2)\n",
      "     |  product((0,1), (0,1), (0,1)) --> (0,0,0) (0,0,1) (0,1,0) (0,1,1) (1,0,0) ...\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  __sizeof__(...)\n",
      "     |      Returns size in memory, in bytes.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class repeat(builtins.object)\n",
      "     |  repeat(object [,times]) -> create an iterator which returns the object\n",
      "     |  for the specified number of times.  If not specified, returns the object\n",
      "     |  endlessly.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __length_hint__(...)\n",
      "     |      Private method returning an estimate of len(list(it)).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class starmap(builtins.object)\n",
      "     |  starmap(function, sequence) --> starmap object\n",
      "     |  \n",
      "     |  Return an iterator whose values are returned from the function evaluated\n",
      "     |  with an argument tuple taken from the given sequence.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class takewhile(builtins.object)\n",
      "     |  takewhile(predicate, iterable) --> takewhile object\n",
      "     |  \n",
      "     |  Return successive entries from an iterable as long as the \n",
      "     |  predicate evaluates to true for each entry.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class zip_longest(builtins.object)\n",
      "     |  zip_longest(iter1 [,iter2 [...]], [fillvalue=None]) --> zip_longest object\n",
      "     |  \n",
      "     |  Return a zip_longest object whose .__next__() method returns a tuple where\n",
      "     |  the i-th element comes from the i-th iterable argument.  The .__next__()\n",
      "     |  method continues until the longest iterable in the argument sequence\n",
      "     |  is exhausted and then it raises StopIteration.  When the shorter iterables\n",
      "     |  are exhausted, the fillvalue is substituted in their place.  The fillvalue\n",
      "     |  defaults to None or can be specified by a keyword argument.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __next__(self, /)\n",
      "     |      Implement next(self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Return state information for pickling.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |      Set state information for unpickling.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "\n",
      "FUNCTIONS\n",
      "    tee(...)\n",
      "        tee(iterable, n=2) --> tuple of n independent iterators.\n",
      "\n",
      "FILE\n",
      "    (built-in)\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import itertools\n",
    "help(itertools)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## yield from\n",
    "- 使用yield from实现：生成器函数需要产出另一个生成器生成的值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def chain(*iterables):\n",
    "    for i in iterables:\n",
    "        yield from i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B', 'C', 0, 1, 2]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'ABC'\n",
    "t = tuple(range(3))\n",
    "list(chain(s, t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## iter函数的另一种用法\n",
    "- 传入两个参数，第一个参数是一个可调用的对象，用于不断调用产生值；第二个参数是哨符\n",
    "- 当产生的值返回这个哨值时，触发迭代器抛出StopIteration异常"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<callable_iterator at 0x1cbdab72668>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def d6():\n",
    "    return randint(1, 6)\n",
    "\n",
    "\n",
    "d6_iter = iter(d6, 1)\n",
    "d6_iter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for roll in d6_iter:\n",
    "    print(roll)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 作者提到的一个实例\n",
    "- 需求：读取两种不同格式的文件，转为json写入文件\n",
    "- 问题：存在两种不同的读文件格式，可能需要交叉读不同类型的文件；文件太大，不能一次性读入内存\n",
    "- 解决：解耦读写逻辑，将两种类型的文件读操作用两个生成器实现，写文件时根据类型调用不同的生成器，获取不同的文件并转格式写入"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}