Opérations de tableau Numpy

Aujourd'hui, nous apprenons quelles opérations nous effectuons sur les tableaux Numpy et comment effectuer ces opérations. Ce tutoriel sera utile si vous connaissez déjà les bases de Python et que vous souhaitez commencer à utiliser Numpy.

Numpy est la bibliothèque avancée de la programmation Python. La principale caractéristique de Numpy est qu'il propose de travailler avec des tableaux multidimensionnels et une vitesse exceptionnelle ainsi que des capacités d'interaction avec ces tableaux.

Numpy est utilisé pour effectuer les opérations logiques et mathématiques. Nous pouvons effectuer plusieurs opérations dans des tableaux qui sont:

• Opérations arithmétiques
• Opérations logiques
• Opérations de comparaison

Opérations arithmétiques

Nous pouvons effectuer plusieurs opérations sur des tableaux Numpy où nous pouvons ajouter, soustraire, multiplier et diviser les deux tableaux; Ces opérations sont appelées opérations arithmétiques. Au moins deux tableaux sont requis pour les opérations arithmétiques, et elles doivent soit avoir la même taille, soit suivre les règles de diffusion de la table.

Syntaxe:

Voyons la syntaxe de l'opération arithmétique de la bibliothèque Python, Numpy. Ici, nous écrivons d'abord le nom de la bibliothèque que nous utilisons qui est «Numpy». Ensuite, nous appelons la fonction de l'opération arithmétique que nous voulons effectuer comme add (), sub (), mul () et div (). Et puis, nous passons les paramètres à cette fonction.

Exemple:

Passons à l'exemple des opérations arithmétiques qui ajoutent, soustrayaient, multiplient et divisent. Voyons comment implémenter ces opérations sur des tableaux Numpy. Ouvrez votre compilateur Python pour la mise en œuvre du programme arithmétique.

La toute première étape de base consiste à importer la bibliothèque de Python qui est numpy. Tout d'abord, nous écrivons le mot-clé «import» qui montre que nous allons importer la bibliothèque. Ensuite, nous écrivons le nom de la bibliothèque qui est «Numpy». Et puis, nous écrivons l'alias numpy, «NP». Dans la troisième ligne de code, nous utilisons l'instruction print () afin que nous puissions afficher le message que nous allons implémenter les opérations arithmétiques. Ensuite, dans la ligne suivante, nous appelons la fonction Numpy Arange () pour la création de Array1 et passons les arguments dedans.

Le premier argument est l'élément de départ de l'array1. Le deuxième argument est l'élément d'arrêt, mais gardez à l'esprit que nous ne pouvons pas inclure l'élément d'arrêt dans Array1. Et le troisième argument est la différence que nous devrions prendre pour obtenir le prochain élément de Array1; DTYPE signifie quel type de données voulons-nous (comme int, float, etc.) pour l'arraie1.

Dans cette ligne, nous utilisons une autre fonction en appliquant la concaténation qui est la fonction Reshape (). Cette fonction est utilisée pour façonner le tableau1. Ici, nous avons 2 rangées et 4 colonnes du tableau. Ensuite, nous créons un autre tableau qui est un tableau2 en utilisant la même fonction que nous utilisons pour Array1 mais nous n'utilisons pas la fonction Reshape () dans le tableau 2 parce que nous ne voulons pas façonner le tableau. Après la création des deux tableaux, nous imprimons le Array1 et le Array2 à l'aide de l'instruction print () et passons les tableaux dedans.

Importer Numpy comme NP
Print ("Implémentation des opérations arthimatiques: \ n")
array1 = np.arange (40, 96, 7, dtype = int).Reshape (2,4)
Print ("Le premier tableau est", Array1.ndim, "Dimensional: \ n", array1)
array2 = np.arange (5, 20, 4, dtype = int)
print ("\ nthe deuxième tableau est", array2.ndim, "Dimensional: \ n", array2)
ajouter = np.ajouter (array1, array2)
print ("\ nadding les deux tableaux: \ n", ajouter)
sub = np.soustraire (array1, array2)
print ("\ nsubtractant les deux tableaux: \ n", sub)
Mul = np.multiplier (array1, array2)
print ("\ nMultiplying les deux tableaux: \ n", Mul)
div = np.Diviser (Array1, Array2)
Print ("\ ndividing the Two Arrays: \ n", div)

Après avoir créé les deux tableaux, nous appelons les fonctions arithmétiques une par une. Tout d'abord, nous appelons la fonction ADD () pour l'ajout de Array1 et Array2. Ensuite, nous appelons la fonction Sub () afin que nous puissions soustraire Array2 de Array1. Ensuite, nous appelons la fonction Mul () pour la multiplication des deux tableaux. Enfin, nous avons la fonction div () qui divise les deux tableaux et nous obtenons le quotient. Nous imprimons ensuite toutes les fonctions à l'aide de l'instruction print () et passons les paramètres dedans.

Voici la sortie de cet exemple expliqué où nous obtenons le résultat d'opérations arithmétiques:

Opérations logiques

Maintenant, passons à la deuxième opération de la bibliothèque Numpy qui est l'opération logique. Nous utilisons l'opération logique pour obtenir la véritable valeur des tableaux Numpy comme les valeurs de vérité booléennes. Nous implémentons les opérations logiques via des fonctions Numpy qui sont des fonctions logical_and (), logical_or () et logical_not ().

Syntaxe:

Regardons le style d'écriture du fonctionnement logique de la bibliothèque Python, Numpy. Tout d'abord, nous écrivons le nom de la bibliothèque que nous utilisons dans ce programme qui est Numpy. Ensuite, nous écrivons le nom de la fonction de l'opérateur logique que nous utilisons, puis y passons les arguments.

Exemple:

Commençons à implémenter l'exemple des opérations logiques de Python-Numpy qui sont logical_and (), logical_or et logical_not.

Nous importons la bibliothèque de Python que nous utilisons dans ce programme qui est Numpy. Ensuite, nous créons le tableau aléatoire en 1 dimension à l'aide de la fonction Numpy Randn () et y passons deux paramètres. Le premier paramètre montre le nombre de lignes du tableau. Le deuxième paramètre montre le nombre de colonnes du tableau. Dans la sixième ligne de code, nous appelons l'instruction print () et passons la fonction logical_and (). Ensuite, dans la ligne suivante, nous passons la fonction logical_or () puis les fonctions logical_not ().

Importer Numpy comme NP
arr = np.aléatoire.Randn (2, 2)
print ("Le tableau aléatoire est: \ n", arr)
print ('\ n le résultat de et est: \ n', np.logical_and (arr> 0, arrond < 0.5))
print ('\ n le résultat ou est: \ n', np.logical_or (arr < 0, arr > 0.5))
print ('\ n le résultat de non est: \ n', np.logical_not (arr> 0))

Voici la sortie de l'extrait de code mentionné précédemment. Comme vous pouvez le voir, nous obtenons le tableau aléatoire à l'aide de la fonction randn () et appliquons les multiples opérations logiques:

Opérations de comparaison

Maintenant, nous avons la troisième opération de tableaux Numpy qui est l'opération de comparaison. Dans cette opération, nous comparons le tableau avec n'importe quel nombre et vérifions s'il est vrai ou faux. Nous effectuons les opérations de comparaison multiples dans des tableaux Numpy qui sont>, =, <=, =, != etc.

Syntaxe:

Voici la syntaxe des opérations de comparaison dans des tableaux Numpy:

Exemple:

Maintenant, passons à l'exemple des opérations de comparaison. Tout d'abord, nous importons la bibliothèque Python qui est Numpy. Ensuite, nous créons un tableau Numpy aléatoire en utilisant la fonction RandInt () pour créer le tableau aléatoire entier de 1 à 20. La taille du tableau est de 1 ligne et 3 colonnes. Ensuite, nous appelons la déclaration print () et passons les opérations de comparaison dedans. Les fonctions que nous effectuons dans cet exemple sont plus grandes (), greve_equal (), moins (), less_equal (), equal () et not_equal ().

Importer Numpy comme NP
arr = np.aléatoire.Randint (1, 8, taille = (1, 3))
print ("Le tableau d'entrée est: \ n", arr)
print ("\ nGreater que: \ n", np.plus grand (arr, 5))
print ("\ nGreater que ou égal à 5: \ n", np.Greater_equal (arr, 5))
print ("\ nless que 5: \ n", np.moins (arr, 5))
print ("\ nless que ou égal à 5: \ n", np.Less_equal (Arr, 5))
print ("\ nequal à 5: \ n", np.égal (arr, 5))
print ("\ nnot égal à 5: \ n", np.not_equal (arr, 5))

Voici la sortie des opérations de comparaison:

Conclusion

Dans cet article, nous avons appris quelles opérations pouvons-nous effectuer dans des tableaux Numpy, comment implémenter ces opérations dans des tableaux Numpy et quelles fonctions utilisons-nous pour implémenter ces opérations de Numpy. Nous avons implémenté des exemples de chaque opération de tableaux Numpy et utilisé les différentes fonctions pour créer le tableau dans ces exemples.