Python에서 연산자 모듈의 연산자 사용법

연산자 모듈은 Python에 내장된 연산자 함수 인터페이스로, 산술 및 비교 내장 연산을 위한 일부 함수를 정의합니다. 연산자 모듈은 C로 구현되어 있어 Python 코드보다 실행 속도가 빠릅니다.

논리연산

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)

결과 인쇄:

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

결과를 보면 연산자의 일부 연산 기능이 원래 연산과 동일하다는 것을 알 수 있습니다.

비교 연산자
연산자는 풍부한 비교 연산을 제공합니다.

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)

결과 인쇄

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

이러한 함수는 <, < =, ==, >= 및 >에 대한 표현식 구문입니다.

산술 연산자
숫자 작업을 위한 산술 연산자도 지원됩니다.

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)

결과 인쇄

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는 절대값을 반환합니다(neg). 반환(-obj), pos 반환(+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)

결과 인쇄

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는 모듈러스를 취한다는 의미, mul은 곱셈을 의미, pow 는 거듭제곱이고 sub는 뺄셈을 의미합니다

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)

결과를 인쇄

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

하고 비트 AND를 의미하고, invert는 부정 연산을 의미하고, lshift는 왼쪽 시프트 또는 비트 OR을 의미하고, rshift는 오른쪽 시프트를 의미하고, xor는 비트 XOR을 의미합니다.

내부 연산자
는 내부 연산이고, x += y는 다른 변수에 복사된 경우 x = iadd(x, y)와 동일합니다. 예를 들어 z = iadd(x, y)는 z = x += 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

속성과 요소에 대한 메소드 가져오기
연산자 모듈의 가장 특별한 기능 중 하나는 메소드 가져오기 개념입니다. , 가져오기 메소드는 런타임에 생성된 일부 콜백 객체로, 객체의 속성이나 시퀀스의 내용을 가져오는 데 사용됩니다. 획득 메소드는 반복자 또는 생성기 시퀀스를 처리할 때 특히 유용하며 오버헤드를 크게 줄여줍니다. 람다 또는 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)

결과:

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

속성 획득 방법은 다음과 유사합니다.

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

요소 획득 방법은

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)

<와 유사합니다. 🎜>

결과는 다음과 같습니다.

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

시퀀스 외에도 요소 가져오기 메소드도 매핑과 함께 작동합니다.

연산자와 사용자 정의 클래스 결합
연산자 모듈의 함수는 해당 작업에 대해 표준 Python 인터페이스를 통해 작업을 수행하므로 내장 유형으로도 작동할 뿐만 아니라 또한 사용자 정의 유형도 있습니다.

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)

결과는 다음과 같습니다.

True
MyObj(3)

입력 확인
연산자 모듈에는 매핑, 숫자 및 시퀀스 유형의 API 호환성을 테스트하는 함수도 포함되어 있습니다.

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)

결과는 다음과 같습니다.

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

그러나 이러한 테스트는 불완전합니다. 변명에 대한 엄격한 정의는 없습니다.

객체 메서드 가져오기
methodcaller를 사용하여 개체의 메서드를 가져옵니다.

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

메서드에 매개변수를 전달할 수도 있습니다:

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

Python의 연산자 모듈에서 연산자 사용과 관련된 더 많은 기사를 보려면 PHP 중국어 웹사이트를 주목하세요!