class Foo: ...
class Bar: ...
assert Foo() != Bar()

u = Foo()
d = {deepcopy(u):1}

if u in d: # словарь d проверил наличие и попутно запомнил указатель (id) ключа u
   idu = id(u)
   del u
   v = Bar()
   idv = id(v)
   assert idu == idv # равенство id не запрещено, если время жизни объектов не пересекается
   print(d[v]) # Грабли: указатель на v и на бывший u совпали, но v не равно u.

IRO>if 'hello' in d:
IRO>    print d['hello']
IRO>

v = d.get('hello')
if v is not None:
    print v

IRO>  if d->m[d->index].key == key : return d->m[d->index].value

key = 'abc'
d = {''.join(key): "Hello"}
assert key in d # True

for i in xrange(10**9):
    if key in d:
        print(d[key])

if 'hello' in d:
    print d['hello']

IRO>if 'hello' in d:
IRO>    print d['hello']
IRO>

if( var h = d["hello"] )
  stdout.println(h);

S>v = d.get('hello')
S>if v is not None:
S>    print v
S>

if 'hello' in d:
    print d['hello']
else:
    print 'default value'

print d.get('hello', 'default value')

S>v = d.get('hello')
S>if v is not None:
S>    print v
S>

d = {'hello': None}
try:
    print d['hello']
except:
    pass

try:
    print d['hi']     
except:
    pass

S>v = d.get('hello')
S>if v is not None:
S>    print v
S>

keys = ['none', 'false', 'zero', 'empty', 'missed']
data = {'none':None, 'false':False, 'zero':0, 'empty':[], 'one':1}
 
def naive(k):
    return data[k] if k in data else 'missed'
 
def smart(k):
    v = data.get(k)
    return v if v is not None else 'missed'
 
def stupid(k):
    v = data.get(k)
    return v if v else 'missed'
 
unique_object = [] # объект глобальный только ради того, чтоб не тратиться на пересоздание на каждый вызов
def verysmart(k):
    v = data.get(k,unique_object)
    return v if v is not unique_object else 'missed'
 
def test(method):
    print(method)
    for k in keys:
        print(k, method(k))
    print()
 
test(naive)     # медленно
test(stupid)    # куча ложных пропусков
test(smart)     # ложный пропуск на none
test(verysmart) # быстро

def verysmart(k, unique_object=[])

def foo(s = []):
  print(s)
  s += [1]

foo() # []
foo() # [1]
foo() # [1,1]

import time

class X:
  def __init__(self,i):
    self.i = i
  def __repr__(self):
    return 'X(%r)' % self.i
  def __eq__(self, other):
    return type(self) == type(other) and self.i == other.i
  def __hash__(self):
    return 0 # злодейски положим всех в одну корзину

N = 5000
ns = range(N)
xs = [ X(i) for i in ns ]

t = time.time()
xn = { X(i):i for i in ns } # квадратичная сложность, тупит 11с
print(time.time()-t)

t = time.time()
all(x in xn for x in xs) # True; квадратичная сложность, тупит 11с
print(time.time()-t)

# добавим для вредности в ту же корзину hash(X(_)) == hash(0) == 0
xn[0] = None

# добавим в проверочный список
xs += [0x7FFFFFFF] # hash == 0

# наивный
t = time.time()
for x in xs:
  if x in xn: # тупим раз
    v = xn[x] # тупим два (не будем тратиться на print)
  else:
    print(x,'missed')
print(time.time()-t) # тупили дважды, 22с

# умный
t = time.time()
for x in xs:
  o = object()
  v = xn.get(x,o) # тупим раз
  if v is not o:
    pass
  else:
    print(x,'missed')
print(time.time()-t) # тупили единожды, 11с

typedef struct {
    /* Cached hash code of me_key.  Note that hash codes are C longs.
     * We have to use Py_ssize_t instead because dict_popitem() abuses
     * me_hash to hold a search finger.
     */
    Py_ssize_t me_hash;
    PyObject *me_key;
    PyObject *me_value;
} PyDictEntry;

d['hello'] = 12;
'hello' in d
d['hello'] = 13;
d['hello'] ?

if?( var h = d["hello"] )
   //use h

W>Приведи пример реализации на псевдокоде такой проверки. Сдаётся мне, что-то тут у тебя не учтено

struct dict
{
int index;
field m[8];
}

object * find( dict * d, object * key )
{
  if d->m[d->index].key == key : return d->m[d->index].value

  ....
}

IRO>>  if d->m[d->index].key == key : return d->m[d->index].value
W>

W>Где оптимизация-то? Почему этому коду не хватает миллиарда итераций чтобы вышеприведённая строчка начала срабатывать?

W>key = 'abc'
W>d = {''.join(key): "Hello"}
W>assert key in d # True

W>for i in xrange(10**9):
W>    if key in d:
W>        print(d[key])

W>

IRO>>  if d->m[d->index].key == key : return d->m[d->index].value
W>

W>Где оптимизация-то? Почему этому коду не хватает миллиарда итераций чтобы вышеприведённая строчка начала срабатывать?

W>key = 'abc'
W>d = {''.join(key): "Hello"}
W>assert key in d # True

W>for i in xrange(10**9):
W>    if key in d:
W>        print(d[key])

W>

    if (MCACHE_CACHEABLE_NAME(name) &&
        PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG)) {
        /* fast path */
        h = MCACHE_HASH_METHOD(type, name);
        if (method_cache[h].version == type->tp_version_tag &&
            method_cache[h].name == name)
            return method_cache[h].value;
    }