Comment utiliser le module opérateur à Python
Syntaxe et utilisation de base
La syntaxe des fonctions disponibles dans le module opérateur est assez simple. Vous appelez une fonction spécifique qui renvoie un résultat après avoir évalué les arguments qui lui sont fournis. Vous trouverez ci-dessous un exemple qui montre des calculs mathématiques effectués en utilisant diverses fonctions disponibles dans le module opérateur.
opérateur d'importationajout = opérateur.Ajouter (5, 6)
soustraction = opérateur.Sub (10, 4)
Multiplication = opérateur.Mul (3, 4)
Division = opérateur.Tredediv (6, 3)
Imprimer (addition)
imprimer (soustraction)
Impression (multiplication)
Impression (Division)
La première instruction importe le module opérateur. Suivant diverses fonctions disponibles dans le module d'opérateur comme «Add», «Sub», «Mul» et «Tredediv» sont appelés et deux numéros leur sont fournis afin que les opérations mathématiques puissent être exécutées sur eux. Après avoir exécuté l'échantillon de code ci-dessus, vous devriez obtenir la sortie suivante:
116
12
2.0
Le code ci-dessus est équivalent aux instructions suivantes dans Python:
addition = 5 + 6soustraction = 10 - 4
multiplication = 3 * 4
Division = 6/3
Imprimer (addition)
imprimer (soustraction)
Impression (multiplication)
Impression (Division)
Dans le premier exemple de code, au lieu d'utiliser des panneaux ou des symboles d'opérateur, vous appelez des fonctions pour faire les mêmes calculs. Le module opérateur comprend de nombreuses autres fonctions d'utilité de ce type. Vous trouverez ci-dessous un exemple qui fait des comparaisons entre deux nombres.
opérateur d'importationégal = opérateur.Eq (5, 6)
MOINSTHAN = OPÉRATEUR.LT (10, 4)
MoinsThanequalto = opérateur.LE (10, 10)
notequal = opérateur.NE (6, 3)
plus grandeur = opérateur.GT (5, 1)
plus grand-diveurs de l'opérateur.GE (5, 6)
Imprimer (égal)
imprimer (moins)
Imprimer (moins theaqualto)
Imprimer (notequal)
Imprimer (plus grand)
Imprimer (plus grandeurhanequalto)
Dans l'échantillon de code ci-dessus, diverses fonctions comme «EQ», «LT», «LE», «NE», «GT» et «GE» sont appelées pour déterminer l'égalité ou l'inégalité de deux nombres fournis comme arguments à ces fonctions. Après avoir exécuté l'échantillon de code ci-dessus, vous devriez obtenir la sortie suivante:
FAUXFAUX
Vrai
Vrai
Vrai
FAUX
Cet exemple de code équivaut aux instructions suivantes:
égal = 5 == 6MOINSTHAN = 10 <4
moinsthanequalto = 10 <= 10
notequal = 6 != 3
plus grandeur = 5> 1
plus grand-à-t-onlo = 5> = 6
Imprimer (égal)
imprimer (moins)
Imprimer (moins theaqualto)
Imprimer (notequal)
Imprimer (plus grand)
Imprimer (plus grandeurhanequalto)
Liste des fonctions utiles disponibles dans le module opérateur
Vous trouverez ci-dessous un tableau montrant certaines des fonctions utiles disponibles dans le module opérateur et leurs déclarations équivalentes. Ce tableau est tiré de la documentation officielle Python pour le module opérateur.
| Type de fonctionnement / calcul | Fonction appelable | Syntaxe équivalente |
|---|---|---|
| Ajout | Ajouter (a, b) | A + B |
| Enchaînement | Concat (SEQ1, SEQ2) | SEQ1 + SEQ2 |
| Test de confinement | contient (seq, obj) | obj en seq |
| Division | Tredediv (a, b) | un B |
| Division | Floordiv (A, B) | un B |
| Dans le monde et | et_ (a, b) | un B |
| Exclusivité | xor (a, b) | a ^ b |
| Inversion | Inverser (a) | ~ a |
| Bit ou | ou_ (a, b) | A | b |
| Exponentiation | Pow (A, B) | un B |
| Identité | is_ (a, b) | A est B |
| Identité | is_not (a, b) | A n'est pas B |
| Affectation indexée | setItem (obj, k, v) | obj [k] = v |
| Suppression indexée | Delitem (OBJ, K) | del obj [k] |
| Indexage | getItem (obj, k) | obj [k] |
| Décalage à gauche | LSHIFT (A, B) | un < |
| Modulo | mod (a, b) | un B |
| Multiplication | Mul (A, B) | un B |
| Multiplication matricielle | Matmul (A, B) | un B |
| Négation (arithmétique) | neg (a) | - un |
| Négation (logique) | not_ (a) | pas un |
| Positif | pos (a) | + un |
| Changement de droite | Rshift (A, B) | A >> B |
| Affectation de tranche | setItem (seq, tranche (i, j), valeurs) | seq [i: j] = valeurs |
| Délétion de tranche | Delitem (SEQ, SLICE (I, J)) | del seq [i: j] |
| Tranchage | getItem (seq, tranche (i, j)) | seq [i: j] |
| Formatage des chaînes | mod (s, obj) | S% obj |
| Soustraction | sub (a, b) | un B |
| Test de vérité | Vérité (OBJ) | obj |
| Commande | lt (a, b) | un |
| Commande | le (a, b) | un <= b |
| Égalité | eq (a, b) | a == b |
| Différence | NE (A, B) | un != b |
| Commande | ge (a, b) | a> = b |
| Commande | gt (a, b) | A> B |
Vous pouvez vous référer à ce tableau pour trouver une fonction d'opérateur appropriée adaptée à vos exigences de programmation.
Fonctions de l'opérateur Inalle
Le module opérateur comprend également un ensemble limité de fonctions qui peuvent effectuer des calculs «en place». Cela se fait en modifiant l'objet lui-même en le faisant passer comme un argument à une fonction d'opérateur. De tels noms de fonction sont préfixés avec le caractère «i». Par exemple, pour modifier un objet en place et ajouter quelque chose, vous devrez utiliser la fonction «IADD» disponible dans le module opérateur. Ces fonctions sont particulièrement utiles pour les objets mutables comme les dictionnaires Python et les listes. Vous trouverez ci-dessous un exemple de code:
opérateur d'importationa = [1, 2, 3, 4]
opérateur.IADD (A, [5, 6, 7, 8])
Imprimer (a)
Ici, la fonction «IADD» a été utilisée pour concaténer deux objets de type liste à Python. La liste qui sera modifiée sur place est fournie comme le premier argument, suivi de la liste à rejoindre. Après avoir exécuté l'échantillon de code ci-dessus, vous devriez obtenir la sortie suivante:
[1, 2, 3, 4, 5, 6, 7, 8]La liste complète des fonctions sur place disponibles dans le module opérateur peut être trouvée ici.
Utilisation de la fonction ItemGetter
Vous pouvez utiliser la fonction «ItemGetter» disponible dans le module opérateur pour choisir des éléments dans une liste. Vous trouverez ci-dessous un exemple de base:
opérateur d'importationa = ["a", "b", "c", "d"]
imprimer (opérateur.itemGetter (1, 2) (a))
print ((a [1], a [2]))
La méthode ItemGetter obtient un élément par son index et il est particulièrement utile pour ramasser plusieurs éléments en un seul coup. La deuxième instruction montre l'utilisation de la fonction d'objets où les index de deux éléments sont fournis comme arguments. La fonction ItemGetter renvoie un objet appelable, qui est ensuite appelé en lui fournissant une liste de python comme argument. Le résultat final de la deuxième et troisième déclaration est le même. Après avoir exécuté l'échantillon de code ci-dessus, vous devriez obtenir la sortie suivante:
('avant JC')('avant JC')
Les appels multiples enchaînés à la fonction ItemGetter peuvent également être écrits comme suit:
opérateur d'importationa = ["a", "b", "c", "d"]
b = opérateur.itemGetter (1, 2)
imprimer (b (a))
La fonction ItemGetter peut également être utilisée comme clé lors du tri d'une liste imbriquée contenant d'autres listes ou tuples. Voici un exemple:
opérateur d'importationa = [["a", 2], ["b", 4], ["c", 1], ["d", 5]]
un.trier (key = opérateur.itemGetter (1))
Imprimer (a)
L'argument «clé» dans la fonction de tri prend un objet appelable. Cet objet appelable est exécuté sur chaque élément de la liste avant de faire des comparaisons à des fins de tri. En fournissant la fonction Callable ItemGetter comme la clé, vous dites la fonction de tri pour ramasser un élément à l'index «1» de chaque liste imbriquée et l'utiliser à des fins de comparaison. Après avoir exécuté l'échantillon de code ci-dessus, vous devriez obtenir la sortie suivante:
[['c', 1], ['a', 2], ['b', 4], ['d', 5]]Conclusion
Le module opérateur n'apporte rien de nouveau à la table, car il utilise des symboles de l'opérateur en dessous pour effectuer des calculs. Vous pouvez très bien écrire des instructions simples en utilisant des symboles de l'opérateur. Cependant, ils sont utiles dans les scénarios où vous souhaitez effectuer des calculs par programme en appelant des fonctions, transmettre des fonctions appelant des arguments et remplacer les instructions Lambda par quelque chose de plus simple.