类别:Python / 日期:2019-12-02 / 浏览:87 / 评论:0

1. 简介

NumPy(Numerical Python) 是 Python 言语的一个扩大程序库,支撑大批的维度数组与矩阵运算,另外也针对数组运算供应大批的数学函数库。最主要的数据构造是ndarray数组。

NumPy 平常与 SciPy(Scientific Python)和 Matplotlib(绘图库)一同运用, 这类组合普遍用于替换 MatLab。

SciPy 是一个开源的 Python 算法库和数学工具包。SciPy 包括的模块有最优化、线性代数、积分、插值、特别函数、疾速傅里叶变换、信号处置惩罚和图象处置惩罚、常微分方程求解和其他科学与工程中经常使用的盘算。

Matplotlib 是 Python 编程言语及其数值数学扩大包 NumPy 的可视化操纵界面。

2. 竖立

竖立一维数组

(1)直接竖立:np.array([1, 2, 3, 4, 5, 6])

(2)从python的list中竖立:np.array(list([1, 2, 3, 4, 5, 6]))

竖立常量值的一维数据

(1)竖立以0为常量值:np.zeros(n,dytpe=float/int)

(2)竖立以1为常量值:np.ones(n)

(3)竖立一个空数组:np.empty(4)

竖立一个元素递增的数组

(1)从0最先增进的递增数组:np.arange(8)

(2)给定区间,自定义步长:np.arange(0,1,0.2)

(3)给定区间,自定义个数:np.linspace(-1,1,50)

竖立多维数组:竖立单维数组,再添加进多维数组

# 数组的构造一定是np.array([]) 不管数组中心寄存的是多少“层”数据
# 二维数组相当于寄存的是“两层”数组罢了
arr1=np.array(list([1, 2, 3, 4, 5]))
arr2=np.array([arr1,[1,0,0,1,0]])               # 2*5的两维数组
arr3=np.array(list([[0,0,1,1,1],[1,1,1,0,0],[2,3,4,5,6]]))    # 3*5的两维数组
arrx=np.array([arr1,list([1, 2, 3, 4, 5],[1,1,1,0,0])])     # 报错
arry=np.array([list([[ 1,2,3,  7, 11],[2,3,4,5,6]]),[1, 2, 3, 4, 5]]) # 报错

相干引荐:《python视频教程》

竖立常量值的(n*m)维数据

(1)竖立以0为常量值:np.zeros((n*m),dytpe=float/int)

(2)竖立以1为常量值:np.ones((n*m))

(3)竖立一个空数组:np.empty((n*m))

竖立随机数字的数组

生成随机数种子:

(1)np.random.seed()

(2)np.random.RandomState()

生成随机数:

生成有散布规律的随机数组

(1)二项散布:np.random.binomial(n, p, size)

(2)正态散布:np.random.normal(loc, scale, size)

将csv文件转化成数组或阵列

运用 np.genfromtxt( ‘csv文件名’,delimiter = ‘文件中的支解符’ )函数将文件转化成数组

 csv_array = np.genfromtxt('sample.csv', delimiter=',')
 print(csv_array)

3. 数组的变形

生成数组/矩阵转置的函数,即行列数字交流,运用.T

a = np.array([[32, 15, 6, 9, 14], 
              [12, 10, 5, 23, 1],
              [2, 16, 13, 40, 37]])
print(a.T)
-------------------
# 效果以下
[[32 12  2]
 [15 10 16]
 [ 6  5 13]
 [ 9 23 40]
 [14  1 37]]

转变数组的外形:

(1)arr.resize(n,m) :arr.resize(n,m)函数是原地修正数组,请求:元素的个数必需一致

a=np.arange(8)
a.resize(2,4)
print(a)
---------------------------
[[0 1 2 3]
 [4 5 6 7]]

(2)arr.reshape(n,m):假如某一个维度的参数为-1,则示意元素总个数会将就另一个维度来盘算

a=np.arange(8).reshape(-1,1)
print(a)
-----------------
[[0]
 [1]
 [2]
 [3]
 [4]
 [5]
 [6]
 [7]]

将一维升至二维:np.newaxis

np.newaxis实际上是直接增添维度的意义,我们平常不会给数组增添太多维度,这里以一维增添到二维为例:

(1)增添行维度:arr[np.newaxis, :]

(2)增添列维度:arr[: , np.newaxis]

a=np.arange(8)
a             # array([0, 1, 2, 3, 4, 5, 6, 7])
a.shape           # (8,)
a[np.newaxis, :]      # array([[0, 1, 2, 3, 4, 5, 6, 7]])
a.shape           # (8,)
a[: , np.newaxis]     # array([[0],[1],[2],[3],[4],[5],[6],[7]])
a.shape           # (8,)

降维:arr.ravel()

arr.ravel()函数在降维时:默许是行序优先生成新数组(就是一行行读);假如传入参数“F”则是列序降维生成新数组

a=np.array([[1,2],[3,4]])
a.ravel()       
a.ravel('F')      
----------------------------
# 效果 array([1, 2, 3, 4])
# 效果 array([1, 3, 2, 4])

4. 盘算

对数组举行盘算操纵

(1)对元素举行加减盘算

a=np.arange(8).reshape(2,4)       # array([[0, 1, 2, 3], [4, 5, 6, 7]])
b=np.random.randint(8,size=(2,4))   # array([[1, 2, 5, 3], [4, 1, 0, 6]])
a+b
a-b
----------------------------
# a+b和a-b效果离别是:
array([[ 1,  3,  7,  6],
       [ 8,  6,  6, 13]])
array([[-1, -1, -3,  0],
       [ 0,  4,  6,  1]])

(2)乘法:平方/矩阵中元素相乘

a=np.arange(8).reshape(2,4)       # array([[0, 1, 2, 3], [4, 5, 6, 7]])
b=np.random.randint(8,size=(2,4))   # array([[1, 2, 5, 3], [4, 1, 0, 6]])
a**2
a*b
-----------------------
# a矩阵平方/a*b矩阵中元素相乘效果离别:
array([[ 0,  1,  4,  9],
       [16, 25, 36, 49]])
array([[ 0,  2, 10,  9],
       [16,  5,  0, 42]])

(3)矩阵*矩阵:

# 请求a矩阵的行要即是b矩阵的列数;且a矩阵的列即是b矩阵的行数
a=np.arange(8).reshape(2,4)       # array([[0, 1, 2, 3], [4, 5, 6, 7]])
b=np.random.randint(8,size=(4,2))   # array([[3, 0],[3, 3],[5, 6],[6, 7]])
c1 = np.dot(a,b)
c2 = a.dot(b)
----------------------
# ab矩阵相乘的效果:c1=c2 
array([[ 31,  36],
     [ 99, 100]])

(4)逻辑盘算

【注】列表是没法作为一个团体对个中的各个元素举行逻辑推断的!

# 效果返回:一个数组,个中每一个元素依据逻辑推断的布尔范例的效果
a > 3 
-----------------------------
# 效果以下:
array([[False, False, False, False],
     [ True,  True,  True,  True]])

5. 取值

猎取一维数组中的某个元素:操纵和list列表的index一样

a = np.array([5, 2, 7, 0, 11])
a[0]      # 效果为 5
a[:4]     # 效果为 从头最先到索引为4完毕
a[2:]     # 效果为 从索引为2的最先到末端
a[::2]      # 效果为 从头最先到末端,每2个取一个值

猎取多维数组的某个元素,某行或列值

a = np.array([[32, 15, 6, 9, 14], 
         [12, 10, 5, 23, 1],
         [2, 16, 13, 40, 37]])
a[2,1]     # 效果是一个元素 16
a[2][1]    # 效果是一个元素 16
a[1]      # 第2行 array([12, 10,  5, 23,  1])
a[:,2]   # 掏出悉数行,第2列 [15,10,16]
a[1:3, :]   # 掏出[1,3)行,悉数列
a[1,1:]    # array([10,  5, 23,  1])

猎取满足逻辑运算的

# 须要注重的是,我们数据举行逻辑盘算操纵获得的仍然是一个数组
# 假如我们想要的是一个过滤后的数组,就须要将"逻辑推断"传入数组中
a = np.array([[32, 15, 6, 9, 14], 
              [12, 10, 5, 23, 1],
              [2, 16, 13, 40, 37]])
a[a > 3]
a[(a > 3) | (a < 2)]  
------------------------------
# 效果离别是:
array([32, 15,  6,  9, 14, 12, 10,  5, 23, 16, 13, 40, 37])
array([32, 15,  6,  9, 14, 12, 10,  5, 23,  1, 16, 13, 40, 37])

遍历:效果是按行输出

a = np.array([[32, 15, 6, 9, 14], 
         [12, 10, 5, 23, 1],
         [2, 16, 13, 40, 37]])
for x in a:
    print(x)
--------------------
[32 15  6  9 14]
[12 10  5 23  1]
[ 2 16 13 40 37]

6. 复制/支解/兼并

复制:arr.cope()

支解:

(1)平分:np.split(arr, n, axis=0/1)(即行数或列数能够整除n时才能够)

(2)不平分:np.array_split(arr, n) 默许按行分n份

a = np.array([[32, 15, 6, 9, 14, 21], 
         [12, 10, 5, 23, 1, 10],
         [2, 16, 13, 40, 37, 8]])
              
# 能够看到a矩阵是(3*6),所以运用np.split()只能尝试行分红3份;或许列分红2/3/6份 
np.split(a,3,axis=0)  
np.split(a,3,axis=1)
np.array_split(a,2)
np.array_split(a,4,axis=1)
-------------------------------------------
[array([[32, 15,  6,  9, 14, 21]]),
 array([[12, 10,  5, 23,  1, 10]]),
 array([[ 2, 16, 13, 40, 37,  8]])]
   
[array([[32, 15],
        [12, 10],
        [ 2, 16]]), array([[ 6,  9],
        [ 5, 23],
        [13, 40]]), array([[14, 21],
        [ 1, 10],
        [37,  8]])]
        
[array([[32, 15,  6,  9, 14, 21],
        [12, 10,  5, 23,  1, 10]]), array([[ 2, 16, 13, 40, 37,  8]])]
        
[array([[32, 15],
        [12, 10],
        [ 2, 16]]), array([[ 6,  9],
        [ 5, 23],
        [13, 40]]), array([[14],
        [ 1],
        [37]]), array([[21],
        [10],
        [ 8]])]


兼并:np.concatenate((arr1,arr2,arr3), axis=0/1) 默许接在数据下面

a=np.random.rand(2,3)
b=np.random.randint(1,size=(2,3))
np.concatenate((a,b,a))         # 接在下面
np.concatenate((a,b,a),axis=1)      # 接在背面
------------------------
array([[0.95912866, 0.81396527, 0.809493  ],
       [0.4539276 , 0.24173315, 0.63931439],
       [0.        , 0.        , 0.        ],
       [0.        , 0.        , 0.        ],
       [0.95912866, 0.81396527, 0.809493  ],
       [0.4539276 , 0.24173315, 0.63931439]])
array([[0.95912866, 0.81396527, 0.809493  , 0.        , 0.        ,
        0.        , 0.95912866, 0.81396527, 0.809493  ],
       [0.4539276 , 0.24173315, 0.63931439, 0.        , 0.        ,
        0.        , 0.4539276 , 0.24173315, 0.63931439]])

以上就是Python Numpy库对数组的操纵详解的细致内容,更多请关注ki4网别的相干文章!

打赏

感谢您的赞助~

打开支付宝扫一扫,即可进行扫码打赏哦~

版权声明 : 本文未使用任何知识共享协议授权,您可以任何形式自由转载或使用。

 可能感兴趣的文章

评论区

发表评论 / 取消回复

必填

选填

选填

◎欢迎讨论,请在这里发表您的看法及观点。