Python3 연산자 재부팅

# 연산자 다시 로드를 사용하여 사용자 정의 클래스에서 생성된 객체를 연산자로 조작할 수 있습니다.
역할:

사용자 정의 클래스의 실례를 내장 대상처럼 연산자 조작

간단한 프로그램 읽기

사용자 정의 대상에 새로운 규칙 부여

#### 산수 연산자 다시 로드
메서드 이름(밑줄이 표시되지 않음)
연산자 및 표현식
설명
add(self, rhs)
self + rhs
덧셈
sub(self, rhs)
self - rhs
뺄셈
mul(self, rhs)
self * rhs
곱셈
truediv(self, rhs)
self/rhs
나눗셈
floordiv(self, rhs)
self//rhs
마루
mod(self, rhs)
self % rhs
남은 것을 구하다
pow(self, rhs)
self ** rhs
멱 연산
설명: 연산자 재부팅 방법과 매개 변수는 이미 고정된 의미가 있기 때문에 원래의 연산자의 의미와 매개 변수의 의미를 바꾸는 것을 권장하지 않습니다.
밤을 하나 들다.

class MyList:
    def __init__(self, iterable=()):
        self.data = list(iterable)

    def __repr__(self):
        return 'MyList({})'.format(self.data)

    def __add__(self, rhs):
        return MyList(self.data + rhs.data)

    def __mul__(self, rhs):
        return MyList(self.data * rhs)

L1 = MyList([1, 2, 3])
L2 = MyList([4, 5, 6])

L3 = L1 + L2
print(L3)  # MyList([1, 2, 3, 4, 5, 6])

L4 = L2 + L1
print(L4)  # MyList([4, 5, 6, 1, 2, 3])

L5 = L1 * 3
print(L5)  # MyList([1, 2, 3, 1, 2, 3, 1, 2, 3])

#### 리버스 연산자의 리셋은 연산자의 왼쪽이 내장 유형인 경우, 오른쪽이 사용자 정의 유형에 대한 산수 연산자 연산을 수행하는 동안 TypeError 오류가 발생하며, 내장 유형의 코드를 수정하여 연산자 작업을 수행할 수 없기 때문에 이 경우 역연산자 작업을 사용해야 합니다.
메서드 이름(밑줄이 표시되지 않음)
연산자 및 표현식
설명
radd(self, lhs)
lhs + self
덧셈
rsub(self, lhs)
lhs - self
뺄셈
rtruediv(self, lhs)
lhs * self
나눗셈
rfloordiv(self, lhs)
lhs/self
마루
rmod(self, lhs)
lhs % self
남은 것을 구하다
rpow(self, lhs)
lhs ** self
멱 연산

class MyList:
    def __init__(self, iterable=()):
        self.data = list(iterable)

    def __repr__(self):
        return 'MyList({})'.format(self.data)

    def __mul__(self, rhs):
        print('__mul__ ')
        return MyList(self.data * rhs)

    def __rmul__(self, lhs):
        print('__rmul__ ')
        return MyList(self.data * lhs)

L1 = MyList([1, 2, 3])
L2 = MyList([4, 5, 6])

L3 = 3 * L1  #   __rmul__ 
print(L3)  # MyList([1, 2, 3, 1, 2, 3, 1, 2, 3])

L4 = L2 * 2  #   __mul__ 
print(L4)  # MyList([4, 5, 6, 4, 5, 6])

#### 복합 대입 산수 연산자의 재부팅은 x+=y를 예로 들면 이 연산자는 x.iadd(y) 방법을 우선적으로 호출합니다. 이 방법이 존재하지 않으면 x=x+y로 분해하고 x=x.add(y) 방법을 호출합니다. 존재하지 않으면 TypeError 형식의 오류 이상을 촉발합니다.
메서드 이름(밑줄이 표시되지 않음)
연산자 및 표현식
설명
iadd(self, rhs)
self += rhs
덧셈
isub(self, rhs)
self -= rhs
뺄셈
imul(self, rhs)
self *= rhs
곱셈
itruediv(self, rhs)
self/= rhs
나눗셈
ifloordiv(self, rhs)
self//= rhs
마루
imod(self, rhs)
self %= rhs
남은 것을 구하다
ipow(self, rhs)
self **= rhs
멱 연산

class MyList:
    def __init__(self, iterable=()):
        self.data = list(iterable)

    def __repr__(self):
        return 'MyList({})'.format(self.data)

    def __add__(self, rhs):
        return MyList(self.data + rhs.data)
   
    def __iadd__(self, rhs):
        print('__iadd__ ')
        self.data += rhs.data
        return self

L1 = MyList([1, 2, 3])
L2 = MyList([4, 5, 6])

L2 += L1  #   __iadd__ 
print(L2)  # MyList([1, 2, 3, 4, 5, 6])

#### 비교 연산자 다시 로드
메서드 이름(밑줄이 표시되지 않음)
연산자 및 표현식
설명
lt(self, rhs)
self < rhs
보다 작음
le(self, rhs)
self <= rhs
보다 작음
gt(self, rhs)
self > rhs
보다 크다
ge(self, rhs)
self >= rhs
보다 크거나 같음
eq(self, rhs)
self == rhs
... 과 같다
ne(self, rhs)
self != rhs
같지 않다
참고: 부울 값(True 또는 False)이 반환됩니다.

def __eq__(self, rhs):
    return self.__data == rhs.__data

s1 = OrderSet([1, 2, 3, 4])
if s1 == OrderSet([3, 4, 5]):
    print('s1 == OrderSet([3, 4, 5])')
else:
    print('s1 != OrderSet([3, 4, 5])')  

이상은 일부 코드일 뿐입니다
####비트 연산자 다시 로드
메서드 이름(밑줄이 표시되지 않음)
연산자 및 표현식
설명
and(self, rhs)
self & rhs
위치
or(self, rhs)
세로줄
비트 또는
xor(self, rhs)
self ^ rhs
위치가 다르거나
lshift(self, rhs)
self << rhs
왼쪽으로 이동
rshift(self, rhs)
self >> rhs
오른쪽으로 이동

class OrderSet:
    def __init__(self, iterable=()):
        self.__data = iterable

    def __repr__(self):
        return 'OrderSet({})'.format(self.__data)

    def __and__(self, rhs):
        r = set(self.__data) & set(rhs.__data)
        return OrderSet(list(r))

    def __or__(self, rhs):
        r = set(self.__data) | set(rhs.__data)
        return OrderSet(list(r))

    def __xor__(self, rhs):
        r = set(self.__data) ^ set(rhs.__data)
        return OrderSet(list(r))

s1 = OrderSet([1, 2, 3, 4])
s2 = OrderSet([3, 4, 5])
print(s1 & s2)  # OrderSet([3, 4])
print(s1 | s2)  # OrderSet([1, 2, 3, 4, 5])
print(s1 ^ s2)  # OrderSet([1, 2, 5])

####역방향 비트 연산자 다시 로드
메서드 이름(밑줄이 표시되지 않음)
연산자 및 표현식
설명
rand(self, lhs)
lhs & self
위치
ror(self, lhs)
lhs\self(세로)
비트 또는
rxor(self, lhs)
lhs ^ self
위치가 다르거나
rlshift(self, lhs)
lhs << self
왼쪽으로 이동
rrshift(self, lhs)
lhs >> self
오른쪽으로 이동
####복합 대입 비트 연산자 다시 로드
메서드 이름(밑줄이 표시되지 않음)
연산자 및 표현식
설명
iand(self, rhs)
self &= rhs
위치
ior(self, rhs)
self = rhs(세로)
비트 또는
ixor(self, rhs)
self ^= rhs
위치가 다르거나
ilshift(self, rhs)
self <<= rhs
왼쪽으로 이동
irshift(self, rhs)
self >>= rhs
오른쪽으로 이동
#### 일원 연산자의 재부팅
메서드 이름(밑줄이 표시되지 않음)
연산자 및 표현식
설명
neg(self)
- self
마이너스 부호
pos(self)
+ self
정호
invert(self)
~ self
반란을 일으키다

class MyList:
    def __init__(self, iterable=()):
        self.data = list(iterable)

    def __repr__(self):
        return 'MyList({})'.format(self.data)

    def __neg__(self):
        G = [-x for x in self.data]
        return MyList(G)

L1 = MyList([1, -2, 3, -4, 5])
L2 = -L1
print(L2)  # MyList([-1, 2, -3, 4, -5])

####in/not in 연산자 재로드 형식:

def __contains__(self, e):
	 

def __contains__(self, item):
	return item in self.__data

s1 = OrderSet([1, 2, 3, 4])
if 2 in s1:
    print('2 in s1  ')

#### 색인 및 슬라이스 연산자를 다시 로드하는 방법으로 사용자 정의 유형의 객체가 색인 및 슬라이스 작업을 지원할 수 있습니다.
메서드 이름(밑줄이 표시되지 않음)
연산자 및 표현식
설명
getitem(self, i)
x = self[i]
인덱스 또는 슬라이스 값
setitem(self, i, v)
self[i] = v
색인 또는 슬라이스 설정
delitem(self, i)
del self[i]
색인 또는 슬라이스 삭제

class MyList:
    def __init__(self, iterable=()):
        self.__data = list(iterable)

    def __repr__(self):
        return 'MyList({})'.format(self.__data)

    def __getitem__(self, i):
        print('i ', i)  # i  3
        return self.__data[i]

    def __setitem__(self, key, value):
        self.__data[key] = value

    def __delitem__(self, key):
        # del self.__data[key]
        self.__data.pop(key)

L1 = MyList([1, -2, 0, -4, 5])
x = L1[3]
print(x)  # 4
L1[3] = 2
print(L1)  # MyList([1, -2, 0, 2, 5])

del L1[2]
print(L1)  # MyList([1, -2, 2, 5])

print(L1[::2])  # i  slice(None, None, 2)
                    # [1, 2]

slice 구조 함수:작용:슬라이스 작업에 대한 전송 형식인 slice 객체를 작성하는 데 사용합니다.

slice(start=None, stop=None, step=None)

slice 객체의 인스턴스 속성 start 슬라이스의 시작값 기본값 None stop 슬라이스의 끝값 기본값 None step 슬라이스의 스텝 길이 기본값 None

class MyList:
    def __init__(self, iterable=()):
        self.__data = list(iterable)

    def __repr__(self):
        return 'MyList({})'.format(self.__data)

    def __getitem__(self, i):
        print('i ', i)
        if type(i) is int:
            print(' :')
        elif type(i) is slice:
            print(' :')
            print(' :', i.start)
            print(' :', i.stop)
            print(' :', i.step)
        elif type(i) is str:
            print(' ')
        return self.__data[i]

L1 = MyList([1, -2, 0, -4, 5])
print(L1[1:3:2])

결과:

i  slice(1, 3, 2)
 :
 : 1
 : 3
 : 2
[-2]

이 절이 끝나다