导入NumPy函数库
import numpy as np
1.创建元素（ndarray）
创建数组:
>>> a = np.array([1, 2, 3, 4]) >>> b = np.array((5, 6, 7, 8)) >>> c = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]]) >>> b array([5, 6, 7, 8]) >>> c array([[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9, 10]]) >>> c.dtype dtype('int32')
数组的大小可以通过其shape属性获得：
>>> a.shape (4,) >>> c.shape (3, 4)
在保持数组元素个数不变的情况下，改变数组每个轴的长度:
>>> c.shape = 4,3 >>> c array([[ 1, 2, 3], [ 4, 4, 5], [ 6, 7, 7], [ 8, 9, 10]])
当某个轴的元素为-1时，将根据数组元素的个数自动计算此轴的长度，因此下面的程序将数组c的shape改为了(2,6)：
>>> c.shape = 2,-1 >>> c array([[ 1, 2, 3, 4, 4, 5], [ 6, 7, 7, 8, 9, 10]])
使用数组的reshape方法，可以创建一个改变了尺寸的新数组，原数组的shape保持不变：
>>> d = a.reshape((2,2)) >>> d array([[1, 2], [3, 4]]) >>> a array([1, 2, 3, 4])
数组a和d其实共享数据存储内存区域，因此修改其中任意一个数组的元素都会同时修改另外一个数组的内容：
>>> a[1] = 100 # 将数组a的第二个元素改为100 >>> d # 注意数组d中的2也被改变了 array([[ 1, 100], [ 3, 4]])
可以通过dtype参数在创建时指定元素类型:
>>> np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]], dtype=np.float) array([[ 1., 2., 3., 4.], [ 4., 5., 6., 7.], [ 7., 8., 9., 10.]]) >>> np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]], dtype=np.complex) array([[ 1.+0.j, 2.+0.j, 3.+0.j, 4.+0.j], [ 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j], [ 7.+0.j, 8.+0.j, 9.+0.j, 10.+0.j]])
NumPy提供了很多专门用来创建数组的函数。
•arange函数类似于python的range函数，通过指定开始值、终值和步长来创建一维数组，注意数组不包括终值:
>>> np.arange(0,1,0.1)
array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
•linspace函数通过指定开始值、终值和元素个数来创建一维数组，可以通过endpoint关键字指定是否包括终值，缺省设置是包括终值:
>>> np.linspace(0, 1, 12) array([ 0. , 0.09090909, 0.18181818, 0.27272727, 0.36363636, 0.45454545, 0.54545455, 0.63636364, 0.72727273, 0.81818182, 0.90909091, 1. ])
•logspace函数和linspace类似，不过它创建等比数列，下面的例子产生1(10^0)到100(10^2)、有20个元素的等比数列:
>>> np.logspace(0, 2, 20) array([ 1. , 1.27427499, 1.62377674, 2.06913808, 2.6366509 , 3.35981829, 4.2813324 , 5.45559478, 6.95192796, 8.8586679 , 11.28837892, 14.38449888, 18.32980711, 23.35721469, 29.76351442, 37.92690191, 48.32930239, 61.58482111, 78.47599704, 100. ])
我们可以写一个Python的函数，它将数组下标转换为数组中对应的值，然后使用此函数创建数组：
>>> def func(i): ... return i%4+1 ... >>> np.fromfunction(func, (10,)) array([ 1., 2., 3., 4., 1., 2., 3., 4., 1., 2.])
创建一个二维数组表示九九乘法表，输出的数组a中的每个元素a[i, j]都等于func2(i, j):
>>> def func2(i, j): ... return (i+1) * (j+1) ... >>> a = np.fromfunction(func2, (9,9)) >>> a array([[ 1., 2., 3., 4., 5., 6., 7., 8., 9.], [ 2., 4., 6., 8., 10., 12., 14., 16., 18.], [ 3., 6., 9., 12., 15., 18., 21., 24., 27.], [ 4., 8., 12., 16., 20., 24., 28., 32., 36.], [ 5., 10., 15., 20., 25., 30., 35., 40., 45.], [ 6., 12., 18., 24., 30., 36., 42., 48., 54.], [ 7., 14., 21., 28., 35., 42., 49., 56., 63.], [ 8., 16., 24., 32., 40., 48., 56., 64., 72.], [ 9., 18., 27., 36., 45., 54., 63., 72., 81.]])
2.存取元素
数组元素的存取方法和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])
和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])
使用整数序列
当使用整数序列对数组元素进行存取时，将使用整数序列中的每个元素作为下标，整数序列可以是列表或者数组。使用整数序列作为下标获得的数组不和原始数组共享数据空间。
>>> 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个元素，组成一个新的数组 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的元素。使用布尔数组作为下标获得的数组不和原始数组共享数据空间，注意这种方式只对应于布尔数组，不能使用布尔列表。
>>> 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函数产生:
>>> x = np.random.rand(10) # 产生一个长度为10，元素值为0-1的随机数的数组 >>> x array([ 0.72223939, 0.921226 , 0.7770805 , 0.2055047 , 0.17567449, 0.95799412, 0.12015178, 0.7627083 , 0.43260184, 0.91379859]) >>> x>0.5 >>> # 数组x中的每个元素和0.5进行大小比较，得到一个布尔数组，True表示x中对应的值大于0.5 array([ True, True, True, False, False, True, False, True, False, True], dtype=bool) >>> x[x>0.5] >>> # 使用x>0.5返回的布尔数组收集x中的元素，因此得到的结果是x中所有大于0.5的元素的数组 array([ 0.72223939, 0.921226 , 0.7770805 , 0.95799412, 0.7627083 , 0.91379859])
3.多维数组
多维数组的存取和一维数组类似，因为多维数组有多个轴，因此它的下标需要用多个值来表示，NumPy采用组元(tuple)作为数组的下标。
，a为一个6x6的数组，图中用颜色区分了各个下标以及其对应的选择区域：
如何创建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]])
多维数组同样也可以使用整数序列和布尔数组进行存取。
4.结构数组
假设我们需要定义一个结构数组，它的每个元素都有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
>>> 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")
结构类型中可以包括其它的结构类型，下面的语句创建一个有一个字段f1的结构，f1的值是另外一个结构，它有字段f2，其类型为16bit整数。
>>> np.dtype([('f1', [('f2', np.int16)])]) dtype([('f1', [('f2', '<i2')])])
5.内存结构
数据存储区域保存着数组中所有元素的二进制数据，dtype对象则知道如何将元素的二进制数据转换为可用的值。数组的维数、大小等信息都保存在ndarray数组对象的数据结构中。图中显示的是如下数组的内存结构：
>>> a = np.array([[0,1,2],[3,4,5],[6,7,8]], dtype=np.float32)
strides中保存的是当每个轴的下标增加1时，数据存储区中的指针所增加的字节数。
| dimension | 3 | 3 | |
| stride | 12 | 4 | |
| 即第0轴的下标增加1数据的地址增加12个字节（3个单精度浮点数的总字节数） | |||
| 第1轴的下标增加1数据的地址增加4个字节（1个单精度浮点数的总字节数） | |||
| 以此类推： | |||
| dimension | 3 | 3 | 2 |
| stride | 3*2*4 | 2*4 | 1*4 |
| dimension | x1 | x2 | xn |
| stride | x2*x3*..*xn | x3*x4*...*xn | 1 |
如果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个字节。
224
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
