我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用random.choices()。
def check_predict(): Best = namedtuple("Best", ["U", "values", "min_value"]) values = [((0, 0), 0) for _ in range(N_TOP_PER_CHUNK)] bests = [] bests.append(Best(U_sinh, list(values), 0)) bests.append(Best(U_rr, list(values), 0)) user_indices = random.choices(range(len(users)), k=N_PER_CHUNK) repo_indices = random.choices(range(len(repos)), k=N_PER_CHUNK) for index in range(N_PER_CHUNK): pos = (user_indices[index], repo_indices[index]) if pos in nonzero_positions: # Link already exists. continue for i in range(len(bests)): new = bests[i].U[pos[0], :] @ V[:, pos[1]] if new > bests[i].min_value: bests[i].values.append((pos, new)) bests[i].values.sort(key=lambda p: p[1], reverse=True) bests[i].values.pop() bests[i] = bests[i]._replace(min_value=bests[i].values[-1][1]) for i in range(len(bests)): assert len(bests[i].values) == N_TOP_PER_CHUNK return bests[0].values, bests[1].values
def _random_depths(self): # Pick a random depth middle = (self._max_depth // 2) + 1 weight = self._max_depth + 1 population = range(weight) cum_weights = list() cumulative = 0.8 for d in population: # first value 0 (zero) will start with default weight if d <= middle: cumulative += d cum_weights.append(cumulative) else: cumulative += weight - d cum_weights.append(cumulative) return choices(population, cum_weights=cum_weights, k=self.total_items)
def test_wildcard_dns_record(self): global wildcard_dns_record ip_dic = {} genrandstr = lambda i: ''.join(random.choices(string.ascii_lowercase + string.digits, k=i)) tasks = [asyncio.ensure_future(self.resolver.query(genrandstr(20) + '.' + self.domain, 'A')) for _ in range(6)] reqs = asyncio.gather(*tasks) result = self.loop.run_until_complete(reqs) for r in result: if ip_dic.get(r.ip[0]): ip_dic[r.ip[0]] += 1 if ip_dic[r.ip[0]] > 3: wildcard_dns_record = r.ip[0] print(f'[*] Found wildcard dns record:{wildcard_dns_record}') return else: ip_dic[r.ip[0]] = 1
def run(self): import random import string # Create a dir contains suplat files working_path = os.getcwd() suplat_dir = os.path.join(working_path, 'SUPLAT_{:}'.format(self.comment)) if not os.path.exists(suplat_dir): os.makedirs(suplat_dir) else: shutil.rmtree(suplat_dir) os.makedirs(suplat_dir) for hnf in self.hnfs: rd_suffix = ''.join(random.choices(string.ascii_uppercase + string.digits, k=4)) sl_origin = hnf.to_general_cell() sl = sl_origin.get_shaped_cell() out = GeneralIO(sl) ofname = "SUPLAT_{:}_{:}.{:}".format(self.v, rd_suffix, self.outmode) lastpath = os.path.join(suplat_dir, ofname) out.write_file(lastpath)
def issue_key(): # issue api token run = True while run: # issue key key = "".join( random.choices( string.ascii_letters + string.digits, k=32)) g.user.api_key = key try: db.session.add(g.user) db.session.commit() run = False except IntegrityError: # check for uniqueness continue return g.user.api_key
def create_test_subvoat(self, count=0): api_token = self.get_api_token() for x in range(count): body = ''.join(random.choices(string.ascii_letters, k=100)) title = ''.join(random.choices(string.ascii_letters, k=10)) result = requests.post('%s/create_subvoat' % (self.base_address), {'subvoat_name':'test_%s' % (title[0:5]), 'username':'test_username', 'api_token':api_token, 'body':body, 'title':title}) self.check(result) #return result.json()['result'] # test subvoat. # try to create thread without subvoat. # try to create subvoat that already exists # try to create subvoat with name length out of parameters (see config.json) # try to create subvoat with incorrect api_token # try to create subvoat with fake user
def test_pareto_front_attrs(): amax = 1.0 amin = 0.7 bmax = 1.3 bmin = 1.0 front_fitness = [(1, 1), (0.9, 1.1), (0.8, 1.2), (0.7, 1.3)] models = [Model(a, b) for a, b in front_fitness] models.extend([Model(a + 0.01 * abs(random.random()) + 0.01, b + 0.01 * abs(random.random()) + 0.01) for a, b in random.choices(front_fitness, k=50)]) models = list(filter(lambda m: m.b <= bmax, models)) front = pareto_front(models, "a", "b") for m in front: assert amin <= m.a <= amax assert bmin <= m.b <= bmax
def new_chat_member_event(chat, member): logger.info('New chat member %s joined group', member['first_name']) text = format_text(''' {greet}, {name}! Guruhga xush kelibsiz! Ushbu guruh o'zbek dasturchilari uchun ochilgan bo'lib, bu yerda guruh a'zolar bir-birlari bilan tajriba almashishlari, savol-javob qilishlari va shu sohadagi foydali narsalar (texnologiyalar, yangiliklar) ni o'zaro ulashishlari maqsad qilingan. {name}, {wish}. {emoticon} ''') greetings = ( 'Assalomu alaykum', 'Salom', 'Guruhimizning yangi a\'zosi', ) greet = random.choice(greetings) wishes = ( 'guruhda faol bo\'lasiz degan umiddaman', 'ishlaringizga omad', 'yana bir bor hush kelibsiz', ) wish = random.choices(wishes) emoticons = ( '??', '??', '??', '??', '??', '??' ) emoticon = random.choice(emoticons) if not await user_exists(chat.bot.pg_pool, member): await insert_user(chat.bot.pg_pool, member) await chat.send_text( text.format(name=member['first_name'], greet=greet, wish=wish, emoticon=emoticon))
def softmax_policy(self): action = choices(list(range(self.action_size)), weights=self.softmax)[0] return action # actor
def softmax_policy(self): action = choices(list(range(self.action_size)), weights=self.softmax)[0] return action
def randstring(n=1, source=None): """Generate a random string of length 'n' from 'source'.""" if not source: source = string.ascii_letters + string.digits if n <= 0: raise ValueError("Length of sequence must be greater than 0.", n) return ''.join(random.choices(source, k=n))
def generate_session_id(): return ''.join([random.choices(string.digits + string.ascii_letters)[0] for x in range(32)])
def check_predict(_): print("#", end="") sys.stdout.flush() max_b = 0 user_indices = random.choices(range(len(users)), k=N_PER_CHUNK) repo_indices = random.choices(range(len(repos)), k=N_PER_CHUNK) for index in range(N_PER_CHUNK): if B[user_indices[index], repo_indices[index]] == 1.0: # Link already exists. continue new_b = U[user_indices[index], :] @ V[:, repo_indices[index]] if new_b > max_b: max_b = new_b user_id = users[user_indices[index]] repo_id = repos[repo_indices[index]] best_pred = (user_id, user_id2name[user_id], repo_id, repo_id2name[repo_id], new_b) # print(best_pred) return best_pred
def get_records_for_test_db(src_db_path, num_rec): with sqlite3.connect(str(src_db_path)) as src_conn: src_conn.row_factory = sqlite3.Row query_yield = src_conn.execute('''SELECT * FROM moz_places''') # all_records = [DBRecord(record) for record in enumerate(query_yield)] all_records = query_yield.fetchall() chosen_records = random.choices(all_records, k=num_rec) chosen_records = [DBRecord(*record) for record in chosen_records] return chosen_records
def random_dataframe(): """Generates a DataFrame with five random walk columns and a tag column""" arr = np.cumsum(np.random.randn(50, 5), axis=1) letters = itertools.combinations(string.ascii_uppercase, 3) columns = [''.join(triplet) for triplet in random.choices(list(letters), k=5)] tags = [chr(i + 65) for i in np.random.randint(0, 5, 50)] ix = pd.date_range(end=pd.Timestamp.utcnow(), periods=50, freq='90min') df = pd.DataFrame(arr, columns=columns) df['tag'] = tags df.index = ix return df
def random_string(): return ''.join(random.choices(string.ascii_lowercase, k=random.randint(4, 10)))
def _gen_rand_str(size, chars=string.ascii_lowercase + string.digits): return ''.join(choices(chars, k=size))
def choice(self, ctx, *choices): """Picks randomly from the choices provided.""" await ctx.send(random.choice(choices))
def choices(self, ctx, qty : int, *choices): """Picks `{qty}` times from the choices provided, with replacement.""" await ctx.send(', '.join(random.choices(choices, k=qty)))
def sample(self, ctx, qty : int, *choices): """Picks `{qty}` times from the choices provided, without replacement.""" count, remainder = divmod(qty, len(choices)) # Number of times through the choices, and number of choices afterward results = [] for _ in range(count): results.extend(random.sample(choices, k=len(choices))) if remainder: results.extend(random.sample(choices, k=remainder)) await ctx.send(', '.join(results))
def choices(population, weights=None, k=1): """ Replacement for `random.choices()`, which is only available in Python 3.6+. TODO: drop once Python 3.6 is required by the sdk. """ if weights and sum(weights) != 1: # Normalize the weights if needed, as numpy.random.choice requires so. weights = [float(i)/sum(weights) for i in weights] return numpy.random.choice(population, size=k, p=weights)
def random_string(length=10, lower=True, upper=False, digits=False): pool = '' if lower: pool += string.ascii_lowercase if upper: pool += string.ascii_uppercase if digits: pool += string.digits return ''.join(random.choices(pool, k=length))
def pick(elem, counters): weights = [(elem in v) * 0.5 + 0.5 for v in counters.values()] return random.choices(list(counters), weights)[0]
def _default_flip(self, ctx): """Flip called with no arguments""" side = random.choices(SIDES, WEIGHTS)[0] file = discord.File(f'data/images/coins/{side}.png', 'coin.png') embed = (discord.Embed(colour=ctx.bot.colour, description=f'...flipped **{side}**') .set_author(name=ctx.author.display_name, icon_url=ctx.author.avatar_url) .set_image(url='attachment://coin.png') ) await ctx.send(file=file, embed=embed)
def _flip_image(self, num_sides): images = { Side.heads: self._heads_image, Side.tails: self._tails_image, } stats = collections.Counter() root = num_sides ** 0.5 height, width = round(root), int(math.ceil(root)) sides = (random.choices(SIDES, WEIGHTS)[0] for _ in range(num_sides)) size = self.image_size image = Image.new('RGBA', (width * size, height * size)) for i, side in enumerate(sides): y, x = divmod(i, width) image.paste(images[side], (x * size, y * size)) stats[side] += 1 message = ' and '.join(pluralize(**{str(side)[:-1]: n}) for side, n in stats.items()) f = io.BytesIO() image.save(f, 'png') f.seek(0) return message, discord.File(f, filename='flipcoins.png')
def add_mod(): # adds a user to the list of moderators username = request.form["username"] user = User.query.filter(func.lower(User.username) == func.lower(username)).first() if not user: return bad_request("user not found") user.form_mod = True run = True while run: # issue key key = "".join( random.choices( string.ascii_letters + string.digits, k=32)) user.api_key = key try: db.session.add(user) db.session.commit() run = False except IntegrityError: # check for uniqueness continue db.session.add(user) db.session.commit() url = url_for('settings', _external=True) subj = f"invitation to moderate {g.settings.site_title}" body = f"**gadzooks!** u/{g.user.username} has added you as a moderator of {g.settings.site_title}" body += f"\n\nclick [here]({url}) to view the site. mod tools will be visible at the top of the page." send_message(username, subj, body) return jsonify(status="OK"), 200
def username_from_repo(self, repo): """Generate a username for a git repo url e.g. minrk-binder-example-abc123 from https://github.com/minrk/binder-example.git """ # start with url path print if '://' not in repo and _ssh_repo_pat.match(repo): # ssh url path = repo.split(':', 1)[1] else: path = urlparse(repo).path prefix = path.strip('/').replace('/', '-').lower() if prefix.endswith('.git'): # strip trailing .git prefix = prefix[:-4] if len(prefix) > 32: # if it's long, truncate prefix = '{}-{}'.format(prefix[:15], prefix[-15:]) # add a random suffix to avoid collisions for users on the same image return '{}-{}'.format(prefix, ''.join(random.choices(SUFFIX_CHARS, k=SUFFIX_LENGTH)))
def expectation_tv(self, data_list): N, F = read_data(data_list, self.nmix, self.ndim) nfiles = F.shape[0] nframes = N.sum() LU = np.zeros((self.nmix, self.tv_dim * (self.tv_dim + 1) // 2)) RU = np.zeros((self.tv_dim, self.nmix * self.ndim)) LLK = 0. T_invS = self.Tm / self.Sigma T_iS_Tt = self.comp_T_invS_Tt() parts = 2500 # modify this based on your HW resources (e.g., memory) nbatch = int(nfiles / parts + 0.99999) for batch in range(nbatch): start = batch * parts fin = min((batch + 1) * parts, nfiles) length = fin - start N1 = N[start:fin] F1 = F[start:fin] L1 = N1.dot(T_iS_Tt) B1 = F1.dot(T_invS.T) Ex = np.empty((length, self.tv_dim)) Exx = np.empty((length, self.tv_dim * (self.tv_dim + 1) // 2)) llk = np.zeros((length, 1)) for ix in range(length): L = np.zeros((self.tv_dim, self.tv_dim)) L[self.itril] = L1[ix] L += np.tril(L, -1).T + self.Im Cxx = inv(L) B = B1[ix][:, np.newaxis] this_Ex = Cxx.dot(B) llk[ix] = self.res_llk(this_Ex, B) Ex[ix] = this_Ex.T Exx[ix] = (Cxx + this_Ex.dot(this_Ex.T))[self.itril] RU += Ex.T.dot(F1) LU += N1.T.dot(Exx) LLK += llk.sum() self.Tm = None tmp_string = ''.join(random.choices(string.ascii_uppercase + string.digits, k=16)) tmpfile = self.tmpdir + 'tmat_' + tmp_string + '.h5' h5write(tmpfile, LU, 'LU') return RU, LLK, nframes
def id3_version(self): return random.choices( [v for v, _ in self.VERSION_WEIGHTS], cum_weights=[w for _, w in self.VERSION_WEIGHTS])[0]
def id3_date(self): d = self._fake.date_object() full_date = random.choices(["y", "n"], cum_weights=[15, 85]) == "y" return Date(year=d.year, month=d.month if full_date else None, day=d.day if full_date else None)
def categories(self, create, extracted, **kwargs): categories = models.Category.objects.all() for category in random.choices(categories, k=random.randint(1, len(categories))): self.categories.add(category)
def random_user_name(): return ''.join(random.choices(string.ascii_uppercase + string.digits, k=8))
def get_record_crystal(scout: Scout, seed: int=None) -> int: record_crystal = 0 if scout.record_crystal: cases: List[int] = [] chances: List[float] = [] random.seed(seed) for case, chance in scout.record_crystal: cases.append(case) chances.append(chance) record_crystal = random.choices(cases, chances)[0] random.seed(None) return record_crystal
def test_new_subvoat_creation(): api_token = get_api_token() result = requests.post('%s/create_subvoat' % (base_address), {'username':'test_username', 'api_token':api_token, 'subvoat_name':'test_%s' % (''.join(random.choices(string.ascii_letters, k=10)))}) print(result.json()) # Try to create the same subvoat that already exists
def test_posting(): api_token = get_api_token() body = ''.join(random.choices(string.ascii_letters, k=100)) title = ''.join(random.choices(string.ascii_letters, k=10)) print(requests.post('%s/submit_thread' % (base_address), {'username':'test_username', 'api_token':api_token, 'subvoat_name':'test_exists', 'title':title, 'body':body}).json())
def test_posting_comment(): api_token = get_api_token() body = ''.join(random.choices(string.ascii_letters, k=100)) data = requests.post('%s/get_threads' % (base_address), {'subvoat_name':'test_exists'}).json() thread_uuid = data['result'][0]['uuid'] print(requests.post('%s/submit_comment' % (base_address), {'thread_uuid':thread_uuid, 'username':'test_username', 'api_token':api_token, 'body':body}).text)
def generate_threads(self, count): api_token = self.get_api_token() for x in range(count): title = ''.join(random.choices(string.ascii_letters, k=10)) body = ''.join(random.choices(string.ascii_letters, k=100)) result = requests.post('%s/submit_thread' % (self.base_address), {'username':'test_username', 'api_token':api_token, 'subvoat_name':'test_exists', 'title':title, 'body':body}).json()
def choices(l, k): for _ in range(k): yield random.choice(l)
def rand_string(min_length, max_length, corpus=ALL): return ''.join(random.choices(corpus, k=random.randrange(min_length, max_length)))
def numberwang(): return random.choices(STRINGS, weights=WEIGHTS)
def shout(message): parts = message.split('.') out = '' for part in parts: out += part.upper() + ''.join(random.choices(['!', '1'], weights=[5, 1], k=random.randint(2, 8))) return out
def pick_n_random_parents(population, n_parents=2): return choices(population, k=n_parents)
def test_breed_amount_works(self): pop1 = Population(chromosomes=self.chromosomes, eval_function=self.eval_func) pop1.survive(n=50).breed(parent_picker=lambda population: choices(population, k=2), combiner=lambda mom, dad: (mom + dad) / 2) assert len(pop1) == 200 pop2 = Population(chromosomes=self.chromosomes, eval_function=self.eval_func) pop2.survive(n=50).breed(parent_picker=lambda population: choices(population, k=2), combiner=lambda mom, dad: (mom + dad) / 2, population_size=400) assert len(pop2) == 400 assert pop2.intended_size == 400
def survive(self, fraction=None, n=None, luck=False) -> 'Population': """Let part of the population survive. Remove part of the population. If both fraction and n are specified, the minimum resulting population size is taken. :param fraction: Fraction of the original population that survives. Defaults to None. :type fraction: float/None :param n: Number of individuals of the population that survive. Defaults to None. :type n: int/None :param luck: If True, individuals randomly survive (with replacement!) with chances proportional to their fitness. Defaults to False. :type luck: bool :return: self """ if fraction is None: if n is None: raise ValueError('everyone survives! must provide either "fraction" and/or "n".') resulting_size = n elif n is None: resulting_size = round(fraction*len(self.individuals)) else: resulting_size = min(round(fraction*len(self.individuals)), n) self.evaluate(lazy=True) if resulting_size == 0: raise RuntimeError('no one survived!') if resulting_size > len(self.individuals): raise ValueError('everyone survives! must provide "fraction" and/or "n" < population size') if luck: self.individuals = choices(self.individuals, k=resulting_size, weights=[individual.fitness for individual in self.individuals]) else: sorted_individuals = sorted(self.individuals, key=lambda x: x.fitness, reverse=self.maximize) self.individuals = sorted_individuals[:resulting_size] return self
def random_string(n): return ''.join(random.choices(string.ascii_uppercase + string.ascii_lowercase + string.digits, k=n))
def run(self): # Create directory contain POSCARs import random import string import tempfile rd_suffix = ''.join(random.choices(string.ascii_uppercase + string.digits, k=5)) working_path = os.getcwd() poscars_dir = os.path.join(working_path, 'STRUCTURES_{0:}_{1:}'.format(self.comment, rd_suffix)) if not os.path.exists(poscars_dir): os.makedirs(poscars_dir) else: shutil.rmtree(poscars_dir) os.makedirs(poscars_dir) ogg = OccupyGenerator(self.cell) g = ogg.gen_nodup_trinary_alloy(Specie(self.s1), self.n1, Specie(self.s2), self.n2) if self.tr is not None: tr = (Specie(self.tr[0]), self.tr[1]) applied_restriction = MinDistanceRestriction(tr) # For diff outmode if self.outmode == 'vasp': Output = VaspPOSCAR prefix = 'POSCAR_A{:}B{:}C{:}_' suffix = '.vasp' else: Output = YamlOutput prefix = 'STRUCTURE_A{:}B{:}C{:}_' suffix = '.yaml' for n_count, c in enumerate(g): if self.mpr: if self.tr is not None: condition = c.is_primitive() and applied_restriction.is_satisfied(c) else: condition = c.is_primitive() else: if self.tr is not None: condition = applied_restriction.is_satisfied(c) else: condition = True if condition: if self.refined: c = c.get_refined_pcell() poscar = Output(c, 1) tf = tempfile.NamedTemporaryFile(mode='w+b', dir=poscars_dir, prefix=prefix.format(self.n0, self.n1, self.n2), suffix=suffix, delete=False) poscar.write(tf.name)
def run(self): # Create directory contain POSCARs import random import string rd_suffix = ''.join(random.choices(string.ascii_uppercase + string.digits, k=5)) working_path = os.getcwd() out_dir = os.path.join(working_path, 'STRUCTURES_{0:}_{1:}'.format(self.comment, rd_suffix)) if not os.path.exists(out_dir): os.makedirs(out_dir) else: shutil.rmtree(out_dir) os.makedirs(out_dir) ogg = OccupyGenerator(self.cell) g = ogg.gen_nodup_exch(Specie(self.exch1), Specie(self.exch2), self.n) if self.tr is not None: tr = (Specie(self.tr[0]), self.tr[1]) applied_restriction = MinDistanceRestriction(tr) for n_count, c in enumerate(g): if self.mpr: if self.tr is not None: condition = c.is_primitive() and applied_restriction.is_satisfied(c) else: condition = c.is_primitive() else: if self.tr is not None: condition = applied_restriction.is_satisfied(c) else: condition = True if condition: if self.refined: c = c.get_refined_pcell() out = GeneralIO(c) f_suffix = ''.join(random.choices(string.ascii_uppercase + string.digits, k=4)) ofname = "STRUCTURE_{:}_{:}.{:}".format(c.comment, f_suffix, self.outmode) lastpath = os.path.join(out_dir, ofname) out.write_file(lastpath)
def run(self): # Create directory contain POSCARs import random import string rd_suffix = ''.join(random.choices(string.ascii_uppercase + string.digits, k=5)) working_path = os.getcwd() out_dir = os.path.join(working_path, 'STRUCTURES_{0:}_{1:}'.format(self.comment, rd_suffix)) if not os.path.exists(out_dir): os.makedirs(out_dir) else: shutil.rmtree(out_dir) os.makedirs(out_dir) ogg = OccupyGenerator(self.cell) g = ogg.gen_nodup_of_ele(self.ele, self.n, self.speckle) # sym for getting degeneracy sym_perm = self.cell.get_symmetry_permutation() if self.tr is not None: tr = (Specie(self.tr[0]), self.tr[1]) applied_restriction = MinDistanceRestriction(tr) for n_count, c in enumerate(g): if self.mpr: if self.tr is not None: condition = c.is_primitive() and applied_restriction.is_satisfied(c) else: condition = c.is_primitive() else: if self.tr is not None: condition = applied_restriction.is_satisfied(c) else: condition = True if condition: if self.refined: c = c.get_refined_pcell() out = GeneralIO(c) f_suffix = ''.join(random.choices(string.ascii_uppercase + string.digits, k=4)) ofname = "STRUCTURE_{:}_D{:}D_{:}.{:}".format(c.comment, c.get_degeneracy(sym_perm), f_suffix, self.outmode) lastpath = os.path.join(out_dir, ofname) out.write_file(lastpath)
def run(self): # Create directory contain POSCARs import random import string rd_suffix = ''.join(random.choices(string.ascii_uppercase + string.digits, k=5)) working_path = os.getcwd() out_dir = os.path.join(working_path, 'STRUCTURES_{0:}_{1:}'.format(self.comment, rd_suffix)) if not os.path.exists(out_dir): os.makedirs(out_dir) else: shutil.rmtree(out_dir) os.makedirs(out_dir) ogg = OccupyGenerator(self.cell) if self.tr is not None: tr = (Specie(self.tr[0]), self.tr[1]) applied_restriction = MinDistanceRestriction(tr) for n1 in range(1, self.n - 1): for n2 in range(1, self.n - n1): g = ogg.gen_nodup_trinary_alloy(Specie(self.s1), n1, Specie(self.s2), n2) for n_count, c in enumerate(g): if self.tr is not None: condition = c.is_primitive() and applied_restriction.is_satisfied(c) else: condition = c.is_primitive() if condition: if self.refined: c = c.get_refined_pcell() out = GeneralIO(c) f_suffix = ''.join(random.choices(string.ascii_uppercase + string.digits, k=4)) ofname = "STRUCTURE_{:}_{:}.{:}".format(c.comment, f_suffix, self.outmode) lastpath = os.path.join(out_dir, ofname) out.write_file(lastpath)
