Python廖雪峰3.高级特性.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99]\n"
     ]
    }
   ],
   "source": [
    "L=[]\n",
    "#range(x,y)生成从x到y-1的数据\n",
    "for x in list(range(1,51)):\n",
    "    L.append(2*x-1)\n",
    "print(L)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 切片\n",
    "如何取list前三个元素？  \n",
    "L[0:3],**同样也是包括左边不包括右边**  \n",
    "List tuple 字符串均可使用切片操作  \n",
    "s[::-1] 可以视为翻转操作\n",
    "s[::2] 隔一个取一个"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[95, 97, 99]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[0:5]\n",
    "L[:]\n",
    "#负数索引小的在前，包括左边不包括右边，L[-1]==99\n",
    "L[-3:-1]\n",
    "#想要得到最后一个元素，留空即可\n",
    "L[-3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "利用切片操作，实现一个trim()函数，去除字符串首尾的空格，注意不要调用str的strip()方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#import pdb\n",
    "def trim(s):\n",
    "    #pdb.set_trace()\n",
    "    if s=='':\n",
    "        return s\n",
    "    elif s[-1]==' ':\n",
    "        return trim(s[:-1])\n",
    "    elif s[0]==' ':\n",
    "        return trim(s[1:])\n",
    "    else:\n",
    "        return s\n",
    " \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试成功!\n"
     ]
    }
   ],
   "source": [
    "if trim('hello  ') != 'hello':\n",
    "    print('test1fail!')\n",
    "elif trim('  hello') != 'hello':\n",
    "    print('test2fail!')\n",
    "elif trim('  hello  ') != 'hello':\n",
    "    print('test3fail!')\n",
    "elif trim('  hello  world  ') != 'hello  world':\n",
    "    print('test4fail!')\n",
    "elif trim('') != '':\n",
    "    print('test5fail!')\n",
    "elif trim('    ') != '':\n",
    "    print('test6fail!')\n",
    "else:    \n",
    "    print('测试成功!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "print(trim('hello  '))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2迭代\n",
    "给定的list，tuple，dict 我们可以通过for循环遍历这个列表，成为迭代  \n",
    "使用for...in  \n",
    "**默认情况下迭代字典时迭代的是key，若迭代值使用for value in d.values(),同时迭代两者使用for k,v in d.items()**  \n",
    "如果同时需要下标，使用enumerate()函数将元素建立索引  \n",
    "for i,value in enumerate(['A','B','C'])  \n",
    "同时使用两个变量  \n",
    "for x,y in[(1,1),(2,4),(3,9)]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1\n",
      "2 4\n",
      "3 9\n"
     ]
    }
   ],
   "source": [
    "for x,y in[(1,1),(2,4),(3,9)]:\n",
    "    print(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pdb\n",
    "def findMinAndMax(L):\n",
    "    if len(L)==0:\n",
    "        return (None,None)\n",
    "    else:\n",
    "        max=-1000\n",
    "        min=1000\n",
    "        for x in L:\n",
    "            #pdb.set_trace()\n",
    "            if max<x:\n",
    "                max=x\n",
    "            if min>x:\n",
    "                min=x\n",
    "        return (min,max)\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试成功!\n"
     ]
    }
   ],
   "source": [
    "# 测试\n",
    "if findMinAndMax([]) != (None, None):\n",
    "    print('测试失败1!')\n",
    "elif findMinAndMax([7]) != (7, 7):\n",
    "    print('测试失败2!')\n",
    "elif findMinAndMax([7, 1]) != (1, 7):\n",
    "    print('测试失败3!')\n",
    "elif findMinAndMax([7, 1, 3, 9, 5]) != (1, 9):\n",
    "    print('测试失败4!')\n",
    "else:\n",
    "    print('测试成功!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7, 7)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "findMinAndMax([7,7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 列表生成式\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x*x for x in list(range(1,10))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 16, 36, 64, 100]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x*x for x in range(1,11) if x%2==0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AQ', 'AW', 'AE', 'BQ', 'BW', 'BE', 'CQ', 'CW', 'CE']"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[m+n for m in 'ABC' for n in 'QWE']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['pekomen', 'python']"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "[d for d in os.listdir('./Documents/pythonforML')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['y+B', 'x+A', 'z+C']"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " d = {'x': 'A', 'y': 'B', 'z': 'C' }\n",
    " [k +'+'+v for k,v in d.items()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['hello', 'world', 'apple']\n",
      "测试通过!\n"
     ]
    }
   ],
   "source": [
    "L1 = ['Hello', 'World', 18, 'Apple', None]\n",
    "L2 = [x.lower() for x in L1 if isinstance(x,str)]\n",
    "print(L2)\n",
    "if L2 == ['hello', 'world', 'apple']:\n",
    "    print('测试通过!')\n",
    "else:\n",
    "    print('测试失败!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4 生成器\n",
    "列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator  \n",
    "**要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n"
     ]
    }
   ],
   "source": [
    "g = (x * x for x in range(10))\n",
    "for x in g:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这就是定义generator的另一种方法。**如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator：**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fib(max):\n",
    "    n, a, b = 0, 0, 1\n",
    "    while n < max:\n",
    "        yield b\n",
    "        a, b = b, a + b\n",
    "        n = n + 1\n",
    "    return 'done'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<generator object fib at 0x00000181C21DBBA0>\n"
     ]
    }
   ],
   "source": [
    "f = fib(6)\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，**遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def odd():\n",
    "    print('step 1')\n",
    "    yield 1\n",
    "    print('step 2')\n",
    "    yield(3)\n",
    "    print('step 3')\n",
    "    yield(5)\n",
    "    \n",
    "o =  odd()\n",
    "next(o)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-113-ff071067a2bc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mo\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "next(o)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "g: 1\n",
      "g: 1\n",
      "g: 2\n",
      "g: 3\n",
      "g: 5\n",
      "g: 8\n",
      "Generator return value: done\n"
     ]
    }
   ],
   "source": [
    "g = fib(6)\n",
    "while True:\n",
    "    try:\n",
    "        x = next(g)\n",
    "        print('g:',x)\n",
    "    except StopIteration as e:\n",
    "        print('Generator return value:',e.value)\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pdb\n",
    "def triangles():\n",
    "    L = [ 1 ]    \n",
    "    while True:        \n",
    "        #若不使用L[:]，则返回的是L而不是L的copy，因此当L变化时，results中的结果都会变！！！\n",
    "        yield L[:]        \n",
    "        for i in range(1, len(L)):            \n",
    "            L[ i ] = K[ i - 1 ] + K[ i ]        \n",
    "        L.append(1)        \n",
    "        K = L[:]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n",
      "[1, 1]\n",
      "[1, 2, 1]\n",
      "[1, 3, 3, 1]\n",
      "[1, 4, 6, 4, 1]\n",
      "[1, 5, 10, 10, 5, 1]\n",
      "[1, 6, 15, 20, 15, 6, 1]\n",
      "[1, 7, 21, 35, 35, 21, 7, 1]\n",
      "[1, 8, 28, 56, 70, 56, 28, 8, 1]\n",
      "[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]\n",
      "测试通过!\n"
     ]
    }
   ],
   "source": [
    "\n",
    "n = 0       \n",
    "results = []\n",
    "\n",
    "for t in triangles():\n",
    "    print(t)\n",
    "    results.append(t)\n",
    "  #  print(results)\n",
    "    n = n + 1\n",
    "    if n == 10:\n",
    "        break\n",
    "        \n",
    "if results == [\n",
    "    [1],\n",
    "    [1, 1],\n",
    "    [1, 2, 1],\n",
    "    [1, 3, 3, 1],\n",
    "    [1, 4, 6, 4, 1],\n",
    "    [1, 5, 10, 10, 5, 1],\n",
    "    [1, 6, 15, 20, 15, 6, 1],\n",
    "    [1, 7, 21, 35, 35, 21, 7, 1],\n",
    "    [1, 8, 28, 56, 70, 56, 28, 8, 1],\n",
    "    [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]\n",
    "]:\n",
    "    print('测试通过!')\n",
    "else:\n",
    "    print('测试失败!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  3.5 迭代器  \n",
    "可以直接作用于for循环的成为可迭代对象  \n",
    "可以使用isinstance()判断一个对象是否是Iterable对象：  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Iterable\n",
    "isinstance([],Iterable)\n",
    "isinstance((x for x in range(10)), Iterable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。**\n",
    "把list、dict、str等Iterable变成Iterator可以使用iter()函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Iterator\n",
    "isinstance((x for x in range(10)), Iterator)\n",
    "isinstance({}, Iterator)\n",
    "isinstance(iter({}), Iterator)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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": 1
}