هل هناك فرق بين "==" و "هو" ؟

Question

بلدي جوجل-فو وقد فشلت.

في بيثون ، التاليين اختبارات المساواة ما يعادل?

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

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

هل هذا ينطبق على الكائنات حيث أن المقارنة بين الحالتين (أ 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

في حالتك الاختبار الثاني يعمل فقط لأن الثعبان مخابئ صغيرة صحيح الكائنات ، وهي تفاصيل التنفيذ.أكبر الأعداد الصحيحة ، هذا لا يعمل:

>>> 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 كما المفرد الحالات لأسباب تتعلق بالأداء.هنا مثال على ذلك مما يدل على هذا:

>>> 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 ينتج معكوس القيمة الحقيقة.

وهكذا ، فإن التحقق من الهوية هو نفس التحقق من المساواة بين معرفات الكائنات.وهذا هو ،

a is b

هو نفسه:

id(a) == id(b)

حيث id هو مدمج الدالة بإرجاع عدد صحيح أن "هو ضمان أن تكون فريدة من نوعها في وقت واحد بين الكائنات الموجودة" (انظر help(id)) و حيث a و b أي كائنات التعسفي.

استخدام آخر الاتجاهات

يجب عليك استخدام هذه المقارنات عن معاني الكلمات.استخدام is للتحقق من الهوية ، == للتحقق من المساواة.

بيب 8 الرسمية الثعبان نمط دليل المكتبة القياسية يذكر أيضا اثنين من حالات الاستخدام ل is:

مقارنات إلى وحدانية مثل None ينبغي دائما أن يتم مع is أو is not, أبدا المساواة بين المشغلين.

أيضا, حذار من كتابة if x عندما كنت حقا يعني if x is not None -- على سبيل المثالعند اختبار ما إذا كان متغير أو حجة الافتراضية None تم تعيين إلى قيمة أخرى.فإن قيمة أخرى قد يكون لها نوع (مثل كما حاوية) التي يمكن أن تكون خاطئة في منطقية السياق!

استنتاج المساواة من الهوية

إذا is صحيح المساواة عادة يمكن الاستدلال المنطقي ، إذا كان الكائن هو نفسه, ثم ينبغي أن الاختبار يعادل نفسها.

في معظم الحالات هذا المنطق صحيحا ، ولكنها تعتمد على تنفيذ __eq__ طريقة خاصة.كما مستندات أقول ،

السلوك الافتراضي من أجل المساواة المقارنة (== و !=) على أساس هوية الكائنات.ومن ثم المساواة المقارنة من الحالات مع نفس الهوية النتائج في المساواة بين الجنسين مقارنة الحالات مع هويات مختلفة النتائج في عدم المساواة.A الدافع لهذا السلوك الافتراضي هو الرغبة في أن جميع الكائنات يجب أن تكون انعكاسية (أيx y يعني 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)

على contrapositive هو أيضا عادة الحقيقي - إذا سمثينغس اختبار لا تساوي, عادة يمكنك أن تستنتج أنها لا نفس الكائن.

منذ الاختبارات من أجل المساواة يمكن تخصيص هذا الاستدلال لا يصح دائما لجميع أنواع.

استثناء

الاستثناء الملحوظ هو 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 هي عادة أعداد صغيرة.الخلل فقط حدث اليوم بعد ستة أشهر في الإنتاج ، لأن a و b أخيرا كبيرة بما يكفي أن لا يكون مؤقتا.– gwg

عملت في التنمية.وقد مرت بعض unittests.

وعملت في الإنتاج حتى رمز التحقق من عدد صحيح أكبر من 256, وعند هذه النقطة فشل في الإنتاج.

هذا هو إنتاج الفشل التي يمكن أن تكون قد اشتعلت في مراجعة التعليمات البرمجية أو ربما مع نمط-مدقق.

اسمحوا لي أن أؤكد: لا تستخدم is مقارنة الأعداد الصحيحة.

Answer 5

ما هو الفرق بين is و ==?

== و is هي المقارنة مختلفة!وغيرها من قلت:

• == يقارن قيم الأشياء.
• is يقارن مراجع الكائنات.

في بيثون أسماء تشير إلى الأشياء ، على سبيل المثال في هذه الحالة 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 إذا كنت:

• تريد معرفة ما اذا كان اثنين من الكائنات هي حقا نفس الكائن (وليس فقط نفس "القيمة").مثال واحد يمكن أن يكون إذا لك استخدام الكائن المفرد المستمر.

• تريد مقارنة القيمة بيثون ثابت.الثوابت في بيثون هي:

  • None
  • True¹
  • False¹
  • NotImplemented
  • Ellipsis
  • __debug__
  • الطبقات (على سبيل المثال int is int أو int is float)
  • يمكن أن يكون هناك إضافية الثوابت في المدمج في وحدات أو وحدات 3rd الطرف.على سبيل المثال 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__ يمكن العثور عليها في فئة أو superclasses) __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 على المصفوفات == سيعود مجموعة:

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

ولكن is وسوف يتحقق دائما العودة True أو False!

---

¹ كما هارون القاعة المذكورة في التعليقات:

عموما يجب أن لا تفعل أي is True أو is False الشيكات لأن المرء عادة يستخدم هذه "الضوابط" في السياق الذي ضمنا تحويل الشرط إلى منطقية (على سبيل المثال في if البيان).ذلك is True مقارنة و ضمني منطقية يلقي القيام بمزيد من العمل من مجرد القيام منطقية الزهر و كنت تحد نفسك القيم المنطقية (الذي لا يعتبر pythonic).

مثل 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) بجعلها سنغلتونس.هذا السلوك تماما تعتمد على التنفيذ و لا يضمن أن تكون محفوظة تحت كل أنواع طفيفة العمليات التحويلية.

على سبيل المثال ، بيثون 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 مشغل يقارن هوية اثنين من الكائنات.على == مشغل يقارن قيم اثنين من الكائنات.

كائن هوية لا يتغير أبدا مرة واحدة وقد تم إنشاؤها ؛ قد تعتقد أنها كائن عنوان في الذاكرة.

يمكنك التحكم في المقارنة بين سلوك الكائن القيم من خلال تحديد __cmp__ الأسلوب أو غنية مقارنة طريقة مثل __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

إلقاء نظرة على تجاوز سعة مكدس السؤال بايثون "هو" المشغل يتصرف بشكل غير متوقع مع الاعداد الصحيحه.

ما هو الغالب يتلخص في أن "is"التحقق لمعرفة ما إذا كانوا من نفس الكائن ، ليس فقط على قدم المساواة مع بعضها البعض (الأرقام أدناه 256 هي حالة خاصة).

Answer 11

جون Feminella قال أكثر من مرة سوف تستخدمها == و != لأن الهدف هو مقارنة القيم.أود فقط أن تصنيف ما كنت تفعل بقية الوقت:

هناك واحد فقط مثيل واحد من NoneType أيأي هو المفرد.وبالتالي foo == None و foo is None يعني نفس.ومع ذلك is الاختبار هو أسرع و Pythonic اتفاقية استخدام foo is None.

إذا كنت تفعل بعض التأمل أو اللعب مع جمع القمامة أو التحقق من ما إذا كان الخاص بك مبنية خصيصا سلسلة تتدرب الأداة تعمل أو غيرها ، ثم ربما لديك استخدام القضية foo هو bar.

الصواب والخطأ أيضا (الآن) ووحدانية, ولكن لا يوجد أي استخدام حدة 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

بيثون الفرق بين هو و يساوي(==)

هو المشغل قد يبدو وكأنه نفس المشغل المساواة ولكن فهي ليست نفسها.

هو يتحقق إذا كان كل من المتغيرات تشير إلى نفس الكائن في حين على == التوقيع على الشيكات إذا كانت قيم المتغيرين هي نفسها.

حتى إذا كان هو المشغل بإرجاع 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

"==" يقارن القيم

"هو" يقارن الأساسية الكائنات

# 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) الأسلوب ، من الناحية المثالية التي ينبغي أن يقارن قيمة return True أو False.(وبعبارة أخرى فإنه يقارن قيمة)

جافا الناس:

• في جافا ، لتحديد ما إذا كان اثنين من متغيرات السلسلة المرجع نفسه الذاكرة الفعلية الموقع باستخدام str1 == str2.(كائن يسمى الهوية و هو مكتوب في بايثون str1 هو str2).

• مقارنة قيم السلسلة في جاوة ، usestr1.يساوي(str2);في بيثون ، استخدام 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)

Python Shell الإخراج:

س = أ(2) o1 = o

o == o1 2 2 صحيح

o o1 صحيح

ن1 = عدد(2)

o o1 كاذبة

Answer 19

إذا قارنته مع جافا سكريبت (ومع ذلك ، لا ينصح مقارنة لغة واحدة مقابل أخرى):

• استخدام is الصارم المقارنة.جافا سكريبت ما يعادل (===)
• استخدام == المساواة المقارنة.

Answer 20

في حين أن جميع هذه الإجابات التي تعتمد على تنفيذ اعتراض مؤشر المقارنة مقابل قيمة المقارنة المرجح الصحيح ، هناك أعمق النحوية السبب ، is لتحديد ما إذا كانت قيمة المتغير هو None (في منطقية في كثير من الأحيان تمثيل NULL).

في قاعدة بيانات علائقية وغيرها من منطق النظم ، NULL يعني أن القيمة الفعلية هو "غير معروف".وبالتالي تعبير منطقي xx == NULL يجب دائما تقييم NULL نفسها, كما أنه من المستحيل أن تعرف من أي وقت مضى إذا xx, مهما كان قد يكون لها قيمة, هو نفس مجهولة القيمة.في لغات البرمجة أن تلتزم أكثر الصارم لقواعد منطقية المنطق ، xx == NULL (أو Pythonically 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.