Utilisation par l'opérateur du module opérateur en Python

Le module opérateur est l'interface de fonction d'opérateur intégrée en python. Il définit certaines fonctions pour les opérations intégrées d'arithmétique et de comparaison. Le module opérateur est implémenté en C, la vitesse d'exécution est donc plus rapide que le code Python.

Opération logique

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)

Résultat d'impression :

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

Vous pouvez savoir à partir des résultats que certaines des fonctions opérationnelles de l'opérateur sont les mêmes que les opérations d'origine.

Opérateur de comparaison
opérateur fournit des opérations de comparaison riches.

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)

Imprimer les résultats

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

Ces fonctions sont équivalentes à < Syntaxe d'expression pour ;, <=, ==, >= et >.

Opérateurs arithmétiques
Les opérateurs arithmétiques permettant de travailler avec des nombres sont également pris en charge.

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)

Imprimer les résultats

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

valeur de retour des abdominaux Valeur absolue, neg renvoie (-obj), pos renvoie (obj).

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)

Imprimer le résultat

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 signifie prendre le module, mul signifie multiplication, pow est la puissance, sub signifie soustraction

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)

Imprimer le résultat

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

et signifie AND au niveau du bit, invert signifie opération de négation, lshift signifie décalage à gauche, ou signifie OR au niveau du bit, rshift signifie décalage à droite et xor signifie XOR au niveau du bit.

L'opérateur sur place
est une opération sur place, x = y est équivalent à x = iadd(x, y), s'il est copié dans d'autres variables telles que car z = iadd(x, y) est équivalent à z = x ;

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

Obtention de méthodes pour les attributs et les éléments
L'une des fonctionnalités les plus spéciales du module opérateur est le concept de méthodes d'obtention. Les méthodes Get sont des objets de rappel construits au moment de l'exécution, utilisés pour obtenir les propriétés de l'objet ou le contenu de la séquence. Les méthodes Get sont particulièrement utiles lorsqu'il s'agit d'itérateurs ou de séquences génératrices. La surcharge qu'elles introduisent réduira considérablement les performances. des fonctions lambda ou Python.

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)

Résultat :

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)]

Méthode d'acquisition d'attribut Semblable à

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

La méthode d'acquisition des éléments est similaire à

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)

Les résultats sont les suivants :

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)]

En plus des séquences , les méthodes d'acquisition d'éléments s'appliquent également au mappage.

Combinaison d'opérateurs et de classes personnalisées
Les fonctions du module opérateur effectuent leur travail via l'interface Python standard pour l'opération correspondante, de sorte qu'elles fonctionnent non seulement avec les types intégrés, mais également avec ceux définis par l'utilisateur.

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)

Le résultat est le suivant :

True
MyObj(3)

Le module opérateur de vérification de type
contient également des fonctions permettant de tester la compatibilité API des types carte, numérique et séquence.

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)

Les résultats sont les suivants :

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

Mais ces les tests ne sont pas parfaits, car les excuses ne sont pas strictement définies.

Obtenir la méthode de l'objet
Utilisez methodcaller pour obtenir la méthode de l'objet.

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

Vous pouvez également passer des paramètres à la méthode :

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

Pour plus d'articles liés à l'utilisation des opérateurs dans le module opérateur en Python, veuillez faire attention au site Web PHP chinois !