转载：http://blog.csdn.net/pipisorry/article/details/39215089
NumPy介绍
Numpy(读作num-pie)是Python中的一个矩阵计算包，功能类似于MATLAB的矩阵计算。
标准安装的Python中用列表(list)保存一组值，可以用来当作数组使用，不过由于列表的元素可以是任何对象，因此列表中所保存的是对象的指针。这样为了保存一个简单的[1,2,3]，需要有3个指针和三个整数对象。对于数值运算来说这种结构显然比较浪费内存和CPU计算时间。
此外Python还提供了一个array模块，array对象和列表不同，它直接保存数值，和C语言的一维数组比较类似。但是由于它不支持多维，也没有各种运算函数，因此也不适合做数值运算。
NumPy的诞生弥补了这些不足，NumPy提供了两种基本的对象：ndarray（N-dimensional array object）和ufunc（universal function object）。ndarray(下文统一称之为数组)是存储单一数据类型的多维数组(同c语言数组直接保存数值，见下面的多维数组ndarray内存结构部分)，而ufunc则是能够对数组进行处理的函数。from:张若愚的《Python科学计算》
具体参见http://www.numpy.org/
安装numpy参见linux和windows中安装python科学计算环境-pycharm、numpy
在Python中使用help帮助
>>> import numpy
>>> help(numpy.argsort)
Numpy中array和ndarray的区别
What is the difference between ndarray and array in numpy?
np.array is just a convenience function to create an ndarray, it is not a class itself.
You can also create an array using np.ndarray, but it is not the recommended way. From the docstring of np.ndarray:
Arrays should be constructed using array, zeros orempty ... The parameters given here refer to a low-level method (ndarray(...)) for instantiating an array.
where can I find the implementations in the numpy source code?
1 Most of the meat of the implementation is in C code, here in multiarray, but you can start looking at the ndarray interfaces here:
https://github.com/numpy/numpy/blob/master/numpy/core/numeric.py
2 array() is implemented in core/src/multiarray/methods.c in array_getarray()
皮皮blog
NumPy中的数据类型
对于科学计算来说，Python中自带的整型、浮点型和复数类型远远不够，因此NumPy中添加了许多数据类型。
Numpy中基础的数据类型是np.dtype类的对象.
需要指定所用数据类型的场合, 比如新生成数组时, 一般都会有个可选参数叫dtype (注意看上面示例). 这个参数可以接受真正的np.dtype对象, 也可以很聪明地直接接收普通的标量类型, 也可以接收各种类型的字符串表示(注意看下面那个大列表里的字符简称). 其默认值一般都是python原生的那种float型(一般就相当于C里面的double).
类似于其他语言的int, float, double之类的标量类型并不是np.dtype类型对象, 但可以用它来构造np.dtype对象. 比如用Python原生的float型来构造:my_type = np.dtype(float)
numpy缺失值的表示(None, np.NaN, np.NaT, pd.NaT)
NaN: not a number, NaN is the default missing value marker forreasons of computational speed and convenience, we need to be able to easilydetect this value with data of different types: floating point, integer,boolean, and general object.
None: treats None like np.nan. In many cases, however, the Python None will arise and we wish to also consider that “missing” or “null”.
NaT: Datetimes, For datetime64[ns] types, NaT represents missing values. This is a pseudo-native sentinel value that can be represented by numpy in a singular dtype (datetime64[ns]). pandas objects provide intercompatibility between NaT and NaN.
inf: Prior to version v0.10.0 inf and -inf were also considered to be “null” in computations. This is no longer the case by default; use the mode.use_inf_as_null option to recover it.
Note: numpy缺失值的判断要用np.isnan(),而不能使用a[0] == np.NaN.[numpy教程：逻辑函数Logic functions ]
numpy数据类型
Numpy中提供了更细致的标量类型, 见下表,这些基础的标量类型不是np.dtype对象.
每一个numpy内置的数据类型都有一个特征码，它能唯一标识数据类型：
采用特征码来表示数据类型时，特征码来表示数据类型时，第一个字符指明数据的种类，其余字符指明每一种数据类型的字节（ 对于字符串来说，该指明字符中字符数）。其中数据 类型的字节数必须与某一个 numpy内置的类型相匹配，否则将会抛出异常。
np.类型名对应于别的语言的类型字符简称Booleansnp.bool_Python bool'?'np.bool88 bit bool Intnp.byteC char'b'np.shortC short'h'np.intcC int'i' #int32np.int_Python int'l'np.longlongC long long'q'np.intp用作指针??'p'np.int8 np.int16 np.int32 np.int64特定长度 Unsigned Intnp.ubyteC unsigned char'B'np.ushortC unsigned short'H'np.uintcC unsigned int'I'np.uint_Python unsigned int'L'np.ulonglongC unsigned long long'Q'np.uintp用作指针??'P'np.uint8 np.uint16 np.uint32 np.uint64特定长度 Floatnp.singleC float'f'np.doubleC double np.float_Python float'd'np.longfloatC long float'g'np.float32 np.float64 np.float96 np.float128特定长度 后两个依赖于平台 Complex(复数)np.csingle 'F'np.complex_Python complex'D'np.clongfloat 'G'np.complex64 np.complex128 np.complex192 np.complex256特定长度 后两个依赖于平台 Any Python Objectnp.object_保存的实际是引用'O'np.str_Python str'S#' # = number #控制每个str长度np.unicode_Python unicode'U#'void 'V#'
NumPy中的基本数据类型取值范围
名称描述bool用一个Bit存储的布尔类型（True或False）inti由所在平台决定其大小的整数（一般为int32或int64）int8一个字节大小，-128 至 127int16整数，-32768 至 32767int32整数，-2 ** 31 至 2 ** 32 -1int64整数，-2 ** 63 至 2 ** 63 - 1uint8无符号整数，0 至 255uint16无符号整数，0 至 65535uint32无符号整数，0 至 2 ** 32 - 1uint64无符号整数，0 至 2 ** 64 - 1float16半精度浮点数：16位，正负号1位，指数5位，精度10位float32单精度浮点数：32位，正负号1位，指数8位，精度23位float64或float双精度浮点数：64位，正负号1位，指数11位，精度52位complex64复数，分别用两个32位浮点数表示实部和虚部complex128或complex复数，分别用两个64位浮点数表示实部和虚部
[NumPy数组（数组初探）]
[Data type objects]
[Data type objects (dtype)]
多维数组ndarray内存结构
下面让我们来看看ndarray数组对象是如何在内存中储存的。如下图所示，关于数组的描述信息保存在一个数据结构中，这个结构引用两个对象：一块用于保存数据的存储区域和一个用于描述元素类型的dtype对象。
ndarray数组对象在内存中的储存方式
数据存储区域保存着数组中所有元素的二进制数据，dtype对象则知道如何将元素的二进制数据转换为可用的值。数组的维数、大小等信息都保存在ndarray数组对象的数据结构中。图中显示的是如下数组的内存结构：
>>> a = np.array([[0,1,2],[3,4,5],[6,7,8]], dtype=np.float32)
a.strides
(12, 4)
strides中保存的是当每个轴的下标增加1时，数据存储区中的指针所增加的字节数。例如图中的strides为12,4，即第0轴的下标增加1时，数据的地址增加12个字节：即a[1,0]的地址比a[0,0]的地址要高12个字节，正好是3个单精度浮点数的总字节数；第1轴下标增加1时，数据的地址增加4个字节，正好是单精度浮点数的字节数。
如果strides中的数值正好和对应轴所占据的字节数相同的话，那么数据在内存中是连续存储的。然而数据并不一定都是连续储存的，前面介绍过通过下标范围得到新的数组是原始数组的视图，即它和原始视图共享数据存储区域：
>>> b = a[::2,::2]
>>> b
array([[ 0., 2.],
[ 6., 8.]], dtype=float32)
>>> b.strides
(24, 8)
由于数组b和数组a共享数据存储区，而b中的第0轴和第1轴都是数组a中隔一个元素取一个，因此数组b的strides变成了24,8，正好都是数组a的两倍。 对照前面的图很容易看出数据0和2的地址相差8个字节，而0和6的地址相差24个字节。
元素在数据存储区中的排列格式有两种：C语言格式和Fortan语言格式。在C语言中，多维数组的第0轴是最上位的，即第0轴的下标增加1时，元素的地址增加的字节数最多；而Fortan语言的多维数组的第0轴是最下位的，即第0轴的下标增加1时，地址只增加一个元素的字节数。在NumPy中，元素在内存中的排列缺省是以C语言格式存储的，如果你希望改为Fortan格式的话，只需要给数组传递order="F"参数：
>>> c = np.array([[0,1,2],[3,4,5],[6,7,8]], dtype=np.float32, order="F")
>>> c.strides
(4, 12)
皮皮blog
ndarray数组维度-横向量和列向量
{关于numpy数组维度表示上的区别，numpy多维数组横向量和列向量的区别}
zeros([5,]) #返回的是一维列向量
[ 0. 0. 0. 0. 0.]
#等价于这样的矩阵（一维数组），zeros([5])、zeros(5)以及zeros(5,)
zeros([5, 1]) #返回的是二维列向量
[[ 0.]
[ 0.]
[ 0.]
[ 0.]
[ 0.]]
zeros([1, 5]) #二维横向量
[[ 0. 0. 0. 0. 0.]]
a = array([1,2,3]) #一维列向量
print(a.shape, a)
b = array([[1,2,3]]) #二维横向量
print(b.shape, b)
(3,) [1 2 3]
(1, 3) [[1 2 3]]
Note:a=np.array([1,2,3]) 由 a.shape知道a是一个列向量，而b=np.array([[1,2,3]])是一个横向量。
b=arange(1,5) #列向量
print(b.shape, b)
a=array([[1,2,3,4]])#横向量
print(a.shape, a)
print(a+b)
(4,) [1 2 3 4]
(1, 4) [[1 2 3 4]]
[[2 4 6 8]]
Note:
1. 上面的例子没有说明的，数值就是原来的，没有变。比较上面知道，基本上横向量和列向量是可以任意加减的。但是其他的要有一样的shape才可以。
2.一维列向量的转置还是本身。
3. 一维列向量（如(3,)）在广播运算中是当做二维行向量（如(1,3)）计算的。也就是说(3,)相当于(1,3)。
np.mean(二维向量)
返回的是一个一维列向量
numpy.mean的维度：规范化，x矩阵中xi总是以列向量表示一个数据点，行代表维度（行0代表维度1）
A = [[-2. -1. 0. 1. 2.] [-1. 0. -1. 2. 0.] [ 1. 1. 1. -1. -2.]]
col_mean = np.mean(A, 0)
print(col_mean.shape)(5,) [[-1.33333333 -1. 0. 0.33333333 2. ] [-0.33333333 0. -1. 1.33333333 0. ]
[ 1.66666667 1. 1. -1.66666667 -2. ]]
col_mean = np.mean(A, 0).reshape(1, len(A[0]))
print(col_mean.shape)
# print(col_mean)
A -= col_mean
print(A)
(1, 5) [[-1.33333333 -1. 0. 0.33333333 2. ] [-0.33333333 0. -1. 1.33333333 0. ] [ 1.66666667 1. 1. -1.66666667 -2. ]]
皮皮blog
array元素存取
元素存取的不同方式
下标范围存取元素
结束索引在这儿是不被包含的！和python中的list的索引相同！但是不同于pandas中的索引是被包含的！！！
数组元素的存取方法和Python的标准方法相同：
>>> a = np.arange(10)
>>> a[5] # 用整数作为下标可以获取数组中的某个元素
5
>>> a[3:5] # 用范围作为下标获取数组的一个切片，包括a[3]不包括a[5]
array([3, 4])
>>> a[:5] # 省略开始下标，表示从a[0]开始
array([0, 1, 2, 3, 4])
>>> a[:-1] # 下标可以使用负数，表示从数组后往前数
array([0, 1, 2, 3, 4, 5, 6, 7, 8])
>>> a[2:4] = 100,101 # 下标还可以用来修改元素的值
>>> a
array([ 0, 1, 100, 101, 4, 5, 6, 7, 8, 9])
>>> a[1:-1:2] # 范围中的第三个参数表示步长，2表示隔一个元素取一个元素
array([ 1, 101, 5, 7])
>>> a[::-1] # 省略范围的开始下标和结束下标，步长为-1，整个数组头尾颠倒
array([ 9, 8, 7, 6, 5, 4, 101, 100, 1, 0])
>>> a[5:1:-2] # 步长为负数时，开始下标必须大于结束下标
array([ 5, 101])
numpy数组下标是可以越界的！
>>> b array([1, 2, 3, 4, 5, 6]) >>> b[1:30309] array([2, 3, 4, 5, 6]) 如果越界了，会自动检测，只返回到结尾的数据。
和Python的列表序列不同，通过下标范围获取的新的数组是原始数组的一个视图，它与原始数组共享同一块数据空间。
>>> b = a[3:7] # 通过下标范围产生一个新的数组b，b和a共享同一块数据空间
>>> b
array([101, 4, 5, 6])
>>> b[2] = -10 # 将b的第2个元素修改为-10
>>> b
array([101, 4, -10, 6])
>>> a # a的第5个元素也被修改为10
array([ 0, 1, 100, 101, 4, -10, 6, 7, 8, 9])
除了使用下标范围存取元素之外，NumPy还提供了两种存取元素的高级方法。
使用整数序列
当使用整数序列对数组元素进行存取时，将使用整数序列中的每个元素作为下标，整数序列可以是列表或者数组。使用整数序列作为下标获得的数组不和原始数组共享数据空间。
>>> x = np.arange(10,1,-1)
>>> x
array([10, 9, 8, 7, 6, 5, 4, 3, 2])
>>> x[[3, 3, 1, 8]] # 获取x中的下标为3, 3, 1, 8的4个元素，组成一个新的数组；python自带的list不能这么做
array([7, 7, 9, 2])
>>> b = x[np.array([3,3,-3,8])] #下标可以是负数
>>> b[2] = 100
>>> b
array([7, 7, 100, 2])
>>> x # 由于b和x不共享数据空间，因此x中的值并没有改变
array([10, 9, 8, 7, 6, 5, 4, 3, 2])
>>> x[[3,5,1]] = -1, -2, -3 # 整数序列下标也可以用来修改元素的值
>>> x
array([10, -3, 8, -1, 6, -2, 4, 3, 2])
使用布尔数组
当使用布尔数组b作为下标存取数组x中的元素时，将收集数组x中所有在数组b中对应下标为True的元素，使用布尔数组作为下标获得的数组不和原始数组共享数据空间。
注意这种方式只对应于布尔数组（np.array([True, False, ....])），不能使用布尔列表([True, False, ....])。
使用布尔数组进行numpy数组值的替换：a[ a == 3] = 4; ll_array[np.array(labels_list) == label] = km_model.centers[label]
>>> x = np.arange(5,0,-1)
>>> x
array([5, 4, 3, 2, 1])
>>> x[np.array([True, False, True, False, False])]
>>> # 布尔数组中下标为0，2的元素为True，因此获取x中下标为0,2的元素
array([5, 3])
>>> x[[True, False, True, False, False]]
>>> # 如果是布尔列表，则把True当作1, False当作0，按照整数序列方式获取x中的元素
array([4, 5, 4, 5, 5])
>>> x[np.array([True, False, True, True])]
>>> # 布尔数组的长度不够时，不够的部分都当作False
array([5, 3, 2])
>>> x[np.array([True, False, True, True])] = -1, -2, -3
>>> # 布尔数组下标也可以用来修改元素
>>> x
array([-1, 4, -2, -3, 1])
布尔数组一般不是手工产生，而是使用布尔运算的ufunc函数产生，关于ufunc函数请参照 ufunc运算 一节。
>>> x
array([ 0.72223939, 0.921226 , 0.7770805 , 0.2055047 , 0.17567449,
0.95799412, 0.12015178, 0.7627083 , 0.43260184, 0.91379859])
>>> x[x>0.5]
array([ 0.72223939, 0.921226 , 0.7770805 , 0.95799412, 0.7627083 , 0.91379859])
多维数组切片操作
多维数组的存取和一维数组类似，因为多维数组有多个轴，因此它的下标需要用多个值来表示，NumPy采用组元(tuple)作为数组的下标。如下图所示，a为一个6x6的数组，图中用颜色区分了各个下标以及其对应的选择区域。
虽然我们经常在Python中用圆括号将组元括起来，但是其实组元的语法定义只需要用逗号隔开即可,不需要圆括号，例如 x,y=y,x 就是用组元交换变量值的一个例子。
使用数组切片语法访问多维数组中的元素
如何创建这个数组: 数组a实际上是一个加法表，纵轴的值为0, 10, 20, 30, 40, 50；横轴的值为0, 1, 2, 3, 4, 5。纵轴的每个元素都和横轴的每个元素求和，就得到图中所示的数组a。你可以用下面的语句创建它，至于其原理我们将在后面的章节进行讨论：
>>> np.arange(0, 60, 10).reshape(-1, 1) + np.arange(0, 6)
array([[ 0, 1, 2, 3, 4, 5],
[10, 11, 12, 13, 14, 15],
[20, 21, 22, 23, 24, 25],
[30, 31, 32, 33, 34, 35],
[40, 41, 42, 43, 44, 45],
[50, 51, 52, 53, 54, 55]])
多维数组同样也可以使用整数序列和布尔数组进行存取
假设x是一个二维数组，inds是整数序列的数组array类型表示的下标：
如果inds是一个一维array，则x[inds]返回的是一个二维array；但是如果inds是一个二维array，则x[inds]返回的是一个三维array。
import numpy as np
x = np.array([[1, 2, 3], [2, 3, 4]])
inds = np.array([0, 1])
print(x[inds].shape, '\n', x[inds])
inds = np.array([[0, 1]])
print(x[inds].shape, '\n', x[inds])
(2, 3) [[1 2 3] [2 3 4]] (1, 2, 3) [[[1 2 3] [2 3 4]]]
使用整数序列和布尔数组访问多维数组中的元素
a[(0,1,2,3,4),(1,2,3,4,5)] : 用于存取数组的下标和仍然是一个有两个元素的组元，组元中的每个元素都是整数序列，分别对应数组的第0轴和第1轴。从两个序列的对应位置取出两个整数组成下标： a[0,1], a[1,2], ..., a[4,5]。
a[3:, [0, 2, 5]] : 下标中的第0轴是一个范围，它选取第3行之后的所有行；第1轴是整数序列，它选取第0, 2, 5三列。
a[mask, 2] : 下标的第0轴是一个布尔数组，它选取第0，2，5行；第1轴是一个整数，选取第2列。
结构数组
在C语言中我们可以通过struct关键字定义结构类型，结构中的字段占据连续的内存空间，每个结构体占用的内存大小都相同，因此可以很容易地定义结构数组。和C语言一样，在NumPy中也很容易对这种结构数组进行操作。只要NumPy中的结构定义和C语言中的定义相同，NumPy就可以很方便地读取C语言的结构数组的二进制数据，转换为NumPy的结构数组。
假设我们需要定义一个结构数组，它的每个元素都有name, age和weight字段。在NumPy中可以如下定义：
import numpy as np
persontype = np.dtype({
'names':['name', 'age', 'weight'],
'formats':['S32','i', 'f']})
a = np.array([("Zhang",32,75.5),("Wang",24,65.2)],
dtype=persontype)
我们先创建一个dtype对象persontype，通过其字典参数描述结构类型的各个字段。字典有两个关键字：names，formats。每个关键字对应的值都是一个列表。names定义结构中的每个字段名，而formats则定义每个字段的类型：
S32 : 32个字节的字符串类型，由于结构中的每个元素的大小必须固定，因此需要指定字符串的长度
i : 32bit的整数类型，相当于np.int32
f : 32bit的单精度浮点数类型，相当于np.float32
然后我们调用array函数创建数组，通过关键字参数 dtype=persontype， 指定所创建的数组的元素类型为结构persontype。运行上面程序之后，我们可以在IPython中执行如下的语句查看数组a的元素类型
>>> a.dtype
dtype([('name', '|S32'), ('age', ' 这里我们看到了另外一种描述结构类型的方法： 一个包含多个组元的列表，其中形如 (字段名, 类型描述) 的组元描述了结构中的每个字段。类型描述前面为我们添加了 "|", "<" 等字符，这些字符用来描述字段值的字节顺序： | : 忽视字节顺序 < : 低位字节在前 > : 高位字节在前 结构数组的存取方式和一般数组相同，通过下标能够取得其中的元素，注意元素的值看上去像是组元，实际上它是一个结构： >>> a[0] ('Zhang', 32, 75.5) >>> a[0].dtype dtype([('name', '|S32'), ('age', ' a[0]是一个结构元素，它和数组a共享内存数据，因此可以通过修改它的字段，改变原始数组中的对应字段： >>> c = a[1] >>> c["name"] = "Li" >>> a[1]["name"] "Li" 结构像字典一样可以通过字符串下标获取其对应的字段值： >>> a[0]["name"] 'Zhang' 我们不但可以获得结构元素的某个字段，还可以直接获得结构数组的字段，它返回的是原始数组的视图，因此可以通过修改b[0]改变a[0]["age"]： >>> b=a[:]["age"] # 或者a["age"] >>> b array([32, 24]) >>> b[0] = 40 >>> a[0]["age"] 40 通过调用a.tostring或者a.tofile方法，可以直接输出数组a的二进制形式： >>> a.tofile("test.bin") 利用下面的C语言程序可以将test.bin文件中的数据读取出来。 内存对齐 C语言的结构体为了内存寻址方便，会自动的添加一些填充用的字节，这叫做内存对齐。例如如果把下面的name[32]改为name[30]的话，由于内存对齐问题，在name和age中间会填补两个字节，最终的结构体大小不会改变。因此如果numpy中的所配置的内存大小不符合C语言的对齐规范的话，将会出现数据错位。为了解决这个问题，在创建dtype对象时，可以传递参数align=True，这样numpy的结构数组的内存对齐和C语言的结构体就一致了。 #include struct person { char name[32]; int age; float weight; }; struct person p[2]; void main () { FILE *fp; int i; fp=fopen("test.bin","rb"); fread(p, sizeof(struct person), 2, fp); fclose(fp); for(i=0;i<2;i++) printf("%s %d %f", p[i].name, p[i].age, p[i].weight); getchar(); } 结构类型中可以包括其它的结构类型，下面的语句创建一个有一个字段f1的结构，f1的值是另外一个结构，它有字段f2，其类型为16bit整数。 >>> np.dtype([('f1', [('f2', np.int16)])]) dtype([('f1', [('f2', ' 当某个字段类型为数组时，用组元的第三个参数表示，下面描述的f1字段是一个shape为(2,3)的双精度浮点数组: >>> np.dtype([('f0', 'i4'), ('f1', 'f8', (2, 3))]) dtype([('f0', ' 用下面的字典参数也可以定义结构类型，字典的关键字为结构中字段名，值为字段的类型描述，但是由于字典的关键字是没有顺序的，因此字段的顺序需要在类型描述中给出，类型描述是一个组元，它的第二个值给出字段的字节为单位的偏移量，例如age字段的偏移量为25个字节： >>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)}) dtype([('surname', '|S25'), ('age', '|u1')]) [http://mp.weixin.qq.com/s?__biz=MjM5NzU0MzU0Nw==&mid=204507794&idx=2&sn=56f4950a7399af1b1bf69e194d55a48a&scene=1&from=singlemessage&isappinstalled=0#rd] 掩码数组 {表示的是不完整的数据或是含有无效值的数据} >>> import numpy.ma as ma >>> b array([2, 3, 3, 0, 1, 4, 2, 4]) >>> mask=b<3 >>> mx=ma.array(b,mask=mask) >>> mx masked_array(data = [-- 3 3 -- -- 4 -- 4], mask = [ True False False True True False True False],fill_value = 999999) 接下来就可以对这些数据操作了 点(…) 代表许多产生一个完整的索引元组必要的分号。如果x是秩为5的数组(即它有5个轴)，那么: x[1,2,…] 等同于 x[1,2,:,:,:], x[…,3] 等同于 x[:,:,:,:,3] x[4,…,5,:] 等同 x[4,:,:,5,:]. >>> c = array( [ [[ 0, 1, 2], # a 3D array (two stacked 2D arrays) ... [ 10, 12, 13]], ... ... [[100,101,102], ... [110,112,113]] ] ) >>> c.shape (2, 2, 3) >>> c[1,...] # same as c[1,:,:] or c[1] array([[100, 101, 102], [110, 112, 113]]) >>> c[...,2] # same as c[:,:,2] array([[ 2, 13], [102, 113]]) from:http://blog.csdn.net/pipisorry/article/details/39215089 ref: NumPy Reference* 中文 Python 笔记：03.numpy* 《Python科学计算》 《Tentative NumPy Tutorial》