Numpy Logical_and

Comme d'autres cadres et langues, Numpy prend également en charge les opérateurs logiques et leurs opérations comme et, ou etc. Dans ce guide Numpy, nous discuterons de l'opération «logique_and» Numpy. L'opérateur Logical_and calcule la valeur de vérité de A1 et A2 Elementwise. Le NP.La méthode logical_and () est une méthode de tableau mathématique qui est utilisée pour calculer la sortie de Xi et Yi pour chaque composant XI de Array1 concernant l'élément Yi de Array2. Il nous donne la sortie sous forme de tableau. Pour le NP.Fonction Logical_and () Pour travailler, nous devons le transmettre aux tableaux d'entrée de la même forme

Syntaxe

Ceci est la syntaxe de notre méthode.

nombant.logical_and (x1, x2, out = non, où = true, dType = aucun)

Il a les paramètres suivants

x1, x2 sont les tableaux d'entrée. Ces deux doivent être de la même forme, qui seront également les mêmes que la sortie.

dehors est l'emplacement où la sortie est stockée. Nous pouvons fournir la forme manuellement sinon il alloue un nouveau tableau.

où est une condition qui est un paramètre facultatif. Si la condition est vraie, le tableau de résultat qui est le tableau extérieur sera défini sur la sortie non. Sinon, le tableau de sortie restera dans sa forme réelle en maintenant sa valeur réelle.

dtype Définit le type de tableau de sortie.

Exemple # 01:

Maintenant, nous prendrons deux tableaux avec les mêmes valeurs et certaines valeurs différentes. L'opérateur et l'opérateur renvoie vrai lorsque les deux valeurs sont les mêmes ou les deux conditions sont vraies et renvoient faux dans tous les autres cas. C'est comment fonctionne et fonctionne l'opérateur. Dans notre exemple, nous vérifierons également si notre et l'opérateur, en utilisant cette méthode, fonctionne de la même manière ou non.

Après avoir réussi à importer notre bibliothèque Numpy en NP, nous avons attribué des valeurs «1», «1», «0» et «0» à notre premier tableau, et «1», «0», «1» et «0 "À notre deuxième tableau. Nous allons effectuer l'opérateur et sur nos tableaux et nous verrons la sortie en imprimant notre tableau de sortie que nous avons initialisé par nous-mêmes comme notre troisième tableau. Nous exécuterons notre code:

Importer Numpy comme NP
arr_x = [1, 1, 0, 0]
arr_y = [1, 0, 1, 0]
arr_z = np.Logical_and (Arr_X, Arr_Y)
imprimer (ar_z)

Ce qui suit est le résultat que nous obtiendrons de notre code. Dans cette sortie, nous pouvons voir que la fonction a renvoyé la sortie comme vraie et fausse. Il n'est revenu que là où les valeurs des deux tableaux étaient les mêmes. Ainsi, par la sortie, nous pouvons conclure que les fonctions de l'opérateur logique Numpy fonctionnent de la même manière que tous les autres opérateurs et nous donnent la sortie exacte.

Exemple # 02:

Avant de passer à l'exemple suivant, soyons clairs: zéros et ceux ne sont pas seulement les valeurs utilisées pendant les opérations logiques. Dans certains cas, nous utilisons également des valeurs vraies et fausses lorsque le vrai est égal à «1» et False est égal à «0». Maintenant dans l'exemple ci-dessous, nous passerons les valeurs vraies et fausses à nos tableaux d'entrée et nous effectuerons l'opération Logical_and sur ces tableaux et stockerons le résultat dans le troisième tableau. En imprimant le troisième tableau, nous verrons si notre opérateur fonctionne sur des valeurs comme vrai et fausse ou si elle ne fonctionne que sur zéro et une valeur.

Importer Numpy comme NP
arr_a = [false, false, true, true]
arr_b = [false, true, false, true]
arr_c = np.Logical_and (Arr_A, Arr_B)
Print (Arr_C)

Importons d'abord notre bibliothèque Numpy, la raison en est que nous allons effectuer certaines opérations fournies par la bibliothèque Numpy. Dans la ligne suivante, nous déclarerons deux tableaux auxquels nous stockons les valeurs du tableau aussi vraies et fausses que nous l'expliquerons ci-dessus. Après avoir déclaré les deux tableaux qui sont «ARR_A» et «ARR_B», nous déclarerons un autre tableau qui tiendra le résultat de notre et de l'opération effectuée entre les tableaux transmis à notre logique et à notre opération. En fin de compte, nous imprimerons le tableau résultant à l'aide de l'instruction print ().

Ici, la méthode nous a retourné la sortie et c'est la sortie exacte que nous attendions. Seul vrai est retourné lorsque les deux tableaux sont vrais. C'est ainsi que l'opérateur et fonctionnent également en réalité. Ainsi, nous pouvons impliquer que cela fonctionne non seulement sur 0 et 1, mais fonctionne également sur vrai et faux.

Exemple # 03:

Après avoir travaillé sur l'opérateur Logical_and, une question se pose dans votre esprit: que se passe-t-il si nous ne transmettons pas les tableaux de la même forme à notre opérateur? Pour répondre à votre question, nous avons fait cet exemple dans lequel nous avons passé deux tableaux de formes différentes à notre fonction pour voir quelle sortie notre fonction renvoie dans ce cas. Nous avons déclaré deux tableaux, l'un avec des éléments «4» dedans et l'autre avec des éléments «5» dedans afin qu'ils n'aient pas la même forme. Nous avons stocké la sortie dans le troisième tableau et nous l'imprimerons pour vérifier la sortie. Maintenant, nous allons exécuter notre code pour vérifier ce qui se passe.

Importer Numpy comme NP
small_arr = [0, 0, 1, 1]
grande_arr = [1, 0, 1, 0, 1]
out_arr = np.logical_and (small_arr, grand_arr)
imprimer (out_arr)

Maintenant, importez d'abord la bibliothèque Numpy, puis définissez deux tableaux avec différentes tailles les nommant «small_arr» qui contient des éléments «4» et «borde_arr» qui contient des éléments «5». Ensuite, nous définirons un autre tableau qui contiendra le tableau résultant après avoir effectué la logique et l'opération. Enfin, nous imprimerons le tableau résultant à l'aide de l'instruction print ().

Malheureusement, le code nous a donné une erreur. Mais par cet exemple, nous avons appris que nous ne pouvons passer les tableaux qu'avec la même forme à notre fonction; Sinon, cela donnera une erreur. Si nous lisons la dernière ligne d'erreur, nous pouvons comprendre que le système nous dit que nous ne pouvons pas diffuser les formes 4 et 5 ensemble. Les 4 et 5 sont le nombre d'éléments que nous avons passés respectivement à nos small_arr et grand_arr.

Conclusion

Nous avons appris le Numpy NP.Méthode logical_and () dans ce guide. Nous avons discuté de la facilité avec laquelle nous pouvons effectuer des opérations logiques sur nos tableaux à l'aide du NP.Fonction Logical_and () de Numpy. Nous avons également montré comment le système se comporte lorsque nous le dépassons les tableaux de différentes formes. Nous avons appliqué le paramètre «où» à notre fonction dans ce guide qui nous aide beaucoup à comprendre le concept.