def test_Hashable(self):
# Check some non-hashables
non_samples = [bytearray(), list(), set(), dict()]
for x in non_samples:
self.assertNotIsInstance(x, Hashable)
self.assertFalse(issubclass(type(x), Hashable), repr(type(x)))
# Check some hashables
samples = [None,
int(), float(), complex(),
str(),
tuple(), frozenset(),
int, list, object, type, bytes()
]
for x in samples:
self.assertIsInstance(x, Hashable)
self.assertTrue(issubclass(type(x), Hashable), repr(type(x)))
self.assertRaises(TypeError, Hashable)
# Check direct subclassing
class H(Hashable):
def __hash__(self):
return super().__hash__()
self.assertEqual(hash(H()), 0)
self.assertFalse(issubclass(int, H))
self.validate_abstract_methods(Hashable, '__hash__')
self.validate_isinstance(Hashable, '__hash__')
python类Hashable()的实例源码
def memoized(func):
"""A decorator to cache function's return value
"""
cache = {}
@functools.wraps(func)
def wrapper(*args):
if not isinstance(args, collections.Hashable):
# args is not cacheable. just call the function.
return func(*args)
if args in cache:
return cache[args]
else:
value = func(*args)
cache[args] = value
return value
return wrapper
def test_sets():
a = Link('foo', 'bar', 'doz')
b = Link('foo', 'bar', 'doz')
c = Link('42')
assert isinstance(a, collections.Hashable)
assert hash(a) == hash(b)
assert hash(b) != hash(c)
s1 = set([a])
s2 = set([b])
s3 = set([c])
assert (s1 - s2) == set()
assert (s1 | s2) == set([a])
assert (s1 | s2 | s3) == set([a,b,c])
assert ((s1 | s2 | s3) - s1) == set([c])
def _validate_excludes(self, excludes, field, value):
""" {'type': ['hashable', 'hashables']} """
if isinstance(excludes, Hashable):
excludes = [excludes]
# Save required field to be checked latter
if 'required' in self.schema[field] and self.schema[field]['required']:
self._unrequired_by_excludes.add(field)
for exclude in excludes:
if (exclude in self.schema and
'required' in self.schema[exclude] and
self.schema[exclude]['required']):
self._unrequired_by_excludes.add(exclude)
if [True for key in excludes if key in self.document]:
# Wrap each field in `excludes` list between quotes
exclusion_str = ', '.join("'{0}'"
.format(word) for word in excludes)
self._error(field, errors.EXCLUDES_FIELD, exclusion_str)
def memoized(func):
_cache = {}
def _deco(*args, **kwargs):
if 'clear_cache' in kwargs or 'clear_cache_only' in kwargs:
_cache.clear()
if 'clear_cache_only' in kwargs:
return # we don't care about the output
del kwargs['clear_cache']
if not isinstance(args, collections.Hashable):
return func(*args, **kwargs)
if args in _cache:
return _cache[args]
else:
value = func(*args, **kwargs)
_cache[args] = value
return value
return update_wrapper(_deco, func)
def projections(value, match_value=True):
if match_value and isinstance(value, collections.Hashable):
yield value
traits = getattr(value, "MATCH_TRAITS", None)
if traits is not None:
if isinstance(traits, tuple):
for t in traits:
yield t
else:
yield traits
if not isinstance(value, Marker):
if isinstance(value, super):
for cls in value.__self_class__.__mro__[1:]:
yield cls
else:
for cls in value.__class__.__mro__:
yield cls
def tag(self, *tags):
"""
Tags the job with one or more unique indentifiers.
Tags must be hashable. Duplicate tags are discarded.
:param tags: A unique list of ``Hashable`` tags.
:return: The invoked job instance
"""
if any([not isinstance(tag, collections.Hashable) for tag in tags]):
raise TypeError('Every tag should be hashable')
if not all(isinstance(tag, collections.Hashable) for tag in tags):
raise TypeError('Tags must be hashable')
self.tags.update(tags)
return self
def to_frozenset(item):
"""Recursively convert 'item' to a frozenset"""
if isinstance(item, Hashable):
return item
if isinstance(item, dict):
return frozenset([(k, to_frozenset(v)) for k, v in item.items()])
if isinstance(item, list):
return frozenset([to_frozenset(v) for v in item])
def construct_mapping(self, node, deep=False):
if not isinstance(node, MappingNode):
raise ConstructorError(None, None,
"expected a mapping node, but found %s" % node.id,
node.start_mark)
mapping = {}
for key_node, value_node in node.value:
key = self.construct_object(key_node, deep=deep)
if not isinstance(key, collections.Hashable):
raise ConstructorError("while constructing a mapping", node.start_mark,
"found unhashable key", key_node.start_mark)
value = self.construct_object(value_node, deep=deep)
mapping[key] = value
return mapping
def test_hash(self):
def mycmp(x, y):
return y - x
key = functools.cmp_to_key(mycmp)
k = key(10)
self.assertRaises(TypeError, hash, k)
self.assertFalse(isinstance(k, collections.Hashable))
def construct_mapping(self, node, deep=False):
if not isinstance(node, nodes.MappingNode):
raise ConstructorError(
None, None,
'expected a mapping node, but found %s' % node.id,
node.start_mark
)
mapping = {}
for key_node, value_node in node.value:
key = self.construct_object(key_node, deep=deep)
if not isinstance(key, collections.Hashable):
self.echoerr(
'While constructing a mapping', node.start_mark,
'found unhashable key', key_node.start_mark
)
continue
elif type(key.value) != unicode:
self.echoerr(
'Error while constructing a mapping', node.start_mark,
'found key that is not a string', key_node.start_mark
)
continue
elif key in mapping:
self.echoerr(
'Error while constructing a mapping', node.start_mark,
'found duplicate key', key_node.start_mark
)
continue
value = self.construct_object(value_node, deep=deep)
mapping[key] = value
return mapping
def msgpack_encode_hashable(x):
if not isinstance(x, collections.Hashable):
raise ValueError(x)
return messagepack.packb(x)
def test_collections_hashable(self):
x = np.array([])
self.assertFalse(isinstance(x, collections.Hashable))
def __call__(self, *args):
if not isinstance(args, collections.Hashable):
# uncachable, return direct function application
return self.func(*args)
if args in self.cache:
return self.cache[args]
else:
val = self.func(*args)
self.cache[args] = val
return val
def __call__(self, *args):
if not isinstance(args, collections.Hashable):
# uncacheable. a list, for instance.
# better to not cache than blow up.
return self.func(*args)
if args in self.cache:
return self.cache[args]
else:
value = self.func(*args)
self.set_cache(value, *args)
return value
def __call__(self, *args):
if not isinstance(args, collections.Hashable):
# uncacheable. a list, for instance.
# better to not cache than blow up.
return self.func(*args)
if args in self.cache:
return self.cache[args]
else:
value = self.func(*args)
self.cache[args] = value
return value
def unique(a):
if isinstance(a,collections.Hashable):
c = set(a)
else:
c = []
for x in a:
if x not in c:
c.append(x)
return c
def intersect(a, b):
if isinstance(a,collections.Hashable) and isinstance(b,collections.Hashable):
c = set(a) & set(b)
else:
c = unique(filter(lambda x: x in b, a))
return c
def difference(a, b):
if isinstance(a,collections.Hashable) and isinstance(b,collections.Hashable):
c = set(a) - set(b)
else:
c = unique(filter(lambda x: x not in b, a))
return c
def symmetric_difference(a, b):
if isinstance(a,collections.Hashable) and isinstance(b,collections.Hashable):
c = set(a) ^ set(b)
else:
c = unique(filter(lambda x: x not in intersect(a,b), union(a,b)))
return c
def union(a, b):
if isinstance(a,collections.Hashable) and isinstance(b,collections.Hashable):
c = set(a) | set(b)
else:
c = unique(a + b)
return c
def _make_hashable(o):
if isinstance(o, collections.Hashable):
return o
# Py2 requires string class name, not Unicode (which literals are)
return type(str(''), (type(o),), dict(__hash__=_uni_hash))(o)
def _make_hashable(o):
if isinstance(o, collections.Hashable):
return o
# Py2 requires string class name, not Unicode (which literals are)
return type(str(''), (type(o),), dict(__hash__=_uni_hash))(o)
def _make_hashable(o):
if isinstance(o, collections.Hashable):
return o
# Py2 requires string class name, not Unicode (which literals are)
return type(str(''), (type(o),), dict(__hash__=_uni_hash))(o)
def test_hashable(self):
a = grammar.TypeExpression('X')
b = grammar.TypeExpression('Y', fields=(a,))
c = grammar.TypeExpression('Y', fields=(a,))
d = grammar.TypeExpression('Z', predicate=grammar.Predicate("stuff"))
self.assertIsInstance(a, collections.Hashable)
# There really shouldn't be a collision between these:
self.assertNotEqual(hash(a), hash(d))
self.assertEqual(b, c)
self.assertEqual(hash(b), hash(c))
# TODO: Test dictionaries work well
def test_hash():
for cls in classes[-2:]:
s = set([cls.eye(1), cls.eye(1)])
assert len(s) == 1 and s.pop() == cls.eye(1)
# issue 3979
for cls in classes[:2]:
assert not isinstance(cls.eye(1), collections.Hashable)
def test_direct_subclassing(self):
for B in Hashable, Iterable, Iterator, Sized, Container, Callable:
class C(B):
pass
self.assertTrue(issubclass(C, B))
self.assertFalse(issubclass(int, C))
def test_registration(self):
for B in Hashable, Iterable, Iterator, Sized, Container, Callable:
class C:
__hash__ = None # Make sure it isn't hashable by default
self.assertFalse(issubclass(C, B), B.__name__)
B.register(C)
self.assertTrue(issubclass(C, B))
def test_hash(self):
def mycmp(x, y):
return y - x
key = functools.cmp_to_key(mycmp)
k = key(10)
self.assertRaises(TypeError, hash, k)
self.assertFalse(isinstance(k, collections.Hashable))
def test_not_hashable(self):
for obj in self.error_expected:
self.assertNotIsInstance(obj, Hashable)
# Issue #4701: Check that some builtin types are correctly hashable
