六、类.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python类提供了***面向对象编程***的所有标准特性：类的继承机制可以有多个基类；一个派生类可以覆盖他的基类的方法，方法可以调用基类同名的方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. 简述命名与对象"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "对象(object)具有独立性，而多个命名(name)（在多个作用域（scope）中）可以绑定在同一个对象上。在其它语言中被称为别名。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Python的作用域和命名空间"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***命名空间***是从命名到对象的映射。多数命名空间通常是以Python的*字典*实现的，但通常不关心具体的实现方式。  \n",
    "***命名空间***的例子：内建函数的集合（如*abs()*之类的函数或者内建异常名字）；模块的全局名字；函数的局部名字。值得注意的是，不同命名空间里面的名字之间没有任何关系。   \n",
    "命名空间在不同时刻创建并且有不同的生命周期。包含内建名字的命名空间，当脚本开始的时候创建，并且从不删除。一个模块的全局命名空间在模块的定义被读进来的时候创建。内建名字其实也在一个模块里，也即*builtins*模块  \n",
    "一个函数的***局部命名空间***当这个函数被调用的时候创建，当这个函数返回或者抛出异常的时候删除。当然，每次递归都有他们自己的局部命名空间。  \n",
    "***ｓｃｏｐｅ（作用域）***是一个python程序的可以直接获得某命名空间文本区域。   \n",
    "如果没有[global](https://docs.python.org/3.5/reference/simple_stmts.html#global)声明，那么赋值的名字总是在最靠里的命名空间里。赋值并不复制数据，只是将名字绑定到对象。删除也是一样的。  \n",
    "***作用域***\n",
    "[global](https://docs.python.org/3.5/reference/simple_stmts.html#global)声明可以用于声明某个值在全局作用域中，并且应该在全局作用域进行重新绑定；[nonlocal](https://docs.python.org/3.5/reference/simple_stmts.html#nonlocal)声明从里向外搜索某个值，而不会在当前作用域的命名空间的字典中添加新的键值对，如果外层作用域中没有找到该变量，则会报错。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1 作用域和命名空间例子"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After local assignment: test spam\n",
      "After nonlocal assignment: nonlocal spam\n",
      "After global assignment: nonlocal spam\n",
      "In global scope: global spam\n"
     ]
    }
   ],
   "source": [
    "# -*- encoding: utf-8 *-*\n",
    "def scope_test():\n",
    "    def do_local():\n",
    "        spam = \"local spam\"  # 只存在于这个函数的命名空间\n",
    "\n",
    "    def do_nonlocal():\n",
    "        nonlocal spam\n",
    "        spam = \"nonlocal spam\"  # 向外找，找到外层的“test spam”\n",
    "\n",
    "    def do_global():  \n",
    "        global spam  # spam定义在整个模块全局作用域，与上面两个的作用域不同\n",
    "        spam = \"global spam\" # 只是改变了全局作用域中的ｓｐａｍ的值\n",
    "\n",
    "    spam = \"test spam\"\n",
    "    do_local()\n",
    "    print(\"After local assignment:\", spam)\n",
    "    do_nonlocal()\n",
    "    print(\"After nonlocal assignment:\", spam)\n",
    "    do_global()\n",
    "    print(\"After global assignment:\", spam)\n",
    "\n",
    "scope_test()\n",
    "print(\"In global scope:\", spam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. 初识类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "类引入了一点新的语法，三个新的对象类型，和一些新的符号"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1 类定义的语法"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "class ClassName:\n",
    "    <statement-1>\n",
    "    .\n",
    "    .\n",
    "    .\n",
    "    <statement-N>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当输入一个类的定义，那么就会产生一个新的命名空间，并且被作为局部作用域——因此，所有的对局部变量的赋值，都会在这个新的命名空间上进行"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2 类对象\n",
    "\n",
    "    类对象允许两个操作：属性参考（attribute references）和实例化(instantiation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    \"\"\"A simple example class\"\"\"\n",
    "    i = 12345\n",
    "\n",
    "    def f(self):\n",
    "        return 'hello world'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.MyClass.f>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 属性参考：\n",
    "MyClass.i\n",
    "MyClass.f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 实例化\n",
    "x = MyClass()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果需要在初始化时，进行某些操作，需要在类里面定义***`__init__()`***"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "def __init__(self):\n",
    "    self.data = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Complex:\n",
    "    def __init__(self, realpart, imagpart):\n",
    "        self.r = realpart\n",
    "        self.i = imagpart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.0, -4.5)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = Complex(3.0, -4.5)\n",
    "x.r, x.i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3　实例对象\n",
    "\n",
    "    实例对象只能进行属性参考，共有两种属性：数据属性和方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "数据属性与Ｃ＋＋中的“数据成员”相类比。他不需要被声明；就像局部变量一样，他们一旦被赋值就存在了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "方法是属于对象的一个函数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.4　方法对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello world'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 方法可以这样调用\n",
    "x = MyClass()\n",
    "x.f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但是事实上方法可以作为一个方法对象，先保存起来，后面再调用"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "xf = x.f\n",
    "while True:\n",
    "    print(xf())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.5 类和实例变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Dog:\n",
    "\n",
    "    kind = 'canine'         # class variable shared by all instances\n",
    "\n",
    "    def __init__(self, name):\n",
    "        self.name = name    # instance variable unique to each instance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "类的变量和每个实例的变量不能滥用"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "class Dog:\n",
    "\n",
    "    tricks = []             # mistaken use of a class variable\n",
    "\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def add_trick(self, trick):\n",
    "        self.tricks.append(trick)\n",
    "\n",
    ">>> d = Dog('Fido')\n",
    ">>> e = Dog('Buddy')\n",
    ">>> d.add_trick('roll over')\n",
    ">>> e.add_trick('play dead')\n",
    ">>> d.tricks                # unexpectedly shared by all dogs\n",
    "['roll over', 'play dead']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "正确的情况是每条狗有自己的ｔｒｉｃｋ"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "class Dog:\n",
    "\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.tricks = []    # creates a new empty list for each dog\n",
    "\n",
    "    def add_trick(self, trick):\n",
    "        self.tricks.append(trick)\n",
    "\n",
    ">>> d = Dog('Fido')\n",
    ">>> e = Dog('Buddy')\n",
    ">>> d.add_trick('roll over')\n",
    ">>> e.add_trick('play dead')\n",
    ">>> d.tricks\n",
    "['roll over']\n",
    ">>> e.tricks\n",
    "['play dead']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. 一些说明"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "数据属性会覆盖同名的方法属性，为了避免冲突，可行的传统方法包括：大写方法的名字；在数据属性的名字前加一个小的独特的符号，比如下划线；或者方法用动词，数据属性用名词。  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "每个值都是对象，因此也都有一个类，他们保存在*`object.__class__`*里面"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 5\n",
    "a.__class__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. 继承"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "class DerivedClassName(BaseClassName):\n",
    "    <statement-1>\n",
    "    .\n",
    "    .\n",
    "    .\n",
    "    <statement-N>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当基类在别的模块中时，也可以这么表达："
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "class DerivedClassName(modname.BaseClassName):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在解析类的属性参考时，如果被使用的属性没有在当前类中找到，那么就会在他的基类里面找，如果还没有，就在基类的基类里面找，直至找到"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "派生类的方法可以覆盖积累的方法。当一个基类中的方法调用同一个基类的另一个方法时，最终可能调用的是覆盖了他的派生类的方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果要直接调用基类的方法，可以直接调用*`BaseClassName.methodname(self, arguments)`*。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python有两个内建函数是与继承相关的：  \n",
    "* [isinstance()](https://docs.python.org/3.5/library/functions.html#isinstance)用于检验实例的类型，如：*isinstance(obj, int)*，当obj.__class__是*int*，或者从*int*派生的时候为真  \n",
    "* [issubclass()](https://docs.python.org/3.5/library/functions.html#issubclass)用于检验类的继承。如：*issubclass(bool, int)*当*bool*是*int*的子类的时候为真"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1 多继承"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "class DerivedClassName(Base1, Base2, Base3):\n",
    "    <statement-1>\n",
    "    .\n",
    "    .\n",
    "    .\n",
    "    <statement-N>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "大多数情况下，可以认为继承的属性的搜索顺序是，**深度优先，从左到右**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "事实上，更加复杂一点，方法的解析顺序是动态变化的，为了支持[super()](https://docs.python.org/3.5/library/functions.html#super)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 6. 私有变量"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python中并不存在无法访问的“私有变量”，但是有约定，就是以下划线开头的名字。 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于有一种有效的类私有成员的案例（主要是为了避免和子类的名字冲突），有一种称为“name mangling”的方法来支持这种机制。任何*`__spam`*格式（前面最少两个下划线，后面最多一个下划线）的标识符，用*`_classname__spam`*进行替换"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Mapping:\n",
    "    def __init__(self, iterable):\n",
    "        self.items_list = []\n",
    "        self.__update(iterable)\n",
    "\n",
    "    def update(self, iterable):\n",
    "        for item in iterable:\n",
    "            self.items_list.append(item)\n",
    "\n",
    "    __update = update   # private copy of original update() method\n",
    "\n",
    "class MappingSubclass(Mapping):\n",
    "\n",
    "    def update(self, keys, values):\n",
    "        # provides new signature for update()\n",
    "        # but does not break __init__()\n",
    "        for item in zip(keys, values):\n",
    "            self.items_list.append(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. 杂谈\n",
    "    \n",
    "    可以使用类得到类似于Pascal的\"record\"或者Ｃ的结构体的数据类型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Employee:\n",
    "    pass\n",
    "\n",
    "john = Employee()  # Create an empty employee record\n",
    "\n",
    "# Fill the fields of the record\n",
    "john.name = 'John Doe'\n",
    "john.dept = 'computer lab'\n",
    "john.salary = 1000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. 迭代器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***for*** 语句"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "1\n",
      "2\n",
      "3\n",
      "two\n",
      "one\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    },
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'myfile.txt'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-ccc2dcc2ab88>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mchar\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m\"123\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mchar\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mline\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"myfile.txt\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mline\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mend\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m''\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'myfile.txt'"
     ]
    }
   ],
   "source": [
    "for element in [1, 2, 3]:\n",
    "    print(element)\n",
    "for element in (1, 2, 3):\n",
    "    print(element)\n",
    "for key in {'one':1, 'two':2}:\n",
    "    print(key)\n",
    "for char in \"123\":\n",
    "    print(char)\n",
    "for line in open(\"myfile.txt\"):\n",
    "    print(line, end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***for***语句实际上调用了容器对象的**[iter()](https://docs.python.org/3.5/library/functions.html#iter)**函数，这个函数返回一个迭代对象，其定义了一个*`__next__（）`*方法，每次从容器里得到一个元素，直至停止。可以通过内建函数**[next](https://docs.python.org/3.5/library/functions.html#next)**调用*`__next__()`*"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    ">>> s = 'abc'\n",
    ">>> it = iter(s)\n",
    ">>> it\n",
    "<iterator object at 0x00A1DB50>\n",
    ">>> next(it)\n",
    "'a'\n",
    ">>> next(it)\n",
    "'b'\n",
    ">>> next(it)\n",
    "'c'\n",
    ">>> next(it)\n",
    "Traceback (most recent call last):\n",
    "  File \"<stdin>\", line 1, in <module>\n",
    "    next(it)\n",
    "StopIteration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过了解迭代器协议的机理，定义一个返回有*`__next__()`*的对象的*`__iter__()`*方法，可以将迭代的行为加到自己的类里。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Reverse:\n",
    "    \"\"\"Iterator for looping over a sequence backwards.\"\"\"\n",
    "    def __init__(self, data):\n",
    "        self.data = data\n",
    "        self.index = len(data)\n",
    "\n",
    "    def __iter__(self):\n",
    "        return self\n",
    "\n",
    "    def __next__(self):\n",
    "        if self.index == 0:\n",
    "            raise StopIteration\n",
    "        self.index = self.index - 1\n",
    "        return self.data[self.index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "m\n",
      "a\n",
      "p\n",
      "s\n"
     ]
    }
   ],
   "source": [
    "rev = Reverse('spam')\n",
    "iter(rev)\n",
    "\n",
    "for char in rev:\n",
    "    print(char)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9. 生成器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[生成器](https://docs.python.org/3.5/glossary.html#term-generator)**是一个简单有效的创造迭代器的工具。他们使用**[yield](https://docs.python.org/3.5/reference/simple_stmts.html#yield)**来得到数据。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def reverse(data):\n",
    "    for index in range(len(data)-1, -1, -1):\n",
    "        yield data[index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f\n",
      "l\n",
      "o\n",
      "g\n"
     ]
    }
   ],
   "source": [
    "for char in reverse('golf'):\n",
    "    print(char)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "生成器可以做的事情都可以用上节基于类的迭代器来做。只不过，生成器可以自动创造*`__iter__()`*和*`__next__()`*方法，因此变得十分简洁。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10. 生成器表达式"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一些简单的生成器可以通过圆括号来进行简洁的表示。这些表达式用于生成器直接被一个接近的函数使用的情况。"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    ">>> sum(i*i for i in range(10))                 # sum of squares\n",
    "285\n",
    "\n",
    ">>> xvec = [10, 20, 30]\n",
    ">>> yvec = [7, 5, 3]\n",
    ">>> sum(x*y for x,y in zip(xvec, yvec))         # dot product\n",
    "260\n",
    "\n",
    ">>> from math import pi, sin\n",
    ">>> sine_table = {x: sin(x*pi/180) for x in range(0, 91)}\n",
    "\n",
    ">>> unique_words = set(word  for line in page  for word in line.split())\n",
    "\n",
    ">>> valedictorian = max((student.gpa, student.name) for student in graduates)\n",
    "\n",
    ">>> data = 'golf'\n",
    ">>> list(data[i] for i in range(len(data)-1, -1, -1))\n",
    "['f', 'l', 'o', 'g']"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}