def test_this_and_that(self): self.assert_ (2 == len (self.fake_dict.keys ())) cat_hits = self.fake_dict[bag ("cat")] self.assert_ (2 == len (cat_hits)) self.assert_ (cat_hits[0] == "cat") self.assert_ (cat_hits[1] == "tac") self.assert_ (1 == len (self.fake_dict[bag ("fred")])) self.assert_ (self.fake_dict[bag ("fred")][0] == "fred")
def jaccard_two_lists(from_list, to_list): # bag it from_bag = bag.bag(from_list) to_bag = bag.bag(to_list) # In the intersection (respectively union) of two multisets A and # B, the count of x is the min (respectively sum) of its counts in # A and B.) union_count = 0 intersection_count = 0 keys = Set() keys.update(from_bag.iterunique()) keys.update(to_bag.iterunique()) for thing in keys: union_count += max(to_bag[thing], from_bag[thing]) intersection_count += min(to_bag[thing], from_bag[thing]) # Jaccard's coefficient: size of intersection over size of union. if union_count == 0: return float(0) if intersection_count == 0: return float(0) return float(intersection_count) / float(union_count)
def __init__(self, d, conn): self.name = d.name self.__conn = conn self.__state = constants.PLAYER_STATE_LOGIN conn.ply = self self.bag = bag.bag(self) self.bag.add(constants.ItemBullet, 10000) self.dead = False self.pos = data.data(x = 1000, z = 1000) # data self.hero = "hero" self.weapon = constants.WeaponNormal self.run_distance = 0 self.point = 0
def __init__(self, cSpeed=0, cHeight=0, cMusic='a', ): self.speed = self.startSpeed = cSpeed # 0-9 self.startHeight = cHeight # 0-5 self.score = 0 self.bag = bag.bag(7) self.lines = 0 self.timer = stopwatch.Stopwatch() self.pause = False # generate height garbage self.field = field.Field() # populate blocks self.currPiece = piece.Piece(self.bag.grab()) self.nextPiece = piece.Piece(self.bag.grab())
def snarf_dictionary_from_IO (I): print >> sys.stderr, "Snarfing", I hash_table = {} for w in re.findall (r'.+', I.read ()): w = string.lower (w) if not word_acceptable(w): continue key = bag(w) if hash_table.has_key (key): if (0 == hash_table[key].count (w)): # avoid duplicates hash_table[key].append (w) else: hash_table[key] = [w] print >> sys.stderr, "done" return hash_table
def parse_reaction_formula_side(self, s): """ parse the side formula, e.g. '2 C00001 + C00002 + 3 C00003' return the set of CIDs, ignore stoichiometry """ compound_bag = bag.bag() for member in s.split("+"): member = member.strip() if (member.find(' ') > -1): (amount, cid) = member.split() else: amount = 1 cid = member try: compound_bag.add(cid, int(amount)) except ValueError: raise KeggParseException("Non-specific reaction: " + s) return compound_bag
def snarf_dictionary_from_IO(I): print "Snarfing", I hash_table = {} for w in re.findall(r".+", I.read()): w = string.lower(w) if non_letter_re.search(w): continue if not long_enough_re.match(w): continue if not has_a_vowel_re.search(w): continue key = bag(w) if hash_table.has_key(key): if 0 == hash_table[key].count(w): # avoid duplicates hash_table[key].append(w) else: hash_table[key] = [w] print "done" return hash_table
def snarf_dictionary_from_IO (I): print "Snarfing", I hash_table = {} for w in re.findall (r'.+', I.read ()): w = string.lower (w) if non_letter_re.search (w): continue if (not long_enough_re.match (w)): continue if (not has_a_vowel_re.search (w)): continue key = bag(w) if hash_table.has_key (key): if (0 == hash_table[key].count (w)): # avoid duplicates hash_table[key].append (w) else: hash_table[key] = [w] print "done" return hash_table
action="store", type="string", dest="dict_fn", default=dict.default_dict_name, metavar="FILE", help="location of word list") (options, args) = parser.parse_args() if (0 == len(args)): parser.print_help () sys.exit (0) dict_hash_table = dict.snarf_dictionary (options.dict_fn) the_phrase = bag (args[0]) print >> sys.stderr, "Pruning dictionary. Before:", len (dict_hash_table.keys ()), "bags ...", # Now convert the hash table to a list, longest entries first. (This # isn't necessary, but it makes the more interesting anagrams appear # first.) # While we're at it, prune the list, too. That _is_ necessary for the # program to finish before you grow old and die. the_dict_list = [[k, dict_hash_table[k]] for k in dict_hash_table.keys () if (subtract_bags (the_phrase, k))] # Note that sorting entries "alphabetically" only makes partial sense,
def snarf_dictionary(fn): try: fh = open(hash_cache, "rb") rv = cPickle.load(fh) print "Reading cache", hash_cache, "instead of dictionary", fn except: fh = open(fn, "r") rv = snarf_dictionary_from_IO(fh) fh.close() fh = open(hash_cache, "wb") cPickle.dump(rv, fh, 2) fh.close() return rv fake_input = "cat\ntac\nfred\n" fake_dict = snarf_dictionary_from_IO(StringIO.StringIO(fake_input)) assert 2 == len(fake_dict.keys()) cat_hits = fake_dict[bag("cat")] assert 2 == len(cat_hits) assert cat_hits[0] == "cat" assert cat_hits[1] == "tac" assert 1 == len(fake_dict[bag("fred")]) assert fake_dict[bag("fred")][0] == "fred" print __name__, "tests passed."
action="store", type="string", dest="dict_fn", default="../words.utf8", metavar="FILE", help="location of word list") (options, args) = parser.parse_args() if (0 == len(args)): parser.print_help() sys.exit(0) dict_hash_table = snarf_dictionary(options.dict_fn) the_phrase = bag(args[0]) print "Pruning dictionary. Before:", len( dict_hash_table.keys()), "bags ...", # Now convert the hash table to a list, longest entries first. (This # isn't necessary, but it makes the more interesting anagrams appear # first.) # While we're at it, prune the list, too. That _is_ necessary for the # program to finish before you grow old and die. the_dict_list = [[k, dict_hash_table[k]] for k in dict_hash_table.keys() if (subtract_bags(the_phrase, k))] the_dict_list.sort(biggest_first_then_alphabetically)
def __init__(self, name): self.name=name self.startCash=2000 self.startBagCapacity=80 self.startDebt=0 self.playersBag=bag.bag(self.name + "'s Bag ", self.startBagCapacity)
hash_cache = "hash.cache" def snarf_dictionary (fn): try: fh = open (hash_cache, "rb") rv= cPickle.load (fh) print "Reading cache", hash_cache, "instead of dictionary", fn except: fh = open (fn, "r") rv = snarf_dictionary_from_IO (fh) fh.close () fh = open (hash_cache, "wb") cPickle.dump (rv, fh, 2) fh.close () return rv fake_input = "cat\ntac\nfred\n" fake_dict = snarf_dictionary_from_IO (StringIO.StringIO (fake_input)) assert (2 == len (fake_dict.keys ())) cat_hits = fake_dict[bag ("cat")] assert (2 == len (cat_hits)) assert (cat_hits[0] == "cat") assert (cat_hits[1] == "tac") assert (1 == len (fake_dict[bag ("fred")])) assert (fake_dict[bag ("fred")][0] == "fred") print __name__, "tests passed."