安装numpy

如果你用的是Anaconda，那numpy已经装好了，如果不是，你可以参考这里http://www.numpy.org/的安装教程，如果你安装好了import一下，检查一下版本：

import numpy
numpy.__version__
'1.11.1'

在SciPy/PyData世界工作的人一般会对numpy进行缩写：

import numpy as np

查看numy内置文档

比如想看numpy命名空间下的所有内容，你可以输入：

In [3]: np.<TAB>

查看numpy内置文档，可以输入：

In [4]: np?

Python里的数据类型

C或者Java是静态类型语言，意思是变量类型需要事先声明，Python是一种动态类型语言，可以省略这种规范，
比如下面一段C语言代码：

/* C code */
int result = 0;
for(int i=0; i<100; i++){
    result += i;
}

在Python里可以写成这样：

# Python code
result = 0
for i in range(100):
    result += i

主要区别是在Python里变量可以动态推断，也就是你可以给变量赋值任何类型的数据：

# Python code
x = 4
x = "four"

这里我们可以把x的内容从一个整数替换成一个字符串，同样的事在C语言里会产生编译错误：

/* C code */
int x = 4;
x = "four";  // FAILS

Python整数不只是整数

标准的 Python 实现是用 C 编写的。这意味着每个 Python 对象只是一个巧妙伪装的 C 结构，它不仅包含它的值，还包含其他信息。比如我们可以在Python里定义一个整数 x = 10000，x不只是一个“raw”的整数，它实际上是一个指向复合 C 结构的指针，其中包含多个值。它实际上是一个指向复合 C 结构的指针，其中包含多个值。查看 Python 3.4 源代码，我们发现integer (long) 类型定义实际上看起来像这样（一次 C 宏被扩展）：

struct _longobject {
    long ob_refcnt;
    PyTypeObject *ob_type;
    size_t ob_size;
    long ob_digit[1];
};

一个Python 3.4整数实际上包含4个成分：

• ob_refcnt，帮助 Python 静默处理内存分配和释放的引用计数
• ob_type，编码变量的类型
• ob_size，指定随后数据成员的大小
• ob_digit，我们希望Python变量代表的那个整数

这意味着与在 C 等编译语言中存储整数相比，在 Python 中存储整数开销较大，如下图所示：

Python.png

在这PyObject_HEAD是包含参引用计数、类型代码和前面提到的其他部分的结构的一部分。

请注意这里的区别：C 整数本质上是内存中某个位置的标签，其字节编码整数值。 Python 整数是指向内存中某个位置的指针，该位置包含所有 Python 对象信息，包括包含整数值的字节。 Python 整数结构中的这些额外信息使 Python 可以如此自由和动态地编码。然而，Python 类型中的所有这些额外信息都是有代价的，这在组合了许多这些对象的结构中变得尤为明显。

Python列表不只是列表

现在让我们考虑一下当一个Python数据结构包含很多Python对象的时候会发生什么。Python 中标准的可变多元素容器是列表。让我们先创建一个整数列表：

L = list(range(10))
L
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
type(L[0])
int

或者是一个字符串列表：

L2 = [str(c) for c in L]
L2
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
type(L2[0])
str

由于 Python 的动态类型，我们甚至可以创建异构列表：

L3 = [True, "2", 3.0, 4]
[type(item) for item in L3]
[bool, str, float, int]

但这种灵活性是有代价的：为了允许这些灵活的类型，列表中的每一项都必须包含自己的类型信息、引用计数和其他信息——也就是说，每一项都是一个完整的 Python 对象。在所有变量都属于同一类型的特殊情况下，这些信息中的大部分都是多余的：将数据存储在固定类型的数组中会更有效率。下图说明了动态类型列表和静态类型（NumPy 样式）数组之间的区别：

Numpy数组和Python列表.png

在实现层面，数组本质上包含一个指向一个连续数据块的指针。另一方面，Python 列表包含一个指向指针块的指针，每个指针又指向一个完整的 Python 对象，例如我们之前看到的 Python 整数。同样，列表的优点是灵活性：因为每个列表元素都是包含数据和类型信息的完整结构，所以列表可以填充任何所需类型的数据。静态类型的 NumPy 样式数组缺乏这种灵活性，但在存储和操作数据方面效率更高。

Python的静态数组

Python 提供了几种不同的选项来将数据存储在高效、固定类型的数据缓冲区中。内置数组模块（自 Python 3.3 起可用）可用于创建统一类型的密集数组。

import array
L = list(range(10))
A = array.array('i', L)
A
array('i', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

其中 'i' 是类型code，意思是保存的是整数类型。

然而，更有用的是 NumPy 包的 ndarray 对象。虽然 Python 的数组对象提供了基于数组的数据的高效存储，但 NumPy 增加了对该数据的高效操作。我们将在后面的部分探讨这些操作；这里我们将演示几种创建 NumPy 数组的方法。

我们先import一下：

import numpy as np

从Python列表创建numpy数组

我们可以用np.array从Python列表创建数组：

# integer array:
np.array([1, 4, 2, 5, 3])
array([1, 4, 2, 5, 3])

请记住，与 Python 列表不同，NumPy 仅限于包含相同类型的数组。如果类型不匹配，NumPy 将尽可能向上转换（这里，整数被向上转换为浮点数）。

np.array([3.14, 4, 2, 3])
array([ 3.14,  4.  ,  2.  ,  3.  ])

如果我们想指定输出数组的类型，可以用dtype：

np.array([1, 2, 3, 4], dtype='float32')
array([ 1.,  2.,  3.,  4.], dtype=float32)

最后，与 Python 列表不同，NumPy 数组可以是多维的；这是使用一组列表初始化多维数组的一种方法：

# nested lists result in multi-dimensional arrays
np.array([range(i, i + 3) for i in [2, 4, 6]])
array([[2, 3, 4],
       [4, 5, 6],
       [6, 7, 8]])

内部列表被视为二维数组的行。

从零开始创建数组

特别是对于较大的数组，使用 NumPy 中内置的例程从头开始创建数组效率更高：

# Create a length-10 integer array filled with zeros
np.zeros(10, dtype=int)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
# Create a 3x5 floating-point array filled with ones
np.ones((3, 5), dtype=float)
array([[ 1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.]])
# Create a 3x5 array filled with 3.14
np.full((3, 5), 3.14)
array([[ 3.14,  3.14,  3.14,  3.14,  3.14],
       [ 3.14,  3.14,  3.14,  3.14,  3.14],
       [ 3.14,  3.14,  3.14,  3.14,  3.14]])
# Create an array filled with a linear sequence
# Starting at 0, ending at 20, stepping by 2
# (this is similar to the built-in range() function)
np.arange(0, 20, 2)
array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])
# Create an array of five values evenly spaced between 0 and 1
np.linspace(0, 1, 5)
array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
# Create a 3x3 array of uniformly distributed
# random values between 0 and 1
np.random.random((3, 3))
array([[ 0.99844933,  0.52183819,  0.22421193],
       [ 0.08007488,  0.45429293,  0.20941444],
       [ 0.14360941,  0.96910973,  0.946117  ]])
# Create a 3x3 array of normally distributed random values
# with mean 0 and standard deviation 1
np.random.normal(0, 1, (3, 3))
array([[ 1.51772646,  0.39614948, -0.10634696],
       [ 0.25671348,  0.00732722,  0.37783601],
       [ 0.68446945,  0.15926039, -0.70744073]])
# Create a 3x3 array of random integers in the interval [0, 10)
np.random.randint(0, 10, (3, 3))
array([[2, 3, 4],
       [5, 7, 8],
       [0, 5, 0]])
# Create a 3x3 identity matrix
np.eye(3)
array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.]])
# Create an uninitialized array of three integers
# The values will be whatever happens to already exist at that memory location
np.empty(3)
array([ 1.,  1.,  1.])

NumPy标准数据类型

NumPy 数组包含单一类型的值，因此详细了解这些类型及其限制非常重要。因为 NumPy 是用 C 构建的，所以 C、Fortran 和其他相关语言的用户会熟悉这些类型。
下表列出了标准的 NumPy 数据类型。请注意，在构造数组时，可以使用字符串指定它们：

np.zeros(10, dtype='int16')

或使用相关的np对象：

np.zeros(10, dtype=np.int16)

还有更高级的类型规范，例如指定大端或小端数字；有关详细信息，请参阅NumPy documentation。
NumPy也支持复合数据类型，在这个教程里有介绍： Structured Data: NumPy's Structured Arrays。