1.科学计算工具-Numpy基础数据结构

1.1、数组ndarray的属性

NumPy数组是一个多维数组对象，称为ndarray。其由两部分组成：

① 实际的数据

② 描述这些数据的元数据

注意数组格式，中括号，元素之间没有逗号(和列表的区别)

type(ar)是查看变量的类型(注意了，type(ar)是函数，ar.dtype是方法查看数值的类型)

ar.ndim查看数组的维度

ar.shape 数组的维度，对于n行m列的数组，shape为(n，m)

ar.size  数组的元素总数，对于n行m列的数组，元素总数为n*m

ar.itemsize 数组中每个元素的字节大小，int32类型字节为4，float64的字节为8

importnumpy as np

ar= np.array([1,2,3,4,5,6]) #一维数组就是1行

print(ar, type(ar), ar.dtype)

打印：

[1 2 3 4 5 6] int32

#输出数组，注意数组的格式：中括号，元素之间没有逗号(和列表区分)； 数组中元素的类型，类似type()是查看变量的类型(注意了，type()是函数，.dtype是方法查看数值的类型)

ar= np.array([[1,2,3,4,5,6], [2,3,4,5,6,7]]) #二维数组就是1行1列

print(ar)

打印：

[[1 2 3 4 5 6]

[2 3 4 5 6 7]]

ar= np.array([[1,2,3,4,5,6], [2,3,4,5,6,7], [3,4,5,6,7,8]]) #3行6列的二维数组

print(ar)

打印：

[[1 2 3 4 5 6]

[2 3 4 5 6 7]

[3 4 5 6 7 8]]

ar= np.array([[[1,2,3,4,5,6], [2,3,4,5,6,7], [3,4,5,6,7,8]],[[1,2,3,4,5,6], [2,3,4,5,6,7], [3,4,5,6,7,8]]]) #2个二维数组或多个二维数组即三维数组

print(ar)

打印：

[[[1 2 3 4 5 6]

[2 3 4 5 6 7]

[3 4 5 6 7 8]]

[[1 2 3 4 5 6]

[2 3 4 5 6 7]

[3 4 5 6 7 8]]]

ar= np.array([[1,2,3,4,5,6], [2,3,4,5,6,7], [3,4,5,6,7,8]]) #3行6列的二维数组#ar = np.array([[[1,2,3,4,5,6], [2,3,4,5,6,7], [3,4,5,6,7,8]], [[1,2,3,4,5,6], [2,3,4,5,6,7], [3,4,5,6,7,8]]]) #2个二维数组或多个二维数组即三维数组

print(ar, type(ar), ar.dtype)print(ar.ndim) #输出数组维度的个数(轴数)，或者说“秩”，维度的数量也称rank

print(ar.shape) ## 数组的维度，对于n行m列的数组，shape为(n，m)

print(ar.size) #数组的元素总数，对于n行m列的数组，元素总数为n*m

print(ar.itemsize) #数组中每个元素的字节大小，int32类型字节为4，float64的字节为8

print(ar.data) #包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。

ar #交互方式下输出，会有array(数组)

打印：

[[1 2 3 4 5 6]

[2 3 4 5 6 7]

[3 4 5 6 7 8]] int322(3, 6)18

4

array([[1, 2, 3, 4, 5, 6],

[2, 3, 4, 5, 6, 7],

[3, 4, 5, 6, 7, 8]])

数组的基本属性

① 数组的维数称为秩(rank)，一维数组的秩为1，二维数组的秩为2，以此类推

② 在NumPy中，每一个线性的数组称为是一个轴(axes)，秩其实是描述轴的数量：

比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组

所以一维数组就是NumPy中的轴(axes)，第一个轴相当于是底层数组，第二个轴是底层数组里的数组。

而轴的数量——秩，就是数组的维数。

1.2、数组的创建

创建数组方法一： array()函数 、 arange()，类似range()，在给定间隔内返回均匀间隔的值。

np.array(列表、元组、数组、生成器 ) 如：np.array(range(10)) ，如果有两个嵌套序列，长度不一样就会变成一维数组；

np.arange(5, 12, 2)--类似range( ) 返回5-11的数，步长为2

>>> ar1 = np.array(range(10)) #整型

>>>ar1

array([0,1, 2, 3, 4, 5, 6, 7, 8, 9])>>> print(ar1)

[01 2 3 4 5 6 7 8 9]>>> ar2 = np.arange(10)

>>> print(ar2)

[0 1 2 3 4 5 6 7 8 9]

>>> ar3 = np.array([1,2,3,4,5])>>> print(ar3,type(ar3),ar3.dtype)

[1 2 3 4 5] int32>>> ar3 = np.array([1,2,3.14,4,5.20]) #浮点型

>>> print(ar3,type(ar3),ar3.dtype)

[1. 2. 3.14 4. 5.2 ] float64>>> ar4 = np.array([[1,2,3,4,5],[5,6,7,8,9]])>>> print(ar4)

[[1 2 3 4 5]

[5 6 7 8 9]]>>> ar4 = np.array([[1,2,3,4,5],[5,6,7,8,9,10]]) #嵌套序列不一样就会变成一维数组

>>> print(ar4,type(ar4),ar4.dtype,ar4.ndim)

[list([1, 2, 3, 4, 5]) list([5, 6, 7, 8, 9, 10])] object 1>>> ar4 = np.array([[1,2,3,4,5],['a','b','c','d','e']])>>> print(ar4)

[['1' '2' '3' '4' '5']

['a' 'b' 'c' 'd' 'e']]>>> print(ar4,ar4.ndim)

[['1' '2' '3' '4' '5']

['a' 'b' 'c' 'd' 'e']] 2

>>> ar4 = np.array([[1,2,3],('a','b','c')]) ######二维数组，嵌套序列，可以是列表可以是元组。

>>> print(ar4, ar4.shape, ar4.ndim, ar4.size)

[['1' '2' '3']

['a' 'b' 'c']] (2, 3) 2 6

>>>

>>> print(np.random.rand(10).reshape(2,5)) ###随机数组，10个0-1的数字，2乘以5

[[0.927168 0.77335508 0.0120362 0.1504996 0.93548895]

[0.34811207 0.41284246 0.75599419 0.53838818 0.74908313]]>>>

创建数组方法二：linspace():返回在间隔[开始，停止]上计算的num个均匀间隔的样本。

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None) 如np.linspace(10, 20, 11)

start：起始值，stop：结束值

num：生成样本数，默认为50

endpoint：默认值为True(可不写)，即包含最后一个值。endpoint = False 是不包含最后一个值。

retstep：默认值为False(可不写)，即步长不显示出来；如果为真retstep = True就会返回样本的步长(间距)。返回(样本，步骤)，其中步长是样本之间的间距 → 输出为一个包含2个元素的元祖，第一个元素为array，第二个为步长实际值

>>> print(np.linspace(10,20,num=20)) #10-20，前后都是闭合，都可以取到。它是把19拆分了。

[10. 10.52631579 11.05263158 11.57894737 12.10526316 12.63157895

13.15789474 13.68421053 14.21052632 14.73684211 15.26315789 15.78947368

16.31578947 16.84210526 17.36842105 17.89473684 18.42105263 18.94736842

19.47368421 20. ]>>> print(np.linspace(10,20,num=21))

[10. 10.5 11. 11.5 12. 12.5 13. 13.5 14. 14.5 15. 15.5 16. 16.5

17. 17.5 18. 18.5 19. 19.5 20. ]>>> print(np.linspace(10,20,num=21,endpoint = False)) #默认是True， False是最后一个值不包含；

[10. 10.47619048 10.95238095 11.42857143 11.9047619 12.38095238

12.85714286 13.33333333 13.80952381 14.28571429 14.76190476 15.23809524

15.71428571 16.19047619 16.66666667 17.14285714 17.61904762 18.0952381

18.57142857 19.04761905 19.52380952]>>> print(np.linspace(10,20,num=21,endpoint = True)) #跟上边一样了，可以省略不写

[10. 10.5 11. 11.5 12. 12.5 13. 13.5 14. 14.5 15. 15.5 16. 16.5

17. 17.5 18. 18.5 19. 19.5 20. ]>>> s = np.linspace(10,20,num=21,retstep =True)>>> print(s,type(s))

(array([10. , 10.5, 11. , 11.5, 12. , 12.5, 13. , 13.5, 14. , 14.5, 15. ,15.5, 16. , 16.5, 17. , 17.5, 18. , 18.5, 19. , 19.5, 20. ]), 0.5) #2个元素，一个为array，另一个为步长。

>>> print(s[0])

[10. 10.5 11. 11.5 12. 12.5 13. 13.5 14. 14.5 15. 15.5 16. 16.5

17. 17.5 18. 18.5 19. 19.5 20. ]>>> print(np.linspace(10,20,num=21,retstep =False)) #默认为False

[10. 10.5 11. 11.5 12. 12.5 13. 13.5 14. 14.5 15. 15.5 16. 16.5

17. 17.5 18. 18.5 19. 19.5 20. ]

创建数组方法三：zeros()/zeros_like()/ones()/ones_like()

np.zeros((3, 5), dtype=np.int )、np.zeros_like(ar)

#numpy.zeros(shape, dtype=float, order='C'):返回给定形状和类型的新数组，用零填充。shape：数组纬度，二维以上需要用()，且输入参数为整数dtype：数据类型，默认numpy.float64order：是否在存储器中以C或Fortran连续(按行或列方式)存储多维数据。

>>> print(np.zeros(5))

[0. 0. 0. 0. 0.]>>> print(np.zeros(10))

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]>>> print(np.zeros((3,5)))

[[0. 0. 0. 0. 0.]

[0. 0. 0. 0. 0.]

[0. 0. 0. 0. 0.]]>>> print(np.zeros((3,5), dtype=np.int))

[[0 0 0 0 0]

[0 0 0 0 0]

[0 0 0 0 0]]>>> ar = np.array([list(range(10)),list(range(10,20))])>>> print(ar)

[[ 01 2 3 4 5 6 7 8 9]

[10 11 12 13 14 15 16 17 18 19]]>>> print(np.zeros_like(ar))

[[0 0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0 0]]>>> ar2 = np.ones(9)>>> ar3 = np.ones((2,3,4))>>> ar4 =np.ones_like(ar3)>>> print(ar2)

[1. 1. 1. 1. 1. 1. 1. 1. 1.]>>> print(ar3)

[[[1. 1. 1. 1.]

[1. 1. 1. 1.]

[1. 1. 1. 1.]]

[[1. 1. 1. 1.]

[1. 1. 1. 1.]

[1. 1. 1. 1.]]]>>> print(ar4)

[[[1. 1. 1. 1.]

[1. 1. 1. 1.]

[1. 1. 1. 1.]]

[[1. 1. 1. 1.]

[1. 1. 1. 1.]

[1. 1. 1. 1.]]]>>>

>>>

创建数组方法四：eye()

# 创建一个正方的N*N的单位矩阵，对角线值为1，其余为0

>>> print(np.eye(5))

[[1. 0. 0. 0. 0.]

[0.1. 0. 0. 0.]

[0. 0.1. 0. 0.]

[0. 0. 0.1. 0.]

[0. 0. 0. 0.1.]]

ndarray的数据类型bool用一个字节存储的布尔类型(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位浮点数表示实部和虚部

2、Numpy通用函数

2.1数组形状：

ar.T (一维数组转置后结果不变，二维数组如shape(2,5) .T后为shape(5,2))

ar.reshape(2,5) 直接将已有数组改变形状；np.zero(2,3).reshape(3,4)生成数组后直接改变形状；np.reshape(np.arange(12),(3,4))参数内添加数组，目标形状

数组提供新形状，而不更改其数据，所以元素数量需要一致！！

np.resize(np.arange(5),(3,4))

>>> importnumpy as np>>> ar1 = np.arange(10)>>> print(ar1,'\n',ar1.T) #一维数组转置后结果不变

[01 2 3 4 5 6 7 8 9]

[01 2 3 4 5 6 7 8 9]>>> ar2 = np.ones((5,2))>>> print(ar2,'\n',ar2.T)

[[1. 1.]

[1. 1.]

[1. 1.]

[1. 1.]

[1. 1.]]

[[1. 1. 1. 1. 1.]

[1. 1. 1. 1. 1.]]>>>

# .T方法：转置，例如原shape为(3,4)/(2,3,4)，转置结果为(4,3)/(4,3,2) → 所以一维数组转置后结果不变

>>> ar3 = ar1.reshape(2,5) #reshape用法一，直接将已有数组改变形状。>>> print(ar1,'\n',ar3)

[01 2 3 4 5 6 7 8 9]

[[01 2 3 4]

[5 6 7 8 9]]>>> ar4 = np.zeros((4,6)).reshape(3,8) #reshape用法二，生成数组后直接改变形状。>>> print(ar4)

[[0. 0. 0. 0. 0. 0. 0. 0.]

[0. 0. 0. 0. 0. 0. 0. 0.]

[0. 0. 0. 0. 0. 0. 0. 0.]]>>> ar5 = np.reshape(np.arange(12),(3,4)) #reshape用法三，参数内添加数组，目标形状。>>> print(ar5)

[[ 01 2 3]

[4 5 6 7]

[8 9 10 11]]>>>

# numpy.reshape(a, newshape, order='C')：为数组提供新形状，而不更改其数据，所以元素数量需要一致！！

>>> ar6 = np.resize(np.arange(5),(3,4))>>> print(ar6)

[[01 2 3]

[4 0 1 2]

[3 4 0 1]]>>>

# numpy.resize(a, new_shape)：返回具有指定形状的新数组，如有必要可重复填充所需数量的元素。

# 注意了：.T/.reshape()/.resize()都是生成新的数组！！！

2.2数组的复制(赋值=，　　copy())

赋值进行修改ar1中的值，ar2也会改变，它们指向的是同一个数值。

而使用copy方法(  ar1.copy( ) )再去进行修改，就不会变了。

>>> ar1 = np.arange(10)>>> ar2 =ar1>>> print(ar2 isar1)

True>>> ar1[2] = 9 #赋值，ar1改变，ar2也会改变；

>>> print(ar1, ar2)

[01 9 3 4 5 6 7 8 9] [0 19 3 4 5 6 7 8 9]

# 回忆python的赋值逻辑：指向内存中生成的一个值 → 这里ar1和ar2指向同一个值，所以ar1改变，ar2一起改变>>> ar3 =ar1.copy()>>> print(ar3 isar1)

False>>> ar1[0] = 9

>>> print(ar1, ar3) #copy()方法，ar1改变，ar3不会变

[9 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]>>>

# copy方法生成数组及其数据的完整拷贝

2.3数组类型转换：.astype()

ar1.astype(np.int64)

>>> ar1 = np.arange(10, dtype=float)>>> print(ar1,ar1.dtype)

[0.1. 2. 3. 4. 5. 6. 7. 8. 9.] float64

# 可以在参数位置设置数组类型>>> ar2 =ar1.astype(np.int32)>>> print(ar2,ar2.dtype)

[01 2 3 4 5 6 7 8 9] int32

# a.astype()：转换数组类型

# 注意：养成好习惯，数组类型用np.int32，而不是直接int32

2.4数组堆叠

np.hstack((数组1，数组2) ) 水平堆叠数组，括号内的如果是一维数组形状可以不一样，二维数组形状要一致 (水平堆叠，堆这堆这缺位了不行呀)

np.vstack((a,b))垂直堆叠数组，

np.stack((a,b),axis = 1)       axis默认为0，可不写，即按照垂直的堆，注意跟vstack的区别；  axis=1即按照横向的堆与hstack不一样的哦。

>>> a = np.arange(5) #a为一维数组，5个元素；>>> b = np.arange(5,9) #b为一维数组，4个元素；>>> ar1 =np.hstack((a,b)) #注意：((a,b))这里形状可以不一样。>>> print(a,a.shape)

[01 2 3 4] (5,)>>> print(b,b.shape)

[5 6 7 8] (4,)>>> print(ar1,ar1.shape)

[01 2 3 4 5 6 7 8] (9,)>>>

>>> a = np.array([[1],[2],[3]]) #a为二维数组，3行1列；>>> b = np.array([['a'],['b'],['c']]) #b为二维数组，3行1列；>>> ar2 =np.hstack((a,b)) #((a,b))，这里a，b形状必须一致。水平(按列顺序)堆叠数组>>> print(a,a.shape,'\n', b,b.shape)

[[1]

[2]

[3]] (3, 1)

[['a']

['b']

['c']] (3, 1)>>> print(ar2,ar2.shape)

[['1' 'a']

['2' 'b']

['3' 'c']] (3, 2)

# numpy.hstack(tup)：水平(按列顺序)堆叠数组>>>

>>> a = np.arange(5)>>> b = np.arange(5,10)>>> ar1 =np.vstack((a,b))>>> print(a,a.shape,'\n', b,b.shape)

[01 2 3 4] (5,)

[5 6 7 8 9] (5,)>>> print(ar1,ar1.shape)

[[01 2 3 4]

[5 6 7 8 9]] (2, 5)>>> a = np.array([[1],[2],[3]])>>> b = np.array([['a'],['b'],['c'],['d']])>>> ar2 =np.vstack((a,b)) #这里形状可以不一样。垂直(按行顺序)丢叠数组>>> print(a,a.shape,'\n',b,b.shape)

[[1]

[2]

[3]] (3, 1)

[['a']

['b']

['c']

['d']] (4, 1)>>>print(ar2,ar2.shape)

[['1']

['2']

['3']

['a']

['b']

['c']

['d']] (7, 1)

# numpy.vstack(tup)：垂直(按行顺序)堆叠数组>>>

>>> a = np.arange(5)>>> b = np.arange(5,10)>>> ar1 =np.stack((a,b))>>> ar2 =np.stack((a,b),axis = 1)>>> print(a,a.shape,'\n',b,b.shape)

[01 2 3 4] (5,)

[5 6 7 8 9] (5,)>>>print(ar1,ar1.shape)

[[01 2 3 4]

[5 6 7 8 9]] (2, 5)>>> print(ar2,ar2.shape)

[[0 5]

[1 6]

[2 7]

[3 8]

[4 9]] (5, 2)>>>

# numpy.stack(arrays, axis=0)：沿着新轴连接数组的序列，形状必须一样！

# 重点解释axis参数的意思，假设两个数组[1 2 3]和[4 5 6]，shape均为(3,0)

#axis=0：[[1 2 3] [4 5 6]]，shape为(2,3)

# axis=1：[[1 4] [2 5] [3 6]]，shape为(3,2)

>>> a = np.array([[1],[2],[3]]) #3行1列的二维数组

>>> b = np.array([['a'],['b'],['c']]) #3行1列的二维数组

>>> print(np.hstack((a,b))) #3行2列

[['1' 'a']

['2' 'b']

['3' 'c']]>>> print(np.vstack((a,b))) #6行1列

[['1']

['2']

['3']

['a']

['b']

['c']]>>> print(np.stack((a,b))) #shape为(2,3,1)，每个元素表示相应的数组每一维的长度。ndim为3

[[['1']

['2']

['3']]

[['a']

['b']

['c']]]>>> print(np.stack((a,b),axis =0)) #默认为0，可不写。

[[['1']

['2']

['3']]

[['a']

['b']

['c']]]>>> print(np.stack((a,b),axis = 1))#.shape --> (3,2,1) ； .ndim ---> 3

[[['1']

['a']]

[['2']

['b']]

[['3']

['c']]]>>>

2.5数组拆分(np.hsplit( ar, n)垂直　　np.vsplit(ar, n)水平拆分 )

>>> ar = np.arange(16).reshape(4,4)>>> ar1 = np.hsplit(ar,2)>>> print(ar)

[[ 01 2 3]

[4 5 6 7]

[8 9 10 11]

[12 13 14 15]]>>> print(ar1,type(ar1))

[array([[ 0,1],

[ 4, 5],

[ 8, 9],

[12, 13]]),array([[ 2, 3],

[ 6, 7],

[10, 11],

[14, 15]])]

# numpy.hsplit(ary, indices_or_sections)：将数组垂直(逐列)拆分为多个子数组 → 按列拆分

# 输出结果为列表，列表中元素为数组

>>> ar2 =np.vsplit(ar,4)>>> print(ar2,type(ar2))

[array([[0,1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]]), array([[12, 13, 14, 15]])]

>>>

# numpy.vsplit(ary, indices_or_sections)：:将数组水平(行方向)拆分为多个子数组 → 按行拆

2.6数组简单运算

(+     -    *    /     **　mean()　min()  max()　std()　var()　sum()  sort() ,   axis=0按列/axis=1按行)

>>> ar = np.arange(6).reshape(2,3)>>> print(ar)

[[01 2]

[3 4 5]]>>> print(ar + 10) #加法

[[10 11 12]

[13 14 15]]>>> print(ar * 2) #乘法

[[ 02 4]

[6 8 10]]>>> print(1 / (ar+1)) #除法

[[1. 0.5 0.33333333]

[0.25 0.2 0.16666667]]>>> print(ar ** 0.5) #幂法

[[0.1. 1.41421356]

[1.73205081 2. 2.23606798]]>>>

>>> print(ar.mean()) #求平均值2.5

>>> print(ar.max()) #求最大值5

>>> print(ar.min()) #求最小值

0>>> print(ar.std()) #求标准差1.707825127659933

>>> print(ar.var()) #求方差2.9166666666666665

>>> print(ar.sum(),np.sum(ar,axis =0)) #求和 np.sum()------>> axis = 0按列求和、axis =1按行求和。15 [3 5 7]>>> print(np.sort(np.array([1,4,3,2,5,6]))) #排序

[1 2 3 4 5 6]

#常用函数

3.Numpy索引及切片

ar[2]、  ar[3][1] 、  ar[3, 1] 、  ar[1: 3] 、  ar[:2 , 1:]切片为数组中的第1、2行，第2、3、4列。

>>> ar = np.arange(20)>>> print(ar)

[ 01 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]>>> print(ar[4])4

>>> print(ar[3:6])

[3 4 5]

# 一维数组基本索引及切片>>>

>>> ar = np.arange(16).reshape(4,4)>>>print(ar,'数组轴数为%i'%ar.ndim) #4*4的数组

[[ 01 2 3]

[ 4 5 6 7]

[ 8 9 10 11]

[12 13 14 15]] 数组轴数为2>>> print(ar[2], '数组轴数为%i'%ar[2].ndim) #切片为下一个维度的一个元素，所以为一维数组。

[8 9 10 11] 数组轴数为1>>> print(ar[2][1]) #二次索引，得到一维数组中的一个值；9

>>> print(ar[1:3], '数组轴数为%i'%ar[1:3].ndim) #切片为2个一维数组组成的二维数组；

[[4 5 6 7]

[8 9 10 11]] 数组轴数为2>>> print(ar[2,2]) #切片为数组中的第3行第3列；10

>>> print(ar[:2 , 1:]) #切片为数组中的第1、2行，第2、3、4列；二维数组

[[1 2 3]

[5 6 7]]>>>

# 二维数组索引及切片

>>> ar = np.arange(8).reshape(2,2,2)>>> print(ar, '数组轴数为%i'%ar.ndim) #2*2*2的数组；

[[[01]

[2 3]]

[[4 5]

[6 7]]] 数组轴数为3>>> print(ar[0], '数组轴数为%i'%ar[0].ndim) #三维数组的下一个维度的第一个元素 ----->> 一个二维数组；

[[01]

[2 3]] 数组轴数为2>>> print(ar[0][0], '数组轴数为%i'%ar[0][0].ndim) #三维数组的下一个维度的第一个元素下的第一个元素 ------>> 一个一维数组

[01] 数组轴数为1>>> print(ar[0][0][1], '数组轴数为%i'%ar[0][0][1].ndim)1数组轴数为0>>>

# **三维数组索引及切片

布尔型索引及切片

用布尔型矩阵进行筛选  、用判断矩阵做筛选

>>> ar = np.arange(12).reshape(3,4)>>> i =np.array([True,False,True])>>> j =np.array([True,True,False,False])>>> print(ar,'\n',i,'\n',j)

[[ 01 2 3]

[ 4 5 6 7]

[ 8 9 10 11]] [ True False True][ True True False False]>>>print(ar[i,:]) #在第一维度做判断，只保留True，这里第一维度是指行，ar[i,:]等同于ar[i](简单书写格式)；索引[i,:] i代表行索引，：代表列索引全部都有[[ 01 2 3]

[8 9 10 11]]>>> print(ar[:,j]) #在第二维度即按列去做判断，这里ar[:,j]就不等同于ar[j]了 。

[[01]

[4 5]

[8 9]]>>>

#布尔型索引：以布尔型的矩阵去做筛选

>>> m = ar > 5

>>> print(m) #这里m是一个判断矩阵；

[[False False False False]

[False False True True]

[ True True True True]]>>> print(ar[m]) #用m判断矩阵去筛选ar数组中>5的元素 ------------->>>后边pandas判断方式的原理就在此。

[6 7 8 9 10 11]

数组索引及切片的值更改、复制

>>> ar = np.arange(10)>>> print(ar)

[01 2 3 4 5 6 7 8 9]>>> ar[5] = 100

>>> ar[7:9] = 200

>>> print(ar)

[ 01 2 3 4 100 6 200 200 9]>>>

##一个标量赋值给一个索引/切片时，会自动改变/传播原始数组

>>> ar = np.arange(10)>>> b =ar.copy()>>> b[7:9] = 200

>>> print(ar)

[01 2 3 4 5 6 7 8 9]>>> print(b)

[ 01 2 3 4 5 6 200 200 9]>>>

#复制

4、Numpy随机数

随机数生成

####生成一个标准正太分布的4*4样本值

>>> samples = np.random.normal(size=(4,4))#random.normal就表示正态分布>>> print(samples)

[[0.07060943 -1.25339552 0.29914172 -0.5340139]

[-0.48759624 -0.59666746 -0.11825987 0.04588257]

[-0.43502379 -0.29065528 0.17958867 -1.61939862]

[0.06733506 0.11634428 0.05324929 -0.46936231]]

numpy.random.rand(d0, d1, ..., dn)：生成一个[0,1)之间的随机浮点数或N维浮点数组 —— 均匀分布

以给定的形状创建一个数组，并在数组中加入在[0,1]之间均匀分布的随机样本。

>>> a =np.random.rand()>>> print(a,type(a)) #生成一个随机浮点数0.34655619552666683

>>>

>>> b = np.random.rand(4)>>> print(b,type(b)) #生成形状为4的一维数组

[0.97735994 0.20438528 0.5741046 0.6604635 ]

>>> c = np.random.rand(2,3)>>> print(c,type(c)) #生成形状为2*3的二维数组，注意这里不是((2,3))

[[0.75476081 0.30673306 0.94664526]

[0.4011794 0.91558286 0.09614256]]

>>>

#####在Jupyter里边运行

samples1 = np.random.rand(500)

samples2= np.random.rand(500)importmatplotlib.pyplot as plt%matplotlib inline# 生成500个均匀分布的样本值

numpy.random.randn(d0, d1, ..., dn)：生成一个浮点数或N维浮点数组 —— 正态分布；

以给定的形状创建一个数组，数组元素来符合标准正态分布N(0,1) ；若要获得一般正态分布

则可用sigma * np.random.randn(…) + mu进行表示

samples1 = np.random.randn(500)

samples2= np.random.randn(500)importmatplotlib.pyplot as plt%matplotlib inline

plt.scatter(samples1,samples2)#randn和rand的参数用法一样#生成1000个正太的样本值

numpy.random.randint(low, high=None, size=None, dtype='l')：生成一个整数或N维整数数组

#若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数，且high必须大于low#dtype参数：只能是int类型

>>> print(np.random.randint(2)) ## low=2：生成1个[0,2)之间随机整数

0>>> print(np.random.randint(2,size = 5)) #low=2,size=5 ：生成5个[0,2)之间随机整数

[1 10 0 0]>>> print(np.random.randint(2,6,size=5)) #low=2,high=6,size=5：生成5个[2,6)之间随机整数

[2 4 2 5 4]>>> print(np.random.randint(2,size=(2,3))) #low=2,size=(2,3)：生成一个2x3整数数组,取数范围：[0,2)随机整数

[[0 1 1]

[10 0]]>>> print(np.random.randint(2,6,(2,3))) #low=2,high=6,size=(2,3)：生成一个2*3整数数组,取值范围：[2,6)随机整数

[[5 3 3]

[3 2 2]]

5.Numpy数据的输入输出

存储数组数据 .npy文件

importos

os.chdir(r'C:\Users\Administrator\Desktop')

ar= np.random.rand(5,5)print(ar)#np.save('arraydata.npy',ar)

np.save(r'C:\Users\Administrator\Desktop\arraydata.npy',ar)print('finish')

打印：

[[0.26757585 0.29147944 0.64875451 0.93792551 0.94136359]

[0.26270971 0.11359578 0.40340343 0.43775798 0.00448808]

[0.77723808 0.67647676 0.01720309 0.1811023 0.5937187]

[0.64925335 0.76782983 0.07480746 0.54560242 0.34152663]

[0.77761772 0.67317061 0.61600948 0.58411754 0.61670874]]

finish

读取数组数据 .npy文件

ar_load = np.load('arraydata.npy')print(ar_load)

#np.load(r'C:\Users\Administrator\Desktop\arraydata.npy') ##也可以直接打开

[[0.26757585 0.29147944 0.64875451 0.93792551 0.94136359]

[0.26270971 0.11359578 0.40340343 0.43775798 0.00448808]

[0.77723808 0.67647676 0.01720309 0.1811023 0.5937187]

[0.64925335 0.76782983 0.07480746 0.54560242 0.34152663]

[0.77761772 0.67317061 0.61600948 0.58411754 0.61670874]]

# 存储/读取文本文件

ar = np.random.rand(5,5)

np.savetxt('array.txt',ar,delimiter=',')#np.savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ')：存储为文本txt文件

ar_loadtxt = np.loadtxt('array.txt',delimiter=',') ##delimiter=','是以，进行分隔print(ar_loadtxt)#也可以直接 np.loadtxt(r'C:\Users\Administrator\Desktop\array.txt')

[[0.85083698 0.67495645 0.95420959 0.29894536 0.85662616]

[0.2238608 0.31017771 0.58716182 0.48031634 0.65689202]

[0.79469571 0.32661995 0.99651714 0.1758829 0.01264854]

[0.75023541 0.10395296 0.69800992 0.23672871 0.00297461]

[0.828437 0.67540604 0.92137268 0.652755 0.23985235]]