Operatorverwendung des Operatormoduls in Python

Das Operatormodul ist die integrierte Operatorfunktionsschnittstelle in Python. Es definiert einige Funktionen für integrierte Arithmetik- und Vergleichsoperationen. Das Operatormodul ist in C implementiert, sodass die Ausführungsgeschwindigkeit schneller ist als bei Python-Code.

Logische Operation

from operator import *

a = [1, 2, 3]
b = a
print 'a =', a
print 'b =', b
print 

print 'not_(a)   :', not_(a)
print 'truth(a)   :', truth(a)
print 'is_(a, b)  :', is_(a, b)
print 'is_not(a, b) :', is_not(a, b)

Ergebnis drucken:

a = [1, 2, 3]
b = [1, 2, 3]
not_(a)   : False
truth(a)  : True
is_(a, b)  : True
is_not(a, b): False

Anhand der Ergebnisse können Sie erkennen, dass einige der Bedienfunktionen des Bedieners mit den ursprünglichen Vorgängen identisch sind.

Vergleichsoperator
Der Operator bietet umfangreiche Vergleichsoperationen.

a = 3
b = 5
print 'a =', a
print 'b =', b
print 

for func in (lt, le, eq, ne, ge, gt):
  print '{0}(a, b):'.format(func.__name__), func(a, b)

Ergebnisse drucken

a = 3
b = 5

lt(a, b): True
le(a, b): True
eq(a, b): False
ne(a, b): True
ge(a, b): False
gt(a, b): False

Diese Funktionen entsprechen < Ausdruckssyntax für ;, e3f4476ef81ef6b65e9e656b21faf973= und >.

Arithmetische Operatoren
Arithmetische Operatoren für die Arbeit mit Zahlen werden ebenfalls unterstützt.

a, b, c, d = -1, 2, -3, 4

print 'a =', a
print 'b =', b
print 'c =', c
print 'd =', d
 
print '\nPositive/Negative:'
print 'abs(a):', abs(a)
print 'neg(a):', neg(a)
print 'neg(b):', neg(b)
print 'pos(a):', pos(a)
print 'pos(b):', pos(b)

Ergebnisse drucken

a = -1
b = 2
c = -3
d = 4

Positive/Negative:
abs(a): 1
neg(a): 1
neg(b): -2
pos(a): -1
pos(b): 2

abs-Rückgabewert Absoluter Wert, neg gibt (-obj) zurück, pos gibt (+obj) zurück.

a = -2
b = 5.0

print 'a =', a
print 'b =', b
 
print '\nArithmetic'
print 'add(a, b)    :', add(a, b)
print 'p(a, b)    :', p(a, b)
print 'floorp(a, b)  :', floorp(a, b)
print 'mod(a, b)    :', mod(a, b)
print 'mul(a, b)    :', mul(a, b)
print 'pow(a, b)    :', pow(a, b)
print 'sub(a, b)    :', sub(a, b)
print 'truep(a, b)  :', truep(a, b)

Ergebnis drucken

a = -2
b = 5.0

Arithmetic
add(a, b)    : 3.0
p(a, b)    : -0.4
floorp(a, b)  : -1.0
mod(a, b)    : 3.0 # 查看负数取模
mul(a, b)    : -10.0
pow(a, b)    : -32.0
sub(a, b)    : -7.0
truep(a, b)  : -0.4

mod bedeutet Einnahmemodul, mul bedeutet Multiplikation, pow ist die Potenz, sub bedeutet Subtraktion

a = 2
b = 6

print 'a =', a
print 'b =', b

print '\nBitwise:'
print 'and_(a, b)  :', and_(a, b)
print 'invert(a)  :', invert(a)
print 'lshift(a, b) :', lshift(a, b)
print 'or_(a, b)  :', or_(a, b)
print 'rshift(a, b) :', rshift(a, b)
print 'xor(a, b)  :', xor(a, b)

Ergebnis drucken

a = 2
b = 6

Bitwise:
and_(a, b)  : 2
invert(a)  : -3
lshift(a, b) : 128
or_(a, b)  : 6
rshift(a, b) : 0
xor(a, b)  : 4

und bedeutet bitweises UND, invertieren bedeutet Negationsoperation, lshift bedeutet Linksverschiebung oder bitweises ODER, rshift bedeutet Rechtsverschiebung und xor bedeutet bitweises XOR.

In-Place-Operator
ist eine In-Place-Operation, x += y entspricht x = iadd(x, y), wenn sie in andere Variablen kopiert wird wie z = iadd(x, y) ist äquivalent zu z = x; z += y.

a = 3
b = 4
c = [1, 2]
d = ['a', 'b']

print 'a =', a
print 'b =', b
print 'c =', c
print 'd =', d
print

a = iadd(a, b)
print 'a = iadd(a, b) =>', a
print

c = iconcat(c, d)
print 'c = iconcat(c, d) =>', c

Methoden für Attribute und Elemente abrufen
Eine der speziellsten Funktionen des Operatormoduls ist das Konzept von Get-Methoden sind einige zur Laufzeit erstellte Callback-Objekte, die zum Abrufen der Eigenschaften des Objekts oder des Inhalts der Sequenz verwendet werden. Get-Methoden sind besonders nützlich, wenn sie mit Iteratoren oder Generatorsequenzen arbeiten von Lambda- oder Python-Funktionen.

from operator import *
class MyObj(object):
  def __init__(self, arg):
    super(MyObj, self).__init__()
    self.arg = arg
  def __repr__(self):
    return 'MyObj(%s)' % self.arg

objs = [MyObj(i) for i in xrange(5)]
print "Object:", objs

g = attrgetter("arg")
vals = [g(i) for i in objs]
print "arg values:", vals

objs.reverse()
print "reversed:", objs
print "sorted:", sorted(objs, key=g)

Ergebnis:

Object: [MyObj(0), MyObj(1), MyObj(2), MyObj(3), MyObj(4)]
arg values: [0, 1, 2, 3, 4]
reversed: [MyObj(4), MyObj(3), MyObj(2), MyObj(1), MyObj(0)]
sorted: [MyObj(0), MyObj(1), MyObj(2), MyObj(3), MyObj(4)]

Attributerfassungsmethode Ähnlich wie

lambda x, n='attrname':getattr(x,nz）

Die Elementerfassungsmethode ähnelt

lambda x,y=5:x[y]

from operator import *

l = [dict(val=-1*i) for i in xrange(4)]
print "dictionaries:", l
g = itemgetter("val")
vals = [g(i) for i in l]
print "values: ", vals
print "sorted:", sorted(l, key=g)

l = [(i,i*-2) for i in xrange(4)]
print "tuples: ", l
g = itemgetter(1)
vals = [g(i) for i in l]
print "values:", vals
print "sorted:", sorted(l, key=g)

Die Ergebnisse sind wie folgt:

dictionaries: [{'val': 0}, {'val': -1}, {'val': -2}, {'val': -3}]
values: [0, -1, -2, -3]
sorted: [{'val': -3}, {'val': -2}, {'val': -1}, {'val': 0}]
tuples: [(0, 0), (1, -2), (2, -4), (3, -6)]
values: [0, -2, -4, -6]
sorted: [(3, -6), (2, -4), (1, -2), (0, 0)]

Zusätzlich zu Sequenzen , Elementerfassungsmethoden Gilt auch für die Zuordnung.

Operatoren und benutzerdefinierte Klassen kombinieren
Funktionen im Operatormodul erledigen ihre Arbeit über die Standard-Python-Schnittstelle für die entsprechende Operation, sodass sie nicht nur mit integrierten Typen arbeiten, sondern auch auch mit benutzerdefinierten Typen.

from operator import *

class MyObj(object):
  def __init__(self, val):
    super(MyObj, self).__init__()
    self.val = val
    return 

  def __str__(self):
    return "MyObj(%s)" % self.val

  def __lt__(self, other):
    return self.val < other.val

  def __add__(self, other):
    return MyObj(self.val + other.val)

a = MyObj(1)
b = MyObj(2)

print lt(a, b)
print add(a,b)

Das Ergebnis ist wie folgt:

True
MyObj(3)

Das Operatormodul Typprüfung
enthält auch Funktionen zum Testen der API-Kompatibilität von Karten-, numerischen und Sequenztypen.

from operator import *

class NoType(object):
  pass

class MultiType(object):
  def __len__(self):
    return 0

  def __getitem__(self, name):
    return "mapping"

  def __int__(self):
    return 0

o = NoType()
t = MultiType()

for func in [isMappingType, isNumberType, isSequenceType]:
  print "%s(o):" % func.__name__, func(o)
  print "%s(t):" % func.__name__, func(t)

Die Ergebnisse sind wie folgt:

isMappingType(o): False
isMappingType(t): True
isNumberType(o): False
isNumberType(t): True
isSequenceType(o): False
isSequenceType(t): True

Aber diese Tests sind nicht perfekt, weil Ausreden nicht streng definiert sind.

Objektmethode abrufen
Verwenden Sie methodcaller, um die Methode des Objekts abzurufen.

from operator import methodcaller

class Student(object):
  def __init__(self, name):
    self.name = name

  def getName(self):
    return self.name

stu = Student("Jim")
func = methodcaller('getName')
print func(stu)  # 输出Jim

Sie können der Methode auch Parameter übergeben:

f=methodcaller('name', 'foo', bar=1)
f(b)  # return  b.name('foo', bar=1)
methodcaller方法等价于下面这个函数：

def methodcaller(name, *args, **kwargs):
   def caller(obj):
      return getattr(obj, name)(*args, **kwargs)
   return caller

Weitere Artikel zur Verwendung von Operatoren im Operatormodul in Python finden Sie auf der chinesischen PHP-Website!