python--numpy库的讲解1

1、NumPy Ndarray 对象
例如：

import numpy as np
a=np.array([1,2,3,4,5,6])
print(a)

2、Numpy数组属性
ndarray.ndim：

import numpy as np
a=np.array([[1,2,3],[4,5,6]])
#ndarray.ndim表示输出数组的维度，比如是二维还是三维
print(a.ndim)
#注意两个中括号才表示二维维度，如下例子，一个中括号表示一维，两个中括号表示二维
w0=np.array([1,2])
print(w0)
w1=np.array([1,2],ndmin=2)
print(w1)

2
[1 2]
[[1 2]]

ndarray.shape：表示输出数组的行列特征（维度），
若想改变数组的维度，直接在后面改成你想要 的维度大小。

a=np.array([[1,2,3],[4,5,6]])
print(a.shape)

结果表示二行三列

(2, 3)

例2：改变数组维度大小

import numpy as np
a=np.array([[1,2,3],[4,5,6]])
a.shape=(3,2)
print(a)

结果如下：

[[1 2]
 [3 4]
 [5 6]]

另外一种表达方法，引入reshape，不过注意，这个返回的是非拷贝副本，即改变返回后数组的元素，原数组对应元素的值也会改变
例3：结果跟例2一样

import numpy as np
a=np.array([[1,2,3],[4,5,6]])
print(a.reshape(3,2))

ndarray.itemsize
补充知识点，一般默认下整数类型，类似于c语言中的int32，int64，
所以这个属性就表示数组中的每一个元素的大小是多少

#如果我后面不加类型的话，默认是int32,32/8=4个字节
a=np.array([[1,2,3],[4,5,6]])
print(a.itemsize)

#改变数组类型，8/8=1个字节
b=np.array([[1,2,3],[4,5,6]],dtype=np.int8)
print(b.itemsize)

结果如下：

4
1

ndarray.size
返回数组元素的总个数，相当于shape里面的NM(n行m列）
ndarray.dtype
返回对象的元素类型

a=np.array([[1,2,3],[4,5,6]])
print(a.size)
print(a.dtype)

6
int32

除了利用ndarray创建数组外，也可以通过以下方式来创造你想要的数组
1>numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：
2>numpy.zeros 创建指定大小的数组，数组元素以 0 来填充：
3>numpy.ones 创建指定形状的数组，数组元素以 1 来填充：

#1、numpy.empty
a=np.empty((2,3),dtype=float)
print(a)

#2、numpy.zeros,这个默认是浮点数，所以如果需要整型，要加int
b=np.zeros((2,3),dtype=int)
print(b)

b1=np.zeros(2,dtype=int)
print(b1)

#3、创建指定形状的数组，以1来填充,默认是浮点类型，所以要想改成整型，需要自己填充
c=np.ones((2,3))
print(c)

结果如下;

[[6.23042070e-307 1.69118108e-306 6.23060065e-307]
 [8.45593934e-307 7.56593017e-307 1.11261027e-306]]
[[0 0 0]
 [0 0 0]]
[0 0]
[[1. 1. 1.]
 [1. 1. 1.]]

3、从已有的数组创建数组

#1、将列表转换成数组
r=[1,2,3]
t=np.asarray(r)
print(t)
#2、将元组转换成数组
r1=(1,2,3)
print(np.asarray(r1))
#3、以数据流的方式转换成数组对象
s = b'hello world'
a=np.frombuffer(s, dtype='S1',offset=1)
print(a)
#4、从可迭代对象中建立nparray对象，返回一维数组
x=np.fromiter(r1,dtype=float)
print(x)

结果如下：

[1 2 3]
[1 2 3]
[b'e' b'l' b'l' b'o' b' ' b'w' b'o' b'r' b'l' b'd']
[1. 2. 3.]

注意以数据流的形式转换时，dtype的类型要对应。

引入可迭代对象：可迭代对象就是存储了元素的一个容器对象。
常见的可迭代对象包括：
a)集合数据类型，如list，tuple,dict set,str等
b)生成器（generator），包括生成器和带yield的生成器函数（generator function）
如何判断一个对象是可迭代对象呢？
例：

from collections import Iterable
print(isinstance(r,Iterable))

结果如下：

True

4、从数值范围到创建数组

numpy.arange
格式 numpy.arange(start, stop,step,dtype)
start：起始值，默认为0
stop：终止值，不包含
step：步长，默认为1
dtype：如果没有提供，则会使用输入数据的类型
例：

import numpy as np
a=np.arange(6)#生成0到5的数组
b=np.arange(6,dtype=float)#设置返回类型float
c=np.arange(10,20,2)#设置起始位置，终止值以及步长
print(a)
print(b)
print(c)

结果如下：

[0 1 2 3 4 5]
[0. 1. 2. 3. 4. 5.]
[10 12 14 16 18]

numpy.linspace
函数用于创建一个一维数组，数组是一个等差数列构成的

import numpy as np
s0=np.linspace(10,20,5)#设置起始点为10，终止点为20，数列个数为5的数列
s1=np.linspace(1,2,5,retstep=True,endpoint=False,dtype=int)#输出元素全是1的等差序列，不包含终止值
print(s0)
print(s1)

结果如下：

[10.  12.5 15.  17.5 20. ]
(array([1, 1, 1, 1, 1]), 0.2)

numpy.logspace
创建一个于等比数列

import numpy as np
s0=np.logspace(0,9,10,base=2)
s1=np.logspace(1,2,5,endpoint=False,dtype=int)
print(s0)
print(s1)

结果如下：

[  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]
[10 15 25 39 63]

其中base参数意思是取对数的时候log的下标
5、numpy切片与索引

import numpy as np
a=np.arange(10)
print(a)
#切片操作,起始值为2，终止值为8，但不包括8，步长为2
s=slice(2,8,2)
print(a[s])
#索引，直接通过数组的下标进行访问
b1=a[2]   #冒号的解释：如果只放置一个参数，只返回与该索引相对应的单个元素,
b2=a[2:]  #多一个冒号表示取2后面所有的元素
b3=a[2:8] #如果放置两个参数，返回两个索引之间的项
b4=a[2:8:2]
print('*******进行索引操作********')
print(b1)
print(b2)
print(b3)
print(b4)

结果如下;

[0 1 2 3 4 5 6 7 8 9]
[2 4 6]
*******进行索引操作********
2
[2 3 4 5 6 7 8 9]
[2 3 4 5 6 7]
[2 4 6]

对于多维数组来说：输出以行列分割，拿二维举例，冒号不仅仅代表的一个元素，而是行与列的起始值与终止值

#对于多维数组来说，输出以行列分割
b=np.arange(25).reshape(5,5)
print(b)
print("----------")
print(b[1:])#第一行所有之前的元素
print("-----2---------")
print(b[:1])#表述输出第0行到第一行，但不包括第1行
print("-----3---------")
print(b[1:3,2:5])#表示第一行到第三行，但不包括三行，第二列到第五列，但不包括第五列

结果如下：

[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]]
----------
[[ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]]
-----2---------
[[0 1 2 3 4]]
-----3---------
[[ 7  8  9]
 [12 13 14]]

三维数组来说：

b=np.arange(27).reshape(3,3,3)
print(b)
print("--------1-------")
print(b[1:])  #第一个维度以后所有的值
print(b[1:2]) #第一个维度到第二个维度的所有值，但不包含第二个维度
print("-------第二个冒号------")
print(b[1:2,:2])  #第一个维度到第二个维度，但不包括第二个维度，第0行到第二行，但不包括第二行
print("------第三个冒号-------")
print(b[1:2,:2,:2])#第一个维度到第二个维度，但不包括第二个维度---
                   #第0行到第二行，但不包括第二行，第0列到第二列，当不包括第二列

结果如下：

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

 [[ 9 10 11]
  [12 13 14]
  [15 16 17]]

 [[18 19 20]
  [21 22 23]
  [24 25 26]]]
--------1-------
[[[ 9 10 11]
  [12 13 14]
  [15 16 17]]

 [[18 19 20]
  [21 22 23]
  [24 25 26]]]
[[[ 9 10 11]
  [12 13 14]
  [15 16 17]]]
-------第二个冒号------
[[[ 9 10 11]
  [12 13 14]]]
------第三个冒号-------
[[[ 9 10]
  [12 13]]]

进程已结束,退出代码0

对于省略号来讲，就是那一行（列）的所有元素取完，再取列（行）例如：

b=np.arange(9).reshape(3,3)
print(b)
print(b[...,:2])#所有行取完，取完再从第0列到第二列，但不包括第二列

结果如下：

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

6、numpy高级索引
1、整数数组索引
我自己的理解是，逗号前面代表的是行的序号值，逗号后面的列的序号值，比如你要取三个数，三个数各自对应的有一个行列序号，逗号前面代表三个数的行序号，逗号后面代表三个数的列序号，（其中，行序号要用中括号全部括起来）如下，我们要取四个角的元素，他们的位置分别为【0,0】【0,3】、【3,0】，【3,3】的数，我们就得把它的行【0,0】括起来变成【0，0,3,3】,列同样。

b=np.arange(16).reshape(4,4)
# b = np.ones((2,2))
print(b)
#整数数组
rows = np.array([[0,0],[3,3]])
cols = np.array([[0,2],[0,2]])
# y = b[rows,cols]
y2=b[[0,0,3,3],
     [0,3,0,3]]
print(y2)

结果如下：

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

如果我们想要把这个输出矩阵变成二维的，
如下：

y2=b[[[0,0],[3,3]],
     [[0,3],[0,3]]]

应用：可以从矩阵中选择或改变元素

b=np.arange(16).reshape(4,4)
print(b)
c=[0,2,0,1]
print(b[np.arange(4),c])#表示使用c的索引从a中的每一行选择一个元素

结果如下：

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

改变元素：

b[np.arange(4),c]+=10

结果如下：

[[10  1  2  3]
 [ 4  5 16  7]
 [18  9 10 11]
 [12 23 14 15]]

2、布尔索引：采用布尔运算来获取符合指定条件下的元素的数组。
大于—例1：

x=np.arange(16).reshape(4,4)
y=x[x>5]
print(y)

结果如下：

[ 6  7  8  9 10 11 12 13 14 15]

过滤NaN-例2：

x=np.array([np.NaN,1,2,3,np.NaN])
y=x[~np.isnan(x)]
print(y)
y1=y.astype(int)#将浮点型数组转换成整数型数组
print(y1)

结果如下：

[1. 2. 3.]
[1 2 3]

3、花式索引
只讲传入多个索引数组
例：

x=np.arange(24).reshape(6,4)
#意思是先选取第1,3,5,2行，在按照第0,3,2,1排序
y=x[[1,3,5,2]][:,[0,3,2,1]]
print(x)
print('-------------------')
print(y)
print("np.ix函数相当于上面，按要求选取行，在按要求选取列")
z=x[np.ix_([1,3,5,2],[0,3,2,1])]
print(z)

结果：

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]
 [16 17 18 19]
 [20 21 22 23]]
-------------------
[[ 4  7  6  5]
 [12 15 14 13]
 [20 23 22 21]
 [ 8 11 10  9]]
[[ 4  7  6  5]
 [12 15 14 13]
 [20 23 22 21]
 [ 8 11 10  9]]

进程已结束,退出代码0