来自斯坦福的python2入门教程.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#coding=utf-8 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python2 入门教程\n",
    "https://github.com/kuleshov/cs228-material/blob/master/tutorials/python/cs228-python-tutorial.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 简介"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python本身是一种很棒的通用编程语言，但是在一些流行的类库（numpy,scipy,matplotlib,Pandas）的支持下，它已成为科学计算的强大开发工具。\n",
    "\n",
    "对于没有Python开发经验的小白来说,本教程可以作为Python编程语言和科学计算的速成课程。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在本教程中,我们将介绍：\n",
    "\n",
    "* Python 基础知识: 基本数据类型（容器，列表，字典，集合，元组），函数，类\n",
    "* Numpy: 数组，数组索引，数据类型，数组数学，广播\n",
    "* Matplotlib: 绘图，子图，图像\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python 基础知识"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python是一种高级动态类型的多范式编程语言。 Python代码通常被称为伪代码，因为它允许您在非常少的代码行中表达非常强大的思想，同时具有非常强的可读性。 作为示例，这里是Python中经典快速排序算法的实现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quicksort(arr):\n",
    "    if len(arr) <= 1:\n",
    "        return arr\n",
    "    pivot = arr[len(arr) // 2]\n",
    "    left = [x for x in arr if x < pivot]\n",
    "    middle = [x for x in arr if x == pivot]\n",
    "    right = [x for x in arr if x > pivot]\n",
    "    return quicksort(left) + middle + quicksort(right)\n",
    "\n",
    "print quicksort([3,6,8,10,1,2,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python 版本"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "目前有两种不同的受支持版本的Python，2.7和3.X。 有点令人困惑的是，Python 3.0引入了许多向后兼容的语言更改，因此为2.7编写的代码可能无法在3.X下运行，反之亦然。 对于这个类，所有代码都将使用Python 2.7。\n",
    "\n",
    "您可以通过运行`python --version`在命令行检查Python版本。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 2.7.15 :: Anaconda, Inc.\r\n"
     ]
    }
   ],
   "source": [
    "!python --version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 基本数据类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 数字"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "整数和浮点数的工作方式与其他语言相同："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 <type 'int'>\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "print x, type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "2\n",
      "6\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "print x + 1   # 加法;\n",
    "print x - 1   # 减法;\n",
    "print x * 2   # 乘法;\n",
    "print x ** 2  # n次方(指数法);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "x += 1\n",
    "print x  # Prints \"4\"\n",
    "x *= 2\n",
    "print x  # Prints \"8\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'float'>\n",
      "2.5 3.5 5.0 6.25\n"
     ]
    }
   ],
   "source": [
    "y = 2.5\n",
    "print type(y) \n",
    "print y, y + 1, y * 2, y ** 2 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "请注意，与许多语言不同，Python没有一元增量（x ++）或减量（x -- ）运算符。\n",
    "\n",
    "Python还有长整数和复数的内置类型; 您可以在文档中找到所有详细信息。 [文档](https://docs.python.org/2/library/stdtypes.html#numeric-types-int-float-long-complex)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 逻辑类型(Booleans)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python实现布尔逻辑的所有常用运算符，但使用英语单词而不是符号（&&，||等）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'bool'>\n"
     ]
    }
   ],
   "source": [
    "t, f = True, False\n",
    "print type(t) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "逻辑运算(与、或、非、异或):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print t and f # 逻辑 与;\n",
    "print t or f  # 逻辑 或;\n",
    "print not t   # 逻辑 非;\n",
    "print t != f  # 逻辑 异或;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 字符串"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello 5\n"
     ]
    }
   ],
   "source": [
    "hello = 'hello'   # 单引号包含字符串\n",
    "world = \"world\"   # 双引号包含字符串.\n",
    "print hello, len(hello)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "hw = hello + ' ' + world  # 字符串连接\n",
    "print hw  # prints \"hello world\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world 12\n"
     ]
    }
   ],
   "source": [
    "hw12 = '%s %s %d' % (hello, world, 12)  # sprintf style string formatting\n",
    "print hw12  # prints \"hello world 12\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String对象有很多有用的方法;例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "HELLO\n",
      "  hello\n",
      " hello \n",
      "he(ell)(ell)o\n",
      "world\n"
     ]
    }
   ],
   "source": [
    "s = \"hello\"\n",
    "print s.capitalize()\n",
    "print s.upper()\n",
    "print s.rjust(7) #字符串右对齐  \n",
    "print s.center(7)  \n",
    "print s.replace('l', '(ell)')\n",
    "                               \n",
    "print '  world '.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字符串操作的官方文档: [文档](https://docs.python.org/2/library/stdtypes.html#string-methods)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 容器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python包含几种内置容器类型：列表(List)，字典(Dictionary)，集合(Sets)和元组(Tuples)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 列表"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "列表是Python的等效数组，但是可以调整大小并且可以包含**不同类型**的元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1, 2] 2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "xs = [3, 1, 2]   # 创建一个列表\n",
    "print xs, xs[2]\n",
    "print xs[-1]     # 负数索引表示从右边往左的索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1, 'foo']\n"
     ]
    }
   ],
   "source": [
    "xs[2] = 'foo'    # 列表可以包含不同类型的数据\n",
    "print xs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1, 'foo', 'bar']\n"
     ]
    }
   ],
   "source": [
    "xs.append('bar') # 往列表中添加新的元素,类似于堆栈的压栈\n",
    "print xs  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bar [3, 1, 'foo']\n"
     ]
    }
   ],
   "source": [
    "x = xs.pop()     # 从列表中删除最后一个元素,类似于堆栈的出栈\n",
    "print x, xs "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "像往常一样，您可以在文档中找到有关列表的所有详细信息。 [文档](https://docs.python.org/2/tutorial/datastructures.html#more-on-lists)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 切片"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "除了一次访问一个列表元素之外，Python还提供了访问子列表的简明语法; 这被称为切片："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n",
      "[2, 3]\n",
      "[2, 3, 4]\n",
      "[0, 1]\n",
      "[0, 1, 2, 3, 4]\n",
      "[0, 1, 2, 3]\n",
      "[0, 1, 8, 9, 4]\n"
     ]
    }
   ],
   "source": [
    "nums = range(5)    # range 是一个内置的函数,用它可以生成一个整数列表\n",
    "print nums         \n",
    "print nums[2:4]    # 获取索引从2到4位(但不包含索引4)的元素; prints \"[2, 3]\"\n",
    "print nums[2:]     # 获取索引从2位到列表末端所有元素; prints \"[2, 3, 4]\"\n",
    "print nums[:2]     # 获取从列表开头到索引2(但不包含索引2)的所有元素; prints \"[0, 1]\"\n",
    "print nums[:]      # 获取列表全部元素; prints [\"0, 1, 2, 3, 4]\"\n",
    "print nums[:-1]    # 获取索开头至末端(但不包含末端)所有元素prints [\"0, 1, 2, 3]\"\n",
    "nums[2:4] = [8, 9] # 对列表切片数据进行赋值\n",
    "print nums         # Prints \"[0, 1, 8, 9, 4]\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 循环"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "您可以循环遍历列表的元素，如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat\n",
      "dog\n",
      "monkey\n"
     ]
    }
   ],
   "source": [
    "animals = ['cat', 'dog', 'monkey']\n",
    "for animal in animals:\n",
    "    print animal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果要访问循环体内每个元素的索引，请使用内置枚举函数：enumerate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#1: cat\n",
      "#2: dog\n",
      "#3: monkey\n"
     ]
    }
   ],
   "source": [
    "animals = ['cat', 'dog', 'monkey']\n",
    "for idx, animal in enumerate(animals):\n",
    "    print '#%d: %s' % (idx + 1, animal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 列表推广:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "编程时，我们经常想要将一种数据转换为另一种数据。 举个简单的例子，考虑以下计算平方数的代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "nums = [0, 1, 2, 3, 4]\n",
    "squares = []\n",
    "for x in nums:\n",
    "    squares.append(x ** 2)\n",
    "print squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "您可以使用列表推广使此代码更简单："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "nums = [0, 1, 2, 3, 4]\n",
    "squares = [x ** 2 for x in nums]\n",
    "print squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "列表推广也可以包含条件:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 16]\n"
     ]
    }
   ],
   "source": [
    "nums = [0, 1, 2, 3, 4]\n",
    "even_squares = [x ** 2 for x in nums if x % 2 == 0]\n",
    "print even_squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 字典"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字典存储（key，value）对，类似于Java中的Map或Javascript中的对象。 你可以像这样使用它："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cute\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "d = {'cat': 'cute', 'dog': 'furry'}  # 创建一个带有初始值的字典\n",
    "print d['cat']       # 根据key来获取value; prints \"cute\"\n",
    "print 'cat' in d     # 查询字典是否包含某个key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wet\n"
     ]
    }
   ],
   "source": [
    "d['fish'] = 'wet'    # 添加新的key和value\n",
    "print d['fish']      # Prints \"wet\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'monkey'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-20-1c0e9bfbd3b5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mprint\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'monkey'\u001b[0m\u001b[0;34m]\u001b[0m  \u001b[0;31m#如果键不存在,会报异常\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'monkey'"
     ]
    }
   ],
   "source": [
    "print d['monkey']  #如果键不存在,会报异常"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N/A\n",
      "wet\n"
     ]
    }
   ],
   "source": [
    "print d.get('monkey', 'N/A')  # 根据key获取有默认值的value; prints \"N/A\"\n",
    "print d.get('fish', 'N/A')    # 根据key获取有默认值的value; prints \"wet\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N/A\n"
     ]
    }
   ],
   "source": [
    "del d['fish']        # 从字典中删除元素\n",
    "print d.get('fish', 'N/A') # \"fish\" 在字典中已不存在; prints \"N/A\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "您可以在官方文档中找到有关字典的所有信息。 [文档](https://docs.python.org/2/library/stdtypes.html#dict)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "遍历词典中的键很容易："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A person has 2 legs\n",
      "A spider has 8 legs\n",
      "A cat has 4 legs\n"
     ]
    }
   ],
   "source": [
    "d = {'person': 2, 'cat': 4, 'spider': 8}\n",
    "for animal in d:\n",
    "    legs = d[animal]\n",
    "    print 'A %s has %d legs' % (animal, legs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果要访问键及其对应的值，请使用iteritems方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A person has 2 legs\n",
      "A spider has 8 legs\n",
      "A cat has 4 legs\n"
     ]
    }
   ],
   "source": [
    "d = {'person': 2, 'cat': 4, 'spider': 8}\n",
    "for animal, legs in d.iteritems():\n",
    "    print 'A %s has %d legs' % (animal, legs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字典推广：这些与列表推广类似，但允许您轻松构建字典。 例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 0, 2: 4, 4: 16}\n"
     ]
    }
   ],
   "source": [
    "nums = [0, 1, 2, 3, 4]\n",
    "even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}\n",
    "print even_num_to_square"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 集合(Sets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sets是不同元素的**无序,去重**的集合。 举个简单的例子，请考虑以下事项："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set(['duck', 'dog', 'cow', 'cat'])\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "animals = {'cat', 'dog','cat','cow','cow','duck'}\n",
    "print animals\n",
    "print 'cat' in animals   # 检查元素是否存在于集合中; prints \"True\"\n",
    "print 'fish' in animals  # prints \"False\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "animals.add('fish')      # 往集合中添加一个元素\n",
    "print 'fish' in animals\n",
    "print len(animals)       # 返回集合的长度;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "animals.add('cat')       # 往集合中添加重复元素是无效的\n",
    "print len(animals)       \n",
    "animals.remove('cat')    # 删除集合中的元素\n",
    "print len(animals)       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_循环_: 遍历一个集合具有与遍历列表有相同的语法; 但是由于集合是无序的，因此遍历集合的结果与你看到的元素存储的顺序是不一致的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#1: fish\n",
      "#2: dog\n",
      "#3: cat\n"
     ]
    }
   ],
   "source": [
    "animals = {'cat', 'dog', 'fish'}\n",
    "for idx, animal in enumerate(animals):\n",
    "    print '#%d: %s' % (idx + 1, animal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "集合的推广：像列表和词典一样，我们可以使用集合推导轻松构建集合："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set([0, 1, 2, 3, 4, 5])\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "print {int(sqrt(x)) for x in range(30)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5]\n"
     ]
    }
   ],
   "source": [
    "print [int(sqrt(x)) for x in range(30)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 元组(Tuples)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "元组是（不可变的）**有序值**列表。 元组在很多方面类似于列表; 其中一个最重要的区别是元组可以用作字典中的键和集合的元素，而列表则不能。 这是一个简单的例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'tuple'>\n",
      "{(0, 1): 0, (1, 2): 1, (6, 7): 6, (5, 6): 5, (7, 8): 7, (8, 9): 8, (4, 5): 4, (2, 3): 2, (9, 10): 9, (3, 4): 3}\n",
      "5\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "d = {(x, x + 1): x for x in range(10)}  # 创建一个字典,该字典的key是tuples\n",
    "t = (5, 6)       # Create a tuple\n",
    "print type(t)\n",
    "print d\n",
    "print d[t]       \n",
    "print d[(1, 2)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'tuple'>\n",
      "<type 'tuple'>\n",
      "('physics', 'chemistry', 1997, 2000)\n",
      "(1, 2, 3, 4, 2, 5, 1)\n",
      "tup1[0]:  physics\n",
      "tup2[1:5]:  (2, 3, 4, 2)\n"
     ]
    }
   ],
   "source": [
    "tup1 = ('physics', 'chemistry', 1997, 2000)\n",
    "tup2 = (1, 2, 3, 4, 2, 5, 1 )\n",
    "print type(tup1) \n",
    "print type(tup2)\n",
    "print tup1\n",
    "print tup2\n",
    "print \"tup1[0]: \", tup1[0]\n",
    "print \"tup2[1:5]: \", tup2[1:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'bool' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-25-c8aeb8cd20ae>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'bool' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "t[0] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python函数使用`def`关键字定义。 例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "negative\n",
      "zero\n",
      "positive\n"
     ]
    }
   ],
   "source": [
    "def sign(x):\n",
    "    if x > 0:\n",
    "        return 'positive'\n",
    "    elif x < 0:\n",
    "        return 'negative'\n",
    "    else:\n",
    "        return 'zero'\n",
    "\n",
    "for x in [-1, 0, 1]:\n",
    "    print sign(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们还可以对函数的参数设置默认值，如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Bob!\n",
      "HELLO, FRED\n"
     ]
    }
   ],
   "source": [
    "def hello(name, loud=False):\n",
    "    if loud:\n",
    "        print 'HELLO, %s' % name.upper()\n",
    "    else:\n",
    "        print 'Hello, %s!' % name\n",
    "\n",
    "hello('Bob')\n",
    "hello('Fred', loud=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在Python中定义类的语法很简单："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Fred\n",
      "HELLO, FRED!\n"
     ]
    }
   ],
   "source": [
    "class Greeter:\n",
    "\n",
    "    # 构造器\n",
    "    def __init__(self, name):\n",
    "        self.name = name  # Create an instance variable\n",
    "\n",
    "    # 实例 方法\n",
    "    def greet(self, loud=False):\n",
    "        if loud:\n",
    "            print 'HELLO, %s!' % self.name.upper()\n",
    "        else:\n",
    "            print 'Hello, %s' % self.name\n",
    "\n",
    "g = Greeter('Fred') \n",
    "g.greet()            \n",
    "g.greet(loud=True)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy是Python科学计算的核心库。 它提供了一个高性能的多维数组对象，以及用于处理这些数组的工具。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "要使用Numpy，我们首先需要导入numpy库："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数组(Arrays)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "numpy数组是一个值网格，所有类型都相同，并由非负整数元组索引。 维数是数组的大小; 数组的形状是一个整数元组，给出了每个维度的数组大小。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以从嵌套的Python列表初始化numpy数组，并使用方括号访问元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'numpy.ndarray'> (3,) 1 2 3\n",
      "[5 2 3]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3])  # 创建一个一维数组\n",
    "print type(a), a.shape, a[0], a[1], a[2]\n",
    "a[0] = 5\n",
    "print a                  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "b = np.array([[1,2,3],[4,5,6]])   # 创建一个二维数组\n",
    "print b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n",
      "1 2 4\n"
     ]
    }
   ],
   "source": [
    "print b.shape                   \n",
    "print b[0, 0], b[0, 1], b[1, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy还提供了许多创建数组的函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  0.]\n",
      " [ 0.  0.]]\n"
     ]
    }
   ],
   "source": [
    "a = np.zeros((2,2))  # 创建零矩阵\n",
    "print a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1.]\n",
      " [1. 1.]]\n",
      "(2, 2)\n"
     ]
    }
   ],
   "source": [
    "b = np.ones((2,2))   # 创建所有元素为常数1的矩阵矩阵\n",
    "print b\n",
    "print b.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 7]\n",
      " [7 7]]\n"
     ]
    }
   ],
   "source": [
    "c = np.full((2,2), 7) # 创建常数矩阵\n",
    "print c "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "d = np.eye(3)        # 创建一个单位矩阵\n",
    "print d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.125364   0.29962041]\n",
      " [0.18998236 0.16666616]]\n"
     ]
    }
   ],
   "source": [
    "e = np.random.random((2,2)) # 创建一个随机数矩阵\n",
    "print e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数组索引"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy提供了几种索引数组的方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "切片：与Python列表类似，可以切割numpy数组。 由于数组可能是多维的，因此必须为数组的每个维指定一个切片："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "--------------\n",
      "[[2 3]\n",
      " [6 7]]\n"
     ]
    }
   ],
   "source": [
    "# 创建一个3×4的矩阵\n",
    "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
    "\n",
    "b = a[:2,1:3]\n",
    "print a\n",
    "print '--------------'\n",
    "print b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数组的切片是原数组的视图，因此修改它将修改原始数组。###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1 77  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "--------------\n",
      "[[77  3]\n",
      " [ 6  7]]\n"
     ]
    }
   ],
   "source": [
    "b[0, 0] = 77\n",
    "print a\n",
    "print '--------------'\n",
    "print b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "您还可以将整数索引与切片索引混合使用。 但是，这样做会产生比原始数组更低级别的数组。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "--------------\n",
      "(3, 4)\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
    "print a\n",
    "print '--------------'\n",
    "print a.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "两种访问数组中间行数据的方法。 将整数索引与切片混合会产生较低等级的数组，而仅使用切片会产生与原始数组相同等级的数组："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 6 7 8] (4,)\n",
      "--------------\n",
      "[[5 6 7 8]] (1, 4)\n",
      "--------------\n",
      "[[5 6 7 8]] (1, 4)\n"
     ]
    }
   ],
   "source": [
    "row_r1 = a[1, :]    \n",
    "row_r2 = a[1:2, :]  \n",
    "row_r3 = a[[1], :]  \n",
    "print row_r1, row_r1.shape \n",
    "print '--------------'\n",
    "print row_r2, row_r2.shape\n",
    "print '--------------'\n",
    "print row_r3, row_r3.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]] (3, 4)\n",
      "--------------\n",
      "[ 2  6 10] (3,)\n",
      "--------------\n",
      "[[ 2]\n",
      " [ 6]\n",
      " [10]] (3, 1)\n"
     ]
    }
   ],
   "source": [
    "col_r1 = a[:, 1]\n",
    "col_r2 = a[:, 1:2]\n",
    "print a,a.shape\n",
    "print '--------------'\n",
    "print col_r1, col_r1.shape\n",
    "print '--------------'\n",
    "print col_r2, col_r2.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "整数数组索引：使用切片索引到numpy数组时，生成的数组视图将始终是原始数组的子数组。 相反，整数数组索引允许您使用另一个数组中的数据构造任意数组。 这是一个例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n",
      "------------\n",
      "[1 4 5]\n",
      "------------\n",
      "[1 4 5]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "print a\n",
    "print '------------'\n",
    "print a[[0, 1, 2], [0, 1, 0]]\n",
    "print '------------'\n",
    "print np.array([a[0, 0], a[1, 1], a[2, 0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 2]\n",
      "------------\n",
      "[2 2]\n"
     ]
    }
   ],
   "source": [
    "print a[[0, 0], [1, 1]]\n",
    "print '------------'\n",
    "print np.array([a[0, 1], a[0, 1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "整数数组索引的一个有用技巧是从矩阵的每一行中选择或改变一个元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "print a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3]\n",
      "------------\n",
      "[0 2 0 1]\n",
      "------------\n",
      "[ 1  6  7 11]\n"
     ]
    }
   ],
   "source": [
    "b = np.array([0, 2, 0, 1])\n",
    "print np.arange(4)\n",
    "print '------------'\n",
    "print b\n",
    "print '------------'\n",
    "print a[np.arange(4), b]  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11  2  3]\n",
      " [ 4  5 16]\n",
      " [17  8  9]\n",
      " [10 21 12]]\n"
     ]
    }
   ],
   "source": [
    "a[np.arange(4), b] += 10\n",
    "print a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "布尔数组索引：布尔数组索引允许您选择数组的任意元素。 通常，这种类型的索引用于选择满足某些条件的数组元素。 这是一个例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n",
      "-----------\n",
      "[[False False]\n",
      " [ True  True]\n",
      " [ True  True]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "\n",
    "bool_idx = (a > 2)  \n",
    "                                        \n",
    "print a\n",
    "print '-----------'\n",
    "print bool_idx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 4 5 6]\n",
      "-----------\n",
      "[3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "# 使用布尔数组来过滤数组元素,并生产一个一维的数组\n",
    "print a[bool_idx]\n",
    "print '-----------'\n",
    "print a[a > 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为简洁起见，我们遗漏了很多关于numpy数组索引的细节; 如果你想了解更多，你应该阅读文档。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数据类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "每个numpy数组都是相同类型元素的网格。 Numpy提供了一组可用于构造数组的大量数值数据类型。 Numpy在创建数组时尝试猜测数据类型，但构造数组的函数通常还包含一个可选参数来显式指定数据类型。 下面是一个例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64 float64 int64\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2])# Let numpy choose the datatype\n",
    "y = np.array([1.0, 2.0])# Let numpy choose the datatype\n",
    "z = np.array([1, 2], dtype=np.int64)# Force a particular datatype\n",
    "\n",
    "print x.dtype, y.dtype, z.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "您可以在[文档](http://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html)中阅读有关numpy数据类型的所有信息。 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数组/矩阵的数学运算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "基本数学函数在数组上以元素方式运行，既可以作为运算符重载，也可以作为numpy模块中的函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2.]\n",
      " [3. 4.]]\n",
      "    \n",
      "[[5. 6.]\n",
      " [7. 8.]]\n",
      "----------\n",
      "[[ 6.  8.]\n",
      " [10. 12.]]\n",
      "----------\n",
      "[[ 6.  8.]\n",
      " [10. 12.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
    "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
    "\n",
    "# 矩阵对应元素相加\n",
    "print x\n",
    "print \"    \"\n",
    "print y\n",
    "print '----------'\n",
    "print x + y\n",
    "print '----------'\n",
    "print np.add(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-4. -4.]\n",
      " [-4. -4.]]\n",
      "----------\n",
      "[[-4. -4.]\n",
      " [-4. -4.]]\n"
     ]
    }
   ],
   "source": [
    "# 矩阵对应元素相减\n",
    "print x - y\n",
    "print '----------'\n",
    "print np.subtract(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5. 12.]\n",
      " [21. 32.]]\n",
      "----------\n",
      "[[ 5. 12.]\n",
      " [21. 32.]]\n"
     ]
    }
   ],
   "source": [
    "# 矩阵对应元素相乘\n",
    "print x * y\n",
    "print '----------'\n",
    "print np.multiply(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n",
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n"
     ]
    }
   ],
   "source": [
    "# 矩阵对应元素相除\n",
    "print x / y\n",
    "print np.divide(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         1.41421356]\n",
      " [1.73205081 2.        ]]\n"
     ]
    }
   ],
   "source": [
    "print np.sqrt(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "请注意，* 只是对应元素相乘，而不是矩阵乘法。 我们使用dot方法来计算向量的内积。 dot 既可以作为numpy模块中的函数使用，也可以作为数组对象的实例方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 9 10]\n",
      "    \n",
      "[11 12]\n",
      "----------\n",
      "219\n",
      "219\n",
      "----------\n",
      "[ 99 120]\n"
     ]
    }
   ],
   "source": [
    "# 向量的内积\n",
    "v = np.array([9,10])\n",
    "w = np.array([11, 12])\n",
    "\n",
    "print v\n",
    "print \"    \"\n",
    "print w\n",
    "print '----------'\n",
    "print v.dot(w)\n",
    "print np.dot(v, w)\n",
    "print '----------'\n",
    "print v * w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]] (2, 2)\n",
      "----------\n",
      "[ 9 10] (2,)\n",
      "----------\n",
      "[29 67]\n",
      "----------\n",
      "[29 67]\n"
     ]
    }
   ],
   "source": [
    "# 矩阵和向量做内积\n",
    "x = np.array([[1,2],[3,4]])\n",
    "y = np.array([[5,6],[7,8]])\n",
    "\n",
    "print x,x.shape\n",
    "print '----------'\n",
    "print v,v.shape\n",
    "print '----------'\n",
    "print x.dot(v)\n",
    "print '----------'\n",
    "print np.dot(x, v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]] (2, 2)\n",
      "----------\n",
      "[[5 6]\n",
      " [7 8]] (2, 2)\n",
      "----------\n",
      "[[19 22]\n",
      " [43 50]]\n",
      "----------\n",
      "[[19 22]\n",
      " [43 50]]\n"
     ]
    }
   ],
   "source": [
    "# Matrix / matrix product; both produce the rank 2 array\n",
    "print x,x.shape\n",
    "print '----------'\n",
    "print y,y.shape\n",
    "print '----------'\n",
    "print x.dot(y)\n",
    "print '----------'\n",
    "print np.dot(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy提供了许多用于在数组上执行计算的有用函数; 其中最有用的是求和:`sum`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "---------\n",
      "10\n",
      "---------\n",
      "[4 6]\n",
      "---------\n",
      "[3 7]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2],[3,4]])\n",
    "print x\n",
    "print '---------'\n",
    "print np.sum(x)  # 所有元素求和; prints \"10\"\n",
    "print '---------'\n",
    "print np.sum(x, axis=0)  # 按列求和; prints \"[4 6]\"\n",
    "print '---------'\n",
    "print np.sum(x, axis=1)  # 按行求和; prints \"[3 7]\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "您可以在[文档](http://docs.scipy.org/doc/numpy/reference/routines.math.html)中找到numpy提供的完整数学函数列表。 \n",
    "\n",
    "除了使用数组计算数学函数之外，我们经常需要重新改变数组形状或以其他方式操纵数组中的数据。 这种操作的最简单的例子是转置矩阵; 要转置矩阵，只需使用数组对象的T属性："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "---------\n",
      "[[1 3]\n",
      " [2 4]]\n"
     ]
    }
   ],
   "source": [
    "print x\n",
    "print '---------'\n",
    "print x.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]]\n",
      "---------\n",
      "[[1]\n",
      " [2]\n",
      " [3]]\n"
     ]
    }
   ],
   "source": [
    "v = np.array([[1,2,3]])\n",
    "print v \n",
    "print '---------'\n",
    "print v.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 广播"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "广播是一种强大的机制，允许numpy在执行算术运算时使用不同形状的数组。 我们经常有一个较小的数组和一个较大的数组，我们希望多次使用较小的数组来对较大的数组执行某些操作。\n",
    "\n",
    "例如，假设我们想要向矩阵的每一行添加一个常量向量。 我们可以这样做："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]] (4, 3)\n",
      "---------\n",
      "[1 0 1] (3,)\n",
      "---------\n",
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "# 我们将向矩阵x的每一行相加一个向量,并将结果存储在矩阵y中\n",
    "\n",
    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "v = np.array([1, 0, 1])\n",
    "y = np.empty_like(x)   # Create an empty matrix with the same shape as x\n",
    "\n",
    "# 在每一次的显式的循环中向矩阵X的每一行加上向量y\n",
    "for i in range(4):\n",
    "    y[i, :] = x[i, :] + v\n",
    "print x,x.shape\n",
    "print '---------'\n",
    "print v,v.shape\n",
    "print '---------'\n",
    "print y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这有效; 但是当矩阵x非常大时，在Python中计算显式循环可能会很慢。 注意，将向量v添加到矩阵x的每一行等同于通过垂直堆叠v的多个副本来形成矩阵vv，然后执行x和vv的元素求和。 我们可以像这样实现这种方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 1]\n",
      " [1 0 1]\n",
      " [1 0 1]\n",
      " [1 0 1]]\n"
     ]
    }
   ],
   "source": [
    "vv = np.tile(v, (4, 1))  # 将v沿着行的方向复制4次，沿列的方向复制1次\n",
    "print vv                 \n",
    "                                               "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]] (4, 3)\n",
      "---------\n",
      "[[1 0 1]\n",
      " [1 0 1]\n",
      " [1 0 1]\n",
      " [1 0 1]] (4, 3)\n",
      "---------\n",
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "y = x + vv  # 将x和vv的对应元素相加\n",
    "print x,x.shape\n",
    "print '---------'\n",
    "print vv,vv.shape\n",
    "print '---------'\n",
    "print y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy广播允许我们执行此计算而不实际创建v的多个副本。考虑这个版本，使用广播："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n",
      "----------\n",
      "[1 0 1] (3,)\n",
      "----------\n",
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# We will add the vector v to each row of the matrix x,\n",
    "# storing the result in the matrix y\n",
    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "v = np.array([1, 0, 1])\n",
    "y = x + v  # Add v to each row of x using broadcasting\n",
    "print x\n",
    "print '----------'\n",
    "print v,v.shape\n",
    "print '----------'\n",
    "print y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "即使x的形状是(4,3),v的形状是(3,)，由于广播，y = x + v 这行代码也起作用; 这行代码就好像v的形状是(4,3)，其中每一行都是v的副本，并且总和是按元素执行的。\n",
    "想进一步了解矩阵运算请阅读 [文档](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) 或这个 [探索](http://wiki.scipy.org/EricsBroadcastingDoc).\n",
    "\n",
    "支持广播的功能称为通用功能。 您可以在[文档](http://docs.scipy.org/doc/numpy/reference/ufuncs.html#available-ufuncs)中找到所有通用功能的列表.\n",
    "\n",
    "以下是广播的一些应用："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "------------\n",
      "[4 5]\n",
      "---------------\n",
      "[[1]\n",
      " [2]\n",
      " [3]]\n",
      "---------------\n",
      "[[ 4  5]\n",
      " [ 8 10]\n",
      " [12 15]]\n"
     ]
    }
   ],
   "source": [
    "# 计算两个向量的外积\n",
    "v = np.array([1,2,3])  # v 的形状是 (3,)\n",
    "w = np.array([4,5])    # w 形状是 (2,)\n",
    "# 计算外积, 首选必须将向量v的外形变成列的形式\n",
    "# 对变形后的v和w进行广播操作,使其变成两个形状一致的矩阵,然后再进行 * 运算\n",
    "# 结果矩阵的形状是(3, 2), 成为矩阵v和w的外积:\n",
    "print v\n",
    "print '------------'\n",
    "print w\n",
    "print '---------------'\n",
    "print np.reshape(v, (3, 1))\n",
    "print '---------------'\n",
    "print np.reshape(v, (3, 1)) * w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "----------\n",
      "[1 2 3]\n",
      "---------\n",
      "[[2 4 6]\n",
      " [5 7 9]]\n"
     ]
    }
   ],
   "source": [
    "# 将矩阵x的每一个行加一个向量v\n",
    "x = np.array([[1,2,3], [4,5,6]])\n",
    "print x\n",
    "print '----------'\n",
    "print v\n",
    "print '---------'\n",
    "print x + v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "----------\n",
      "[4 5]\n",
      "-------------\n",
      "[[1 4]\n",
      " [2 5]\n",
      " [3 6]]\n",
      "----------\n",
      "[[ 5  9]\n",
      " [ 6 10]\n",
      " [ 7 11]]\n",
      "----------\n",
      "[[ 5  6  7]\n",
      " [ 9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "# 将一个矩阵x的每一列加上一个向量w\n",
    "print x\n",
    "print '----------'\n",
    "print w\n",
    "print '-------------'\n",
    "print x.T\n",
    "print '----------'\n",
    "print (x.T + w)\n",
    "print '----------'\n",
    "print (x.T + w).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "----------\n",
      "[[4]\n",
      " [5]]\n",
      "---------------------\n",
      "[[ 5  6  7]\n",
      " [ 9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "# 另一种解决方法是改变向量w的形状,然后进行广播\n",
    "print x\n",
    "print '----------'\n",
    "print np.reshape(w, (2, 1))\n",
    "print '---------------------'\n",
    "print x + np.reshape(w, (2, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  4  6]\n",
      " [ 8 10 12]]\n"
     ]
    }
   ],
   "source": [
    "# 矩阵和常数相乘:\n",
    "# x 的形状是 (2, 3). Numpy 认为 常数标量 的形状是 ();\n",
    "# 所以常数标量可以被广播到与矩阵x相同的形状(2,3)\n",
    "print x * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "广播通常会使您的代码更简洁，更快速，因此您应该尽可能地使用它。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个简短的教程涉及了许多关于numpy需要了解的重要事项，但还远未完成. 想要掌握更多Numpy的技巧请阅读官方 [文档](http://docs.scipy.org/doc/numpy/reference/) ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib是一个绘图库。 在本节中，简要介绍matplotlib.pyplot模块."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过运行这个特殊的iPython命令，我们将显示内嵌图："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "“matplotlib”中最重要的功能是绘图，它允许您绘制2D数据。 这是一个简单的例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fda88473850>]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 计算sin函数的坐标x,y的坐标值\n",
    "x = np.arange(0, 3 * np.pi, 0.1)\n",
    "y = np.sin(x)\n",
    "\n",
    "plt.plot(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过一些额外的工作，我们可以轻松地一次绘制多条线，并添加标题，图例和轴标签："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fda883b3950>"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_sin = np.sin(x)\n",
    "y_cos = np.cos(x)\n",
    "\n",
    "\n",
    "plt.plot(x, y_sin)\n",
    "plt.plot(x, y_cos)\n",
    "plt.xlabel('x axis label')\n",
    "plt.ylabel('y axis label')\n",
    "plt.title('Sine and Cosine')\n",
    "plt.legend(['Sine', 'Cosine'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 子图 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "您可以使用子图功能一次绘制多个子图。 下面是一个例子"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compute the x and y coordinates for points on sine and cosine curves\n",
    "x = np.arange(0, 3 * np.pi, 0.1)\n",
    "y_sin = np.sin(x)\n",
    "y_cos = np.cos(x)\n",
    "\n",
    "# Set up a subplot grid that has height 2 and width 1,\n",
    "# and set the first such subplot as active.\n",
    "plt.subplot(2, 1, 1)\n",
    "\n",
    "# Make the first plot\n",
    "plt.plot(x, y_sin)\n",
    "plt.title('Sine')\n",
    "\n",
    "# Set the second subplot as active, and make the second plot.\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(x, y_cos)\n",
    "plt.title('Cosine')\n",
    "\n",
    "# Show the figure.\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "您可以在[文档](http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.subplot)中阅读有关子图功能的更多信息。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}