operator — Standard operators as functions

소스 코드: Lib/operator.py

---

operator 모듈은 파이썬의 내장 연산자에 해당하는 효율적인 함수 집합을 내보냅니다. 예를 들어, operator.add(x, y)는 x+y 표현식과 동등합니다. 많은 함수 이름은 특수 메서드에 사용되는 이름인데, 이중 밑줄이 없습니다. 이전 버전과의 호환성을 위해, 이들 중 많은 것은 이중 밑줄이 있는 변형을 가집니다. 이중 밑줄이 없는 변형이 명확성을 위해 선호됩니다.

함수는 객체 비교, 논리 연산, 수학 연산 및 시퀀스 연산을 수행하는 범주로 분류됩니다.

객체 비교 함수는 모든 객체에 유용하며, 이들이 지원하는 풍부한 비교(rich comparison) 연산자의 이름을 따릅니다:

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)

a와 b 사이에 “풍부한 비교(rich comparisons)”를 수행합니다. 구체적으로, lt(a, b)는 a < b와 동등하고, le(a, b)는 a <= b와 동등하고, eq(a, b)는 a == b와 동등하고, ne(a, b)는 a != b와 동등하고, gt(a, b)는 a > b와 동등하고, ge(a, b)는 a >= b와 동등합니다. 이러한 함수는 불리언 값으로 해석 할 수도 있고, 그렇지 않을 수도 있는 임의의 값을 반환 할 수 있음에 유의하십시오. 풍부한 비교에 대한 자세한 정보는 비교를 참조하십시오.

논리 연산도 일반적으로 모든 객체에 적용 할 수 있으며, 진릿값 검사, 아이덴티티 검사 및 불리언 연산을 지원합니다:

operator.not_(obj)

operator.__not__(obj)

Return the outcome of not obj. (Note that there is no __not__() method for object instances; only the interpreter core defines this operation. The result is affected by the __bool__() and __len__() methods.)

operator.truth(obj)

obj가 참이면 True를 반환하고, 그렇지 않으면 False를 반환합니다. 이것은 bool 생성자를 사용하는 것과 동등합니다.

operator.is_(a, b)

a is b를 반환합니다. 객체 아이덴티티를 검사합니다.

operator.is_not(a, b)

a is not b를 반환합니다. 객체 아이덴티티를 검사합니다.

operator.is_none(a)

Return a is None. Tests object identity.

Added in version 3.14.

operator.is_not_none(a)

Return a is not None. Tests object identity.

Added in version 3.14.

수학적 및 비트별 연산이 가장 많습니다:

operator.abs(obj)

operator.__abs__(obj)

obj의 절댓값을 반환합니다.

operator.add(a, b)

operator.__add__(a, b)

a와 b 숫자에 대해, a + b를 반환합니다.

operator.and_(a, b)

operator.__and__(a, b)

a와 b의 비트별 논리곱(and)을 반환합니다.

operator.floordiv(a, b)

operator.__floordiv__(a, b)

a // b를 반환합니다.

operator.index(a)

operator.__index__(a)

정수로 변환된 a를 반환합니다. a.__index__()와 동등합니다.

버전 3.10에서 변경: The result always has exact type int. Previously, the result could have been an instance of a subclass of int.

operator.inv(obj)

operator.invert(obj)

operator.__inv__(obj)

operator.__invert__(obj)

숫자 obj의 비트별 반전을 반환합니다. 이것은 ~obj와 동등합니다.

operator.lshift(a, b)

operator.__lshift__(a, b)

a를 b만큼 왼쪽으로 시프트 한 값을 반환합니다.

operator.mod(a, b)

operator.__mod__(a, b)

a % b를 반환합니다.

operator.mul(a, b)

operator.__mul__(a, b)

a와 b 숫자에 대해, a * b를 반환합니다.

operator.matmul(a, b)

operator.__matmul__(a, b)

a @ b를 반환합니다.

Added in version 3.5.

operator.neg(obj)

operator.__neg__(obj)

obj의 부정(-obj)을 반환합니다.

operator.or_(a, b)

operator.__or__(a, b)

a와 b의 비트별 논리합(or)을 반환합니다.

operator.pos(obj)

operator.__pos__(obj)

양의 obj(+obj)를 반환합니다.

operator.pow(a, b)

operator.__pow__(a, b)

a와 b 숫자에 대해, a ** b를 반환합니다.

operator.rshift(a, b)

operator.__rshift__(a, b)

a를 b만큼 오른쪽으로 시프트 한 값을 반환합니다.

operator.sub(a, b)

operator.__sub__(a, b)

a - b를 반환합니다.

operator.truediv(a, b)

operator.__truediv__(a, b)

a / b를 반환합니다. 여기서 2/3는 0이 아니라 .66입니다. 이것은 “실수(true)” 나누기라고 도합니다.

operator.xor(a, b)

operator.__xor__(a, b)

a와 b의 비트별 배타적 논리합을 반환합니다.

시퀀스에 적용되는 연산(일부는 매핑에도 적용됩니다)은 다음과 같습니다:

operator.concat(a, b)

operator.__concat__(a, b)

a와 b 시퀀스에 대해 a + b를 반환합니다.

operator.contains(a, b)

operator.__contains__(a, b)

b in a 검사의 결과를 반환합니다. 피연산자가 뒤집혀 있음에 유의하십시오.

operator.countOf(a, b)

a에서 b가 발생하는 횟수를 반환합니다.

operator.delitem(a, b)

operator.__delitem__(a, b)

a의 값을 인덱스 b에서 제거합니다.

operator.getitem(a, b)

operator.__getitem__(a, b)

인덱스 b에 있는 a의 값을 반환합니다.

operator.indexOf(a, b)

a에서 b가 처음으로 발견되는 인덱스를 반환합니다.

operator.setitem(a, b, c)

operator.__setitem__(a, b, c)

인덱스 b의 a의 값을 c로 설정합니다.

operator.length_hint(obj, default=0)

Return an estimated length for the object obj. First try to return its actual length, then an estimate using object.__length_hint__(), and finally return the default value.

Added in version 3.4.

The following operation works with callables:

operator.call(obj, /, *args, **kwargs)

operator.__call__(obj, /, *args, **kwargs)

Return obj(*args, **kwargs).

Added in version 3.11.

operator 모듈은 일반화된 어트리뷰트와 항목 조회를 위한 도구도 정의합니다. 이것은 map(), sorted(), itertools.groupby() 또는 함수 인자를 기대하는 다른 함수의 인자로 사용될 고속 필드 추출기를 만드는 데 유용합니다.

operator.attrgetter(attr)

operator.attrgetter(*attrs)

피연산자에서 attr을 꺼내는 콜러블 객체를 반환합니다. 둘 이상의 어트리뷰트가 요청되면, 어트리뷰트의 튜플을 반환합니다. 어트리뷰트 이름은 점을 포함할 수도 있습니다. 예를 들어:

• f = attrgetter('name') 다음에, f(b) 호출은 b.name을 반환합니다.

• f = attrgetter('name', 'date') 다음에, f(b) 호출은 (b.name, b.date)를 반환합니다.

• f = attrgetter('name.first', 'name.last') 다음에, f(b) 호출은 (b.name.first, b.name.last)를 반환합니다.

다음과 동등합니다:

def attrgetter(*items):
    if any(not isinstance(item, str) for item in items):
        raise TypeError('attribute name must be a string')
    if len(items) == 1:
        attr = items[0]
        def g(obj):
            return resolve_attr(obj, attr)
    else:
        def g(obj):
            return tuple(resolve_attr(obj, attr) for attr in items)
    return g

def resolve_attr(obj, attr):
    for name in attr.split("."):
        obj = getattr(obj, name)
    return obj

operator.itemgetter(item)

operator.itemgetter(*items)

Return a callable object that fetches item from its operand using the operand’s __getitem__() method. If multiple items are specified, returns a tuple of lookup values. For example:

• f = itemgetter(2) 다음에, f(r) 호출은 r[2]를 반환합니다.

• g = itemgetter(2, 5, 3) 다음에, g(r) 호출은 (r[2], r[5], r[3])을 반환합니다.

다음과 동등합니다:

def itemgetter(*items):
    if len(items) == 1:
        item = items[0]
        def g(obj):
            return obj[item]
    else:
        def g(obj):
            return tuple(obj[item] for item in items)
    return g

The items can be any type accepted by the operand’s __getitem__() method. Dictionaries accept any hashable value. Lists, tuples, and strings accept an index or a slice:

>>> itemgetter(1)('ABCDEFG')
'B'
>>> itemgetter(1, 3, 5)('ABCDEFG')
('B', 'D', 'F')
>>> itemgetter(slice(2, None))('ABCDEFG')
'CDEFG'
>>> soldier = dict(rank='captain', name='dotterbart')
>>> itemgetter('rank')(soldier)
'captain'

튜플 레코드에서 특정 필드를 꺼내기 위해 itemgetter()를 사용하는 예:

>>> inventory = [('apple', 3), ('banana', 2), ('pear', 5), ('orange', 1)]
>>> getcount = itemgetter(1)
>>> list(map(getcount, inventory))
[3, 2, 5, 1]
>>> sorted(inventory, key=getcount)
[('orange', 1), ('banana', 2), ('apple', 3), ('pear', 5)]

operator.methodcaller(name, /, *args, **kwargs)

피연산자에서 name 메서드를 호출하는 콜러블 객체를 반환합니다. 추가 인자 및/또는 키워드 인자가 주어지면, 해당 인자도 메서드에 제공됩니다. 예를 들어:

• f = methodcaller('name') 다음에, f(b) 호출은 b.name()을 반환합니다.

• f = methodcaller('name', 'foo', bar=1) 다음에, f(b) 호출은 b.name('foo', bar=1)을 반환합니다.

다음과 동등합니다:

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

연산자를 함수에 매핑하기

이 표는 추상 연산이 파이썬 문법의 연산자 기호와 operator 모듈의 함수로 어떻게 대응되는지를 보여줍니다.

연산	문법	함수
더하기(Addition)	a + b	add(a, b)
이어붙이기(Concatenation)	seq1 + seq2	concat(seq1, seq2)
포함 검사(Containment Test)	obj in seq	contains(seq, obj)
나누기(Division)	a / b	truediv(a, b)
나누기(Division)	a // b	floordiv(a, b)
비트별 논리곱(Bitwise And)	a & b	and_(a, b)
비트별 배타적 논리합(Bitwise Exclusive Or)	a ^ b	xor(a, b)
비트별 반전(Bitwise Inversion)	~ a	invert(a)
비트별 논리합(Bitwise Or)	a | b	or_(a, b)
거듭제곱(Exponentiation)	a ** b	pow(a, b)
아이덴티티(Identity)	a is b	is_(a, b)
아이덴티티(Identity)	a is not b	is_not(a, b)
아이덴티티(Identity)	a is None	is_none(a)
아이덴티티(Identity)	a is not None	is_not_none(a)
인덱싱된 대입(Indexed Assignment)	obj[k] = v	setitem(obj, k, v)
인덱싱된 삭제(Indexed Deletion)	del obj[k]	delitem(obj, k)
인덱싱(Indexing)	obj[k]	getitem(obj, k)
왼쪽으로 시프트(Left Shift)	a << b	lshift(a, b)
모듈로(Modulo)	a % b	mod(a, b)
곱하기(Multiplication)	a * b	mul(a, b)
행렬 곱하기(Matrix Multiplication)	a @ b	matmul(a, b)
부정 (산술)(Negation (Arithmetic))	- a	neg(a)
부정 (논리)(Negation (Logical))	not a	not_(a)
양(Positive)	+ a	pos(a)
오른쪽으로 시프트(Right Shift)	a >> b	rshift(a, b)
슬라이스 대입(Slice Assignment)	seq[i:j] = values	setitem(seq, slice(i, j), values)
슬라이스 삭제(Slice Deletion)	del seq[i:j]	delitem(seq, slice(i, j))
슬라이싱(Slicing)	seq[i:j]	getitem(seq, slice(i, j))
문자열 포매팅(String Formatting)	s % obj	mod(s, obj)
빼기(Subtraction)	a - b	sub(a, b)
진릿값 검사(Truth Test)	obj	truth(obj)
대소비교(Ordering)	a < b	lt(a, b)
대소비교(Ordering)	a <= b	le(a, b)
동등성(Equality)	a == b	eq(a, b)
다름(Difference)	a != b	ne(a, b)
대소비교(Ordering)	a >= b	ge(a, b)
대소비교(Ordering)	a > b	gt(a, b)

제자리 연산자

많은 연산에는 “제자리(in-place)” 버전이 있습니다. 아래에 나열된 것들은 일반적인 문법보다 제자리 연산자에 대한 더 기본적인 액세스를 제공하는 함수입니다; 예를 들어, 문장 x += y는 x = operator.iadd(x, y)와 동등합니다. 또 다른 식으로는, z = operator.iadd(x, y)가 복합문 z = x; z += y와 동등하다고 말하는 것입니다.

이 예제들에서, 제자리 메서드가 호출될 때, 계산과 대입이 두 개의 분리된 단계에서 수행된다는 점에 유의하십시오. 아래 나열된 제자리 함수는 제자리 메서드를 호출하는 첫 번째 단계만 수행합니다. 두 번째 단계인 대입은 처리되지 않습니다.

문자열, 숫자 및 튜플과 같은 불변 대상의 경우, 갱신된 값이 계산되지만, 입력 변수에 다시 할당되지 않습니다:

>>> a = 'hello'
>>> iadd(a, ' world')
'hello world'
>>> a
'hello'

리스트와 딕셔너리 같은 가변 대상의 경우, 제자리 메서드가 갱신을 수행하므로, 이후 대입이 필요하지 않습니다:

>>> s = ['h', 'e', 'l', 'l', 'o']
>>> iadd(s, [' ', 'w', 'o', 'r', 'l', 'd'])
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
>>> s
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

operator.iadd(a, b)

operator.__iadd__(a, b)

a = iadd(a, b)는 a += b와 동등합니다.

operator.iand(a, b)

operator.__iand__(a, b)

a = iand(a, b)는 a &= b와 동등합니다.

operator.iconcat(a, b)

operator.__iconcat__(a, b)

a와 b 시퀀스에 대해, a = iconcat(a, b)는 a += b와 동등합니다.

operator.ifloordiv(a, b)

operator.__ifloordiv__(a, b)

a = ifloordiv(a, b)는 a //= b와 동등합니다.

operator.ilshift(a, b)

operator.__ilshift__(a, b)

a = ilshift(a, b)는 a <<= b와 동등합니다.

operator.imod(a, b)

operator.__imod__(a, b)

a = imod(a, b)는 a %= b와 동등합니다.

operator.imul(a, b)

operator.__imul__(a, b)

a = imul(a, b)는 a *= b와 동등합니다.

operator.imatmul(a, b)

operator.__imatmul__(a, b)

a = imatmul(a, b)는 a @= b와 동등합니다.

Added in version 3.5.

operator.ior(a, b)

operator.__ior__(a, b)

a = ior(a, b)는 a |= b와 동등합니다.

operator.ipow(a, b)

operator.__ipow__(a, b)

a = ipow(a, b)는 a **= b와 동등합니다.

operator.irshift(a, b)

operator.__irshift__(a, b)

a = irshift(a, b)는 a >>= b와 동등합니다.

operator.isub(a, b)

operator.__isub__(a, b)

a = isub(a, b)는 a -= b와 동등합니다.

operator.itruediv(a, b)

operator.__itruediv__(a, b)

a = itruediv(a, b)는 a /= b와 동등합니다.

operator.ixor(a, b)

operator.__ixor__(a, b)

a = ixor(a, b)는 a ^= b와 동등합니다.