Ravel Python Numpy

Comme Numpy est une bibliothèque standard Python qui fonctionne avec des opérations mathématiques de haut niveau comme des tableaux et des matrices avec un calcul efficace. Il a une fonction intégrée pour manipuler les tableaux. Cet article aura une discussion approfondie sur l'une des fonctions soutenues contre Numpy qui sont appelées Numpy.Fonction Ravel ().

Il renvoie un tableau d'aplatissement contigu qui signifie qu'il modifie un réseau bidimensionnel ou un tableau multidimensionnel en un tableau unique du même type que celui du tableau d'entrée. Ayons un exemple de mise en œuvre de cette fonction Ravel () comment elle s'accompagne de différentes manières.

Tous les exemples s'exécutent dans le terminal de Spyder. Notez que nous devons importer le module Numpy pour accéder à cette fonction Ravel ().

Syntaxe de Numpy.effilochage()

La syntaxe utilisée dans Numpy.La fonction Ravel () est comme ceci:

# Numpy.ravel (z, order = "c")

Paramètre passé de Numpy.effilochage()

Principalement, il y a deux paramètres passés dans cette fonction: «z» et «ordre». Le «z» est un tableau d'entrée qui change dans un tableau d'aplatissement contigu ou dans un tableau unidimensionnel. Les éléments du tableau sont dans l'ordre spécifié par le paramètre «Order» et emballés dans un tableau unidimensionnel.

Cette commande est un paramètre facultatif qui prend trois arguments: C, F et K. Si nous définissons une commande comme C, le tableau est aplati en ligne de ligne, et par défaut, le paramètre «C» est pris. Si nous définissons «F», le tableau obtient un tableau aplati en colonne-major. D'un autre côté, il est défini dans l'ordre «K» qui appliquant le tableau dans le même ordre que les éléments se produisent en mémoire.

Exemple 1:

Dans cet exemple, nous avons un tableau à 2 dimensions en tant que tableau d'entrée ayant des valeurs différentes avec une variable attribuée avec le nom 'arr_1'. Ensuite, nous appellerons l'ARR_1.Fonction Ravel () Pour aplatir un tableau dans une autre variable 'arr_2'.

Nous pouvons avoir des valeurs de tableau d'entrée et aplatir les valeurs du tableau sur l'écran de la console via des instructions d'impression.

Importer Numpy comme NP
arr_1 = np.Array ([[0, -8, 3], [15, 2, 1]])
arr_2 = arr_1.effilochage()
print ("Affichage du tableau d'entrée: \ n", arr_1)
print ("Affichage du tableau de sortie: \ n", arr_2)

Enfin, nous avons la sortie du tableau 2D converti dans le tableau 1-D ci-dessous.

Exemple 2:

Ici, dans l'exemple, nous montrerons que la fonction Ravel () est égale à la fonction Reshape (). Tout d'abord, nous avons créé un tableau 2D à partir de la fonction du tableau NP.array () puis attribué my_arr.Ravel () à une variable 'Output_arr' qui transporte le tableau d'aplatissement; Après cela, nous avons imprimé à la fois les tableaux d'entrée et le tableau de sortie.

Enfin nous avons appliqué My_Arr.Reshape (-1) dans une variable Reshape_arr. Nous avons imprimé le tableau de rechape et le tableau de fonction Ravel ().

Importer Numpy comme NP
my_arr = np.Array ([[99, 15, 56], [7, 63, -54]])
output_arr = my_arr.effilochage()
print ("Affichage du tableau d'entrée: \ n", my_arr)
print ("Affichage du tableau d'entrée: \ n", output_arr)
rehape_arr = my_arr.Reshape (-1)
print ("Affichage du tableau de remodelage: \ n", my_arr)

Comme nous avons remodelé le tableau et aplati le tableau de la fonction Ravel (), la sortie est indiquée dans la capture d'écran ci-dessous.

Exemple 3:

Dans cet exemple particulier, nous appliquons le Numpy.Fonction Ravel () avec l'ordre «f» qui définira le tableau 2D dans un tableau 1D de colonne majore. Nous avons un tableau 2D dans une variable «F_Arr» et F_Ar.La fonction Ravel () avec l'ordre est égal à «f» dans une autre variable représentée comme F_Output qui imprimera la sortie en tant que colonne-major.

Enfin, nous avons une déclaration imprimée de F_ARR en tant que tableau d'entrée et tableau F_Output comme tableau de sortie.

Importer Numpy comme NP
F_arr = np.Array ([[11, 32, 23], [-4, 58, 88]])
F_output = f_arr.Ravel ('f')
print ("Affichage du tableau d'entrée: \ n", f_arr)
print ("Affichage du tableau de sortie: \ n", f_output)

La sortie du code ci-dessus dans le tableau de colonnes-major s'affiche ci-dessous.

Exemple 4:

Cet exemple utilise «C» comme paramètre d'ordre qui convertira le tableau 2D en un tableau 1D qui est en ligne. Nous avons créé un tableau 2D qui transporte des valeurs différentes dans sa variable «x_array».

Après cela, nous avons le X_Array.Fonction Ravel () Prenant le paramètre de commande comme «C» qui nous donnera un tableau 1D en tant que Row-Major.

Importer Numpy comme NP
x_array = np.Array ([[0, 4, 8], [1, 5, 9]])
y_array = x_array.Ravel ('C')
print ("Ceci est un tableau d'entrée: \ n", x_array)
print ("Ceci est un tableau de sortie: \ n", y_array)

En tant que paramètre de commande défini sur «C» qui nous donne un tableau de sortie dans un tableau aplati.

Exemple 5:

Dans cet exemple, prenez le paramètre de commande et définissez-le comme «K» pour savoir comment fonctionne ce paramètre de commande. Pour cela, nous devons prendre un tableau 2D et stocker la valeur du tableau dans une variable «k_array» à partir d'une fonction de tableau.

Puis appeler un k_arr.Ravel () Fonctionne et passant un jeu de commandes comme «K» comme un argument qui renverra une ligne de ligne unique à partir d'un tableau 2D. Nous pouvons voir le tableau d'entrée et résulter d'un tableau avec le jeu de commandes comme «K» via une déclaration d'impression. Nous avons imprimé les tableaux.

Importer Numpy comme NP
k_array = np.Array ([[4, 14, 44], [5, 15, 55]])
k_output = k_array.Ravel ('K')
print ("voici le tableau d'entrée: \ n", k_array)
print ("voici le tableau de sortie: \ n", k_output)

Enfin, nous avons le tableau de sortie en tant que tableau aplati. Nous avons sorti la capture d'écran ci-dessous du code ci-dessus.

Exemple 6:

Le dernier exemple est d'utiliser le remodelage avec l'échange de ses axes. Implémentons cet exemple cette fois; Nous avons réglé la plage du tableau sur une valeur 10 à partir d'un NP.appel de fonction arange (). Cela aidera dans la fonction Reshape (). Comme la fonction Reshape () remodelera le nombre de dimensions sans avoir de changement de données.

Nous avons également appelé la fonction swapaxes () qui échangera l'axe de 0 à 1, puis nous avons stocké NP.Fonction Ravel () qui prend un tableau d'entrée et le commande comme «C» en variable «p». Nous avons pris différentes variables pour définir l'ordre C, K, F comme P, Q et R. Impression de la variable qui donnera une sortie différente pour différents ensembles de commandes.

Importer Numpy comme NP
my_array = np.Arange (10).Reshape (2,5).swapaxes (0,1)
p = np.Ravel (my_array, ordonnance = 'c')
Q = np.Ravel (my_array, ordonnance = 'k')
r = np.Ravel (my_array, ordonnance = 'f')
print ("Array de sortie: \ n", my_array)
Print ("Tableau de sortie de C-Order: \ n", P)
Imprimer ("Tableau de sortie de K-Order: \ n", Q)
Imprimer ("Tableau de sortie de F_Order: \ n", R)

Nous avons une sortie différente ci-dessous sur l'écran.

Conclusion

Nous avons une discussion profonde sur tous les paramètres de commande de la fonction Ravel (). Nous avons vu comment cette fonction renvoie un tableau aplati du tableau bidimensionnel avec un exemple différent. Espérons que ces illustrations vous aideront à comprendre le concept plus parfaitement.