转载：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科学计算》
安装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()
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.类型名 | 对应于别的语言的类型 | 字符简称 |
| Booleans | ||
| np.bool_ | Python bool | '?' |
| np.bool8 | 8 bit bool | |
| Int | ||
| np.byte | C char | 'b' |
| np.short | C short | 'h' |
| np.intc | C int | 'i' #int32 |
| np.int_ | Python int | 'l' |
| np.longlong | C long long | 'q' |
| np.intp | 用作指针?? | 'p' |
| np.int8 np.int16 np.int32 np.int64 | 特定长度 | |
| Unsigned Int | ||
| np.ubyte | C unsigned char | 'B' |
| np.ushort | C unsigned short | 'H' |
| np.uintc | C unsigned int | 'I' |
| np.uint_ | Python unsigned int | 'L' |
| np.ulonglong | C unsigned long long | 'Q' |
| np.uintp | 用作指针?? | 'P' |
| np.uint8 np.uint16 np.uint32 np.uint64 | 特定长度 | |
| Float | ||
| np.single | C float | 'f' |
| np.double | C double | |
| np.float_ | Python float | 'd' |
| np.longfloat | C 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 Object | ||
| np.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 至 127 |
| int16 | 整数，-32768 至 32767 |
| int32 | 整数，-2 ** 31 至 2 ** 32 -1 |
| int64 | 整数，-2 ** 63 至 2 ** 63 - 1 |
| uint8 | 无符号整数，0 至 255 |
| uint16 | 无符号整数，0 至 65535 |
| uint32 | 无符号整数，0 至 2 ** 32 - 1 |
| uint64 | 无符号整数，0 至 2 ** 64 - 1 |
| float16 | 半精度浮点数：16位，正负号1位，指数5位，精度10位 |
| float32 | 单精度浮点数：32位，正负号1位，指数8位，精度23位 |
| float64或float | 双精度浮点数：64位，正负号1位，指数11位，精度52位 |
| complex64 | 复数，分别用两个32位浮点数表示实部和虚部 |
| complex128或complex | 复数，分别用两个64位浮点数表示实部和虚部 |
[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)
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. ]]
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', '<i4'), ('weight', '<f4')])
这里我们看到了另外一种描述结构类型的方法： 一个包含多个组元的列表，其中形如 (字段名, 类型描述) 的组元描述了结构中的每个字段。类型描述前面为我们添加了 "|", "<" 等字符，这些字符用来描述字段值的字节顺序：
| : 忽视字节顺序
< : 低位字节在前
> : 高位字节在前
结构数组的存取方式和一般数组相同，通过下标能够取得其中的元素，注意元素的值看上去像是组元，实际上它是一个结构：
>>> a[0]
('Zhang', 32, 75.5)
>>> a[0].dtype
dtype([('name', '|S32'), ('age', '<i4'), ('weight', '<f4')])
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 <stdio.h>
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', '<i2')])])
当某个字段类型为数组时，用组元的第三个参数表示，下面描述的f1字段是一个shape为(2,3)的双精度浮点数组:
>>> np.dtype([('f0', 'i4'), ('f1', 'f8', (2, 3))])
dtype([('f0', '<i4'), ('f1', '<f8', (2, 3))])
用下面的字典参数也可以定义结构类型，字典的关键字为结构中字段名，值为字段的类型描述，但是由于字典的关键字是没有顺序的，因此字段的顺序需要在类型描述中给出，类型描述是一个组元，它的第二个值给出字段的字节为单位的偏移量，例如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科学计算》
《Tentative NumPy Tutorial》
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
