Flatte（）和Ravel（）Numpy函数之间的差异-yiteyi-C++库

我们有两种类似的方法将ndarray转换为1D数组：flatte（）和拉威尔

null

import numpy as np
a = np.array( [ (1,7,3,4),(3,2,4,1) ] )
#OUTPUT:
print( a.flatten() )
# [ 1,7,3,4,3,2,4,1 ] 
print ( a.ravel() )
# [ 1,7,3,4,3,2,4,1 ]

这里出现了一个问题，为什么有两个numpy函数来执行相同的任务？

Flatte（）和Ravel（）之间的差异

a、拉威尔 : （i）仅返回原始数组的引用/视图（ii）如果修改数组，您会注意到原始数组的值也会发生变化。（iii）Ravel比Flatte（）更快，因为它不占用任何内存。（iv）Ravel是图书馆级别的功能。

a、展平 : （i）返回原始数组的副本（ii）如果修改此数组的任何值，则原始数组的值不受影响。（iii）flatte（）比ravel（）慢，因为它占用内存。（iv）展平是一种制作无阵列物体的方法。

让我们通过这个代码来检查差异

                         # Python code to differentiate                       
                         # between flatten and ravel in numpy                       
                         import                                     numpy as np                       
                                   
                         # Create a numpy array                       
                         a                                     =                                     np.array([(                                     1                                     ,                                     2                                     ,                                     3                                     ,                                     4                                     ),(                                     3                                     ,                                     1                                     ,                                     4                                     ,                                     2                                     )])                       
                                   
                         # Let's print the array a                       
                         print                                     (                                     "Original array: "                                     )                       
                         print                                     (a)                       
                                   
                         # To check the dimension of array (dimension =2)                       
                         # ( and type is numpy.ndarray )                       
                         print                                     (                                     "Dimension of array-> "                                     , (a.ndim))                       
                                   
                                   
                         print                                     (                                     "Output for RAVEL "                                     )                       
                         # Convert nd array to 1D array                       
                         b                                     =                                     a.ravel()                       
                                   
                         # Ravel only passes a view of                       
                         # original array to array 'b'                       
                         print                                     (b)                       
                         b[                                     0                                     ]                                     =                                     1000                       
                         print                                     (b)                       
                                   
                         # Note here that value of original                       
                         # array 'a' at also a[0][0] becomes 1000                       
                         print                                     (a)                       
                                   
                         # Just to check the dimension i.e. 1                       
                         # (and type is same numpy.ndarray )                       
                         print                                     (                                     "Dimension of array->"                                     ,(b.ndim))                       
                                   
                         print                                     (                                     "Output for FLATTEN "                                     )                       
                                   
                         # Convert nd array to 1D array                       
                         c                                     =                                     a.flatten()                       
                                   
                         # Flatten passes copy of                       
                         # original array to 'c'                       
                         print                                     (c)                       
                         c[                                     0                                     ]                                     =                                     0                       
                         print                                     (c)                       
                                   
                         # Note that by changing                       
                         # value of c there is no                       
                         # affect on value of original                       
                         # array 'a'                       
                         print                                     (a)                       
                                   
                         print                                     (                                     "Dimension of array-> "                                     , (c.ndim))                       

OUTPUT:
Original array:
 
[[1 2 3 4]
 [3 1 4 2]]
Dimension of array->  2

Output for RAVEL 

[1 2 3 4 3 1 4 2]
[1000    2    3    4    3    1    4    2]
[[1000    2    3    4]
 [   3    1    4    2]]
Dimension of array-> 1

Output for FLATTEN 

[1000    2    3    4    3    1    4    2]
[0 2 3 4 3 1 4 2]
[[1000    2    3    4]
 [   3    1    4    2]]
Dimension of array->  1

本文由 肖亚·乌帕尔 .

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Python