Python3 operator-Modul

In Python 2.x verwenden Siecmp()die Funktion, um die Größenbeziehung von zwei Listen, Zahlen, Zeichenfolgen usw. zu vergleichen.

In Python 3.X gibt escmp()die Funktion nicht mehr. Wenn Sie Vergleichsfunktionalität implementieren müssen, müssen Sieoperatordas Modul importieren, das für jedes Objekt geeignet ist und die folgenden Methoden enthält:

Im operator-Modul enthaltene Methoden

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)unda < bgleich wie,operator.le(a, b)unda <= bgleich wie,operator.eq(a, b)unda == bgleich wie,operator.ne(a, b)unda != bgleich wie,operator.gt(a, b)unda > bgleich wie,operator.ge(a, b)unda >= bgleich wie.

Beispiel

# operator-Modul importieren
import operator
 
# Zahlen
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()

# Zeichenketten
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()

# Rückgabewert prüfen
print("type((operator.lt(x,y)): ", type(operator.lt(x,y)))

Die Ausgabe des obigen Codes ist:

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

Zwei Listen vergleichen:

Beispiel

# operator-Modul importieren
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))

Die Ausgabe des obigen Codes ist:

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

Operatorfunktionen

Das operator-Modul bietet eine Reihe hocheffizienter Funktionen, die den in Python integrierten Operatoren entsprechen. Zum Beispiel istoperator.add(x, y)mit dem Ausdruckx+yidentisch.

Zu den Funktionstypen gehören: Vergleichsoperationen, logische Operationen, mathematische Operationen und Sequenzoperationen auf Objekten.

Objektvergleichsfunktionen gelten für alle Objekte, und Funktionsnamen werden nach ihren entsprechenden Vergleichsoperatoren benannt.

Viele Funktionsnamen sind dieselben wie spezielle Methodennamen, nur ohne doppelte Unterstriche. Aus Gründen der Abwärtskompatibilität bleiben auch viele Funktionen mit doppelten Unterstrichen erhalten. Zur Klarheit wird empfohlen, Funktionen ohne doppelte Unterstriche zu verwenden.

Beispiel

# Python-Beispiel
# add(), sub(), mul()
 
# operator-Modul importieren
import operator
 
# Variablen initialisieren
a = 4
 
b = 3
 
# Verwende add(), um zwei Werte zu addieren
print ("Ergebnis der add()-Operation:",end="");
print (operator.add(a, b))
 
# Verwende sub(), um zwei Werte zu subtrahieren
print ("Ergebnis der sub()-Operation:",end="");
print (operator.sub(a, b))
 
# Verwende mul(), um zwei Werte zu multiplizieren
print ("Ergebnis der mul()-Operation:",end="");
print (operator.mul(a, b))

Die Ausgabe des obigen Codes ist:

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

Aktion

Syntax

Funktion

Addition

a + b

add(a, b)

String-Verkettung

seq1 + seq2

concat(seq1, seq2)

Enthaltensein-Test

obj in seq

contains(seq, obj)

Division

a / b

truediv(a, b)

Division

a // b

floordiv(a, b)

Bitweises AND

a & b

and_(a, b)

Bitweises XOR

a ^ b

xor(a, b)

Bitweises NICHT

~ a

invert(a)

Bitweises OR

a | b

or_(a, b)

Potenzierung

a ** b

pow(a, b)

Identität

a is b

is_(a, b)

Identität

a is not b

is_not(a, b)

Indexzuweisung

obj[k] = v

setitem(obj, k, v)

Indexlöschung

del obj[k]

delitem(obj, k)

Indexwert

obj[k]

getitem(obj, k)

Linksverschiebung

a << b

lshift(a, b)

Modulo

a % b

mod(a, b)

Multiplikation

a * b

mul(a, b)

Matrixmultiplikation

a @ b

matmul(a, b)

Negation (arithmetisch)

- a

neg(a)

Logische Negation

not a

not_(a)

Positiv

+ a

pos(a)

Rechtsverschiebung

a >> b

rshift(a, b)

Slice-Zuweisung

seq[i:j] = values

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

Slice-Löschung

del seq[i:j]

delitem(seq, slice(i, j))

Slice-Wert

seq[i:j]

getitem(seq, slice(i, j))

String-Formatierung

s % obj

mod(s, obj)

Subtraktion

a - b

sub(a, b)

Wahrheitsprüfung

obj

truth(obj)

Comparison

a < b

lt(a, b)

Comparison

a <= b

le(a, b)

Gleichheit

a == b

eq(a, b)

Ungleichheit

a != b

ne(a, b)

Comparison

a >= b

ge(a, b)

Comparison

a > b

gt(a, b)
Weitere Erweiterungen