update chapter3 and README

Author: bat67

.gitignore

@@ -0,0 +1 @@
+_book

3.NumPy-basics/Array_creation.md

@@ -0,0 +1,117 @@
+<!-- TOC -->
+
+- [创建数组](#%E5%88%9B%E5%BB%BA%E6%95%B0%E7%BB%84)
+    - [导言](#%E5%AF%BC%E8%A8%80)
+    - [将Python类似数组的对象转换为NumPy数组](#%E5%B0%86python%E7%B1%BB%E4%BC%BC%E6%95%B0%E7%BB%84%E7%9A%84%E5%AF%B9%E8%B1%A1%E8%BD%AC%E6%8D%A2%E4%B8%BAnumpy%E6%95%B0%E7%BB%84)
+    - [内置的NumPy数组创建](#%E5%86%85%E7%BD%AE%E7%9A%84numpy%E6%95%B0%E7%BB%84%E5%88%9B%E5%BB%BA)
+    - [从磁盘读取数组](#%E4%BB%8E%E7%A3%81%E7%9B%98%E8%AF%BB%E5%8F%96%E6%95%B0%E7%BB%84)
+        - [标准二进制格式](#%E6%A0%87%E5%87%86%E4%BA%8C%E8%BF%9B%E5%88%B6%E6%A0%BC%E5%BC%8F)
+        - [普通的ASCII格式](#%E6%99%AE%E9%80%9A%E7%9A%84ascii%E6%A0%BC%E5%BC%8F)
+        - [自定义二进制格式](#%E8%87%AA%E5%AE%9A%E4%B9%89%E4%BA%8C%E8%BF%9B%E5%88%B6%E6%A0%BC%E5%BC%8F)
+        - [特殊库的使用](#%E7%89%B9%E6%AE%8A%E5%BA%93%E7%9A%84%E4%BD%BF%E7%94%A8)
+
+<!-- /TOC -->
+# 创建数组
+
+> 原文：[Array creation](http://docs.scipy.org/doc/numpy-dev/user/basics.creation.html)
+
+> 另见：
+[数组创建例程](http://docs.scipy.org/doc/numpy-dev/reference/routines.array-creation.html#routines-array-creation)
+
+## 导言
+
+数组创建的一般机制有五种：
+
+- 从其它Python的结构转换（如列表和元组）
+- 内置的NumPy数组创建对象（如 `arange`, `ones`, `zeros`以及其它）
+- 从磁盘中读取标准或自定义格式的数据
+- 通过使用字符串或者缓冲区，从原始的字节创建数组
+- 使用特殊的库函数（比如`random`）
+
+本节不会涉及复制和连接等扩展和转换现有数组的方法，也不会涉及创建对象数组和结构化数组。这些会在它们自己的章节中讲述。
+
+## 将Python类似数组的对象转换为NumPy数组
+
+通常，Python中排列为数组结构的数值数据可以通过`array()`函数来转换成数组，典型的例子就是列表和元组。具体使用方法请见`array()`函数的文档。一些对象也支持数组的协议，并且可以用这种方法转换成数组。辨识一个对象是否能转换为数组，最简单的方法就是在交互式环境中尝试这一方法，看看它是否有效（即Python之道）。
+
+例如：
+
+```python
+>>> x = np.array([2,3,1,0])
+>>> x = np.array([2, 3, 1, 0])
+>>> x = np.array([[1,2.0],[0,0],(1+1j,3.)]) # note mix of tuple and lists,
+    and types
+>>> x = np.array([[ 1.+0.j, 2.+0.j], [ 0.+0.j, 0.+0.j], [ 1.+1.j, 3.+0.j]])
+```
+
+## 内置的NumPy数组创建
+
+NumPy具有从无到有创建数组的内置功能：
+
+`zeros(shape)` 将创建一个填充为0的指定形状的数组。
+
+```python
+>>> np.zeros((2, 3)) array([[ 0., 0., 0.], [ 0., 0., 0.]])
+```
+
+`ones(shape)` 将创建一个填充为1的数组。在其他所有方面都和`zeros`相同。
+
+`arange()`将创建有规律的增量值数组。它的几种用法请见docstring。这里给出几个例子：
+
+```python
+>>> np.arange(10)
+array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+>>> np.arange(2, 10, dtype=np.float)
+array([ 2., 3., 4., 5., 6., 7., 8., 9.])
+>>> np.arange(2, 3, 0.1)
+array([ 2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])
+```
+
+请注意，关于最后一个用例，有一些使用技巧，请见`arrange`的docstring。
+
+`linspace()`将以指定数量的元素创建数组，并平分开始值和结束值。例如：
+
+```python
+>>> np.linspace(1., 4., 6)
+array([ 1. ,  1.6,  2.2,  2.8,  3.4,  4. ])
+```
+
+这些创建函数的好处是，可以保证元素个数、起始点和结束点，`arange()`一般不会指定任意的起始值、结束值和步长。
+
+`indices()`将创建数组的集合（用一维数组来模拟高维数组），每一维都有表示它的变量。一个例子说明比口头描述好得多：
+
+```python
+>>> np.indices((3,3))
+array([[[0, 0, 0], [1, 1, 1], [2, 2, 2]], [[0, 1, 2], [0, 1, 2], [0, 1, 2]]])
+```
+
+计算规则网格上的高维函数时，这会非常有用。
+
+## 从磁盘读取数组
+
+这大概是大数组创建的最常见情况。当然，细节取决于磁盘上的数据格式，所以这一节只能给出如何处理各种格式的一般建议。
+
+### 标准二进制格式
+
+各个领域都有数组数据的标准格式。以下列出了用于读取和返回NumPy数组的已知Python库（也有其它的库可以读取数组并转换为NumPy数组，所以也请看一下最后一节）
+
+```python
+HDF5: PyTables
+FITS: PyFITS
+```
+
+一些格式不能直接读取，但是不难将其转换为类似PIL库（能够读写许多图像格式，例如jpg、png以及其它）所支持的格式。
+
+### 普通的ASCII格式
+
+逗号分隔值文件（CSV）被广泛使用（可以被类似Excel的一些程序导入导出）。有一些在python中读取这些文件的方法，例如Python和pylab（Matplotlib的一部分）中的函数。
+
+更通用的ASCII文件可以使用SciPy的IO包来读取。
+
+### 自定义二进制格式
+
+有多种方法可以使用。如果文件有一个相对简单的格式，那么你可以写一个简单的I/O库并使用`numpy fromfile()`和`tofile()`方法直接读写NumPy数组（注意字节顺序！）。如果有一个不错的C/C++库可以用于读取数据，则可以用各种技巧把它封装一下，虽然这可能要耗费一些工作量，也需要更多高级的知识来和C/C++交互。
+
+### 特殊库的使用
+
+有一些库可以用于生成特殊用途的数组，这样的库不可能全部列举出来。最常见的用法是使用许多数组生成函数来产生带有随机值的数组，以及使用一些生成特殊矩阵（如对角线）的功能函数。

3.NumPy-basics/Broadcasting.md

@@ -0,0 +1,127 @@
+<!-- TOC -->
+
+- [数据类型](#%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B)
+    - [数组类型和类型之间的转换](#%E6%95%B0%E7%BB%84%E7%B1%BB%E5%9E%8B%E5%92%8C%E7%B1%BB%E5%9E%8B%E4%B9%8B%E9%97%B4%E7%9A%84%E8%BD%AC%E6%8D%A2)
+    - [数组标量](#%E6%95%B0%E7%BB%84%E6%A0%87%E9%87%8F)
+    - [扩展精度](#%E6%89%A9%E5%B1%95%E7%B2%BE%E5%BA%A6)
+
+<!-- /TOC -->
+
+# 数据类型
+
+> 原文：[Data types](http://docs.scipy.org/doc/numpy-dev/user/basics.types.html)
+
+> 另见：
+[数据类型对象](http://docs.scipy.org/doc/numpy-dev/reference/arrays.dtypes.html#arrays-dtypes)
+
+## 数组类型和类型之间的转换
+
+NumPy支持的数值类型比Python更多。这一节会讲述所有可用的类型，以及如何改变数组的数据类型。
+
+| 数据类型 | 描述 |
+| --- | --- |
+| bool_ | 以字节存储的布尔值（True 或 False） |
+| int_ | 默认的整数类型（和 C 的 long 一样，是 int64 或者 int32） |
+| intc | 和 C 的 int 相同（一般为 int64 或 int32） |
+| intp | 用于下标的整数（和 C 的 ssize_t 相同，一般为int64 或者 int32） |
+| int8 | 字节（-128 到 127） |
+| int16 | 整数（-32768 到 32767） |
+| int32 | 整数（-2147483648 到 2147483647） |
+| int64 | 整数（-9223372036854775808 到 9223372036854775807） |
+| uint8 | 无符号整数（0 到 255） |
+| uint16 | 无符号整数（0 到 65535） |
+| uint32 | 无符号整数（0 到 4294967295） |
+| uint64 | 无符号整数（0 到 18446744073709551615） |
+| float_ | float64 的简写 |
+| float16 | 半精度浮点：1位符号，5位指数，10位尾数 |
+| float32 | 单精度浮点：1位符号，8位指数，23位尾数 |
+| float64 | 双精度浮点：1位符号，11位指数，52位尾数 |
+| complex_ | complex128 的简写 |
+| complex64 | 由两个32位浮点（实部和虚部）组成的复数 |
+| complex128 | 由两个64位浮点（实部和虚部）组成的复数 |
+
+此外，Intel平台相关的C整数类型 `short`、`long`，`long long` 和它们的无符号版本是有定义的。
+
+NumPy数值类型是dtype对象的实例，每个都有独特的特点。一旦你导入了NumPy：
+
+```python
+>>> import numpy as np
+```
+
+这些 dtype 都可以通过 `np.bool_` ， `np.float32` 以及其它的形式访问。
+
+更高级的类型不在表中给出，请见[结构化数组](http://docs.scipy.org/doc/numpy-dev/user/basics.rec.html#structured-arrays)一节。
+
+有5种基本的数值类型：布尔（`bool`），整数（`int`），无符号整数（`uint`），浮点（`float`）和复数。其中的数字表示类型所占的位数（即需要多少位代表内存中的一个值）。有些类型，如`int`和`intp`，依赖于平台（例如32位和64位机）有不同的位数。在与低级别的代码（如C或Fortran）交互和在原始内存中寻址时应该考虑到这些。
+
+数据类型可以用做函数，来将Python类型转换为数组标量（详细解释请见数组标量一节），或者将Python的数值序列转换为同类型的NumPy数组，或者作为参数传入接受dtype的关键词的NumPy函数或方法中，例如：
+
+```python
+>>> import numpy as np
+>>> x = np.float32(1.0)
+>>> x
+1.0
+>>> y = np.int_([1,2,4])
+>>> y
+array([1, 2, 4])
+>>> z = np.arange(3, dtype=np.uint8)
+>>> z
+array([0, 1, 2], dtype=uint8)
+```
+
+数组类型也可以由字符代码指定，这主要是为了保留旧的包的向后兼容，如Numeric。一些文档仍旧可能这样写，例如：
+
+```python
+>>> np.array([1, 2, 3], dtype='f')
+array([ 1.,  2.,  3.], dtype=float32)
+```
+
+我们推荐用 dtype 对象来取代。
+
+要转换数组类型，使用 `.astype()` 方法（推荐），或者将类型自身用作函数，例如：
+
+```python
+>>> z.astype(float)
+array([  0.,  1.,  2.])
+>>> np.int8(z)
+array([0, 1, 2], dtype=int8)
+```
+
+需要注意的是，上面我们使用Python的浮点对象作为 dtype。NumPy知道`int`是指`np.int_`，`bool`指`np.bool_`，`float`指`np.float_`，`complex`指`np.complex_ `。其他数据类型在Python中没有对应。
+
+通过查看 dtype 属性来确定数组的类型：
+
+```python
+>>> z.dtype
+dtype('uint8')
+```
+
+dtype 对象还包含有关类型的信息，如它的位宽和字节顺序。数据类型也可以间接用于类型的查询属性，例如检查是否是整数：
+
+```python
+>>> d = np.dtype(int)
+>>> d
+dtype('int32')
+
+>>> np.issubdtype(d, int)
+True
+
+>>> np.issubdtype(d, float)
+False
+```
+
+## 数组标量
+
+NumPy一般以数组标量返回数组元素（带有相关dtype的标量）。数组标量不同于Python标量，但他们中的大部分可以互换使用（一个主要的例外是2.x之前的Python，其中整数数组标量不能作为列表和元组的下标）。也有一些例外，比如当代码需要标量的一个非常特定的属性，或检查一个值是否是特定的Python标量时。一般来说，总是可以使用相应的Python类型函数（如`int`，`float`，`complex`，`str`，`unicode`），将数组标量显式转换为Python标量来解决问题。
+
+使用数组标量的主要优点是，它们保留了数组的类型（Python可能没有匹配的标量类型，如`int16`）。因此，使用数组标量确保了数组和标量之间具有相同的行为，无论值在不在数组中。NumPy标量也有许多和数组相同的方法。
+
+## 扩展精度
+
+Python 的浮点数通常都是64位的，几乎相当于 `np.float64` 。在一些不常见的情况下，更精确的浮点数可能更好。是否可以这样做取决于硬件和开发环境：具体来说，x86 机器提供了80位精度的硬件浮点支持，虽然大多数 C 编译器都以 `long double` 类型来提供这个功能，但 MSVC （标准的Windows版本）中 `long double` 和 `double` 一致。NumPy中可以通过 `np.longdouble` 来使用编译器的 `long double` （复数为 `np.clongdouble` ）。你可以通过 `np.finfo(np.longdouble)` 来了解你的 numpy 提供了什么。
+
+NumPy 不提供比 C 的 `long double` 精度更高的 dtype；特别是128位 IEEE 四精度数据类型（Fortran 的 `REAL*16`）是不能用的。
+
+为了高效的内存对齐，`np.longdouble`通常填充零位来存储，共96位或128位。哪个更有效取决于硬件环境；通常在32位系统中，他们被填充到96位，而在64位系统，他们通常是填充到128位。`np.longdouble` 以系统默认的方式填充；而 `np.float96` 和 `np.float128` 为那些需要特定填充位的用户提供。尽管名字不同，`np.float96` 和 `np.float128`都只提供和`np.longdouble`相同的精度，也就是说，大多数 x86 机器上面只有80位，标准Windows版本上只有64位。
+
+注意，即使`np.longdouble`比Python的`float`精度更高，也很容易失去额外的精度，因为Python经常强行以`float`来传值。例如，`%`格式化运算符要求其参数转换成标准的Python类型，因此它不可能保留额外的精度，即使要求更多的小数位数。可以使用`1 + np.finfo(np.longdouble).eps`来测试你的代码。

3.NumPy-basics/Byte-swapping.md

@@ -0,0 +1,10 @@
+# NumPy基础
+
+- [数据类型](Data_types.md)
+- [创建数组](Array_creation.md)
+- [](IO_with_NumPy.md)
+- [](Indexing.md)
+- [](Broadcasting.md)
+- [](Byte-swapping.md)
+- [](Structured_arrays.md)
+- [](Subclassing_ndarray.md)