"=="와 "is"사이에 차이가 있습니까?

Question

나의 Google-Fu 저를 실패했습니다.

파이썬에서는 평등에 대한 다음 두 가지 테스트가 동등합니까?

n = 5
# Test one.
if n == 5:
    print 'Yay!'

# Test two.
if n is 5:
    print 'Yay!'

인스턴스를 비교할 객체의 경우 (A list 말하다)?

좋아, 이런 종류의 질문에 내 질문에 대답한다.

L = []
L.append(1)
if L == [1]:
    print 'Yay!'
# Holds true, but...

if L is [1]:
    print 'Yay!'
# Doesn't.

그래서 == 테스트 값은 어디에 있습니다 is 그들이 같은 대상인지 확인하기 위해 테스트합니까?

Answer 1

is 돌아올 것입니다 True 두 변수가 동일한 객체를 가리키면 == 변수가 참조하는 객체가 동일하다면

>>> a = [1, 2, 3]
>>> b = a
>>> b is a 
True
>>> b == a
True
>>> b = a[:] # Make a new copy of list `a` via the slice operator, and assign it to variable `b`
>>> b is a
False
>>> b == a
True

귀하의 경우, 두 번째 테스트는 Python이 작은 정수 객체를 캐시하기 때문에 만 작동합니다. 이는 구현 세부 사항입니다. 더 큰 정수의 경우 작동하지 않습니다.

>>> 1000 is 10**3
False
>>> 1000 == 10**3
True

문자열 리터럴에 대해서도 마찬가지입니다.

>>> "a" is "a"
True
>>> "aa" is "a" * 2
True
>>> x = "a"
>>> "aa" is x * 2
False
>>> "aa" is intern(x*2)
True

참조하십시오 이 질문 또한.

Answer 2

언제 사용 해야하는지 알려주는 간단한 경험 법칙이 있습니다. == 또는 is.

• == 입니다 가치 평등. 두 객체의 값이 같은지 알고 싶을 때 사용하십시오.
• is 입니다 참조 평등. 두 참조가 동일한 객체를 참조하는지 알고 싶을 때 사용하십시오.

일반적으로 무언가를 간단한 유형과 비교할 때 일반적으로 확인하고 있습니다. 가치 평등, 당신은 사용해야합니다 ==. 예를 들어, 예제의 의도는 X가 2와 같은 값을 가지고 있는지 확인하는 것입니다.==)), 여부가 아닙니다 x 문자 그대로 2와 동일한 대상을 참조합니다.

---

다른 주목할만한 것 : CPYTHON 참조 구현이 작동하는 방식으로 인해 실수로 사용하면 예상치 못한 결과를 얻을 수 있습니다. is 정수에 대한 참조 평등을 비교하려면 :

>>> a = 500
>>> b = 500
>>> a == b
True
>>> a is b
False

그것은 우리가 기대했던 것과 거의 같습니다. a 그리고 b 값이 동일한 값을 가지지 만 뚜렷한 엔티티입니다. 하지만 이건 어때?

>>> c = 200
>>> d = 200
>>> c == d
True
>>> c is d
True

이것은 이전 결과와 일치하지 않습니다. 여기서 무슨 일이야? 성능의 이유로 싱글 톤 인스턴스로 -5..256 범위의 Python Caches Integer Object의 기준 구현이 밝혀졌습니다. 다음은 이것을 보여주는 예입니다.

>>> for i in range(250, 260): a = i; print "%i: %s" % (i, a is int(str(i)));
... 
250: True
251: True
252: True
253: True
254: True
255: True
256: True
257: False
258: False
259: False

이것은 사용하지 말아야 할 또 다른 분명한 이유입니다 is: 동작은 가치 평등을 위해 잘못 사용하면 동작이 구현됩니다.

Answer 3

== 값이 동일한 지 여부를 결정합니다 is 그들이 똑같은 객체이고 동일인지 결정합니다.

Answer 4

차이가 있습니까? == 그리고 is 파이썬에서?

예, 그들은 매우 중요한 차이가 있습니다.

==: 평등 확인 - 의미론은 동등한 객체 (반드시 동일한 객체가 아니라)가 동일하게 테스트한다는 것입니다. 로서 문서화가 말합니다:

연산자 <,>, ==,> =, <= 및! = 두 객체의 값을 비교합니다.

is: 정체성 확인 - 의미론은 (메모리에 보관 된대로) 대상입니다. ~이다 그 물체. 다시, 문서화가 말합니다:

연산자 is 그리고 is not 객체 아이덴티티 테스트 : x is y 경우에만 사실입니다 x 그리고 y 같은 대상입니다. 객체 아이덴티티는 다음을 사용하여 결정됩니다 id() 기능. x is not y 역 진실 값을 산출합니다.

따라서 신원 검사는 객체의 ID의 동등성을 확인하는 것과 동일합니다. 그건,

a is b

와 같다:

id(a) == id(b)

어디 id "동시에 기존 객체들 사이에서 고유 한 것으로 보장 된"정수를 반환하는 내장 함수입니다 (참조 help(id)) 그리고 어디에 a 그리고 b 임의의 대상입니다.

다른 사용 방향

이 비교는 그들의 의미론에 사용해야합니다. 사용 is 신원을 확인하고 == 평등을 확인합니다.

PEP 8, 표준 라이브러리의 공식 파이썬 스타일 가이드도 언급합니다. 두 가지 사용 사례 is:

싱글 톤과 비교 None 항상 완료해야합니다 is 또는 is not, 평등 운영자는 절대 없습니다.

또한 글쓰기를 조심하십시오 if x 당신이 정말로 의미 할 때 if x is not None - 예 : 기본값이 변수 또는 인수 여부를 테스트 할 때 None다른 값으로 설정되었습니다. 다른 값에는 부울 맥락에서 거짓일 수있는 유형 (예 : 컨테이너)이있을 수 있습니다!

정체성에서 평등을 유추합니다

만약에 is 사실, 평등은 할 수 있습니다 대개 추론 - 논리적으로, 객체 자체가 자체라면, 그것은 그 자체와 동등한 것으로 테스트해야합니다.

대부분의 경우이 논리는 사실이지만 __eq__ 특별한 방법. 로서 문서 말하다,

평등 비교를위한 기본 동작 (== 그리고 !=)는 객체의 정체성을 기반으로합니다. 따라서 동일한 정체성을 가진 사례의 평등 비교는 평등을 초래하고, 다른 정체성을 가진 사례의 평등 비교는 불평등을 초래합니다. 이 기본 동작에 대한 동기는 모든 객체가 반사적이어야한다는 소망입니다 (예 : x는 x == y를 의미합니다).

일관성의 이익을 위해 다음을 권장합니다.

평등 비교는 반사적이어야합니다. 다시 말해, 동일한 객체는 동일하게 비교해야합니다.

x is y 암시합니다 x == y

우리는 이것이 사용자 정의 객체의 기본 동작임을 알 수 있습니다.

>>> class Object(object): pass
>>> obj = Object()
>>> obj2 = Object()
>>> obj == obj, obj is obj
(True, True)
>>> obj == obj2, obj is obj2
(False, False)

반대 성도는 일반적으로 사실입니다. 평등하지 않은 것으로 테스트하면 일반적으로 동일한 대상이 아니라고 추론 할 수 있습니다.

평등 테스트는 사용자 정의 될 수 있으므로이 추론은 항상 모든 유형에 맞는 것은 아닙니다.

예외

주목할만한 예외입니다 nan - 항상 그 자체와 같지 않은 것으로 테스트합니다.

>>> nan = float('nan')
>>> nan
nan
>>> nan is nan
True
>>> nan == nan           # !!!!!
False

신분을 확인하는 것은 평등을 확인하는 것보다 훨씬 빠른 점검이 될 수 있습니다 (회원을 재귀 적으로 확인해야 할 수도 있음).

그러나 둘 이상의 물체를 동등한 것으로 찾을 수있는 평등으로 대체 할 수는 없습니다.

목록과 튜플의 평등을 비교하면 물체의 신원이 동일하다고 가정합니다 (빠른 점검이기 때문에). 논리가 일관성이없는 경우 모순을 만들 수 있습니다. nan:

>>> [nan] == [nan]
True
>>> (nan,) == (nan,)
True

주의 이야기 :

문제는 사용하려고합니다 is 정수를 비교합니다. 정수의 인스턴스가 다른 참조로 얻은 것과 동일한 인스턴스라고 가정해서는 안됩니다. 이 이야기는 이유를 설명합니다.

의견 제시자는 평등을 확인하는 대신 작은 정수 (-5 ~ 256 포함)가 파이썬의 싱글 톤이라는 사실에 의존하는 코드를 가지고있었습니다.

와우, 이것은 몇 가지 교활한 버그로 이어질 수 있습니다. A가 B IS인지 확인한 코드가 있었는데, A와 B는 일반적으로 적은 숫자이기 때문에 원하는대로 작동했습니다. A와 B는 캐시되지 않을 정도로 크기 때문에 6 개월 만에 생산 후 6 개월 만에 버그가 발생했습니다. - GWG

그것은 개발에서 일했습니다. 일부 유닛 테스트를 통과했을 수 있습니다.

코드가 256보다 큰 정수를 확인할 때까지 생산에서 작동했으며,이 시점에서 생산에 실패했습니다.

이것은 코드 검토 또는 스타일 체커로 잡힐 수있는 생산 실패입니다.

강조하겠습니다. 사용하지 마세요 is 정수를 비교합니다.

Answer 5

차이점은 무엇입니까? is 그리고 ==?

== 그리고 is 다른 비교입니다! 다른 사람들이 이미 말했듯이 :

• == 객체의 값을 비교합니다.
• is 객체의 참조를 비교합니다.

Python 이름에서는 객체를 나타냅니다. 예를 들어이 경우 value1 그리고 value2 참조 int 값을 저장하는 인스턴스 1000:

value1 = 1000
value2 = value1

왜냐하면 value2 동일한 개체를 나타냅니다 is 그리고 == 줄게 True:

>>> value1 == value2
True
>>> value1 is value2
True

다음 예에서는 이름이 있습니다 value1 그리고 value2 다른 것을 참조하십시오 int 인스턴스, 두 사람이 동일한 정수를 저장하더라도 :

>>> value1 = 1000
>>> value2 = 1000

동일한 값 (정수)이 저장되므로 == 될거야 True, 그렇기 때문에 종종 "가치 비교"라고 불리는 이유입니다. 하지만 is 돌아올 것입니다 False 이것들은 다른 대상이기 때문에 :

>>> value1 == value2
True
>>> value1 is value2
False

언제 어느 것을 사용해야합니까?

일반적으로 is 훨씬 빠른 비교입니다. 그렇기 때문에 Cpython 캐시 (또는 아마도 아마도 재사용 작은 정수, 일부 문자열 등과 같은 특정 물체가 더 나은 용어 일 것입니다. 그러나 이것은 다음과 같이 취급해야합니다. 구현 세부 사항 경고없이 어느 시점에서도 (가능성이 낮더라도) 변경 될 수 있습니다.

당신은해야합니다 만 사용합니다 is 만약 너라면:

• 두 객체가 실제로 동일한 객체인지 확인하고 싶습니다 (동일한 "값"이 아닌). 한 가지 예는 다음과 같습니다 너 싱글 톤 객체를 일정하게 사용하십시오.

• 값을 a와 비교하고 싶습니다 파이썬 끊임없는. 파이썬의 상수는 다음과 같습니다.

  • None
  • True¹
  • False¹
  • NotImplemented
  • Ellipsis
  • __debug__
  • 수업 (예 : int is int 또는 int is float)
  • 내장 모듈 또는 타사 모듈에는 추가 상수가있을 수 있습니다. 예를 들어 np.ma.masked Numpy 모듈에서)

~ 안에 다른 모든 케이스를 사용해야합니다 == 평등을 확인합니다.

동작을 사용자 정의 할 수 있습니까?

몇 가지 측면이 있습니다 == 이미 다른 답변에서 언급되지 않았습니다. 파이썬 "데이터 모델". 즉, 동작을 사용하여 사용자 정의 할 수 있습니다 __eq__ 방법. 예를 들어:

class MyClass(object):
    def __init__(self, val):
        self._value = val

    def __eq__(self, other):
        print('__eq__ method called')
        try:
            return self._value == other._value
        except AttributeError:
            raise TypeError('Cannot compare {0} to objects of type {1}'
                            .format(type(self), type(other)))

이것은 메소드가 실제로 다음이라고 불린다는 것을 설명하는 인공적인 예일뿐입니다.

>>> MyClass(10) == MyClass(10)
__eq__ method called
True

기본적으로 (다른 구현이없는 경우 __eq__ 클래스 또는 슈퍼 클래스에서 찾을 수 있습니다) __eq__ 용도 is:

class AClass(object):
    def __init__(self, value):
        self._value = value

>>> a = AClass(10)
>>> b = AClass(10)
>>> a == b
False
>>> a == a

따라서 실제로 구현하는 것이 중요합니다 __eq__ 사용자 정의 클래스에 대한 참조 비교보다 "더 많은"을 원한다면!

반면에 당신은 사용자 정의 할 수 없습니다 is 체크 무늬. 항상 비교할 것입니다 단지 동일한 참조가있는 경우.

이러한 비교가 항상 부울을 되 찾을 수 있습니까?

왜냐하면 __eq__ 재 구현되거나 재정의 될 수 있습니다. 반품에 국한되지 않습니다. True 또는 False. 그것 ~할 수 있었다 무엇이든 반환하십시오 (그러나 대부분의 경우 부울을 반환해야합니다!).

예를 들어 Numpy Arrays가 있습니다 == 배열을 반환합니다.

>>> import numpy as np
>>> np.arange(10) == 2
array([False, False,  True, False, False, False, False, False, False, False], dtype=bool)

하지만 is 수표는 항상 반환됩니다 True 또는 False!

---

¹ 의견에 언급 된 Aaron Hall :

일반적으로 당신은 아무 일도하지 않아야합니다 is True 또는 is False 암시 적으로 변환하는 컨텍스트에서 일반적으로 이러한 "점검"을 사용하기 때문에 확인합니다. 상태 부울 (예 : An if 성명). 그래서 is True 비교 그리고 암시 적 부울 출연진은 부울 캐스트를하는 것보다 더 많은 일을하고 있습니다. 그리고 당신은 부울 (피티닉으로 간주되지 않는)으로 제한합니다.

PEP8과 같이 :

부울 값을 비교하지 마십시오 True 또는 False 사용 ==.

Yes:   if greeting:
No:    if greeting == True:
Worse: if greeting is True:

Answer 6

그들은 완전히 다릅니다. is 객체 아이덴티티를 확인합니다 == 평등을 점검합니다 (두 피연산자 유형에 따라 다름 개념).

그것은 운이 좋은 우연의 일치 일뿐입니다. "is"작은 정수 (예 : 5 == 4+1)에서 올바르게 작동하는 것 같습니다. Cpython은 싱글 톤을 만들어 범위 (-5 ~ 256)의 정수 저장을 최적화합니다.. 이 동작은 완전히 구현에 따라 다르며 모든 방식의 사소한 변형 작업에 따라 보존되지는 않습니다.

예를 들어, Python 3.5는 또한 짧은 문자열 싱글 톤을 만들지 만 슬라이스는이 동작을 방해합니다.

>>> "foo" + "bar" == "foobar"
True
>>> "foo" + "bar" is "foobar"
True
>>> "foo"[:] + "bar" == "foobar"
True
>>> "foo"[:] + "bar" is "foobar"
False

Answer 7

https://docs.python.org/library/stdtypes.html#comparisons

is 정체성 테스트== 평등 테스트

각 (작은) 정수 값은 단일 값으로 매핑되므로 3 개는 동일하고 동일합니다. 이것은 언어 사양의 일부가 아닌 구현 세부 사항입니다.

Answer 8

귀하의 대답이 맞습니다. 그만큼 is 연산자는 두 객체의 ID를 비교합니다. 그만큼 == 연산자는 두 객체의 값을 비교합니다.

객체의 정체성은 생성 된 후에는 변하지 않습니다. 당신은 그것을 메모리의 개체의 주소로 생각할 수 있습니다.

당신은 __cmp__ 방법 또는 a 풍부한 비교 방법과 같은 방법 __eq__.

Answer 9

그만큼 == 연산자는 피연산자와 값 평등을 검사하는 값을 비교합니다. 반면 is 작업자는 두 피연산자가 동일한 개체를 참조하는지 여부를 확인합니다.

a = [1,2,3,4]
b = a
print(a == b) # true
print(a is b) # true

그러나 우리가한다면

b = a[:] # b now references a copy of a
print(a == b) # true
print(a is b) # false
print(a is not b) # true

원래, is 속기로 생각할 수 있습니다 id(a) == id(b). 그러나이를 넘어서, 런타임 환경에 대한 단점이 더욱 복잡해집니다. 짧은 줄과 작은 정수가 돌아옵니다 True 비교할 때 is, 동일한 객체에 대한 메모리를 덜 사용하려고 시도하는 파이썬 기계로 인해.

a = 'python'
b = 'python'

print(a == b) # true
print(a is b) # true

Answer 10

스택 오버 플로우 질문을 살펴보십시오 Python의 "IS"연산자는 정수와 예기치 않게 동작합니다..

주로 요약하는 것은 "is"서로 동일하지 않고 동일한 개체인지 확인합니다 (256 미만의 숫자는 특별한 경우입니다).

Answer 11

John Feminella가 말했듯이, 대부분의 시간은 == 및! =를 사용할 것입니다. 목표는 값을 비교하는 것이기 때문입니다. 나는 당신이 나머지 시간에 무엇을 할 것인지 분류하고 싶습니다.

Nonetype의 인스턴스는 하나만 있습니다. 즉, 싱글 톤은 없습니다. 따라서 foo == None 그리고 foo is None 동일하게 의미합니다. 그러나, 그 is 테스트가 더 빠르고 피스닉 컨벤션은 사용하는 것입니다. foo is None.

쓰레기 수집으로 내성을하거나 멍청이를하고 있거나 사용자 정의 구축 문자열 인턴 가제트가 작동하는지 여부를 확인하는 경우 아마도 유스 케이스가있을 것입니다. foo ~이다 bar.

True와 False는 또한 (현재) 싱글 톤이지만, foo == True 그리고 사용 사례가 없습니다 foo is True.

Answer 12

그들 대부분은 이미 그 요점에 대답했습니다. 추가 메모 (내 이해와 실험을 기반으로하지만 문서화 된 출처에서 얻은 것은 아닙니다).

== 변수에 의해 언급 된 개체가 동일하다면

위에서 답변을 읽어야합니다

== 변수에 의해 언급 된 개체가 동일하고 동일한 유형/클래스에 속하는 객체 인 경우

. 아래 테스트를 바탕 으로이 결론에 도달했습니다.

list1 = [1,2,3,4]
tuple1 = (1,2,3,4)

print(list1)
print(tuple1)
print(id(list1))
print(id(tuple1))

print(list1 == tuple1)
print(list1 is tuple1)

여기서 목록과 튜플의 내용은 동일하지만 유형/클래스는 다릅니다.

Answer 13

간단히 말해서, is 두 참조가 동일한 객체를 가리키는 지 여부를 확인합니다.== 두 객체의 값이 같은지 여부를 확인합니다.

a=[1,2,3]
b=a        #a and b point to the same object
c=list(a)  #c points to different object 

if a==b:
    print('#')   #output:#
if a is b:
    print('##')  #output:## 
if a==c:
    print('###') #output:## 
if a is c:
    print('####') #no output as c and a point to different object 

Answer 14

실제로 나는 이것을 의견으로 추가하고 싶었지만 쉽게 아름답게 아름답게 할 수 없었기 때문에 답으로 추가 할 수 있습니다. 이것을 답으로 간주하지 마십시오.

이것이 내가 이해하기 위해 한 일입니다.

다음 단계를 하나씩 실행하고 모든 단계에서 출력을 이해합니다.

a = [1,2]
b = [1,2,3]
b.pop()
id(a)
id(b)
a is b
a == b

Answer 15

이 게시물의 다른 사람들이 질문에 세부적으로 대답 하듯이 강조하다 주로 비교 is 그리고 == 현악기 다른 결과를 줄 수 있으며 프로그래머에게 신중하게 사용하도록 촉구합니다.

문자열 비교를 위해 사용하십시오 == 대신에 is:

str = 'hello'
if (str is 'hello'):
    print ('str is hello')
if (str == 'hello'):
    print ('str == hello')

밖으로:

str is hello
str == hello

하지만 아래 예에서 == 그리고 is 다른 결과를 얻을 수 있습니다.

str = 'hello sam'
    if (str is 'hello sam'):
        print ('str is hello sam')
    if (str == 'hello sam'):
        print ('str == hello sam')

밖으로:

str == hello sam

결론:

사용 is 줄을 신중하게 비교합니다

Answer 16

IS와 동일 사이의 파이썬 차이 (==)

IS 연산자는 평등 연산자와 동일하게 보일 수 있지만 동일하지 않습니다.

IS는 두 변수가 동일한 객체를 가리키는 지 확인하지만 == 부호는 두 변수의 값이 동일한지 확인합니다.

따라서 운영자가 TRUE를 반환하면 평등은 확실히 사실이지만 그 반대는 사실이거나 그렇지 않을 수도 있습니다.

다음은 유사성과 차이를 보여주는 예입니다.

>>> a = b = [1,2,3]
>>> c = [1,2,3]
>>> a == b
True
>>> a == c
True
>>> a is b
True
>>> a is c
False
>>> a = [1,2,3]
>>> b = [1,2]
>>> a == b
False
>>> a is b
False
>>> del a[2]
>>> a == b
True
>>> a is b
False

Tip: Avoid using is operator for immutable types such as strings and numbers, the result is unpredictable.

Answer 17

"=="는 값을 비교합니다

"IS"는 기본 물체를 비교합니다

# this pgm is to show you the diff b/n == and is

# a==b and a is b

# == compares values
# is compares references i.e compares wether two variables refer to same object(memory)

a=10
b=10
print(a==b) # returns True as a,b have same value 10 
print(a is b)
# returns True,
# we usually falsey assume that a =10 a new object . b=10 a new obj created
# but actually when b=10 ,nothing but b is pointed to 10 until value of a or b is changed from 10 

a=[1]
b=[1]
print(a==b)
#returns True as a,b have a list element 1
print(a is b)
#returns False because here two different objs are created when initiated with lists

Answer 18

O1은 O2입니다 => O1과 O2가 모두 메모리에서 동일한 물리적 위치를 가리키면 비교합니다 (즉, 동일한 개체 인 경우)

O1 == O2 => 여기서 파이썬은 O1의 __cmp __ (O2) 메소드를 호출합니다.이 방법은 이상적으로 값을 비교하고 true 또는 false를 반환해야합니다. (즉, 그것은 가치를 비교합니다)

자바 사람들을 위해 :

• Java에서는 두 문자열 변수가 사용하여 동일한 물리적 메모리 위치를 참조하는지 여부를 결정합니다. str1 == str2. (객체 아이덴티티라고 불리는 것은 str1로서의 Python은 str2입니다).

• Java의 문자열 값을 비교하려면 usest1.equals (str2); 안에 Python, str1 == str2를 사용하십시오.

예시:

class A():
    ...:     def __init__(self,a):
    ...:         self.a = a
    ...:     def __repr__(self):
    ...:         return str(self.a)
    ...:     def __cmp__(self, value):
    ...:         print self.a
    ...:         print value.a
    ...:         return cmp(self.a, value.a)

파이썬 쉘 출력 :

o = A (2) O1 = O

o == O1 2 2 true

O는 O1 TRUE입니다

O1 = A (2)

O는 O1 False입니다

Answer 19

JavaScript와 비교하는 경우 (그러나 한 언어와 다른 언어를 비교하는 것이 권장되지 않음) :

• 사용 is 엄격한 비교를 위해. 자바 스크립트 등가 (===)
• 사용 == 평등 비교를 위해.

Answer 20

이의 제기 포인터 비교와 값 비교의 구현에 의존하는 이러한 모든 답변은 정확할 수 있지만, 사용에 대한 더 깊은 구문 적 이유가 있습니다. is 변수 값이 있는지 확인합니다 None (부울 논리에서 종종 NULL).

관계형 데이터베이스 및 기타 로직 시스템에서 NULL 실제 값은 "알 수 없음"임을 암시합니다. 따라서 논리적 표현 xx == NULL 항상 평가해야합니다 NULL 그 자체로 xx, 그것이 무엇이든 할 수있는 것은 알려지지 않은 값과 동일합니다. 부울 논리의 규칙에 더 엄격하게 부착되는 프로그래밍 언어에서 xx == NULL (또는 파이썬으로 xx == None) 올바르게 평가합니다 NULL, 변수 값이 있는지 확인하기 위해 대안 수단을 제공해야합니다. NULL. 파이썬은 이와 관련하여 객체 참조의 단일 특성으로 인해 이상적입니다. None. 그러나 명확성과 논리적 정확성을 위해 파이썬을 사용합니다. is 비교 연산자는 나에게 훨씬 더 건전한 연습을합니다.

Answer 21

예, 둘 사이에는 차이가 있습니다.

• '==' : 객체를 값으로 비교합니다.

• '안에' : 객체를 참조 별 비교합니다.

  a = [1,2,3]  
  b = a # both pointing to same object (memory location)
  
  a == b:  
  True  
  a in b:   
  True  #because a and b are pointing to same object
  

이제이 사례를 고려해 봅시다.

a = [1,2,3]
b = list(a)  # creating copy of object a

a == b:  
True  # as values are same
a in b:   
False  # because they are pointing to different object.