Module operator de Python3

Dans Python 2.x, utilisez la fonctioncmp()pour comparer la relation de taille entre deux listes, des nombres, des chaînes, etc.

Dans Python 3.X, il n'y a plus la fonctioncmp(). Si vous devez implémenter une fonctionnalité de comparaison, vous devez importer le moduleoperator, qui convient à tout objet et inclut les méthodes suivantes :

Méthodes contenues dans le module operator

operator.lt(a, b)
operator.le(a, b)
operator.eq(a, b)
operator.ne(a, b)
operator.ge(a, b)
operator.gt(a, b)
operator.__lt__(a, b)
operator.__le__(a, b)
operator.__eq__(a, b)
operator.__ne__(a, b)
operator.__ge__(a, b)
operator.__gt__(a, b)

operator.lt(a, b)eta < bidentique à,operator.le(a, b)eta <= bidentique à,operator.eq(a, b)eta == bidentique à,operator.ne(a, b)eta != bidentique à,operator.gt(a, b)eta > béquivalent à,operator.ge(a, b)eta >= béquivalent à.

Exemple

# Importer le module operator
import operator
 
# Nombres
x = 10
y = 20

print("x:",x, ", y:",y)
print("operator.lt(x,y): ", operator.lt(x,y))
print("operator.gt(y,x): ", operator.gt(y,x))
print("operator.eq(x,x): ", operator.eq(x,x))
print("operator.ne(y,y): ", operator.ne(y,y))
print("operator.le(x,y): ", operator.le(x,y))
print("operator.ge(y,x): ", operator.ge(y,x))
print()

# Chaînes de caractères
x = "Google"
y = "Example"

print("x:",x, ", y:",y)
print("operator.lt(x,y): ", operator.lt(x,y))
print("operator.gt(y,x): ", operator.gt(y,x))
print("operator.eq(x,x): ", operator.eq(x,x))
print("operator.ne(y,y): ", operator.ne(y,y))
print("operator.le(x,y): ", operator.le(x,y))
print("operator.ge(y,x): ", operator.ge(y,x))
print()

# Vérifier la valeur de retour
print("type((operator.lt(x,y)): ", type(operator.lt(x,y)))

La sortie du code ci-dessus est :

x: 10 , y: 20
operator.lt(x,y):  True
operator.gt(y,x):  True
operator.eq(x,x):  True
operator.ne(y,y):  False
operator.le(x,y):  True
operator.ge(y,x):  True

x: Google , y: Example
operator.lt(x,y):  True
operator.gt(y,x):  True
operator.eq(x,x):  True
operator.ne(y,y):  False
operator.le(x,y):  True
operator.ge(y,x):  True

Comparer deux listes :

Exemple

# Importer le module operator
import operator

a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))

La sortie du code ci-dessus est :

operator.eq(a,b):  False
operator.eq(c,b):  True

Fonctions d'opérateur

Le module operator fournit un ensemble de fonctions très efficaces correspondant aux opérateurs intégrés de Python. Par exemple,operator.add(x, y)avec l'expressionx+yest identique.

Les types de fonctions incluent : opérations de comparaison, opérations logiques, opérations mathématiques et opérations de séquence sur des objets.

Les fonctions de comparaison d'objets s'appliquent à tous les objets, et les noms des fonctions sont nommés d'après leurs opérateurs de comparaison correspondants.

De nombreux noms de fonctions sont identiques aux noms de méthodes spéciales, mais sans doubles traits de soulignement. Pour des raisons de rétrocompatibilité, de nombreuses fonctions avec doubles traits de soulignement sont également conservées. Pour plus de clarté, il est recommandé d'utiliser des fonctions sans doubles traits de soulignement.

Exemple

# Exemple Python
# add(), sub(), mul()
 
# Importer le module operator
import operator
 
# Initialiser les variables
a = 4
 
b = 3
 
# Utiliser add() pour additionner deux valeurs
print ("résultat de l'opération add() :",end="");
print (operator.add(a, b))
 
# Utiliser sub() pour soustraire deux valeurs
print ("résultat de l'opération sub() :",end="");
print (operator.sub(a, b))
 
# Utiliser mul() pour multiplier deux valeurs
print⟦1┃"résultat de l'opération mul() :" ("mul() operation result:",end="");
print (operator.mul(a, b))

La sortie du code ci-dessus est :

add() 运算结果 :7
sub() 运算结果 :1
mul() 运算结果 :12

Opération

Syntaxe

Fonction

Addition

a + b

add(a, b)

Concaténation de chaînes

seq1 + seq2

concat(seq1, seq2)

Test d'appartenance

obj in seq

contains(seq, obj)

Division

a / b

truediv(a, b)

Division

a // b

floordiv(a, b)

ET bit à bit

a & b

and_(a, b)

OU exclusif bit à bit

a ^ b

xor(a, b)

NON bit à bit

~ a

invert(a)

OU bit à bit

a | b

or_(a, b)

Exponentiation

a ** b

pow(a, b)

Identité

a is b

is_(a, b)

Identité

a is not b

is_not(a, b)

Affectation par index

obj[k] = v

setitem(obj, k, v)

Suppression par index

del obj[k]

delitem(obj, k)

Valeur d'index

obj[k]

getitem(obj, k)

Décalage à gauche

a << b

lshift(a, b)

Modulo

a % b

mod(a, b)

Multiplication

a * b

mul(a, b)

Multiplication matricielle

a @ b

matmul(a, b)

Négation (arithmétique)

- a

neg(a)

Négation logique

not a

not_(a)

Positif

+ a

pos(a)

Décalage à droite

a >> b

rshift(a, b)

Affectation de tranche

seq[i:j] = values

setitem(seq, slice(i, j), values)

Suppression de tranche

del seq[i:j]

delitem(seq, slice(i, j))

Valeur de tranche

seq[i:j]

getitem(seq, slice(i, j))

Formatage de chaîne

s % obj

mod(s, obj)

Soustraction

a - b

sub(a, b)

Test de vérité

obj

truth(obj)

Comparaison

a < b

lt(a, b)

Comparaison

a <= b

le(a, b)

Égalité

a == b

eq(a, b)

Inégalité

a != b

ne(a, b)

Comparaison

a >= b

ge(a, b)

Comparaison

a > b

gt(a, b)
Autres extensions