1.3.1.4基本可视化

现在我们有了第一个数组，我们将要进行可视化。

从pylab模式启动IPython。

  1. ipython --pylab

或notebook：

  1. ipython notebook --pylab=inline

或者如果IPython已经启动，那么：

In [119]:

  1. %pylab
  1. Using matplotlib backend: MacOSX
  2. Populating the interactive namespace from numpy and matplotlib

或者从Notebook中：

In [121]:

  1. %pylab inline
  1. Populating the interactive namespace from numpy and matplotlib

inline 对notebook来说很重要，以便绘制的图片在notebook中显示而不是在新窗口显示。

Matplotlib是2D制图包。我们可以像下面这样导入它的方法：

In [10]:

  1. import matplotlib.pyplot as plt  #整洁形式

然后使用（注你需要显式的使用 show ）:

  1. plt.plot(x, y)       # 线图
  2. plt.show()           # <-- 显示图表（使用pylab的话不需要）

或者，如果你使用 pylab：

  1. plt.plot(x, y)       # 线图

在脚本中推荐使用 import matplotlib.pyplot as plt。 而交互的探索性工作中用 pylab。

  • 1D作图：

In [12]:

  1. x = np.linspace(0, 3, 20)
  2. y = np.linspace(0, 9, 20)
  3. plt.plot(x, y)       # 线图

Out[12]:

  1. [<matplotlib.lines.Line2D at 0x1068f38d0>]

1.3.1.4基本可视化 - 图1

In [13]:

  1. plt.plot(x, y, 'o')  # 点图

Out[13]:

  1. [<matplotlib.lines.Line2D at 0x106b32090>]

1.3.1.4基本可视化 - 图2

  • 2D 作图:

In [14]:

  1. image = np.random.rand(30, 30)
  2. plt.imshow(image, cmap=plt.cm.hot)    
  3. plt.colorbar()

Out[14]:

  1. <matplotlib.colorbar.Colorbar instance at 0x106a095f0>

1.3.1.4基本可视化 - 图3

更多请见matplotlib部分（暂缺）

练习：简单可视化

画出简单的数组：cosine作为时间的一个函数以及2D矩阵。

在2D矩阵上试试使用 gray colormap。

1.3.1.5索引和切片

数组的项目可以用与其他Python序列（比如：列表）一样的方式访问和赋值：

In [15]:

  1. a = np.arange(10)
  2. a

Out[15]:

  1. array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [16]:

  1. a[0], a[2], a[-1]

Out[16]:

  1. (0, 2, 9)

警告：索引从0开始与其他的Python序列（以及C/C++）一样。相反，在Fortran或者Matlab索引从1开始。

使用常用的Python风格来反转一个序列也是支持的：

In [17]:

  1. a[::-1]

Out[17]:

  1. array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])

对于多维数组，索引是整数的元组：

In [18]:

  1. a = np.diag(np.arange(3))
  2. a

Out[18]:

  1. array([[0, 0, 0],
  2.        [0, 1, 0],
  3.        [0, 0, 2]])

In [19]:

  1. a[1, 1]

Out[19]:

  1. 1

In [21]:

  1. a[2, 1] = 10 # 第三行，第二列
  2. a

Out[21]:

  1. array([[ 0,  0,  0],
  2.        [ 0,  1,  0],
  3.        [ 0, 10,  2]])

In [22]:

  1. a[1]

Out[22]:

  1. array([0, 1, 0])

注：

  • 在2D数组中，第一个纬度对应行，第二个纬度对应列。
  • 对于多维度数组 a，a[0]被解释为提取在指定纬度的所有元素

切片：数组与其他Python序列也可以被切片：

In [23]:

  1. a = np.arange(10)
  2. a

Out[23]:

  1. array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [24]:

  1. a[2:9:3] # [开始:结束:步长]

Out[24]:

  1. array([2, 5, 8])

注意最后一个索引是不包含的！：

In [25]:

  1. a[:4]

Out[25]:

  1. array([0, 1, 2, 3])

切片的三个元素都不是必选：默认情况下，起点是0，结束是最后一个，步长是1：

In [26]:

  1. a[1:3]

Out[26]:

  1. array([1, 2])

In [27]:

  1. a[::2]

Out[27]:

  1. array([0, 2, 4, 6, 8])

In [28]:

  1. a[3:]

Out[28]:

  1. array([3, 4, 5, 6, 7, 8, 9])

Numpy索引和切片的一个小说明…

numpy_indexing

赋值和切片可以结合在一起：

In [29]:

  1. a = np.arange(10)
  2. a[5:] = 10
  3. a

Out[29]:

  1. array([ 0,  1,  2,  3,  4, 10, 10, 10, 10, 10])

In [30]:

  1. b = np.arange(5)
  2. a[5:] = b[::-1]
  3. a

Out[30]:

  1. array([0, 1, 2, 3, 4, 4, 3, 2, 1, 0])

练习：索引与切片

  • 试试切片的特色，用起点、结束和步长：从linspace开始，试着从后往前获得奇数，从前往后获得偶数。 重现上面示例中的切片。你需要使用下列表达式创建这个数组：

In [31]:

  1. np.arange(6) + np.arange(0, 51, 10)[:, np.newaxis]

Out[31]:

  1. array([[ 0,  1,  2,  3,  4,  5],
  2.        [10, 11, 12, 13, 14, 15],
  3.        [20, 21, 22, 23, 24, 25],
  4.        [30, 31, 32, 33, 34, 35],
  5.        [40, 41, 42, 43, 44, 45],
  6.        [50, 51, 52, 53, 54, 55]])

练习：数组创建

创建下列的数组（用正确的数据类型）：

  1. [[1, 1, 1, 1],
  2.  [1, 1, 1, 1],
  3.  [1, 1, 1, 2],
  4.  [1, 6, 1, 1]]
  6. [[0., 0., 0., 0., 0.],
  7.  [2., 0., 0., 0., 0.],
  8.  [0., 3., 0., 0., 0.],
  9.  [0., 0., 4., 0., 0.],
  10.  [0., 0., 0., 5., 0.],
  11.  [0., 0., 0., 0., 6.]]

参考标准：每个数组

提示：每个数组元素可以像列表一样访问，即a[1] 或 a[1, 2]。

提示：看一下 diag 的文档字符串。

练习：创建平铺数组

看一下 np.tile 的文档，是用这个函数创建这个数组：

  1. [[4, 3, 4, 3, 4, 3],
  2.  [2, 1, 2, 1, 2, 1],
  3.  [4, 3, 4, 3, 4, 3],
  4.  [2, 1, 2, 1, 2, 1]]